commit f2fe6b88555fd45b90aea343e8536eca74d5a3cb
Author: Acrux Development <acruxstudios.dev@gmail.com>
Date:   Sat Oct 24 09:53:48 2026 -0300

    Add project files

diff --git a/.clang-format b/.clang-format
new file mode 100644
index 0000000..541defa
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,117 @@
+---
+# .clang-format
+# Enforces the formatting rules from the C/C++ Coding Style Guide (Part I: C++ Style).
+# Applies equally to Part II C API files per §15 (Indentation and Braces) — same
+# tabs/Allman/line-length rules, just different naming (naming can't be enforced
+# by clang-format; see .clang-tidy).
+Language: Cpp
+Standard: Latest
+
+# --- Indentation (style guide §2) ---
+UseTab: Always
+TabWidth: 4
+IndentWidth: 4
+ContinuationIndentWidth: 4
+IndentCaseLabels: true
+IndentPPDirectives: None
+IndentExternBlock: Indent
+
+# Access specifiers (public:/private:) sit unindented, flush with the class
+# keyword — only members are indented one level, matching every example in §1/§6.
+AccessModifierOffset: -4
+
+# Namespace bodies are indented like any other block (style guide §Namespaces).
+NamespaceIndentation: All
+
+# --- Braces: Allman style everywhere (style guide §3) ---
+BreakBeforeBraces: Allman
+Cpp11BracedListStyle: true
+# InlineOnly (not Empty or None): out-of-class function definitions always
+# get full Allman expansion regardless of length, same as before -- this
+# only additionally allows a function *defined inside a class body* to
+# stay a compact one-liner if it's short enough to fit. That's specifically
+# for the trivial-one-liner exception to "avoid inline member definitions"
+# in Class Member Organization (style guide §6) -- a plain getter like
+# `int getValue() const { return m_value; }` stays inline-and-compact;
+# anything defined out-of-class still always gets the full brace expansion.
+AllowShortFunctionsOnASingleLine: InlineOnly
+AllowShortIfStatementsOnASingleLine: Never
+AllowShortLoopsOnASingleLine: false
+AllowShortBlocksOnASingleLine: Never
+AllowShortEnumsOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: false
+
+# No trailing "// namespace X" / "// class X" comments on closing braces
+# (style guide §Namespaces / §6).
+FixNamespaceComments: false
+
+# --- Pointers and references attach to the type (style guide §4) ---
+PointerAlignment: Left
+ReferenceAlignment: Pointer
+DerivePointerAlignment: false
+
+# --- Line length (style guide §8) ---
+ColumnLimit: 100
+
+# --- Spacing (style guide §5) ---
+SpaceBeforeParens: ControlStatements
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+SpaceAfterCStyleCast: false
+SpaceBeforeAssignmentOperators: true
+SpacesInAngles: false
+
+# --- Include ordering (style guide §7: main header, C headers, C++ std,
+# third-party, project headers) ---
+SortIncludes: true
+SortUsingDeclarations: true
+IncludeBlocks: Regroup
+IncludeIsMainRegex: '(Test)?$'
+IncludeCategories:
+  # 1. Corresponding header is auto-detected and always sorted first.
+  # 2. C system headers wrapped for C++ (<cstdio>, <cstdint>, ...).
+  - Regex: '^<(cassert|cctype|cerrno|cfenv|cfloat|cinttypes|climits|clocale|cmath|csetjmp|csignal|cstdarg|cstddef|cstdint|cstdio|cstdlib|cstring|ctime|cuchar|cwchar|cwctype)>$'
+    Priority: 1
+    CaseSensitive: true
+  # 3. C++ standard library headers (no dot, no slash — <vector>, <memory>, ...).
+  - Regex: '^<[a-z_]+>$'
+    Priority: 2
+    CaseSensitive: true
+  # 4. Third-party / external library headers (<fmt/format.h>, <boost/...>, ...).
+  - Regex: '^<.*>$'
+    Priority: 3
+    CaseSensitive: true
+  # 5. Project headers, quoted ("NetworkManager.hpp", ...).
+  - Regex: '^".*"$'
+    Priority: 4
+    CaseSensitive: true
+
+# --- Misc ---
+AlignTrailingComments: true
+AlignConsecutiveAssignments: false
+AlignConsecutiveDeclarations: false
+
+# Parameters/arguments: never one-per-line (style guide §8). When a
+# signature/call doesn't fit on one line, keep everything together on a
+# single continuation line if it fits there (AllowAll...OnNextLine), and
+# fall back to packing multiple per line (BinPack...) rather than ever
+# breaking to one per line. This can't force a genuinely long signature
+# to fit within ColumnLimit without wrapping at all -- doing that would
+# require ColumnLimit: 0 project-wide, which would also stop comments and
+# ordinary expressions from ever wrapping. See §8 for the full rule.
+#
+# COMPATIBILITY NOTE: clang-format 20 changed BinPackParameters (and the
+# equivalent for call arguments) from a boolean to an enum, and later
+# versions deprecated it again in favor of a nested PackParameters/
+# PackArguments option. The boolean form below is correct for clang-format
+# through 19 (still the most common version in practice, e.g. Ubuntu
+# 24.04 LTS ships 18). On clang-format 20 or newer, replace `true` with
+# `BinPack` on both lines if you find these are being silently ignored.
+BinPackArguments: true
+BinPackParameters: true
+AllowAllArgumentsOnNextLine: true
+AllowAllParametersOfDeclarationOnNextLine: true
+
+BreakConstructorInitializers: BeforeColon
+ConstructorInitializerIndentWidth: 4
+PenaltyReturnTypeOnItsOwnLine: 1000
diff --git a/.clang-tidy b/.clang-tidy
new file mode 100644
index 0000000..87e69b8
--- /dev/null
+++ b/.clang-tidy
@@ -0,0 +1,161 @@
+---
+# .clang-tidy
+# Enforces naming conventions (style guide §1) and a subset of the Language
+# Feature Do's and Don'ts (style guide §10) for C++ code. Place at the repo
+# root for Part I (C++) files. For Part II (C API) files, use the
+# directory-scoped override in c-api/.clang-tidy instead — clang-tidy picks
+# the closest .clang-tidy file up the directory tree, so nesting one there
+# gives that subtree different naming rules without affecting the rest of
+# the project.
+#
+# readability-redundant-inline-specifier is a narrow, complementary aid for
+# the "avoid inline member definitions" rule in §6 (Class Member
+# Organization): it only catches an explicit `inline` keyword that's
+# already redundant (e.g. on a function defined in the class body, which
+# is implicitly inline regardless). It does not catch — and nothing in
+# this file catches — an inline definition that omits the keyword
+# entirely, which is the actual, common case the style guide rule is
+# about; that one stays a code-review judgment call.
+Checks: >
+  -*,
+  readability-identifier-naming,
+  readability-redundant-inline-specifier,
+  modernize-use-nullptr,
+  modernize-use-override,
+  modernize-use-equals-default,
+  modernize-use-equals-delete,
+  modernize-loop-convert,
+  modernize-concat-nested-namespaces,
+  modernize-use-default-member-init,
+  modernize-avoid-c-arrays,
+  modernize-use-nodiscard,
+  cppcoreguidelines-special-member-functions,
+  cppcoreguidelines-owning-memory,
+  cppcoreguidelines-no-malloc,
+  cppcoreguidelines-pro-type-member-init,
+  cppcoreguidelines-pro-type-cstyle-cast,
+  cppcoreguidelines-macro-usage,
+  performance-unnecessary-value-param,
+  performance-unnecessary-copy-initialization,
+  bugprone-exception-escape,
+  bugprone-use-after-move
+
+WarningsAsErrors: ''
+HeaderFilterRegex: '.*\.hpp$'
+FormatStyle: file
+
+CheckOptions:
+  # --- Naming Conventions — style guide §1 ---
+  - key: readability-identifier-naming.NamespaceCase
+    value: lower_case
+
+  - key: readability-identifier-naming.ClassCase
+    value: CamelCase
+  - key: readability-identifier-naming.StructCase
+    value: CamelCase
+  - key: readability-identifier-naming.EnumCase
+    value: CamelCase
+  - key: readability-identifier-naming.EnumConstantCase
+    value: CamelCase
+
+  - key: readability-identifier-naming.FunctionCase
+    value: camelBack
+  - key: readability-identifier-naming.MethodCase
+    value: camelBack
+
+  - key: readability-identifier-naming.VariableCase
+    value: camelBack
+  - key: readability-identifier-naming.LocalVariableCase
+    value: camelBack
+  - key: readability-identifier-naming.ParameterCase
+    value: camelBack
+
+  # A plain local `const` (not `static`, not `constexpr`) stays under the
+  # Local Variables rule (camelCase) per the style guide's own note that
+  # only *global/static* const/constexpr values are "constants" for this
+  # rule's purposes -- without this, it silently inherits the general
+  # ConstantCase (PascalCase) fallback below instead, which would flag
+  # totally ordinary code like `const std::string name = ...;` inside a
+  # function. StaticConstantCase/GlobalConstantCase/ConstexprVariableCase
+  # below are unaffected and still require PascalCase, matching the guide.
+  - key: readability-identifier-naming.LocalConstantCase
+    value: camelBack
+
+  # Private/protected member variables: camelCase with an m_ prefix.
+  - key: readability-identifier-naming.PrivateMemberCase
+    value: camelBack
+  - key: readability-identifier-naming.PrivateMemberPrefix
+    value: m_
+  - key: readability-identifier-naming.ProtectedMemberCase
+    value: camelBack
+  - key: readability-identifier-naming.ProtectedMemberPrefix
+    value: m_
+  # Public members (e.g. plain data structs) — camelCase, no prefix.
+  - key: readability-identifier-naming.PublicMemberCase
+    value: camelBack
+
+  # Static class data members — camelCase with an s_ prefix (distinct from
+  # instance members above). "ClassMember" is clang-tidy's category for
+  # static (non-const) data members specifically.
+  - key: readability-identifier-naming.ClassMemberCase
+    value: camelBack
+  - key: readability-identifier-naming.ClassMemberPrefix
+    value: s_
+
+  # Global (namespace/file-scope, mutable) variables — camelCase with a g_
+  # prefix, to flag genuinely global mutable state at every use site.
+  - key: readability-identifier-naming.GlobalVariableCase
+    value: camelBack
+  - key: readability-identifier-naming.GlobalVariablePrefix
+    value: g_
+
+  # Static variables — function-local `static` or file-scope `static` —
+  # camelCase with an s_ prefix, for the same reason as globals above.
+  - key: readability-identifier-naming.StaticVariableCase
+    value: camelBack
+  - key: readability-identifier-naming.StaticVariablePrefix
+    value: s_
+
+  # Constants and enum values — PascalCase (style guide §1 table).
+  - key: readability-identifier-naming.ConstantCase
+    value: CamelCase
+  - key: readability-identifier-naming.GlobalConstantCase
+    value: CamelCase
+  - key: readability-identifier-naming.StaticConstantCase
+    value: CamelCase
+  - key: readability-identifier-naming.ClassConstantCase
+    value: CamelCase
+  - key: readability-identifier-naming.ConstexprVariableCase
+    value: CamelCase
+
+  # Template parameters — PascalCase (e.g. ValueType).
+  - key: readability-identifier-naming.TemplateParameterCase
+    value: CamelCase
+  - key: readability-identifier-naming.TypeTemplateParameterCase
+    value: CamelCase
+
+  # Type aliases / typedefs — PascalCase, matching class naming.
+  - key: readability-identifier-naming.TypeAliasCase
+    value: CamelCase
+  - key: readability-identifier-naming.TypedefCase
+    value: CamelCase
+
+  # Macros — ALL_CAPS_SNAKE_CASE (the one deliberate exception in §1).
+  - key: readability-identifier-naming.MacroDefinitionCase
+    value: UPPER_CASE
+
+  # --- cppcoreguidelines-owning-memory — style guide §10, Memory and Ownership ---
+  # Flags raw new/delete and legacy C allocators used for ownership instead of
+  # std::unique_ptr / std::shared_ptr.
+  - key: cppcoreguidelines-owning-memory.LegacyResourceProducers
+    value: 'malloc;calloc;realloc;strdup;strndup'
+  - key: cppcoreguidelines-owning-memory.LegacyResourceConsumers
+    value: 'free;realloc'
+
+  # --- cppcoreguidelines-macro-usage — style guide §10, prefer constexpr over #define ---
+  # Allow include-guard-style and project-prefixed macros; flag everything else
+  # that could instead be a constexpr constant.
+  - key: cppcoreguidelines-macro-usage.AllowedRegexp
+    value: '^[A-Z0-9_]+_H(PP)?$'
+  - key: cppcoreguidelines-macro-usage.CheckCapsOnly
+    value: false
diff --git a/.editorconfig b/.editorconfig
new file mode 100644
index 0000000..a36a39a
--- /dev/null
+++ b/.editorconfig
@@ -0,0 +1,34 @@
+# .editorconfig
+# Baseline whitespace/indentation rules for editors that don't run
+# clang-format live (or before it runs). See .clang-format for the
+# authoritative, full formatting rules from the style guide.
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+# Windows scripts are CRLF (see .gitattributes). Without this, the global
+# end_of_line = lf above would have editors rewrite them as LF.
+[*.{bat,cmd,ps1}]
+end_of_line = crlf
+
+# Style guide §2 / §15 — tabs everywhere, C++ and C API alike.
+[*.{c,h,cpp,hpp,cc,cxx,tpp}]
+indent_style = tab
+indent_size = 4
+tab_width = 4
+max_line_length = 100
+
+# Config/build files typically use spaces by convention — not covered by the
+# C/C++ style guide, kept here only so this file has a sane fallback for
+# CMakeLists.txt, YAML, etc. in the same repo.
+[*.{yml,yaml,cmake,json}]
+indent_style = space
+indent_size = 2
+
+[CMakeLists.txt]
+indent_style = space
+indent_size = 2
diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 0000000..f53f6af
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1,29 @@
+# .gitattributes
+#
+# Forces LF line endings for source files regardless of OS or each
+# contributor's core.autocrlf setting. Without this, the same file can have
+# CRLF on a Windows checkout and LF on Linux/Mac, which makes clang-format
+# and the pre-commit hook's diff check report false formatting differences
+# that have nothing to do with actual style.
+* text=auto eol=lf
+
+# Be explicit for the style guide's own file types, on top of the general
+# rule above.
+*.c    text eol=lf
+*.h    text eol=lf
+*.cpp  text eol=lf
+*.hpp  text eol=lf
+*.cc   text eol=lf
+*.cxx  text eol=lf
+*.tpp  text eol=lf
+
+# Windows-specific scripts keep CRLF (cmd.exe is fussy about LF-only batch
+# files; PowerShell scripts follow the same convention).
+*.bat  text eol=crlf
+*.cmd  text eol=crlf
+*.ps1  text eol=crlf
+
+# Never touch binaries.
+*.png  binary
+*.jpg  binary
+*.ico  binary
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..de463c9
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,441 @@
+## Ignore Visual Studio temporary files, build results, and
+## files generated by popular Visual Studio add-ons.
+##
+## Get latest from https://github.com/github/gitignore/blob/main/VisualStudio.gitignore
+
+# User-specific files
+*.rsuser
+*.suo
+*.user
+*.userosscache
+*.sln.docstates
+*.env
+
+# User-specific files (MonoDevelop/Xamarin Studio)
+*.userprefs
+
+# Mono auto generated files
+mono_crash.*
+
+# Build results
+[Dd]ebug/
+[Dd]ebugPublic/
+[Rr]elease/
+[Rr]eleases/
+
+[Dd]ebug/x64/
+[Dd]ebugPublic/x64/
+[Rr]elease/x64/
+[Rr]eleases/x64/
+bin/x64/
+obj/x64/
+
+[Dd]ebug/x86/
+[Dd]ebugPublic/x86/
+[Rr]elease/x86/
+[Rr]eleases/x86/
+bin/x86/
+obj/x86/
+
+[Ww][Ii][Nn]32/
+[Aa][Rr][Mm]/
+[Aa][Rr][Mm]64/
+[Aa][Rr][Mm]64[Ee][Cc]/
+bld/
+[Oo]bj/
+[Oo]ut/
+[Ll]og/
+[Ll]ogs/
+
+# Build results on 'Bin' directories
+**/[Bb]in/*
+# Uncomment if you have tasks that rely on *.refresh files to move binaries
+# (https://github.com/github/gitignore/pull/3736)
+#!**/[Bb]in/*.refresh
+
+# Visual Studio 2015/2017 cache/options directory
+.vs/
+# Uncomment if you have tasks that create the project's static files in wwwroot
+#wwwroot/
+
+# Visual Studio 2017 auto generated files
+Generated\ Files/
+
+# MSTest test Results
+[Tt]est[Rr]esult*/
+[Bb]uild[Ll]og.*
+*.trx
+
+# NUnit
+*.VisualState.xml
+TestResult.xml
+nunit-*.xml
+
+# Approval Tests result files
+*.received.*
+
+# Build Results of an ATL Project
+[Dd]ebugPS/
+[Rr]eleasePS/
+dlldata.c
+
+# Benchmark Results
+BenchmarkDotNet.Artifacts/
+
+# .NET Core
+project.lock.json
+project.fragment.lock.json
+artifacts/
+.artifacts/
+
+# ASP.NET Scaffolding
+ScaffoldingReadMe.txt
+
+# StyleCop
+StyleCopReport.xml
+
+# Files built by Visual Studio
+*_i.c
+*_p.c
+*_h.h
+*.ilk
+*.meta
+*.obj
+*.idb
+*.iobj
+*.pch
+*.pdb
+*.ipdb
+*.pgc
+*.pgd
+*.rsp
+# but not Directory.Build.rsp, as it configures directory-level build defaults
+!Directory.Build.rsp
+*.sbr
+*.tlb
+*.tli
+*.tlh
+*.tmp
+*.tmp_proj
+*_wpftmp.csproj
+*.log
+*.tlog
+*.vspscc
+*.vssscc
+.builds
+*.pidb
+*.svclog
+*.scc
+
+# Chutzpah Test files
+_Chutzpah*
+
+# Visual C++ cache files
+ipch/
+*.aps
+*.ncb
+*.opendb
+*.opensdf
+*.sdf
+*.cachefile
+*.VC.db
+*.VC.VC.opendb
+
+# Visual Studio profiler
+*.psess
+*.vsp
+*.vspx
+*.sap
+
+# Visual Studio Trace Files
+*.e2e
+
+# TFS 2012 Local Workspace
+$tf/
+
+# Guidance Automation Toolkit
+*.gpState
+
+# ReSharper is a .NET coding add-in
+_ReSharper*/
+*.[Rr]e[Ss]harper
+*.DotSettings.user
+
+# TeamCity is a build add-in
+_TeamCity*
+
+# DotCover is a Code Coverage Tool
+*.dotCover
+
+# AxoCover is a Code Coverage Tool
+.axoCover/*
+!.axoCover/settings.json
+
+# Coverlet is a free, cross platform Code Coverage Tool
+coverage*.json
+coverage*.xml
+coverage*.info
+
+# Visual Studio code coverage results
+*.coverage
+*.coveragexml
+
+# NCrunch
+_NCrunch_*
+.NCrunch_*
+.*crunch*.local.xml
+nCrunchTemp_*
+
+# MightyMoose
+*.mm.*
+AutoTest.Net/
+
+# Web workbench (sass)
+.sass-cache/
+
+# Installshield output folder
+[Ee]xpress/
+
+# DocProject is a documentation generator add-in
+DocProject/buildhelp/
+DocProject/Help/*.HxT
+DocProject/Help/*.HxC
+DocProject/Help/*.hhc
+DocProject/Help/*.hhk
+DocProject/Help/*.hhp
+DocProject/Help/Html2
+DocProject/Help/html
+
+# Click-Once directory
+publish/
+
+# Publish Web Output
+*.[Pp]ublish.xml
+*.azurePubxml
+# Note: Comment the next line if you want to checkin your web deploy settings,
+# but database connection strings (with potential passwords) will be unencrypted
+*.pubxml
+*.publishproj
+
+# Microsoft Azure Web App publish settings. Comment the next line if you want to
+# checkin your Azure Web App publish settings, but sensitive information contained
+# in these scripts will be unencrypted
+PublishScripts/
+
+# NuGet Packages
+*.nupkg
+# NuGet Symbol Packages
+*.snupkg
+# The packages folder can be ignored because of Package Restore
+**/[Pp]ackages/*
+# except build/, which is used as an MSBuild target.
+!**/[Pp]ackages/build/
+# Uncomment if necessary however generally it will be regenerated when needed
+#!**/[Pp]ackages/repositories.config
+# NuGet v3's project.json files produces more ignorable files
+*.nuget.props
+*.nuget.targets
+
+# Microsoft Azure Build Output
+csx/
+*.build.csdef
+
+# Microsoft Azure Emulator
+ecf/
+rcf/
+
+# Windows Store app package directories and files
+AppPackages/
+BundleArtifacts/
+Package.StoreAssociation.xml
+_pkginfo.txt
+*.appx
+*.appxbundle
+*.appxupload
+
+# Visual Studio cache files
+# files ending in .cache can be ignored
+*.[Cc]ache
+# but keep track of directories ending in .cache
+!?*.[Cc]ache/
+
+# Others
+ClientBin/
+~$*
+*~
+*.dbmdl
+*.dbproj.schemaview
+*.jfm
+*.pfx
+*.publishsettings
+orleans.codegen.cs
+
+# Including strong name files can present a security risk
+# (https://github.com/github/gitignore/pull/2483#issue-259490424)
+#*.snk
+
+# Since there are multiple workflows, uncomment next line to ignore bower_components
+# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
+#bower_components/
+
+# RIA/Silverlight projects
+Generated_Code/
+
+# Backup & report files from converting an old project file
+# to a newer Visual Studio version. Backup files are not needed,
+# because we have git ;-)
+_UpgradeReport_Files/
+Backup*/
+UpgradeLog*.XML
+UpgradeLog*.htm
+ServiceFabricBackup/
+*.rptproj.bak
+
+# SQL Server files
+*.mdf
+*.ldf
+*.ndf
+
+# Business Intelligence projects
+*.rdl.data
+*.bim.layout
+*.bim_*.settings
+*.rptproj.rsuser
+*- [Bb]ackup.rdl
+*- [Bb]ackup ([0-9]).rdl
+*- [Bb]ackup ([0-9][0-9]).rdl
+
+# Microsoft Fakes
+FakesAssemblies/
+
+# GhostDoc plugin setting file
+*.GhostDoc.xml
+
+# Node.js Tools for Visual Studio
+.ntvs_analysis.dat
+node_modules/
+
+# Visual Studio 6 build log
+*.plg
+
+# Visual Studio 6 workspace options file
+*.opt
+
+# Visual Studio 6 auto-generated workspace file (contains which files were open etc.)
+*.vbw
+
+# Visual Studio 6 workspace and project file (working project files containing files to include in project)
+*.dsw
+*.dsp
+
+# Visual Studio 6 technical files
+*.ncb
+*.aps
+
+# Visual Studio LightSwitch build output
+**/*.HTMLClient/GeneratedArtifacts
+**/*.DesktopClient/GeneratedArtifacts
+**/*.DesktopClient/ModelManifest.xml
+**/*.Server/GeneratedArtifacts
+**/*.Server/ModelManifest.xml
+_Pvt_Extensions
+
+# Paket dependency manager
+**/.paket/paket.exe
+paket-files/
+
+# FAKE - F# Make
+**/.fake/
+
+# CodeRush personal settings
+**/.cr/personal
+
+# Python Tools for Visual Studio (PTVS)
+**/__pycache__/
+*.pyc
+
+# Cake - Uncomment if you are using it
+#tools/**
+#!tools/packages.config
+
+# Tabs Studio
+*.tss
+
+# Telerik's JustMock configuration file
+*.jmconfig
+
+# BizTalk build output
+*.btp.cs
+*.btm.cs
+*.odx.cs
+*.xsd.cs
+
+# OpenCover UI analysis results
+OpenCover/
+
+# Azure Stream Analytics local run output
+ASALocalRun/
+
+# MSBuild Binary and Structured Log
+*.binlog
+MSBuild_Logs/
+
+# AWS SAM Build and Temporary Artifacts folder
+.aws-sam
+
+# NVidia Nsight GPU debugger configuration file
+*.nvuser
+
+# MFractors (Xamarin productivity tool) working folder
+**/.mfractor/
+
+# Local History for Visual Studio
+**/.localhistory/
+
+# Visual Studio History (VSHistory) files
+.vshistory/
+
+# BeatPulse healthcheck temp database
+healthchecksdb
+
+# Backup folder for Package Reference Convert tool in Visual Studio 2017
+MigrationBackup/
+
+# Ionide (cross platform F# VS Code tools) working folder
+**/.ionide/
+
+# Fody - auto-generated XML schema
+FodyWeavers.xsd
+
+# VS Code files for those working on multiple tools
+.vscode/*
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+!.vscode/*.code-snippets
+
+# Local History for Visual Studio Code
+.history/
+
+# Built Visual Studio Code Extensions
+*.vsix
+
+# Windows Installer files from build outputs
+*.cab
+*.msi
+*.msix
+*.msm
+*.msp
+
+# >>> Configuration.cmake generated paths -- BEGIN (do not edit by hand; edit Configuration.cmake and reconfigure) >>>
+.cache/sysroots/
+.cache/tools/
+.cache/wine/
+compile_commands.json
+out/
+out/build/
+out/dist/
+out/docs/
+out/install/
+# <<< Configuration.cmake generated paths -- END <<<
diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 0000000..0f78e17
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,33 @@
+# =============================================================================
+# CMakeLists.txt -- the project's entry point
+#
+# Deliberately tiny, and the project's: nothing in it changes when the template
+# does. Two directories hold everything else:
+#
+#   project/   this project's settings -- its name, version, languages, C++
+#              standard, output layout (project/Configuration.cmake)
+#   breeze/    the template: the build system, toolchains, scripts and docs.
+#              Replace it wholesale to update the template.
+#
+# source/ (modules), vendor/ (vendored code) and out/ (everything generated)
+# stay at the root, as does c-api/ if you use it.
+# =============================================================================
+
+cmake_minimum_required(VERSION 3.25)
+
+# project() takes its arguments from the settings, so they are read first. The
+# file holds settings only (no compiler needed), which is what lets the scripts
+# read the same file without a configure.
+include("${CMAKE_CURRENT_SOURCE_DIR}/project/Configuration.cmake")
+
+project(
+    ${PROJECT_TITLE}
+    VERSION ${PROJECT_VERSION_NUMBER}
+    DESCRIPTION "${PROJECT_SUMMARY}"
+    LANGUAGES ${PROJECT_LANGUAGES}
+)
+
+# Everything else -- target selection, output paths, module discovery, install
+# rules -- is the template's. Add project-wide CMake of your own below this line
+# (or above it, if it has to come before the template's), not in breeze/.
+include("${CMAKE_CURRENT_SOURCE_DIR}/breeze/cmake/Breeze.cmake")
diff --git a/CMakePresets.json b/CMakePresets.json
new file mode 100644
index 0000000..59818a5
--- /dev/null
+++ b/CMakePresets.json
@@ -0,0 +1,11 @@
+{
+    "version": 6,
+    "cmakeMinimumRequired": {
+        "major": 3,
+        "minor": 25,
+        "patch": 0
+    },
+    "include": [
+        "breeze/CMakePresets.json"
+    ]
+}
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..3480698
--- /dev/null
+++ b/README.md
@@ -0,0 +1,187 @@
+# BreezeCLI
+
+`breeze`: a global command line tool for projects built on the breeze SDK (the CMake template in `breeze/`).
+It is written with [CLIForge](source/CLIForge) and is itself a breeze project: build it with
+`breeze/scripts/build.sh` (or, once you have a `breeze`, `breeze build`).
+
+Three things, kept apart on purpose:
+
+| | What it is | Where it lives | Versioned by |
+|---|---|---|---|
+| **CLI** | this program; one per machine, any number of versions installed | `~/.breeze/cli/<version>/` | its own version (`breeze cli version`) |
+| **SDK** | the template: `breeze/`, replaced as a whole on an update | in each project | `breeze/VERSION` (`breeze sdk version`) |
+| **Tools** | extensions a project installs from a repository | `<project>/.breeze/tools/<id>/` | the tool's tags |
+
+The CLI is global and the SDK is per project, so one CLI works on projects that are on different SDK versions, and on
+the layouts before `breeze/` existed (see [Older SDKs](#older-sdks)).
+
+## Commands
+
+Run `breeze --help`, or `breeze <command> --help`, for the exact options. The commands inside a project find it by
+walking up from the current directory.
+
+### Projects and modules
+
+```
+breeze project new <name> [--id] [--sdk]     a new project (no demo code, one executable module to start from)
+breeze project version|name|id [--set]       the project's version, name (CMake project()) and id
+breeze add exec|obj|test|example <name> [--id] [--deps ...]
+breeze add lib <name> (--static|--shared) [--id] [--deps ...]
+breeze delete <id> [--yes]                   refuses while another module depends on it
+breeze rename <id> [--name] [--id]           renames the directory and/or id, fixing the DEPENDS that name it
+breeze ls [--filter] [--exec] [--obj] [--lib] [--test] [--example] [--shared] [--static]
+breeze deps of <module> [--recursive]        what it depends on
+breeze deps on <module> [--recursive]        what depends on it
+```
+
+Modules are read from, and written as, the `add_*_module(...)` calls in each `CMakeLists.txt`; the CLI changes only
+what it must (a rename touches the id, the directories and the DEPENDS entries, nothing else in the files). Ids default
+to `<name in snake case>` plus `_exe`, `_lib`, `_obj`, `_test` or `_example`; `--deps` takes modules (by id or
+directory) or any other CMake target (`fmt::fmt`).
+
+### Building and running
+
+```
+breeze setup [--required|--all]
+breeze build   [-P platform] [-A arch] [-C compiler] [-M mode] [-j jobs] [-p preset] [--cargs ...] [--bargs ...] [--no-configure]
+breeze install [the same, and --no-build]
+breeze run [id] [-p/-P/-A/-C/-M ...] [-x arguments ...]
+breeze docs
+breeze clean [--no-build] [--docs]
+breeze defaults build platform|arch|compiler|preset|mode [--set <value>]
+breeze defaults run [--set <id>]
+```
+
+These drive the SDK's own scripts (`breeze/scripts/*.sh`, `.bat` on Windows), so the environment they set up (the
+pinned Ninja, the MSVC environment) is the one used. A platform, architecture and compiler name a preset
+(`-P linux -A x64 -C gcc` is `linux-x64-gcc`, ignoring case and punctuation: `ClangCl` finds `clang-cl`); whatever is
+missing comes from the project's defaults, then this machine. `--set none` clears a default. Defaults are kept in
+`.breeze/defaults.json`, meant to be committed.
+
+`--cargs` and `--bargs` take everything up to the next option, dashes included:
+`breeze build --cargs -DBUILD_TESTS=ON -DBUILD_EXAMPLES=ON -j 8`. `--bargs` (and `--no-configure`) run
+`cmake --build` on the directory the scripts configured, which the SDK's scripts have no way to do; so there must be a
+configured build first, and on Windows these two are not supported yet (the MSVC environment comes from the scripts).
+`-j` reaches the build through `CMAKE_BUILD_PARALLEL_LEVEL`.
+
+`run` with no id runs `breeze defaults run`, or the project's only executable. `-M` is accepted for `run` and ignored:
+the SDK keeps one build directory per preset.
+
+### The CLI itself
+
+```
+breeze cli version | ls
+breeze cli install <version> | pick <version> | uninstall <version>
+```
+
+Versions live in `~/.breeze/cli/<version>/` (`$BREEZE_HOME` moves `~/.breeze`); `cli/current` names the picked one.
+Every other command first hands itself over to the picked version, so whichever `breeze` your shell finds is the
+picked one, and `cli ...` commands always run in the version you started. Put `~/.breeze/bin` on `PATH`: the first
+`cli install` puts a copy of `breeze` there. Installing this program's own version needs nothing else:
+
+```
+./breeze cli install $(./breeze cli version)
+```
+
+Other versions come from the **CLI source**: `breeze config cli-source --set <URL or directory>`, expected to hold
+`<version>/breeze-<platform>-<arch>[.exe]` (platform `linux`, `macos`, `windows`; arch `x64`, `arm64`, `arm32`, `x86`).
+A URL is downloaded with `curl`. What is installed must run and say it is that version, or nothing is kept.
+
+### SDK versions
+
+```
+breeze sdk version | update | upgrade | migrate <version>
+```
+
+An SDK version is a snapshot of the whole template: `breeze/` (the SDK proper) plus the files a project starts from.
+Versions come from the **SDK source**: `breeze config sdk-source --set <git repository (URL or path) | directory>`.
+A repository's tags are the versions (`v1.2.0` or `1.2.0`); a directory has one subdirectory per version
+(`1.0.0/`, `1.1.0/`). The version of an SDK is the one line in `breeze/VERSION`, which the repository's tag should match.
+
+* `update` looks at the source and says what is there, and whether this project is behind.
+* `upgrade` moves to the newest version with the same major version.
+* `migrate <version>` moves to exactly that version, any way, across majors; `latest` is the newest release.
+
+Moving replaces `breeze/` (the old one is kept in `.breeze/backup/`), adds to `project/Configuration.cmake` any setting
+the new SDK has and the project's file lacks, and says which dot files (`.clang-format`, ...) now differ from the
+SDK's. Nothing else of the project is touched.
+
+### Tools
+
+```
+breeze tool install <repo> | uninstall <id> | update <id> | upgrade <id> | migrate <id> <version> | ls
+breeze tool <id> <arguments...>
+```
+
+A tool is a git repository (or, while it is being written, a directory) with a `breeze-tool.json` at its root:
+
+```json
+{ "id": "resembed", "version": "1.0.0", "description": "Embeds resources", "entry": "bin/resembed.sh" }
+```
+
+`entry` may be `{ "posix": "...", "windows": "..." }`. Installed, it is copied into `.breeze/tools/<id>/` and recorded in
+`.breeze/tools.json` (commit both); `breeze tool <id> ...` then runs the entry with those arguments, in the project's
+directory, with `BREEZE_PROJECT_ROOT`, `BREEZE_SDK_DIR`, `BREEZE_SDK_VERSION`, `BREEZE_TOOL_ID`, `BREEZE_TOOL_DIR`,
+`BREEZE_CLI`, `BREEZE_HOME` and `BREEZE_EDITOR` set. Everything after the id belongs to the tool, `--help` included, and its
+exit code is the CLI's. So `breeze tool san asan enable <module>` is whatever the `san` tool does with
+`asan enable <module>`. `install`, `uninstall`, `update`, `upgrade`, `migrate` and `ls` can't be tool ids.
+
+### Configuration
+
+```
+breeze config editor [--set]       the editor tools open files with (BREEZE_EDITOR in their environment)
+breeze config sdk-source [--set]   where SDK versions come from
+breeze config cli-source [--set]   where CLI versions come from
+```
+
+Kept in `~/.breeze/config.json`; `BREEZE_EDITOR`, `BREEZE_SDK_SOURCE` and `BREEZE_CLI_SOURCE` in the environment win.
+`--set none` clears one.
+
+## Older SDKs
+
+The CLI asks each project's SDK where things are instead of assuming:
+
+* **breeze/ layout** (with or without `breeze/VERSION`): everything above.
+* **The flat layout** (`scripts/`, `cmake/`, `Configuration.cmake` at the root): `ls`, `deps`, `add`, `rename`, `delete`,
+  `project name|version|id`, `build`, `run`, `install`, `clean` work through that layout's scripts and presets; what an
+  old SDK lacks is said when asked for (`add obj` on an SDK without objects modules; a preset on one without presets).
+  `breeze sdk migrate <version>` moves a flat project to the `breeze/` layout: the old `CMakeLists.txt`,
+  `Configuration.cmake`, `cmake/`, `scripts/` and `.githooks/` go to `.breeze/backup/`, and the project's name, version,
+  description, languages, C++ standard and any setting it had changed go into `project/Configuration.cmake`. The
+  project's own `README.md`, sources and dot files stay.
+
+## Building and testing
+
+```
+breeze/scripts/build.sh --preset linux-x64-gcc --cargs -DBUILD_TESTS=ON
+out/build/linux-x64-gcc/bin/tests/core_tests     # unit tests
+tests/e2e.sh                                     # drives the built program through every command group
+```
+
+`tests/e2e.sh` needs cmake, a compiler and git, and no network: it builds its own SDK source, tool and releases in a
+temporary directory.
+
+Layout: `source/CLIForge` (the command line library), `source/BreezeCore` (everything the commands do; unit tested),
+`source/Breeze` (the `breeze` executable: command registration only), `source/tests/CoreTests`.
+
+nlohmann/json is used for the files the CLI keeps: an installed 3.11 or newer is found, else the release is fetched
+(pinned by hash) when you configure.
+
+## Notes on CLIForge
+
+CLIForge is used as it came, with these changes to `source/CLIForge`, to be taken back into the library:
+
+* `CliError::kind()` returned `kind()` (endless recursion); it now returns `m_kind`.
+* `#pragma once` removed from the four `.cpp` files (a compiler warning each).
+
+Things to know when writing commands with it: an action's return value is ignored (so `Commands.cpp` leaves exit
+codes in `breeze::cli::exitCode()` for `main()`); an exception that is not a `CliError` leaves `Engine::run`; a token
+starting with `-` is always read as an option (which is why `main()` rewrites the values of `--cargs`, `--bargs` and
+`-x` to the `--cargs=-DX=1` form, see `breeze/Arguments.hpp`); parameters are required, so `run [id]` is two commands.
+
+## Status
+
+Built and tested on Linux with gcc and clang (x64) and gcc for arm64 (run under qemu): the unit tests and the 94 checks
+of `tests/e2e.sh` pass. Downloading a CLI release over HTTP was tried against a local web server with `curl`; git
+sources were tried with local repositories only. MinGW compiles the Windows code (process creation, `cmd.exe` scripts,
+paths) but nothing has been run on Windows, and nothing has been built on macOS.
diff --git a/breeze/CMakePresets.json b/breeze/CMakePresets.json
new file mode 100644
index 0000000..1d7033f
--- /dev/null
+++ b/breeze/CMakePresets.json
@@ -0,0 +1,166 @@
+{
+    "version": 6,
+    "cmakeMinimumRequired": { "major": 3, "minor": 25, "patch": 0 },
+    "configurePresets": [
+        {
+            "name": "base",
+            "hidden": true,
+            "generator": "Ninja",
+            "binaryDir": "${sourceDir}/out/build/${presetName}"
+        },
+        {
+            "name": "base-linux",
+            "hidden": true,
+            "inherits": "base",
+            "condition": { "type": "equals", "lhs": "${hostSystemName}", "rhs": "Linux" }
+        },
+        {
+            "name": "base-macos",
+            "hidden": true,
+            "inherits": "base",
+            "condition": { "type": "equals", "lhs": "${hostSystemName}", "rhs": "Darwin" }
+        },
+        {
+            "name": "base-windows",
+            "hidden": true,
+            "inherits": "base",
+            "condition": { "type": "equals", "lhs": "${hostSystemName}", "rhs": "Windows" }
+        },
+        {
+            "name": "base-mingw",
+            "hidden": true,
+            "inherits": "base",
+            "condition": { "type": "inList", "string": "${hostSystemName}", "list": ["Windows", "Linux"] }
+        },
+        {
+            "name": "linux-x64-gcc",
+            "inherits": "base-linux",
+            "displayName": "Linux x64 (GCC)",
+            "description": "GCC for x64 Linux: native on x64 hardware; on an ARM64 machine a cross build with x86_64-linux-gnu-g++",
+            "toolchainFile": "${sourceDir}/breeze/cmake/toolchains/linux-x64-gcc.cmake"
+        },
+        {
+            "name": "linux-x64-clang",
+            "inherits": "base-linux",
+            "displayName": "Linux x64 (Clang)",
+            "description": "Clang for x64 Linux: native on x64 hardware; on an ARM64 machine a cross build (clang++ --target=x86_64-linux-gnu)",
+            "toolchainFile": "${sourceDir}/breeze/cmake/toolchains/linux-x64-clang.cmake"
+        },
+        {
+            "name": "linux-arm64-gcc",
+            "inherits": "base-linux",
+            "displayName": "Linux ARM64 (GCC)",
+            "description": "GCC for ARM64 (aarch64) Linux: native on ARM64 hardware, otherwise a cross build with aarch64-linux-gnu-g++ (Debian/Ubuntu: apt install g++-aarch64-linux-gnu; qemu-user, if installed, lets ctest run the result)",
+            "toolchainFile": "${sourceDir}/breeze/cmake/toolchains/linux-arm64-gcc.cmake"
+        },
+        {
+            "name": "linux-arm64-clang",
+            "inherits": "base-linux",
+            "displayName": "Linux ARM64 (Clang)",
+            "description": "Clang for ARM64 (aarch64) Linux: native on ARM64 hardware, otherwise a cross build (clang++ --target=aarch64-linux-gnu; needs the aarch64 GCC cross package for its libraries, or -DCMAKE_SYSROOT)",
+            "toolchainFile": "${sourceDir}/breeze/cmake/toolchains/linux-arm64-clang.cmake"
+        },
+        {
+            "name": "linux-arm32-gcc",
+            "inherits": "base-linux",
+            "displayName": "Linux ARM32 (GCC)",
+            "description": "GCC for 32-bit ARM (armhf) Linux: native on 32-bit ARM hardware, otherwise a cross build with arm-linux-gnueabihf-g++ (Debian/Ubuntu: apt install g++-arm-linux-gnueabihf). A 32-bit ARM userland on 64-bit ARM hardware should pass -DCMAKE_CXX_COMPILER=g++ -- see breeze/cmake/toolchains/_common.cmake",
+            "toolchainFile": "${sourceDir}/breeze/cmake/toolchains/linux-arm32-gcc.cmake"
+        },
+        {
+            "name": "linux-arm32-clang",
+            "inherits": "base-linux",
+            "displayName": "Linux ARM32 (Clang)",
+            "description": "Clang for 32-bit ARM (armhf) Linux: native on 32-bit ARM hardware, otherwise a cross build (clang++ --target=<the triple the cross g++ was built for, normally arm-linux-gnueabihf>) -- see linux-arm32-gcc",
+            "toolchainFile": "${sourceDir}/breeze/cmake/toolchains/linux-arm32-clang.cmake"
+        },
+        {
+            "name": "macos-arm64-clang",
+            "inherits": "base-macos",
+            "displayName": "macOS ARM64 (Clang)",
+            "description": "Clang for Apple Silicon macOS -- Apple Clang from the Xcode Command Line Tools (xcode-select --install), or LLVM's own with -DCMAKE_CXX_COMPILER. The architecture is pinned with CMAKE_OSX_ARCHITECTURES, so this means arm64 even under a Rosetta-translated cmake; minimum macOS 11.0",
+            "toolchainFile": "${sourceDir}/breeze/cmake/toolchains/macos-arm64-clang.cmake"
+        },
+        {
+            "name": "macos-x64-clang",
+            "inherits": "base-macos",
+            "displayName": "macOS x64 (Clang)",
+            "description": "Clang for Intel macOS -- Apple Clang from the Xcode Command Line Tools, or LLVM's own with -DCMAKE_CXX_COMPILER. Pinned to x86_64 with CMAKE_OSX_ARCHITECTURES, so on an Apple Silicon Mac it builds x64 code that runs through Rosetta 2; minimum macOS 11.0",
+            "toolchainFile": "${sourceDir}/breeze/cmake/toolchains/macos-x64-clang.cmake"
+        },
+        {
+            "name": "windows-x64-msvc",
+            "inherits": "base-windows",
+            "displayName": "Windows x64 (MSVC)",
+            "description": "cl.exe for x64: run from an x64 Native Tools Command Prompt for VS -- cl.exe's architecture comes from that developer environment, not from CMake",
+            "toolchainFile": "${sourceDir}/breeze/cmake/toolchains/windows-x64-msvc.cmake"
+        },
+        {
+            "name": "windows-arm64-msvc",
+            "inherits": "base-windows",
+            "displayName": "Windows ARM64 (MSVC)",
+            "description": "cl.exe for ARM64: run from a Visual Studio Developer Prompt configured for ARM64 (an ARM64 Native Tools prompt, or x64_arm64 via vcvarsall.bat to cross-build from an x64 host) -- cl.exe's architecture comes from that environment, not from CMake",
+            "toolchainFile": "${sourceDir}/breeze/cmake/toolchains/windows-arm64-msvc.cmake"
+        },
+        {
+            "name": "windows-x64-clang-cl",
+            "inherits": "base-windows",
+            "displayName": "Windows x64 (clang-cl)",
+            "description": "clang-cl (Clang with the MSVC ABI), pinned to --target=x86_64-pc-windows-msvc so it means x64 whatever the machine's own architecture is",
+            "toolchainFile": "${sourceDir}/breeze/cmake/toolchains/windows-x64-clang-cl.cmake"
+        },
+        {
+            "name": "windows-arm64-clang-cl",
+            "inherits": "base-windows",
+            "displayName": "Windows ARM64 (clang-cl)",
+            "description": "clang-cl (Clang with the MSVC ABI), pinned to --target=aarch64-pc-windows-msvc so it means ARM64 whatever the machine's own architecture is",
+            "toolchainFile": "${sourceDir}/breeze/cmake/toolchains/windows-arm64-clang-cl.cmake"
+        },
+        {
+            "name": "windows-x64-clang",
+            "inherits": "base-windows",
+            "displayName": "Windows x64 (Clang, GNU-style)",
+            "description": "Clang with its own GNU-style driver, e.g. from an MSYS2 CLANG64 shell -- assumes that environment's clang++ is what's on PATH, distinct from clang-cl above",
+            "toolchainFile": "${sourceDir}/breeze/cmake/toolchains/windows-x64-clang.cmake"
+        },
+        {
+            "name": "windows-arm64-clang",
+            "inherits": "base-windows",
+            "displayName": "Windows ARM64 (Clang, GNU-style)",
+            "description": "Clang with its own GNU-style driver, e.g. from an MSYS2 CLANGARM64 shell -- assumes that environment's clang++ is what's on PATH",
+            "toolchainFile": "${sourceDir}/breeze/cmake/toolchains/windows-arm64-clang.cmake"
+        },
+        {
+            "name": "windows-x86-mingw32",
+            "inherits": "base-mingw",
+            "displayName": "Windows x86 (MinGW32)",
+            "description": "32-bit MinGW g++: i686-w64-mingw32-g++ from an MSYS2 MINGW32 shell on Windows, or a cross build from Linux (apt install g++-mingw-w64-i686; wine, if installed, lets ctest run the result)",
+            "toolchainFile": "${sourceDir}/breeze/cmake/toolchains/windows-x86-mingw32.cmake"
+        },
+        {
+            "name": "windows-x64-mingw64",
+            "inherits": "base-mingw",
+            "displayName": "Windows x64 (MinGW-w64)",
+            "description": "64-bit MinGW-w64 g++: x86_64-w64-mingw32-g++ from an MSYS2 MINGW64 shell on Windows, or a cross build from Linux (apt install g++-mingw-w64-x86-64; wine, if installed, lets ctest run the result)",
+            "toolchainFile": "${sourceDir}/breeze/cmake/toolchains/windows-x64-mingw64.cmake"
+        }
+    ],
+    "buildPresets": [
+        { "name": "linux-x64-gcc", "configurePreset": "linux-x64-gcc" },
+        { "name": "linux-x64-clang", "configurePreset": "linux-x64-clang" },
+        { "name": "linux-arm64-gcc", "configurePreset": "linux-arm64-gcc" },
+        { "name": "linux-arm64-clang", "configurePreset": "linux-arm64-clang" },
+        { "name": "linux-arm32-gcc", "configurePreset": "linux-arm32-gcc" },
+        { "name": "linux-arm32-clang", "configurePreset": "linux-arm32-clang" },
+        { "name": "macos-arm64-clang", "configurePreset": "macos-arm64-clang" },
+        { "name": "macos-x64-clang", "configurePreset": "macos-x64-clang" },
+        { "name": "windows-x64-msvc", "configurePreset": "windows-x64-msvc" },
+        { "name": "windows-arm64-msvc", "configurePreset": "windows-arm64-msvc" },
+        { "name": "windows-x64-clang-cl", "configurePreset": "windows-x64-clang-cl" },
+        { "name": "windows-arm64-clang-cl", "configurePreset": "windows-arm64-clang-cl" },
+        { "name": "windows-x64-clang", "configurePreset": "windows-x64-clang" },
+        { "name": "windows-arm64-clang", "configurePreset": "windows-arm64-clang" },
+        { "name": "windows-x86-mingw32", "configurePreset": "windows-x86-mingw32" },
+        { "name": "windows-x64-mingw64", "configurePreset": "windows-x64-mingw64" }
+    ]
+}
diff --git a/breeze/README.md b/breeze/README.md
new file mode 100644
index 0000000..97fc496
--- /dev/null
+++ b/breeze/README.md
@@ -0,0 +1,720 @@
+# CMakeTemplate
+
+A C++20 project template for CMake 3.25+ that builds the same way on Linux, macOS and Windows.
+
+- **Adding code means adding a folder.** A module is a directory under `source/` whose
+  `CMakeLists.txt` is one or two lines long. The root `CMakeLists.txt` is never edited.
+- **The template is one folder.** `breeze/` holds everything that makes it work: the build system,
+  toolchains, scripts and these docs. `project/` holds this project's own settings, and `source/`,
+  `vendor/` and `out/` are yours, at the root. Updating the template means replacing `breeze/`.
+- **Sixteen targets, one preset each.** Linux (x64, arm64, arm32 × GCC, Clang), macOS (arm64, x64),
+  Windows (x64, arm64 × MSVC, clang-cl, Clang; x64 and x86 MinGW-w64). Every target has its own
+  toolchain file and its own build directory, so switching targets never rebuilds anything.
+- **One setup script** checks your machine and offers to install what is missing, one tool at a
+  time, nothing without your yes.
+- **A working demo** to copy from: the shared library `core_lib` (with a piece of it, `core_farewell`, in an
+  objects module of its own), the executables `hello_exe` and
+  `farewell_exe`, a vendored header-only dependency (`tiny_ansi`), a vendored CMake dependency
+  (`tiny_case`) and `fmt`, fetched from Git.
+
+**Part 1, using the template:** [Requirements](#requirements) · [Quick start](#quick-start) ·
+[Choosing a target](#choosing-a-target) · [Everyday commands](#everyday-commands) ·
+[Adding code](#adding-code) · [Settings](#settings) · [Making it yours](#making-it-yours) ·
+[Updating the template](#updating-the-template) · [Troubleshooting](#troubleshooting)
+
+**Part 2, how it works:** [Layout](#repository-layout) · [The settings file](#the-settings-file) ·
+[Modules](#modules) · [Dependencies](#dependencies) · [Targets and toolchains](#targets-and-toolchains) ·
+[Setup internals](#setup-internals) · [Script internals](#script-internals) ·
+[Style and tooling](#style-and-tooling) · [Embedding](#embedding) ·
+[Verification status](#verification-status)
+
+---
+
+# Part 1: Using the template
+
+## Requirements
+
+- **Required:** Git, CMake 3.25 or newer, and a C++20 compiler (GCC, Clang, MSVC or MinGW-w64).
+- **Optional, each only for what uses it:** Clang, clang-format and clang-tidy (`refactor` and the
+  pre-commit hook), cross compilers, MinGW-w64, `qemu-user` and `wine` (to run cross-built
+  programs), Doxygen.
+- **Fetched for you** into `.cache/tools/`: Ninja 1.13.2 and Doxygen 1.16.1, pinned so every machine
+  builds with the same versions. A Ninja already on `PATH` is the fallback; the project builds
+  without Doxygen.
+- Setup installs tools through apt, dnf and pacman (Linux), Homebrew (macOS) and winget (Windows).
+  On anything else it reports what is missing and leaves the installing to you.
+
+## Quick start
+
+```sh
+breeze/scripts/setup.sh                  # once per clone; asks before installing anything
+breeze/scripts/build.sh                  # configure and build (Release)
+breeze/scripts/run.sh hello_exe World    # Hello, World! (from demo_core)
+```
+
+On Windows use `breeze\scripts\setup.bat`, `breeze\scripts\build.bat` and `breeze\scripts\run.bat hello_exe World`, from
+`cmd` or PowerShell.
+
+To build for a specific target, name its preset: `breeze/scripts/build.sh --preset linux-x64-clang`. `run`
+then follows the build you made last, or takes `--preset` too.
+
+## Choosing a target
+
+A target is a preset named `<os>-<arch>-<compiler>`. `breeze/scripts/build.sh --list-presets` shows the ones
+your OS offers. Without `--preset` the first compiler CMake finds is used and the build goes to
+`out/build/default/`.
+
+| Presets | Build | Needs |
+|---|---|---|
+| `linux-x64-gcc` `linux-x64-clang` `linux-arm64-gcc` `linux-arm64-clang` `linux-arm32-gcc` `linux-arm32-clang` | Linux on x86-64, AArch64, 32-bit ARM | On matching hardware, just the compiler. Otherwise a cross compiler for that architecture; the Clang presets also need Clang. |
+| `macos-arm64-clang` `macos-x64-clang` | macOS on Apple Silicon, Intel | Xcode Command Line Tools. Either Mac builds both; x64 programs run on Apple Silicon under Rosetta 2. |
+| `windows-x64-msvc` `windows-arm64-msvc` | Windows, MSVC | Visual Studio or Build Tools with the C++ workload. ARM64 also needs the ARM64 build tools component; from an x64 machine that is a cross build (`breeze\scripts\setup.bat` offers to add it). |
+| `windows-x64-clang-cl` `windows-arm64-clang-cl` | Windows, clang-cl (MSVC ABI) | The above plus clang-cl: LLVM, or Visual Studio's Clang component. |
+| `windows-x64-clang` `windows-arm64-clang` | Windows, MSYS2 Clang (MinGW ABI) | MSYS2's CLANG64 (x64) or CLANGARM64 (ARM64) Clang package. MSYS2 has CLANGARM64 only on ARM64 Windows, so `windows-arm64-clang` needs such a machine; from x64 use the ARM64 MSVC or clang-cl presets. |
+| `windows-x64-mingw64` `windows-x86-mingw32` | Windows, MinGW-w64 GCC | MSYS2 with MinGW-w64 GCC. Also cross-builds from Linux. |
+
+**Cross builds.** A Linux preset for another architecture compiles with the matching
+`<triplet>-g++` (`aarch64-linux-gnu`, `arm-linux-gnueabihf`, `x86_64-linux-gnu`); the MinGW presets
+also cross-build from Linux. Setup installs these where your package manager has them (see
+[What setup can install](#what-setup-can-install)). If `qemu-user` (Linux targets) or `wine`
+(Windows targets) is installed when you configure, `breeze/scripts/run` and `ctest` use it to run the
+result.
+
+**Windows ARM64 from an x64 machine** is a cross build too: `windows-arm64-msvc` and
+`windows-arm64-clang-cl` compile with Visual Studio's x64-hosted ARM64 tools (`vcvarsall x64_arm64`),
+which need the ARM64 build tools component, and the programs cannot run on the build machine.
+
+**Windows environments.** MSVC and clang-cl only work inside a Visual Studio developer environment,
+and MSYS2's compilers only with their folder on `PATH`. `breeze\scripts\build.bat` enters the right one for
+the preset by itself, for that run only, so no "Native Tools Command Prompt" or MSYS2 shell is
+needed; `PMN_NO_ENV=1` turns it off ([details](#windows-environments)). Plain `cmake --preset ...`
+and IDEs don't do this: start them from the matching prompt.
+
+## Everyday commands
+
+Every script exists as `.sh` and `.bat` with the same options, answers `-h` / `--help`, and works
+from any directory in the repository. `--preset NAME` (or `--preset=NAME`) must come first.
+
+| Script | Usage | Does |
+|---|---|---|
+| `setup` | `[--yes] [--all] [--everything] [--check] [--skip-tools]` | Checks and installs tools, fetches pinned Ninja and Doxygen, activates the pre-commit hook. |
+| `build` | `[--preset NAME] [BUILD_TYPE] [CMAKE_ARGS…]`<br>`--list-presets` | Configures and builds into `out/build/<preset>`. `BUILD_TYPE` is `Debug`, `Release` (default), `RelWithDebInfo` or `MinSizeRel`; further arguments go to CMake as they are, e.g. `-DBUILD_TESTS=ON`. |
+| `run` | `[--preset NAME] TARGET [ARGS…]` | Runs an executable by CMake target name; without a target it lists them. Cross-built programs run under qemu or wine when available. |
+| `install` | `[--preset NAME] [BUILD_TYPE]` | Installs this project's targets to `out/install/<preset>/{bin,lib}`. |
+| `docs` | `[--preset NAME] [MODULE]` | Builds the Doxygen docs of every module, or one, into `out/docs/`. |
+| `refactor` | `[PATH]` | Runs clang-format, then clang-tidy `--fix` (which needs a previous build for its compile database), over `source/` and `c-api/`, or just `PATH`. Review with `git diff`. |
+
+`run`, `install` and `docs` act on the build made last unless you pass `--preset`; `BUILD_DIR`
+selects an exact directory instead. The build type is not part of the directory name, so changing it
+within a preset reconfigures that directory.
+
+**Setup flags.** `--yes` installs the required tools without asking (for CI), `--all` the optional
+ones too, `--everything` also the third-party extras (today: Arch's prebuilt 32-bit ARM toolchain
+from the AUR), `--check` only reports and exits 1 if a required tool is missing, `--skip-tools` goes
+straight to the downloads. At each question: `y` installs, `n` skips that tool, `a` accepts everything
+left, `s` skips the remaining optional tools, `q` stops asking. With no terminal and no flag nothing
+is installed.
+
+**CMake directly.**
+
+```sh
+cmake --preset linux-x64-gcc
+cmake --build --preset linux-x64-gcc
+ctest --test-dir out/build/linux-x64-gcc        # tests need -DBUILD_TESTS=ON
+```
+
+IDEs with preset support (CLion, VS Code, Visual Studio) list the presets for your OS; personal ones
+go in `CMakeUserPresets.json`. A bare `-DDIST_TARGET=…` only labels a build, it does not choose a
+compiler, and a label that disagrees with the compiler stops the configure: pick targets with
+presets.
+
+## Adding code
+
+Create a directory with a `CMakeLists.txt`; the next build finds it.
+
+```cmake
+# source/MyLib/CMakeLists.txt      library: sources in src/, headers in include/
+add_lib_module(my_lib TYPE SHARED DEPENDS fmt::fmt)
+
+# source/MyPiece/CMakeLists.txt    objects: compiled, no library of its own (a piece of one)
+add_objects_module(my_piece)     # taken in by naming it: add_lib_module(my_lib DEPENDS my_piece)
+
+# source/MyApp/CMakeLists.txt      executable: *.cpp in the module
+add_exe_module(my_app DEPENDS my_lib)
+
+# source/tests/my_test/CMakeLists.txt        built with -DBUILD_TESTS=ON, registered with CTest
+add_test_module(my_test DEPENDS my_lib)
+
+# source/examples/my_example/CMakeLists.txt  built with -DBUILD_EXAMPLES=ON
+add_example_module(my_example DEPENDS my_lib)
+```
+
+Options: `OUTPUT_NAME <file name>` (for an objects module, which has no file, only the name `MODULE_NAME`
+carries), `DEPENDS <targets>`, `EXTRA_SOURCES <files>`, `NO_DOCS`. Third-party
+code comes in three ways, called from the CMakeLists of the module that needs it:
+
+```cmake
+add_vendor_header_only(tiny_ansi)       # vendor/tiny_ansi/include, header-only
+add_vendor_subdirectory(tiny_case)      # vendor/tiny_case/CMakeLists.txt
+add_dependency(fmt                      # an installed copy if new enough, else fetched
+    GIT_REPOSITORY https://github.com/fmtlib/fmt.git  GIT_TAG 12.1.0
+    FIND_PACKAGE_ARGS 12 NAMES fmt)
+```
+
+What one module declares, every module can use: `source/CoreFarewell` depends on the `fmt::fmt` that
+`source/Core` declares, whether fmt was fetched or an installed copy was found.
+
+Every module also gets Doxygen docs (`NO_DOCS` opts out; a `README.md` in the module's directory
+becomes its main page).
+
+## Settings
+
+Pass options to `build` as CMake arguments, e.g. `breeze/scripts/build.sh -DBUILD_TESTS=ON`.
+
+| Option | Default | Effect |
+|---|---|---|
+| `BUILD_TESTS`, `BUILD_EXAMPLES` | OFF | Build the modules under `source/tests` and `source/examples`. |
+| `INSTALL_TESTS`, `INSTALL_EXAMPLES` | OFF | Also install them (implies the matching `BUILD_` option). |
+| `BUILD_SHARED_LIBS` | OFF | Library type for modules that don't say `TYPE`. |
+| `ENABLE_DOXYGEN` | ON | Per-module documentation; `-DDOXYGEN_<TAG>=…` sets any Doxyfile tag. |
+| `PMN_MINGW_STATIC_RUNTIME` | OFF | MinGW: link the GCC runtime into executables instead of shipping its DLLs. Unsafe when an executable uses a shared module that passes STL types across its interface. |
+
+The project's own settings (its name, version, languages and C++ standard, `PROJECT_CODE_NAME`,
+`DEFAULT_BUILD_TYPE`, `OUT_DIR` and the directories under it) live in `project/Configuration.cmake`;
+the cache variables among them can also be overridden with `-D`.
+
+## Making it yours
+
+1. In `project/Configuration.cmake` set `PROJECT_TITLE`, `PROJECT_VERSION_NUMBER`, `PROJECT_SUMMARY`,
+   `PROJECT_LANGUAGES` and `PROJECT_CXX_STANDARD` (the arguments of `project()` and the C++ standard),
+   `PROJECT_CODE_NAME` (it becomes the `PROJECT_NAME_CODE` compile definition and the install
+   component) and `DEFAULT_BUILD_TYPE`.
+2. Delete the demo modules in `source/` and `vendor/` and add your own.
+3. Replace the root `README.md` with the project's own (Doxygen uses it as the main page).
+4. Run `breeze/scripts/setup`.
+
+Nothing in `breeze/` needs an edit. The root `CMakeLists.txt` and `CMakePresets.json` are yours to
+extend (project-wide CMake of your own, or presets that `inherit` from the template's) and need
+nothing to get started.
+
+## Updating the template
+
+The template is the `breeze/` folder and nothing else; no file of the project's lives in it. To
+update, replace the folder with the new version's and run `breeze/scripts/setup` again (it points
+git's `core.hooksPath` at `breeze/githooks` and re-checks your tools).
+
+| The project's (an update never touches them) | The template's (replaced as a whole) |
+|---|---|
+| `project/`, `source/`, `vendor/`, `c-api/`; the root `CMakeLists.txt`, `CMakePresets.json` and `README.md` | `breeze/` |
+
+Four kinds of file sit at the root, outside `breeze/`, because the tools that read them look there: the
+dot files (`.clang-format`, `.clang-tidy` and `c-api/.clang-tidy`, `.editorconfig`, `.gitattributes`)
+and `.gitignore`, whose marked block every configure rewrites. A new template version may change
+them: compare them with the new copies. A new version may also read a setting your
+`project/Configuration.cmake` doesn't have yet; the configure then stops and names it, and the new
+version's own `project/Configuration.cmake` shows its default.
+
+**With the `breeze` CLI** the update is `breeze sdk update` (what is available), `breeze sdk upgrade` (the newest
+version of your major version) or `breeze sdk migrate <version>`: it replaces `breeze/` for you (keeping the old one in
+`.breeze/backup/`), adds the settings the new version has, and moves a project in the old flat layout to this one. The
+SDK's version is `breeze/VERSION`, one line, and a release of the template is a tag (`v1.2.0`) whose `breeze/VERSION`
+says the same.
+
+**Moving a project that has the old flat layout** (`cmake/`, `scripts/` and `Configuration.cmake` at the
+root): put in `breeze/`, `project/` and the new root `CMakeLists.txt`, `CMakePresets.json` and
+`README.md`, and delete the old `cmake/`, `scripts/`, `.githooks/`, `StyleGuide.md` and
+`Configuration.cmake`. Carry your values over into `project/Configuration.cmake`: from the old
+`Configuration.cmake` (`PROJECT_CODE_NAME`, `DEFAULT_BUILD_TYPE`, any output path you changed) and from
+the old `CMakeLists.txt` (the `project()` arguments and the C++ standard). Run `breeze/scripts/setup`
+once, which moves `core.hooksPath` from `.githooks` to `breeze/githooks`, and delete `out/build/`: the
+old build directories point at files that are gone.
+
+## Troubleshooting
+
+| Symptom | Cause and fix |
+|---|---|
+| Windows: CMake says `cl` is missing or targets the wrong architecture | CMake ran outside the right Visual Studio developer prompt. Use `breeze\scripts\build.bat`, or open the matching prompt, then delete the build directory. |
+| Windows: a MinGW or `-clang` preset can't find its compiler | MSYS2's toolchain folder isn't on `PATH`. `breeze\scripts\build.bat` adds it; set `MSYS2_ROOT` if MSYS2 isn't in `<system drive>\msys64`. |
+| Windows: `cannot open msvcrt.lib`, `could not open 'msvcrtd.lib'`, or an x64 `cl` used for an ARM64 preset | The Visual Studio component for that target isn't installed. For ARM64 it is "MSVC … C++ ARM64/ARM64EC build tools (Latest)", which an x64 machine needs to cross-compile. `breeze\scripts\setup.bat` offers to add it, and `breeze\scripts\build.bat` stops with this explanation before CMake runs. |
+| `windows-arm64-clang` on an x64 machine says it needs MSYS2's CLANGARM64 | MSYS2 provides CLANGARM64 only on ARM64 Windows. Build ARM64 from x64 with `windows-arm64-msvc` or `windows-arm64-clang-cl`. |
+| `linux-arm32-*` fails with `invalid -march= option` or `Scrt1.o: file not recognized` | The cross compiler, binutils and C library come from different package sets. `breeze/scripts/setup.sh` reports this as `[part]`; on Arch x64 it replaces them with a matching prebuilt set. |
+| A cross build stops with `Could NOT find X11` (or OpenGL, ALSA, …), though the host has it | Cross builds look only in the target's root, which has the C/C++ runtime and nothing else; the host's libraries are for the wrong architecture. Give the build a target sysroot: a root filesystem for the target with those libraries in `.cache/sysroots/linux-<arch>`, or `-DCMAKE_SYSROOT=<dir>`. See [Cross builds and system libraries](#cross-builds-and-system-libraries). |
+| `breeze/scripts/run` can't run a cross-built program | No emulator was installed when the build directory was configured. Install `qemu-user` or `wine` and run `breeze/scripts/build` again. |
+| wine complains about its prefix | Delete `.cache/wine/`; it is rebuilt on the next run. |
+| "No pinned Ninja / Doxygen binary is configured for this machine" | Pinned downloads exist for x64 and arm64 on Windows, Linux and macOS (Doxygen: x64 Linux and Windows, and macOS). A 32-bit `cmake.exe` on 64-bit Windows looks the same. Use 64-bit CMake, or put Ninja / Doxygen on `PATH` (`-DDOXYGEN_EXECUTABLE=…`). |
+| `DIST_TARGET` mismatch error | `-DDIST_TARGET=…` disagrees with the compiler CMake chose. Use `--preset`, or drop the option. |
+| `linux-arm32-gcc` looks for a cross compiler on a 32-bit userland running on a 64-bit ARM kernel | `uname -m` reports aarch64 there. Pass `-DCMAKE_CXX_COMPILER=g++`. |
+| The pre-commit hook rejects a commit | clang-format or clang-tidy found problems in staged C/C++ files. Run `breeze/scripts/refactor` and review the diff. |
+
+---
+
+# Part 2: How it works
+
+## Repository layout
+
+```
+CMakeLists.txt             the project's entry point: project(), then breeze/ (never edited)
+CMakePresets.json          includes breeze/CMakePresets.json; the project's own presets go here
+README.md                  the project's own
+project/
+  Configuration.cmake      the project's settings: identity, output paths. One source of truth
+breeze/                    the template: replace this folder to update it
+  README.md  StyleGuide.md
+  VERSION                  the SDK's version, one line (the `breeze` CLI reads it)
+  CMakePresets.json        16 configure + 16 build presets, plus hidden base presets
+  cmake/
+    Breeze.cmake           the build system: options, output dirs, module discovery, install rules
+    TargetSelection.cmake  DIST_TARGET -> PLATFORM, ARCHITECTURE, COMPILER_ID
+    GitignoreSync.cmake    keeps the generated block of .gitignore current
+    BuildHelpers.cmake     module macros, output dirs, RPATH, runtime DLLs, manifest
+    Dependencies.cmake     add_vendor_header_only, add_vendor_subdirectory, add_dependency
+    Documentation.cmake    per-module Doxygen targets            (+ DoxygenPin, FetchDoxygen)
+    NinjaPin.cmake         pinned Ninja                          (+ FetchNinja)
+    HostArch.cmake         machine architecture -> x64 / arm64 / arm32
+    PrintConfig.cmake      script mode: print project/Configuration.cmake values
+    BuildDir.cmake         script mode: which build directory a script uses
+    CopyRuntimeDlls.cmake  post-build copy of runtime DLLs
+    toolchains/            one file per target, plus _common.cmake
+  scripts/                 setup build run install docs refactor, each .sh + .bat
+                           helpers: _common.sh  _tools.sh  _tools.ps1  _winenv.bat
+  githooks/pre-commit      clang-format + clang-tidy on staged files
+source/                    Core/ (core_lib)  CoreFarewell/ (core_farewell, objects)  HelloApp/  FarewellApp/
+                           [tests/  examples/]
+vendor/                    tiny_case/ (CMake project)  tiny_ansi/ (header-only)
+c-api/                     .clang-tidy for a C API surface
+.clang-format  .clang-tidy  .editorconfig  .gitattributes  .gitignore
+```
+
+Generated, git-ignored: `out/` (`build/<preset>/`, `install/<target>/`, `docs/`, `dist/` reserved)
+and `.cache/` (`tools/`, `wine/`, `sysroots/`).
+
+## The settings file
+
+`project/Configuration.cmake` defines the project's identity and every output path. The output
+settings are cache variables, so `-D` overrides any; the identity values are plain variables, because
+the root `CMakeLists.txt` passes them to `project()`. The scripts never duplicate a value: they read
+it through `cmake -P` helpers.
+
+| Variable | Default | Meaning |
+|---|---|---|
+| `PROJECT_TITLE` `PROJECT_VERSION_NUMBER` `PROJECT_SUMMARY` `PROJECT_LANGUAGES` | `DemoApp` `0.1.0` … `CXX` | The name, `VERSION`, `DESCRIPTION` and `LANGUAGES` of `project()`. |
+| `PROJECT_CXX_STANDARD` | `20` | `CMAKE_CXX_STANDARD`; the standard is required and compiler extensions are off. |
+| `PROJECT_CODE_NAME` | `demo` | Compile definition `PROJECT_NAME_CODE`; the `cmake --install` component. |
+| `DEFAULT_BUILD_TYPE` | `Release` | Used by CMake and the scripts when no type is given. |
+| `OUT_DIR` | `<source>/out` | Root of everything generated. |
+| `BUILD_OUTPUT_DIR` `INSTALL_OUTPUT_DIR` `DOCS_OUTPUT_DIR` `DIST_OUTPUT_DIR` | `OUT_DIR/build` `/install` `/docs` `/dist` | One build directory per preset, one install directory per `DIST_TARGET`; `dist` is reserved. |
+| `TOOLCACHE_DIR` | `<source>/.cache/tools` | Pinned Ninja and Doxygen. |
+| `RUNTIME_OUTPUT_SUBDIR` `LIBRARY_OUTPUT_SUBDIR` `ARCHIVE_OUTPUT_SUBDIR` | `bin` `bin` `lib` | Layout inside a build or install tree. |
+| `COMPILE_COMMANDS_DESTINATION` | `<source>/compile_commands.json` | Copy of the compile database for clangd and clang-tidy, refreshed after each build. |
+
+`DIST_TARGET`, `PLATFORM`, `ARCHITECTURE` and `COMPILER_ID` are not settings: the template derives them
+(`breeze/cmake/TargetSelection.cmake`, see [Target selection](#target-selection)).
+
+- **Script mode.** `cmake "-DPRINT_VARS=A;B" -P breeze/cmake/PrintConfig.cmake` prints `-- A=value` lines.
+  `cmake [-DPMN_NAME=<preset|default>] [-DPMN_RECORD=ON] -P breeze/cmake/BuildDir.cmake` prints
+  `-- BUILD_DIR=…` (or `-- ERROR=…`) and, with `PMN_RECORD`, remembers the choice in
+  `out/build/.last`. A plain `cmake -P` script can include the settings file because it holds
+  settings only: nothing in it needs a compiler or writes a file. Target selection and the
+  `.gitignore` sync are the template's, and only a real configure runs them.
+- **`.gitignore`.** A marked block is regenerated on every real configure from the output paths, so
+  moving `OUT_DIR` updates it. The rest of the file is never touched.
+
+## Modules
+
+- **Discovery.** Every `source/<dir>/`, `source/tests/<dir>/` and `source/examples/<dir>/` that
+  contains a `CMakeLists.txt` is added, with `CONFIGURE_DEPENDS`, so adding or removing a module
+  reconfigures by itself.
+- **Macros** (`breeze/cmake/BuildHelpers.cmake`). `add_lib_module` (`add_static_lib_module` and
+  `add_shared_lib_module` are shorthands for its `TYPE`), `add_objects_module`, `add_exe_module`,
+  `add_test_module`, `add_example_module`.
+
+| Macro | Sources (recursive globs) | Output | Notes |
+|---|---|---|---|
+| `add_lib_module` | `src/*.cpp`, `include/*.h(pp)` | shared: `bin/`, static: `lib/` | `include/` is public. Without `TYPE`, `BUILD_SHARED_LIBS` decides. |
+| `add_objects_module` | `src/*.cpp`, `include/*.h(pp)` | nothing of its own: the objects go into whatever names it in `DEPENDS` | `include/` is public. See "Objects modules" below. |
+| `add_exe_module` | `*.cpp`, `include/*.h(pp)` | `bin/` | |
+| `add_test_module` | same | `bin/tests/` | Registered with CTest and `all_tests`; `EXCLUDE_FROM_ALL` unless `BUILD_TESTS`. |
+| `add_example_module` | same | `bin/examples/` | Same, with `BUILD_EXAMPLES`. |
+
+- **What each module target gets.** The compile definitions `MODULE_NAME` (its output name; for an objects
+  module the `OUTPUT_NAME` it was given),
+  `PROJECT_NAME`, `PROJECT_NAME_CODE`, `PROJECT_VER` and, in Debug, `DEBUG`; warnings (`/W4
+  /permissive-` on MSVC, `-Wall -Wextra -Wpedantic` elsewhere); its `DEPENDS` linked `PRIVATE` (objects
+  modules, below, are the exception for libraries); an
+  RPATH of `$ORIGIN` (`$ORIGIN/..` for tests and examples), which becomes `@loader_path` for Mach-O
+  in one place, `_apply_rpath`; and a Doxygen target unless `NO_DOCS`. Project-wide: C++20 without
+  extensions, position-independent code, `CMAKE_BUILD_WITH_INSTALL_RPATH` off Windows.
+- **Objects modules.** `add_objects_module` compiles a directory to object files and stops there: no
+  archive, no DLL, nothing in `bin/` or `lib/`. Name it in the `DEPENDS` of a library, an executable, a
+  test, an example or another objects module, and its objects become part of that target. That makes it
+  the way to split a big library into pieces: each piece is a module of its own, with its own `include/`,
+  and what remains of the library is a line naming them.
+
+  ```cmake
+  # source/CoreMath/CMakeLists.txt
+  add_objects_module(core_math OUTPUT_NAME "core")
+  # source/CoreIo/CMakeLists.txt
+  add_objects_module(core_io OUTPUT_NAME "core" DEPENDS core_math)
+  # source/Core/CMakeLists.txt        the library: its own sources, plus the pieces
+  add_lib_module(core_lib TYPE SHARED OUTPUT_NAME "core" DEPENDS core_io)
+  ```
+
+  - **Name the direct pieces only.** `core_lib` above gets `core_math` too, because `core_io` needs it:
+    CMake links an object library's objects into the target that names it and no further, so the
+    template follows the objects modules behind the ones you name (`_resolve_object_modules`, run once
+    all modules are discovered, so directory order doesn't matter). Cycles stop the configure.
+  - **Headers.** A piece's `include/` is public, and a library passes its pieces' headers on: whoever
+    depends on `core_lib` sees `core_math`'s and `core_io`'s headers. Those consumers must not name the
+    pieces again, which would link a second copy of the objects into them (two copies of the library's
+    state, when it is shared). An executable takes pieces privately. Keep a piece's private headers in
+    `src/`.
+  - **`OUTPUT_NAME`** is only what `MODULE_NAME` carries, so that the pieces of one library all identify
+    as it. What a piece links itself, a static library for instance, is reached at the final link.
+  - **What they are not.** Not installed, not run, not in the manifest; always position-independent,
+    because they may end up in a shared library. Tests and examples can name a piece to test it without
+    the rest of the library. `source/CoreFarewell` is the demo: `core_lib` takes it in, and
+    `farewell_exe` finds `core/Farewell.hpp` through `core_lib` alone.
+- **Manifest.** Each configure writes `module_manifest-<CONFIG>.txt` into the build directory, one
+  `target=path` line per executable; `breeze/scripts/run` resolves target names through it.
+- **Runtime DLLs (Windows).** Shared modules an executable depends on are copied next to it after
+  the build (`CopyRuntimeDlls.cmake`: `cmake -E copy_if_different` fails on the empty list that
+  `$<TARGET_RUNTIME_DLLS:…>` is for most targets). For
+  MinGW the GCC runtime (`libgcc_s_*-1.dll`, `libstdc++-6.dll`, `libwinpthread-1.dll`) is located
+  through the compiler and copied the same way, and installed beside the executables.
+  `PMN_MINGW_STATIC_RUNTIME=ON` links executables statically instead; that is unsafe when they use a
+  shared module whose interface passes STL types (separate heaps and unwinders), hence off by
+  default.
+- **Install.** Targets are tagged with the component `PROJECT_CODE_NAME` and go to
+  `out/install/<DIST_TARGET>/{bin,lib}` (tests and examples under `bin/tests`, `lib/tests`, … when
+  `INSTALL_TESTS` / `INSTALL_EXAMPLES`). `breeze/scripts/install` always passes `--component`, which keeps
+  the `install()` rules of fetched or vendored dependencies out; a bare `cmake --install` would run
+  them too.
+- **Docs.** A `docs_<target>` target per module plus an aggregate `docs`, built into
+  `out/docs/<target>/html/` with `out/docs/index.html` linking them. Any Doxyfile tag can be set
+  as `DOXYGEN_<TAG>`. Without a usable Doxygen, or with `ENABLE_DOXYGEN=OFF`, `breeze/scripts/docs` does nothing and says
+  why; `-DDOXYGEN_PINNED_VERSION=…` replaces the pinned version.
+
+## Dependencies
+
+`breeze/cmake/Dependencies.cmake` offers `add_vendor_header_only(NAME [INCLUDE_DIR dir])` (an INTERFACE
+target over `vendor/<name>/include`), `add_vendor_subdirectory(SUBDIR)` (a source drop, submodule or
+subtree with its own `CMakeLists.txt`) and `add_dependency(NAME <FetchContent_Declare args>)`
+(`find_package` first when `FIND_PACKAGE_ARGS` is given, a fetch otherwise). All three keep the
+dependency's warnings out of your build (`SYSTEM`) and its targets out of `compile_commands.json`,
+and all are no-ops when repeated for the same name, so two modules may ask for the same dependency.
+The targets are usable from every module, wherever the call was made: an installed copy's imported
+targets are directory-scoped by default, so `add_dependency` makes them global for the call
+(`CMAKE_FIND_PACKAGE_TARGETS_GLOBAL`), and a sibling module's `DEPENDS fmt::fmt` finds them.
+Always give `FIND_PACKAGE_ARGS` a minimum version: without one any installed copy beats the pinned
+tag. A dependency's own options are set (`set(<OPTION> … CACHE …)`) before the call;
+`source/Core/CMakeLists.txt` is the commented example. In cross builds `find_package` only looks in
+the target's root, so a host's `libfmt` is never picked up -- and neither is anything the target's
+root lacks, which is what a target sysroot is for (see
+[Cross builds and system libraries](#cross-builds-and-system-libraries)).
+
+## Targets and toolchains
+
+### Target selection
+
+`DIST_TARGET` is the one label of a build, `<platform>-<arch>-<compiler>`; `PLATFORM`,
+`ARCHITECTURE` (`x64`, `arm64`, `arm32`, `x86`) and `COMPILER_ID` (`gcc`, `clang`, `msvc`,
+`clang-cl`, `mingw64`, `mingw32`) follow from it.
+
+- A **toolchain file** (`breeze/cmake/toolchains/<target>.cmake`, three lines each) declares it with
+  `pmn_toolchain_target(<target>)` and calls one family macro: `pmn_linux_toolchain(arch gcc|clang)`,
+  `pmn_macos_toolchain(arch)`, `pmn_msvc_toolchain(arch)`, `pmn_clang_cl_toolchain(arch)`,
+  `pmn_msys_clang_toolchain()`, `pmn_mingw_toolchain(arch)`. An explicit `-DDIST_TARGET` must agree
+  with the toolchain's.
+- **Without a toolchain**, `TargetSelection.cmake` detects the target from the compiler CMake found.
+  Linux: the machine's architecture (`HostArch.cmake`) and the compiler ID. macOS:
+  `CMAKE_OSX_ARCHITECTURES`, else `CMAKE_SYSTEM_PROCESSOR`; several architectures (a universal
+  binary) is an error. Windows: MSVC and clang-cl by `CMAKE_CXX_COMPILER_ARCHITECTURE_ID`, GNU-style
+  Clang by the host architecture, GCC as MinGW by pointer size (there is no ARM MinGW target:
+  MinGW-w64's GCC has no ARM64 Windows backend).
+- An explicit `-DDIST_TARGET` is **cross-checked** against that detection, and a disagreement stops
+  the configure with the toolchain file or preset to use. An undetectable architecture also stops
+  it, with the list of valid values.
+- **Presets** (`breeze/CMakePresets.json`, version 6, included by the root `CMakePresets.json`). A hidden `base` (Ninja, `out/build/${presetName}`)
+  and host-OS bases with `condition`s (`base-linux`, `base-macos`, `base-windows`, `base-mingw` for
+  Windows or Linux hosts) sit under 16 visible configure presets and 16 build presets with the same
+  names. There are no test presets.
+
+### Linux
+
+`pmn_linux_toolchain` decides by comparing the requested architecture with the machine's.
+
+- **Native** uses the ordinary `g++` / `clang++`. **Cross** uses `<triplet>-g++` /
+  `<triplet>-gcc`, resolved to absolute paths so every `try_compile` agrees; a missing compiler stops
+  with the install hint. A compiler passed with `-DCMAKE_CXX_COMPILER` beats the toolchain's; a stray
+  `CXX` environment variable does not. A 32-bit userland on a 64-bit ARM kernel reports `aarch64`, so
+  it needs `-DCMAKE_CXX_COMPILER=g++`.
+- **Cross mechanics** (`pmn_cross_target`): `CMAKE_SYSTEM_NAME` / `PROCESSOR` are set, programs come
+  from the host, and libraries, headers and packages only from the target sysroot (if there is one, see below) and
+  `/usr/<triplet>`.
+- **Emulator** (`pmn_cross_emulator`): `qemu-<arch> -L <root>` for Linux targets, `wine64` /
+  `wine` for MinGW. It is stored as the cache entry `CMAKE_CROSSCOMPILING_EMULATOR` once found, so an
+  emulator installed later is picked up by the next configure and a stored choice stays until you
+  change the entry or delete the build directory. `breeze/scripts/run` and CTest read it from there.
+- **Clang** cross builds use `clang++ --target=<triple>` with the cross g++'s libstdc++ and linker.
+  When that g++ reports a real sysroot (dnf's COPR toolchains, ARM's own), Clang also gets
+  `--sysroot` and `--gcc-toolchain=/usr`; flat layouts (Debian's `/usr/<triplet>`, pacman's) need
+  neither.
+- **Checks.** The toolchain asks the installed cross g++ about itself instead of trusting a
+  convention, because a cross compiler is only as good as the binutils and C library installed
+  beside it. Each check is a warning with the likely cause, printed once, and configure carries on:
+  - a sysroot that `-print-sysroot` reports but that isn't on disk is dropped (Clang would otherwise
+    fall back to the host's crt files: `Scrt1.o: file not recognized`);
+  - Clang's `--target` is the triple `-dumpmachine` reports when it is the same architecture:
+    ARM's own GCC is `arm-none-linux-gnueabihf`, and Clang finds its libraries only under that
+    name;
+  - `-print-prog-name=as` returning a bare `as` means GCC found no assembler for its target and will
+    run the host's (`invalid -march= option`).
+- **Idempotence.** CMake reads a toolchain file again for every scope that needs it (`project()`,
+  each enabled language, `try_compile`), so everything here must be cheap and leave the same result
+  when repeated; flags appended to `*_FLAGS_INIT` are added only if absent.
+
+#### Cross builds and system libraries
+
+A cross compiler package ships the target's C/C++ runtime and nothing else, and a cross build looks only
+in the target's own root, never at the host's libraries (they are for the wrong architecture). So a
+dependency that needs another system library -- raylib's GLFW wants X11, others OpenGL or ALSA -- stops
+with `Could NOT find X11` even though the host has it. The fix is a **target sysroot**: a root filesystem
+for the target (`usr/include`, `usr/lib`, …) with those libraries installed.
+
+- **Where it is looked for.** `-DCMAKE_SYSROOT=<dir>` (also in a preset), else
+  `.cache/sysroots/linux-<arch>` (`linux-arm64`, `linux-arm32`, `linux-x64`) if that directory exists:
+  one per architecture, shared by the gcc and clang presets, so several cross presets build one after
+  another with no options. The configure prints `Target sysroot: …` or, when there is none,
+  `Cross build without a target sysroot …`; `breeze/scripts/build.sh` repeats the explanation when such a
+  configure fails on something not found. `.cache/sysroots/` is git-ignored.
+- **What it changes.** `--sysroot` for GCC and Clang; `find_package`/`find_library` search it before the
+  compiler's own root; qemu runs the result against it (`-L`) when it holds the target's dynamic loader;
+  pkg-config answers from its `.pc` files only (`PKG_CONFIG_SYSROOT_DIR`, `PKG_CONFIG_LIBDIR`, and
+  `PKG_CONFIG_PATH` dropped); a Debian-style `usr/lib/<triplet>` layout is found too.
+- **Before the first configure, or a fresh build directory after.** A build directory keeps what CMake
+  detected about the compiler the first time it was configured, so adding, changing or removing a
+  sysroot afterwards stops the configure and names the directory to delete
+  (`rm -rf out/build/<preset>`); `breeze/scripts/build.sh` says the same when a configure fails on a
+  missing library.
+- **Getting one.** Whatever gives you the target's own libraries and headers:
+  - *Copy it from the target*, with its `-dev` packages installed:
+    `rsync -aR pi@raspberrypi:/lib pi@raspberrypi:/usr/include pi@raspberrypi:/usr/lib .cache/sysroots/linux-arm64/`
+    (absolute symlinks that come along can be made relative with `symlinks -rc`).
+  - *Arch host:* the Arch Linux ARM root filesystem (archlinuxarm.org/about/downloads; check the
+    signature listed there), with the packages installed through qemu. For 32-bit ARM use the `armv7`
+    tarball and `linux-arm32`.
+    ```bash
+    sudo pacman -S --needed qemu-user-static qemu-user-static-binfmt arch-install-scripts libarchive
+    sudo systemctl restart systemd-binfmt
+    mkdir -p .cache/sysroots/linux-arm64
+    sudo bsdtar -xpf ArchLinuxARM-aarch64-latest.tar.gz -C .cache/sysroots/linux-arm64
+    sudo arch-chroot .cache/sysroots/linux-arm64 /bin/bash -c \
+      'pacman-key --init && pacman-key --populate archlinuxarm && pacman -Syu --noconfirm libx11 libxrandr libxinerama libxcursor libxi mesa'
+    ```
+  - *Debian or Ubuntu host:* `debootstrap --arch=arm64 --include=libx11-dev,libxrandr-dev,libxinerama-dev,libxcursor-dev,libxi-dev,libgl-dev <suite> .cache/sysroots/linux-arm64 <mirror>`
+    with `qemu-user-static` installed.
+- **Or build natively.** Run the build inside that same root filesystem under qemu (`arch-chroot`,
+  `chroot`) or on the device itself: an aarch64 machine takes the `linux-arm64-*` presets as native
+  builds, with no sysroot involved.
+- **If linking picks the wrong C library.** The sysroot's glibc is used, not the cross package's. A
+  sysroot much older than the cross compiler's own glibc can fail to link; update the sysroot.
+
+### macOS
+
+Apple's clang is one multi-architecture compiler, so building x86_64 on Apple Silicon, or the
+reverse, is an `-arch` flag, not a cross build: no sysroot, no emulator, `CMAKE_CROSSCOMPILING` stays
+off. `pmn_macos_toolchain` pins `CMAKE_OSX_ARCHITECTURES` explicitly, even when it equals the
+machine's (an x86_64 `cmake` under Rosetta would otherwise quietly build x86_64 for an arm64 target),
+and sets `CMAKE_OSX_DEPLOYMENT_TARGET` to 11.0 unless you pass another; Apple's libc++ marks newer
+library features (`std::format`, `std::pmr`, …) unavailable below the macOS that introduced them.
+Universal binaries are not a target: build both presets and `lipo -create` the results. Apple's
+clang (Command Line Tools) and LLVM's own, e.g. Homebrew's, both count as Clang; Homebrew's llvm is
+keg-only and is where `clang-tidy` comes from, so `breeze/scripts/refactor.sh` and the hook look in
+`/opt/homebrew/opt/llvm/bin` and `/usr/local/opt/llvm/bin` after `PATH`.
+
+### Windows
+
+- **MSVC** (`pmn_msvc_toolchain`) picks `cl`; its architecture comes from the developer environment it
+  runs in, not from CMake, so the architecture check is what notices the wrong prompt (a 32-bit-
+  targeting `cl` is reported with the fix). **clang-cl** picks `clang-cl` and pins
+  `--target=<arch>-pc-windows-msvc`. **MSYS2 Clang** (`pmn_msys_clang_toolchain`) picks `clang++`;
+  CLANG64 / CLANGARM64 decides its target. **MinGW** (`pmn_mingw_toolchain`) uses
+  `<triplet>-g++` (`x86_64-w64-mingw32`, `i686-w64-mingw32`), natively on Windows or as a cross build
+  from Linux, where `wine` runs the result.
+- **Checks.** For the presets that link against MSVC's runtime libraries (msvc and clang-cl),
+  `pmn_check_msvc_target` warns once, before CMake's compiler test fails on it, when the prompt's
+  `VSCMD_ARG_TGT_ARCH` names another target or `VCToolsInstallDir\lib\<arch>\msvcrt.lib` does not
+  exist, i.e. the target's Visual Studio component is not installed.
+- **Runtime.** MinGW executables use a dynamic GCC runtime whose DLLs are copied beside them (see
+  [Modules](#modules)).
+- **`wine` hosts.** On x64 Debian/Ubuntu `wine` needs `wine64` and `wine32:i386` (an i386 multiarch
+  that setup offers to enable); on Arch it lives in `multilib`, which setup offers to enable. Wine is
+  not offered on ARM64 hosts.
+
+#### Windows environments
+
+`breeze\scripts\build.bat` calls `breeze\scripts\_winenv.bat <preset>` right before configuring. The environment
+lives only in that run (`setlocal`); the user's own `cmake` is put back in front of `PATH`
+afterwards, because Visual Studio's environment adds its own, often older, one.
+
+| Presets | Environment entered |
+|---|---|
+| `windows-x64-msvc` `windows-arm64-msvc` | `vcvarsall.bat` of the newest Visual Studio or Build Tools that has the target's component, found with `vswhere` (the x86/x64 tools, plus the ARM64 tools for arm64, so an older Visual Studio that has them beats a newer one that doesn't), with `x64`, `x64_arm64`, `arm64` or `arm64_x64` according to the target and the machine (`x86_x64` and `x86_arm64` on 32-bit Windows). It then checks that `lib\<target>\msvcrt.lib` exists under `VCToolsInstallDir` and stops with the component to add if not: with the target's component missing, `vcvarsall` still reports the target and leaves the host's x64 `cl` on `PATH`, so neither its exit status nor `VSCMD_ARG_TGT_ARCH` is proof. |
+| `windows-x64-clang-cl` `windows-arm64-clang-cl` | The same, then `clang-cl` on `PATH` if absent: `Program Files\LLVM\bin`, else Visual Studio's own copy (`VC\Tools\Llvm\x64\bin`, `…\ARM64\bin`, `…\bin`). |
+| `windows-x64-mingw64` `windows-x86-mingw32` | `<MSYS2>\mingw64\bin` or `mingw32\bin` first on `PATH`, unless the preset's compiler is already on it. |
+| `windows-x64-clang` `windows-arm64-clang` | `<MSYS2>\clang64\bin` or `clangarm64\bin` first on `PATH`, always: a `clang++` from elsewhere targets another ABI. `clangarm64` exists only on ARM64 Windows; on x64 the helper says so and points at the cross-building presets. |
+
+`<MSYS2>` is `MSYS2_ROOT`, else `%SystemDrive%\msys64`. Left alone: a shell that already is a
+developer prompt for the right target (`VSCMD_ARG_TGT_ARCH` and `cl` on `PATH`), presets it doesn't
+know, and everything when `PMN_NO_ENV` is set. `vcvarsall` is judged by what it leaves behind, not
+by its exit status; a failure prints its output and the likely fix. The helper is flat batch on
+purpose (single-line `if` and `goto`, no parenthesized blocks), because the paths it expands contain
+`(x86)`.
+
+## Setup internals
+
+`breeze/scripts/setup.sh` and `setup.bat` run four steps: check and offer the tools, fetch the pinned
+Ninja, fetch the pinned Doxygen, activate the pre-commit hook (`git config core.hooksPath
+breeze/githooks`). A step that cannot finish (no pinned binary for this machine, no network) says so and
+the others still run.
+
+- **Catalog.** `_tools.sh` holds one row per tool: id, required or optional, label, what it is for
+  and the package for each manager. `_tools.ps1` holds the Windows equivalent. For each missing tool
+  setup says what it is for, shows the exact command and waits; required tools default to yes,
+  optional ones to no.
+- **Cross compilers must work, not merely exist.** An AArch64, 32-bit ARM or x86-64 cross compiler
+  counts as installed only if it compiles *and links* a small C++ program (which needs the target's
+  assembler, headers, libstdc++, crt1.o and libc). One that can't is reported as `[part]` with the
+  compiler's first error line and offered for repair. After an install the test runs again and, on a
+  failure, prints `-dumpmachine`, `-print-sysroot`, `-print-prog-name=as` and the installed
+  `<triplet>-*` packages.
+- **Consent.** Third-party extras (today only the AUR toolchain below) are never answered by `--all`
+  or by an earlier `a`: only `--everything` or a `y` typed at their own question.
+
+### What setup can install
+
+| Tool | apt | dnf | pacman | Homebrew |
+|---|---|---|---|---|
+| Git, CMake | `git` `cmake` | `git` `cmake` | `git` `cmake` | `git` `cmake` |
+| C++ compiler | `g++` | `gcc-c++` | `gcc` | Xcode Command Line Tools |
+| Clang | `clang` | `clang` | `clang` | Apple's, from the tools |
+| clang-format | `clang-format` | `clang-tools-extra` | `clang` | `clang-format` |
+| clang-tidy | `clang-tidy` | `clang-tools-extra` | `clang` | `llvm` |
+| AArch64 cross | `g++-aarch64-linux-gnu` | `aarch64-linux-gnu-{binutils,gcc,glibc}` (COPR) | `aarch64-linux-gnu-gcc` (x64 hosts) | — |
+| 32-bit ARM cross | `g++-arm-linux-gnueabihf` | `arm-linux-gnueabihf-{binutils,gcc,glibc}` (COPR) | AUR, below (x64 hosts) | — |
+| x86-64 cross | `g++-x86-64-linux-gnu` | — | — | — |
+| MinGW-w64 | `g++-mingw-w64-x86-64` `g++-mingw-w64-i686` | `mingw64-gcc-c++` `mingw32-gcc-c++` | `mingw-w64-gcc` | — |
+| qemu-user | `qemu-user` | `qemu-user` | `qemu-user` | — |
+| wine | `wine` `wine64` `wine32:i386` | `wine` | `wine` (multilib) | — |
+| Ninja | `ninja-build` | `ninja-build` | `ninja` | `ninja` |
+
+Ninja is only offered where no pinned download exists (32-bit ARM Linux). Fedora's own cross GCC
+packages ship no libstdc++, so on dnf the ARM compilers come from lantw44's COPR, enabled only after
+a separate confirmation. On Windows, setup uses winget for Git, CMake, Visual Studio 2022 Build
+Tools (C++ workload), LLVM and MSYS2; adds the "MSVC ARM64 build tools" component
+(`Microsoft.VisualStudio.Component.VC.Tools.ARM64`) to an existing Visual Studio through the
+Visual Studio Installer's `modify` command, which asks for administrator rights; and uses MSYS2's
+`pacman` for `mingw-w64-x86_64-gcc`,
+`mingw-w64-i686-gcc` and `mingw-w64-clang-x86_64-clang`; it can add the tools' folders to the user
+`PATH`. On macOS it runs `xcode-select --install` and, if you agree, Homebrew's installer.
+
+**32-bit ARM on Arch** has no official package. The AUR carries ARM's own prebuilt GNU toolchain
+(x86-64 hosts only) as four packages, `arm-linux-gnueabihf-{binutils,glibc-headers,glibc,gcc}-bin`.
+Setup builds each from its AUR repository with `makepkg` (sources are downloaded once into
+`~/.cache/pmn-aur-arm32/`) and installs all four in one transaction,
+`pacman -U --noconfirm --needed --ask 4`. `--ask 4` pre-answers yes to "X and Y are in conflict.
+Remove Y?" (pacman's default, and `--noconfirm`'s, is no); that is how a source-built binutils or
+glibc is replaced, and it applies to any conflicting package in the transaction, which the prompt says.
+Leftover `gcc-stage1` / `gcc-stage2` packages are removed first, and nothing is removed until all
+four have built. Installing `arm-linux-gnueabihf-gcc-bin` alone through an AUR helper does not work:
+its dependencies are generic names (`binutils`, `glibc`, `glibc-headers`), which a helper resolves
+to the source-built packages (hours of compiling), leaving ARM's prebuilt GCC beside a binutils and
+glibc that don't fit it.
+
+## Script internals
+
+- **Same options, two languages.** Each script is `.sh` (bash 3.2-compatible, macOS's default shell:
+  no `mapfile`, no bash-4 expansions, empty arrays guarded for `set -u`, BSD `sed` and `mktemp`) and
+  `.bat`. `_common.sh` holds what the `.sh` scripts share: reading config, resolving the build
+  directory, the Homebrew llvm lookup. `build.bat` additionally enters the compiler environment
+  ([Windows environments](#windows-environments)); the `.sh` scripts assume you are in the one you
+  need, which on Linux and macOS is every shell.
+- **Which build.** `--preset NAME` selects `out/build/NAME`, otherwise `BuildDir.cmake` picks the
+  directory recorded in `out/build/.last`, falling back to `default`. `build` records the directory
+  it used.
+- **`build`** prefers the pinned Ninja, then one on `PATH`, then CMake's default generator with a
+  warning. `cmd.exe` splits `%1`, `%2`, … on `=`, `,` and `;`, which would mangle `-DNAME=value`,
+  so `build.bat` takes the preset and build type off the front and forwards the rest from the
+  unsplit `%*`.
+- **`run`** finds the executable in `module_manifest-<CONFIG>.txt`, reads
+  `CMAKE_CROSSCOMPILING_EMULATOR` from the build's `CMakeCache.txt` and runs through it. Under
+  wine it sets `XDG_RUNTIME_DIR` and a private `WINEPREFIX` in `.cache/wine/` (`WINEARCH` for the
+  x86 and x64 targets); `run.bat` runs natively.
+- **`install`** runs `cmake --install --component <PROJECT_CODE_NAME>` into
+  `out/install/<DIST_TARGET>`.
+- **`refactor`** runs clang-format, then clang-tidy with `--fix`, over `source/` and `c-api/`.
+
+## Style and tooling
+
+`StyleGuide.md` has two parts: C++ (PascalCase and camelCase naming) and a C API surface
+(snake_case). Formatting (tabs, Allman braces, line length) comes from the single root
+`.clang-format`; naming from the root `.clang-tidy`, and `c-api/.clang-tidy` swaps in the C rules for
+files under `c-api/`. `.editorconfig` and `.gitattributes` keep editors and line endings in line
+(`.bat` and `.ps1` stay CRLF). The pre-commit hook runs clang-format and clang-tidy on staged C/C++
+files and skips with a warning when the tools are missing.
+
+## Embedding
+
+Used through `add_subdirectory`, the root project decides: `OUT_DIR` derives from the outermost
+`CMAKE_SOURCE_DIR`, and its toolchain and presets apply.
+
+## Verification status
+
+- **Linux and Windows presets, Arch x64:** the 32-bit ARM presets build with the prebuilt AUR
+  toolchain (reported by the maintainer). The Arch install and repair logic was also exercised
+  against stand-in `pacman`, `git`, `makepkg` and cross-compiler programs: broken compiler,
+  declined, `--all`, `--everything`, a failing build leaving the machine untouched.
+- **`_winenv.bat`:** exercised with an emulator of the batch subset it uses against a fake machine
+  (every preset, 32-bit, x64 and ARM64 hosts, already-correct prompts, an x64 machine without the
+  ARM64 tools, damaged installs, and each failure path). Its first run on a real `cmd.exe` is its
+  first test there.
+- **Toolchain checks in `_common.cmake`** (including `pmn_check_msvc_target`): written without a
+  CMake available to run them; the Arch 32-bit ARM configure was their first real run, and the
+  Windows ones are untested.
+- **Setup's ARM64 component row** (`Get-MsvcArm64Status`, `Install-MsvcComponent` in
+  `_tools.ps1`): written without PowerShell available; only bracket and quote balance were
+  checked.
+- **Target sysroots** (`pmn_find_sysroot`, `pmn_use_sysroot`, the explanation `breeze/scripts/build.sh` adds to a
+  failed cross configure): exercised on Linux x64 with CMake 3.28 and Ubuntu's cross compilers, against a
+  *stand-in* sysroot (the cross libc, real X11 headers, and empty stub libraries compiled for the target),
+  not against Arch Linux ARM or Raspberry Pi OS packages. arm64 and arm32, gcc and clang, found by
+  directory and by `-DCMAKE_SYSROOT`, flat and Debian-style multiarch layouts, pkg-config kept to the
+  sysroot, a sysroot without a loader, a missing one, a wrong one; a raylib 5.5 game built for arm64 stops
+  with `Could NOT find X11` without a sysroot and builds with one. The native x64 and MinGW presets were
+  rebuilt unchanged. The recipes above for *making* a sysroot (`rsync`, Arch Linux ARM, `debootstrap`) have
+  not been run, and neither a Mac nor Windows has run any of this; the new code is reached only by Linux
+  cross builds.
+- **The `breeze/` and `project/` layout:** the Linux side was exercised from the finished tree and
+  from the zip: the presets through the root file's `include` (and a project preset that inherits one),
+  native x64 gcc, arm64 gcc and clang and arm32 gcc with and without a sysroot, MinGW from Linux, a raylib
+  game for arm64, and `setup`, `build`, `run`, `install`, `docs`, `refactor`, the `cmake -P` queries and
+  the pre-commit hook; also replacing `breeze/` with a pristine copy, a `project/Configuration.cmake` that
+  lacks a setting, and a sysroot added or removed over an existing build directory. The changes to the
+  `.bat` and `.ps1` scripts are the moved paths and the `cd` to the root, nothing else (each changed line
+  was compared with the old file; CRLF endings are intact); nothing was run on Windows or on a Mac.
+- **Objects modules:** built and run on Linux with gcc and clang for x64, arm64 and arm32 (the ARM ones
+  under qemu), and with MinGW from Linux (built and linked; the DLL exports the pieces' symbols, nothing
+  was run). A scratch tree covered pieces three deep, pieces behind a static library, a static and a
+  shared library, an executable, a test and an example taking pieces, consumers discovered before their
+  pieces, a raw library name in `DEPENDS`, and a cycle. Each piece appears once in the archive and on the
+  link line. Not run: MSVC and macOS. For MSVC, CMake's own generator source shows the absorbed objects
+  feeding the `.def` file that `WINDOWS_EXPORT_ALL_SYMBOLS` produces, so the DLL should export them; that
+  is a reading, not a run.
+- **A dependency declared by one module and used by another** (`fmt::fmt`, declared in `source/Core`,
+  used by `source/CoreFarewell`): built with fmt 12.1.0 installed (static and shared) and not installed,
+  with CMake 3.25.2, 3.27.9, 3.28.3, 3.31.6 and 4.1.2, plus a module that CMake reaches before the one
+  that declares it. Cross builds ignore the host's copy and fetch one for the target.
+- **macOS:** the toolchain, `TargetSelection.cmake`'s detection and the RPATH translation were
+  exercised by cross-compiling to Mach-O from Linux and reading the load commands (`LC_RPATH
+  @loader_path`, `@rpath/libdemo_core.dylib`, arm64 and x86_64); the scripts ran under a real bash
+  3.2. No Mac has run Apple's own clang and SDK yet, so look there first if something is off.
diff --git a/breeze/StyleGuide.md b/breeze/StyleGuide.md
new file mode 100644
index 0000000..386590d
--- /dev/null
+++ b/breeze/StyleGuide.md
@@ -0,0 +1,748 @@
+# C/C++ Coding Style Guide
+
+This guide is split into two parts:
+
+- **[Part I: C++ Style](#part-i-c-style)** applies to all internal application/library code written in C++.
+- **[Part II: C API Style](#part-ii-c-api-style)** applies specifically to public API surfaces exposed as plain C (`extern "C"`, `.h` headers) — e.g. for dynamic library boundaries, plugin interfaces, or C-consumer compatibility. Keep these two worlds separate: don't let C-API constraints (no exceptions, no classes, `snake_case`) leak into internal C++ code, and don't let C++ constructs leak into a public C API.
+
+## Contents
+
+**[Part I: C++ Style](#part-i-c-style)**
+1. [Naming Conventions](#1-naming-conventions)
+2. [Indentation](#2-indentation)
+3. [Brace Placement (Allman Style)](#3-brace-placement-allman-style)
+4. [Pointers and References](#4-pointers-and-references)
+5. [Spacing](#5-spacing)
+6. [Header Files](#6-header-files)
+   - [Namespaces](#namespaces)
+   - [Headers as Public API: Keep Implementation Types Out](#headers-as-public-api-keep-implementation-types-out)
+   - [Templates](#templates)
+     - [Implementing Templates (Project Standard)](#implementing-templates-project-standard)
+   - [Class Member Organization](#class-member-organization)
+7. [Include Directive Order](#7-include-directive-order)
+8. [Line Length](#8-line-length)
+9. [Comments](#9-comments)
+10. [Language Feature Do's and Don'ts](#10-language-feature-dos-and-donts)
+    - [Memory and Ownership](#memory-and-ownership)
+    - [Error Handling](#error-handling)
+    - [Modern C++ Features](#modern-c-features)
+11. [Library Linking and Runtime Loading](#11-library-linking-and-runtime-loading)
+    - [Static Linking](#static-linking)
+    - [Dynamic Linking (Shared Libraries)](#dynamic-linking-shared-libraries)
+    - [Runtime Loading (dlopen and LoadLibrary)](#runtime-loading-dlopen-and-loadlibrary)
+    - [Summary](#summary)
+12. [Miscellaneous](#12-miscellaneous)
+
+**[Part II: C API Style](#part-ii-c-api-style)**
+13. [Naming Conventions (C API)](#13-naming-conventions-c-api)
+14. [File Extensions and Structure](#14-file-extensions-and-structure)
+15. [Indentation and Braces](#15-indentation-and-braces)
+16. [API Design Do's and Don'ts](#16-api-design-dos-and-donts)
+17. [Boundary Rule of Thumb](#17-boundary-rule-of-thumb)
+
+---
+
+# Part I: C++ Style
+
+## 1. Naming Conventions
+
+| Symbol Type            | Convention        | Example                          |
+|-------------------------|-------------------|-----------------------------------|
+| Classes / Structs        | `PascalCase`       | `class NetworkManager;`          |
+| Functions / Methods       | `camelCase`        | `void connectToServer();`         |
+| Local Variables            | `camelCase`         | `int retryCount = 0;`              |
+| Member Variables (private/protected) | `camelCase` with `m_` prefix | `int m_connectionTimeout;` |
+| Static Member Variables (class-scope `static`) | `camelCase` with `s_` prefix | `static int s_instanceCount;` |
+| Global Variables (namespace/file scope, mutable) | `camelCase` with `g_` prefix | `int g_activeConnectionCount;` |
+| Static Variables (function-local or file-scope `static`) | `camelCase` with `s_` prefix | `static int s_retryAttempts;` |
+| Constants                | `PascalCase`        | `constexpr int MaxRetries = 5;`   |
+| Enum Type Names            | `PascalCase`        | `enum class ConnectionState`      |
+| Enum Values                 | `PascalCase`         | `ConnectionState::Connected`       |
+| Namespaces                | `snake_case`        | `namespace network_utils`          |
+| Template Parameters       | `PascalCase`         | `template <typename ValueType>`   |
+| Macros                     | `ALL_CAPS_SNAKE_CASE` | `#define MAX_BUFFER_SIZE 1024`   |
+| File Names                 | `PascalCase`         | `NetworkManager.cpp` / `.hpp`     |
+
+> **Note:** Macros are an exception to the general PascalCase/camelCase scheme since `ALL_CAPS` is the near-universal C/C++ convention and helps macros stand out visually from regular code.
+
+> **Note:** `g_`/`s_` mark *mutable* global/static state specifically so it stands out at every use site — genuinely global mutable variables are rare and worth flagging by name. A `constexpr` or `const` global/static value is a **constant**, not a variable for this rule's purposes: it keeps the `PascalCase` constant convention above, with no `g_`/`s_` prefix, since it can't cause the aliasing/lifetime bugs the prefix exists to call out (e.g. `constexpr int MaxRetries = 5;` at namespace scope, not `g_MaxRetries`). A `static` variable inside a function keeps `s_` for the same reason as a file-scope one — both persist across calls and are exactly the kind of hidden state the prefix is meant to surface.
+
+---
+
+## 2. Indentation
+
+- Use **tabs** for indentation (not spaces).
+- Do not mix tabs and spaces.
+- Configure your editor's tab width to display consistently (recommended: 4 columns wide) across the team.
+- **Namespace bodies are indented**, exactly like any other block (`if`, `class`, `for`, ...) — a namespace is not a special case left flush against the margin. See [Namespaces](#namespaces) for the full rule and examples.
+
+```cpp
+void doSomething()
+{
+	if (condition)
+	{
+		performAction();
+	}
+}
+```
+
+---
+
+## 3. Brace Placement (Allman Style)
+
+Braces always go on their **own new line**, aligned with the statement that opens the block.
+
+```cpp
+// Correct (Allman)
+if (isReady)
+{
+	start();
+}
+else
+{
+	waitForReady();
+}
+
+class Widget
+{
+public:
+	Widget();
+	~Widget();
+};
+
+void process()
+{
+	for (int i = 0; i < count; ++i)
+	{
+		handle(i);
+	}
+}
+```
+
+```cpp
+// Incorrect (K&R style — do not use)
+if (isReady) {
+	start();
+}
+```
+
+---
+
+## 4. Pointers and References
+
+Attach `*` and `&` to the **type**, not the variable name.
+
+```cpp
+int* pointerToValue;
+const std::string& nameRef;
+
+void processData(const Data* data, int& outResult);
+```
+
+---
+
+## 5. Spacing
+
+- One space around binary operators: `a + b`, `x == y`.
+- No space between a function name and its parentheses: `doWork()`, not `doWork ()`.
+- One space after control-flow keywords: `if (`, `for (`, `while (`.
+
+```cpp
+if (a == b)
+{
+	total = a + b * c;
+}
+```
+
+---
+
+## 6. Header Files
+
+- Use `#pragma once` at the top of every header.
+- **`.hpp` for C++ headers, `.h` for C headers.** Any header containing C++-only constructs (classes, templates, namespaces, overloads, `enum class`, etc.) uses `.hpp`. Reserve `.h` for headers meant to be valid C — see [Part II: C API Style](#part-ii-c-api-style) for the public C API convention.
+- **One `.cpp` per `.hpp`.** Each header declaring a class or module has exactly one corresponding source file implementing it, sharing the same base name (`NetworkManager.hpp` ↔ `NetworkManager.cpp`). Avoid dumping multiple unrelated classes' implementations into one `.cpp`, and avoid splitting one class's implementation across multiple `.cpp` files.
+- **One class, struct, or enum per header — meaning one *publicly usable* type.** Each `.hpp` exposes exactly one type as part of its public API: the primary class/struct/enum a caller `#include`s the header to use. A header should never declare two independent, separately-usable types (e.g. `NetworkManager` and an unrelated `RetryPolicy`) side by side — each gets its own `.hpp`. This is what prevents the dependency problem: a file that only needs `RetryPolicy` should never be forced to also compile/depend on everything `NetworkManager` pulls in. Small types that have no meaning or use *outside* the primary type — a nested `enum class` used only as one of its parameters, a tag type only passed to its constructor — aren't "separate" types for this rule; they're part of the primary type's interface and stay in the same header.
+- Header-only components (templates, small inline utilities) are the exception to the one-`.cpp`-per-`.hpp` rule — they may have a `.hpp` with no matching `.cpp` — but the one-type-per-header rule still applies to them (see [Templates](#templates) below).
+- Match header/source file names to the primary class (`PascalCase`), e.g. `NetworkManager.hpp` / `NetworkManager.cpp` for `class NetworkManager`.
+- **Do not add a trailing comment on a closing brace** (`}; // class NetworkManager`, `} // namespace network_utils`, `} // if (isReady)`, etc.), for namespaces, classes, functions, or any other block. Keep blocks short and readable enough that the comment isn't needed — if a block is too long to tell what its closing brace belongs to at a glance, the fix is to shorten or restructure the block, not to annotate the brace.
+
+```cpp
+// NetworkManager.hpp
+#pragma once
+
+namespace network_utils
+{
+	class NetworkManager
+	{
+	public:
+		NetworkManager();
+		~NetworkManager();
+
+		void connectToServer();
+
+	private:
+		int m_connectionTimeout;
+	};
+}
+```
+
+### Namespaces
+
+- **Namespace contents are indented**, exactly like the body of any other block. Don't leave everything inside a namespace flush against the left margin just because the namespace itself doesn't "do" anything at runtime — indentation is what makes nesting depth obvious at a glance, and a namespace is nesting.
+- **Use the C++17 nested-namespace syntax (`namespace outer::inner { ... }`) instead of manually nesting namespace blocks**, whenever you're declaring a fixed, known multi-level namespace (e.g. `network_utils::detail`). Manually nesting `namespace network_utils { namespace detail { ... } }` for a case like this just adds an extra level of indentation and an extra closing brace for no benefit.
+- The one case that still requires manual nesting: wrapping an **anonymous** namespace inside a named one (e.g. hiding a `.cpp`-local helper type inside `network_utils`) — anonymous namespaces have no name, so there's nothing to join with `::`.
+
+```cpp
+// Preferred — a fixed multi-level namespace uses the single nested-namespace form
+namespace network_utils::detail
+{
+	struct RetryState
+	{
+		int attemptCount;
+		int backoffMs;
+	};
+}
+```
+
+```cpp
+// Avoid — manually nesting two named namespaces that could be joined with ::
+namespace network_utils
+{
+	namespace detail
+	{
+		struct RetryState
+		{
+			int attemptCount;
+			int backoffMs;
+		};
+	}
+}
+```
+
+### Headers as Public API: Keep Implementation Types Out
+
+Treat every header as a **public interface contract**, not a scratchpad for whatever the implementation happens to need. A caller including `NetworkManager.hpp` should see only what they need to *use* `NetworkManager` — not the types that exist purely to help `NetworkManager.cpp` implement it internally.
+
+- **Implementation-only helper types belong in the `.cpp`, not the `.hpp`.** If a class needs a small helper struct, enum, or class that callers never see or interact with (a parser's internal token type, a lookup-table entry, a strategy object used only inside one function), define it in the `.cpp` file, wrapped in an unnamed (anonymous) namespace so it has internal linkage and can't leak or collide across translation units:
+
+```cpp
+// NetworkManager.cpp
+#include "NetworkManager.hpp"
+
+namespace network_utils
+{
+	namespace
+	{
+		// Implementation detail — never appears in the header, never used outside this file.
+		struct RetryState
+		{
+			int attemptCount;
+			int backoffMs;
+		};
+	}
+
+	void NetworkManager::connectToServer()
+	{
+		RetryState state{0, 100};
+		// ...
+	}
+}
+```
+
+- **Forward-declare instead of including, whenever the header only needs a pointer or reference to another type.** This keeps the header's dependency footprint to exactly the API surface it exposes, rather than transitively dragging in every header its implementation happens to use.
+
+```cpp
+// NetworkManager.hpp
+#pragma once
+
+namespace network_utils
+{
+	class Socket; // forward declaration — full definition only needed in NetworkManager.cpp
+
+	class NetworkManager
+	{
+	public:
+		void connectToServer();
+
+	private:
+		Socket* m_socket;
+	};
+}
+```
+
+- **One real C++ constraint to know:** a class's *own* private member variables (as opposed to helper types) generally must still be declared in the header, because C++ needs the complete type — including all members — to know the class's size and layout wherever it's used by value, on the stack, or as a direct member of another class. This is different from hiding a *helper type*; you're not hiding the fact that `NetworkManager` has a timeout, only hiding the definition of an unrelated struct it happens to use internally.
+- If you need to hide private *members* too — for a stable ABI across a shared-library boundary (see [Library Linking and Runtime Loading](#11-library-linking-and-runtime-loading)) or to shrink recompiles when private internals change — the standard technique is the **Pimpl idiom** (pointer to implementation): the header holds only a forward-declared pointer, and the real member variables live in a struct defined entirely in the `.cpp`.
+
+```cpp
+// NetworkManager.hpp
+#pragma once
+#include <memory>
+
+namespace network_utils
+{
+	class NetworkManager
+	{
+	public:
+		NetworkManager();
+		~NetworkManager();
+
+		void connectToServer();
+
+	private:
+		struct Impl;               // forward-declared, defined only in NetworkManager.cpp
+		std::unique_ptr<Impl> m_impl;
+	};
+}
+```
+
+```cpp
+// NetworkManager.cpp
+#include "NetworkManager.hpp"
+
+namespace network_utils
+{
+	struct NetworkManager::Impl
+	{
+		int connectionTimeout;
+	};
+
+	NetworkManager::NetworkManager() : m_impl(std::make_unique<Impl>()) {}
+	NetworkManager::~NetworkManager() = default;
+
+	void NetworkManager::connectToServer()
+	{
+		// use m_impl->connectionTimeout
+	}
+}
+```
+
+  Pimpl isn't required for every class — it adds an extra pointer indirection and a heap allocation, so reserve it for types where header-hiding genuinely matters (public library API, ABI-sensitive dynamic-library boundaries, or classes whose private internals churn often enough that reducing rebuild fan-out is worth the cost). For ordinary internal application classes, plain private members in the header (as in the example at the top of this section) are fine — only the *helper types*, not the members themselves, need to move out.
+
+### Templates
+
+Templates are *more* exposed to the one-type-per-header problem than ordinary classes, for two structural reasons specific to how templates compile:
+
+1. **No compiled-`.cpp` firewall.** An ordinary class hides its implementation behind a `.cpp` — callers only need the declaration to link against it. A template has no such firewall: the compiler needs the *full definition* everywhere it's instantiated, so templates live entirely in headers (see the exception to "one `.cpp` per `.hpp`" in [Header Files](#6-header-files)). That means anything sharing a header with a template gets pulled into every translation unit that only wanted that one template.
+2. **Parsing cost applies even to unused templates.** Bundling `template <typename T> class Cache` and `template <typename T> class Pool` in the same header means a file that only uses `Cache` still has to parse `Pool`'s full definition, and a change to `Pool` still bumps the header's timestamp — forcing a rebuild of every translation unit that includes it, including the ones that never touch `Pool` at all.
+
+Given that, the rules:
+
+- **One template class/function per header.** `Cache` and `Pool` each get their own `.hpp`, even if they're conceptually related utilities that usually get used together.
+- **Keep a template's declaration and inline implementation in the same `.hpp`** — templates generally can't be split into a separate `.cpp` the way non-template code can (see reason 1 above) — but that's not license to merge *other*, unrelated templates into the same file alongside it.
+- **If several templates genuinely share implementation details** (a common traits struct, a shared constant), factor *only that shared piece* into its own single-purpose header, rather than merging the templates themselves into one file. If the shared piece belongs in a nested namespace (e.g. an internal `detail` namespace not meant for outside use), declare it with the `::` nested-namespace syntax from [Namespaces](#namespaces).
+- **Avoid including heavy headers** (e.g. `<iostream>`, large third-party headers) inside a widely-used template header purely for convenience — because template headers are included wherever they're instantiated, an unnecessary include here silently bloats compile times project-wide, multiplied across every instantiation site.
+
+```cpp
+// Avoid — two unrelated templates sharing one header
+// Cache.hpp
+#pragma once
+
+namespace storage
+{
+	template <typename Key, typename Value>
+	class Cache
+	{
+	public:
+		void insert(const Key& key, const Value& value);
+		const Value* find(const Key& key) const;
+	};
+
+	template <typename T>
+	class Pool
+	{
+	public:
+		T* acquire();
+		void release(T* item);
+	};
+}
+```
+
+```cpp
+// Preferred — one template per header
+// Cache.hpp
+#pragma once
+
+namespace storage
+{
+	template <typename Key, typename Value>
+	class Cache
+	{
+	public:
+		void insert(const Key& key, const Value& value);
+		const Value* find(const Key& key) const;
+	};
+}
+```
+
+```cpp
+// Pool.hpp — separate file, included only where Pool is actually needed
+#pragma once
+
+namespace storage
+{
+	template <typename T>
+	class Pool
+	{
+	public:
+		T* acquire();
+		void release(T* item);
+	};
+}
+```
+
+If `Cache` and `Pool` both rely on the same internal helper — say, a fixed-capacity ring buffer trait — that shared piece moves to its own header, in an internal namespace declared with `::`:
+
+```cpp
+// DetailTraits.hpp — included by both Cache.hpp and Pool.hpp, nothing else
+#pragma once
+
+namespace storage::detail
+{
+	template <typename T, std::size_t Capacity>
+	struct RingBufferTraits
+	{
+		using ValueType = T;
+		static constexpr std::size_t capacity = Capacity;
+	};
+}
+```
+
+#### Implementing Templates (Project Standard)
+
+Templates are the one exception to this guide's header-declares/`.cpp`-implements split: the compiler needs a template's *complete definition* at every point it gets instantiated, and a separately-compiled `.cpp` can't supply that. So the implementation has to live in the header — but to keep this consistent across the codebase rather than a per-template judgment call, **this project uses one standard pattern**:
+
+> **Declare template members in the class body, and define them out-of-line further down in the same header** — the same shape as an out-of-line member definition of a non-template class, just kept in the `.hpp` instead of moved to a `.cpp`.
+
+```cpp
+// Cache.hpp
+#pragma once
+
+namespace storage
+{
+	template <typename Key, typename Value>
+	class Cache
+	{
+	public:
+		void insert(const Key& key, const Value& value);
+		const Value* find(const Key& key) const;
+
+	private:
+		std::unordered_map<Key, Value> m_entries;
+	};
+
+	template <typename Key, typename Value>
+	void Cache<Key, Value>::insert(const Key& key, const Value& value)
+	{
+		m_entries[key] = value;
+	}
+
+	template <typename Key, typename Value>
+	const Value* Cache<Key, Value>::find(const Key& key) const
+	{
+		auto it = m_entries.find(key);
+		return it != m_entries.end() ? &it->second : nullptr;
+	}
+}
+```
+
+- **Exception:** a genuinely trivial one-line body (a plain getter, a one-expression forwarding call) can stay inline in the class, same as it would for a non-template class. Don't force it out-of-line just for consistency's sake.
+- **Escape hatch, not a pattern:** if a template is only ever meant to be used with a small, fixed set of types, its definitions *can* move to a `.cpp` via explicit instantiation (`template class Cache<int, std::string>;`). This is a deliberate, rare trade-off — it turns a general-purpose template into one that only supports the explicitly instantiated types — and should be a documented exception with a stated reason (e.g. reducing header bloat for a widely-included, ABI-sensitive type), not the default way templates get written.
+
+> **See also:** [Library Linking and Runtime Loading](#11-library-linking-and-runtime-loading) — the Pimpl idiom above exists mainly to satisfy the ABI constraints described there · [Part II: C API Style](#part-ii-c-api-style) — the `.h`/`.hpp` split introduced here is defined in full there.
+
+### Class Member Organization
+
+- **Member order: `public`, then `protected`, then `private`.** Group each access level together, in that order. The widest audience — everyone who includes the header — reads what's relevant to them (the public interface) first, without wading through implementation details to find it. Don't reopen an access specifier further down "for organization"; interleaving defeats the ordering rule's purpose.
+- **Avoid inline member function definitions in the class body.** Declare the member in the class; define its body separately — out-of-line in the matching `.cpp` for an ordinary class (see the `NetworkManager` example in [Header Files](#6-header-files) above), or out-of-line further down the same header for a template member (see [Implementing Templates](#implementing-templates-project-standard) above). This keeps the class body itself a clean, scannable interface instead of a mix of signatures and implementation.
+  - **Exception:** a genuinely trivial one-line body (a plain getter, a one-expression forwarding call) may stay inline in the class — the same exception already noted for templates above.
+- **Inline template members go at the bottom of their access section.** When a class mixes ordinary members with template members that use the trivial-one-liner exception just above, keep the plain declarations together at the top of each `public`/`protected`/`private` block, and place the inline template members after them, at the bottom of that same block — not interleaved. A reader scanning the interface sees the plain signatures first; the inline implementation detail comes last, where it doesn't interrupt that scan.
+
+```cpp
+class NetworkManager
+{
+public:
+	NetworkManager();
+	~NetworkManager();
+
+	void connectToServer();
+	bool isConnected() const;
+
+	// Inline template member (trivial-one-liner exception, see Templates
+	// above) -- kept at the bottom of this access section rather than
+	// interleaved with the plain declarations above.
+	template <typename T> T configValue() const { return static_cast<T>(m_connectionTimeout); }
+
+protected:
+	virtual void onDisconnected();
+
+private:
+	int m_connectionTimeout;
+};
+```
+
+None of this is mechanically enforced — `readability-redundant-inline-specifier` (see `.clang-tidy`) catches one narrow related mistake (a redundant explicit `inline` keyword) but not the member-order or inline-body rules themselves.
+
+---
+
+## 7. Include Directive Order
+
+Group includes into blocks, separated by a blank line, in the following order. Within each block, sort alphabetically.
+
+1. **Corresponding header** — for a `.cpp`, its own `.hpp` comes first (catches missing-include bugs in the header itself).
+2. **C system headers** — `<cstdio>`, `<cstdlib>`, etc.
+3. **C++ standard library headers** — `<vector>`, `<memory>`, `<string>`, etc.
+4. **Third-party / external library headers** — e.g. `<boost/...>`, `<fmt/...>`.
+5. **Project headers** — other headers from this codebase, using quoted includes (`"..."`).
+
+```cpp
+// NetworkManager.cpp
+#include "NetworkManager.hpp"   // 1. corresponding header
+
+#include <cstdint>               // 2. C system headers
+
+#include <memory>                // 3. C++ standard library
+#include <string>
+#include <vector>
+
+#include <fmt/format.h>          // 4. third-party libraries
+
+#include "Logger.hpp"            // 5. project headers
+#include "SocketWrapper.hpp"
+```
+
+- Use angle brackets `<...>` for system, standard library, and third-party headers.
+- Use quotes `"..."` for project-local headers.
+- This ordering guarantees each header can be compiled standalone (no hidden dependency on something included before it) and makes missing includes fail fast in CI rather than silently compiling due to include order in some other file.
+
+---
+
+## 8. Line Length
+
+- Prefer a maximum of **100 characters** per line.
+- **Do not wrap parameters onto their own line.** Keep a function's parameter list together — on the declaration line if it fits, otherwise packed as tightly as the line allows on a continuation line. Never lay parameters out one per line; that turns a short signature into a tall list a reader has to scroll past to see the return type and name.
+  - `clang-format` enforces the "never one-per-line" part. It can't force a genuinely long signature to fit within 100 characters without wrapping at all — that would need line length limits disabled project-wide, which would also stop ordinary long expressions and comments from ever wrapping, so it isn't done. If a signature is long enough that even packing parameters together still overflows, let it overflow rather than reach for one-per-line as the fallback.
+
+---
+
+## 9. Comments
+
+- **Document symbols with Doxygen-style comments, never a plain `//`.** Any comment documenting a function, class, struct, enum, member variable, or macro — explaining what it *is* or *does*, as opposed to annotating a line of implementation — uses `///` or `/** ... */`. This is what makes the project's generated documentation (see the Doxygen integration) actually useful instead of a bare list of undocumented signatures.
+- **`///` for most documentation; `/** ... */` for longer, multi-paragraph explanations.** Both are valid Doxygen syntax — pick based on length, not per-file preference.
+- **Plain `//` is still correct for everything that isn't documenting a symbol** — a note on a tricky line inside a function body, a `// TODO`, a block disabled during debugging. The rule above is about comments attached to a declaration, not every comment everywhere.
+
+```cpp
+/// Establishes a connection to the configured server.
+/// @return true if the connection succeeded.
+bool connectToServer();
+```
+
+```cpp
+/**
+ * Parses and validates a server configuration blob.
+ *
+ * Accepts either JSON or the legacy INI format; the format is
+ * auto-detected from the first non-whitespace byte.
+ *
+ * @param raw  the raw configuration bytes, in either supported format.
+ * @return     a parsed Config, or std::nullopt if raw is malformed.
+ */
+std::optional<Config> parseConfig(std::string_view raw);
+```
+
+---
+
+## 10. Language Feature Do's and Don'ts
+
+### Memory and Ownership
+
+| Do | Don't |
+|----|-------|
+| Use `std::unique_ptr` / `std::shared_ptr` for owning dynamic objects | Use raw `new` / `delete` for ownership |
+| Use raw pointers or references for **non-owning** access | Use a raw pointer to express or transfer ownership |
+| Use `std::make_unique` / `std::make_shared` to construct smart pointers | Construct a smart pointer with `new` directly (`std::unique_ptr<T>(new T())`) |
+| Follow RAII for all resources (files, locks, sockets, etc.) | Manually pair acquire/release calls |
+
+### Error Handling
+
+| Do | Don't |
+|----|-------|
+| Throw exceptions for **true exceptional situations** (unrecoverable errors, invariant violations, constructor failures) | Use exceptions for expected/recoverable control flow (e.g. "value not found") |
+| Use return values (`bool`, `std::optional`, error codes, `std::expected` where available) for expected failure cases | Use exceptions as a substitute for normal branching logic |
+| Catch exceptions by `const&` | Catch exceptions by value (causes slicing) |
+| Keep destructors `noexcept` (the default) | Let exceptions escape a destructor |
+
+### Modern C++ Features
+
+| Do | Don't |
+|----|-------|
+| Use `auto` when it improves readability (iterators, lambdas, long template types) | Use `auto` when it hides an important or non-obvious type |
+| Use range-based `for` loops over index-based loops when the index isn't needed | Write manual index loops just to iterate a container |
+| Use lambdas for short, local callbacks and algorithm predicates | Write a named functor class for a one-off, trivial operation |
+| Use structured bindings for multi-value returns (`auto [key, value] = ...`) | Unpack pairs/tuples manually with `.first` / `.second` when structured bindings are clearer |
+| Use `constexpr` / `consteval` for compile-time constants and computations | Use `#define` macros for constants |
+| Use `enum class` over plain `enum` | Use unscoped `enum` (pollutes namespace, weak typing) |
+| Use `override` and `final` explicitly on overriding virtual functions | Omit `override`, relying on the compiler to catch signature mismatches |
+| Use `nullptr` | Use `NULL` or `0` for pointers |
+| Prefer `std::array` / `std::vector` over C-style arrays | Use raw C-style arrays for anything beyond fixed, tiny buffers |
+| Pass small, cheap-to-copy types by value; pass large objects by `const&` | Pass large objects by value out of habit |
+| Use `std::string_view` for read-only, non-owning string parameters | Take `const std::string&` when the caller may pass a string literal or substring |
+
+---
+
+## 11. Library Linking and Runtime Loading
+
+How a component is built and linked shapes how strictly some of the above rules should be enforced.
+
+### Static Linking
+
+- Libraries are compiled directly into the final binary at build time.
+- Header/implementation split still matters for compile-time isolation, but ABI stability across the boundary is **not** a concern — the whole binary is rebuilt together.
+- Inline-heavy, template-heavy, and header-only code (common with `auto`, templates, `constexpr`) is safe here since everything resolves at compile time in one binary.
+
+### Dynamic Linking (Shared Libraries)
+
+- Applies to `.so` (Linux), `.dll` (Windows), and `.dylib` (macOS) targets.
+- The public headers exposed across a shared-library boundary form an **ABI contract** — style choices here have real consequences:
+  - Avoid exposing `inline` functions, templates, or `constexpr` values in the public API surface if the library and its consumers may be compiled by different compilers/versions — inlined code bakes assumptions into the caller.
+  - Avoid changing the layout of any `class`/`struct` exposed across the boundary (adding/reordering member variables) without a version bump — it breaks binary compatibility for already-compiled consumers.
+  - Prefer exposing a stable, minimal interface at the boundary (see [Part II: C API Style](#part-ii-c-api-style)), and keep the `PascalCase` classes with full modern C++ usage as **internal implementation detail** behind it.
+  - Mark exported symbols explicitly (e.g. `__declspec(dllexport)` / `__attribute__((visibility("default")))`), and keep everything else hidden by default, to keep the ABI surface intentional and small.
+
+### Runtime Loading (dlopen and LoadLibrary)
+
+- Any function loaded dynamically at runtime **must** be declared with C linkage (`extern "C"`) to avoid name-mangling issues — this is exactly the case [Part II: C API Style](#part-ii-c-api-style) exists for, even in an otherwise all-`.hpp` C++ codebase.
+- Keep the loaded interface as a plain function-pointer table or `extern "C"` API — no classes, no exceptions crossing the boundary (an exception thrown from a plugin loaded via `dlopen` and caught in the host app is undefined behavior across incompatible runtimes/compilers).
+- Document plugin/module boundaries clearly with `.hpp` interface headers describing the contract, even though the actual crossing point is a plain C-style vtable or function table.
+
+### Summary
+
+| Context | Modern C++ features across the boundary | ABI stability required |
+|---|---|---|
+| Static link | Freely (templates, `auto`, inline, `constexpr`) | No — whole program rebuilt together |
+| Dynamic link (`.so`/`.dll`) | Restrict at the public boundary; free internally | Yes — layout & symbol changes are breaking |
+| Runtime load (`dlopen`) | `extern "C"` only at the boundary ([Part II](#part-ii-c-api-style) style) | Yes — plus no exceptions/classes across it |
+
+> **See also:** [Boundary Rule of Thumb](#17-boundary-rule-of-thumb) — decides, file by file, whether a piece of code follows this section or Part II · [Part II: C API Style](#part-ii-c-api-style) — the actual convention referenced throughout this section.
+
+---
+
+## 12. Miscellaneous
+
+- Mark single-argument constructors `explicit` unless implicit conversion is intended.
+- Prefer `const` correctness everywhere it applies.
+- **Leave a blank line after an early exit** — a `return`, `break`, or `continue` statement, or a block whose last statement is one of these — whenever more code follows at that same level. It visually marks where the early-exit path ends and the normal-case code begins. Skip the blank line if the statement (or its block) is the last thing in its own enclosing function or loop; there's nothing after it to separate from.
+  - Not enforced by `clang-format` or `clang-tidy` — neither has a check for this. It's a code-review convention.
+
+```cpp
+void process(const std::vector<int>& values)
+{
+	if (values.empty())
+	{
+		return;
+	}
+
+	for (int value : values)
+	{
+		accumulate(value);
+	}
+}
+```
+
+---
+
+# Part II: C API Style
+
+This section governs any code written as **plain C**, or any `extern "C"` surface exposed *from* a C++ library for consumption by C callers, dynamic loaders (`dlopen`), or other languages via FFI. Nothing in this section applies to internal C++ implementation — only to the boundary itself and to files that are genuinely compiled as C.
+
+## 13. Naming Conventions (C API)
+
+| Symbol Type            | Convention           | Example                              |
+|-------------------------|----------------------|----------------------------------------|
+| Public API functions     | `snake_case` with library prefix | `net_manager_connect(NetManager* mgr);` |
+| Types (`struct`/`enum`/typedef) | `PascalCase` with library prefix, `_t` suffix optional | `NetManagerT` or `NetManager` |
+| Struct fields             | `snake_case`          | `int connection_timeout;`             |
+| Function parameters        | `snake_case`           | `int retry_count`                      |
+| Constants / `#define`        | `ALL_CAPS_SNAKE_CASE` with library prefix | `#define NET_MAX_RETRIES 5`         |
+| Enum values                  | `ALL_CAPS_SNAKE_CASE` with library + enum prefix | `NET_STATE_CONNECTED`             |
+| Internal global variables (translation-unit-visible, mutable) | `g_snake_case` | `int g_active_connection_count;` |
+| Static variables (function-local or file-scope `static`) | `s_snake_case` | `static int s_retry_attempts;` |
+| File names                    | `snake_case`            | `net_manager.h` / `net_manager.c`      |
+
+- Every public symbol (function, type, macro, enum value) is **prefixed with the library/module name** to avoid collisions in the global C symbol namespace, since C has no namespaces.
+- `snake_case` is used throughout the C API — this is a deliberate departure from the `camelCase`/`PascalCase` used in Part I, and is one of the clearest visual signals that a symbol belongs to the C boundary rather than internal C++.
+- The `g_`/`s_` prefixes are for **internal, non-exported** state — the kind of file-scope `static` variable that never appears in a public header. A genuinely public global exported from the API surface is unusual enough that it should get the full library prefix instead (`net_manager_default_timeout`, not `g_net_manager_default_timeout`) — don't stack both prefixes on the same symbol.
+
+---
+
+## 14. File Extensions and Structure
+
+- **`.h`** for all public C API headers — must be valid to include from both C and C++ translation units.
+- **`.c`** for files actually compiled as C. If the "C API" is really a C++ implementation exposing an `extern "C"` shim, the shim itself lives in a `.cpp` file but declares its exported functions in a `.h` header guarded for C++ (see below).
+- One `.h` per logical module/library surface (e.g. `net_manager.h`), mirroring the one-header-per-component rule from Part I, but scoped to the *public* API rather than one per internal class.
+
+```c
+/* net_manager.h */
+#ifndef NET_MANAGER_H
+#define NET_MANAGER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct NetManager NetManager;
+
+NetManager* net_manager_create(void);
+void net_manager_destroy(NetManager* mgr);
+int net_manager_connect(NetManager* mgr, const char* host, int port);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* NET_MANAGER_H */
+```
+
+- Use traditional `#ifndef`/`#define`/`#endif` header guards in `.h` files rather than `#pragma once` — `.h` files must remain portable to strict C compilers where `#pragma once` support is less universally guaranteed.
+- Always wrap declarations in `extern "C" { ... }` guarded by `#ifdef __cplusplus`, so the same header works whether included from a C or a C++ translation unit.
+
+---
+
+## 15. Indentation and Braces
+
+Match Part I for consistency across the codebase: **tabs** for indentation, **Allman** brace placement.
+
+```c
+int net_manager_connect(NetManager* mgr, const char* host, int port)
+{
+	if (mgr == NULL)
+	{
+		return NET_ERROR_INVALID_ARGUMENT;
+	}
+
+	return connect_impl(mgr, host, port);
+}
+```
+
+---
+
+## 16. API Design Do's and Don'ts
+
+| Do | Don't |
+|----|-------|
+| Return an integer error code / status enum from every fallible function | Throw or let a C++ exception cross into `extern "C"` code (undefined behavior for C callers) |
+| Use opaque pointers (`typedef struct NetManager NetManager;` with the definition hidden in the `.c`/`.cpp`) to hide implementation details and preserve ABI stability | Expose full `struct` layouts in the public header if the layout may change — this breaks binary compatibility |
+| Provide explicit `_create` / `_destroy` (or `_init` / `_free`) pairs for any type owning resources | Rely on constructors/destructors (C has none) or leave lifetime management implicit |
+| Take a `void* user_data` parameter on any callback-accepting function | Assume the caller can supply capturing closures — plain C function pointers can't capture state |
+| Check all pointer parameters for `NULL` before dereferencing at public entry points | Assume public API callers always pass valid pointers |
+| Keep the header C89/C99-compatible (no `//` comments, no variable declarations mid-block if targeting strict C89) unless the project's minimum C standard is confirmed higher | Use C++-only syntax anywhere in a `.h` that must remain includable from C |
+| Document ownership transfer explicitly in comments (e.g. "caller owns the returned pointer and must call `net_manager_destroy`") | Leave ownership of returned pointers ambiguous |
+
+---
+
+## 17. Boundary Rule of Thumb
+
+- If a file is `.cpp`/`.hpp` and never crosses a dynamic-library, plugin, or FFI boundary: **use [Part I](#part-i-c-style), full stop.**
+- If a file declares or implements symbols meant to be called from C, another language, or loaded via `dlopen`/`LoadLibrary`: **use [Part II](#part-ii-c-api-style)** for that surface, even if the implementation behind it is C++.
+- Never mix the two conventions within the same file — a `.h` should never contain `camelCase` C++-flavored declarations, and a `.hpp` should never contain `snake_case` C-flavored ones. Where a C++ class needs a C API, write a thin `extern "C"` shim (Part II style) that internally calls into the real C++ implementation (Part I style).
+
+> **See also:** [Library Linking and Runtime Loading](#11-library-linking-and-runtime-loading) — the dynamic-library and `dlopen` boundaries that make this rule necessary in the first place.
diff --git a/breeze/VERSION b/breeze/VERSION
new file mode 100644
index 0000000..3eefcb9
--- /dev/null
+++ b/breeze/VERSION
@@ -0,0 +1 @@
+1.0.0
diff --git a/breeze/cmake/Breeze.cmake b/breeze/cmake/Breeze.cmake
new file mode 100644
index 0000000..671a5de
--- /dev/null
+++ b/breeze/cmake/Breeze.cmake
@@ -0,0 +1,530 @@
+# =============================================================================
+# breeze/cmake/Breeze.cmake
+#
+# The build system itself: what the template contributes to a project, from
+# the C++ standard and the output directories to module discovery and the
+# install rules. Included by the project's CMakeLists.txt right after
+# project(); the project's own settings are in project/Configuration.cmake (read
+# here, through CMakeLists.txt having included it). Replacing breeze/ updates
+# the template without touching either.
+# =============================================================================
+
+cmake_minimum_required(VERSION 3.25)
+
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+# This project's settings (PROJECT_CODE_NAME, DEFAULT_BUILD_TYPE, the output paths
+# and the bin/lib subdirectory names) come from project/Configuration.cmake --
+# already included by CMakeLists.txt, before project(); this is a no-op unless
+# something includes this file on its own. The target selection
+# (DIST_TARGET/PLATFORM/ARCHITECTURE/COMPILER_ID) is TargetSelection.cmake: it
+# needs real compiler detection, which is why it comes after project(), and
+# everything below depends on it. Edit project/Configuration.cmake, or pass
+# -D<NAME>=... at configure time, rather than hardcoding a value it already owns
+# anywhere else in this project, scripts included.
+# Where the template is, and where the project that uses it is -- found from this
+# file's own location rather than from CMAKE_SOURCE_DIR, which is the outermost
+# project's when this one is embedded with add_subdirectory().
+set(PMN_BREEZE_CMAKE_DIR "${CMAKE_CURRENT_LIST_DIR}")
+get_filename_component(PMN_PROJECT_ROOT "${CMAKE_CURRENT_LIST_DIR}/../.." ABSOLUTE)
+include("${PMN_PROJECT_ROOT}/project/Configuration.cmake")
+
+# The contract with project/Configuration.cmake: these are the settings the template
+# reads. A project file from an older template version may lack one that a newer
+# version added -- say which, instead of failing somewhere downstream on an empty value.
+foreach(_pmn_setting
+        PROJECT_CODE_NAME DEFAULT_BUILD_TYPE
+        OUT_DIR BUILD_OUTPUT_DIR INSTALL_OUTPUT_DIR DOCS_OUTPUT_DIR DIST_OUTPUT_DIR
+        TOOLCACHE_DIR COMPILE_COMMANDS_DESTINATION
+        RUNTIME_OUTPUT_SUBDIR LIBRARY_OUTPUT_SUBDIR ARCHIVE_OUTPUT_SUBDIR)
+    if(NOT DEFINED ${_pmn_setting})
+        message(FATAL_ERROR
+            "project/Configuration.cmake does not define ${_pmn_setting}, which this version "
+            "of breeze/ needs. Add it: a fresh copy of the template's project/Configuration.cmake "
+            "shows the default.")
+    endif()
+endforeach()
+include("${CMAKE_CURRENT_LIST_DIR}/TargetSelection.cmake")
+include("${CMAKE_CURRENT_LIST_DIR}/GitignoreSync.cmake")
+
+# The language standard is the project's choice (project/Configuration.cmake);
+# requiring it and turning compiler extensions off is the template's policy.
+if(NOT DEFINED PROJECT_CXX_STANDARD)
+    set(PROJECT_CXX_STANDARD 20)
+endif()
+set(CMAKE_CXX_STANDARD ${PROJECT_CXX_STANDARD})
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+
+# This project uses C++20 but not C++20 modules. CMake >= 3.28 nevertheless
+# assumes C++20 sources might `import` modules and scans every one of them
+# before compiling (policy CMP0155) -- in any directory whose own
+# cmake_minimum_required is >= 3.28, which includes fetched dependencies
+# like fmt even though this project's own minimum is lower. The scan needs
+# a scanner tool (clang-scan-deps for Clang, which e.g. Ubuntu's plain
+# `clang` package doesn't ship, so the build dies with
+# "CMAKE_CXX_COMPILER_CLANG_SCAN_DEPS-NOTFOUND") and adds a step to every
+# compile. This variable is CMake's documented opt-out; it is inherited by
+# every target created below, third-party ones included. If you start using
+# modules, remove it (or set the CXX_SCAN_FOR_MODULES property on just the
+# targets that need it).
+set(CMAKE_CXX_SCAN_FOR_MODULES OFF)
+
+# Every static library in the project gets built with -fPIC by default --
+# including vendored/fetched ones, whose own CMakeLists.txt we don't
+# control and can't rely on to opt in themselves. Without this, a static
+# dependency (ours or third-party) fails to link the moment it ends up
+# pulled into a SHARED module: "recompile with -fPIC". Cheap on every
+# platform that matters here; add_lib_module's STATIC branch also sets
+# this per-target as a belt-and-braces fallback.
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+# -------------------------------------------------------
+# Generator guard -- require Ninja (single or multi-config)
+# -------------------------------------------------------
+if(NOT CMAKE_GENERATOR MATCHES "Ninja")
+    message(WARNING
+        "This project targets Ninja. "
+        "Current generator: '${CMAKE_GENERATOR}'. "
+        "Reconfigure with:  cmake -G Ninja  or  cmake -G \"Ninja Multi-Config\"")
+endif()
+
+# Single-config Ninja needs CMAKE_BUILD_TYPE at configure time.
+# Ninja Multi-Config uses CMAKE_CONFIGURATION_TYPES instead (no BUILD_TYPE needed).
+if(CMAKE_GENERATOR STREQUAL "Ninja")
+    if(NOT CMAKE_BUILD_TYPE)
+        set(CMAKE_BUILD_TYPE "${DEFAULT_BUILD_TYPE}" CACHE STRING
+            "Build type (Debug|Release|RelWithDebInfo|MinSizeRel)" FORCE)
+        message(STATUS "CMAKE_BUILD_TYPE not set -- defaulting to ${DEFAULT_BUILD_TYPE}")
+    endif()
+    set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS
+        Debug Release RelWithDebInfo MinSizeRel)
+endif()
+
+# -------------------------------------------------------
+# Flat output layout
+# Multi-config generators (Ninja Multi-Config) append /<Config> by default.
+# Override all four configs so both Ninja variants produce the same layout.
+# Subdirectory names come from project/Configuration.cmake (RUNTIME_OUTPUT_SUBDIR
+# etc.); the base directory is always CMAKE_BINARY_DIR, wherever -B points
+# (breeze/scripts/build.sh uses out/build/<preset> -- see project/Configuration.cmake).
+# -------------------------------------------------------
+foreach(_cfg Debug Release RelWithDebInfo MinSizeRel)
+    string(TOUPPER "${_cfg}" _CFG)
+    set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_${_CFG} "${CMAKE_BINARY_DIR}/${RUNTIME_OUTPUT_SUBDIR}")
+    set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_${_CFG} "${CMAKE_BINARY_DIR}/${LIBRARY_OUTPUT_SUBDIR}")
+    set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_${_CFG} "${CMAKE_BINARY_DIR}/${ARCHIVE_OUTPUT_SUBDIR}")
+endforeach()
+
+# -------------------------------------------------------
+# RPATH strategy
+# By default CMake builds with a temporary RPATH and relinks at install time
+# to embed the final one. Ninja on Linux with Clang does not support that
+# relink step and will error out. Setting this ON tells CMake to embed the
+# install RPATH at build time so no relink is ever needed.
+# This is safe here because all our RPATHs are relative to the binary that
+# carries them ($ORIGIN on Linux, @loader_path on macOS -- see
+# _apply_rpath in breeze/cmake/BuildHelpers.cmake), so the same value is correct
+# for both the build tree and the installed layout. Guarded to non-Windows
+# since RPATH is an ELF/Mach-O concept only. (On macOS the same setting also
+# spares CMake from rewriting load commands with install_name_tool at
+# install time.)
+# -------------------------------------------------------
+if(NOT WIN32)
+    set(CMAKE_BUILD_WITH_INSTALL_RPATH ON)
+endif()
+
+# -------------------------------------------------------
+# options
+# -------------------------------------------------------
+option(BUILD_TESTS      "Build test binaries"      OFF)
+option(BUILD_EXAMPLES   "Build example binaries"   OFF)
+option(INSTALL_TESTS    "Install test binaries"    OFF)
+option(INSTALL_EXAMPLES "Install example binaries" OFF)
+
+# Project-wide default for add_lib_module() when a module doesn't pass
+# TYPE explicitly. This is CMake's own BUILD_SHARED_LIBS variable, so it
+# also affects any third-party add_library() calls (FetchContent, etc.)
+# that respect it. Override per-module with add_lib_module(... TYPE
+# STATIC|SHARED ...), or globally with -DBUILD_SHARED_LIBS=ON.
+option(BUILD_SHARED_LIBS "Build libraries as SHARED by default" OFF)
+
+# INSTALL_* implies BUILD_* so targets exist when cmake --install runs
+if(INSTALL_TESTS)
+    set(BUILD_TESTS ON CACHE BOOL "" FORCE)
+endif()
+if(INSTALL_EXAMPLES)
+    set(BUILD_EXAMPLES ON CACHE BOOL "" FORCE)
+endif()
+
+message(STATUS "BUILD_TESTS      = ${BUILD_TESTS}")
+message(STATUS "BUILD_EXAMPLES   = ${BUILD_EXAMPLES}")
+message(STATUS "BUILD_SHARED_LIBS (default lib TYPE) = ${BUILD_SHARED_LIBS}")
+
+# -------------------------------------------------------
+# Global compiler settings
+#
+# MSVC is TRUE for both cl.exe and clang-cl (windows-x64-msvc and
+# windows-x64-clang-cl -- Clang targeting the MSVC ABI), so the outer
+# block covers both with the flags they share. Two flags are cl.exe-only,
+# though: clang-cl doesn't implement them and reports "argument unused
+# during compilation" for every translation unit, so they're gated on the
+# compiler ID (MSVC == cl.exe; clang-cl reports Clang) rather than on
+# the MSVC variable.
+#
+# Shared by cl.exe and clang-cl:
+#   /EHsc            -- standard C++ exception handling
+#   /utf-8           -- UTF-8 source + execution charset
+# cl.exe only:
+#   /MP              -- parallel file compilation within one compiler
+#                       invocation (Ninja also parallelizes across
+#                       invocations; clang-cl ignores this)
+#   /Zc:preprocessor -- conformant preprocessor (fixes __VA_ARGS__ etc.);
+#                       clang's preprocessor is always conformant
+# -------------------------------------------------------
+if(MSVC)
+    add_compile_options(/EHsc /utf-8)
+    add_compile_definitions(_CRT_SECURE_NO_WARNINGS)
+    if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
+        add_compile_options(/MP /Zc:preprocessor)
+    endif()
+endif()
+
+# -------------------------------------------------------
+# MinGW runtime linking (windows-x86-mingw32 / windows-x64-mingw64)
+#
+# A MinGW build dynamically links libgcc/libstdc++/(on some toolchains)
+# libwinpthread by default, which then have to ship alongside every
+# binary that needs them -- easy to forget, and the exact DLL names
+# differ between mingw32 and mingw64 and between exception models (SEH
+# on x86_64; DWARF-2 or SJLJ on i686). PMN_MINGW_RUNTIME_DLLS below
+# resolves the actual files by asking the compiler rather than
+# hardcoding names (-print-file-name=NAME echoes NAME back unchanged if
+# it can't find it, which is how "not applicable to this toolchain" is
+# detected), and BuildHelpers.cmake's _copy_mingw_runtime_dlls() copies
+# them next to every EXECUTABLE/SHARED/test/example target that needs
+# them, in the build tree and at install time (the "install" section
+# below) -- so nothing here needs a manual step. MINGW is CMake's
+# built-in equivalent of this project's own COMPILER_ID being "mingw32"
+# or "mingw64".
+#
+# PMN_MINGW_STATIC_RUNTIME (default OFF) is what this project used to do
+# unconditionally: link every EXECUTABLE against a private, static copy
+# of libgcc/libstdc++/winpthread instead (-static-libgcc -static-libstdc++
+# -static -lwinpthread -- EXECUTABLE targets only, via a generator
+# expression, since applying it to a SHARED target collides with
+# WINDOWS_EXPORT_ALL_SYMBOLS: a statically-linked unwinder re-exported
+# from the DLL's own import library and a second static copy in the EXE
+# both trying to define `_Unwind_Resume` is a link error). It trades
+# shipping the runtime DLLs for a standalone .exe -- which is safe only
+# as long as no EXECUTABLE built this way ALSO links a MinGW SHARED
+# module (this project always has one -- core_lib/demo_core.dll) THAT
+# PASSES AN STL TYPE ACROSS THAT BOUNDARY BY VALUE. core_lib's
+# std::string makeGreeting(...) does exactly that: an executable with
+# its own private, statically-linked libstdc++ has its own private
+# allocator, separate from the one the dynamically-linked DLL uses
+# (libstdc++-6.dll's); a std::string built on the DLL side -- heap
+# allocated there once its contents outgrow small-string optimization,
+# which "Hello, World! (from demo_core)" does -- and then destroyed on
+# the executable's side is freed through a DIFFERENT allocator instance
+# than the one that allocated it. That is undefined behavior across any
+# Windows DLL boundary (well documented -- e.g.
+# github.com/msys2/MINGW-packages/issues/5763, a DLL/EXE pair crashing
+# the moment an exception -- which unwinds through the same kind of
+# per-runtime-instance bookkeeping a heap allocator uses -- crosses a
+# static/dynamic runtime mismatch like this one), and on real Windows
+# (confirmed directly: some emulators are considerably more lenient
+# about a cross-heap free() than real Windows is, so a mismatch like
+# this can look fine there and still be live) it reliably crashes
+# shortly after the mismatched value is used -- which is exactly what
+# this project's own demos did while PMN_MINGW_STATIC_RUNTIME was the
+# only option: hello_exe/farewell_exe printed their (still-valid, not
+# yet corrupted) greeting and then crashed destroying the very
+# std::string they had just printed. Turning this option ON is safe
+# again only for a MinGW build with no SHARED module at all, or where
+# every SHARED module's boundary is a plain C API (no STL type crosses
+# it by value) -- e.g. also statically-linking that module and giving
+# it a C entry point avoids the whole class of problem, since it no
+# longer depends on the dynamic runtime at all.
+# -------------------------------------------------------
+option(PMN_MINGW_STATIC_RUNTIME
+    "MinGW: statically link libgcc/libstdc++/winpthread into every executable instead of shipping the runtime DLLs next to it. UNSAFE for an executable that also links a MinGW SHARED module (like this project's core_lib) which passes an STL type across that boundary by value -- see the comment above. Default OFF: dynamic linking everywhere, with the runtime DLLs copied automatically."
+    OFF)
+
+if(MINGW)
+    if(PMN_MINGW_STATIC_RUNTIME)
+        add_link_options(
+            "$<$<STREQUAL:$<TARGET_PROPERTY:TYPE>,EXECUTABLE>:-static-libgcc;-static-libstdc++;-static;-lwinpthread>"
+        )
+    endif()
+
+    set(PMN_MINGW_RUNTIME_DLLS "")
+    # -print-file-name=<name>.dll only searches "lib"-shaped paths, where
+    # the .dll.a import library lives -- not "bin", where the runtime
+    # .dll itself does on every package manager here except apt: asked
+    # for the bare .dll on those, it just echoes the name back
+    # unresolved, silently leaving it out of this list further down.
+    # Confirmed directly against each package's own file listing:
+    #   pacman  -- /usr/<triplet>/bin/<dll>              (flat)
+    #   dnf     -- /usr/<triplet>/sys-root/mingw/bin/<dll> (nested)
+    # -- and against discussion.fedoraproject.org's "Location of
+    # mingw64/mingw32 system libraries like libgcc_s_seh-1.dll and
+    # libwinpthread-1.dll" (Oct 2024) for why dnf's -print-file-name
+    # specifically comes up empty. On apt, -print-file-name already
+    # resolves the .dll directly (confirmed independently in that same
+    # thread) -- both fallbacks below only run where that lookup came
+    # back empty, so apt is unaffected either way.
+    get_filename_component(_pmn_mingw_cxx_name "${CMAKE_CXX_COMPILER}" NAME)
+    string(REGEX REPLACE "-g\\+\\+(\\.exe)?$" "" _pmn_mingw_triplet "${_pmn_mingw_cxx_name}")
+    execute_process(
+        COMMAND "${CMAKE_CXX_COMPILER}" -print-sysroot
+        OUTPUT_VARIABLE _pmn_mingw_sysroot
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+        ERROR_QUIET
+    )
+    foreach(_pmn_dll_candidate
+        libgcc_s_seh-1.dll
+        libgcc_s_dw2-1.dll
+        libgcc_s_sjlj-1.dll
+        libstdc++-6.dll
+        libwinpthread-1.dll
+    )
+        execute_process(
+            COMMAND "${CMAKE_CXX_COMPILER}" -print-file-name=${_pmn_dll_candidate}
+            OUTPUT_VARIABLE _pmn_resolved_dll
+            OUTPUT_STRIP_TRAILING_WHITESPACE
+        )
+        if(NOT EXISTS "${_pmn_resolved_dll}")
+            if(_pmn_mingw_triplet AND EXISTS "/usr/${_pmn_mingw_triplet}/bin/${_pmn_dll_candidate}")
+                set(_pmn_resolved_dll "/usr/${_pmn_mingw_triplet}/bin/${_pmn_dll_candidate}")
+            elseif(_pmn_mingw_sysroot AND EXISTS "${_pmn_mingw_sysroot}/mingw/bin/${_pmn_dll_candidate}")
+                set(_pmn_resolved_dll "${_pmn_mingw_sysroot}/mingw/bin/${_pmn_dll_candidate}")
+            endif()
+        endif()
+        if(EXISTS "${_pmn_resolved_dll}")
+            list(APPEND PMN_MINGW_RUNTIME_DLLS "${_pmn_resolved_dll}")
+        endif()
+    endforeach()
+    if(PMN_MINGW_RUNTIME_DLLS)
+        if(PMN_MINGW_STATIC_RUNTIME)
+            message(STATUS "MinGW runtime DLLs (bundled next to SHARED targets only -- PMN_MINGW_STATIC_RUNTIME is ON): ${PMN_MINGW_RUNTIME_DLLS}")
+        else()
+            message(STATUS "MinGW runtime DLLs (bundled next to every EXECUTABLE/SHARED target that needs them): ${PMN_MINGW_RUNTIME_DLLS}")
+        endif()
+    endif()
+endif()
+
+# -------------------------------------------------------
+# Build machinery (macros/functions) -- see breeze/cmake/BuildHelpers.cmake.
+# This file should change rarely; it holds nothing project-specific.
+# -------------------------------------------------------
+include("${PMN_BREEZE_CMAKE_DIR}/BuildHelpers.cmake")
+
+# -------------------------------------------------------
+# Third-party dependencies -- see breeze/cmake/Dependencies.cmake for
+# add_vendor_header_only / add_vendor_subdirectory / add_dependency.
+# A module declares its own dependencies in its own CMakeLists.txt (see
+# source/Core/CMakeLists.txt for an example); nothing to add here.
+# -------------------------------------------------------
+include("${PMN_BREEZE_CMAKE_DIR}/Dependencies.cmake")
+
+# -------------------------------------------------------
+# Documentation -- see breeze/cmake/Documentation.cmake. Every module
+# automatically gets its own Doxygen target the moment Doxygen is
+# installed; nothing to add here or in a module's own CMakeLists.txt
+# unless you want to opt a module out (NO_DOCS) or override a Doxyfile
+# setting (-DDOXYGEN_<TAG>=...).
+# -------------------------------------------------------
+include("${PMN_BREEZE_CMAKE_DIR}/Documentation.cmake")
+
+# -------------------------------------------------------
+# Module discovery
+#
+# Every module lives in its own directory with its own CMakeLists.txt --
+# usually a single add_lib_module/add_objects_module/add_exe_module/
+# add_test_module/add_example_module(...) call (see breeze/cmake/BuildHelpers.cmake
+# for what each accepts). This file never needs editing to add, remove, or reconfigure
+# a module: just add or remove the module's directory + CMakeLists.txt.
+#
+#   source/<Name>/CMakeLists.txt          -- library, objects or app/executable module
+#   source/tests/<Name>/CMakeLists.txt    -- test module
+#   source/examples/<Name>/CMakeLists.txt -- example module
+#
+# (source/tests and source/examples aren't picked up by the first call
+# below -- they have no CMakeLists.txt directly inside them, only their
+# own children do, so they're only ever visited by their dedicated calls.)
+#
+# _discover_module_subdirectories() add_subdirectory()s every matching
+# directory automatically; CONFIGURE_DEPENDS means the next build
+# reconfigures on its own once a module directory is added or removed.
+# -------------------------------------------------------
+_discover_module_subdirectories("${CMAKE_SOURCE_DIR}/source")
+_discover_module_subdirectories("${CMAKE_SOURCE_DIR}/source/tests")
+_discover_module_subdirectories("${CMAKE_SOURCE_DIR}/source/examples")
+
+# Object modules (add_objects_module) can only be told from libraries once every
+# module exists: this links what each one needs of them -- the pieces behind
+# the pieces, and their headers for a library's consumers. See its comment.
+_resolve_object_modules()
+
+# Emits <build-dir>/module_manifest-<CONFIG>.txt ("target_name=path_to_binary"
+# per line) for every executable module discovered above. breeze/scripts/run.sh / run.bat
+# read this to resolve a CMake target name to its binary -- must run after
+# discovery.
+_write_module_manifest("${CMAKE_BINARY_DIR}")
+
+# Writes out/docs/index.html (DOCS_OUTPUT_DIR, see project/Configuration.cmake)
+# linking to every module's generated documentation (a no-op if
+# ENABLE_DOXYGEN is off) -- must run after discovery, same reasoning as
+# the manifest above.
+_write_docs_index("${DOCS_OUTPUT_DIR}")
+
+# -------------------------------------------------------
+# Copy compile_commands.json to the project root once it's fully
+# populated, so clangd/clang-tidy/IWYU find it without extra config (most
+# editors look for it at the repo root or search upward from the source
+# file; CMake only ever writes it into the build directory). Runs at
+# build time, by which point CMake's own generate step has already
+# written build/compile_commands.json, so this works even on the very
+# first build with no prior build directory. Vendored and fetched
+# dependencies are excluded from it (see breeze/cmake/Dependencies.cmake) so it
+# only reflects code this project owns.
+# -------------------------------------------------------
+if(CMAKE_EXPORT_COMPILE_COMMANDS)
+    add_custom_target(copy_compile_commands ALL
+        COMMAND ${CMAKE_COMMAND} -E copy_if_different
+            "${CMAKE_BINARY_DIR}/compile_commands.json"
+            "${COMPILE_COMMANDS_DESTINATION}"
+        COMMENT "Copying compile_commands.json to project root"
+        VERBATIM
+    )
+endif()
+
+# -------------------------------------------------------
+# install
+# -------------------------------------------------------
+set(_pmn_install_target_dir ${INSTALL_OUTPUT_DIR}/${DIST_TARGET})
+
+# primary
+set(RUNTIME_OUT_DIR  ${_pmn_install_target_dir}/${RUNTIME_OUTPUT_SUBDIR})
+set(LIBRARY_OUT_DIR  ${_pmn_install_target_dir}/${LIBRARY_OUTPUT_SUBDIR})
+set(ARCHIVE_OUT_DIR  ${_pmn_install_target_dir}/${ARCHIVE_OUTPUT_SUBDIR})
+
+# tests -- runtime/library -> bin/tests/   archives -> lib/tests/
+set(TEST_RUNTIME_OUT_DIR ${_pmn_install_target_dir}/${RUNTIME_OUTPUT_SUBDIR}/tests)
+set(TEST_LIBRARY_OUT_DIR ${_pmn_install_target_dir}/${LIBRARY_OUTPUT_SUBDIR}/tests)
+set(TEST_ARCHIVE_OUT_DIR ${_pmn_install_target_dir}/${ARCHIVE_OUTPUT_SUBDIR}/tests)
+
+# examples -- runtime/library -> bin/examples/   archives -> lib/examples/
+set(EXAMPLE_RUNTIME_OUT_DIR ${_pmn_install_target_dir}/${RUNTIME_OUTPUT_SUBDIR}/examples)
+set(EXAMPLE_LIBRARY_OUT_DIR ${_pmn_install_target_dir}/${LIBRARY_OUTPUT_SUBDIR}/examples)
+set(EXAMPLE_ARCHIVE_OUT_DIR ${_pmn_install_target_dir}/${ARCHIVE_OUTPUT_SUBDIR}/examples)
+
+# Every install(TARGETS ...) below is tagged COMPONENT ${PROJECT_CODE_NAME}.
+# A vendored/fetched dependency's own CMakeLists.txt (see
+# breeze/cmake/Dependencies.cmake) usually has install() rules of its own, with
+# no COMPONENT tag -- installing with `cmake --install build` (no
+# --component filter) would pull those in too, typically under
+# CMAKE_INSTALL_PREFIX (e.g. /usr/local). breeze/scripts/install.sh / install.bat always
+# pass --component ${PROJECT_CODE_NAME} so only this project's own
+# artifacts are installed; use the same flag if you invoke cmake --install
+# directly.
+message(STATUS "Will install primary modules.")
+get_property(_pmn_primary_targets GLOBAL PROPERTY PMN_MODULE_TARGETS_PRIMARY)
+if(_pmn_primary_targets)
+    install(TARGETS ${_pmn_primary_targets}
+        COMPONENT ${PROJECT_CODE_NAME}
+        ARCHIVE DESTINATION ${ARCHIVE_OUT_DIR}
+        LIBRARY DESTINATION ${LIBRARY_OUT_DIR}
+        RUNTIME DESTINATION ${RUNTIME_OUT_DIR}
+    )
+endif()
+
+# MinGW runtime DLLs (see the "MinGW runtime linking" comment above) --
+# installed as plain files, alongside the DLLs above, rather than as
+# TARGETS, since they're not CMake targets this project defines. RUNTIME,
+# not LIBRARY: a .dll is a runtime artifact on Windows no matter which
+# install()-TARGETS category built it. Always into RUNTIME_OUT_DIR: the
+# primary executables land there, and so does core_lib/demo_core.dll,
+# which needs this regardless of PMN_MINGW_STATIC_RUNTIME (see that
+# option's comment -- a SHARED module is never a candidate for it).
+if(PMN_MINGW_RUNTIME_DLLS)
+    install(FILES ${PMN_MINGW_RUNTIME_DLLS}
+        COMPONENT ${PROJECT_CODE_NAME}
+        DESTINATION ${RUNTIME_OUT_DIR}
+    )
+endif()
+
+# Both blocks below read whatever test/example modules discovery actually
+# found -- no target names to keep in sync here when a module is added,
+# removed, or renamed.
+if(INSTALL_TESTS)
+    get_property(_pmn_test_targets GLOBAL PROPERTY PMN_MODULE_TARGETS_TEST)
+    if(_pmn_test_targets)
+        message(STATUS "Will install test modules: ${_pmn_test_targets}")
+        install(TARGETS ${_pmn_test_targets}
+            COMPONENT ${PROJECT_CODE_NAME}
+            ARCHIVE DESTINATION ${TEST_ARCHIVE_OUT_DIR}
+            LIBRARY DESTINATION ${TEST_LIBRARY_OUT_DIR}
+            RUNTIME DESTINATION ${TEST_RUNTIME_OUT_DIR}
+        )
+        # Matches BuildHelpers.cmake's add_test_module: skipped under
+        # PMN_MINGW_STATIC_RUNTIME, where test executables are
+        # self-contained instead.
+        if(PMN_MINGW_RUNTIME_DLLS AND NOT PMN_MINGW_STATIC_RUNTIME)
+            install(FILES ${PMN_MINGW_RUNTIME_DLLS}
+                COMPONENT ${PROJECT_CODE_NAME}
+                DESTINATION ${TEST_RUNTIME_OUT_DIR}
+            )
+        endif()
+        # The install-time match for _copy_target_runtime_dlls(): a test
+        # that depends on a SHARED module (core_lib included) needs that
+        # module's .dll installed alongside it too, on any Windows
+        # compiler -- bin/tests/ is a separate install destination from
+        # bin/, and Windows has no relative-RPATH equivalent (see that
+        # function's comment). install(FILES) silently installs nothing
+        # for a target with no SHARED dependency -- confirmed directly --
+        # so this needs no separate "is there anything to install" guard.
+        if(WIN32)
+            foreach(_pmn_test_target ${_pmn_test_targets})
+                install(FILES "$<TARGET_RUNTIME_DLLS:${_pmn_test_target}>"
+                    COMPONENT ${PROJECT_CODE_NAME}
+                    DESTINATION ${TEST_RUNTIME_OUT_DIR}
+                )
+            endforeach()
+        endif()
+    else()
+        message(WARNING "INSTALL_TESTS is ON but no test modules were found under source/tests/.")
+    endif()
+endif()
+
+if(INSTALL_EXAMPLES)
+    get_property(_pmn_example_targets GLOBAL PROPERTY PMN_MODULE_TARGETS_EXAMPLE)
+    if(_pmn_example_targets)
+        message(STATUS "Will install example modules: ${_pmn_example_targets}")
+        install(TARGETS ${_pmn_example_targets}
+            COMPONENT ${PROJECT_CODE_NAME}
+            ARCHIVE DESTINATION ${EXAMPLE_ARCHIVE_OUT_DIR}
+            LIBRARY DESTINATION ${EXAMPLE_LIBRARY_OUT_DIR}
+            RUNTIME DESTINATION ${EXAMPLE_RUNTIME_OUT_DIR}
+        )
+        # See the matching pair of comments in the INSTALL_TESTS block above.
+        if(PMN_MINGW_RUNTIME_DLLS AND NOT PMN_MINGW_STATIC_RUNTIME)
+            install(FILES ${PMN_MINGW_RUNTIME_DLLS}
+                COMPONENT ${PROJECT_CODE_NAME}
+                DESTINATION ${EXAMPLE_RUNTIME_OUT_DIR}
+            )
+        endif()
+        if(WIN32)
+            foreach(_pmn_example_target ${_pmn_example_targets})
+                install(FILES "$<TARGET_RUNTIME_DLLS:${_pmn_example_target}>"
+                    COMPONENT ${PROJECT_CODE_NAME}
+                    DESTINATION ${EXAMPLE_RUNTIME_OUT_DIR}
+                )
+            endforeach()
+        endif()
+    else()
+        message(WARNING "INSTALL_EXAMPLES is ON but no example modules were found under source/examples/.")
+    endif()
+endif()
diff --git a/breeze/cmake/BuildDir.cmake b/breeze/cmake/BuildDir.cmake
new file mode 100644
index 0000000..c292ee7
--- /dev/null
+++ b/breeze/cmake/BuildDir.cmake
@@ -0,0 +1,125 @@
+# =============================================================================
+# BuildDir.cmake
+#
+# Script-mode bridge, the same idea as PrintConfig.cmake: tells
+# breeze/scripts/*.sh and breeze/scripts/*.bat which build directory to work on, so that
+# logic exists once here instead of twice in two shell dialects.
+#
+# Every preset builds in its own directory, out/build/<name> (see
+# BUILD_OUTPUT_DIR in project/Configuration.cmake), which is what lets you switch
+# presets without one's cache clobbering another's. The scripts have to
+# pick one of them:
+#
+#   build.*             knows the name already (--preset <name>, else
+#                        "default") and only needs the path. After a
+#                        successful configure it also records the choice as
+#                        the one built last.
+#   run.* install.*     take an optional --preset <name>; without it they use
+#   docs.*               the directory that was built last, or the only one
+#                        that exists, or say what to do if that's ambiguous.
+#
+# Usage:
+#   cmake [-DPMN_NAME=<name>] [-DPMN_RECORD=ON] -P breeze/cmake/BuildDir.cmake
+#
+#   PMN_NAME     a preset name, or "default". Given: the answer is
+#                BUILD_OUTPUT_DIR/<name>, whether or not it exists yet (build
+#                is about to create it). Not given: discover one -- the one
+#                built last, else the only one, else an error.
+#   PMN_RECORD   also remember PMN_NAME as the one built last (a one-line
+#                file, out/build/.last).
+#
+# Prints exactly one line, via message(STATUS ...) for the reason
+# PrintConfig.cmake documents (STATUS is the one message() mode CMake sends
+# to stdout, at the cost of a "-- " prefix every caller strips):
+#
+#   -- BUILD_DIR=<path>   relative to the project root with forward slashes
+#                         when it's inside the project (the normal case),
+#                         absolute otherwise
+#   -- ERROR=<text>       what to tell the user
+#
+# The exit status is 0 either way -- callers key on which line they got. The
+# error text sticks to plain words and avoids the characters cmd.exe treats
+# specially (& | < > ^ % ! and parentheses), so a .bat can echo it back
+# verbatim.
+# =============================================================================
+
+get_filename_component(CMAKE_SOURCE_DIR "${CMAKE_CURRENT_LIST_DIR}/../.." ABSOLUTE)
+include("${CMAKE_SOURCE_DIR}/project/Configuration.cmake")
+
+# <path> shown relative to the project root when it's inside it.
+function(_pmn_display_path ABSOLUTE_PATH OUT_VAR)
+    file(RELATIVE_PATH _pmn_rel "${CMAKE_SOURCE_DIR}" "${ABSOLUTE_PATH}")
+    if(_pmn_rel MATCHES "^\\.\\.")
+        set(${OUT_VAR} "${ABSOLUTE_PATH}" PARENT_SCOPE)
+    else()
+        set(${OUT_VAR} "${_pmn_rel}" PARENT_SCOPE)
+    endif()
+endfunction()
+
+set(_pmn_root "${BUILD_OUTPUT_DIR}")
+_pmn_display_path("${_pmn_root}" _pmn_root_shown)
+
+set(_pmn_key "")
+set(_pmn_value "")
+
+if(NOT "${PMN_NAME}" STREQUAL "")
+    # ---- A name was given: the answer is just the path. ----------------------
+    if(PMN_NAME MATCHES "[/\\\\]" OR PMN_NAME STREQUAL "." OR PMN_NAME STREQUAL "..")
+        set(_pmn_key "ERROR")
+        set(_pmn_value "'${PMN_NAME}' is not a valid preset name: it must be a single directory name, not a path.")
+    else()
+        _pmn_display_path("${_pmn_root}/${PMN_NAME}" _pmn_shown)
+        set(_pmn_key "BUILD_DIR")
+        set(_pmn_value "${_pmn_shown}")
+        if(PMN_RECORD)
+            file(MAKE_DIRECTORY "${_pmn_root}")
+            file(WRITE "${_pmn_root}/.last" "${PMN_NAME}\n")
+        endif()
+    endif()
+else()
+    # ---- No name: discover one. ---------------------------------------------
+    # Candidates are the subdirectories that hold a CMake cache.
+    set(_pmn_candidates "")
+    file(GLOB _pmn_children LIST_DIRECTORIES true "${_pmn_root}/*")
+    foreach(_pmn_child IN LISTS _pmn_children)
+        if(IS_DIRECTORY "${_pmn_child}" AND EXISTS "${_pmn_child}/CMakeCache.txt")
+            get_filename_component(_pmn_child_name "${_pmn_child}" NAME)
+            list(APPEND _pmn_candidates "${_pmn_child_name}")
+        endif()
+    endforeach()
+    list(SORT _pmn_candidates)
+    list(LENGTH _pmn_candidates _pmn_count)
+
+    # The one built last, if that pointer still names a real build.
+    set(_pmn_last "")
+    if(EXISTS "${_pmn_root}/.last")
+        file(STRINGS "${_pmn_root}/.last" _pmn_last_lines LIMIT_COUNT 1)
+        string(STRIP "${_pmn_last_lines}" _pmn_last)
+    endif()
+
+    set(_pmn_chosen "")
+    if(NOT "${_pmn_last}" STREQUAL "" AND "${_pmn_last}" IN_LIST _pmn_candidates)
+        set(_pmn_chosen "${_pmn_last}")
+    elseif(_pmn_count EQUAL 1)
+        set(_pmn_chosen "${_pmn_candidates}")
+    endif()
+
+    if(NOT "${_pmn_chosen}" STREQUAL "")
+        _pmn_display_path("${_pmn_root}/${_pmn_chosen}" _pmn_shown)
+        set(_pmn_key "BUILD_DIR")
+        set(_pmn_value "${_pmn_shown}")
+    elseif(_pmn_count EQUAL 0)
+        set(_pmn_key "ERROR")
+        if(EXISTS "${_pmn_root}/CMakeCache.txt")
+            set(_pmn_value "${_pmn_root_shown} holds a build from the old single-directory layout, which this version no longer uses. Delete it, then run breeze/scripts/build to create one build directory per preset.")
+        else()
+            set(_pmn_value "No build found under ${_pmn_root_shown}. Run breeze/scripts/build first, optionally with --preset NAME.")
+        endif()
+    else()
+        list(JOIN _pmn_candidates ", " _pmn_names)
+        set(_pmn_key "ERROR")
+        set(_pmn_value "Several builds exist under ${_pmn_root_shown} and none was built last through the scripts: ${_pmn_names}. Pass --preset NAME to choose one.")
+    endif()
+endif()
+
+message(STATUS "${_pmn_key}=${_pmn_value}")
diff --git a/breeze/cmake/BuildHelpers.cmake b/breeze/cmake/BuildHelpers.cmake
new file mode 100644
index 0000000..2ba9c67
--- /dev/null
+++ b/breeze/cmake/BuildHelpers.cmake
@@ -0,0 +1,627 @@
+# =============================================================================
+# BuildHelpers.cmake
+#
+# Reusable, project-agnostic build machinery: module discovery, per-target
+# compiler/RPATH settings, and the module-registration macros (add_lib_module,
+# add_objects_module, add_exe_module, add_test_module, add_example_module) that
+# a module's own CMakeLists.txt calls.
+#
+# This file is meant to change rarely and hold nothing project-specific.
+# New targets should not need edits here, or in Breeze.cmake --
+# see the "Module discovery" section of Breeze.cmake and the per-module
+# CMakeLists.txt convention described there.
+#
+# Expects the including file (Breeze.cmake) to have already set (from project()
+# and project/Configuration.cmake): PROJECT_NAME, PROJECT_VERSION,
+# PROJECT_CODE_NAME. Multiplatform: MSVC/WIN32 branches guard the
+# Windows-only paths; everything else is generic.
+# =============================================================================
+
+include_guard(GLOBAL)
+
+# -----------------------------------------------------------------------
+# all_tests / all_examples -- aggregate targets so groups can be built
+# without CMake target-name collisions:
+#   cmake --build . --target all_tests
+#   cmake --build . --target all_examples
+#
+# enable_testing() is required for add_test_module()'s add_test() calls to
+# actually be discoverable by ctest -- without it, tests build fine but
+# `ctest` reports "No tests were found" with no error anywhere else.
+# -----------------------------------------------------------------------
+enable_testing()
+add_custom_target(all_tests    COMMENT "Build all test targets")
+add_custom_target(all_examples COMMENT "Build all example targets")
+
+# -----------------------------------------------------------------------
+# _discover_module_subdirectories(ROOT_DIR): add_subdirectory() every
+# immediate child of ROOT_DIR that contains its own CMakeLists.txt.
+#
+# This is the whole mechanism behind "no root edits to add a module": drop
+# a new directory with a one-line CMakeLists.txt under one of the known
+# module roots (source/ for libraries and apps, source/tests/ or
+# source/examples/ for tests and examples) and it is picked up automatically.
+# CONFIGURE_DEPENDS means the *next build* reconfigures on its own after a
+# module directory is added or removed -- no manual `cmake` re-run needed.
+#
+# Order between add_subdirectory() calls does not matter for correctness:
+# CMake resolves target_link_libraries() names against the whole project
+# at generate time, not sequentially, so a module may DEPENDS on a module
+# discovered later (verified empirically -- this isn't a guess).
+#
+# A macro (not a function) so add_subdirectory() behaves exactly as if it
+# were called directly from the caller -- no extra scope layer involved.
+# -----------------------------------------------------------------------
+macro(_discover_module_subdirectories ROOT_DIR)
+    if(IS_DIRECTORY "${ROOT_DIR}")
+        file(GLOB _pmn_module_candidates CONFIGURE_DEPENDS LIST_DIRECTORIES true "${ROOT_DIR}/*")
+        foreach(_pmn_candidate ${_pmn_module_candidates})
+            if(IS_DIRECTORY "${_pmn_candidate}" AND EXISTS "${_pmn_candidate}/CMakeLists.txt")
+                add_subdirectory("${_pmn_candidate}")
+            endif()
+        endforeach()
+    endif()
+endmacro()
+
+# -----------------------------------------------------------------------
+# _apply_compile_options: per-target warning flags.
+# MSVC path  : /W4 (high warnings) + /permissive- (strict conformance).
+# GCC/Clang  : -Wall -Wextra -Wpedantic.
+# -----------------------------------------------------------------------
+function(_apply_compile_options TARGET)
+    if(MSVC)
+        target_compile_options(${TARGET} PRIVATE /W4 /permissive-)
+    else()
+        target_compile_options(${TARGET} PRIVATE -Wall -Wextra -Wpedantic)
+    endif()
+endfunction()
+
+# -----------------------------------------------------------------------
+# _apply_rpath: RPATH is an ELF (Linux) and Mach-O (macOS) concept; skip
+# entirely on Windows. Callers spell "relative to this binary" the ELF way,
+# $ORIGIN[/..]; Mach-O's loader has never heard of that token -- its
+# equivalent is @loader_path -- so it is translated here, once, instead of
+# every call site having to know which platform it's on. (For an executable
+# @loader_path is the executable's own directory; for a library, the
+# library's. That is exactly the layout this project uses: everything
+# lands flat in bin/, tests and examples one level down in bin/tests and
+# bin/examples.)
+# -----------------------------------------------------------------------
+function(_apply_rpath TARGET RPATH_VAL)
+    if(NOT WIN32)
+        if(APPLE)
+            string(REPLACE "$ORIGIN" "@loader_path" RPATH_VAL "${RPATH_VAL}")
+        endif()
+        set_target_properties(${TARGET} PROPERTIES
+            BUILD_RPATH   "${RPATH_VAL}"
+            INSTALL_RPATH "${RPATH_VAL}"
+        )
+    endif()
+endfunction()
+
+# -----------------------------------------------------------------------
+# _set_output_dirs(TARGET RUNTIME_DIR [LIBRARY_DIR]):
+#
+# Breeze.cmake sets CMAKE_RUNTIME_OUTPUT_DIRECTORY_<CONFIG> /
+# CMAKE_LIBRARY_OUTPUT_DIRECTORY_<CONFIG> globally (once, near the top) so
+# every target defaults to the flat bin/ layout. That also means every
+# new target's per-config RUNTIME_OUTPUT_DIRECTORY_<CONFIG> /
+# LIBRARY_OUTPUT_DIRECTORY_<CONFIG> property is pre-populated at creation
+# time -- and a per-config property always wins over the plain
+# (config-independent) one. So a module that needs a *different* output
+# directory (tests -> bin/tests, examples -> bin/examples) must override
+# the per-config properties too, or the override silently has no effect.
+# This helper does both in one place.
+# -----------------------------------------------------------------------
+function(_set_output_dirs TARGET RUNTIME_DIR)
+    set(_library_dir "${RUNTIME_DIR}")
+    if(ARGC GREATER 2)
+        set(_library_dir "${ARGV2}")
+    endif()
+    set_target_properties(${TARGET} PROPERTIES
+        RUNTIME_OUTPUT_DIRECTORY "${RUNTIME_DIR}"
+        LIBRARY_OUTPUT_DIRECTORY "${_library_dir}"
+    )
+    foreach(_cfg Debug Release RelWithDebInfo MinSizeRel)
+        string(TOUPPER "${_cfg}" _CFG)
+        set_target_properties(${TARGET} PROPERTIES
+            RUNTIME_OUTPUT_DIRECTORY_${_CFG} "${RUNTIME_DIR}"
+            LIBRARY_OUTPUT_DIRECTORY_${_CFG} "${_library_dir}"
+        )
+    endforeach()
+endfunction()
+
+# -----------------------------------------------------------------------
+# _copy_mingw_runtime_dlls(TARGET): copies PMN_MINGW_RUNTIME_DLLS (computed
+# once in Breeze.cmake's "MinGW runtime linking" section) next to
+# TARGET's own built binary, in the build tree, so it runs without a
+# manual step. install()-time placement is the matching
+# install(FILES ...) in Breeze.cmake's "install" section. A no-op
+# whenever PMN_MINGW_RUNTIME_DLLS is empty (every non-MinGW platform, or
+# a MinGW toolchain where none of the candidate DLLs were found).
+#
+# Called for every SHARED module unconditionally (source/Core's
+# core_lib/demo_core.dll always uses the dynamic runtime -- see the
+# "MinGW runtime linking" comment for why making it static too isn't an
+# option), and for EXECUTABLE/test/example targets only when
+# PMN_MINGW_STATIC_RUNTIME is OFF (the default): with it ON those are
+# statically linked and don't need these DLLs, so the caller skips this
+# call entirely rather than copying files nothing imports.
+# -----------------------------------------------------------------------
+function(_copy_mingw_runtime_dlls TARGET)
+    if(MINGW AND PMN_MINGW_RUNTIME_DLLS)
+        add_custom_command(TARGET ${TARGET} POST_BUILD
+            COMMAND ${CMAKE_COMMAND} -E copy_if_different ${PMN_MINGW_RUNTIME_DLLS} "$<TARGET_FILE_DIR:${TARGET}>"
+            COMMENT "Copying MinGW runtime DLLs next to ${TARGET}"
+            VERBATIM
+        )
+    endif()
+endfunction()
+
+# -----------------------------------------------------------------------
+# _copy_target_runtime_dlls(TARGET): on Windows (any compiler -- MSVC,
+# clang-cl, or MinGW), copies every SHARED-library dependency's own .dll
+# next to TARGET's binary, via CMake's TARGET_RUNTIME_DLLS generator
+# expression. This is the OTHER half of running on Windows that
+# _copy_mingw_runtime_dlls doesn't cover: that one only bundles the
+# compiler's OWN runtime (libgcc/libstdc++/winpthread); this one bundles
+# this project's SHARED modules (core_lib/demo_core.dll, and anything
+# else a module's own CMakeLists.txt declares SHARED).
+#
+# Needed specifically for add_test_module/add_example_module: they land
+# one directory below the primary modules (bin/tests, bin/examples),
+# with an RPATH of "$ORIGIN/.." for the ELF/Mach-O builds where that
+# works (see _apply_rpath) -- but Windows has no equivalent of a
+# *relative*, directory-based DLL search path, so a test or example that
+# depends on a SHARED module built by this project needs that DLL
+# copied into ITS OWN directory to run at all, not just the primary
+# one. (The primary modules -- add_exe_module -- don't need this: they
+# already land in the SAME flat bin/ directory as every SHARED module,
+# so they already find it there.) Confirmed directly by cross-building
+# for windows-x64-mingw64 and running the result under Wine: a test
+# depending on core_lib fails to start (STATUS_DLL_NOT_FOUND,
+# "libdemo_core.dll ... not found") without this.
+#
+# Delegates the actual copy to CopyRuntimeDlls.cmake rather than calling
+# `cmake -E copy_if_different` directly, because that fails the whole
+# build the moment TARGET_RUNTIME_DLLS is empty -- the common case for
+# any test/example that doesn't depend on a SHARED module -- and
+# `cmake -E copy_if_different <dest-only, no sources>` is exactly that:
+# zero sources. See that script for the confirmed failure and the
+# one-line `if(FILES)` fix.
+# -----------------------------------------------------------------------
+function(_copy_target_runtime_dlls TARGET)
+    if(WIN32)
+        add_custom_command(TARGET ${TARGET} POST_BUILD
+            COMMAND ${CMAKE_COMMAND}
+                -DDEST=$<TARGET_FILE_DIR:${TARGET}>
+                "-DFILES=$<TARGET_RUNTIME_DLLS:${TARGET}>"
+                -P "${PMN_BREEZE_CMAKE_DIR}/CopyRuntimeDlls.cmake"
+            COMMENT "Copying ${TARGET}'s own SHARED-library dependencies next to it"
+            VERBATIM
+        )
+    endif()
+endfunction()
+
+# -----------------------------------------------------------------------
+# _register_executable_target(TARGET): tracks every executable module
+# (exe/test/example) in a global property so _write_module_manifest()
+# can find them all without anything needing to know their names ahead
+# of time.
+# -----------------------------------------------------------------------
+function(_register_executable_target TARGET)
+    set_property(GLOBAL APPEND PROPERTY PMN_EXECUTABLE_TARGETS ${TARGET})
+endfunction()
+
+# -----------------------------------------------------------------------
+# _register_module_target(CATEGORY TARGET): tracks a target under
+# CATEGORY (PRIMARY, TEST, or EXAMPLE) in a global property so
+# Breeze.cmake's install() rules can be generated from whatever modules
+# actually got discovered, instead of a hardcoded target list that would
+# need editing every time a module is added or removed.
+# -----------------------------------------------------------------------
+function(_register_module_target CATEGORY TARGET)
+    set_property(GLOBAL APPEND PROPERTY PMN_MODULE_TARGETS_${CATEGORY} ${TARGET})
+endfunction()
+
+# -----------------------------------------------------------------------
+# _write_module_manifest(OUTPUT_DIR): call once, after every module has
+# been discovered, to emit "<target-name>=<absolute-path-to-binary>"
+# lines for every executable module into
+# OUTPUT_DIR/module_manifest-<CONFIG>.txt.
+#
+# breeze/scripts/run.sh / run.bat read this file to resolve a CMake target name to its
+# actual executable path -- so they never hardcode per-module paths and
+# never need editing when a module is added, removed, or renamed.
+# $<CONFIG> is part of the filename because file(GENERATE) requires that
+# for content (like $<TARGET_FILE:...>) that can differ per build
+# configuration under a multi-config generator (e.g. Ninja Multi-Config).
+# -----------------------------------------------------------------------
+function(_write_module_manifest OUTPUT_DIR)
+    get_property(_pmn_targets GLOBAL PROPERTY PMN_EXECUTABLE_TARGETS)
+    set(_manifest_content "")
+    foreach(_t ${_pmn_targets})
+        string(APPEND _manifest_content "${_t}=$<TARGET_FILE:${_t}>\n")
+    endforeach()
+    file(GENERATE
+        OUTPUT "${OUTPUT_DIR}/module_manifest-$<CONFIG>.txt"
+        CONTENT "${_manifest_content}"
+    )
+endfunction()
+
+# -----------------------------------------------------------------------
+# _finalize_module_target(TARGET MODULE_NAME [OUTPUT_NAME name] [DEPENDS ...])
+#
+# The tail every module macro below shares: identity compile definitions,
+# warning flags, OUTPUT_NAME, and DEPENDS linking. Centralized so all four
+# macros stay in lockstep -- edit once here instead of four times.
+# Re-parses the caller's raw ARGN, so it's safe to call as
+# _finalize_module_target(${NAME} ${_MODULE_NAME} ${ARGN}) even though
+# ARGN also contains keywords (TYPE, EXTRA_SOURCES, ...) this function
+# doesn't know about -- those are simply ignored.
+# -----------------------------------------------------------------------
+# -----------------------------------------------------------------------
+# _finalize_module_target(TARGET MODULE_NAME [OUTPUT_NAME name] [DEPENDS ...]
+#                          [NO_DOCS])
+#
+# The tail every module macro below shares: identity compile definitions,
+# warning flags, OUTPUT_NAME, DEPENDS linking, and an automatic per-module
+# Doxygen target (see breeze/cmake/Documentation.cmake) unless NO_DOCS is given.
+# Centralized so all four macros stay in lockstep -- edit once here
+# instead of four times. Re-parses the caller's raw ARGN, so it's safe to
+# call as _finalize_module_target(${NAME} ${_MODULE_NAME} ${ARGN}) even
+# though ARGN also contains keywords (TYPE, EXTRA_SOURCES, ...) this
+# function doesn't know about -- those are simply ignored.
+# -----------------------------------------------------------------------
+function(_finalize_module_target TARGET MODULE_NAME)
+    cmake_parse_arguments(FIN "NO_DOCS" "OUTPUT_NAME" "DEPENDS" ${ARGN})
+
+    # Every module and what it DEPENDS on, for _resolve_object_modules(): object
+    # modules can't be told apart from libraries here -- the module they name
+    # may not have been discovered yet -- so that is decided once all exist.
+    set_property(GLOBAL APPEND PROPERTY PMN_ALL_MODULES ${TARGET})
+    set_property(GLOBAL PROPERTY PMN_DEPENDS_${TARGET} "${FIN_DEPENDS}")
+
+    target_compile_definitions(${TARGET} PRIVATE
+        $<$<CONFIG:Debug>:DEBUG>
+        MODULE_NAME="${MODULE_NAME}"
+        PROJECT_NAME="${PROJECT_NAME}"
+        PROJECT_NAME_CODE="${PROJECT_CODE_NAME}"
+        PROJECT_VER="${PROJECT_VERSION}"
+    )
+    _apply_compile_options(${TARGET})
+
+    # An objects module has no file to name: for it OUTPUT_NAME is only the name
+    # MODULE_NAME carries (the library it is a piece of, usually).
+    get_target_property(_pmn_target_type ${TARGET} TYPE)
+    if(FIN_OUTPUT_NAME AND NOT _pmn_target_type STREQUAL "OBJECT_LIBRARY")
+        set_target_properties(${TARGET} PROPERTIES OUTPUT_NAME ${FIN_OUTPUT_NAME})
+    endif()
+    if(FIN_DEPENDS)
+        target_link_libraries(${TARGET} PRIVATE ${FIN_DEPENDS})
+    endif()
+    if(NOT FIN_NO_DOCS)
+        _add_module_docs(${TARGET})
+    endif()
+endfunction()
+
+# =============================================================================
+# add_lib_module(NAME [TYPE STATIC|SHARED] [OUTPUT_NAME name] [DEPENDS ...]
+#                 [EXTRA_SOURCES ...] [NO_DOCS])
+#
+# Called from a library module's own CMakeLists.txt (e.g. source/Core/CMakeLists.txt).
+# Sources/headers are globbed relative to that module's own directory:
+# src/*.cpp and include/*.h(pp) underneath it. TYPE picks STATIC or SHARED
+# for this module only; omit it to use the project-wide default
+# (BUILD_SHARED_LIBS -- set in Breeze.cmake's OPTIONS section, or pass
+# -DBUILD_SHARED_LIBS=ON at configure time).
+#
+# Headers are globbed in purely so they show up in IDE project trees --
+# CMake never compiles headers, so this is inert for the actual build.
+# =============================================================================
+macro(add_lib_module NAME)
+    cmake_parse_arguments(ARG "" "OUTPUT_NAME;TYPE" "DEPENDS;EXTRA_SOURCES" ${ARGN})
+
+    if(ARG_OUTPUT_NAME)
+        set(_MODULE_NAME ${ARG_OUTPUT_NAME})
+    else()
+        set(_MODULE_NAME ${NAME})
+    endif()
+
+    if(ARG_TYPE)
+        set(_LIB_TYPE ${ARG_TYPE})
+    elseif(BUILD_SHARED_LIBS)
+        set(_LIB_TYPE SHARED)
+    else()
+        set(_LIB_TYPE STATIC)
+    endif()
+    if(NOT _LIB_TYPE MATCHES "^(STATIC|SHARED)$")
+        message(FATAL_ERROR "add_lib_module(${NAME}): TYPE must be STATIC or SHARED, got '${_LIB_TYPE}'")
+    endif()
+
+    file(GLOB_RECURSE ${NAME}_SOURCES CONFIGURE_DEPENDS src/*.cpp)
+    file(GLOB_RECURSE ${NAME}_HEADERS CONFIGURE_DEPENDS include/*.h include/*.hpp)
+
+    add_library(${NAME} ${_LIB_TYPE} ${${NAME}_SOURCES} ${${NAME}_HEADERS} ${ARG_EXTRA_SOURCES})
+    target_include_directories(${NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
+
+    if(_LIB_TYPE STREQUAL "STATIC")
+        # Keep static libs relocatable in case they end up linked into a
+        # shared library or PIE executable later.
+        set_target_properties(${NAME} PROPERTIES POSITION_INDEPENDENT_CODE ON)
+    else()
+        # LIBRARY_OUTPUT_DIRECTORY controls .so placement on Linux.
+        # RUNTIME_OUTPUT_DIRECTORY controls .dll placement on Windows.
+        # WINDOWS_EXPORT_ALL_SYMBOLS auto-generates a .def file so all
+        # public symbols are exported without __declspec(dllexport).
+        # Remove if you prefer explicit visibility macros instead.
+        _set_output_dirs(${NAME} "${CMAKE_BINARY_DIR}/${RUNTIME_OUTPUT_SUBDIR}" "${CMAKE_BINARY_DIR}/${LIBRARY_OUTPUT_SUBDIR}")
+        set_target_properties(${NAME} PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON)
+
+        # A SHARED module always keeps the dynamic MinGW runtime -- see
+        # Breeze.cmake's "MinGW runtime linking" comment for why it's
+        # never a candidate for PMN_MINGW_STATIC_RUNTIME -- so this call
+        # is unconditional, unlike the EXECUTABLE-producing macros below.
+        _copy_mingw_runtime_dlls(${NAME})
+    endif()
+
+    _register_module_target(PRIMARY ${NAME})
+    _finalize_module_target(${NAME} ${_MODULE_NAME} ${ARGN})
+endmacro()
+
+# Back-compat wrappers for the old two-macro spelling.
+# Prefer add_lib_module(... TYPE STATIC|SHARED) directly in new code.
+macro(add_static_lib_module NAME)
+    add_lib_module(${NAME} TYPE STATIC ${ARGN})
+endmacro()
+macro(add_shared_lib_module NAME)
+    add_lib_module(${NAME} TYPE SHARED ${ARGN})
+endmacro()
+
+# =============================================================================
+# add_objects_module(NAME [OUTPUT_NAME name] [DEPENDS ...] [EXTRA_SOURCES ...] [NO_DOCS])
+#
+# Called from an objects module's own CMakeLists.txt (e.g. source/CoreMath/CMakeLists.txt).
+# An OBJECT library: its sources are compiled, and that is all -- no archive, no
+# DLL, nothing in bin/ or lib/. Name it in the DEPENDS of a library, an
+# executable, a test, an example, or another objects module, and its object
+# files become part of that target. That is what makes it the way to split
+# one big library into pieces: each piece is a module of its own (own
+# directory, own include/, built and tested on its own), and the library
+# that is left is one line naming them.
+#
+#   source/CoreMath/CMakeLists.txt   add_objects_module(core_math)
+#   source/CoreIo/CMakeLists.txt     add_objects_module(core_io DEPENDS core_math)
+#   source/Core/CMakeLists.txt       add_lib_module(core DEPENDS core_io)
+#
+# Sources/headers are globbed like a library's: src/*.cpp and include/*.h(pp)
+# under the module's own directory. include/ is public: whoever takes the
+# objects sees the headers -- and for a library, so do ITS consumers (see
+# _resolve_object_modules below), because the headers of the pieces are the
+# library's headers. Keep a piece's private headers in src/.
+#
+# OUTPUT_NAME names nothing here -- there is no file -- but is what the
+# MODULE_NAME definition carries: pass the library's name so the pieces
+# of one library all identify as it.
+#
+# Not installed, not run, not in the module manifest: the objects live on
+# inside whatever took them. Always compiled position-independent, since
+# they may land in a shared library.
+# =============================================================================
+macro(add_objects_module NAME)
+    cmake_parse_arguments(ARG "" "OUTPUT_NAME" "DEPENDS;EXTRA_SOURCES" ${ARGN})
+
+    if(ARG_OUTPUT_NAME)
+        set(_MODULE_NAME ${ARG_OUTPUT_NAME})
+    else()
+        set(_MODULE_NAME ${NAME})
+    endif()
+
+    file(GLOB_RECURSE ${NAME}_SOURCES CONFIGURE_DEPENDS src/*.cpp)
+    file(GLOB_RECURSE ${NAME}_HEADERS CONFIGURE_DEPENDS include/*.h include/*.hpp)
+
+    add_library(${NAME} OBJECT ${${NAME}_SOURCES} ${${NAME}_HEADERS} ${ARG_EXTRA_SOURCES})
+    target_include_directories(${NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
+    set_target_properties(${NAME} PROPERTIES POSITION_INDEPENDENT_CODE ON)
+
+    # Its own category: install() (Breeze.cmake) only takes PRIMARY, and an
+    # OBJECT library has nothing of its own to install.
+    _register_module_target(OBJECTS ${NAME})
+    _finalize_module_target(${NAME} ${_MODULE_NAME} ${ARGN})
+endmacro()
+
+# -----------------------------------------------------------------------
+# _resolve_object_modules(): call once, after every module has been
+# discovered (Breeze.cmake does).
+#
+# CMake links an OBJECT library's objects into the target that names it,
+# exactly once -- and no further. A piece that DEPENDS on another piece does
+# not carry that piece's objects along, so a library naming only the first
+# one fails at link time with undefined references. And a library that has
+# taken a piece's objects does not pass the piece's headers on to its own
+# consumers, unless it links the piece PUBLIC.
+#
+# So, for every module target, the objects modules it names -- directly, or
+# through other objects modules -- are collected, and each is linked:
+#
+#   * library (static/shared) or objects module: PUBLIC. Objects go into it;
+#     its consumers see the pieces' include/ and compile definitions, and
+#     get no second copy of the objects -- they are inside it already.
+#   * executable (app, test, example): PRIVATE. Nothing consumes it.
+#
+# Only objects modules are followed. A module that is an ordinary library
+# keeps whatever it has inside it; what a piece links (a static library, say)
+# is reached by CMake on its own at the final link.
+#
+# Done here and not in the macros because the macros can't know what a
+# name in DEPENDS is: modules are discovered in directory order, and the
+# one named may not exist yet.
+# -----------------------------------------------------------------------
+function(_resolve_object_modules)
+    get_property(_pmn_all_modules GLOBAL PROPERTY PMN_ALL_MODULES)
+    foreach(_pmn_module IN LISTS _pmn_all_modules)
+        get_target_property(_pmn_module_type ${_pmn_module} TYPE)
+        get_property(_pmn_direct GLOBAL PROPERTY PMN_DEPENDS_${_pmn_module})
+
+        set(_pmn_queue "${_pmn_direct}")
+        set(_pmn_seen "")
+        set(_pmn_pieces "")
+        while(NOT "${_pmn_queue}" STREQUAL "")
+            list(POP_FRONT _pmn_queue _pmn_name)
+            if(_pmn_name IN_LIST _pmn_seen)
+                continue()
+            endif()
+            list(APPEND _pmn_seen ${_pmn_name})
+            if(NOT TARGET ${_pmn_name})
+                continue()
+            endif()
+            get_target_property(_pmn_name_type ${_pmn_name} TYPE)
+            if(NOT _pmn_name_type STREQUAL "OBJECT_LIBRARY")
+                continue()
+            endif()
+            if(_pmn_name STREQUAL _pmn_module)
+                message(FATAL_ERROR
+                    "The objects module '${_pmn_module}' depends on itself, through the "
+                    "objects modules it names (directly or not) in DEPENDS.")
+            endif()
+            list(APPEND _pmn_pieces ${_pmn_name})
+            get_property(_pmn_more GLOBAL PROPERTY PMN_DEPENDS_${_pmn_name})
+            list(APPEND _pmn_queue ${_pmn_more})
+        endwhile()
+
+        foreach(_pmn_piece IN LISTS _pmn_pieces)
+            if(_pmn_module_type STREQUAL "EXECUTABLE")
+                # Already linked PRIVATE when named directly (_finalize_module_target).
+                if(NOT _pmn_piece IN_LIST _pmn_direct)
+                    target_link_libraries(${_pmn_module} PRIVATE ${_pmn_piece})
+                endif()
+            else()
+                target_link_libraries(${_pmn_module} PUBLIC ${_pmn_piece})
+            endif()
+        endforeach()
+    endforeach()
+endfunction()
+
+# =============================================================================
+# add_exe_module(NAME [OUTPUT_NAME name] [DEPENDS ...] [EXTRA_SOURCES ...] [NO_DOCS])
+#
+# Called from an app module's own CMakeLists.txt (e.g. HelloApp/CMakeLists.txt).
+# Sources/headers are globbed relative to that module's own directory:
+# *.cpp and include/*.h(pp) underneath it.
+# =============================================================================
+macro(add_exe_module NAME)
+    cmake_parse_arguments(ARG "" "OUTPUT_NAME" "DEPENDS;EXTRA_SOURCES" ${ARGN})
+
+    if(ARG_OUTPUT_NAME)
+        set(_MODULE_NAME ${ARG_OUTPUT_NAME})
+    else()
+        set(_MODULE_NAME ${NAME})
+    endif()
+
+    file(GLOB_RECURSE ${NAME}_SOURCES CONFIGURE_DEPENDS *.cpp)
+    file(GLOB_RECURSE ${NAME}_HEADERS CONFIGURE_DEPENDS include/*.h include/*.hpp)
+
+    add_executable(${NAME} ${${NAME}_SOURCES} ${${NAME}_HEADERS} ${ARG_EXTRA_SOURCES})
+    target_include_directories(${NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
+    _set_output_dirs(${NAME} "${CMAKE_BINARY_DIR}/${RUNTIME_OUTPUT_SUBDIR}")
+    _apply_rpath(${NAME} "$ORIGIN")
+    _register_module_target(PRIMARY ${NAME})
+    _register_executable_target(${NAME})
+    # Skipped when PMN_MINGW_STATIC_RUNTIME is ON: that link option (set in
+    # Breeze.cmake) makes this target self-contained instead, and these
+    # DLLs would be unused files sitting next to it. See that option's own
+    # comment for why OFF (dynamic, copied here) is the safe default.
+    if(NOT PMN_MINGW_STATIC_RUNTIME)
+        _copy_mingw_runtime_dlls(${NAME})
+    endif()
+
+    _finalize_module_target(${NAME} ${_MODULE_NAME} ${ARGN})
+endmacro()
+
+# =============================================================================
+# add_test_module(NAME [OUTPUT_NAME name] [DEPENDS ...] [EXTRA_SOURCES ...] [NO_DOCS])
+#
+# Called from a test module's own CMakeLists.txt (e.g. source/tests/mytest/CMakeLists.txt).
+# Lands in bin/tests/, so shared-lib deps one level up need $ORIGIN/...
+# EXCLUDE_FROM_ALL keeps it out of the default build; BUILD_TESTS opts it
+# back in.
+# =============================================================================
+macro(add_test_module NAME)
+    cmake_parse_arguments(ARG "" "OUTPUT_NAME" "DEPENDS;EXTRA_SOURCES" ${ARGN})
+
+    if(ARG_OUTPUT_NAME)
+        set(_MODULE_NAME ${ARG_OUTPUT_NAME})
+    else()
+        set(_MODULE_NAME ${NAME})
+    endif()
+
+    file(GLOB_RECURSE ${NAME}_SOURCES CONFIGURE_DEPENDS *.cpp)
+    file(GLOB_RECURSE ${NAME}_HEADERS CONFIGURE_DEPENDS include/*.h include/*.hpp)
+
+    if(BUILD_TESTS)
+        add_executable(${NAME} ${${NAME}_SOURCES} ${${NAME}_HEADERS} ${ARG_EXTRA_SOURCES})
+    else()
+        add_executable(${NAME} EXCLUDE_FROM_ALL ${${NAME}_SOURCES} ${${NAME}_HEADERS} ${ARG_EXTRA_SOURCES})
+    endif()
+    target_include_directories(${NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include)
+    _set_output_dirs(${NAME} "${CMAKE_BINARY_DIR}/${RUNTIME_OUTPUT_SUBDIR}/tests")
+    _apply_rpath(${NAME} "$ORIGIN/..")
+    _register_module_target(TEST ${NAME})
+    _register_executable_target(${NAME})
+    # See add_exe_module's identical guard on the first call: skipped
+    # under PMN_MINGW_STATIC_RUNTIME, which makes this target
+    # self-contained instead. The second call is unconditional and
+    # WIN32-wide (not just MinGW): bin/tests/ is a different directory
+    # from bin/, so any SHARED module this test depends on (this
+    # project's core_lib included) needs its own .dll copied here too --
+    # see _copy_target_runtime_dlls's own comment for why a *different*
+    # mechanism than the one above is needed for that.
+    if(NOT PMN_MINGW_STATIC_RUNTIME)
+        _copy_mingw_runtime_dlls(${NAME})
+    endif()
+    _copy_target_runtime_dlls(${NAME})
+
+    _finalize_module_target(${NAME} ${_MODULE_NAME} ${ARGN})
+
+    add_test(NAME ${NAME} COMMAND ${NAME})
+    add_dependencies(all_tests ${NAME})
+endmacro()
+
+# =============================================================================
+# add_example_module(NAME [OUTPUT_NAME name] [DEPENDS ...] [EXTRA_SOURCES ...] [NO_DOCS])
+#
+# Called from an example module's own CMakeLists.txt (e.g. source/examples/myexample/CMakeLists.txt).
+# Same bin/examples/ + $ORIGIN/.. layout as tests.
+# =============================================================================
+macro(add_example_module NAME)
+    cmake_parse_arguments(ARG "" "OUTPUT_NAME" "DEPENDS;EXTRA_SOURCES" ${ARGN})
+
+    if(ARG_OUTPUT_NAME)
+        set(_MODULE_NAME ${ARG_OUTPUT_NAME})
+    else()
+        set(_MODULE_NAME ${NAME})
+    endif()
+
+    file(GLOB_RECURSE ${NAME}_SOURCES CONFIGURE_DEPENDS *.cpp)
+    file(GLOB_RECURSE ${NAME}_HEADERS CONFIGURE_DEPENDS include/*.h include/*.hpp)
+
+    if(BUILD_EXAMPLES)
+        add_executable(${NAME} ${${NAME}_SOURCES} ${${NAME}_HEADERS} ${ARG_EXTRA_SOURCES})
+    else()
+        add_executable(${NAME} EXCLUDE_FROM_ALL ${${NAME}_SOURCES} ${${NAME}_HEADERS} ${ARG_EXTRA_SOURCES})
+    endif()
+    target_include_directories(${NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include)
+    _set_output_dirs(${NAME} "${CMAKE_BINARY_DIR}/${RUNTIME_OUTPUT_SUBDIR}/examples")
+    _apply_rpath(${NAME} "$ORIGIN/..")
+    _register_module_target(EXAMPLE ${NAME})
+    _register_executable_target(${NAME})
+    # See add_test_module's identical pair of calls and comment just above.
+    if(NOT PMN_MINGW_STATIC_RUNTIME)
+        _copy_mingw_runtime_dlls(${NAME})
+    endif()
+    _copy_target_runtime_dlls(${NAME})
+
+    _finalize_module_target(${NAME} ${_MODULE_NAME} ${ARGN})
+
+    add_dependencies(all_examples ${NAME})
+endmacro()
diff --git a/breeze/cmake/CopyRuntimeDlls.cmake b/breeze/cmake/CopyRuntimeDlls.cmake
new file mode 100644
index 0000000..e64ddd3
--- /dev/null
+++ b/breeze/cmake/CopyRuntimeDlls.cmake
@@ -0,0 +1,21 @@
+# =============================================================================
+# CopyRuntimeDlls.cmake
+#
+# Usage (from a POST_BUILD add_custom_command; see BuildHelpers.cmake's
+# _copy_target_runtime_dlls()):
+#   cmake -DDEST=<dir> "-DFILES=$<TARGET_RUNTIME_DLLS:tgt>" -P CopyRuntimeDlls.cmake
+#
+# Exists only because `cmake -E copy_if_different <dest>` -- the obvious,
+# one-line way to do this -- errors out (and fails the whole build) when
+# given zero source files, which $<TARGET_RUNTIME_DLLS:tgt> legitimately
+# evaluates to for most targets (anything that links no SHARED library,
+# which is most executables in most projects, this one's included: only
+# a target that depends on a SHARED module -- like core_lib -- has any
+# files here at all). Confirmed directly: without this indirection, that
+# empty case stops the build with cmake -E's own usage text as the error.
+# A plain `if(FILES)` here is all it takes to make "nothing to do" a
+# success instead of a build failure.
+# =============================================================================
+if(FILES)
+    file(COPY ${FILES} DESTINATION "${DEST}")
+endif()
diff --git a/breeze/cmake/Dependencies.cmake b/breeze/cmake/Dependencies.cmake
new file mode 100644
index 0000000..2d98a79
--- /dev/null
+++ b/breeze/cmake/Dependencies.cmake
@@ -0,0 +1,159 @@
+# =============================================================================
+# Dependencies.cmake
+#
+# Three ways to bring in a third-party dependency, and one helper that ties
+# two of them together. All three keep the dependency's own warnings out of
+# your build (SYSTEM) and its sources out of compile_commands.json, so
+# clangd/clang-tidy stay focused on code this project owns.
+#
+#   add_vendor_header_only(NAME [INCLUDE_DIR <dir>])
+#       A buildless (header-only) drop checked into vendor/<NAME>/include
+#       (or vendor/<INCLUDE_DIR>). Wraps it as an INTERFACE target NAME.
+#
+#   add_vendor_subdirectory(SUBDIR)
+#       A vendored dependency that ships its own CMakeLists.txt, checked
+#       into vendor/<SUBDIR> (a plain source drop, git submodule, or git
+#       subtree). Whatever target names that CMakeLists.txt defines are
+#       what you DEPENDS on.
+#
+#   add_dependency(NAME <FetchContent_Declare args...>)
+#       CMake's native find_package + FetchContent integration: pass
+#       FIND_PACKAGE_ARGS ... to try an already-installed copy (an apt/
+#       vcpkg/conan package) first, and only download + build from source
+#       if nothing is found. Omit FIND_PACKAGE_ARGS to always fetch.
+#       https://cmake.org/cmake/help/latest/module/FetchContent.html#integrating-with-find-package
+#
+# All three are safe to call more than once for the same name (e.g. two
+# modules that both need the same dependency) -- later calls are no-ops.
+#
+# A module DEPENDS on whatever target the chosen path defines, exactly
+# like depending on another module -- add_lib_module/add_exe_module/etc. don't
+# need to know or care which of the three supplied it.
+#
+# IMPORTANT -- installing: a vendored/fetched dependency's own
+# CMakeLists.txt usually has its own install() rules, and there is no
+# reliable, version-independent way to suppress them from here (EXCLUDE_
+# FROM_ALL's effect on install() is explicitly documented as undefined,
+# and CMAKE_SKIP_INSTALL_RULES breaks `cmake --install` outright for
+# FetchContent -- both were tried and rejected). The actual fix lives in
+# CMakeLists.txt: our own install(TARGETS ...) calls are tagged
+# COMPONENT ${PROJECT_CODE_NAME}, and breeze/scripts/install.sh / install.bat always pass
+# --component so a third-party dependency's untagged install rules are
+# never pulled in. Installing with plain `cmake --install build` (no
+# --component) will also install whatever the dependency wanted to
+# install, typically under CMAKE_INSTALL_PREFIX (e.g. /usr/local) --
+# use the install script, or pass --component yourself.
+# =============================================================================
+
+include_guard(GLOBAL)
+
+# -----------------------------------------------------------------------
+# _exclude_from_compile_commands(DIR): drop every target defined under
+# DIR from compile_commands.json. Applied to vendored/fetched third-party
+# code so the exported compile database stays focused on code this
+# project actually owns.
+# -----------------------------------------------------------------------
+function(_exclude_from_compile_commands DIR)
+    if(NOT IS_DIRECTORY "${DIR}")
+        return()
+    endif()
+    get_property(_pmn_dir_targets DIRECTORY "${DIR}" PROPERTY BUILDSYSTEM_TARGETS)
+    foreach(_t ${_pmn_dir_targets})
+        set_target_properties(${_t} PROPERTIES EXPORT_COMPILE_COMMANDS OFF)
+    endforeach()
+endfunction()
+
+# -----------------------------------------------------------------------
+# add_vendor_header_only(NAME [INCLUDE_DIR <dir>])
+# -----------------------------------------------------------------------
+macro(add_vendor_header_only NAME)
+    cmake_parse_arguments(ARG "" "INCLUDE_DIR" "" ${ARGN})
+    if(NOT TARGET ${NAME})
+        add_library(${NAME} INTERFACE)
+        if(ARG_INCLUDE_DIR)
+            target_include_directories(${NAME} SYSTEM INTERFACE "${CMAKE_SOURCE_DIR}/vendor/${ARG_INCLUDE_DIR}")
+        else()
+            target_include_directories(${NAME} SYSTEM INTERFACE "${CMAKE_SOURCE_DIR}/vendor/${NAME}/include")
+        endif()
+    endif()
+endmacro()
+
+# -----------------------------------------------------------------------
+# add_vendor_subdirectory(SUBDIR)
+#
+# EXCLUDE_FROM_ALL means only targets actually depended on via
+# target_link_libraries get built. SYSTEM marks its headers so our
+# per-module warning flags (added only by add_lib_module/add_objects_module/
+# add_exe_module/etc., never globally) don't fire when *our* code includes them.
+# -----------------------------------------------------------------------
+macro(add_vendor_subdirectory SUBDIR)
+    get_property(_pmn_vendor_added GLOBAL PROPERTY PMN_VENDOR_ADDED_${SUBDIR} SET)
+    if(NOT _pmn_vendor_added)
+        set_property(GLOBAL PROPERTY PMN_VENDOR_ADDED_${SUBDIR} TRUE)
+        add_subdirectory(
+            "${CMAKE_SOURCE_DIR}/vendor/${SUBDIR}"
+            "${CMAKE_BINARY_DIR}/vendor/${SUBDIR}"
+            EXCLUDE_FROM_ALL SYSTEM
+        )
+        _exclude_from_compile_commands("${CMAKE_SOURCE_DIR}/vendor/${SUBDIR}")
+    endif()
+endmacro()
+
+# -----------------------------------------------------------------------
+# add_dependency(NAME <FetchContent_Declare args...>)
+#
+# Example -- prefer an installed copy that's new enough, fetch+build from
+# source otherwise:
+#   add_dependency(fmt
+#       GIT_REPOSITORY https://github.com/fmtlib/fmt.git
+#       GIT_TAG        12.1.0
+#       GIT_SHALLOW    TRUE
+#       FIND_PACKAGE_ARGS 12 NAMES fmt
+#   )
+#   add_lib_module(mylib DEPENDS fmt::fmt)
+#
+# Always give FIND_PACKAGE_ARGS a minimum version (the "12" above). Without
+# one, ANY installed copy beats the pinned GIT_TAG -- including a distro
+# package years older than the pin -- so a "pinned" dependency isn't. A
+# dependency's own CMake options (fmt's FMT_MODULE, say) are set with
+# set(<OPTION> <value> CACHE ...) BEFORE this call. source/Core/CMakeLists.txt
+# is the real, commented instance of both.
+#
+# FetchContent_MakeAvailable() is documented idempotent per name, so
+# calling this more than once for the same NAME (from multiple modules)
+# is safe.
+#
+# The targets it makes are usable from EVERY module, wherever the call is
+# made and whichever module CMake reaches first -- one module can declare
+# fmt and another just DEPENDS on fmt::fmt. A copy built from source gets
+# that for free (its targets are global). An installed copy found through
+# FIND_PACKAGE_ARGS does not: find_package() defines imported targets in the
+# directory that called it and below, so a sibling module's
+# target_link_libraries(... fmt::fmt) failed with "target was not found" --
+# only on machines that happen to have the package installed. Hence
+# CMAKE_FIND_PACKAGE_TARGETS_GLOBAL, for the duration of FetchContent_
+# MakeAvailable -- not of FetchContent_Declare, which reads the variable too
+# and, in CMake 3.24 to 3.28 at least, builds a broken find_package() call
+# from it ("Argument not separated from preceding token by whitespace").
+# -----------------------------------------------------------------------
+macro(add_dependency NAME)
+    include(FetchContent)
+    FetchContent_Declare(${NAME} SYSTEM ${ARGN})
+    if(DEFINED CMAKE_FIND_PACKAGE_TARGETS_GLOBAL)
+        set(_pmn_prev_targets_global "${CMAKE_FIND_PACKAGE_TARGETS_GLOBAL}")
+    else()
+        unset(_pmn_prev_targets_global)
+    endif()
+    set(CMAKE_FIND_PACKAGE_TARGETS_GLOBAL ON)
+    FetchContent_MakeAvailable(${NAME})
+    if(DEFINED _pmn_prev_targets_global)
+        set(CMAKE_FIND_PACKAGE_TARGETS_GLOBAL "${_pmn_prev_targets_global}")
+    else()
+        unset(CMAKE_FIND_PACKAGE_TARGETS_GLOBAL)
+    endif()
+    unset(_pmn_prev_targets_global)
+    string(TOLOWER "${NAME}" _pmn_lc_name)
+    if(DEFINED ${_pmn_lc_name}_SOURCE_DIR)
+        _exclude_from_compile_commands("${${_pmn_lc_name}_SOURCE_DIR}")
+    endif()
+endmacro()
diff --git a/breeze/cmake/Documentation.cmake b/breeze/cmake/Documentation.cmake
new file mode 100644
index 0000000..ec0214a
--- /dev/null
+++ b/breeze/cmake/Documentation.cmake
@@ -0,0 +1,190 @@
+# =============================================================================
+# Documentation.cmake
+#
+# Automatic, per-module Doxygen documentation, using a pinned Doxygen
+# version -- never your system's doxygen, so every machine gets identical
+# output. Zero setup required at the CMakeLists.txt level: every module
+# registered via add_lib_module/add_objects_module/add_exe_module/
+# add_test_module/add_example_module gets its own documentation target for free -- nothing
+# to add to a module's own CMakeLists.txt. Vendored and fetched
+# dependencies (breeze/cmake/Dependencies.cmake) are never auto-documented, same
+# reasoning as their compile_commands.json exclusion: it's not your code.
+#
+# IMPORTANT: this file only ever LOOKS for an already-downloaded pinned
+# Doxygen (see breeze/cmake/DoxygenPin.cmake for where) -- it never downloads
+# anything itself, so a plain `breeze/scripts/build.sh` never touches Doxygen or
+# needs network access. Run `breeze/scripts/setup.sh` / `setup.bat` once (which
+# runs breeze/cmake/FetchDoxygen.cmake) to actually fetch it; until then,
+# documentation targets print a message pointing at that script instead
+# of building, and everything else builds completely normally.
+#
+# What gets generated, per module <target>, once set up:
+#   out/docs/<target>/html/index.html   -- via `cmake --build <build-dir> --target docs_<target>`
+# Plus one landing page linking to all of them:
+#   out/docs/index.html                 -- via `cmake --build <build-dir> --target docs`
+# (or just run breeze/scripts/docs.sh / docs.bat, which builds `docs` and prints the path)
+# Paths above use the defaults from project/Configuration.cmake (DOCS_OUTPUT_DIR).
+#
+# Configuring it:
+#   -DENABLE_DOXYGEN=OFF                disable entirely (skips even the presence check)
+#   -DDOXYGEN_PINNED_VERSION=1.17.0     use a different pinned version (also
+#       update the two SHA256 hashes in breeze/cmake/DoxygenPin.cmake to match
+#       that release's assets, and re-run breeze/scripts/setup.sh)
+#   -DDOXYGEN_WARN_IF_UNDOCUMENTED=YES / -DDOXYGEN_QUIET=NO   stricter/louder output
+#   -DDOXYGEN_<ANY_DOXYFILE_TAG>=...    any Doxyfile tag can be set this way --
+#       see https://www.doxygen.nl/manual/config.html
+# A module can opt out with NO_DOCS, e.g.:
+#   add_lib_module(core_lib TYPE SHARED NO_DOCS ...)
+# =============================================================================
+
+include_guard(GLOBAL)
+
+option(ENABLE_DOXYGEN "Generate per-module Doxygen documentation using a pinned, project-managed Doxygen (run breeze/scripts/setup.sh once to fetch it)" ON)
+
+if(ENABLE_DOXYGEN)
+    include("${CMAKE_CURRENT_LIST_DIR}/DoxygenPin.cmake")
+
+    if(NOT DOXYGEN_PIN_PLATFORM_SUPPORTED)
+        message(WARNING "No pinned Doxygen ${DOXYGEN_PINNED_VERSION} binary is configured for this "
+                         "host platform. Install Doxygen ${DOXYGEN_PINNED_VERSION} manually, make sure "
+                         "it's on PATH or pass -DDOXYGEN_EXECUTABLE=/path/to/doxygen, or extend "
+                         "breeze/cmake/DoxygenPin.cmake with a download URL + hash for this platform.")
+        set(ENABLE_DOXYGEN OFF)
+    elseif(NOT EXISTS "${DOXYGEN_PIN_EXECUTABLE}")
+        # Not fetched yet -- see the file header. Deliberately not a
+        # message() here: this is the normal, expected state before
+        # breeze/scripts/setup.sh has ever run, not something to warn about.
+        set(ENABLE_DOXYGEN OFF)
+    else()
+        # Pre-seed DOXYGEN_EXECUTABLE with our pinned path *before*
+        # find_package(Doxygen) runs, rather than overriding it
+        # afterward. find_program() (which find_package uses internally)
+        # does not re-search when the cache variable already holds a
+        # valid path -- so this makes find_package() treat our pinned
+        # copy as the one it found, and run its own normal success path
+        # using it: creating the Doxygen::doxygen imported target,
+        # determining DOXYGEN_VERSION, and generating the Doxyfile
+        # template doxygen_add_docs() needs. All of that only happens as
+        # a side effect of find_package() succeeding -- overriding
+        # DOXYGEN_EXECUTABLE *after* calling it (the previous approach
+        # here) leaves those steps never having run at all, which
+        # doxygen_add_docs() then fails on. This way we don't have to
+        # reimplement any of find_package's own (undocumented, and
+        # confirmed version-dependent -- CMake 3.28 and 4.3 both hit
+        # this differently) internal machinery ourselves.
+        set(DOXYGEN_EXECUTABLE "${DOXYGEN_PIN_EXECUTABLE}" CACHE FILEPATH "Pinned Doxygen executable (never the system's)" FORCE)
+    endif()
+endif()
+
+if(ENABLE_DOXYGEN)
+    # Also searches for `dot` (Graphviz) for call graphs -- an optional,
+    # system-detected enhancement, unrelated to the doxygen executable
+    # itself, which is pre-seeded above to always resolve to our pinned
+    # copy rather than a system one.
+    find_package(Doxygen QUIET OPTIONAL_COMPONENTS dot)
+
+    if(NOT DOXYGEN_FOUND)
+        message(WARNING "Pre-seeding DOXYGEN_EXECUTABLE with the pinned Doxygen at "
+                         "${DOXYGEN_PIN_EXECUTABLE} did not result in find_package(Doxygen) "
+                         "succeeding. Documentation will be disabled for this configure.")
+        set(ENABLE_DOXYGEN OFF)
+    endif()
+endif()
+
+if(ENABLE_DOXYGEN)
+    message(STATUS "Doxygen ${DOXYGEN_VERSION} ready (pinned, not system-installed: ${DOXYGEN_EXECUTABLE}) -- per-module documentation enabled")
+
+    # Project-wide defaults, one Doxyfile tag per DOXYGEN_<TAG> variable.
+    # Override any of them with -DDOXYGEN_<TAG>=... at configure time.
+    # Kept deliberately quiet and lenient by default (no warnings about
+    # undocumented entities) so a freshly generated module with zero
+    # doxygen comments still produces clean, useful output -- browsable
+    # files/functions/call graphs -- instead of a wall of warnings.
+    set(DOXYGEN_GENERATE_HTML YES)
+    set(DOXYGEN_GENERATE_LATEX NO)
+    set(DOXYGEN_EXTRACT_ALL YES)
+    set(DOXYGEN_EXTRACT_STATIC YES)
+    set(DOXYGEN_EXTRACT_PRIVATE NO)
+    set(DOXYGEN_WARN_IF_UNDOCUMENTED NO)
+    set(DOXYGEN_QUIET YES)
+    set(DOXYGEN_RECURSIVE YES)
+    set(DOXYGEN_SOURCE_BROWSER YES)
+    set(DOXYGEN_GENERATE_TREEVIEW YES)
+    if(DOXYGEN_DOT_FOUND)
+        set(DOXYGEN_HAVE_DOT YES)
+        set(DOXYGEN_CALL_GRAPH YES)
+        set(DOXYGEN_CALLER_GRAPH YES)
+    endif()
+
+    add_custom_target(docs COMMENT "Build documentation for every module")
+else()
+    add_custom_target(docs
+        COMMAND ${CMAKE_COMMAND} -E echo
+            "Documentation isn't set up yet (or ENABLE_DOXYGEN=OFF). Run breeze/scripts/setup.sh (or setup.bat) once to fetch the pinned Doxygen, then reconfigure."
+        VERBATIM
+    )
+endif()
+
+# -----------------------------------------------------------------------
+# _add_module_docs(TARGET): called automatically from _finalize_module_target
+# for every module -- creates docs_<TARGET> (a Doxygen run scoped to that
+# module's own directory) and wires it into the aggregate `docs` target.
+# A no-op if ENABLE_DOXYGEN is off. Excluded from the default build same
+# as tests/examples -- documentation is opt-in per build, not generated
+# on every compile.
+#
+# If the module's own directory has a README.md, it's used as that
+# module's Doxygen mainpage automatically.
+# -----------------------------------------------------------------------
+function(_add_module_docs TARGET)
+    if(NOT ENABLE_DOXYGEN)
+        return()
+    endif()
+
+    set(DOXYGEN_OUTPUT_DIRECTORY "${DOCS_OUTPUT_DIR}/${TARGET}")
+    set(DOXYGEN_PROJECT_NAME "${TARGET}")
+    if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/README.md")
+        set(DOXYGEN_USE_MDFILE_AS_MAINPAGE "${CMAKE_CURRENT_SOURCE_DIR}/README.md")
+    else()
+        unset(DOXYGEN_USE_MDFILE_AS_MAINPAGE)
+    endif()
+
+    doxygen_add_docs(docs_${TARGET}
+        "${CMAKE_CURRENT_SOURCE_DIR}"
+        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
+        COMMENT "Generating documentation for module '${TARGET}'"
+    )
+    set_target_properties(docs_${TARGET} PROPERTIES EXCLUDE_FROM_ALL TRUE)
+    add_dependencies(docs docs_${TARGET})
+
+    set_property(GLOBAL APPEND PROPERTY PMN_DOC_MODULES ${TARGET})
+endfunction()
+
+# -----------------------------------------------------------------------
+# _write_docs_index(OUTPUT_DIR): call once, after every module has been
+# discovered, to write a plain landing page at OUTPUT_DIR/index.html
+# linking to each module's own generated docs -- so "where do I start
+# reading" has one obvious answer regardless of how many modules exist.
+# -----------------------------------------------------------------------
+function(_write_docs_index OUTPUT_DIR)
+    if(NOT ENABLE_DOXYGEN)
+        return()
+    endif()
+    file(MAKE_DIRECTORY "${OUTPUT_DIR}")
+    get_property(_pmn_doc_modules GLOBAL PROPERTY PMN_DOC_MODULES)
+    list(SORT _pmn_doc_modules)
+    set(_pmn_doc_links "")
+    foreach(_pmn_mod ${_pmn_doc_modules})
+        string(APPEND _pmn_doc_links "    <li><a href=\"${_pmn_mod}/html/index.html\">${_pmn_mod}</a></li>\n")
+    endforeach()
+    file(WRITE "${OUTPUT_DIR}/index.html" "<!DOCTYPE html>
+<html>
+<head><meta charset=\"utf-8\"><title>${PROJECT_NAME} -- module documentation</title></head>
+<body>
+  <h1>${PROJECT_NAME} module documentation</h1>
+  <ul>
+${_pmn_doc_links}  </ul>
+</body>
+</html>
+")
+endfunction()
diff --git a/breeze/cmake/DoxygenPin.cmake b/breeze/cmake/DoxygenPin.cmake
new file mode 100644
index 0000000..cac9923
--- /dev/null
+++ b/breeze/cmake/DoxygenPin.cmake
@@ -0,0 +1,98 @@
+# =============================================================================
+# DoxygenPin.cmake
+#
+# Pure computation of "where does the pinned Doxygen live, and where would
+# it be downloaded from" -- no network calls, no download, no extraction.
+# Shared by two very different callers, which is why this is its own file:
+#
+#   breeze/cmake/Documentation.cmake  include()s this during the normal CMake
+#                              configure to find out where to LOOK for an
+#                              already-downloaded pinned Doxygen. Never
+#                              downloads anything itself -- see that file.
+#
+#   breeze/cmake/FetchDoxygen.cmake   include()s this when run standalone via
+#                              `cmake -P breeze/cmake/FetchDoxygen.cmake` (what
+#                              breeze/scripts/setup.sh / setup.bat call) to know
+#                              what to actually download.
+#
+# Needs TOOLCACHE_DIR to already be set -- Documentation.cmake gets it from
+# project/Configuration.cmake (included earlier by CMakeLists.txt); FetchDoxygen.cmake
+# sets it manually since script mode (`cmake -P`) never runs CMakeLists.txt.
+#
+# Bump DOXYGEN_PINNED_VERSION to change the pinned version project-wide --
+# doing so also requires updating the SHA256 hashes below to match the
+# new release's assets (each was checked against the digest GitHub
+# publishes for the asset AND a local download, not trusted from either
+# alone). A stale hash fails loud and hard, on purpose, in
+# FetchDoxygen.cmake rather than silently accepting an unexpected file).
+# =============================================================================
+
+include_guard(GLOBAL)
+
+if(NOT DEFINED DOXYGEN_PINNED_VERSION)
+    set(DOXYGEN_PINNED_VERSION "1.16.1")
+endif()
+
+string(REPLACE "." "_" _pmn_doxygen_tag_version "${DOXYGEN_PINNED_VERSION}")
+set(DOXYGEN_PIN_TAG "Release_${_pmn_doxygen_tag_version}")
+set(DOXYGEN_PIN_ROOT "${TOOLCACHE_DIR}/doxygen-${DOXYGEN_PINNED_VERSION}")
+
+# This is a HOST question (what machine is actually running Doxygen), not
+# a DIST_TARGET one -- see HostArch.cmake's header. Needed even on the
+# cross DIST_TARGETs (an ARM64 Linux build from an x64 machine, an x64
+# macOS build on an Apple Silicon one, ...): the machine running Doxygen and
+# the DIST_TARGET being built need not share an architecture there, and
+# this file only ever cares about the former.
+include("${CMAKE_CURRENT_LIST_DIR}/HostArch.cmake")
+pmn_host_arch(_pmn_doxygen_host_arch)
+
+if(CMAKE_HOST_WIN32 AND _pmn_doxygen_host_arch STREQUAL "x64")
+    set(DOXYGEN_PIN_URL "https://github.com/doxygen/doxygen/releases/download/${DOXYGEN_PIN_TAG}/doxygen-${DOXYGEN_PINNED_VERSION}.windows.x64.bin.zip")
+    set(DOXYGEN_PIN_HASH "ddfa59a4ae9549651330471c2e387ec7a9891080543faed541c859e5ce448653")
+    set(DOXYGEN_PIN_EXECUTABLE "${DOXYGEN_PIN_ROOT}/doxygen.exe")
+    set(DOXYGEN_PIN_PLATFORM_SUPPORTED TRUE)
+elseif(CMAKE_HOST_UNIX AND NOT CMAKE_HOST_APPLE AND _pmn_doxygen_host_arch STREQUAL "x64")
+    set(DOXYGEN_PIN_URL "https://github.com/doxygen/doxygen/releases/download/${DOXYGEN_PIN_TAG}/doxygen-${DOXYGEN_PINNED_VERSION}.linux.bin.tar.gz")
+    set(DOXYGEN_PIN_HASH "a56f885d37e3aae08a99f638d17bbb381224c03a878d9e2dda4f9fa4baf1d8bd")
+    set(DOXYGEN_PIN_EXECUTABLE "${DOXYGEN_PIN_ROOT}/doxygen-${DOXYGEN_PINNED_VERSION}/bin/doxygen")
+    set(DOXYGEN_PIN_PLATFORM_SUPPORTED TRUE)
+elseif(CMAKE_HOST_APPLE AND _pmn_doxygen_host_arch STREQUAL "arm64")
+    # macOS ships two plain zips (next to the .dmg GUI installers, which are
+    # deliberately not used here: mounting a disk image needs hdiutil and a
+    # GUI app bundle around what is, inside, just this CLI binary). Each
+    # holds doxygen-<version>/doxygen -- no bin/ level, unlike the Linux
+    # tarball. Which one is the MACHINE's architecture, not the cmake
+    # process's, courtesy of HostArch.cmake's Rosetta handling.
+    set(DOXYGEN_PIN_URL "https://github.com/doxygen/doxygen/releases/download/${DOXYGEN_PIN_TAG}/doxygen-${DOXYGEN_PINNED_VERSION}-mac-arm.zip")
+    set(DOXYGEN_PIN_HASH "f75d4e7253ad959d691cb65b6c3a9bb0c138ce75bce7cef17f5ebf36c7b54bdc")
+    set(DOXYGEN_PIN_EXECUTABLE "${DOXYGEN_PIN_ROOT}/doxygen-${DOXYGEN_PINNED_VERSION}/doxygen")
+    set(DOXYGEN_PIN_PLATFORM_SUPPORTED TRUE)
+elseif(CMAKE_HOST_APPLE AND _pmn_doxygen_host_arch STREQUAL "x64")
+    set(DOXYGEN_PIN_URL "https://github.com/doxygen/doxygen/releases/download/${DOXYGEN_PIN_TAG}/doxygen-${DOXYGEN_PINNED_VERSION}-mac-intel.zip")
+    set(DOXYGEN_PIN_HASH "1530e5eca05b442e4cdd80a8ad6b22e1bbb3fc14e12b64b07c61de4be48cc5f1")
+    set(DOXYGEN_PIN_EXECUTABLE "${DOXYGEN_PIN_ROOT}/doxygen-${DOXYGEN_PINNED_VERSION}/doxygen")
+    set(DOXYGEN_PIN_PLATFORM_SUPPORTED TRUE)
+else()
+    # What's left: Windows or Linux on ARM64/ARM32, and any other exotic
+    # host. (macOS has its own branches above.) Unlike Ninja (see the
+    # equivalent comment in NinjaPin.cmake), the upstream Doxygen
+    # project's GitHub releases don't publish ARM Linux or ARM Windows
+    # binaries at all as of DOXYGEN_PINNED_VERSION -- the release's asset
+    # list is the two macOS zips, two macOS disk images, the x64 Linux
+    # tarball, the x64 Windows zip and installer, the sources, and the
+    # manual -- so this isn't fillable yet.
+    # To add support once/if such an asset exists: find its exact name at
+    # https://github.com/doxygen/doxygen/releases/tag/${DOXYGEN_PIN_TAG},
+    # download and verify it out-of-band, and add a branch here with its
+    # URL and SHA256, following the pattern above; this project won't put
+    # an unverified hash into one meant to catch supply-chain tampering
+    # (see the file-header comment above). Until then this degrades the
+    # same way any other unsupported host already does: FetchDoxygen.cmake
+    # gives a clear error, and Documentation.cmake disables ENABLE_DOXYGEN
+    # with a warning instead of failing the build (see that file) -- a
+    # plain build never depends on Doxygen regardless.
+    set(DOXYGEN_PIN_URL "")
+    set(DOXYGEN_PIN_HASH "")
+    set(DOXYGEN_PIN_EXECUTABLE "")
+    set(DOXYGEN_PIN_PLATFORM_SUPPORTED FALSE)
+endif()
diff --git a/breeze/cmake/FetchDoxygen.cmake b/breeze/cmake/FetchDoxygen.cmake
new file mode 100644
index 0000000..8b8b51b
--- /dev/null
+++ b/breeze/cmake/FetchDoxygen.cmake
@@ -0,0 +1,110 @@
+# =============================================================================
+# FetchDoxygen.cmake
+#
+# Downloads, verifies, and extracts the pinned Doxygen (see DoxygenPin.cmake
+# for the version/URL/hash) into TOOLCACHE_DIR. Run standalone, NOT included
+# by the normal CMake configure:
+#
+#   cmake -P breeze/cmake/FetchDoxygen.cmake
+#
+# This is what breeze/scripts/setup.sh / setup.bat call. It's deliberately not part
+# of the main `cmake --preset <name>` configure -- see breeze/cmake/Documentation.cmake,
+# which only ever LOOKS for the result of this script and never downloads
+# anything itself, so a plain build never depends on Doxygen or on network
+# access. Safe to re-run any time; a no-op if the pinned version is already
+# present.
+# =============================================================================
+
+# TOOLCACHE_DIR normally comes from project/Configuration.cmake, which isn't
+# loaded in this standalone script-mode invocation -- read it from there
+# directly (it holds settings only, so including it has no side
+# effects) rather than
+# hardcoding a second copy of its default. If you've overridden
+# TOOLCACHE_DIR via -DTOOLCACHE_DIR=... at configure time, pass the same
+# value here to match: cmake -DTOOLCACHE_DIR=... -P breeze/cmake/FetchDoxygen.cmake
+if(NOT DEFINED TOOLCACHE_DIR)
+    get_filename_component(CMAKE_SOURCE_DIR "${CMAKE_CURRENT_LIST_DIR}/../.." ABSOLUTE)
+    include("${CMAKE_SOURCE_DIR}/project/Configuration.cmake")
+endif()
+
+include("${CMAKE_CURRENT_LIST_DIR}/DoxygenPin.cmake")
+
+if(NOT DOXYGEN_PIN_PLATFORM_SUPPORTED)
+    set(_pmn_doxygen_platform_hint "")
+    if(CMAKE_HOST_WIN32)
+        set(_pmn_doxygen_platform_hint
+            " If this looks like an ordinary 64-bit machine, double-check this isn't "
+            "a 32-bit cmake.exe running under WoW64 (installed under \"Program Files "
+            "(x86)\" is a good sign it is) -- that's a common, easy way to end up here "
+            "even on x64/ARM64 hardware; installing the 64-bit CMake from cmake.org "
+            "fixes it.")
+    endif()
+    message(FATAL_ERROR "No pinned Doxygen ${DOXYGEN_PINNED_VERSION} binary is configured for this host "
+                         "platform.${_pmn_doxygen_platform_hint} Install Doxygen ${DOXYGEN_PINNED_VERSION} "
+                         "manually, make sure it's on PATH or pass "
+                         "-DDOXYGEN_EXECUTABLE=/path/to/doxygen at project-configure time, or extend "
+                         "breeze/cmake/DoxygenPin.cmake with a download URL + hash for this platform.")
+endif()
+
+if(EXISTS "${DOXYGEN_PIN_EXECUTABLE}")
+    message(STATUS "Doxygen ${DOXYGEN_PINNED_VERSION} already present: ${DOXYGEN_PIN_EXECUTABLE}")
+    return()
+endif()
+
+message(STATUS "Downloading pinned Doxygen ${DOXYGEN_PINNED_VERSION} (cached under ${TOOLCACHE_DIR})")
+set(_pmn_doxygen_archive "${TOOLCACHE_DIR}/_doxygen_download.archive")
+
+# No EXPECTED_HASH here on purpose: file(DOWNLOAD ... EXPECTED_HASH ...)
+# raises a hard, unrecoverable CMake Error on ANY failure -- including
+# plain network/connectivity failures -- which would turn a "you're
+# offline" hiccup into a worse error than it needs to be. Downloading
+# first and verifying the hash ourselves afterward lets us give a clearer
+# message for a network failure, while still treating a genuine hash
+# mismatch (see below) as fully fatal.
+file(DOWNLOAD "${DOXYGEN_PIN_URL}" "${_pmn_doxygen_archive}"
+    STATUS _pmn_doxygen_dl_status
+    SHOW_PROGRESS
+)
+list(GET _pmn_doxygen_dl_status 0 _pmn_doxygen_dl_code)
+if(NOT _pmn_doxygen_dl_code EQUAL 0)
+    list(GET _pmn_doxygen_dl_status 1 _pmn_doxygen_dl_msg)
+    file(REMOVE "${_pmn_doxygen_archive}")
+    message(FATAL_ERROR "Failed to download pinned Doxygen ${DOXYGEN_PINNED_VERSION}: ${_pmn_doxygen_dl_msg}. "
+                         "Check your network connection and try again -- your build doesn't need this to "
+                         "succeed, only `breeze/scripts/docs.sh` / `docs.bat` does.")
+endif()
+
+# Verify integrity, deliberately as a hard failure -- a mismatch here means
+# the downloaded artifact doesn't match what this project expects
+# (corruption or tampering in transit, or a stale pinned hash after
+# bumping DOXYGEN_PINNED_VERSION in DoxygenPin.cmake without updating the
+# matching hash there): a supply-chain-relevant integrity failure, not
+# something to silently continue past.
+file(SHA256 "${_pmn_doxygen_archive}" _pmn_doxygen_actual_hash)
+string(TOLOWER "${_pmn_doxygen_actual_hash}" _pmn_doxygen_actual_hash)
+string(TOLOWER "${DOXYGEN_PIN_HASH}" _pmn_doxygen_expected_hash_lc)
+if(NOT _pmn_doxygen_actual_hash STREQUAL _pmn_doxygen_expected_hash_lc)
+    file(REMOVE "${_pmn_doxygen_archive}")
+    message(FATAL_ERROR "Pinned Doxygen ${DOXYGEN_PINNED_VERSION} download hash mismatch -- "
+                         "expected ${_pmn_doxygen_expected_hash_lc}, got ${_pmn_doxygen_actual_hash}. "
+                         "This usually means DOXYGEN_PINNED_VERSION was bumped in breeze/cmake/DoxygenPin.cmake "
+                         "without updating the matching hash there, or the download was corrupted or "
+                         "tampered with in transit.")
+endif()
+
+file(ARCHIVE_EXTRACT INPUT "${_pmn_doxygen_archive}" DESTINATION "${DOXYGEN_PIN_ROOT}")
+file(REMOVE "${_pmn_doxygen_archive}")
+
+if(NOT CMAKE_HOST_WIN32)
+    file(CHMOD "${DOXYGEN_PIN_EXECUTABLE}" PERMISSIONS
+        OWNER_READ OWNER_WRITE OWNER_EXECUTE
+        GROUP_READ GROUP_EXECUTE
+        WORLD_READ WORLD_EXECUTE)
+endif()
+
+if(EXISTS "${DOXYGEN_PIN_EXECUTABLE}")
+    message(STATUS "Doxygen ${DOXYGEN_PINNED_VERSION} ready: ${DOXYGEN_PIN_EXECUTABLE}")
+else()
+    message(FATAL_ERROR "Download/extract completed but the expected executable is missing: "
+                         "${DOXYGEN_PIN_EXECUTABLE}")
+endif()
diff --git a/breeze/cmake/FetchNinja.cmake b/breeze/cmake/FetchNinja.cmake
new file mode 100644
index 0000000..1e062b4
--- /dev/null
+++ b/breeze/cmake/FetchNinja.cmake
@@ -0,0 +1,108 @@
+# =============================================================================
+# FetchNinja.cmake
+#
+# Downloads, verifies, and extracts the pinned ninja (see NinjaPin.cmake for
+# the version/URL/hash) into TOOLCACHE_DIR. Run standalone, never included by
+# the normal CMake configure -- ninja is needed as the generator itself
+# (`cmake -G Ninja`), so it has to be resolved *before* configure runs, unlike
+# Doxygen (see FetchDoxygen.cmake), which is only needed for a downstream
+# custom target:
+#
+#   cmake -P breeze/cmake/FetchNinja.cmake
+#
+# This is what breeze/scripts/setup.sh / setup.bat call, and also what breeze/scripts/
+# build.sh / build.bat call on demand if neither a pinned nor a system ninja
+# is found (see the comment there). Safe to re-run any time; a no-op if the
+# pinned version is already present.
+# =============================================================================
+
+# TOOLCACHE_DIR normally comes from project/Configuration.cmake, which isn't
+# loaded in this standalone script-mode invocation -- read it from there
+# directly (it holds settings only, so including it has no side
+# effects) rather than
+# hardcoding a second copy of its default. If you've overridden
+# TOOLCACHE_DIR via -DTOOLCACHE_DIR=... at configure time, pass the same
+# value here to match: cmake -DTOOLCACHE_DIR=... -P breeze/cmake/FetchNinja.cmake
+if(NOT DEFINED TOOLCACHE_DIR)
+    get_filename_component(CMAKE_SOURCE_DIR "${CMAKE_CURRENT_LIST_DIR}/../.." ABSOLUTE)
+    include("${CMAKE_SOURCE_DIR}/project/Configuration.cmake")
+endif()
+
+include("${CMAKE_CURRENT_LIST_DIR}/NinjaPin.cmake")
+
+if(NOT NINJA_PIN_PLATFORM_SUPPORTED)
+    set(_pmn_ninja_platform_hint "")
+    if(CMAKE_HOST_WIN32)
+        set(_pmn_ninja_platform_hint
+            " If this looks like an ordinary 64-bit machine, double-check this isn't "
+            "a 32-bit cmake.exe running under WoW64 (installed under \"Program Files "
+            "(x86)\" is a good sign it is) -- that's a common, easy way to end up here "
+            "even on x64/ARM64 hardware; installing the 64-bit CMake from cmake.org "
+            "fixes it.")
+    endif()
+    message(FATAL_ERROR "No pinned ninja ${NINJA_PINNED_VERSION} binary is configured for this host "
+                         "platform.${_pmn_ninja_platform_hint} Install ninja manually and make sure "
+                         "it's on PATH, or extend breeze/cmake/NinjaPin.cmake with a download URL + hash for "
+                         "this platform.")
+endif()
+
+if(EXISTS "${NINJA_PIN_EXECUTABLE}")
+    message(STATUS "ninja ${NINJA_PINNED_VERSION} already present: ${NINJA_PIN_EXECUTABLE}")
+    return()
+endif()
+
+message(STATUS "Downloading pinned ninja ${NINJA_PINNED_VERSION} (cached under ${TOOLCACHE_DIR})")
+set(_pmn_ninja_archive "${TOOLCACHE_DIR}/_ninja_download.archive")
+
+# No EXPECTED_HASH here on purpose -- see the identical comment in
+# FetchDoxygen.cmake: file(DOWNLOAD ... EXPECTED_HASH ...) raises a hard,
+# unrecoverable CMake Error on ANY failure, including plain network
+# failures. Downloading first and verifying the hash ourselves afterward
+# lets a network failure and a genuine integrity failure be told apart and
+# handled differently (see below).
+file(DOWNLOAD "${NINJA_PIN_URL}" "${_pmn_ninja_archive}"
+    STATUS _pmn_ninja_dl_status
+    SHOW_PROGRESS
+)
+list(GET _pmn_ninja_dl_status 0 _pmn_ninja_dl_code)
+if(NOT _pmn_ninja_dl_code EQUAL 0)
+    list(GET _pmn_ninja_dl_status 1 _pmn_ninja_dl_msg)
+    file(REMOVE "${_pmn_ninja_archive}")
+    message(FATAL_ERROR "Failed to download pinned ninja ${NINJA_PINNED_VERSION}: ${_pmn_ninja_dl_msg}. "
+                         "Check your network connection and try again, or install ninja yourself and "
+                         "make sure it's on PATH -- breeze/scripts/build.sh / build.bat will use a system ninja "
+                         "if no pinned one is found.")
+endif()
+
+# Verify integrity, deliberately as a hard failure -- see the identical
+# comment in FetchDoxygen.cmake: a mismatch here means corruption/tampering
+# in transit, or a stale pinned hash after bumping NINJA_PINNED_VERSION in
+# NinjaPin.cmake without updating the matching hash there.
+file(SHA256 "${_pmn_ninja_archive}" _pmn_ninja_actual_hash)
+string(TOLOWER "${_pmn_ninja_actual_hash}" _pmn_ninja_actual_hash)
+string(TOLOWER "${NINJA_PIN_HASH}" _pmn_ninja_expected_hash_lc)
+if(NOT _pmn_ninja_actual_hash STREQUAL _pmn_ninja_expected_hash_lc)
+    file(REMOVE "${_pmn_ninja_archive}")
+    message(FATAL_ERROR "Pinned ninja ${NINJA_PINNED_VERSION} download hash mismatch -- "
+                         "expected ${_pmn_ninja_expected_hash_lc}, got ${_pmn_ninja_actual_hash}. "
+                         "This usually means NINJA_PINNED_VERSION was bumped in breeze/cmake/NinjaPin.cmake "
+                         "without updating the matching hash there, or the download was corrupted or "
+                         "tampered with in transit.")
+endif()
+
+file(ARCHIVE_EXTRACT INPUT "${_pmn_ninja_archive}" DESTINATION "${NINJA_PIN_ROOT}")
+file(REMOVE "${_pmn_ninja_archive}")
+
+if(NOT CMAKE_HOST_WIN32)
+    file(CHMOD "${NINJA_PIN_EXECUTABLE}" PERMISSIONS
+        OWNER_READ OWNER_WRITE OWNER_EXECUTE
+        GROUP_READ GROUP_EXECUTE
+        WORLD_READ WORLD_EXECUTE)
+endif()
+
+if(EXISTS "${NINJA_PIN_EXECUTABLE}")
+    message(STATUS "ninja ${NINJA_PINNED_VERSION} ready: ${NINJA_PIN_EXECUTABLE}")
+else()
+    message(FATAL_ERROR "Download/extract completed but the expected executable is missing: "
+                         "${NINJA_PIN_EXECUTABLE}")
+endif()
diff --git a/breeze/cmake/GitignoreSync.cmake b/breeze/cmake/GitignoreSync.cmake
new file mode 100644
index 0000000..f758b48
--- /dev/null
+++ b/breeze/cmake/GitignoreSync.cmake
@@ -0,0 +1,114 @@
+# =============================================================================
+# .gitignore sync
+#
+# Keeps a marked block in .gitignore in sync with the actual, current
+# values of the path variables above -- every configure, automatically.
+# Nothing outside that block (e.g. the Visual Studio template this
+# project's .gitignore starts from) is ever touched. This is what makes
+# this file the real source of truth for these paths specifically: change
+# OUT_DIR (or override it with -DOUT_DIR=...) and .gitignore updates on
+# the next configure instead of silently drifting out of sync with what
+# actually gets generated.
+#
+# If .gitignore doesn't exist yet, it's created with just this block. If
+# it exists but has no markers yet, the block is appended. If the markers
+# are already there, only the content between them is replaced. The file
+# is only rewritten when the computed content actually differs, so a
+# normal reconfigure doesn't spuriously touch it (or its mtime).
+#
+# A path is only added if it resolves inside the repo (CMAKE_SOURCE_DIR)
+# -- e.g. an overridden TOOLCACHE_DIR pointing somewhere else entirely is
+# silently skipped, since .gitignore has nothing meaningful to say about
+# a location outside the repository it lives in.
+#
+# Skipped entirely in query mode -- see "How scripts read this file"
+# above.
+# =============================================================================
+
+include_guard(GLOBAL)
+
+# out/dist/ is reserved (see the output layout in project/Configuration.cmake) and
+# nothing writes to it yet, so it is created eagerly here -- otherwise it simply
+# would not exist until something populates it, which could easily read as "this
+# was never wired up" rather than "intentionally reserved for later". A file
+# system side effect, so it lives here and not in the settings file: a script's
+# query of those settings runs far more often than a real configure.
+file(MAKE_DIRECTORY "${DIST_OUTPUT_DIR}")
+
+set(_pmn_gitignore_begin "# >>> Configuration.cmake generated paths -- BEGIN (do not edit by hand; edit Configuration.cmake and reconfigure) >>>")
+set(_pmn_gitignore_end   "# <<< Configuration.cmake generated paths -- END <<<")
+
+function(_pmn_gitignore_relpath ABSOLUTE_VALUE OUT_VAR)
+    file(RELATIVE_PATH _pmn_rel "${CMAKE_SOURCE_DIR}" "${ABSOLUTE_VALUE}")
+    if(_pmn_rel MATCHES "^\\.\\.")
+        set(${OUT_VAR} "" PARENT_SCOPE)
+    else()
+        set(${OUT_VAR} "${_pmn_rel}" PARENT_SCOPE)
+    endif()
+endfunction()
+
+set(_pmn_gitignore_entries "")
+foreach(_pmn_dir_var OUT_DIR BUILD_OUTPUT_DIR DIST_OUTPUT_DIR INSTALL_OUTPUT_DIR DOCS_OUTPUT_DIR TOOLCACHE_DIR)
+    _pmn_gitignore_relpath("${${_pmn_dir_var}}" _pmn_rel)
+    if(_pmn_rel)
+        list(APPEND _pmn_gitignore_entries "${_pmn_rel}/")
+    endif()
+endforeach()
+
+_pmn_gitignore_relpath("${COMPILE_COMMANDS_DESTINATION}" _pmn_cc_rel)
+if(_pmn_cc_rel)
+    list(APPEND _pmn_gitignore_entries "${_pmn_cc_rel}")
+endif()
+
+# breeze/scripts/run.sh keeps the wine prefixes it creates in .cache/wine/ -- a
+# fixed place, not one of the path variables above. Listed here rather
+# than added to .gitignore by hand: this block is rewritten on every
+# configure, which silently deleted a hand-added line.
+list(APPEND _pmn_gitignore_entries ".cache/wine/")
+# Likewise the target sysroots breeze/cmake/toolchains/_common.cmake looks for
+# in .cache/sysroots/linux-<arch> (see pmn_find_sysroot there): root
+# filesystems for cross builds, hundreds of megabytes, never to commit.
+list(APPEND _pmn_gitignore_entries ".cache/sysroots/")
+
+list(REMOVE_DUPLICATES _pmn_gitignore_entries)
+list(SORT _pmn_gitignore_entries)
+
+set(_pmn_gitignore_block_content "")
+foreach(_pmn_entry ${_pmn_gitignore_entries})
+    string(APPEND _pmn_gitignore_block_content "${_pmn_entry}\n")
+endforeach()
+
+set(_pmn_gitignore_path "${CMAKE_SOURCE_DIR}/.gitignore")
+set(_pmn_gitignore_new_block "${_pmn_gitignore_begin}\n${_pmn_gitignore_block_content}${_pmn_gitignore_end}")
+
+if(EXISTS "${_pmn_gitignore_path}")
+    file(READ "${_pmn_gitignore_path}" _pmn_gitignore_content)
+else()
+    set(_pmn_gitignore_content "")
+endif()
+
+string(FIND "${_pmn_gitignore_content}" "${_pmn_gitignore_begin}" _pmn_gitignore_begin_pos)
+string(FIND "${_pmn_gitignore_content}" "${_pmn_gitignore_end}" _pmn_gitignore_end_pos)
+
+if(_pmn_gitignore_begin_pos GREATER -1 AND _pmn_gitignore_end_pos GREATER -1
+   AND _pmn_gitignore_end_pos GREATER _pmn_gitignore_begin_pos)
+    # Replace only the content between the existing markers.
+    string(SUBSTRING "${_pmn_gitignore_content}" 0 ${_pmn_gitignore_begin_pos} _pmn_gitignore_before)
+    string(LENGTH "${_pmn_gitignore_end}" _pmn_gitignore_end_marker_len)
+    math(EXPR _pmn_gitignore_after_start "${_pmn_gitignore_end_pos} + ${_pmn_gitignore_end_marker_len}")
+    string(SUBSTRING "${_pmn_gitignore_content}" ${_pmn_gitignore_after_start} -1 _pmn_gitignore_after)
+    set(_pmn_gitignore_final "${_pmn_gitignore_before}${_pmn_gitignore_new_block}${_pmn_gitignore_after}")
+else()
+    # No markers yet -- append (trimming trailing blank lines first so we
+    # don't accumulate extra blank lines across repeated appends).
+    string(REGEX REPLACE "\n+$" "" _pmn_gitignore_trimmed "${_pmn_gitignore_content}")
+    if(_pmn_gitignore_trimmed STREQUAL "")
+        set(_pmn_gitignore_final "${_pmn_gitignore_new_block}\n")
+    else()
+        set(_pmn_gitignore_final "${_pmn_gitignore_trimmed}\n\n${_pmn_gitignore_new_block}\n")
+    endif()
+endif()
+
+if(NOT _pmn_gitignore_final STREQUAL _pmn_gitignore_content)
+    file(WRITE "${_pmn_gitignore_path}" "${_pmn_gitignore_final}")
+endif()
diff --git a/breeze/cmake/HostArch.cmake b/breeze/cmake/HostArch.cmake
new file mode 100644
index 0000000..255807f
--- /dev/null
+++ b/breeze/cmake/HostArch.cmake
@@ -0,0 +1,155 @@
+# =============================================================================
+# HostArch.cmake
+#
+# One place to turn this project's own architecture labels -- x64, arm64,
+# or arm32 (empty if unrecognized) -- out of a processor string. Two entry
+# points, because "which architecture" has two different questions behind it:
+#
+#   pmn_host_arch()     the machine CMake is actually running ON.
+#                        NinjaPin.cmake / DoxygenPin.cmake use it to decide
+#                        whether a pinned-tool download exists for the machine
+#                        running CMake -- always a HOST question, independent
+#                        of what's being built. TargetSelection.cmake also uses
+#                        it for Clang's GNU-style driver on Windows (see
+#                        below for why MSVC/clang-cl need a different check,
+#                        done separately in that file).
+#
+#   pmn_target_arch()   the machine the build is FOR, i.e.
+#                        CMAKE_SYSTEM_PROCESSOR. TargetSelection.cmake's Linux
+#                        DIST_TARGET detection uses it. On a native build it
+#                        is the same answer as pmn_host_arch() (CMake sets
+#                        CMAKE_SYSTEM_PROCESSOR from the host unless told
+#                        otherwise); the difference is a cross build, where a
+#                        toolchain file (breeze/cmake/toolchains/) sets it to the
+#                        target -- asking the host there would label an
+#                        aarch64 cross build "x64".
+#
+# Both share one aarch64/armv7l/... spelling list, and the platform-specific
+# unreliability below is only handled once. Needs no project()/compiler
+# detection, so it's safe to include from a bare `cmake -P` script.
+#
+# About pmn_host_arch() on each platform: on Linux it is
+# CMAKE_HOST_SYSTEM_PROCESSOR, which is just `uname -m` -- reliable, with
+# one catch that used to break the pinned-tool download on every Linux
+# machine: `cmake -P` (script mode -- how breeze/scripts/setup.sh runs
+# FetchNinja.cmake and FetchDoxygen.cmake) never runs CMake's system
+# detection, so CMAKE_HOST_SYSTEM_PROCESSOR is simply not defined there.
+# In that case this asks the OS itself, with `uname -m`. On macOS it is
+# the same `uname -m`, corrected for Rosetta 2 (see the comment inside the
+# function). On
+# Windows it deliberately does NOT use CMAKE_HOST_SYSTEM_
+# PROCESSOR (or CMAKE_SYSTEM_PROCESSOR): both are just the
+# PROCESSOR_ARCHITECTURE environment variable, which reports the
+# architecture of the CURRENT PROCESS, not the machine -- a 32-bit
+# cmake.exe (still a completely ordinary, common download; nothing exotic)
+# running under WoW64 on an ordinary 64-bit machine reports "x86" here even
+# though the machine itself is x64 or ARM64. That's the same class of
+# problem as the MSVC/clang-cl architecture-detection trap in
+# TargetSelection.cmake (CMake issue #25466: gitlab.kitware.com/cmake/cmake/-/issues/25466),
+# just via WoW64 process redirection rather than a cross-targeting
+# compiler -- confirmed the hard way, as exactly what broke the pinned-
+# ninja/-doxygen lookup below on an entirely ordinary 64-bit machine with a
+# 32-bit cmake.exe on PATH. PROCESSOR_ARCHITEW6432 is what Windows itself
+# sets to expose the TRUE architecture to a WoW64-redirected 32-bit
+# process; it's simply unset outside WoW64, which is exactly when
+# PROCESSOR_ARCHITECTURE was already correct anyway -- so preferring it
+# when present, falling back to PROCESSOR_ARCHITECTURE otherwise, is
+# correct either way.
+# =============================================================================
+
+include_guard(GLOBAL)
+
+# _pmn_arch_label(<processor-string> <out-var>)
+#
+# The one place the aarch64/x86_64/armv7l/... spellings are mapped to this
+# project's x64/arm64/arm32 labels. <out-var> gets one of those, or "" if
+# unrecognized.
+function(_pmn_arch_label PROCESSOR OUT_VAR)
+    if(PROCESSOR MATCHES "^(aarch64|arm64|ARM64)$")
+        set(${OUT_VAR} "arm64" PARENT_SCOPE)
+    elseif(PROCESSOR MATCHES "^(x86_64|amd64|AMD64)$")
+        set(${OUT_VAR} "x64" PARENT_SCOPE)
+    elseif(PROCESSOR MATCHES "^[Aa][Rr][Mm]")
+        # Every other spelling of 32-bit ARM this project has seen: armv6l
+        # (Raspberry Pi 1/Zero), armv7l (the common case -- Raspberry Pi
+        # 2/3/4 32-bit OS, generic armhf), armv8l (a 32-bit personality/
+        # chroot on 64-bit ARM hardware), or bare "arm"/"ARM". Checked
+        # after arm64/aarch64 above since those also start with "arm".
+        set(${OUT_VAR} "arm32" PARENT_SCOPE)
+    else()
+        set(${OUT_VAR} "" PARENT_SCOPE)
+    endif()
+endfunction()
+
+# pmn_host_arch(<out-var> [<raw-out-var>])
+#
+# <out-var> gets one of x64/arm64/arm32/"" (unrecognized) for the machine
+# running CMake. The optional <raw-out-var> gets whatever raw string was
+# actually checked to produce that -- callers building an error message for
+# the "" case should use this rather than assuming which underlying
+# variable/environment variable was consulted, since that differs by
+# platform (see above).
+function(pmn_host_arch OUT_VAR)
+    if(CMAKE_HOST_WIN32)
+        if(NOT "$ENV{PROCESSOR_ARCHITEW6432}" STREQUAL "")
+            set(_pmn_ha_processor "$ENV{PROCESSOR_ARCHITEW6432}")
+        else()
+            set(_pmn_ha_processor "$ENV{PROCESSOR_ARCHITECTURE}")
+        endif()
+    elseif(CMAKE_HOST_SYSTEM_PROCESSOR)
+        set(_pmn_ha_processor "${CMAKE_HOST_SYSTEM_PROCESSOR}")
+    elseif(CMAKE_HOST_UNIX)
+        # Script mode (cmake -P): not defined -- see the header. This is
+        # exactly what CMake itself does to fill it in during a configure.
+        execute_process(COMMAND uname -m
+            OUTPUT_VARIABLE _pmn_ha_processor
+            OUTPUT_STRIP_TRAILING_WHITESPACE
+            ERROR_QUIET)
+    else()
+        set(_pmn_ha_processor "${CMAKE_SYSTEM_PROCESSOR}")
+    endif()
+
+    # macOS: a process running under Rosetta 2 -- an x86_64 cmake on an Apple
+    # Silicon Mac, entirely ordinary since Intel builds of CMake and of most
+    # developer tools still circulate -- is told it's on an x86_64 machine,
+    # by `uname -m` and so by CMAKE_HOST_SYSTEM_PROCESSOR alike. The same
+    # class of trap as a 32-bit process under WoW64 on Windows (see the
+    # header), and fixed the same way: ask about the MACHINE.
+    # hw.optional.arm64 is 1 on any Apple Silicon Mac no matter whether the
+    # asking process is translated, and doesn't exist on Intel (-i makes a
+    # missing OID a silent empty answer instead of an error).
+    if(CMAKE_HOST_APPLE)
+        _pmn_arch_label("${_pmn_ha_processor}" _pmn_ha_probe)
+        if(_pmn_ha_probe STREQUAL "x64")
+            execute_process(COMMAND sysctl -in hw.optional.arm64
+                OUTPUT_VARIABLE _pmn_ha_arm64
+                OUTPUT_STRIP_TRAILING_WHITESPACE
+                ERROR_QUIET)
+            if(_pmn_ha_arm64 STREQUAL "1")
+                set(_pmn_ha_processor "arm64")
+            endif()
+        endif()
+    endif()
+
+    if(ARGC GREATER 1)
+        set(${ARGV1} "${_pmn_ha_processor}" PARENT_SCOPE)
+    endif()
+
+    _pmn_arch_label("${_pmn_ha_processor}" _pmn_ha_label)
+    set(${OUT_VAR} "${_pmn_ha_label}" PARENT_SCOPE)
+endfunction()
+
+# pmn_target_arch(<out-var> [<raw-out-var>])
+#
+# Same contract as pmn_host_arch(), but for the machine the build is FOR:
+# CMAKE_SYSTEM_PROCESSOR. Only meaningful where that variable can be
+# trusted -- Linux, where it is `uname -m` for a native build and whatever
+# the toolchain file says for a cross build. Not for MSVC/clang-cl, where
+# it reflects the cmake.exe process instead (see the header).
+function(pmn_target_arch OUT_VAR)
+    if(ARGC GREATER 1)
+        set(${ARGV1} "${CMAKE_SYSTEM_PROCESSOR}" PARENT_SCOPE)
+    endif()
+    _pmn_arch_label("${CMAKE_SYSTEM_PROCESSOR}" _pmn_ta_label)
+    set(${OUT_VAR} "${_pmn_ta_label}" PARENT_SCOPE)
+endfunction()
diff --git a/breeze/cmake/NinjaPin.cmake b/breeze/cmake/NinjaPin.cmake
new file mode 100644
index 0000000..9ae2726
--- /dev/null
+++ b/breeze/cmake/NinjaPin.cmake
@@ -0,0 +1,109 @@
+# =============================================================================
+# NinjaPin.cmake
+#
+# Pure computation of "where does the pinned ninja live, and where would it
+# be downloaded from" -- no network calls, no download, no extraction.
+# Mirrors DoxygenPin.cmake exactly; see that file for the full rationale.
+# Shared by two very different callers:
+#
+#   breeze/scripts/build.sh / build.bat  include() this (via `cmake -P`, same
+#                                 mechanism as FetchNinja.cmake below) to
+#                                 find out where to LOOK for an
+#                                 already-downloaded pinned ninja, before
+#                                 CMake configure even runs -- ninja is
+#                                 needed as the generator itself, unlike
+#                                 Doxygen, which is only ever needed for a
+#                                 downstream custom target. Never
+#                                 downloads anything itself.
+#
+#   breeze/cmake/FetchNinja.cmake        include()s this when run standalone via
+#                                 `cmake -P breeze/cmake/FetchNinja.cmake` (what
+#                                 breeze/scripts/setup.sh / setup.bat call) to
+#                                 know what to actually download.
+#
+# Needs TOOLCACHE_DIR to already be set. Both callers above set it manually
+# (matching project/Configuration.cmake's default) since neither runs through
+# CMakeLists.txt.
+#
+# Bump NINJA_PINNED_VERSION to change the pinned version project-wide --
+# doing so also requires updating the SHA256 hashes below to match the
+# new release's assets (a stale hash fails loud and hard, on purpose, in
+# FetchNinja.cmake rather than silently accepting an unexpected file).
+# GitHub publishes a sha256 digest for every release asset (the
+# "digest" field of its releases API, shown on the release page too); the
+# hashes below were each checked against it AND against a local download,
+# rather than trusted from either alone.
+# =============================================================================
+
+include_guard(GLOBAL)
+
+if(NOT DEFINED NINJA_PINNED_VERSION)
+    set(NINJA_PINNED_VERSION "1.13.2")
+endif()
+
+set(NINJA_PIN_TAG "v${NINJA_PINNED_VERSION}")
+set(NINJA_PIN_ROOT "${TOOLCACHE_DIR}/ninja-${NINJA_PINNED_VERSION}")
+
+# This is a HOST question (what machine is actually running ninja), not a
+# DIST_TARGET one -- see HostArch.cmake's header. Needed even on the
+# cross DIST_TARGETs (an ARM64 Linux build from an x64 machine, an x64
+# macOS build on an Apple Silicon one, ...): the machine running ninja and
+# the DIST_TARGET being built need not share an architecture there, and
+# this file only ever cares about the former.
+include("${CMAKE_CURRENT_LIST_DIR}/HostArch.cmake")
+pmn_host_arch(_pmn_ninja_host_arch)
+
+if(CMAKE_HOST_WIN32 AND _pmn_ninja_host_arch STREQUAL "x64")
+    set(NINJA_PIN_URL "https://github.com/ninja-build/ninja/releases/download/${NINJA_PIN_TAG}/ninja-win.zip")
+    set(NINJA_PIN_HASH "07fc8261b42b20e71d1720b39068c2e14ffcee6396b76fb7a795fb460b78dc65")
+    set(NINJA_PIN_EXECUTABLE "${NINJA_PIN_ROOT}/ninja.exe")
+    set(NINJA_PIN_PLATFORM_SUPPORTED TRUE)
+elseif(CMAKE_HOST_UNIX AND NOT CMAKE_HOST_APPLE AND _pmn_ninja_host_arch STREQUAL "x64")
+    set(NINJA_PIN_URL "https://github.com/ninja-build/ninja/releases/download/${NINJA_PIN_TAG}/ninja-linux.zip")
+    set(NINJA_PIN_HASH "5749cbc4e668273514150a80e387a957f933c6ed3f5f11e03fb30955e2bbead6")
+    set(NINJA_PIN_EXECUTABLE "${NINJA_PIN_ROOT}/ninja")
+    set(NINJA_PIN_PLATFORM_SUPPORTED TRUE)
+elseif(CMAKE_HOST_UNIX AND NOT CMAKE_HOST_APPLE AND _pmn_ninja_host_arch STREQUAL "arm64")
+    # Ninja has shipped ARM64 builds since v1.12.0 (see the comment on the
+    # unsupported fallback below).
+    set(NINJA_PIN_URL "https://github.com/ninja-build/ninja/releases/download/${NINJA_PIN_TAG}/ninja-linux-aarch64.zip")
+    set(NINJA_PIN_HASH "fd2cacc8050a7f12a16a2e48f9e06fca5c14fc4c2bee2babb67b58be17a607fc")
+    set(NINJA_PIN_EXECUTABLE "${NINJA_PIN_ROOT}/ninja")
+    set(NINJA_PIN_PLATFORM_SUPPORTED TRUE)
+elseif(CMAKE_HOST_WIN32 AND _pmn_ninja_host_arch STREQUAL "arm64")
+    set(NINJA_PIN_URL "https://github.com/ninja-build/ninja/releases/download/${NINJA_PIN_TAG}/ninja-winarm64.zip")
+    set(NINJA_PIN_HASH "e52f0bdef9dfb1003229dbd6508a508c4073fd017247002adc66e5e806cb0391")
+    set(NINJA_PIN_EXECUTABLE "${NINJA_PIN_ROOT}/ninja.exe")
+    set(NINJA_PIN_PLATFORM_SUPPORTED TRUE)
+elseif(CMAKE_HOST_APPLE)
+    # ONE asset for both Intel and Apple Silicon: ninja-mac.zip holds a
+    # universal (x86_64 + arm64) Mach-O binary, so unlike Linux/Windows
+    # this branch doesn't care which architecture the host is -- which also
+    # sidesteps the Rosetta trap HostArch.cmake describes.
+    set(NINJA_PIN_URL "https://github.com/ninja-build/ninja/releases/download/${NINJA_PIN_TAG}/ninja-mac.zip")
+    set(NINJA_PIN_HASH "c99048673aa765960a99cf10c6ddb9f1fad506099ff0a0e137ad8960a88f321b")
+    set(NINJA_PIN_EXECUTABLE "${NINJA_PIN_ROOT}/ninja")
+    set(NINJA_PIN_PLATFORM_SUPPORTED TRUE)
+else()
+    # What's left: 32-bit ARM Linux, and any other exotic host. (macOS and
+    # ARM64 Linux/Windows have their own branches above -- Ninja's GitHub
+    # releases have shipped those binaries since v1.12.0, "ARM binaries are
+    # now available for Windows and Linux, too" per that release's notes.)
+    # Not a guess left blank -- there is simply no 32-bit ARM Linux asset
+    # upstream at NINJA_PINNED_VERSION. This project won't put an
+    # unverified SHA256 into a hash meant to catch supply-chain tampering
+    # (see the file-header comment above), so to add support for another
+    # host: find that asset's exact name at
+    # https://github.com/ninja-build/ninja/releases/tag/${NINJA_PIN_TAG},
+    # download and verify it out-of-band, and add a branch here with its
+    # URL and SHA256, following the pattern above. Until then this
+    # degrades the same way any other unsupported host already does:
+    # FetchNinja.cmake / breeze/scripts/setup.sh give a clear error, and
+    # breeze/scripts/build.sh / build.bat fall back to a system ninja with a
+    # warning (see those files) -- the build itself still works, just
+    # without a pinned/version-locked ninja.
+    set(NINJA_PIN_URL "")
+    set(NINJA_PIN_HASH "")
+    set(NINJA_PIN_EXECUTABLE "")
+    set(NINJA_PIN_PLATFORM_SUPPORTED FALSE)
+endif()
diff --git a/breeze/cmake/PrintConfig.cmake b/breeze/cmake/PrintConfig.cmake
new file mode 100644
index 0000000..4529823
--- /dev/null
+++ b/breeze/cmake/PrintConfig.cmake
@@ -0,0 +1,53 @@
+# =============================================================================
+# PrintConfig.cmake
+#
+# Script-mode bridge: lets breeze/scripts/*.sh and breeze/scripts/*.bat read values out of
+# project/Configuration.cmake -- this project's single source of truth (see that
+# file) -- instead of hardcoding a second copy that can silently drift out
+# of sync. This is exactly the bug it replaces: breeze/scripts/install.sh and
+# install.bat used to each hardcode their own literal "demo", with a
+# comment warning it had to be kept in sync with PROJECT_CODE_NAME by hand.
+#
+# Usage:
+#   cmake "-DPRINT_VARS=NAME1;NAME2;..." -P breeze/cmake/PrintConfig.cmake
+#
+# Prints one "NAME=value" line per requested variable, in the order given.
+# Every line is emitted via message(STATUS ...) -- deliberately: it's the
+# only message() mode CMake sends to stdout (verified directly: the
+# no-keyword default, NOTICE, and WARNING all go to stderr; STATUS is the
+# one exception), which is what lets a caller capture it with plain output
+# redirection/command substitution instead of needing a temp file. The
+# tradeoff is that STATUS always prefixes the line with "-- ", so every
+# caller strips that off along with the "NAME=" it already knows: see
+# breeze/scripts/build.sh's _pmn_read_config() or breeze/scripts/build.bat's
+# :read_config for the one small wrapper each shell dialect uses -- every
+# script that needs a value calls that wrapper rather than re-deriving
+# this convention itself.
+#
+# Includes project/Configuration.cmake, which holds settings only: nothing in
+# it needs a compiler and it touches nothing on disk, which is what makes it
+# safe here -- a value lookup shouldn't have side effects, and this runs far
+# more often than a real configure. What does need a real compiler
+# (DIST_TARGET/PLATFORM/ARCHITECTURE/COMPILER_ID, which a plain `cmake -P`
+# script would get wrong: project(... LANGUAGES CXX) never runs) is
+# breeze/cmake/TargetSelection.cmake, not included here. So only ask for names
+# the settings file defines -- PROJECT_CODE_NAME, DEFAULT_BUILD_TYPE, the path
+# variables; see that file's header for the rules on adding to it.
+# =============================================================================
+
+if(NOT DEFINED PRINT_VARS)
+    message(FATAL_ERROR "Usage: cmake \"-DPRINT_VARS=NAME1;NAME2;...\" -P breeze/cmake/PrintConfig.cmake")
+endif()
+
+get_filename_component(CMAKE_SOURCE_DIR "${CMAKE_CURRENT_LIST_DIR}/../.." ABSOLUTE)
+include("${CMAKE_SOURCE_DIR}/project/Configuration.cmake")
+
+foreach(_pmn_print_name ${PRINT_VARS})
+    if(NOT DEFINED ${_pmn_print_name})
+        message(FATAL_ERROR
+            "PrintConfig.cmake: '${_pmn_print_name}' is not defined by "
+            "project/Configuration.cmake -- see that file's header "
+            "('How scripts read this file').")
+    endif()
+    message(STATUS "${_pmn_print_name}=${${_pmn_print_name}}")
+endforeach()
diff --git a/breeze/cmake/TargetSelection.cmake b/breeze/cmake/TargetSelection.cmake
new file mode 100644
index 0000000..ddfe9ed
--- /dev/null
+++ b/breeze/cmake/TargetSelection.cmake
@@ -0,0 +1,610 @@
+# =============================================================================
+# TargetSelection.cmake
+#
+# What the build is FOR: DIST_TARGET -- a single "<platform>-<arch>-<compiler>"
+# string -- and the PLATFORM, ARCHITECTURE and COMPILER_ID derived from it.
+# Included by breeze/cmake/Breeze.cmake right after project(), since it needs
+# real compiler detection; the project's own settings (project/Configuration.cmake)
+# deliberately have none of it, so that a plain `cmake -P` script can read them.
+#
+# Everything below is the template's: nothing in it is configuration. To build
+# for a different target, pick a CMakePresets.json preset or pass -DDIST_TARGET.
+#
+# -----------------------------------------------------------------------
+# Target selection (DIST_TARGET)
+# -----------------------------------------------------------------------
+# DIST_TARGET identifies what you're building for as a single
+# "<platform>-<arch>-<compiler>" string. It is declared by the toolchain
+# file in use (breeze/cmake/toolchains/<DIST_TARGET>.cmake -- what every
+# CMakePresets.json preset selects, and the recommended way to build), or
+# given explicitly with -DDIST_TARGET=<value> (if both are present they
+# must agree), or, with neither, auto-detected from the compiler CMake
+# found. Every value in PMN_VALID_DIST_TARGETS below is supported:
+#
+#   linux-x64-gcc          GCC on x86-64 Linux
+#   linux-x64-clang        Clang on x86-64 Linux
+#   linux-arm64-gcc        GCC on 64-bit ARM Linux (aarch64)
+#   linux-arm64-clang      Clang on 64-bit ARM Linux (aarch64)
+#   linux-arm32-gcc        GCC on 32-bit ARM Linux (armhf/armv7l and similar)
+#   linux-arm32-clang      Clang on 32-bit ARM Linux
+#   macos-arm64-clang      Clang on Apple Silicon macOS -- Apple Clang from
+#                          the Xcode Command Line Tools, or LLVM's own
+#                          Clang (e.g. Homebrew's); both are "clang" here
+#   macos-x64-clang        Clang on Intel macOS (or, given Rosetta 2, an
+#                          Apple Silicon Mac: the toolchain just asks the
+#                          compiler for -arch x86_64)
+#   windows-x64-msvc       cl.exe (MSVC) targeting x64
+#   windows-arm64-msvc     cl.exe (MSVC) targeting ARM64
+#   windows-x64-clang-cl   clang-cl targeting x64 (Clang targeting the
+#                          MSVC ABI -- CMake's MSVC variable is TRUE for
+#                          this too)
+#   windows-arm64-clang-cl clang-cl targeting ARM64
+#   windows-x64-clang      Clang with its own GNU-style driver on Windows,
+#                          targeting x64 (e.g. an MSYS2 CLANG64
+#                          environment) -- distinct from clang-cl above,
+#                          which mimics cl.exe instead of gcc
+#   windows-arm64-clang    Clang with its own GNU-style driver on Windows,
+#                          targeting ARM64 (e.g. an MSYS2 CLANGARM64
+#                          environment)
+#   windows-x86-mingw32    32-bit x86 GCC via MinGW
+#   windows-x64-mingw64    64-bit x64 GCC via MinGW-w64
+#
+# No macOS GCC target and no universal one. Apple's own toolchain IS Clang
+# (a Homebrew GCC would be a second, unrelated compiler ecosystem needing
+# its own SDK and sysroot handling), and a universal binary is a
+# CMAKE_OSX_ARCHITECTURES list with two entries -- which doesn't fit a
+# DIST_TARGET that names ONE architecture, and is rejected below with the
+# reason rather than mislabeled. To ship one universal file, build both
+# macOS presets and combine the results: `lipo -create <arm64 file>
+# <x64 file> -output <file>`.
+#
+# No windows-arm32-* and no ARM64 MinGW target: 32-bit ARM Windows has no
+# real toolchain support left in any of the compilers above (MSVC dropped
+# it; it only ever existed for Windows RT / Windows 10 IoT Core), and
+# mainline MinGW-w64's GCC has no ARM64 Windows (PE/COFF) backend -- ARM64
+# Windows toolchains in that ecosystem are LLVM-based (MSYS2's
+# CLANGARM64, covered by windows-arm64-clang above), not GCC-based.
+#
+# Architecture (x64/arm64/arm32) is detected differently depending on
+# compiler family, because CMAKE_SYSTEM_PROCESSOR turns out not to be
+# trustworthy for all of them:
+#   - Linux (GCC/Clang) goes through breeze/cmake/HostArch.cmake's
+#     pmn_target_arch(), i.e. CMAKE_SYSTEM_PROCESSOR: `uname -m` for a
+#     native build, and whatever the toolchain file sets it to for a
+#     cross build (so an aarch64 cross build from an x64 machine is
+#     labeled arm64, not x64). Clang's GNU-style driver on Windows goes
+#     through pmn_host_arch() instead, an environment-variable check --
+#     see that file for why CMAKE_SYSTEM_PROCESSOR/
+#     CMAKE_HOST_SYSTEM_PROCESSOR can't be trusted there (a second,
+#     related trap: a 32-bit cmake.exe under WoW64, independent of the
+#     MSVC one below).
+#   - macOS goes through CMAKE_OSX_ARCHITECTURES, which the macOS toolchain
+#     files set to exactly one architecture, and only falls back to
+#     CMAKE_SYSTEM_PROCESSOR (`uname -m`) without one. Apple's clang is a
+#     single multi-architecture compiler, so an x86_64 build on an Apple
+#     Silicon Mac is just a different -arch -- not a cross compiler, and
+#     nothing that CMAKE_SYSTEM_PROCESSOR (which under Rosetta 2 reports
+#     the architecture of the cmake PROCESS, the same class of trap as
+#     WoW64 on Windows) could describe reliably.
+#   - MSVC and clang-cl use CMAKE_CXX_COMPILER_ARCHITECTURE_ID instead --
+#     CMAKE_SYSTEM_PROCESSOR is a documented, confirmed-in-the-wild trap
+#     here (tracked as CMake issue #25466): it reflects the architecture
+#     of the cmake.exe process itself, not what the selected cl.exe/
+#     clang-cl actually targets, and those two routinely differ (a
+#     same-machine cross build -- e.g. an x64 Visual Studio install's
+#     "HostX64/ARM64" tools -- is the normal way to target ARM64 from an
+#     x64 dev machine).
+#
+# Toolchain files and cross-compiling: breeze/cmake/toolchains/ has one toolchain
+# file per DIST_TARGET, named after it, and every CMakePresets.json preset
+# selects the one named after itself. A toolchain file settles the compiler
+# (and, for clang-cl, the --target triple) before project() runs, declares
+# the DIST_TARGET it is for, and -- where the target isn't the machine
+# running CMake -- sets up a real cross build: the linux-arm64-* and
+# linux-arm32-* targets cross-compile from any other Linux machine (an x64
+# one, say), and the windows-*-mingw* targets from Linux via mingw-w64,
+# while on matching hardware (ARM64 for linux-arm64-*) the very same
+# preset just builds natively. On macOS the toolchain pins the
+# architecture with CMAKE_OSX_ARCHITECTURES and a minimum macOS version
+# with CMAKE_OSX_DEPLOYMENT_TARGET (11.0 unless you pass your own) -- both
+# are only honored when set BEFORE project(), which is exactly when a
+# toolchain file runs. breeze/cmake/toolchains/_common.cmake documents
+# exactly what each one does and which packages it needs. The exception is
+# MSVC: cl.exe takes its architecture from the Visual Studio developer
+# environment it is started from (vcvarsall.bat), which no CMake file can
+# switch, so the windows-*-msvc toolchains only pick cl and check it is
+# there -- the architecture check below then verifies it is the right one.
+#
+# Without a toolchain file, pointing -DCMAKE_CXX_COMPILER at a cross
+# compiler is not enough on its own: CMake is never told the target is a
+# different architecture, so the auto-detected DIST_TARGET follows the
+# HOST and you'll get a cross-check mismatch (see below) instead, same as
+# any other unmet assumption this file's auto-detection makes.
+#
+# IMPORTANT: -DDIST_TARGET=... on its own only labels the build (which
+# install subdirectory it lands in, which metadata gets printed); it does
+# NOT select a compiler or an architecture. CMake still uses whatever
+# CMAKE_CXX_COMPILER it would otherwise find -- your PATH, your
+# environment, or an explicit -DCMAKE_CXX_COMPILER=... -- same as if
+# DIST_TARGET had never been mentioned. Passing
+# -DDIST_TARGET=windows-x64-mingw64 alone, with no MinGW compiler actually
+# configured, does not make CMake go find one; it configures whatever
+# compiler it would have anyway (often MSVC, since CMake looks for that
+# first on Windows) and mislabels the result. TargetSelection.cmake catches
+# exactly this: a DIST_TARGET that disagrees with what the real compiler
+# (and architecture) auto-detects to is a FATAL_ERROR, not a silent
+# mislabel -- see the "cross-check" step below. A toolchain file doesn't
+# have the problem, because it sets the label and the compiler together:
+# use the toolchain file for that target
+# (-DCMAKE_TOOLCHAIN_FILE=breeze/cmake/toolchains/<DIST_TARGET>.cmake), or simply
+# the matching CMakePresets.json preset, which selects it.
+#
+# Auto-detection FATAL_ERRORs rather than guessing when the compiler
+# doesn't match any of the above, instead of silently assuming MSVC --
+# that silent assumption is exactly what used to misidentify a MinGW GCC
+# build as MSVC (COMPILER_ID "msvc" for an actual GNU compiler), which in
+# turn misfiled its `cmake --install` output under .../windows-x64-msvc/.
+#
+# PLATFORM, ARCHITECTURE, and COMPILER_ID below are metadata derived from
+# DIST_TARGET; Breeze.cmake and the other breeze/cmake/*.cmake modules consume these
+# rather than re-deriving them.
+# =============================================================================
+
+include_guard(GLOBAL)
+
+set(PMN_VALID_DIST_TARGETS
+    linux-x64-gcc
+    linux-x64-clang
+    linux-arm64-gcc
+    linux-arm64-clang
+    linux-arm32-gcc
+    linux-arm32-clang
+    macos-arm64-clang
+    macos-x64-clang
+    windows-x64-msvc
+    windows-arm64-msvc
+    windows-x64-clang-cl
+    windows-arm64-clang-cl
+    windows-x64-clang
+    windows-arm64-clang
+    windows-x86-mingw32
+    windows-x64-mingw64
+)
+list(JOIN PMN_VALID_DIST_TARGETS "  " _pmn_valid_dist_targets_str)
+
+# Where DIST_TARGET came from, for the messages below. A toolchain file
+# (breeze/cmake/toolchains/<DIST_TARGET>.cmake -- every CMakePresets.json preset
+# selects the one named after itself) declares the target it is for via
+# PMN_TOOLCHAIN_DIST_TARGET (see toolchains/_common.cmake), so the label
+# and the compiler the toolchain picked travel together. It is resolved
+# here, ahead of the auto-detection below, because
+# _pmn_dist_target_undetected() decides how hard to fail based on
+# whether DIST_TARGET is already known. An explicit -DDIST_TARGET is
+# still accepted alongside a toolchain, but it has to agree with it.
+set(_pmn_dist_target_source "")
+if(PMN_TOOLCHAIN_DIST_TARGET)
+    if(DIST_TARGET AND NOT DIST_TARGET STREQUAL PMN_TOOLCHAIN_DIST_TARGET)
+        message(FATAL_ERROR
+            "DIST_TARGET was explicitly set to '${DIST_TARGET}', but the toolchain file in use "
+            "(${CMAKE_TOOLCHAIN_FILE}) is for '${PMN_TOOLCHAIN_DIST_TARGET}'.\n"
+            "Drop -DDIST_TARGET (the toolchain already says which target this is), or "
+            "use the toolchain file for '${DIST_TARGET}':\n"
+            "  ${CMAKE_SOURCE_DIR}/breeze/cmake/toolchains/${DIST_TARGET}.cmake")
+    endif()
+    set(DIST_TARGET "${PMN_TOOLCHAIN_DIST_TARGET}")
+    set(_pmn_dist_target_source "toolchain")
+elseif(DIST_TARGET)
+    set(_pmn_dist_target_source "explicit")
+endif()
+
+# _pmn_dist_target_undetected(REASON...): an auto-detection branch
+# below hit a case with no DIST_TARGET for it. REASON explains why --
+# shown whether or not DIST_TARGET was explicitly given (e.g. via a
+# CMakePresets.json preset), so a preset user gets the same specific
+# diagnosis a plain, no-DIST_TARGET user already did.
+#
+# Previously REASON was only ever shown when DIST_TARGET was unset;
+# setting DIST_TARGET (which every preset does -- the recommended way
+# to build, per CMakePresets.json and the README) silently discarded
+# it in favor of the generic "auto-detects to none of the values this
+# project recognizes" cross-check message further down, with no
+# explanation of WHY -- exactly the confusing, unhelpful failure this
+# macro exists to prevent.
+#
+# No DIST_TARGET means there's nothing to fall back on, so REASON is
+# the final word: FATAL_ERROR, with the full valid-values list. With
+# DIST_TARGET set, REASON is advisory context for the unified
+# cross-check FATAL_ERROR further down (which still runs, and has the
+# copy-pasteable fix) -- so this is STATUS, and _pmn_detected_dist_target
+# is left at "" for that check to pick up, same as before this macro
+# existed.
+macro(_pmn_dist_target_undetected)
+    if(DIST_TARGET)
+        set(_pmn_detected_dist_target "")
+        message(STATUS "Could not auto-detect a DIST_TARGET: " ${ARGN})
+    else()
+        message(FATAL_ERROR "Could not auto-detect a DIST_TARGET: " ${ARGN}
+            "\nValid values: ${_pmn_valid_dist_targets_str}")
+    endif()
+endmacro()
+
+include("${CMAKE_CURRENT_LIST_DIR}/HostArch.cmake")
+
+# What DIST_TARGET the CXX compiler CMake actually found auto-detects
+# to -- computed unconditionally, not only when DIST_TARGET is unset,
+# so an explicitly-given DIST_TARGET can be cross-checked against it
+# below rather than trusted as a label. See the file header for why
+# that check exists.
+if(WIN32)
+    if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC" OR
+       (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND CMAKE_CXX_COMPILER_FRONTEND_VARIANT STREQUAL "MSVC"))
+        # MSVC, and clang-cl (Clang's cl.exe-compatible driver
+        # personality, selected either by invoking a binary literally
+        # named clang-cl(.exe) or via `clang++ --driver-mode=cl`;
+        # CMake surfaces this as CMAKE_CXX_COMPILER_FRONTEND_VARIANT
+        # rather than a distinct COMPILER_ID, since it's the same
+        # Clang either way -- just a different argument dialect and
+        # default target ABI). Both get their architecture from
+        # CMAKE_CXX_COMPILER_ARCHITECTURE_ID, deliberately NOT from
+        # CMAKE_SYSTEM_PROCESSOR/CMAKE_HOST_SYSTEM_PROCESSOR (see
+        # HostArch.cmake's header for why those can't be trusted for
+        # this specific case). CMAKE_CXX_COMPILER_ARCHITECTURE_ID is
+        # what CMake itself derives by probing the compiler -- it
+        # needs this internally for the right /machine: linker flag --
+        # so it reflects the real target regardless of which cl.exe/
+        # clang-cl variant ended up on PATH. Its values are
+        # mixed-case by long-standing CMake convention (X86, x64,
+        # ARM, ARM64); normalized to uppercase here so the
+        # comparisons below aren't tripped by that inconsistency.
+        string(TOUPPER "${CMAKE_CXX_COMPILER_ARCHITECTURE_ID}" _pmn_msvc_arch_id)
+        if(_pmn_msvc_arch_id STREQUAL "X64")
+            set(_pmn_win_arch "x64")
+        elseif(_pmn_msvc_arch_id STREQUAL "ARM64")
+            set(_pmn_win_arch "arm64")
+        else()
+            # Includes X86 and ARM (32-bit) -- real MSVC targets, but
+            # not ones this project has a DIST_TARGET for (32-bit ARM
+            # Windows has no real toolchain support left in any
+            # compiler; see the file header). Treated as unrecognized
+            # rather than silently mislabeled as x64 or arm64.
+            set(_pmn_win_arch "")
+        endif()
+
+        if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
+            set(_pmn_win_compiler_id "msvc")
+        else()
+            set(_pmn_win_compiler_id "clang-cl")
+        endif()
+
+        if(_pmn_win_arch)
+            set(_pmn_detected_dist_target "windows-${_pmn_win_arch}-${_pmn_win_compiler_id}")
+        else()
+            # X86 specifically gets its own hint rather than the
+            # generic message below: it's by far the most likely way
+            # to actually hit this branch in practice (ARM on Windows
+            # without ARM64 is rare) -- not a machine that's genuinely
+            # 32-bit-only (vanishingly rare today), almost always
+            # PATH/environment handing CMake the 32-bit-hosted,
+            # 32-bit-targeting cl.exe/clang-cl instead of the x64 one,
+            # e.g. from opening a plain shell instead of an "x64
+            # Native Tools Command Prompt for VS". Reported whether or
+            # not DIST_TARGET was explicitly given -- see
+            # _pmn_dist_target_undetected above.
+            if(_pmn_msvc_arch_id STREQUAL "X86")
+                _pmn_dist_target_undetected(
+                    "${_pmn_win_compiler_id} is "
+                    "targeting X86 (32-bit) -- almost always a sign that PATH/the "
+                    "current shell is handing CMake the 32-bit-hosted, "
+                    "32-bit-targeting ${_pmn_win_compiler_id}, not that this machine "
+                    "is actually 32-bit-only.\n"
+                    "Open an \"x64 Native Tools Command Prompt for VS\" (or a "
+                    "\"Developer PowerShell for VS\" defaulted to x64) so an x64 "
+                    "${_pmn_win_compiler_id} is what's first on PATH, delete this "
+                    "build directory (a failed configure's CMakeCache.txt won't just "
+                    "fix itself), and reconfigure. breeze\\scripts\\build.bat enters the right environment on "
+                    "its own, but the build directory still has to go.\n"
+                    "If 32-bit really is intentional, this project doesn't have a "
+                    "DIST_TARGET for it -- set one explicitly: -DDIST_TARGET=<value>"
+                )
+            else()
+                _pmn_dist_target_undetected(
+                    "${_pmn_win_compiler_id} is "
+                    "targeting an architecture ('${CMAKE_CXX_COMPILER_ARCHITECTURE_ID}') "
+                    "this project doesn't have a DIST_TARGET for -- set one "
+                    "explicitly: -DDIST_TARGET=<value>"
+                )
+            endif()
+        endif()
+    elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+        # Clang with its own GNU-style driver on Windows (e.g. an
+        # MSYS2 CLANG64/CLANGARM64 environment) -- distinct from
+        # clang-cl above, which mimics cl.exe instead of gcc.
+        # CMAKE_CXX_COMPILER_ARCHITECTURE_ID is specific to the MSVC-
+        # style detection used above and isn't populated for this
+        # driver mode. Falls back to HostArch.cmake instead -- unlike
+        # the raw cl.exe/clang-cl case, a GNU-style environment like
+        # MSYS2 is used as a coherent whole (its own cmake, its own
+        # clang++, both built for and normally run on the same
+        # architecture), the same assumption the MinGW pointer-size
+        # check below already makes for mingw32 vs. mingw64.
+        pmn_host_arch(_pmn_win_clang_arch _pmn_win_clang_raw)
+        if(_pmn_win_clang_arch STREQUAL "arm64")
+            set(_pmn_detected_dist_target "windows-arm64-clang")
+        elseif(_pmn_win_clang_arch STREQUAL "x64")
+            set(_pmn_detected_dist_target "windows-x64-clang")
+        else()
+            _pmn_dist_target_undetected(
+                "unrecognized host "
+                "architecture '${_pmn_win_clang_raw}' for Clang's GNU-style driver "
+                "on Windows -- set one explicitly: -DDIST_TARGET=<value>"
+            )
+        endif()
+    elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+        # A real GCC on Windows is MinGW (mingw.org's original,
+        # 32-bit-only project) or MinGW-w64 (adds 64-bit; also
+        # provides a 32-bit target, conventionally called
+        # "mingw32" too since it's the direct successor). Tell
+        # them apart by pointer size rather than parsing the
+        # compiler's own executable name, which is a config
+        # choice, not something to depend on. No ARM MinGW target
+        # here on purpose, unlike the Clang branch above: mainline
+        # MinGW-w64's GCC has no ARM64 Windows (PE/COFF) backend --
+        # ARM64 Windows toolchains in that ecosystem are LLVM-based
+        # (MSYS2's CLANGARM64), not GCC-based.
+        if(CMAKE_SIZEOF_VOID_P EQUAL 8)
+            set(_pmn_detected_dist_target "windows-x64-mingw64")
+        else()
+            set(_pmn_detected_dist_target "windows-x86-mingw32")
+        endif()
+    elseif(DIST_TARGET)
+        # Can't cross-check an explicit value against a compiler this
+        # doesn't recognize at all -- the mismatch message below
+        # handles an empty detected value.
+        set(_pmn_detected_dist_target "")
+    else()
+        message(FATAL_ERROR
+            "Could not auto-detect a DIST_TARGET for CXX compiler "
+            "'${CMAKE_CXX_COMPILER_ID}' on Windows -- set one "
+            "explicitly: -DDIST_TARGET=<value>\n"
+            "Valid values: ${_pmn_valid_dist_targets_str}")
+    endif()
+elseif(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
+    # macOS (CMAKE_SYSTEM_NAME is "Darwin" for macOS only; iOS and
+    # friends have their own names). The architecture is what
+    # CMAKE_OSX_ARCHITECTURES says when it's set -- the macOS toolchain
+    # files always set it, to one value -- else CMAKE_SYSTEM_PROCESSOR.
+    # See the file header for why not CMAKE_SYSTEM_PROCESSOR first.
+    # Mapped explicitly rather than through HostArch.cmake's spelling
+    # table, which files anything starting with "arm" -- arm64e, say --
+    # under 32-bit ARM.
+    set(_pmn_macos_arch "")
+    if(CMAKE_OSX_ARCHITECTURES)
+        list(LENGTH CMAKE_OSX_ARCHITECTURES _pmn_macos_arch_count)
+        if(_pmn_macos_arch_count GREATER 1)
+            message(FATAL_ERROR
+                "CMAKE_OSX_ARCHITECTURES is '${CMAKE_OSX_ARCHITECTURES}' -- several "
+                "architectures, i.e. a universal binary. A DIST_TARGET names exactly one "
+                "architecture (macos-arm64-clang, macos-x64-clang): build each with its "
+                "preset and combine the results with `lipo -create <arm64 file> <x64 file> "
+                "-output <file>` if you need a single universal file.")
+        elseif(CMAKE_OSX_ARCHITECTURES STREQUAL "arm64")
+            set(_pmn_macos_arch "arm64")
+        elseif(CMAKE_OSX_ARCHITECTURES STREQUAL "x86_64")
+            set(_pmn_macos_arch "x64")
+        endif()
+        set(_pmn_macos_arch_raw "CMAKE_OSX_ARCHITECTURES '${CMAKE_OSX_ARCHITECTURES}'")
+    else()
+        pmn_target_arch(_pmn_macos_arch _pmn_macos_arch_processor)
+        set(_pmn_macos_arch_raw "CMAKE_SYSTEM_PROCESSOR '${_pmn_macos_arch_processor}'")
+    endif()
+
+    if(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+        if(_pmn_macos_arch)
+            set(_pmn_detected_dist_target "macos-${_pmn_macos_arch}-clang")
+        else()
+            _pmn_dist_target_undetected(
+                "unrecognized macOS architecture (${_pmn_macos_arch_raw}) -- set one "
+                "explicitly: -DDIST_TARGET=<value>"
+            )
+        endif()
+    elseif(DIST_TARGET)
+        set(_pmn_detected_dist_target "")
+    else()
+        message(FATAL_ERROR
+            "Could not auto-detect a DIST_TARGET for CXX compiler "
+            "'${CMAKE_CXX_COMPILER_ID}' on macOS -- only Clang (Apple's, from the "
+            "Xcode Command Line Tools, or LLVM's own) is a supported macOS target. "
+            "Set one explicitly: -DDIST_TARGET=<value>\n"
+            "Valid values: ${_pmn_valid_dist_targets_str}")
+    endif()
+else()
+    # Linux: architecture comes from CMAKE_SYSTEM_PROCESSOR via
+    # HostArch.cmake -- reliable here (unlike the raw cl.exe/clang-cl
+    # case above). For a native build that is simply `uname -m`; for a
+    # cross build the toolchain file (breeze/cmake/toolchains/) sets it to the
+    # TARGET's architecture, which is exactly what should be labeled --
+    # asking the host machine instead would call an aarch64 cross
+    # build "x64".
+    pmn_target_arch(_pmn_linux_arch)
+
+    if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+        # Not a blind TOLOWER of CMAKE_CXX_COMPILER_ID: CMake's own ID
+        # for GCC is "GNU" (a case-fold gives "gnu", which none of
+        # PMN_VALID_DIST_TARGETS above or CMakePresets.json spell --
+        # every one of them, and everyone outside CMake, calls it
+        # "gcc"). Same reasoning the MSVC/clang-cl branch above
+        # already applies to its own two compiler IDs.
+        if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+            set(_pmn_linux_compiler_id "gcc")
+        else()
+            set(_pmn_linux_compiler_id "clang")
+        endif()
+        if(_pmn_linux_arch)
+            set(_pmn_detected_dist_target "linux-${_pmn_linux_arch}-${_pmn_linux_compiler_id}")
+        else()
+            _pmn_dist_target_undetected(
+                "unrecognized "
+                "CMAKE_SYSTEM_PROCESSOR '${CMAKE_SYSTEM_PROCESSOR}' -- set one "
+                "explicitly: -DDIST_TARGET=<value>"
+            )
+        endif()
+    elseif(DIST_TARGET)
+        set(_pmn_detected_dist_target "")
+    else()
+        message(FATAL_ERROR
+            "Could not auto-detect a DIST_TARGET for CXX compiler "
+            "'${CMAKE_CXX_COMPILER_ID}' -- set one explicitly: "
+            "-DDIST_TARGET=<value>\n"
+            "Valid values: ${_pmn_valid_dist_targets_str}")
+    endif()
+endif()
+
+if(NOT DIST_TARGET)
+    set(DIST_TARGET "${_pmn_detected_dist_target}")
+    message(STATUS "DIST_TARGET not set -- auto-detected: ${DIST_TARGET}")
+    message(STATUS "  (use a CMakePresets.json preset -- or -DCMAKE_TOOLCHAIN_FILE=breeze/cmake/toolchains/<target>.cmake -- to set it explicitly)")
+else()
+    if(NOT DIST_TARGET IN_LIST PMN_VALID_DIST_TARGETS)
+        message(FATAL_ERROR
+            "Unsupported DIST_TARGET: '${DIST_TARGET}'.\n"
+            "Valid values: ${_pmn_valid_dist_targets_str}\n"
+            "Tip: open CMakePresets.json in your IDE to select a preset, "
+            "or pass -DDIST_TARGET=<value> on the command line.")
+    endif()
+
+    if(NOT DIST_TARGET STREQUAL _pmn_detected_dist_target)
+        # This is the check described in the file header: a DIST_TARGET
+        # that disagrees with the compiler CMake actually found.
+        if(_pmn_detected_dist_target)
+            set(_pmn_detected_desc "'${_pmn_detected_dist_target}'")
+        else()
+            set(_pmn_detected_desc "none of the values this project recognizes")
+        endif()
+
+        # The fix depends on where DIST_TARGET came from. From a
+        # toolchain file the compiler was already chosen to match, so
+        # something overrode it afterwards; from a bare -DDIST_TARGET
+        # nothing ever chose a compiler at all.
+        #
+        # (string(CONCAT) rather than a multi-value set(): a list would
+        # swallow every ";" in the text when expanded into message().)
+        if(_pmn_dist_target_source STREQUAL "toolchain")
+            string(CONCAT _pmn_fix
+                "The toolchain file picked its own compiler, so this means it was overridden "
+                "afterwards -- most likely an explicit -DCMAKE_CXX_COMPILER=... (on macOS "
+                "also -DCMAKE_OSX_ARCHITECTURES=...), or a CMakeCache.txt left in this "
+                "build directory by an earlier configure for a different target.\n"
+                "Remove that override, or configure into a fresh build directory. The default "
+                "layout already gives every preset its own (out/build/<preset>); "
+                "${CMAKE_BINARY_DIR} is being shared between targets.")
+        else()
+            string(CONCAT _pmn_fix
+                "-DDIST_TARGET=... only labels the build; it does not select a compiler. Use "
+                "the toolchain file made for that target, which sets both together:\n"
+                "  -DCMAKE_TOOLCHAIN_FILE=${CMAKE_SOURCE_DIR}/breeze/cmake/toolchains/${DIST_TARGET}.cmake\n"
+                "or the matching CMakePresets.json preset, which selects it for you:\n"
+                "  cmake --preset ${DIST_TARGET}")
+        endif()
+
+        # Some compilers can't be redirected from CMake at all; say so
+        # rather than only pointing at a toolchain file that cannot
+        # help.
+        set(_pmn_family_hint "")
+        if(DIST_TARGET MATCHES "-msvc$")
+            set(_pmn_family_hint
+                "\ncl.exe's architecture is decided by the Visual Studio developer environment \
+it is run from, not by CMake: open the matching Native Tools / Cross Tools Command Prompt \
+(vcvarsall.bat), or build with breeze\\scripts\\build.bat, which does that for you.")
+        elseif(DIST_TARGET MATCHES "^windows-(x64|arm64)-clang$")
+            set(_pmn_family_hint
+                "\nThis GNU-style Clang gets its target from the shell environment it runs in: \
+use an MSYS2 CLANG64 (x64) or CLANGARM64 (ARM64) shell, or build with breeze\\scripts\\build.bat, which puts that toolchain first on PATH.")
+        endif()
+
+        message(FATAL_ERROR
+            "DIST_TARGET is '${DIST_TARGET}', but the CXX compiler CMake actually found -- "
+            "${CMAKE_CXX_COMPILER_ID} ${CMAKE_CXX_COMPILER_VERSION} -- auto-detects to "
+            "${_pmn_detected_desc}, not '${DIST_TARGET}'.\n"
+            "${_pmn_fix}\n"
+            "${_pmn_family_hint}")
+    endif()
+
+    message(STATUS "DIST_TARGET    = ${DIST_TARGET}")
+endif()
+
+# Platform / compiler metadata from DIST_TARGET.
+if(DIST_TARGET STREQUAL "linux-x64-gcc")
+    set(PLATFORM "linux")
+    set(ARCHITECTURE "x64")
+    set(COMPILER_ID "gcc")
+elseif(DIST_TARGET STREQUAL "linux-x64-clang")
+    set(PLATFORM "linux")
+    set(ARCHITECTURE "x64")
+    set(COMPILER_ID "clang")
+elseif(DIST_TARGET STREQUAL "linux-arm64-gcc")
+    set(PLATFORM "linux")
+    set(ARCHITECTURE "arm64")
+    set(COMPILER_ID "gcc")
+elseif(DIST_TARGET STREQUAL "linux-arm64-clang")
+    set(PLATFORM "linux")
+    set(ARCHITECTURE "arm64")
+    set(COMPILER_ID "clang")
+elseif(DIST_TARGET STREQUAL "linux-arm32-gcc")
+    set(PLATFORM "linux")
+    set(ARCHITECTURE "arm32")
+    set(COMPILER_ID "gcc")
+elseif(DIST_TARGET STREQUAL "linux-arm32-clang")
+    set(PLATFORM "linux")
+    set(ARCHITECTURE "arm32")
+    set(COMPILER_ID "clang")
+elseif(DIST_TARGET STREQUAL "macos-arm64-clang")
+    set(PLATFORM "macos")
+    set(ARCHITECTURE "arm64")
+    set(COMPILER_ID "clang")
+elseif(DIST_TARGET STREQUAL "macos-x64-clang")
+    set(PLATFORM "macos")
+    set(ARCHITECTURE "x64")
+    set(COMPILER_ID "clang")
+elseif(DIST_TARGET STREQUAL "windows-x64-msvc")
+    set(PLATFORM "windows")
+    set(ARCHITECTURE "x64")
+    set(COMPILER_ID "msvc")
+elseif(DIST_TARGET STREQUAL "windows-arm64-msvc")
+    set(PLATFORM "windows")
+    set(ARCHITECTURE "arm64")
+    set(COMPILER_ID "msvc")
+elseif(DIST_TARGET STREQUAL "windows-x64-clang-cl")
+    set(PLATFORM "windows")
+    set(ARCHITECTURE "x64")
+    set(COMPILER_ID "clang-cl")
+elseif(DIST_TARGET STREQUAL "windows-arm64-clang-cl")
+    set(PLATFORM "windows")
+    set(ARCHITECTURE "arm64")
+    set(COMPILER_ID "clang-cl")
+elseif(DIST_TARGET STREQUAL "windows-x64-clang")
+    set(PLATFORM "windows")
+    set(ARCHITECTURE "x64")
+    set(COMPILER_ID "clang")
+elseif(DIST_TARGET STREQUAL "windows-arm64-clang")
+    set(PLATFORM "windows")
+    set(ARCHITECTURE "arm64")
+    set(COMPILER_ID "clang")
+elseif(DIST_TARGET STREQUAL "windows-x86-mingw32")
+    set(PLATFORM "windows")
+    set(ARCHITECTURE "x86")
+    set(COMPILER_ID "mingw32")
+elseif(DIST_TARGET STREQUAL "windows-x64-mingw64")
+    set(PLATFORM "windows")
+    set(ARCHITECTURE "x64")
+    set(COMPILER_ID "mingw64")
+else()
+    message(FATAL_ERROR
+        "Unsupported DIST_TARGET: '${DIST_TARGET}'.\n"
+        "Valid values: ${_pmn_valid_dist_targets_str}\n"
+        "Tip: open CMakePresets.json in your IDE to select a preset, "
+        "or pass -DDIST_TARGET=<value> on the command line.")
+endif()
+
+message(STATUS "Platform     = ${PLATFORM}")
+message(STATUS "Architecture = ${ARCHITECTURE}")
+message(STATUS "Compiler     = ${COMPILER_ID} (${CMAKE_CXX_COMPILER_ID} ${CMAKE_CXX_COMPILER_VERSION})")
diff --git a/breeze/cmake/toolchains/_common.cmake b/breeze/cmake/toolchains/_common.cmake
new file mode 100644
index 0000000..22da693
--- /dev/null
+++ b/breeze/cmake/toolchains/_common.cmake
@@ -0,0 +1,850 @@
+# =============================================================================
+# toolchains/_common.cmake
+#
+# Helpers shared by the per-DIST_TARGET toolchain files next to this one
+# (linux-x64-gcc.cmake, windows-arm64-clang-cl.cmake, ...). This is not a
+# toolchain file itself -- nothing should point CMAKE_TOOLCHAIN_FILE here.
+#
+# Why toolchain files at all
+# --------------------------
+# A toolchain file is CMake's own mechanism for "build with THIS compiler
+# for THIS target". CMake reads it before project() detects anything, so
+# the compiler and target are settled first instead of being discovered
+# and then cross-checked after the fact. Every CMakePresets.json preset
+# points at the toolchain file with its own name (see the "base" preset),
+# and each file does three things:
+#
+#   1. Declares which DIST_TARGET it is for (PMN_TOOLCHAIN_DIST_TARGET), so
+#      TargetSelection.cmake no longer has to guess from the compiler and
+#      can't be handed a mislabeled build -- the label and the compiler
+#      travel together.
+#   2. Picks the compiler (and, for clang-cl, the --target triple).
+#   3. Where the target isn't the machine running CMake, sets up a real
+#      cross-compile: CMAKE_SYSTEM_NAME / CMAKE_SYSTEM_PROCESSOR, restricts
+#      find_package/find_library to the target's sysroot (so a host-arch
+#      library is never linked into a foreign-arch binary), and registers
+#      an emulator (qemu-user / wine) if one is installed, so ctest can run
+#      what it just built.
+#
+# Two behaviors worth knowing, both verified rather than assumed:
+#
+#   * CMAKE_SYSTEM_NAME is only set when the build really is a cross build.
+#     Setting it -- even to the value the host already has -- flips
+#     CMAKE_CROSSCOMPILING to TRUE, which changes how try_run and
+#     several third-party CMakeLists behave. Native builds leave it alone.
+#
+#   * A compiler chosen here never overrides an explicit
+#     -DCMAKE_CXX_COMPILER=... on the command line (an unguarded set()
+#     in a toolchain file silently would). The toolchain DOES beat a stray
+#     CXX environment variable, since a target called "linux-x64-gcc"
+#     shouldn't be built with whatever CXX=clang++ happens to be exported.
+#
+#   * macOS is deliberately not a "cross build" even when the architecture
+#     differs from the machine's (an x86_64 build on an Apple Silicon Mac):
+#     Apple's clang is one multi-architecture compiler, so that is a
+#     different -arch flag, not a different compiler. pmn_macos_toolchain()
+#     leaves CMAKE_SYSTEM_NAME alone and pins CMAKE_OSX_ARCHITECTURES.
+#
+# Toolchain files are read more than once per configure (CMake re-reads
+# them for every try_compile), so everything here must stay cheap and
+# idempotent.
+# =============================================================================
+
+include_guard(GLOBAL)
+
+include("${CMAKE_CURRENT_LIST_DIR}/../HostArch.cmake")
+
+# -----------------------------------------------------------------------
+# pmn_warn_once(<key> <text>...)
+#
+# message(WARNING ...) at most once per configure. This file is read again
+# for the same scope (see the note at the top), so a plain warning would
+# print as many times as the file is read -- and the same multi-line
+# warning twice in a row reads as two problems. The <text> arguments are
+# joined with nothing between them, like message()'s own, so they must not
+# contain a semicolon (a list separator, which would be lost).
+# -----------------------------------------------------------------------
+function(pmn_warn_once _pmn_key)
+    get_property(_pmn_seen GLOBAL PROPERTY "PMN_WARNED_${_pmn_key}")
+    if(NOT _pmn_seen)
+        set_property(GLOBAL PROPERTY "PMN_WARNED_${_pmn_key}" TRUE)
+        string(JOIN "" _pmn_text ${ARGN})
+        message(WARNING "${_pmn_text}")
+    endif()
+endfunction()
+
+# -----------------------------------------------------------------------
+# pmn_check_msvc_target(<arch>)
+#
+# For the presets that link against MSVC's runtime libraries (msvc and
+# clang-cl): asks the Visual Studio developer prompt CMake runs in what it is
+# set up for, before CMake's own compiler test fails with an error that
+# names neither -- "cannot open msvcrt.lib", or lld-link's "could not open
+# 'msvcrtd.lib'". Both are warnings: the configure carries on, and either
+# works anyway or fails right below the explanation.
+#
+#   * VSCMD_ARG_TGT_ARCH, which the developer prompts set, names another
+#     target than the preset builds for.
+#   * VCToolsInstallDir, set by the same prompts, has no lib/<arch>/msvcrt.lib:
+#     the component that provides the target is not installed. From an x64
+#     machine ARM64 is a cross build and needs the ARM64 build tools; vcvarsall
+#     still "succeeds" without them, leaving the host's x64 cl first on PATH
+#     and the ARM64 library directory in LIB.
+# -----------------------------------------------------------------------
+function(pmn_check_msvc_target _pmn_arch)
+    if(DEFINED ENV{VSCMD_ARG_TGT_ARCH} AND NOT "$ENV{VSCMD_ARG_TGT_ARCH}" STREQUAL "${_pmn_arch}")
+        pmn_warn_once(msvc-target-arch
+            "This Visual Studio developer prompt targets $ENV{VSCMD_ARG_TGT_ARCH}, but the "
+            "'${PMN_TOOLCHAIN_DIST_TARGET}' toolchain builds for ${_pmn_arch}. Open the matching prompt "
+            "(for example an x64 Native Tools or x64_arm64 Cross Tools Command Prompt), or build with "
+            "breeze\\scripts\\build.bat, which enters the right environment for you, and delete the "
+            "build directory after switching.")
+    endif()
+    if(DEFINED ENV{VCToolsInstallDir} AND NOT EXISTS "$ENV{VCToolsInstallDir}/lib/${_pmn_arch}/msvcrt.lib")
+        pmn_warn_once(msvc-target-libs
+            "The MSVC runtime libraries for ${_pmn_arch} are missing: $ENV{VCToolsInstallDir}lib/${_pmn_arch}/msvcrt.lib "
+            "does not exist, so linking will fail with 'cannot open msvcrt.lib'. Add the component for "
+            "${_pmn_arch} in the Visual Studio Installer (Modify, Individual components): \"MSVC ... C++ "
+            "ARM64/ARM64EC build tools (Latest)\" for arm64, which an x64 machine needs too because it "
+            "cross-compiles, or \"MSVC ... C++ x64/x86 build tools (Latest)\" for x64. breeze\\scripts\\setup.bat "
+            "offers to add the ARM64 one.")
+    endif()
+endfunction()
+
+# -----------------------------------------------------------------------
+# pmn_note_once(<key> <text>...)
+#
+# message(STATUS ...) at most once per configure -- pmn_warn_once's quiet
+# sibling, for information that is useful in the log but is not a problem
+# (which target sysroot is in use; that there is none).
+# -----------------------------------------------------------------------
+function(pmn_note_once _pmn_key)
+    get_property(_pmn_seen GLOBAL PROPERTY "PMN_NOTED_${_pmn_key}")
+    if(NOT _pmn_seen)
+        set_property(GLOBAL PROPERTY "PMN_NOTED_${_pmn_key}" TRUE)
+        string(JOIN "" _pmn_text ${ARGN})
+        message(STATUS "${_pmn_text}")
+    endif()
+endfunction()
+
+# -----------------------------------------------------------------------
+# pmn_find_sysroot(<x64|arm64|arm32> <dir-var> <why-var>)
+#
+# Which TARGET SYSROOT, if any, a Linux cross build should use: a directory
+# laid out like the target machine's root filesystem (usr/include, usr/lib,
+# ...) that holds the libraries and headers the project's dependencies need
+# beyond the C/C++ runtime -- X11, OpenGL, ALSA and the like. A cross
+# compiler package brings only the runtime (/usr/<triplet>), so a dependency
+# that asks for anything else stops with "Could NOT find X11" (raylib's GLFW
+# does exactly that on Linux). In order:
+#
+#   1. -DCMAKE_SYSROOT=<dir> on the command line or in a preset: used as is.
+#   2. <project>/.cache/sysroots/linux-<arch>, if that directory exists
+#      (linux-arm64, linux-arm32, linux-x64): one per architecture, shared
+#      by the gcc and clang presets, found without any option -- which is
+#      what lets several cross presets be built one after the other.
+#
+# Both outputs are empty when there is none. A directory that does not exist
+# is an error; one without usr/ in it only a warning (the usual mistake is
+# pointing at the folder that CONTAINS the root filesystem).
+# -----------------------------------------------------------------------
+function(pmn_find_sysroot _pmn_arch _pmn_out_dir _pmn_out_why)
+    set(_pmn_dir "")
+    set(_pmn_why "")
+    # The cache, not the plain variable: a toolchain file sets a plain
+    # CMAKE_SYSROOT itself (below), and a re-read must not mistake that for
+    # the user's choice.
+    if(DEFINED CACHE{CMAKE_SYSROOT} AND NOT "$CACHE{CMAKE_SYSROOT}" STREQUAL "")
+        set(_pmn_dir "$CACHE{CMAKE_SYSROOT}")
+        set(_pmn_why "CMAKE_SYSROOT")
+    else()
+        get_filename_component(_pmn_root "${CMAKE_CURRENT_LIST_DIR}/../../.." ABSOLUTE)
+        if(IS_DIRECTORY "${_pmn_root}/.cache/sysroots/linux-${_pmn_arch}")
+            set(_pmn_dir "${_pmn_root}/.cache/sysroots/linux-${_pmn_arch}")
+            set(_pmn_why ".cache/sysroots/linux-${_pmn_arch}")
+        endif()
+    endif()
+    if(_pmn_dir)
+        if(NOT IS_DIRECTORY "${_pmn_dir}")
+            message(FATAL_ERROR
+                "The target sysroot '${_pmn_dir}' (${_pmn_why}) is not a directory.\n"
+                "Point CMAKE_SYSROOT at a root filesystem for the target (it has usr/include and "
+                "usr/lib in it), or drop the option. See \"Cross builds and system libraries\" "
+                "in the README.")
+        endif()
+        if(NOT IS_DIRECTORY "${_pmn_dir}/usr")
+            pmn_warn_once(sysroot-layout
+                "The target sysroot '${_pmn_dir}' has no usr/ directory, so it does not look like "
+                "a root filesystem -- is it the folder that contains one? Headers are looked for in "
+                "<sysroot>/usr/include and libraries in <sysroot>/usr/lib.")
+        endif()
+    endif()
+    set(${_pmn_out_dir} "${_pmn_dir}" PARENT_SCOPE)
+    set(${_pmn_out_why} "${_pmn_why}" PARENT_SCOPE)
+endfunction()
+
+# -----------------------------------------------------------------------
+# pmn_use_sysroot(<dir> <triplet>)
+#
+# Makes <dir> the target's root for this build:
+#
+#   * CMAKE_SYSROOT -- CMake passes --sysroot= to GCC and Clang, and
+#     find_package/find_library/find_path search under it. It also goes
+#     FIRST in CMAKE_FIND_ROOT_PATH, ahead of the cross compiler's own
+#     /usr/<triplet>, so what the target really has wins.
+#   * CMAKE_LIBRARY_ARCHITECTURE, when the sysroot is Debian-style
+#     multiarch (libraries in usr/lib/<triplet>/): without it find_library
+#     doesn't look there.
+#   * pkg-config: PKG_CONFIG_SYSROOT_DIR / PKG_CONFIG_LIBDIR point at the
+#     sysroot's .pc files only, and PKG_CONFIG_PATH is dropped, so
+#     pkg_check_modules() answers for the target instead of the host (whose
+#     .pc files would hand the compiler x86 include paths and libraries).
+#
+# A macro, like the rest of this file's helpers that set variables: the
+# toolchain file's own scope is where they must land.
+# -----------------------------------------------------------------------
+macro(pmn_use_sysroot _pmn_sr_dir _pmn_sr_triplet)
+    set(CMAKE_SYSROOT "${_pmn_sr_dir}")
+    list(PREPEND CMAKE_FIND_ROOT_PATH "${_pmn_sr_dir}")
+    list(REMOVE_DUPLICATES CMAKE_FIND_ROOT_PATH)
+    if(NOT CMAKE_LIBRARY_ARCHITECTURE AND IS_DIRECTORY "${_pmn_sr_dir}/usr/lib/${_pmn_sr_triplet}")
+        set(CMAKE_LIBRARY_ARCHITECTURE "${_pmn_sr_triplet}")
+    endif()
+    set(_pmn_sr_pc "")
+    foreach(_pmn_sr_sub
+            usr/lib/pkgconfig
+            usr/lib64/pkgconfig
+            usr/lib/${_pmn_sr_triplet}/pkgconfig
+            usr/share/pkgconfig)
+        list(APPEND _pmn_sr_pc "${_pmn_sr_dir}/${_pmn_sr_sub}")
+    endforeach()
+    list(JOIN _pmn_sr_pc ":" _pmn_sr_pc_joined)
+    set(ENV{PKG_CONFIG_SYSROOT_DIR} "${_pmn_sr_dir}")
+    set(ENV{PKG_CONFIG_LIBDIR} "${_pmn_sr_pc_joined}")
+    unset(ENV{PKG_CONFIG_PATH})
+endmacro()
+
+# -----------------------------------------------------------------------
+# pmn_toolchain_target(<DIST_TARGET>)
+#
+# Declares which DIST_TARGET the calling toolchain file is for.
+# TargetSelection.cmake reads PMN_TOOLCHAIN_DIST_TARGET and uses it as
+# DIST_TARGET (an explicit, different -DDIST_TARGET is a FATAL_ERROR).
+# -----------------------------------------------------------------------
+macro(pmn_toolchain_target _pmn_tc_dist_target)
+    set(PMN_TOOLCHAIN_DIST_TARGET "${_pmn_tc_dist_target}")
+endmacro()
+
+# -----------------------------------------------------------------------
+# pmn_use_compilers(<cxx-program> <c-program> "<install hint>")
+#
+# Selects the C++ (and C) compiler by program name, resolved on PATH to an
+# absolute path so it's identical in every try_compile. Skipped for
+# whichever of CMAKE_CXX_COMPILER / CMAKE_C_COMPILER the user already
+# chose explicitly.
+#
+# A missing C++ compiler is a FATAL_ERROR here, with the install hint,
+# rather than CMake's generic "compiler ... is not a full path and was not
+# found in the PATH". The C compiler is set too even though the project
+# is C++-only: if someone later adds a C source or a C dependency, CMake
+# must not silently auto-detect the HOST's cc for a cross build and emit
+# wrong-architecture objects. If the C compiler can't be found, its bare
+# name is set anyway so that mistake fails loudly.
+#
+# A function (not a macro) on purpose: the hint is free text that a macro
+# would evaluate twice, and its temporaries stay out of the caller's scope.
+# PARENT_SCOPE lands in the toolchain file's own scope because the macros
+# below, which call this, don't create one.
+# -----------------------------------------------------------------------
+function(pmn_use_compilers CXX_PROGRAM C_PROGRAM HINT)
+    if(NOT CMAKE_CXX_COMPILER)
+        find_program(_pmn_tc_cxx_path NAMES "${CXX_PROGRAM}" NO_CACHE)
+        if(NOT _pmn_tc_cxx_path)
+            message(FATAL_ERROR
+                "The '${PMN_TOOLCHAIN_DIST_TARGET}' toolchain needs the C++ compiler "
+                "'${CXX_PROGRAM}', but it isn't on PATH.\n${HINT}\n"
+                "(Or name a different compiler explicitly: -DCMAKE_CXX_COMPILER=<path>)")
+        endif()
+        set(CMAKE_CXX_COMPILER "${_pmn_tc_cxx_path}" PARENT_SCOPE)
+    endif()
+    if(NOT CMAKE_C_COMPILER)
+        find_program(_pmn_tc_c_path NAMES "${C_PROGRAM}" NO_CACHE)
+        if(_pmn_tc_c_path)
+            set(CMAKE_C_COMPILER "${_pmn_tc_c_path}" PARENT_SCOPE)
+        else()
+            set(CMAKE_C_COMPILER "${C_PROGRAM}" PARENT_SCOPE)
+        endif()
+    endif()
+endfunction()
+
+# -----------------------------------------------------------------------
+# pmn_cross_target(<system-name> <system-processor> <find-root>)
+#
+# Turns this into a cross build. <find-root> is the target's sysroot-like
+# prefix (Debian/Ubuntu put a cross toolchain's target headers and
+# libraries under /usr/<triplet>); an explicit -DCMAKE_SYSROOT=... and
+# -DCMAKE_FIND_ROOT_PATH=... from the user are kept and extended, not
+# replaced.
+#
+# The four MODE settings are the standard cross-compile split: programs
+# (Doxygen, a pinned ninja, ...) come from the HOST; libraries, headers
+# and CMake packages only from the target's root. That last one is what
+# makes FetchContent's find_package(fmt) miss the host's libfmt -- which
+# would link, then fail at load time as the wrong architecture -- and fall
+# through to fetching and building fmt for the target.
+# -----------------------------------------------------------------------
+macro(pmn_cross_target _pmn_tc_system _pmn_tc_processor _pmn_tc_root)
+    set(CMAKE_SYSTEM_NAME "${_pmn_tc_system}")
+    set(CMAKE_SYSTEM_PROCESSOR "${_pmn_tc_processor}")
+    list(APPEND CMAKE_FIND_ROOT_PATH "${_pmn_tc_root}")
+    list(REMOVE_DUPLICATES CMAKE_FIND_ROOT_PATH)
+    set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+    set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+    set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+    set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
+endmacro()
+
+# -----------------------------------------------------------------------
+# pmn_cross_emulator(<program>|"<program>;<program>" [<args>...])
+#
+# Registers the first of the given program names that is installed
+# (qemu-aarch64, or "wine;wine64", ...) as CMAKE_CROSSCOMPILING_EMULATOR,
+# so ctest and add_custom_command(COMMAND <target>) can run a
+# foreign-architecture binary, and so can breeze/scripts/run.sh. Silent if none is
+# installed -- the build itself doesn't need one. An emulator the user set
+# explicitly is left alone.
+#
+# It's a cache entry rather than a plain variable so that breeze/scripts/run.sh,
+# which runs long after configure, can read it back out of CMakeCache.txt.
+# CMake treats a cached CMAKE_CROSSCOMPILING_EMULATOR exactly like a
+# variable set here (it's also what -DCMAKE_CROSSCOMPILING_EMULATOR=...
+# creates). Only set once found, so installing qemu later still gets
+# picked up on the next configure.
+# -----------------------------------------------------------------------
+function(pmn_cross_emulator PROGRAM)
+    if(NOT CMAKE_CROSSCOMPILING_EMULATOR)
+        find_program(_pmn_tc_emulator_path NAMES ${PROGRAM} NO_CACHE)
+        if(_pmn_tc_emulator_path)
+            set(CMAKE_CROSSCOMPILING_EMULATOR "${_pmn_tc_emulator_path}" ${ARGN}
+                CACHE STRING "Emulator used to run cross-compiled executables (ctest, breeze/scripts/run.sh)")
+        endif()
+    endif()
+endfunction()
+
+# -----------------------------------------------------------------------
+# pmn_linux_toolchain(<x64|arm64|arm32> <gcc|clang>)
+#
+# One implementation behind all six linux-* toolchain files.
+#
+# Native or cross is decided by comparing the requested architecture with
+# the machine CMake is running on (`uname -m`, via HostArch.cmake): the same
+# linux-arm64-gcc preset builds natively on ARM64 hardware with the ordinary
+# g++, and cross-builds from an x64 machine with aarch64-linux-gnu-g++.
+#
+#   GCC   cross: <triplet>-g++ -- breeze/scripts/setup.sh installs this for you on
+#                apt (Debian/Ubuntu), pacman (Arch, arm64 only), and dnf
+#                (Fedora/RHEL, AArch64/32-bit ARM only, from a COPR since
+#                Fedora's own cross-gcc ships no libstdc++) -- see its own
+#                "why" text for exactly what and why, including the gaps:
+#                x86-64-from-arm64 has no known working package anywhere
+#                yet, and 32-bit ARM on Arch is AUR-only (x64 hosts only).
+#   Clang cross: clang++ --target=<triplet>, which additionally needs the
+#                target's libstdc++/libc: the GCC cross package above
+#                provides them under /usr/<triplet>, or pass
+#                -DCMAKE_SYSROOT=<sysroot>. <triplet> is the one the cross
+#                g++ says it was built for (-dumpmachine) when that is the
+#                same architecture -- the preset's own default otherwise.
+#
+# Both families check what the installed cross compiler tells them instead of
+# trusting it: a sysroot it reports that isn't on disk is dropped, with a
+# warning; a GCC that can't find the assembler for its own target (and would
+# quietly run the host's) is warned about up front, before CMake's compiler
+# test fails with an error that names neither. Both are the signature of a
+# compiler installed beside binutils or a C library from a different package
+# set -- see "32-bit ARM on Arch" in the README.
+#
+# A cross build can also have a TARGET SYSROOT -- a root filesystem for the
+# target with the libraries and headers its dependencies need beyond the
+# C/C++ runtime (X11, OpenGL, ALSA, ...), which no cross compiler package
+# ships: -DCMAKE_SYSROOT=<dir>, or just a directory at
+# .cache/sysroots/linux-<arch>. pmn_find_sysroot / pmn_use_sysroot below
+# say what it changes; without one the configure says so in its first lines,
+# and a dependency that wants such a library stops with "Could NOT find".
+#
+# One unusual case falls outside this: a 32-bit userland running on a
+# 64-bit ARM kernel reports aarch64 from `uname -m` while its ordinary g++
+# already builds 32-bit code. For that, pass -DCMAKE_CXX_COMPILER=g++ (the
+# build is then labeled arm32, correctly, but is treated as a cross build).
+#
+# NOTE for anyone editing the macros in this file: a macro's parameters
+# are textual substitutions, so every use inside if() is quoted --
+# unquoted, `if(x64 STREQUAL ...)` would treat "x64" as a variable name.
+# -----------------------------------------------------------------------
+macro(pmn_linux_toolchain _pmn_tc_arch _pmn_tc_family)
+    if("${_pmn_tc_arch}" STREQUAL "x64")
+        set(_pmn_tc_processor "x86_64")
+        set(_pmn_tc_triplet   "x86_64-linux-gnu")
+        set(_pmn_tc_gcc_pkg   "g++-x86-64-linux-gnu")
+        set(_pmn_tc_qemu      "qemu-x86_64")
+    elseif("${_pmn_tc_arch}" STREQUAL "arm64")
+        set(_pmn_tc_processor "aarch64")
+        set(_pmn_tc_triplet   "aarch64-linux-gnu")
+        set(_pmn_tc_gcc_pkg   "g++-aarch64-linux-gnu")
+        set(_pmn_tc_qemu      "qemu-aarch64")
+    elseif("${_pmn_tc_arch}" STREQUAL "arm32")
+        set(_pmn_tc_processor "arm")
+        set(_pmn_tc_triplet   "arm-linux-gnueabihf")
+        set(_pmn_tc_gcc_pkg   "g++-arm-linux-gnueabihf")
+        set(_pmn_tc_qemu      "qemu-arm")
+    else()
+        message(FATAL_ERROR "pmn_linux_toolchain: unknown architecture '${_pmn_tc_arch}'")
+    endif()
+
+    pmn_host_arch(_pmn_tc_host_arch)
+    if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Linux" AND "${_pmn_tc_host_arch}" STREQUAL "${_pmn_tc_arch}")
+        # Native: this machine already IS the target.
+        if("${_pmn_tc_family}" STREQUAL "gcc")
+            pmn_use_compilers(g++ gcc "Run breeze/scripts/setup.sh to install one, or by hand -- e.g. on Debian/Ubuntu: sudo apt install g++")
+        else()
+            pmn_use_compilers(clang++ clang "Run breeze/scripts/setup.sh to install one, or by hand -- e.g. on Debian/Ubuntu: sudo apt install clang")
+        endif()
+    else()
+        # Cross.
+        pmn_cross_target(Linux "${_pmn_tc_processor}" "/usr/${_pmn_tc_triplet}")
+
+        # The actual sysroot the installed cross package for this triplet
+        # was built with -- nothing meaningful on a flat layout (apt's,
+        # and pacman's -- see the "/" normalization below for what their
+        # cross-gcc actually prints), a real path on a nested one (dnf's
+        # COPR toolchain, which mirrors Fedora's own cross-gcc convention:
+        # /usr/<triplet>/sys-root). Queried once, up front, because both
+        # families need it below: GCC already knows its own paths for
+        # compiling and linking, but qemu-user doesn't -- given the flat
+        # guess on a nested layout, it looks for the target's dynamic
+        # linker (ld-linux-aarch64.so.1, etc.) in the wrong place and
+        # doesn't find it ("Could not open '/lib/ld-linux-aarch64.so.1'",
+        # confirmed on Fedora) -- the same class of problem as Clang's
+        # link-time one below, just at run time and for either family.
+        # Clang additionally can't compile at all on a nested layout
+        # without being told the same thing explicitly -- see below.
+        find_program(_pmn_tc_cross_gxx NAMES "${_pmn_tc_triplet}-g++" NO_CACHE)
+        set(_pmn_tc_cross_sysroot "")
+        set(_pmn_tc_cross_machine "")
+        if(_pmn_tc_cross_gxx)
+            execute_process(
+                COMMAND "${_pmn_tc_cross_gxx}" -print-sysroot
+                OUTPUT_VARIABLE _pmn_tc_cross_sysroot
+                OUTPUT_STRIP_TRAILING_WHITESPACE
+                ERROR_QUIET
+            )
+            # A cross-gcc that was never configured with a sysroot of its
+            # own (apt's -- confirmed on Debian, where this broke qemu for
+            # every cross preset the moment this query was added) doesn't
+            # print an empty line for that: it prints "/", gcc's ordinary
+            # "no special sysroot" default. That is not a sysroot to
+            # hand anyone -- as qemu's -L it means "the target's root
+            # filesystem is THIS machine's", so it goes looking for the
+            # target's dynamic linker in the host's own /lib
+            # ("Could not open '/lib/ld-linux-aarch64.so.1'") -- and as
+            # Clang's --sysroot it points header and library lookup at the
+            # host's /usr too. Treated exactly like empty from here on.
+            if(_pmn_tc_cross_sysroot STREQUAL "/")
+                set(_pmn_tc_cross_sysroot "")
+            endif()
+            # A sysroot the compiler reports but that isn't on disk is what a
+            # toolchain whose parts don't belong together looks like: GCC
+            # relocates its configured sysroot next to itself, but only
+            # where the relocated directory exists -- otherwise it keeps the
+            # configured, unrelocated path. Seen with ARM's prebuilt GCC
+            # (built with --with-sysroot=/arm-none-linux-gnueabihf/libc)
+            # installed beside a binutils and glibc from somewhere else:
+            # -print-sysroot says "/arm-none-linux-gnueabihf/libc", nothing is
+            # there, and Clang -- handed that as --sysroot -- fell back to the
+            # HOST's crt files and failed to link ("Scrt1.o: file not
+            # recognized"). A path that doesn't exist is worse than none, so
+            # it is dropped, and said so.
+            if(_pmn_tc_cross_sysroot AND NOT IS_DIRECTORY "${_pmn_tc_cross_sysroot}")
+                pmn_warn_once(sysroot
+                    "The cross compiler ${_pmn_tc_cross_gxx} reports the sysroot "
+                    "'${_pmn_tc_cross_sysroot}', which does not exist, so it is ignored. That is "
+                    "what a toolchain whose parts don't belong together looks like -- a compiler "
+                    "from one package set, binutils or the C library from another -- and linking "
+                    "will most likely fail (\"file not recognized\", a missing crt1.o or libc). "
+                    "Install the compiler, binutils and C library for this target from the same "
+                    "source: breeze/scripts/setup.sh does that where it can (on Arch, for 32-bit ARM, "
+                    "see \"32-bit ARM on Arch\" in the README), or pass -DCMAKE_SYSROOT=<the "
+                    "target's root filesystem>.")
+                set(_pmn_tc_cross_sysroot "")
+            endif()
+            # The triple this compiler itself was built for -- not necessarily
+            # the one the preset is named after: ARM's own GCC release is
+            # arm-none-linux-gnueabihf, and its libraries live under
+            # lib/gcc/arm-none-linux-gnueabihf/, which Clang only finds when
+            # told that exact triple. (Debian's, Fedora's COPR and Arch's own
+            # cross compilers all say the same triple the preset uses, so
+            # nothing changes for them.)
+            execute_process(
+                COMMAND "${_pmn_tc_cross_gxx}" -dumpmachine
+                OUTPUT_VARIABLE _pmn_tc_cross_machine
+                OUTPUT_STRIP_TRAILING_WHITESPACE
+                ERROR_QUIET
+            )
+        endif()
+        # What the cross compiler package itself reports (or /usr/<triplet>):
+        # the root qemu runs the result against unless a target sysroot of the
+        # user's (below) can do it better.
+        if(_pmn_tc_cross_sysroot)
+            set(_pmn_tc_emulator_root "${_pmn_tc_cross_sysroot}")
+        else()
+            set(_pmn_tc_emulator_root "/usr/${_pmn_tc_triplet}")
+        endif()
+
+        # A target sysroot of the user's, if there is one: where the libraries
+        # and headers that a cross compiler package doesn't ship (X11,
+        # OpenGL, ALSA, ...) come from. See pmn_find_sysroot for where it is
+        # looked for and pmn_use_sysroot for what it changes. It replaces
+        # the compiler-reported sysroot for Clang's flags below, and for
+        # qemu's -L when it can run programs, i.e. holds the target's dynamic
+        # loader -- a partial copy (headers and link libraries only) must not
+        # take qemu's root away from the toolchain's.
+        pmn_find_sysroot("${_pmn_tc_arch}" _pmn_tc_sysroot _pmn_tc_sysroot_why)
+
+        # A build directory keeps what CMake detected about the compiler -- its library
+        # directories, the multiarch name -- from the FIRST configure on. A sysroot
+        # added, changed or removed since then leaves that stale, and the link lines
+        # go quietly wrong (a stray -L<sysroot>/usr/lib ahead of the compiler's own,
+        # say). The usual way to get here: a configure stops on a library the
+        # target's root lacks, the sysroot that has it is put in place, and the same
+        # build directory is configured again. So stop, and say what to do.
+        if(_pmn_tc_sysroot)
+            set(_pmn_tc_sysroot_id "${_pmn_tc_sysroot}")
+        else()
+            set(_pmn_tc_sysroot_id "(none)")
+        endif()
+        if(DEFINED CACHE{PMN_TC_SYSROOT_USED} AND NOT "$CACHE{PMN_TC_SYSROOT_USED}" STREQUAL "${_pmn_tc_sysroot_id}")
+            message(FATAL_ERROR
+                "The target sysroot changed since this build directory was first configured: "
+                "it was $CACHE{PMN_TC_SYSROOT_USED}, it is now ${_pmn_tc_sysroot_id}.\n"
+                "CMake keeps what it detected about the compiler in the build directory, and "
+                "that was detected against the old sysroot, so the link lines would go subtly "
+                "wrong. Delete the build directory and configure again:\n"
+                "  rm -rf ${CMAKE_BINARY_DIR}")
+        endif()
+        set(PMN_TC_SYSROOT_USED "${_pmn_tc_sysroot_id}" CACHE INTERNAL
+            "The target sysroot this build directory was first configured with")
+        if(_pmn_tc_sysroot)
+            pmn_use_sysroot("${_pmn_tc_sysroot}" "${_pmn_tc_triplet}")
+            pmn_note_once(sysroot "Target sysroot: ${_pmn_tc_sysroot} (${_pmn_tc_sysroot_why})")
+            set(_pmn_tc_cross_sysroot "${_pmn_tc_sysroot}")
+            file(GLOB _pmn_tc_loaders
+                "${_pmn_tc_sysroot}/lib/ld-linux*"
+                "${_pmn_tc_sysroot}/lib64/ld-linux*"
+                "${_pmn_tc_sysroot}/usr/lib/ld-linux*"
+                "${_pmn_tc_sysroot}/usr/lib64/ld-linux*"
+                "${_pmn_tc_sysroot}/lib/${_pmn_tc_triplet}/ld-linux*"
+                "${_pmn_tc_sysroot}/usr/lib/${_pmn_tc_triplet}/ld-linux*")
+            if(_pmn_tc_loaders)
+                set(_pmn_tc_emulator_root "${_pmn_tc_sysroot}")
+            endif()
+        else()
+            pmn_note_once(no-sysroot
+                "Cross build without a target sysroot: only ${_pmn_tc_emulator_root} is searched for \
+libraries and headers, so a dependency that needs system libraries (X11, OpenGL, ALSA, ...) will \
+stop with \"Could NOT find ...\". Put a root filesystem for the target in \
+.cache/sysroots/linux-${_pmn_tc_arch}, or pass -DCMAKE_SYSROOT=<dir> -- see \"Cross builds and \
+system libraries\" in the README.")
+        endif()
+
+        if("${_pmn_tc_family}" STREQUAL "gcc")
+            pmn_use_compilers("${_pmn_tc_triplet}-g++" "${_pmn_tc_triplet}-gcc"
+                "Run breeze/scripts/setup.sh to install the cross compiler for your package manager (apt for every target; dnf for AArch64 and 32-bit ARM, from a COPR; pacman for AArch64, and for 32-bit ARM from the AUR, which breeze/scripts/setup.sh offers -- see its own \"why\" text for details), or by hand -- e.g. on Debian/Ubuntu: sudo apt install ${_pmn_tc_gcc_pkg}")
+            # A cross GCC finds the assembler for its target in its own
+            # directories (<prefix>/<target>/bin/as and the like); when it
+            # doesn't, it quietly runs whatever `as` is on PATH -- the HOST's
+            # -- and the first file fails with an error that names neither
+            # (x86's `as` says: "invalid -march= option: `armv7-a+simd'").
+            # -print-prog-name=as says what GCC would run: an absolute path
+            # when it found one, the bare name when it didn't.
+            if(_pmn_tc_cross_gxx AND "${CMAKE_CXX_COMPILER}" STREQUAL "${_pmn_tc_cross_gxx}")
+                execute_process(
+                    COMMAND "${_pmn_tc_cross_gxx}" -print-prog-name=as
+                    OUTPUT_VARIABLE _pmn_tc_cross_as
+                    OUTPUT_STRIP_TRAILING_WHITESPACE
+                    ERROR_QUIET
+                )
+                if(_pmn_tc_cross_as AND NOT _pmn_tc_cross_as MATCHES "/")
+                    pmn_warn_once(assembler
+                        "The cross compiler ${_pmn_tc_cross_gxx} cannot find the assembler for its own "
+                        "target (-print-prog-name=as gives the bare name '${_pmn_tc_cross_as}'), so "
+                        "it will run the HOST's assembler instead, and the first file will fail with "
+                        "something like \"invalid -march= option\". The compiler and its binutils have "
+                        "to come from the same package set. breeze/scripts/setup.sh checks this with a test "
+                        "compile and, on Arch for 32-bit ARM, installs a matching set (see "
+                        "\"32-bit ARM on Arch\" in the README). Elsewhere install the binutils that "
+                        "belong to this compiler.")
+                endif()
+            endif()
+        else()
+            # Clang itself is multi-target and happily emits object code for
+            # ${_pmn_tc_triplet} with no cross package installed at all --
+            # the failure this check guards against only shows up much
+            # later, and far more cryptically, at the LINK step: Clang
+            # still hands linking to whatever plain `ld` it finds (the
+            # host's own, unless told otherwise), which doesn't recognize
+            # the target's ELF flavor ("unrecognised emulation mode:
+            # armelf_linux_eabi", say) since it was never built with that
+            # target enabled. The GCC branch above never has this problem
+            # -- "${_pmn_tc_triplet}-g++" simply doesn't exist without the
+            # cross package, so pmn_use_compilers already fails clearly --
+            # so checking for that same binary here (found above, for the
+            # sysroot query), even though Clang doesn't need it to
+            # compile, catches the same missing-package case before it
+            # reaches a linker error with no obvious connection to the
+            # real cause.
+            if(NOT _pmn_tc_cross_gxx)
+                message(FATAL_ERROR
+                    "The '${PMN_TOOLCHAIN_DIST_TARGET}' toolchain needs the ${_pmn_tc_triplet} cross "
+                    "package (for its linker and the target's libstdc++/libc) even to use Clang, and "
+                    "it isn't on PATH: run breeze/scripts/setup.sh to install it for your package manager "
+                    "(apt for every target; dnf for AArch64 and 32-bit ARM, from a COPR; pacman for "
+                    "AArch64, and for 32-bit ARM from the AUR, which breeze/scripts/setup.sh offers -- "
+                    "see its own \"why\" text for details), or by hand -- e.g. on Debian/Ubuntu: "
+                    "sudo apt install ${_pmn_tc_gcc_pkg}\n"
+                    "(Without it, configuring would proceed but linking would fail with an obscure "
+                    "\"unrecognised emulation mode\" or similar error instead of this one.)")
+            endif()
+            pmn_use_compilers(clang++ clang
+                "Run breeze/scripts/setup.sh to install Clang plus the matching cross package, or by hand -- e.g. on Debian/Ubuntu: sudo apt install clang ${_pmn_tc_gcc_pkg} (the second package provides the target's libraries)")
+            set(_pmn_tc_clang_triple "${_pmn_tc_triplet}")
+            if(_pmn_tc_cross_machine MATCHES "^${_pmn_tc_processor}")
+                set(_pmn_tc_clang_triple "${_pmn_tc_cross_machine}")
+            endif()
+            if(NOT _pmn_tc_clang_triple STREQUAL _pmn_tc_triplet)
+                message(STATUS "Clang targets ${_pmn_tc_clang_triple}, the triple ${_pmn_tc_cross_gxx} was built for (the preset's default is ${_pmn_tc_triplet})")
+            endif()
+            set(CMAKE_CXX_COMPILER_TARGET "${_pmn_tc_clang_triple}")
+            set(CMAKE_C_COMPILER_TARGET   "${_pmn_tc_clang_triple}")
+
+            # Unlike GCC, Clang has no distro-specific packaging knowledge
+            # baked in, so it falls back to a generic guess for where
+            # THIS triplet's crt1.o/crtbegin.o/libgcc live -- one that
+            # happens to match a flat /usr/<triplet> layout (apt's,
+            # pacman's) but not one nested under its own sys-root (dnf's
+            # COPR toolchain). Guessed wrong, it silently resolves to the
+            # HOST's own crt1.o instead -- still a real file, just the
+            # wrong architecture, which surfaces as an obscure linker
+            # error ("Relocations in generic ELF", confirmed on a Fedora
+            # aarch64 build) with no obvious connection to a missing
+            # flag. The real sysroot queried above, from the cross-gcc
+            # that's actually installed rather than guessed at here,
+            # fixes this the same way for either family; only Clang needs
+            # telling. --gcc-toolchain additionally points Clang at
+            # crtbegin.o/libgcc, which a sysroot alone doesn't cover on
+            # every layout (confirmed necessary for this same class of
+            # problem on Arch by the Linux kernel's own cross-build
+            # tooling, tools/scripts/Makefile.include -- included here
+            # only alongside a real sysroot, for the same "don't touch
+            # what Clang already gets right" reason); /usr is where a
+            # package manager's own cross-gcc lives on every platform
+            # this toolchain supports.
+            if(_pmn_tc_cross_sysroot)
+                set(CMAKE_SYSROOT "${_pmn_tc_cross_sysroot}")
+                # Appended only if absent: this file is read again for the
+                # same scope (project() and each enabled language, not just
+                # try_compile), and a plain append put the flag twice on every
+                # compile line and four times on every link line.
+                foreach(_pmn_tc_flags_var CMAKE_CXX_FLAGS_INIT CMAKE_C_FLAGS_INIT
+                        CMAKE_EXE_LINKER_FLAGS_INIT CMAKE_SHARED_LINKER_FLAGS_INIT)
+                    if(NOT "${${_pmn_tc_flags_var}}" MATCHES "--gcc-toolchain=/usr")
+                        string(APPEND ${_pmn_tc_flags_var} " --gcc-toolchain=/usr")
+                    endif()
+                endforeach()
+            endif()
+        endif()
+        pmn_cross_emulator("${_pmn_tc_qemu}" -L "${_pmn_tc_emulator_root}")
+    endif()
+endmacro()
+
+# -----------------------------------------------------------------------
+# pmn_mingw_toolchain(<x64|x86>)
+#
+# Behind windows-x64-mingw64 and windows-x86-mingw32. On a Windows host
+# (an MSYS2 MINGW64/MINGW32 shell, or a standalone MinGW-w64) this only
+# picks the compiler by its triplet-prefixed name. On a Linux host it is a
+# real cross build using the distro's own mingw-w64 packages -- apt, dnf
+# and pacman all ship a working one (breeze/scripts/setup.sh knows each; pacman's
+# single mingw-w64-gcc covers both x64 and x86, unlike apt/dnf's separate
+# packages per architecture) -- with wine as the emulator if installed.
+# -----------------------------------------------------------------------
+macro(pmn_mingw_toolchain _pmn_tc_arch)
+    if("${_pmn_tc_arch}" STREQUAL "x64")
+        set(_pmn_tc_processor "x86_64")
+        set(_pmn_tc_triplet   "x86_64-w64-mingw32")
+        set(_pmn_tc_pkg       "g++-mingw-w64-x86-64")
+    elseif("${_pmn_tc_arch}" STREQUAL "x86")
+        set(_pmn_tc_processor "i686")
+        set(_pmn_tc_triplet   "i686-w64-mingw32")
+        set(_pmn_tc_pkg       "g++-mingw-w64-i686")
+    else()
+        message(FATAL_ERROR "pmn_mingw_toolchain: unknown architecture '${_pmn_tc_arch}'")
+    endif()
+
+    if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows")
+        pmn_use_compilers("${_pmn_tc_triplet}-g++" "${_pmn_tc_triplet}-gcc"
+            "Install MinGW-w64 (e.g. MSYS2's mingw-w64 packages) and put its bin directory on PATH. breeze\\scripts\\build.bat puts MSYS2's folder on PATH by itself.")
+    else()
+        pmn_cross_target(Windows "${_pmn_tc_processor}" "/usr/${_pmn_tc_triplet}")
+        pmn_use_compilers("${_pmn_tc_triplet}-g++" "${_pmn_tc_triplet}-gcc"
+            "Run breeze/scripts/setup.sh to install the MinGW-w64 cross compiler for your package manager, or by hand -- e.g. on Debian/Ubuntu: sudo apt install ${_pmn_tc_pkg}")
+        # Tried architecture-matched name first, the other as fallback --
+        # not just for distros that ship only one of the two (the
+        # original reason for trying both), but because on at least one
+        # that ships both, plain "wine" turned out not to actually be
+        # 64-bit capable: windows-x64-mingw64 failed to start at all
+        # through it ("Bad EXE format") while windows-x86-mingw32 through
+        # that same "wine" worked fine, and explicitly preferring
+        # "wine64" for the x64 build fixed it. Confirmed harmless where
+        # this was never a problem (Arch, Fedora): wine64 there either
+        # already matches or doesn't exist, so the fallback is what runs
+        # either way, unchanged from before.
+        if("${_pmn_tc_arch}" STREQUAL "x64")
+            pmn_cross_emulator("wine64;wine")
+        else()
+            pmn_cross_emulator("wine;wine64")
+        endif()
+    endif()
+endmacro()
+
+# -----------------------------------------------------------------------
+# pmn_msvc_toolchain(<x64|arm64>)
+#
+# Behind windows-x64-msvc and windows-arm64-msvc. cl.exe has no --target:
+# which architecture it produces is decided by WHICH cl.exe comes first on
+# PATH, i.e. by the Visual Studio developer environment the shell was
+# started from. A toolchain file therefore can't switch architectures for
+# MSVC. What it can do is pick cl instead of letting CMake fall through to
+# whatever other compiler is on PATH, and fail early with the instruction
+# that fixes the usual cause. Whether the cl.exe it found really targets
+# the architecture in the DIST_TARGET is then verified by
+# TargetSelection.cmake, from CMAKE_CXX_COMPILER_ARCHITECTURE_ID.
+# -----------------------------------------------------------------------
+macro(pmn_msvc_toolchain _pmn_tc_arch)
+    if("${_pmn_tc_arch}" STREQUAL "x64")
+        pmn_use_compilers(cl cl
+            "Open an \"x64 Native Tools Command Prompt for VS\" (or a Developer PowerShell for VS defaulted to x64) and run this again. Or build with breeze\\scripts\\build.bat --preset ${PMN_TOOLCHAIN_DIST_TARGET}, which enters that environment for you.")
+    else()
+        pmn_use_compilers(cl cl
+            "Open a Visual Studio developer prompt configured for ARM64 -- an \"ARM64 Native Tools Command Prompt for VS\", or on an x64 machine an \"x64_arm64 Cross Tools Command Prompt for VS\" (vcvarsall.bat x64_arm64) -- and run this again. Or build with breeze\\scripts\\build.bat --preset ${PMN_TOOLCHAIN_DIST_TARGET}, which enters that environment for you.")
+    endif()
+    pmn_check_msvc_target("${_pmn_tc_arch}")
+endmacro()
+
+# -----------------------------------------------------------------------
+# pmn_clang_cl_toolchain(<x64|arm64>)
+#
+# Behind windows-x64-clang-cl and windows-arm64-clang-cl: LLVM's clang-cl,
+# the cl.exe-compatible driver, targeting the MSVC ABI. Unlike cl.exe,
+# clang-cl takes --target, so the architecture is pinned here
+# (CMAKE_CXX_COMPILER_TARGET -> --target=<triple> on every compile and
+# link line, and while CMake identifies the compiler) instead of depending
+# on whatever the environment or the machine's own architecture defaults
+# to. That is what lets windows-x64-clang-cl mean x64 on an ARM64 Windows
+# machine too.
+#
+# The MSVC STL headers and the Windows SDK libraries still come from a
+# Visual Studio / Build Tools install, as they do for any clang-cl build.
+# -----------------------------------------------------------------------
+macro(pmn_clang_cl_toolchain _pmn_tc_arch)
+    if("${_pmn_tc_arch}" STREQUAL "x64")
+        set(_pmn_tc_triple "x86_64-pc-windows-msvc")
+    elseif("${_pmn_tc_arch}" STREQUAL "arm64")
+        set(_pmn_tc_triple "aarch64-pc-windows-msvc")
+    else()
+        message(FATAL_ERROR "pmn_clang_cl_toolchain: unknown architecture '${_pmn_tc_arch}'")
+    endif()
+    pmn_use_compilers(clang-cl clang-cl
+        "Install LLVM (e.g.:  winget install LLVM.LLVM) or Visual Studio's \"C++ Clang tools for Windows\" component, and make sure clang-cl's directory is on PATH. breeze\\scripts\\build.bat finds LLVM's and Visual Studio's copies by itself.")
+    set(CMAKE_CXX_COMPILER_TARGET "${_pmn_tc_triple}")
+    set(CMAKE_C_COMPILER_TARGET   "${_pmn_tc_triple}")
+    pmn_check_msvc_target("${_pmn_tc_arch}")
+endmacro()
+
+# -----------------------------------------------------------------------
+# pmn_msys_clang_toolchain()
+#
+# Behind windows-x64-clang and windows-arm64-clang: Clang with its own
+# GNU-style driver (clang++), as in an MSYS2 CLANG64 / CLANGARM64 shell
+# -- distinct from clang-cl. Which architecture that clang++ targets is
+# the shell environment's default, so nothing is pinned here; the
+# environment is what makes clang++ a mingw-ABI compiler for the right
+# machine.
+# -----------------------------------------------------------------------
+macro(pmn_msys_clang_toolchain)
+    pmn_use_compilers(clang++ clang
+        "Open an MSYS2 CLANG64 (x64) or CLANGARM64 (ARM64) shell, whose clang++ targets the matching mingw ABI by default. breeze\\scripts\\build.bat puts that shell's toolchain folder on PATH for you.")
+endmacro()
+
+# -----------------------------------------------------------------------
+# pmn_macos_toolchain(<arm64|x64>)
+#
+# Behind macos-arm64-clang and macos-x64-clang. Apple's clang is ONE
+# multi-architecture compiler: which architecture it emits is a flag
+# (-arch), not a different program. So unlike the Linux cross builds there
+# is no cross compiler to find, no sysroot to restrict lookups to and no
+# emulator to register (an x86_64 binary runs on an Apple Silicon Mac
+# through Rosetta 2, and try_run works as usual) -- and CMAKE_CROSSCOMPILING
+# correctly stays FALSE. What this pins instead:
+#
+#   CMAKE_OSX_ARCHITECTURES      the ONE architecture, always -- even when
+#       it is the machine's own. That is the only reliable statement of what
+#       gets built: without it the compiler follows the process that
+#       launched it, so a cmake running under Rosetta 2 on an Apple Silicon
+#       Mac would quietly produce x86_64 for a target that says arm64.
+#   CMAKE_OSX_DEPLOYMENT_TARGET  the oldest macOS the result runs on:
+#       11.0, the first release that runs on Apple Silicon. Left unset it
+#       defaults to the SDK's own version, and everything built then
+#       refuses to start on any macOS older than the build machine's.
+#
+# Both only take effect if set BEFORE the first project(), which is
+# exactly when a toolchain file runs, and both yield to an explicit
+# -DCMAKE_OSX_...= on the command line (the label check in
+# TargetSelection.cmake then catches an architecture that no longer matches
+# the target). Homebrew's LLVM clang instead of Apple's works the same
+# way: -DCMAKE_CXX_COMPILER=$(brew --prefix llvm)/bin/clang++.
+# -----------------------------------------------------------------------
+macro(pmn_macos_toolchain _pmn_tc_arch)
+    if("${_pmn_tc_arch}" STREQUAL "arm64")
+        set(_pmn_tc_osx_arch "arm64")
+    elseif("${_pmn_tc_arch}" STREQUAL "x64")
+        set(_pmn_tc_osx_arch "x86_64")
+    else()
+        message(FATAL_ERROR "pmn_macos_toolchain: unknown architecture '${_pmn_tc_arch}'")
+    endif()
+
+    if(NOT CMAKE_OSX_ARCHITECTURES)
+        set(CMAKE_OSX_ARCHITECTURES "${_pmn_tc_osx_arch}")
+    endif()
+    if(NOT CMAKE_OSX_DEPLOYMENT_TARGET)
+        set(CMAKE_OSX_DEPLOYMENT_TARGET "11.0")
+    endif()
+
+    # /usr/bin/clang++ exists on every Mac, as a stub that only works once
+    # the Command Line Tools (or Xcode) are installed -- without them CMake
+    # would fail inside its own compiler check with "xcrun: error: invalid
+    # active developer path". Say what's actually wrong instead.
+    if(CMAKE_HOST_APPLE)
+        execute_process(COMMAND xcode-select -p
+            RESULT_VARIABLE _pmn_tc_xcode_rc
+            OUTPUT_QUIET ERROR_QUIET)
+        if(NOT _pmn_tc_xcode_rc EQUAL 0)
+            message(FATAL_ERROR
+                "The '${PMN_TOOLCHAIN_DIST_TARGET}' toolchain needs Apple's compiler, but no "
+                "developer directory is set (xcode-select -p failed).\n"
+                "Install the Xcode Command Line Tools:  xcode-select --install\n"
+                "(breeze/scripts/setup.sh offers to do this for you.)")
+        endif()
+    endif()
+
+    pmn_use_compilers(clang++ clang
+        "Install the Xcode Command Line Tools:  xcode-select --install")
+endmacro()
diff --git a/breeze/cmake/toolchains/linux-arm32-clang.cmake b/breeze/cmake/toolchains/linux-arm32-clang.cmake
new file mode 100644
index 0000000..bf66ba7
--- /dev/null
+++ b/breeze/cmake/toolchains/linux-arm32-clang.cmake
@@ -0,0 +1,21 @@
+# linux-arm32-clang: Clang building for 32-bit ARM (armhf) Linux.
+#
+#   On 32-bit ARM hardware: a native build with the ordinary clang++.
+#   Any other Linux machine: a cross build with clang++ --target=arm-linux-gnueabihf
+#                 -- or whatever triple the installed cross g++ reports for
+#                 itself (-dumpmachine): ARM's own GCC, the one on Arch, says
+#                 arm-none-linux-gnueabihf, and Clang only finds its libraries
+#                 under that name
+#                 (needs Clang plus the GCC cross package for the target's
+#                 libstdc++/libc, or -DCMAKE_SYSROOT=...; breeze/scripts/setup.sh
+#                 installs both on apt -- clang g++-arm-linux-gnueabihf --
+#                 and, from a COPR, dnf -- see linux-arm32-gcc.cmake for
+#                 details, and for why not on pacman).
+#                 If qemu-arm is installed it is registered as the
+#                 emulator, so ctest can run the result.
+#
+# See _common.cmake (pmn_linux_toolchain) for the details and overrides.
+include("${CMAKE_CURRENT_LIST_DIR}/_common.cmake")
+
+pmn_toolchain_target("linux-arm32-clang")
+pmn_linux_toolchain(arm32 clang)
diff --git a/breeze/cmake/toolchains/linux-arm32-gcc.cmake b/breeze/cmake/toolchains/linux-arm32-gcc.cmake
new file mode 100644
index 0000000..2045168
--- /dev/null
+++ b/breeze/cmake/toolchains/linux-arm32-gcc.cmake
@@ -0,0 +1,23 @@
+# linux-arm32-gcc: GCC building for 32-bit ARM (armhf) Linux.
+#
+#   On 32-bit ARM hardware: a native build with the ordinary g++.
+#   Any other Linux machine: a cross build with arm-linux-gnueabihf-g++.
+#                 breeze/scripts/setup.sh installs this for you on apt
+#                 (g++-arm-linux-gnueabihf) or, from a COPR, dnf
+#                 (arm-linux-gnueabihf-{binutils,gcc,glibc}); not through
+#                 pacman -- on Arch it exists only in the AUR, as ARM's own
+#                 prebuilt toolchain split into four packages
+#                 (arm-linux-gnueabihf-{binutils,glibc-headers,glibc,gcc}-bin;
+#                 x64 hosts only -- see the README, "32-bit ARM on Arch").
+#                 That GCC is built for the triple arm-none-linux-gnueabihf,
+#                 and finds its assembler and C library by that name, so the
+#                 four have to be installed together: a source-built binutils
+#                 or glibc beside it is the mix that fails (_common.cmake
+#                 warns about both symptoms). If qemu-arm is installed it
+#                 is registered as the emulator, so ctest can run the result.
+#
+# See _common.cmake (pmn_linux_toolchain) for the details and overrides.
+include("${CMAKE_CURRENT_LIST_DIR}/_common.cmake")
+
+pmn_toolchain_target("linux-arm32-gcc")
+pmn_linux_toolchain(arm32 gcc)
diff --git a/breeze/cmake/toolchains/linux-arm64-clang.cmake b/breeze/cmake/toolchains/linux-arm64-clang.cmake
new file mode 100644
index 0000000..aee9070
--- /dev/null
+++ b/breeze/cmake/toolchains/linux-arm64-clang.cmake
@@ -0,0 +1,17 @@
+# linux-arm64-clang: Clang building for 64-bit ARM (aarch64) Linux.
+#
+#   On ARM64 hardware: a native build with the ordinary clang++.
+#   Any other Linux machine: a cross build with clang++ --target=aarch64-linux-gnu
+#                 (needs Clang plus the GCC cross package for the target's
+#                 libstdc++/libc, or -DCMAKE_SYSROOT=...; breeze/scripts/setup.sh
+#                 installs both on apt -- clang g++-aarch64-linux-gnu --
+#                 pacman -- clang aarch64-linux-gnu-gcc -- or, from a COPR,
+#                 dnf -- clang aarch64-linux-gnu-{binutils,gcc,glibc}).
+#                 If qemu-aarch64 is installed it is registered as the
+#                 emulator, so ctest can run the result.
+#
+# See _common.cmake (pmn_linux_toolchain) for the details and overrides.
+include("${CMAKE_CURRENT_LIST_DIR}/_common.cmake")
+
+pmn_toolchain_target("linux-arm64-clang")
+pmn_linux_toolchain(arm64 clang)
diff --git a/breeze/cmake/toolchains/linux-arm64-gcc.cmake b/breeze/cmake/toolchains/linux-arm64-gcc.cmake
new file mode 100644
index 0000000..d16aaec
--- /dev/null
+++ b/breeze/cmake/toolchains/linux-arm64-gcc.cmake
@@ -0,0 +1,15 @@
+# linux-arm64-gcc: GCC building for 64-bit ARM (aarch64) Linux.
+#
+#   On ARM64 hardware: a native build with the ordinary g++.
+#   Any other Linux machine: a cross build with aarch64-linux-gnu-g++.
+#                 breeze/scripts/setup.sh installs this for you on apt
+#                 (g++-aarch64-linux-gnu), pacman (aarch64-linux-gnu-gcc), or,
+#                 from a COPR, dnf (aarch64-linux-gnu-{binutils,gcc,glibc}).
+#                 If qemu-aarch64 is installed it is registered as the
+#                 emulator, so ctest can run the result.
+#
+# See _common.cmake (pmn_linux_toolchain) for the details and overrides.
+include("${CMAKE_CURRENT_LIST_DIR}/_common.cmake")
+
+pmn_toolchain_target("linux-arm64-gcc")
+pmn_linux_toolchain(arm64 gcc)
diff --git a/breeze/cmake/toolchains/linux-x64-clang.cmake b/breeze/cmake/toolchains/linux-x64-clang.cmake
new file mode 100644
index 0000000..8848e96
--- /dev/null
+++ b/breeze/cmake/toolchains/linux-x64-clang.cmake
@@ -0,0 +1,16 @@
+# linux-x64-clang: Clang building for 64-bit x86 (x86_64) Linux.
+#
+#   On x64 hardware: a native build with the ordinary clang++.
+#   Any other Linux machine: a cross build with clang++ --target=x86_64-linux-gnu
+#                 (needs Clang plus the GCC cross package for the target's
+#                 libstdc++/libc, or -DCMAKE_SYSROOT=...; breeze/scripts/setup.sh
+#                 installs both on apt -- clang g++-x86-64-linux-gnu -- see
+#                 _common.cmake's own comment for other package managers).
+#                 If qemu-x86_64 is installed it is registered as the
+#                 emulator, so ctest can run the result.
+#
+# See _common.cmake (pmn_linux_toolchain) for the details and overrides.
+include("${CMAKE_CURRENT_LIST_DIR}/_common.cmake")
+
+pmn_toolchain_target("linux-x64-clang")
+pmn_linux_toolchain(x64 clang)
diff --git a/breeze/cmake/toolchains/linux-x64-gcc.cmake b/breeze/cmake/toolchains/linux-x64-gcc.cmake
new file mode 100644
index 0000000..bb1e227
--- /dev/null
+++ b/breeze/cmake/toolchains/linux-x64-gcc.cmake
@@ -0,0 +1,16 @@
+# linux-x64-gcc: GCC building for 64-bit x86 (x86_64) Linux.
+#
+#   On x64 hardware: a native build with the ordinary g++.
+#   Any other Linux machine: a cross build with x86_64-linux-gnu-g++.
+#                 breeze/scripts/setup.sh installs this for you on apt
+#                 (g++-x86-64-linux-gnu); not through dnf or pacman -- see
+#                 _common.cmake's own comment (and this is a rare case in
+#                 the first place: it only matters on a non-x64 Linux host).
+#                 If qemu-x86_64 is installed it is registered as the
+#                 emulator, so ctest can run the result.
+#
+# See _common.cmake (pmn_linux_toolchain) for the details and overrides.
+include("${CMAKE_CURRENT_LIST_DIR}/_common.cmake")
+
+pmn_toolchain_target("linux-x64-gcc")
+pmn_linux_toolchain(x64 gcc)
diff --git a/breeze/cmake/toolchains/macos-arm64-clang.cmake b/breeze/cmake/toolchains/macos-arm64-clang.cmake
new file mode 100644
index 0000000..82dad35
--- /dev/null
+++ b/breeze/cmake/toolchains/macos-arm64-clang.cmake
@@ -0,0 +1,16 @@
+# macos-arm64-clang: Clang building for Apple Silicon macOS.
+#
+# Apple Clang from the Xcode Command Line Tools (xcode-select --install),
+# or LLVM's own Clang if you point -DCMAKE_CXX_COMPILER at it.
+#
+# The architecture is pinned with CMAKE_OSX_ARCHITECTURES (arm64) rather
+# than left to whichever process launched the compiler, so this means
+# arm64 even when cmake itself is an x86_64 build running under Rosetta 2.
+# The minimum macOS is 11.0, the first release for Apple Silicon, unless
+# you pass -DCMAKE_OSX_DEPLOYMENT_TARGET=... yourself.
+#
+# See _common.cmake (pmn_macos_toolchain).
+include("${CMAKE_CURRENT_LIST_DIR}/_common.cmake")
+
+pmn_toolchain_target("macos-arm64-clang")
+pmn_macos_toolchain(arm64)
diff --git a/breeze/cmake/toolchains/macos-x64-clang.cmake b/breeze/cmake/toolchains/macos-x64-clang.cmake
new file mode 100644
index 0000000..f931024
--- /dev/null
+++ b/breeze/cmake/toolchains/macos-x64-clang.cmake
@@ -0,0 +1,16 @@
+# macos-x64-clang: Clang building for Intel macOS.
+#
+# Apple Clang from the Xcode Command Line Tools (xcode-select --install),
+# or LLVM's own Clang if you point -DCMAKE_CXX_COMPILER at it.
+#
+# The architecture is pinned with CMAKE_OSX_ARCHITECTURES (x86_64) rather
+# than left to whichever process launched the compiler, so this means x64
+# on an Apple Silicon Mac too -- where the result runs through Rosetta 2.
+# The minimum macOS is 11.0 unless you pass
+# -DCMAKE_OSX_DEPLOYMENT_TARGET=... yourself.
+#
+# See _common.cmake (pmn_macos_toolchain).
+include("${CMAKE_CURRENT_LIST_DIR}/_common.cmake")
+
+pmn_toolchain_target("macos-x64-clang")
+pmn_macos_toolchain(x64)
diff --git a/breeze/cmake/toolchains/windows-arm64-clang-cl.cmake b/breeze/cmake/toolchains/windows-arm64-clang-cl.cmake
new file mode 100644
index 0000000..2c8acfd
--- /dev/null
+++ b/breeze/cmake/toolchains/windows-arm64-clang-cl.cmake
@@ -0,0 +1,13 @@
+# windows-arm64-clang-cl: LLVM's clang-cl (the cl.exe-compatible driver)
+# building for ARM64 Windows with the MSVC ABI.
+#
+# The target is pinned to aarch64-pc-windows-msvc (--target=), so this means
+# ARM64 regardless of the machine's own architecture (an x64 machine
+# cross-compiles). The MSVC STL headers and Windows SDK libraries, including
+# their ARM64 variants, still come from a Visual Studio / Build Tools install.
+#
+# See _common.cmake (pmn_clang_cl_toolchain).
+include("${CMAKE_CURRENT_LIST_DIR}/_common.cmake")
+
+pmn_toolchain_target("windows-arm64-clang-cl")
+pmn_clang_cl_toolchain(arm64)
diff --git a/breeze/cmake/toolchains/windows-arm64-clang.cmake b/breeze/cmake/toolchains/windows-arm64-clang.cmake
new file mode 100644
index 0000000..dab3e51
--- /dev/null
+++ b/breeze/cmake/toolchains/windows-arm64-clang.cmake
@@ -0,0 +1,12 @@
+# windows-arm64-clang: Clang with its own GNU-style driver (clang++) building
+# for ARM64 Windows, as in an MSYS2 CLANGARM64 shell. Not clang-cl -- see
+# windows-arm64-clang-cl for that.
+#
+# Nothing is pinned: the CLANGARM64 environment is what makes clang++ target
+# ARM64 with the mingw ABI. TargetSelection.cmake checks that afterwards.
+#
+# See _common.cmake (pmn_msys_clang_toolchain).
+include("${CMAKE_CURRENT_LIST_DIR}/_common.cmake")
+
+pmn_toolchain_target("windows-arm64-clang")
+pmn_msys_clang_toolchain()
diff --git a/breeze/cmake/toolchains/windows-arm64-msvc.cmake b/breeze/cmake/toolchains/windows-arm64-msvc.cmake
new file mode 100644
index 0000000..4f57449
--- /dev/null
+++ b/breeze/cmake/toolchains/windows-arm64-msvc.cmake
@@ -0,0 +1,13 @@
+# windows-arm64-msvc: Microsoft's cl.exe building for ARM64 Windows.
+#
+# Run from an "ARM64 Native Tools Command Prompt for VS" (on an ARM64
+# machine) or an "x64_arm64 Cross Tools Command Prompt for VS" (on an x64
+# machine cross-building for ARM64). cl.exe cannot be pointed at an
+# architecture from here, the developer environment decides it.
+# TargetSelection.cmake verifies the cl.exe it got really targets ARM64.
+#
+# See _common.cmake (pmn_msvc_toolchain).
+include("${CMAKE_CURRENT_LIST_DIR}/_common.cmake")
+
+pmn_toolchain_target("windows-arm64-msvc")
+pmn_msvc_toolchain(arm64)
diff --git a/breeze/cmake/toolchains/windows-x64-clang-cl.cmake b/breeze/cmake/toolchains/windows-x64-clang-cl.cmake
new file mode 100644
index 0000000..94e8188
--- /dev/null
+++ b/breeze/cmake/toolchains/windows-x64-clang-cl.cmake
@@ -0,0 +1,12 @@
+# windows-x64-clang-cl: LLVM's clang-cl (the cl.exe-compatible driver)
+# building for x64 Windows with the MSVC ABI.
+#
+# The target is pinned to x86_64-pc-windows-msvc (--target=), so this means
+# x64 regardless of the machine's own architecture. The MSVC STL headers and
+# Windows SDK libraries still come from a Visual Studio / Build Tools install.
+#
+# See _common.cmake (pmn_clang_cl_toolchain).
+include("${CMAKE_CURRENT_LIST_DIR}/_common.cmake")
+
+pmn_toolchain_target("windows-x64-clang-cl")
+pmn_clang_cl_toolchain(x64)
diff --git a/breeze/cmake/toolchains/windows-x64-clang.cmake b/breeze/cmake/toolchains/windows-x64-clang.cmake
new file mode 100644
index 0000000..e89b22e
--- /dev/null
+++ b/breeze/cmake/toolchains/windows-x64-clang.cmake
@@ -0,0 +1,12 @@
+# windows-x64-clang: Clang with its own GNU-style driver (clang++) building
+# for x64 Windows, as in an MSYS2 CLANG64 shell. Not clang-cl -- see
+# windows-x64-clang-cl for that.
+#
+# Nothing is pinned: the CLANG64 environment is what makes clang++ target
+# x64 with the mingw ABI. TargetSelection.cmake checks that afterwards.
+#
+# See _common.cmake (pmn_msys_clang_toolchain).
+include("${CMAKE_CURRENT_LIST_DIR}/_common.cmake")
+
+pmn_toolchain_target("windows-x64-clang")
+pmn_msys_clang_toolchain()
diff --git a/breeze/cmake/toolchains/windows-x64-mingw64.cmake b/breeze/cmake/toolchains/windows-x64-mingw64.cmake
new file mode 100644
index 0000000..9b77a9d
--- /dev/null
+++ b/breeze/cmake/toolchains/windows-x64-mingw64.cmake
@@ -0,0 +1,15 @@
+# windows-x64-mingw64: MinGW-w64 GCC building for 64-bit Windows.
+#
+#   Windows host: x86_64-w64-mingw32-g++ from an MSYS2 MINGW64 shell (or any
+#                 MinGW-w64 on PATH).
+#   Linux host:   a cross build. breeze/scripts/setup.sh installs this for you on
+#                 apt (g++-mingw-w64-x86-64), dnf (mingw64-gcc-c++) or
+#                 pacman (mingw-w64-gcc, which also covers the 32-bit
+#                 preset below). If wine is installed it is registered as
+#                 the emulator, so ctest can run the result.
+#
+# See _common.cmake (pmn_mingw_toolchain) for the details and overrides.
+include("${CMAKE_CURRENT_LIST_DIR}/_common.cmake")
+
+pmn_toolchain_target("windows-x64-mingw64")
+pmn_mingw_toolchain(x64)
diff --git a/breeze/cmake/toolchains/windows-x64-msvc.cmake b/breeze/cmake/toolchains/windows-x64-msvc.cmake
new file mode 100644
index 0000000..f326cc3
--- /dev/null
+++ b/breeze/cmake/toolchains/windows-x64-msvc.cmake
@@ -0,0 +1,12 @@
+# windows-x64-msvc: Microsoft's cl.exe building for x64 Windows.
+#
+# Run from an "x64 Native Tools Command Prompt for VS" (or any shell where
+# vcvars64.bat has been run): cl.exe cannot be pointed at an architecture
+# from here, the developer environment decides it. TargetSelection.cmake
+# verifies the cl.exe it got really targets x64.
+#
+# See _common.cmake (pmn_msvc_toolchain).
+include("${CMAKE_CURRENT_LIST_DIR}/_common.cmake")
+
+pmn_toolchain_target("windows-x64-msvc")
+pmn_msvc_toolchain(x64)
diff --git a/breeze/cmake/toolchains/windows-x86-mingw32.cmake b/breeze/cmake/toolchains/windows-x86-mingw32.cmake
new file mode 100644
index 0000000..53315d6
--- /dev/null
+++ b/breeze/cmake/toolchains/windows-x86-mingw32.cmake
@@ -0,0 +1,15 @@
+# windows-x86-mingw32: MinGW-w64 GCC building for 32-bit Windows.
+#
+#   Windows host: i686-w64-mingw32-g++ from an MSYS2 MINGW32 shell (or any
+#                 MinGW-w64 on PATH).
+#   Linux host:   a cross build. breeze/scripts/setup.sh installs this for you on
+#                 apt (g++-mingw-w64-i686), dnf (mingw32-gcc-c++) or pacman
+#                 (mingw-w64-gcc, which also covers the 64-bit preset
+#                 above). If wine is installed it is registered as the
+#                 emulator, so ctest can run the result.
+#
+# See _common.cmake (pmn_mingw_toolchain) for the details and overrides.
+include("${CMAKE_CURRENT_LIST_DIR}/_common.cmake")
+
+pmn_toolchain_target("windows-x86-mingw32")
+pmn_mingw_toolchain(x86)
diff --git a/breeze/githooks/pre-commit b/breeze/githooks/pre-commit
new file mode 100644
index 0000000..b70bb76
--- /dev/null
+++ b/breeze/githooks/pre-commit
@@ -0,0 +1,129 @@
+#!/usr/bin/env bash
+#
+# breeze/githooks/pre-commit
+#
+# Runs clang-format and clang-tidy against staged C/C++ files before each
+# commit — no Python, no pre-commit framework, just bash and (optionally)
+# the clang tools themselves.
+#
+# Neither tool is required to have this hook installed: if a binary isn't
+# on PATH, this prints a warning and skips that check instead of blocking
+# the commit. Only *actual formatting/lint issues* from a tool that IS
+# installed will block a commit.
+#
+# Platforms:
+#   - Linux / macOS: runs under the system bash (or Homebrew bash on macOS)
+#     with no extra setup.
+#   - Windows: runs automatically through Git for Windows' bundled Git Bash —
+#     git.exe recognizes the "#!/usr/bin/env bash" line above and executes
+#     hooks through it directly, so no WSL, Cygwin, or separate bash install
+#     is needed. Everything this script uses (mktemp, diff, grep, printf,
+#     command -v) ships with Git for Windows out of the box.
+#
+# One-time setup per clone (same command on every OS):
+#   chmod +x breeze/githooks/pre-commit   (no-op on Windows, harmless either way)
+#   git config core.hooksPath breeze/githooks
+
+set -uo pipefail
+
+# Colors only when writing to an interactive terminal — avoids raw escape
+# codes in CI logs, redirected output, or terminals that don't support ANSI.
+if [ -t 1 ]; then
+    RED=$'\033[0;31m'
+    YELLOW=$'\033[0;33m'
+    GREEN=$'\033[0;32m'
+    RESET=$'\033[0m'
+else
+    RED=''
+    YELLOW=''
+    GREEN=''
+    RESET=''
+fi
+
+exit_code=0
+
+# --- Collect staged C/C++ files (added/copied/modified) ---
+# ':!vendor/*' excludes third-party code vendored under vendor/ (see
+# breeze/cmake/Dependencies.cmake in the parent project) -- it isn't this
+# project's code, so it isn't held to this style guide. Not part of the
+# toolkit as shipped; added for this project's vendor/ convention.
+files=()
+while IFS= read -r line; do
+    [ -n "$line" ] && files+=("$line")
+done < <(git diff --cached --name-only --diff-filter=ACM -- \
+    '*.c' '*.h' '*.cpp' '*.hpp' '*.cc' '*.cxx' '*.tpp' ':!vendor/*')
+
+if [ ${#files[@]} -eq 0 ]; then
+    exit 0
+fi
+
+# On macOS, Homebrew's llvm (the formula that ships clang-tidy) is keg-only:
+# installed but not on PATH. Look there too, AFTER the normal PATH so Apple's
+# tools stay first. (breeze/scripts/_common.sh's _pmn_extend_tool_path does the same
+# for the scripts; a git hook is kept standalone, so it's repeated here.)
+if [ "$(uname -s)" = Darwin ]; then
+    for _llvm_bin in /opt/homebrew/opt/llvm/bin /usr/local/opt/llvm/bin; do
+        if [ -d "$_llvm_bin" ]; then PATH="$PATH:$_llvm_bin"; break; fi
+    done
+fi
+
+# --- clang-format: check staged files are already formatted ---
+if command -v clang-format >/dev/null 2>&1; then
+    unformatted=()
+    for f in "${files[@]}"; do
+        [ -f "$f" ] || continue
+        if ! diff -q <(clang-format "$f") "$f" >/dev/null 2>&1; then
+            unformatted+=("$f")
+        fi
+    done
+
+    if [ ${#unformatted[@]} -gt 0 ]; then
+        echo "${RED}clang-format: these files aren't formatted:${RESET}"
+        printf '  %s\n' "${unformatted[@]}"
+        echo "Fix with: clang-format -i ${unformatted[*]}"
+        exit_code=1
+    fi
+else
+    echo "${YELLOW}warning: clang-format not found on PATH — skipping format check.${RESET}"
+fi
+
+# --- clang-tidy: static analysis, needs a compile database ---
+if command -v clang-tidy >/dev/null 2>&1; then
+    if [ ! -f compile_commands.json ]; then
+        echo "${YELLOW}warning: compile_commands.json not found — skipping clang-tidy.${RESET}"
+        echo "${YELLOW}Generate one with: cmake -DCMAKE_EXPORT_COMPILE_COMMANDS=ON ...${RESET}"
+    else
+        # A template, because BSD mktemp (macOS) wants one where GNU's doesn't.
+        tidy_output=$(mktemp "${TMPDIR:-/tmp}/pmn-clang-tidy.XXXXXX")
+        tidy_had_issues=0
+
+        for f in "${files[@]}"; do
+            [ -f "$f" ] || continue
+            if ! clang-tidy --quiet "$f" >>"$tidy_output" 2>&1; then
+                tidy_had_issues=1
+            fi
+        done
+
+        if grep -q "warning:\|error:" "$tidy_output" 2>/dev/null; then
+            echo "${RED}clang-tidy found issues:${RESET}"
+            cat "$tidy_output"
+            exit_code=1
+        elif [ "$tidy_had_issues" -eq 1 ]; then
+            # Non-zero exit with no warning/error text usually means clang-tidy
+            # itself couldn't run (e.g. missing headers) — surface it, but
+            # don't block the commit on a tooling problem rather than a style one.
+            echo "${YELLOW}warning: clang-tidy exited with an error unrelated to style:${RESET}"
+            cat "$tidy_output"
+        fi
+
+        rm -f "$tidy_output"
+    fi
+else
+    echo "${YELLOW}warning: clang-tidy not found on PATH — skipping static analysis.${RESET}"
+fi
+
+if [ $exit_code -eq 0 ]; then
+    echo "${GREEN}pre-commit checks passed.${RESET}"
+fi
+
+exit $exit_code
diff --git a/breeze/scripts/_common.sh b/breeze/scripts/_common.sh
new file mode 100644
index 0000000..5d66532
--- /dev/null
+++ b/breeze/scripts/_common.sh
@@ -0,0 +1,114 @@
+# Shared helpers for breeze/scripts/*.sh. Sourced, never run directly (hence the
+# leading underscore and no executable bit); every script sources it after
+# it has cd'd to the project root, because both helpers below run
+# `cmake -P breeze/cmake/<something>.cmake` relative to that.
+#
+# There is deliberately no Windows twin of this file: breeze/scripts/*.bat each keep
+# their own copy of these two small wrappers as labels (:read_config and
+# :resolve_build_dir), because sharing labels between .bat files is more
+# fragile than repeating them. What the wrappers *ask* is answered by the
+# same cmake scripts either way, so no logic is duplicated -- only the glue.
+
+# Reads one value out of project/Configuration.cmake -- this project's single
+# source of truth -- via breeze/cmake/PrintConfig.cmake, instead of hardcoding a
+# second copy of a default that can silently drift out of sync. See that
+# file for exactly what this strips off of its output.
+_pmn_read_config() {
+    cmake "-DPRINT_VARS=$1" -P breeze/cmake/PrintConfig.cmake | sed -E 's/^-- [^=]*=//'
+}
+
+# _pmn_resolve_build_dir [<name>]
+#
+# Prints the build directory to use. With a <name> (a preset, or "default")
+# that is simply BUILD_OUTPUT_DIR/<name>; without one it is discovered: the
+# directory breeze/scripts/build.sh built last, else the only one that exists. If
+# neither works, the reason goes to stderr and the return status is 1.
+#
+# The logic itself is breeze/cmake/BuildDir.cmake's -- see it for the details and
+# the one-line answer protocol parsed here.
+_pmn_resolve_build_dir() {
+    local answer
+    # run.sh never needed cmake before it had to ask which build directory to
+    # use, so say what's wrong instead of letting the shell's own "command not
+    # found" and an empty answer speak for it.
+    if ! command -v cmake >/dev/null 2>&1; then
+        echo "error: cmake not found on PATH -- it is needed to work out which build directory to use." >&2
+        echo "       Put it on PATH, or set BUILD_DIR to the directory explicitly, e.g. BUILD_DIR=out/build/<preset>." >&2
+        return 1
+    fi
+    answer="$(cmake "-DPMN_NAME=${1:-}" -P breeze/cmake/BuildDir.cmake | sed -E 's/^-- //')"
+    case "$answer" in
+        BUILD_DIR=*)
+            printf '%s\n' "${answer#BUILD_DIR=}"
+            ;;
+        ERROR=*)
+            echo "error: ${answer#ERROR=}" >&2
+            return 1
+            ;;
+        *)
+            echo "error: breeze/cmake/BuildDir.cmake did not answer as expected: ${answer}" >&2
+            return 1
+            ;;
+    esac
+}
+
+# _pmn_record_build_dir <name>
+#
+# Remembers <name> as the build directory built last, so the next
+# `breeze/scripts/run.sh` / `install.sh` / `docs.sh` without a --preset uses it.
+_pmn_record_build_dir() {
+    cmake "-DPMN_NAME=$1" -DPMN_RECORD=ON -P breeze/cmake/BuildDir.cmake >/dev/null
+}
+
+# _pmn_explain_configure_failure <configure-log> [<build-directory>]
+#
+# Called by breeze/scripts/build.sh after a failed configure. When it was a cross
+# build with no target sysroot (the toolchain says so in the first lines of
+# its output -- breeze/cmake/toolchains/_common.cmake, pmn_linux_toolchain) AND
+# something could not be found, says what that means: the dependency asked
+# for a system library (X11, OpenGL, ALSA, ...) that only a target sysroot
+# can provide. Silent in every other case -- not every "Could NOT find" is
+# this one, and the configure's own error is already on screen.
+_pmn_explain_configure_failure() {
+    [ -r "$1" ] || return 0
+    grep -q 'Cross build without a target sysroot' "$1" || return 0
+    grep -qE 'Could NOT find|Could not find|No package .* found' "$1" || return 0
+    cat >&2 <<'EOF'
+
+==> Configure failed in a cross build that has no target sysroot, and something
+    it needs was not found. That is most likely this: a cross build looks only
+    in the target's own root (the cross compiler's /usr/<triplet>), never at the
+    host's libraries -- those are for the wrong architecture -- and that root has
+    the C/C++ runtime and nothing else. A library such as X11, OpenGL or ALSA is
+    there only if you provide it:
+      * put a root filesystem for the target, with those libraries installed, in
+        .cache/sysroots/linux-<arch>  (arm64, arm32 or x64), or
+      * pass -DCMAKE_SYSROOT=<dir> to breeze/scripts/build.sh.
+    Then delete the build directory before building again: it keeps what it detected
+    about the compiler without the sysroot, and a configure over that stops.
+EOF
+    if [ -n "${2:-}" ]; then
+        echo "      rm -rf $2" >&2
+    fi
+    echo '    breeze/README.md, "Cross builds and system libraries", has the steps.' >&2
+}
+
+# On macOS, Homebrew's llvm formula -- the one that ships clang-tidy -- is
+# keg-only: installed, but deliberately not linked into PATH, so a script
+# looking for `clang-tidy` can't find it. Add its bin directory to the END of
+# PATH (never the front: Apple's clang must stay the one builds use). A
+# no-op everywhere else, and when llvm isn't installed.
+_pmn_extend_tool_path() {
+    [ "$(uname -s)" = Darwin ] || return 0
+    local d
+    for d in /opt/homebrew/opt/llvm/bin /usr/local/opt/llvm/bin; do
+        if [ -d "$d" ]; then
+            case ":$PATH:" in
+                *":$d:"*) ;;
+                *) PATH="$PATH:$d" ;;
+            esac
+            return 0
+        fi
+    done
+    return 0
+}
diff --git a/breeze/scripts/_tools.ps1 b/breeze/scripts/_tools.ps1
new file mode 100644
index 0000000..0ffeba1
--- /dev/null
+++ b/breeze/scripts/_tools.ps1
@@ -0,0 +1,697 @@
+<#
+.SYNOPSIS
+    Interactive installer for the tools this project builds with. Windows;
+    called by breeze\scripts\setup.bat (Linux and macOS have breeze/scripts/_tools.sh).
+
+.DESCRIPTION
+    Checks each tool, and for every one that is missing asks -- ONE TOOL AT
+    A TIME -- whether to install it, showing the exact command first. Nothing
+    is installed without an explicit yes (or -Yes / -All).
+
+      Required   Git, CMake 3.25+, and a C++ compiler: at least one of
+                 Visual Studio Build Tools (MSVC) or MinGW-w64 (via MSYS2)
+      Optional   LLVM (clang-cl, Clang, clang-format, clang-tidy), the MSVC
+                 ARM64 build tools (to build the windows-arm64-msvc and
+                 -clang-cl presets), and the other MSYS2 toolchains (32-bit
+                 MinGW, CLANG64)
+
+    Installs go through winget (Windows Package Manager, part of the App
+    Installer that ships with Windows 10 1809+ and Windows 11). Two things
+    winget does not do for you, and this script does:
+
+      * put CMake and LLVM on PATH -- their installers leave it to you, and
+        every guide that runs `winget install Kitware.CMake` ends with "now
+        add C:\Program Files\CMake\bin to PATH by hand". A tool found in its
+        usual folder but not on PATH is added to this session's PATH (which
+        is handed back to setup.bat through -PathOut so the rest of setup
+        can use it) and, if you agree, to your user PATH permanently.
+      * update a fresh MSYS2, whose package databases are stale (twice, as
+        MSYS2 itself recommends -- updating its runtime asks for a restart)
+        before installing MinGW-w64 into it.
+
+    Written for Windows PowerShell 5.1 as much as for PowerShell 7: no ??,
+    no ternary, no && / ||, nested Join-Path (5.1 has no -AdditionalChildPath),
+    and plain ASCII only (5.1 reads a BOM-less file as the ANSI code page).
+
+.PARAMETER Yes
+    Install the REQUIRED tools without asking. For scripts and CI. Without a
+    terminal and without this, nothing is asked and nothing is installed.
+
+.PARAMETER All
+    Also install the optional tools without asking (implies -Yes).
+
+.PARAMETER Check
+    Only report what is and is not installed; change nothing. Exits 1 if a
+    required tool is missing.
+
+.PARAMETER PathOut
+    File to write the directories that were added to this session's PATH to,
+    one per line, so the calling batch file can add them to its own.
+
+.NOTES
+    Exit status: 0 if every required tool is present at the end, 1 if not.
+#>
+[CmdletBinding()]
+param(
+    [switch]$Yes,
+    [switch]$All,
+    [switch]$Check,
+    [string]$PathOut = ''
+)
+
+if ($All) { $Yes = $true }
+
+# Oldest CMake this project supports (cmake_minimum_required in
+# CMakeLists.txt, breeze/cmake/Breeze.cmake, and the presets files' cmakeMinimumRequired).
+$script:MinCmake = New-Object System.Version 3, 25
+
+# The Visual Studio Build Tools package. 'Microsoft.VisualStudio.BuildTools'
+# (no year) is the newest release; the 2022 one is the long-established,
+# documented path, so it is the default -- change the id here to prefer
+# the newer one.
+$script:MsvcWingetId = 'Microsoft.VisualStudio.2022.BuildTools'
+$script:MsvcOverride = '--passive --wait --add Microsoft.VisualStudio.Workload.VCTools --includeRecommended'
+
+# Answers that carry over from one prompt to the next.
+$script:AnsAll = $false          # "a": yes to everything still to come
+$script:AnsSkipOptional = $false # "s": no to every OPTIONAL tool still to come
+$script:AnsQuit = $false         # "q": stop asking altogether
+
+# Directories added to this session's PATH, for setup.bat to pick up.
+$script:PathAdds = New-Object System.Collections.ArrayList
+
+# ---------------------------------------------------------------------------
+# Small helpers
+# ---------------------------------------------------------------------------
+
+function Say([string]$Text = '')  { Write-Host $Text }
+function Note([string]$Text)      { Write-Host $Text -ForegroundColor DarkGray }
+function Good([string]$Text)      { Write-Host $Text -ForegroundColor Green }
+function Warn([string]$Text)      { Write-Host $Text -ForegroundColor Yellow }
+function Bad([string]$Text)       { Write-Host $Text -ForegroundColor Red }
+
+# Nested Join-Path: Windows PowerShell 5.1's Join-Path takes only two parts.
+function Join-Parts {
+    $p = [string]$args[0]
+    for ($i = 1; $i -lt $args.Count; $i++) { $p = Join-Path $p ([string]$args[$i]) }
+    return $p
+}
+
+function Get-ProgramFiles   { return $env:ProgramFiles }
+function Get-ProgramFilesX86 { return ${env:ProgramFiles(x86)} }
+
+# MSYS2's install folder: C:\msys64 unless MSYS2_ROOT says otherwise.
+function Get-Msys2Root {
+    if ($env:MSYS2_ROOT) { return $env:MSYS2_ROOT }
+    $drive = $env:SystemDrive
+    if (-not $drive) { $drive = 'C:' }
+    return (Join-Path ($drive + '\') 'msys64')
+}
+
+# The first executable called $Name on PATH, or one in $FallbackDirs (the
+# folder the installer puts it in even when it doesn't touch PATH), or $null.
+function Find-Exe([string]$Name, [string[]]$FallbackDirs) {
+    $cmd = Get-Command $Name -ErrorAction SilentlyContinue | Select-Object -First 1
+    if ($cmd) { return $cmd.Source }
+    foreach ($dir in $FallbackDirs) {
+        if (-not $dir) { continue }
+        foreach ($ext in @('.exe', '')) {
+            $candidate = Join-Path $dir ($Name + $ext)
+            if (Test-Path -LiteralPath $candidate -PathType Leaf) { return $candidate }
+        }
+    }
+    return $null
+}
+
+function New-Status([string]$State, [string]$Detail = '') {
+    return [pscustomobject]@{ State = $State; Detail = $Detail }
+}
+
+# ---------------------------------------------------------------------------
+# PATH (session and user)
+#
+# Wrapped in functions so a test can replace the two that touch the real
+# registry.
+# ---------------------------------------------------------------------------
+
+function Get-UserPathValue          { return [Environment]::GetEnvironmentVariable('Path', 'User') }
+function Set-UserPathValue([string]$Value) { [Environment]::SetEnvironmentVariable('Path', $Value, 'User') }
+function Get-MachinePathValue       { return [Environment]::GetEnvironmentVariable('Path', 'Machine') }
+
+function Split-PathList([string]$List) {
+    if (-not $List) { return @() }
+    $sep = [System.IO.Path]::PathSeparator
+    $items = @()
+    foreach ($part in $List.Split($sep)) {
+        $trimmed = $part.Trim().TrimEnd('\', '/')
+        if ($trimmed) { $items += $trimmed }
+    }
+    return $items
+}
+
+function Test-InList([string]$List, [string]$Dir) {
+    $want = $Dir.TrimEnd('\', '/')
+    foreach ($item in (Split-PathList $List)) {
+        if ($item -ieq $want) { return $true }
+    }
+    return $false
+}
+
+function Test-OnSessionPath([string]$Dir) { return (Test-InList $env:Path $Dir) }
+
+function Test-OnPersistentPath([string]$Dir) {
+    return ((Test-InList (Get-UserPathValue) $Dir) -or (Test-InList (Get-MachinePathValue) $Dir))
+}
+
+function Add-ToSessionPath([string]$Dir) {
+    if (Test-OnSessionPath $Dir) { return }
+    $sep = [System.IO.Path]::PathSeparator
+    $current = $env:Path
+    if (-not $current) { $current = '' }
+    $env:Path = $current.TrimEnd($sep) + $sep + $Dir
+    [void]$script:PathAdds.Add($Dir)
+}
+
+function Add-ToUserPath([string]$Dir) {
+    $current = Get-UserPathValue
+    $sep = [System.IO.Path]::PathSeparator
+    if ($current) { $new = $current.TrimEnd($sep) + $sep + $Dir } else { $new = $Dir }
+    Set-UserPathValue $new
+}
+
+# ---------------------------------------------------------------------------
+# Detection
+# ---------------------------------------------------------------------------
+
+function Get-WingetStatus {
+    if (Get-Command winget -ErrorAction SilentlyContinue) { return (New-Status 'ok' 'winget') }
+    return (New-Status 'missing')
+}
+
+function Get-GitStatus {
+    $exe = Find-Exe 'git' @((Join-Parts (Get-ProgramFiles) 'Git' 'cmd'))
+    if (-not $exe) { return (New-Status 'missing') }
+    $ver = ''
+    try { $ver = (& $exe --version 2>$null | Select-Object -First 1) -replace '^git version ', '' } catch { }
+    return (New-Status 'ok' $ver)
+}
+
+function Get-CmakeStatus {
+    $exe = Find-Exe 'cmake' @((Join-Parts (Get-ProgramFiles) 'CMake' 'bin'))
+    if (-not $exe) { return (New-Status 'missing') }
+    $ver = ''
+    try {
+        $first = & $exe --version 2>$null | Select-Object -First 1
+        if ($first -match '(\d+\.\d+(\.\d+)?)') { $ver = $Matches[1] }
+    } catch { }
+    if (-not $ver) { return (New-Status 'ok' '') }
+    $parsed = $null
+    if ([System.Version]::TryParse($ver, [ref]$parsed) -and $parsed -lt $script:MinCmake) {
+        return (New-Status 'old' $ver)
+    }
+    return (New-Status 'ok' $ver)
+}
+
+# MSVC: the Visual Studio Installer ships vswhere.exe, which knows whether
+# the C++ x86/x64 tools are installed in ANY Visual Studio or Build Tools.
+function Get-MsvcStatus {
+    $pf86 = Get-ProgramFilesX86
+    if (-not $pf86) { return (New-Status 'missing') }
+    $vswhere = Join-Parts $pf86 'Microsoft Visual Studio' 'Installer' 'vswhere.exe'
+    if (-not (Test-Path -LiteralPath $vswhere -PathType Leaf)) { return (New-Status 'missing') }
+    $where = $null
+    try {
+        $where = & $vswhere -latest -products '*' -requires Microsoft.VisualStudio.Component.VC.Tools.x86.x64 -property installationPath 2>$null | Select-Object -First 1
+    } catch { }
+    if ($where) { return (New-Status 'ok' ([string]$where)) }
+    return (New-Status 'missing')
+}
+
+# The ARM64 half of the Visual Studio tools: what an x64 machine cross-compiles
+# the windows-arm64-* presets with (the x64-hosted ARM64 compiler and the ARM64
+# runtime libraries), and an ARM64 machine builds them natively with. vswhere
+# again, asking for both components: the x86/x64 one is what the ARM64 tools run
+# on from an x64 machine.
+function Get-MsvcArm64Status {
+    $pf86 = Get-ProgramFilesX86
+    if (-not $pf86) { return (New-Status 'missing') }
+    $vswhere = Join-Parts $pf86 'Microsoft Visual Studio' 'Installer' 'vswhere.exe'
+    if (-not (Test-Path -LiteralPath $vswhere -PathType Leaf)) { return (New-Status 'missing') }
+    $where = $null
+    try {
+        $where = & $vswhere -latest -products '*' -requires Microsoft.VisualStudio.Component.VC.Tools.x86.x64 Microsoft.VisualStudio.Component.VC.Tools.ARM64 -property installationPath 2>$null | Select-Object -First 1
+    } catch { }
+    if ($where) { return (New-Status 'ok' ([string]$where)) }
+    return (New-Status 'missing')
+}
+
+function Get-LlvmStatus {
+    $exe = Find-Exe 'clang-cl' @((Join-Parts (Get-ProgramFiles) 'LLVM' 'bin'))
+    if (-not $exe) { return (New-Status 'missing') }
+    return (New-Status 'ok' (Split-Path -Parent $exe))
+}
+
+function Get-Msys2Status {
+    $bash = Join-Parts (Get-Msys2Root) 'usr' 'bin' 'bash.exe'
+    if (Test-Path -LiteralPath $bash -PathType Leaf) { return (New-Status 'ok' (Get-Msys2Root)) }
+    return (New-Status 'missing')
+}
+
+function Get-MingwStatus([string]$Subdir) {
+    $gpp = Join-Parts (Get-Msys2Root) $Subdir 'bin' 'g++.exe'
+    if (Test-Path -LiteralPath $gpp -PathType Leaf) { return (New-Status 'ok' (Split-Path -Parent $gpp)) }
+    return (New-Status 'missing')
+}
+
+function Get-Clang64Status {
+    $clang = Join-Parts (Get-Msys2Root) 'clang64' 'bin' 'clang++.exe'
+    if (Test-Path -LiteralPath $clang -PathType Leaf) { return (New-Status 'ok' (Split-Path -Parent $clang)) }
+    return (New-Status 'missing')
+}
+
+# ---------------------------------------------------------------------------
+# Asking
+# ---------------------------------------------------------------------------
+
+function Test-CanAsk { return (-not [Console]::IsInputRedirected) }
+
+# One line from the user, or $null at end of input. A function of its own so
+# a test can stand in for the console.
+function Read-Answer { return [Console]::ReadLine() }
+
+# Would an OPTIONAL tool be offered (asked about, or installed by -All) now?
+function Test-OptionalWanted {
+    if ($script:AnsQuit -or $script:AnsSkipOptional) { return $false }
+    if ($All -or $script:AnsAll) { return $true }
+    return (Test-CanAsk)
+}
+
+# Returns $true for "install it". Sets $script:Ans* for answers that outlast
+# one prompt.
+function Confirm-Install([string]$Kind, [string]$Question) {
+    if ($script:AnsQuit) { return $false }
+    if ($script:AnsAll) { return $true }
+    if ($Kind -eq 'optional' -and $script:AnsSkipOptional) { return $false }
+
+    # Flags answer for you...
+    if ($Kind -eq 'required' -and $Yes) { return $true }
+    if ($All) { return $true }
+
+    # ...and with no terminal there is nobody to ask.
+    if (-not (Test-CanAsk)) {
+        Note '    (not asking: no terminal. Re-run interactively, or pass --yes / --all.)'
+        return $false
+    }
+
+    if ($Kind -eq 'required') { $prompt = "  $Question [Y/n/a/q] " } else { $prompt = "  $Question [y/N/a/s/q] " }
+    while ($true) {
+        Write-Host $prompt -NoNewline
+        $answer = Read-Answer
+        if ($null -eq $answer) {
+            # End of input (Ctrl-Z): stop asking rather than loop on it.
+            Write-Host ''
+            $script:AnsQuit = $true
+            return $false
+        }
+        switch ($answer.Trim().ToLowerInvariant()) {
+            { $_ -in @('y', 'yes') } { return $true }
+            { $_ -in @('n', 'no') }  { return $false }
+            ''                       { return ($Kind -eq 'required') }
+            { $_ -in @('a', 'all') } { $script:AnsAll = $true; return $true }
+            { $_ -in @('s', 'skip') } { $script:AnsSkipOptional = $true; return $false }
+            { $_ -in @('q', 'quit') } { $script:AnsQuit = $true; return $false }
+            default {
+                if ($Kind -eq 'required') {
+                    Note '    y = install   n = not this one   a = install everything left   q = stop asking'
+                } else {
+                    Note '    y = install   n = not this one   a = install everything left   s = skip the rest of the optional tools   q = stop asking'
+                }
+            }
+        }
+    }
+}
+
+# ---------------------------------------------------------------------------
+# Installing
+# ---------------------------------------------------------------------------
+
+function Invoke-Winget([string]$Id, [string]$Override = '') {
+    $winget = @('install', '--id', $Id, '-e', '--source', 'winget',
+                '--accept-package-agreements', '--accept-source-agreements')
+    $shown = 'winget ' + ($winget -join ' ')
+    if ($Override) {
+        $winget += @('--override', $Override)
+        $shown += ' --override "' + $Override + '"'
+    }
+    Write-Host ('    $ ' + $shown) -ForegroundColor DarkGray
+    & winget @winget
+    return ($LASTEXITCODE -eq 0)
+}
+
+# Adds a component to the Visual Studio (or Build Tools) install Get-MsvcStatus
+# found, with the Visual Studio Installer's own `modify` command: the documented
+# way to add a component to an existing install. It needs administrator rights,
+# so the installer is started elevated (the usual UAC prompt) and waited for.
+# Exit code 3010 means "done, restart needed", which is still a success.
+function Install-MsvcComponent([string]$ComponentId) {
+    $pf86 = Get-ProgramFilesX86
+    if (-not $pf86) { return $false }
+    $setup = Join-Parts $pf86 'Microsoft Visual Studio' 'Installer' 'setup.exe'
+    $vswhere = Join-Parts $pf86 'Microsoft Visual Studio' 'Installer' 'vswhere.exe'
+    if (-not ((Test-Path -LiteralPath $setup -PathType Leaf) -and (Test-Path -LiteralPath $vswhere -PathType Leaf))) {
+        Bad '    The Visual Studio Installer was not found.'
+        return $false
+    }
+    $installPath = $null
+    try {
+        $installPath = & $vswhere -latest -products '*' -requires Microsoft.VisualStudio.Component.VC.Tools.x86.x64 -property installationPath 2>$null | Select-Object -First 1
+    } catch { }
+    if (-not $installPath) {
+        Bad '    No Visual Studio install with the C++ tools was found to add it to.'
+        return $false
+    }
+    $installerArgs = @('modify', '--installPath', ('"' + $installPath + '"'), '--add', $ComponentId, '--passive', '--norestart')
+    Write-Host ('    $ "' + $setup + '" ' + ($installerArgs -join ' ')) -ForegroundColor DarkGray
+    try {
+        $proc = Start-Process -FilePath $setup -ArgumentList $installerArgs -Verb RunAs -Wait -PassThru
+    } catch {
+        Bad ('    Could not start the Visual Studio Installer: ' + $_.Exception.Message)
+        return $false
+    }
+    return (($proc.ExitCode -eq 0) -or ($proc.ExitCode -eq 3010))
+}
+
+# Whether Update-Msys2Base has already run (successfully or not) in this
+# process, so installing several MSYS2-hosted toolchains in one setup.bat
+# run (e.g. -All pulling in mingw64, mingw32 AND clang64) only pays for the
+# update dance -- the slow, disruptive part -- once, not once per package.
+$script:Msys2BaseUpdated = $false
+
+# Brings the MSYS2 installation's OWN packages (msys2-runtime, bash, pacman,
+# filesystem, ...) up to date, which a fresh install -- what a winget install
+# just produced -- badly needs: its package databases are whatever shipped
+# in that installer image.
+#
+# This is exactly the three-step sequence msys2/setup-msys2 -- the official
+# GitHub Action, and about as battle-tested a reference as this gets --
+# uses, confirmed by reading its source (main.js): an update whose result is
+# NOT trusted, an explicit taskkill, then a second, final update whose
+# result IS. It exists because updating msys2-runtime/bash/pacman while
+# they are the very things running the update can end with MSYS2 force-
+# closing every one of its own processes for safety (mid-transaction, to
+# avoid the heap corruption a live-running old copy of msys2-runtime would
+# otherwise risk) rather than the update finishing normally -- documented
+# behavior (msys2.org/docs/updating), not a bug in this project, and not
+# something --noconfirm reliably suppresses in every MSYS2-pacman version
+# (see msys2/MSYS2-packages#1141, "Updating MSYS2 unattended is broken").
+# Running the update a second time is what actually finishes the job (per
+# that same documentation: "you need to start a new terminal and run the
+# update again"); the taskkill in between is what makes that safe to do
+# from the SAME script, back-to-back, without a real terminal to close --
+# and it must run from OUTSIDE the MSYS2 process tree to have any effect,
+# i.e. from PowerShell, exactly as done here (see the discussion on
+# msys2/MSYS2-packages#4340, where MSYS2's own maintainers say so).
+# `-FI "MODULES eq msys-2.0.dll"` targets any process with that DLL loaded,
+# not any process literally named bash.exe/pacman.exe -- so it cannot catch
+# an unrelated bash.exe (WSL's, Git for Windows', a plain MSYS bash someone
+# else is using) that never loaded MSYS2's runtime in the first place.
+# `--overwrite '*'` on every pacman call, also lifted from that same
+# reference implementation, avoids pacman refusing an update over an
+# unimportant file conflict -- a real, if uncommon, way this could
+# otherwise still stall unattended.
+function Update-Msys2Base {
+    if ($script:Msys2BaseUpdated) { return $true }
+    $bash = Join-Parts (Get-Msys2Root) 'usr' 'bin' 'bash.exe'
+    if (-not (Test-Path -LiteralPath $bash -PathType Leaf)) {
+        Bad '    MSYS2 is not installed at the expected place -- install it first.'
+        return $false
+    }
+    Write-Host '    $ bash -lc "pacman --noconfirm --overwrite ''*'' -Syuu"   (updates MSYS2 itself; may need to close and reopen)' -ForegroundColor DarkGray
+    & $bash -lc "pacman --noconfirm --overwrite '*' -Syuu"
+    Write-Host '    $ taskkill /F /FI "MODULES eq msys-2.0.dll"   (clears any MSYS2 process the update above force-closed)' -ForegroundColor DarkGray
+    & taskkill /F /FI 'MODULES eq msys-2.0.dll' 2>$null | Out-Null
+    Write-Host '    $ bash -lc "pacman --noconfirm --overwrite ''*'' -Syuu"   (final update)' -ForegroundColor DarkGray
+    & $bash -lc "pacman --noconfirm --overwrite '*' -Syuu"
+    $script:Msys2BaseUpdated = $true
+    return ($LASTEXITCODE -eq 0)
+}
+
+function Invoke-Msys2Packages([string[]]$Packages) {
+    $bash = Join-Parts (Get-Msys2Root) 'usr' 'bin' 'bash.exe'
+    if (-not (Test-Path -LiteralPath $bash -PathType Leaf)) {
+        Bad '    MSYS2 is not installed at the expected place -- install it first.'
+        return $false
+    }
+    if (-not (Update-Msys2Base)) {
+        Bad '    Updating MSYS2 itself failed -- see the output above. Try re-running breeze\scripts\setup.bat once MSYS2 has settled (it may need a moment after force-closing its own processes), or update it by hand in an MSYS2 terminal: pacman -Syuu (repeat until it reports nothing to do).'
+        return $false
+    }
+    $list = $Packages -join ' '
+    Write-Host ('    $ ' + $bash + ' -lc "pacman -S --needed --noconfirm --overwrite ''*'' ' + $list + '"') -ForegroundColor DarkGray
+    & $bash -lc ("pacman -S --needed --noconfirm --overwrite '*' " + $list)
+    return ($LASTEXITCODE -eq 0)
+}
+
+# ---------------------------------------------------------------------------
+# The catalog
+#
+# Ordered as they are asked. Each row: a stable Id, whether it is Required or
+# optional (msvc is decided at run time -- see below), a label, why it
+# matters, how to tell if it is there, how to install it, and the folder
+# that has to be on PATH for it to be usable (or $null).
+# ---------------------------------------------------------------------------
+
+function Get-Catalog {
+    $pf = Get-ProgramFiles
+    $msys = Get-Msys2Root
+    return @(
+        @{ Id = 'git';   Kind = 'required'; Label = 'Git';
+           Why = 'FetchContent clones dependencies (fmt) with it';
+           Status = { Get-GitStatus }; Install = { Invoke-Winget 'Git.Git' };
+           PathDir = (Join-Parts $pf 'Git' 'cmd'); PathDefault = $true },
+
+        @{ Id = 'cmake'; Kind = 'required'; Label = 'CMake 3.25 or newer';
+           Why = 'configures and drives every build';
+           Status = { Get-CmakeStatus }; Install = { Invoke-Winget 'Kitware.CMake' };
+           PathDir = (Join-Parts $pf 'CMake' 'bin'); PathDefault = $true },
+
+        # A compiler: at least one of MSVC or MinGW-w64 is required. Which
+        # kind msvc is depends on whether one is already there (see Main).
+        @{ Id = 'msvc';  Kind = 'compiler'; Label = 'Visual Studio Build Tools (MSVC)';
+           Why = 'the windows-*-msvc presets, and the headers/libraries the windows-*-clang-cl ones need';
+           Status = { Get-MsvcStatus };
+           Install = { Invoke-Winget $script:MsvcWingetId $script:MsvcOverride };
+           PathDir = $null },
+
+        # Needs msvc: it adds a component to that install. Without it an x64
+        # machine cannot build the windows-arm64-msvc and -clang-cl presets, which
+        # cross-compile through it.
+        @{ Id = 'msvc-arm64'; Kind = 'optional'; Label = 'MSVC ARM64 build tools';
+           Why = 'the windows-arm64-msvc and windows-arm64-clang-cl presets (a cross build from an x64 machine)';
+           Needs = 'msvc';
+           Status = { Get-MsvcArm64Status };
+           Install = { Install-MsvcComponent 'Microsoft.VisualStudio.Component.VC.Tools.ARM64' };
+           PathDir = $null },
+
+        @{ Id = 'llvm';  Kind = 'optional'; Label = 'LLVM (clang-cl, Clang, clang-format, clang-tidy)';
+           Why = 'the windows-*-clang-cl presets, breeze\scripts\refactor.bat and the pre-commit hook';
+           Status = { Get-LlvmStatus }; Install = { Invoke-Winget 'LLVM.LLVM' };
+           PathDir = (Join-Parts $pf 'LLVM' 'bin'); PathDefault = $true },
+
+        @{ Id = 'msys2'; Kind = 'optional'; Label = 'MSYS2';
+           Why = 'the home of MinGW-w64 on Windows (needed for the windows-*-mingw* presets)';
+           Status = { Get-Msys2Status }; Install = { Invoke-Winget 'MSYS2.MSYS2' };
+           PathDir = $null },
+
+        @{ Id = 'mingw64'; Kind = 'optional'; Label = 'MinGW-w64 GCC, 64-bit';
+           Why = 'the windows-x64-mingw64 preset'; Needs = 'msys2';
+           Status = { Get-MingwStatus 'mingw64' };
+           Install = { Invoke-Msys2Packages @('mingw-w64-x86_64-gcc') };
+           PathDir = (Join-Parts $msys 'mingw64' 'bin'); PathDefault = $false },
+
+        @{ Id = 'mingw32'; Kind = 'optional'; Label = 'MinGW-w64 GCC, 32-bit';
+           Why = 'the windows-x86-mingw32 preset'; Needs = 'msys2';
+           Status = { Get-MingwStatus 'mingw32' };
+           Install = { Invoke-Msys2Packages @('mingw-w64-i686-gcc') };
+           PathDir = (Join-Parts $msys 'mingw32' 'bin'); PathDefault = $false },
+
+        @{ Id = 'clang64'; Kind = 'optional'; Label = 'MSYS2 CLANG64 (GNU-style Clang)';
+           Why = 'the windows-x64-clang preset'; Needs = 'msys2';
+           Status = { Get-Clang64Status };
+           Install = { Invoke-Msys2Packages @('mingw-w64-clang-x86_64-clang') };
+           PathDir = (Join-Parts $msys 'clang64' 'bin'); PathDefault = $false }
+    )
+}
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+function Show-ManualHelp {
+    Say '    Install these yourself instead:'
+    Say '      Git         https://git-scm.com/download/win'
+    Say '      CMake       https://cmake.org/download/   (tick "Add CMake to the system PATH")'
+    Say '      MSVC        https://visualstudio.microsoft.com/visual-cpp-build-tools/   (workload: Desktop development with C++)'
+    Say '      LLVM        https://github.com/llvm/llvm-project/releases'
+    Say '      MSYS2       https://www.msys2.org/'
+}
+
+function Invoke-Main {
+    $catalog = Get-Catalog
+    $wingetStatus = Get-WingetStatus
+    $haveWinget = ($wingetStatus.State -eq 'ok')
+
+    Say ('==> Checking the tools this project builds with (Windows, winget: ' + $(if ($haveWinget) { 'found' } else { 'NOT found' }) + ')')
+
+    # ---- report ---------------------------------------------------------
+    $status = @{}
+    foreach ($row in $catalog) { $status[$row.Id] = (& $row.Status) }
+
+    $haveCompiler = ($status['msvc'].State -eq 'ok') -or ($status['mingw64'].State -eq 'ok') -or ($status['mingw32'].State -eq 'ok')
+    foreach ($row in $catalog) {
+        $st = $status[$row.Id]
+        $kind = $row.Kind
+        if ($kind -eq 'compiler') { if ($haveCompiler) { $kind = 'optional' } else { $kind = 'required' } }
+        $row.EffKind = $kind
+        switch ($st.State) {
+            'ok' {
+                if ($st.Detail) { Write-Host ('    [ ok ]  ' + $row.Label.PadRight(50) + ' ') -NoNewline -ForegroundColor Green; Note $st.Detail }
+                else { Good ('    [ ok ]  ' + $row.Label) }
+            }
+            'old' { Warn ('    [old ]  ' + $row.Label.PadRight(50) + ' ' + $st.Detail + ' (needs ' + $script:MinCmake.ToString() + '+)') }
+            default {
+                if ($kind -eq 'required') { Bad ('    [ !! ]  ' + $row.Label.PadRight(50) + ' missing (required)') }
+                else { Note ('    [ -- ]  ' + $row.Label.PadRight(50) + ' missing (optional)') }
+            }
+        }
+    }
+    if (-not $haveCompiler) {
+        Warn '    A C++ compiler is required: Visual Studio Build Tools, or MinGW-w64 through MSYS2 (either one).'
+    }
+
+    # ---- -Check: report only --------------------------------------------
+    if ($Check) {
+        $missing = ($status['git'].State -ne 'ok') -or ($status['cmake'].State -ne 'ok') -or (-not $haveCompiler)
+        if ($missing) { return 1 }
+        return 0
+    }
+
+    $anythingToInstall = $false
+    foreach ($row in $catalog) { if ($status[$row.Id].State -ne 'ok') { $anythingToInstall = $true } }
+    if ($anythingToInstall -and -not $haveWinget) {
+        Say ''
+        Warn '    winget (Windows Package Manager) was not found, so this script cannot install anything.'
+        Say '    It comes with the App Installer: https://aka.ms/getwinget (or the Microsoft Store).'
+        Show-ManualHelp
+    }
+
+    # ---- offer installs, one at a time ----------------------------------
+    $skipped = @()
+    $failed = @()
+    foreach ($row in $catalog) {
+        if ($script:AnsQuit) { break }
+        $st = & $row.Status          # re-check: an earlier install may have provided it
+        if ($st.State -eq 'ok') { continue }
+        if (-not $haveWinget) { continue }
+
+        # MinGW rows live inside MSYS2.
+        if ($row.Needs) {
+            $needRow = $catalog | Where-Object { $_.Id -eq $row.Needs } | Select-Object -First 1
+            $needed = & $needRow.Status
+            if ($needed.State -ne 'ok') { continue }
+        }
+
+        # After the msvc row, "a compiler exists" may have changed the kind
+        # of the rows still to come.
+        $kind = $row.EffKind
+        if ($kind -eq 'required' -and $row.Id -eq 'msvc') {
+            $now = ((Get-MingwStatus 'mingw64').State -eq 'ok') -or ((Get-MingwStatus 'mingw32').State -eq 'ok')
+            if ($now) { $kind = 'optional' }
+        }
+
+        if ($kind -eq 'optional' -and -not (Test-OptionalWanted)) {
+            $skipped += $row.Label
+            continue
+        }
+
+        Say ''
+        Write-Host ('  ' + $row.Label) -NoNewline -ForegroundColor White
+        Say (' -- ' + $row.Why)
+        if ($st.State -eq 'old') { Note ('    (installed: ' + $st.Detail + ', but too old)') }
+
+        if (Confirm-Install $kind ('Install ' + $row.Label + '?')) {
+            $ok = & $row.Install
+            $after = & $row.Status
+            if ($after.State -eq 'ok') {
+                Good '    installed'
+            } elseif ($after.State -eq 'old') {
+                Warn ('    CMake ' + $after.Detail + ' is older than the ' + $script:MinCmake.ToString() + ' this project needs.')
+                $failed += $row.Label
+            } elseif (-not $ok) {
+                Bad '    install failed -- see the output above.'
+                $failed += $row.Label
+            } else {
+                Warn ('    the install finished, but ' + $row.Label + ' still is not found -- open a new terminal, or check the output above.')
+                $failed += $row.Label
+            }
+        } elseif ($kind -eq 'optional') {
+            $skipped += $row.Label
+        }
+    }
+    if ($skipped.Count -gt 0) {
+        Say ''
+        Note ('  Optional, not installed: ' + ($skipped -join ', '))
+        Note '  (breeze\scripts\setup.bat, run interactively, offers each one; --all installs them all.)'
+    }
+
+    # ---- PATH ------------------------------------------------------------
+    # A tool that is installed but whose folder is not on PATH is unusable
+    # from a plain terminal -- and, for CMake, from the rest of setup.bat.
+    foreach ($row in $catalog) {
+        if (-not $row.PathDir) { continue }
+        $st = & $row.Status
+        if ($st.State -ne 'ok') { continue }
+        if (-not (Test-Path -LiteralPath $row.PathDir -PathType Container)) { continue }
+        if (Test-OnSessionPath $row.PathDir) { continue }
+
+        # This session, always: what follows in setup needs it.
+        Add-ToSessionPath $row.PathDir
+        if (Test-OnPersistentPath $row.PathDir) { continue }
+
+        Say ''
+        Say ('  ' + $row.Label + ' is installed, but its folder is not on your PATH:')
+        Say ('    ' + $row.PathDir)
+        if ($row.PathDefault) { $kind = 'required' } else { $kind = 'optional' }
+        if (-not $row.PathDefault) {
+            Note '    (breeze\scripts\build.bat does not need this: it puts the right MSYS2 toolchain folder first on PATH'
+            Note '     for the preset it builds, for that run only. Adding the folder here puts its g++/gcc on PATH for every program.)'
+        }
+        if (Confirm-Install $kind 'Add it to your user PATH (new terminals will see it)?') {
+            Add-ToUserPath $row.PathDir
+            Good '    added -- open a new terminal to use it there.'
+        }
+    }
+
+    # ---- hand this session's PATH additions back to setup.bat ------------
+    if ($PathOut -and $script:PathAdds.Count -gt 0) {
+        Set-Content -LiteralPath $PathOut -Value ($script:PathAdds.ToArray()) -Encoding ASCII
+    }
+
+    # ---- verdict ---------------------------------------------------------
+    $exit = 0
+    $needGit = (Get-GitStatus).State -ne 'ok'
+    $needCmake = (Get-CmakeStatus).State -ne 'ok'
+    $needCompiler = -not (((Get-MsvcStatus).State -eq 'ok') -or ((Get-MingwStatus 'mingw64').State -eq 'ok') -or ((Get-MingwStatus 'mingw32').State -eq 'ok'))
+    if ($needGit)      { Bad '  still missing (required): Git'; $exit = 1 }
+    if ($needCmake)    { Bad '  still missing (required): CMake 3.25 or newer'; $exit = 1 }
+    if ($needCompiler) { Bad '  still missing (required): a C++ compiler (Visual Studio Build Tools, or MinGW-w64 via MSYS2)'; $exit = 1 }
+    if ($failed.Count -gt 0 -and $exit -eq 0) { Warn ('  These did not install: ' + ($failed -join ', ')) }
+    return $exit
+}
+
+# Run only when executed, not when dot-sourced (a test dot-sources this file
+# to replace the functions that touch the registry).
+if ($MyInvocation.InvocationName -ne '.') {
+    $code = Invoke-Main
+    exit $code
+}
diff --git a/breeze/scripts/_tools.sh b/breeze/scripts/_tools.sh
new file mode 100644
index 0000000..6e1d2f0
--- /dev/null
+++ b/breeze/scripts/_tools.sh
@@ -0,0 +1,1240 @@
+# Interactive installer for the tools this project builds with. Sourced by
+# breeze/scripts/setup.sh (Linux and macOS -- Windows has breeze/scripts/_tools.ps1); never
+# run directly, hence the leading underscore and no executable bit.
+#
+# What it does: works out what OS and package manager it's on, checks each
+# tool in a catalog, and for every one that's missing asks -- ONE TOOL AT A
+# TIME -- whether to install it, showing the exact command first. Nothing is
+# installed without an explicit yes (or --yes / --all, see below).
+#
+# Written for bash 3.2, which is what macOS ships as /bin/bash: no
+# associative arrays, no mapfile, no ${var,,}, and every array that can be
+# empty is expanded with the ${arr[@]+"${arr[@]}"} idiom.
+#
+# Package managers: apt (Debian/Ubuntu), dnf (Fedora/RHEL), pacman (Arch) on
+# Linux; Homebrew on macOS. Anything else is told what the tools are and
+# left to install them itself. MinGW and the emulators (qemu-user, wine) are
+# offered on all three Linux package managers; the Linux-target cross
+# compilers (xc-arm64, xc-arm32, xc-x64) are offered wherever a package is
+# actually known to produce a working one for THIS project (a real libstdc++
+# for the target, laid out under /usr/<triplet> the way breeze/cmake/toolchains/
+# expects) -- apt and pacman ship one of their own for some architectures;
+# where neither does, dnf's own cross-gcc ships without libstdc++ at all (see
+# _pmn_arch_extra_notes), so the working toolchain there comes from a
+# community COPR repository instead, offered with its own explicit consent
+# separate from the "install this tool?" question (see
+# _pmn_dnf_enable_copr), the same way pacman's wine asks separately before
+# enabling the multilib repository it needs. Offering a package that would
+# then not work is worse than not offering it, so anywhere none of this
+# applies, the gap is explained in place (_pmn_arch_extra_notes) rather than
+# silently missing.
+#
+# Entry point: _pmn_tools_run
+#   Environment in (set by setup.sh from its flags):
+#     PMN_TOOLS_YES=1    install REQUIRED tools without asking
+#     PMN_TOOLS_ALL=1    also install OPTIONAL tools without asking
+#     PMN_TOOLS_HEAVY=1  on top of ALL: also do the third-party extras that are
+#                        otherwise never done without a y typed at their own
+#                        question (--all and an earlier "a" don't count) --
+#                        today, on Arch, installing the prebuilt 32-bit ARM
+#                        cross toolchain from the AUR (see _pmn_offer_aur_arm32).
+#                        setup.sh --everything sets this (and ALL, and YES).
+#     PMN_TOOLS_CHECK=1  only report; change nothing
+#   Returns 0 if every required tool is present at the end, 1 if not.
+#
+# Without a terminal on stdin and without --yes/--all it does not prompt (a
+# CI job must never hang on a question nobody can answer): it reports and
+# leaves everything alone.
+
+# Oldest CMake this project supports (cmake_minimum_required in
+# CMakeLists.txt, breeze/cmake/Breeze.cmake, and the presets files' cmakeMinimumRequired).
+PMN_CMAKE_MIN_MAJOR=3
+PMN_CMAKE_MIN_MINOR=25
+
+PMN_TOOLS_YES="${PMN_TOOLS_YES:-0}"
+PMN_TOOLS_ALL="${PMN_TOOLS_ALL:-0}"
+PMN_TOOLS_HEAVY="${PMN_TOOLS_HEAVY:-0}"
+PMN_TOOLS_CHECK="${PMN_TOOLS_CHECK:-0}"
+
+# Answers that carry over from one prompt to the next.
+_PMN_ANS_ALL=0        # "a": yes to everything still to come
+_PMN_ANS_SKIP_OPT=0   # "s": no to every OPTIONAL tool still to come
+_PMN_ANS_QUIT=0       # "q": stop asking altogether
+_PMN_APT_UPDATED=0    # apt-get update runs once, before the first apt install
+
+if [ -t 1 ]; then
+    _PMN_BOLD=$'\033[1m'; _PMN_DIM=$'\033[2m'; _PMN_GREEN=$'\033[32m'
+    _PMN_YELLOW=$'\033[33m'; _PMN_RED=$'\033[31m'; _PMN_RESET=$'\033[0m'
+else
+    _PMN_BOLD=''; _PMN_DIM=''; _PMN_GREEN=''; _PMN_YELLOW=''; _PMN_RED=''; _PMN_RESET=''
+fi
+
+# ---------------------------------------------------------------------------
+# Detection
+# ---------------------------------------------------------------------------
+
+_pmn_have() { command -v "$1" >/dev/null 2>&1; }
+
+# The two directories Homebrew's llvm formula is keg-only in (Apple Silicon,
+# Intel). Keg-only: installed, but deliberately not linked into PATH, which
+# is where clang-tidy comes from.
+_pmn_brew_llvm_bin() {
+    local d
+    for d in /opt/homebrew/opt/llvm/bin /usr/local/opt/llvm/bin; do
+        if [ -d "$d" ]; then printf '%s\n' "$d"; return 0; fi
+    done
+    return 1
+}
+
+# Sets PMN_OS (linux|macos|other), PMN_ARCH (x64|arm64|arm32|""), PMN_PM
+# (apt|dnf|pacman|brew|none) and PMN_SUDO ("" or "sudo").
+_pmn_tools_detect() {
+    local machine
+    case "$(uname -s)" in
+        Linux)  PMN_OS=linux ;;
+        Darwin) PMN_OS=macos ;;
+        *)      PMN_OS=other ;;
+    esac
+
+    machine="$(uname -m)"
+    # An x86_64 shell under Rosetta 2 on an Apple Silicon Mac still reports
+    # x86_64 -- ask about the machine (see breeze/cmake/HostArch.cmake).
+    if [ "$PMN_OS" = macos ] && [ "$machine" = x86_64 ] \
+        && [ "$(sysctl -in hw.optional.arm64 2>/dev/null || true)" = 1 ]; then
+        machine=arm64
+    fi
+    case "$machine" in
+        x86_64|amd64)      PMN_ARCH=x64 ;;
+        aarch64|arm64)     PMN_ARCH=arm64 ;;
+        arm*)              PMN_ARCH=arm32 ;;
+        *)                 PMN_ARCH="" ;;
+    esac
+
+    PMN_PM=none
+    if [ "$PMN_OS" = macos ]; then
+        # Homebrew is often installed but not on PATH in a fresh shell.
+        if ! _pmn_have brew; then
+            local b
+            for b in /opt/homebrew/bin/brew /usr/local/bin/brew; do
+                if [ -x "$b" ]; then eval "$("$b" shellenv)"; break; fi
+            done
+        fi
+        if _pmn_have brew; then PMN_PM=brew; fi
+    elif [ "$PMN_OS" = linux ]; then
+        if   _pmn_have apt-get; then PMN_PM=apt
+        elif _pmn_have dnf;     then PMN_PM=dnf
+        elif _pmn_have pacman;  then PMN_PM=pacman
+        fi
+    fi
+
+    # Root is only a question for Linux's system package managers. Homebrew
+    # refuses to run as root and never needs it -- and decided HERE, before
+    # a fresh Homebrew exists, this would otherwise be computed against
+    # PMN_PM=none.
+    PMN_SUDO=""
+    if [ "$PMN_OS" = linux ] && [ "$(id -u)" != 0 ]; then
+        if _pmn_have sudo; then PMN_SUDO=sudo; else PMN_SUDO="?"; fi
+    fi
+}
+
+# "3.28.3" for the installed cmake, or "" if there isn't one.
+_pmn_cmake_version() {
+    _pmn_have cmake || return 0
+    cmake --version 2>/dev/null | sed -n '1s/^[^0-9]*\([0-9][0-9.]*\).*/\1/p'
+}
+
+# 0 if the installed cmake is at least the minimum.
+_pmn_cmake_new_enough() {
+    local v major minor
+    v="$(_pmn_cmake_version)"
+    [ -n "$v" ] || return 1
+    major="${v%%.*}"; minor="${v#*.}"; minor="${minor%%.*}"
+    if [ "$major" -gt "$PMN_CMAKE_MIN_MAJOR" ]; then return 0; fi
+    [ "$major" -eq "$PMN_CMAKE_MIN_MAJOR" ] && [ "$minor" -ge "$PMN_CMAKE_MIN_MINOR" ]
+}
+
+# macOS: /usr/bin/git, /usr/bin/clang and friends exist on every Mac as
+# stubs that pop up an installer dialog when run without the Command Line
+# Tools -- `command -v` finds them regardless. The developer directory is
+# what says whether real tools sit behind them.
+_pmn_clt_installed() {
+    local dir
+    dir="$(xcode-select -p 2>/dev/null)" || return 1
+    [ -x "$dir/usr/bin/clang" ]
+}
+
+# _pmn_tool_status <id>: prints "ok <detail>", "old <detail>" or "missing".
+_pmn_tool_status() {
+    local v p
+    case "$1" in
+        clt)
+            if _pmn_clt_installed; then echo "ok $(xcode-select -p)"; else echo missing; fi ;;
+        brew)
+            if _pmn_have brew; then echo "ok $(command -v brew)"; else echo missing; fi ;;
+        git)
+            if _pmn_have git; then echo "ok $(git --version | sed 's/^git version //')"; else echo missing; fi ;;
+        cmake)
+            v="$(_pmn_cmake_version)"
+            if [ -z "$v" ]; then echo missing
+            elif _pmn_cmake_new_enough; then echo "ok $v"
+            else echo "old $v"; fi ;;
+        cxx)
+            if   _pmn_have g++;     then echo "ok g++ $(g++ -dumpversion 2>/dev/null)"
+            elif _pmn_have clang++; then echo "ok clang++"
+            elif _pmn_have c++;     then echo "ok c++"
+            else echo missing; fi ;;
+        clang)
+            if _pmn_have clang++; then echo "ok $(clang++ --version 2>/dev/null | sed -n '1s/.*version \([0-9][0-9.]*\).*/\1/p')"; else echo missing; fi ;;
+        clang-format|clang-tidy)
+            if _pmn_have "$1"; then echo "ok $(command -v "$1")"
+            elif p="$(_pmn_brew_llvm_bin)" && [ -x "$p/$1" ]; then echo "ok $p/$1"
+            else echo missing; fi ;;
+        # Compiled and linked for real, not just found on PATH -- see
+        # _pmn_cross_probe for why a mere `command -v` isn't enough.
+        xc-arm64)  _pmn_cross_status aarch64-linux-gnu ;;
+        xc-arm32)  _pmn_cross_status arm-linux-gnueabihf ;;
+        xc-x64)    _pmn_cross_status x86_64-linux-gnu ;;
+        mingw64)   if _pmn_have x86_64-w64-mingw32-g++;    then echo "ok"; else echo missing; fi ;;
+        mingw32)   if _pmn_have i686-w64-mingw32-g++;      then echo "ok"; else echo missing; fi ;;
+        qemu)      if _pmn_have qemu-aarch64 || _pmn_have qemu-arm || _pmn_have qemu-x86_64; then echo "ok"; else echo missing; fi ;;
+        wine)
+            if _pmn_have wine || _pmn_have wine64; then
+                if [ "$PMN_PM" = apt ] && [ "$PMN_ARCH" = x64 ] && ! _pmn_apt_wine64_installed; then
+                    echo "partial wine64 is missing (64-bit Windows programs need it)"
+                elif [ "$PMN_PM" = apt ] && [ "$PMN_ARCH" = x64 ] && ! _pmn_apt_wine32_installed; then
+                    echo "partial wine32:i386 is missing (32-bit Windows programs need it)"
+                else
+                    echo "ok"
+                fi
+            else
+                echo missing
+            fi ;;
+        ninja)     if _pmn_have ninja; then echo "ok $(ninja --version 2>/dev/null)"; else echo missing; fi ;;
+        *)         echo missing ;;
+    esac
+}
+
+# ---------------------------------------------------------------------------
+# The catalog
+#
+#   id | kind | label | why | apt | dnf | pacman | brew
+#
+# "-" means "not offered through that package manager". Rows are filtered per
+# platform by _pmn_tools_rows below, and listed in the order they're asked.
+# ---------------------------------------------------------------------------
+
+_pmn_row_cat() {
+    case "$1" in
+        git)          echo "git|required|Git|FetchContent clones dependencies (fmt) with it|git|git|git|git" ;;
+        cmake)        echo "cmake|required|CMake $PMN_CMAKE_MIN_MAJOR.$PMN_CMAKE_MIN_MINOR or newer|configures and drives every build|cmake|cmake|cmake|cmake" ;;
+        cxx)          echo "cxx|required|C++ compiler (GCC)|compiles the project|g++|gcc-c++|gcc|-" ;;
+        clang)        echo "clang|optional|Clang|the linux-*-clang presets (GCC alone is enough otherwise)|clang|clang|clang|-" ;;
+        clang-format) echo "clang-format|optional|clang-format|breeze/scripts/refactor.sh and the pre-commit hook|clang-format|clang-tools-extra|clang|clang-format" ;;
+        clang-tidy)   echo "clang-tidy|optional|clang-tidy|breeze/scripts/refactor.sh and the pre-commit hook|clang-tidy|clang-tools-extra|clang|llvm" ;;
+        xc-arm64)     echo "xc-arm64|optional|AArch64 cross compiler|the linux-arm64-* presets, built from this machine|g++-aarch64-linux-gnu|aarch64-linux-gnu-binutils aarch64-linux-gnu-gcc aarch64-linux-gnu-glibc|aarch64-linux-gnu-gcc|-" ;;
+        xc-arm32)     echo "xc-arm32|optional|32-bit ARM cross compiler|the linux-arm32-* presets, built from this machine|g++-arm-linux-gnueabihf|arm-linux-gnueabihf-binutils arm-linux-gnueabihf-gcc arm-linux-gnueabihf-glibc|-|-" ;;
+        xc-x64)       echo "xc-x64|optional|x86-64 cross compiler|the linux-x64-* presets, built from this machine|g++-x86-64-linux-gnu|-|-|-" ;;
+        mingw64)      echo "mingw64|optional|MinGW-w64 (64-bit Windows)|the windows-x64-mingw64 preset, cross-built from Linux|g++-mingw-w64-x86-64|mingw64-gcc-c++|mingw-w64-gcc|-" ;;
+        mingw32)      echo "mingw32|optional|MinGW-w64 (32-bit Windows)|the windows-x86-mingw32 preset, cross-built from Linux|g++-mingw-w64-i686|mingw32-gcc-c++|mingw-w64-gcc|-" ;;
+        qemu)         echo "qemu|optional|qemu-user|runs ARM cross builds (breeze/scripts/run.sh, ctest)|qemu-user|qemu-user|qemu-user|-" ;;
+        # apt names wine64 outright: `wine` only depends on "wine64 | wine32",
+        # an either/or, so `apt-get install wine wine32:i386` lets apt satisfy
+        # it with wine32 alone and leave wine64 out (it installs wine,
+        # wine32:i386 and libwine:i386 and nothing else). Without wine64 no
+        # 64-bit Windows program -- windows-x64-mingw64 -- can run at all.
+        wine)         echo "wine|optional|wine|runs MinGW cross builds (breeze/scripts/run.sh, ctest)|wine wine64 wine32:i386|wine|wine|-" ;;
+        ninja)        echo "ninja|required|Ninja|the build generator (no pinned download exists for this machine)|ninja-build|ninja-build|ninja|ninja" ;;
+        clt)          echo "clt|required|Xcode Command Line Tools|Apple Clang, git and make: the compiler for the macos-* presets|-|-|-|-" ;;
+        brew)         echo "brew|required|Homebrew|installs CMake and the other tools below|-|-|-|-" ;;
+    esac
+}
+
+# The ids to consider on this platform, in the order they are asked.
+_pmn_tools_ids() {
+    if [ "$PMN_OS" = macos ]; then
+        echo "clt brew cmake clang-format clang-tidy"
+        return
+    fi
+    local ids="git cmake cxx clang clang-format clang-tidy"
+    # Cross toolchains: only for architectures this machine can build FOR
+    # without being them, and only where a package (or, for dnf, a COPR --
+    # see _pmn_dnf_copr_for) is verified to actually provide a working one --
+    # confirmed against each distro's own package pages (and, for apt and
+    # the pacman rows below, this project's own users), not assumed from one
+    # distro's naming carrying over to another's. See _pmn_arch_extra_notes
+    # for what's deliberately still left out here and why: Fedora's own
+    # repos have no C++-capable Linux-target cross compiler at all (its
+    # cross-gcc packages ship no libstdc++, which is why dnf's rows below
+    # point at a COPR instead), no package manager here has one for
+    # x86-64-from-arm64, and pacman has no OFFICIAL package for 32-bit ARM
+    # either (AUR-only -- see _pmn_offer_aur_arm32).
+    case "$PMN_PM" in
+        apt)
+            case "$PMN_ARCH" in
+                x64)   ids="$ids xc-arm64 xc-arm32 mingw64 mingw32 qemu wine" ;;
+                arm64) ids="$ids xc-x64 xc-arm32 mingw64 mingw32 qemu" ;;
+            esac
+            ;;
+        pacman)
+            case "$PMN_ARCH" in
+                # xc-arm32 has no pacman package (its row says "-"): it is
+                # listed so the report shows whether it works, and
+                # _pmn_offer_aur_arm32 does the installing.
+                x64)   ids="$ids xc-arm64 xc-arm32 mingw64 mingw32 qemu wine" ;;
+                arm64) ids="$ids mingw64 mingw32 qemu" ;;
+            esac
+            ;;
+        dnf)
+            case "$PMN_ARCH" in
+                x64)   ids="$ids xc-arm64 xc-arm32 mingw64 mingw32 qemu wine" ;;
+                arm64) ids="$ids xc-arm32 mingw64 mingw32 qemu wine" ;;
+                *)     ids="$ids mingw64 mingw32 qemu wine" ;;
+            esac
+            ;;
+    esac
+    echo "$ids"
+}
+
+# -----------------------------------------------------------------------
+# Distro situations the catalog's plain "-" (not offered through this
+# package manager) doesn't explain on its own. Printed once, right after
+# the report, so "why isn't X in this list" has an answer instead of
+# looking like an oversight.
+# -----------------------------------------------------------------------
+_pmn_arch_extra_notes() {
+    case "$PMN_PM" in
+        apt)
+            if [ "$PMN_ARCH" = arm64 ] && ! _pmn_have wine && ! _pmn_have wine64; then
+                _pmn_note "    wine isn't offered here: Debian/Ubuntu do package it for arm64, but it's"
+                _pmn_note "    had long-standing arm64-host reliability problems there (hangs on"
+                _pmn_note "    startup on recent releases -- e.g. Ubuntu bug 2102681) serious enough"
+                _pmn_note "    that offering it would likely just fail. Install wine by hand if you"
+                _pmn_note "    want to try it anyway; the windows-*-mingw* presets don't need it --"
+                _pmn_note "    it's ctest and breeze/scripts/run.sh that use it to run what they build."
+            fi
+            ;;
+        dnf)
+            _pmn_note "    Fedora's own gcc-aarch64-linux-gnu / gcc-arm-linux-gnu / gcc-x86-64-linux-gnu"
+            _pmn_note "    packages ship no libstdc++ -- their own package description says"
+            _pmn_note "    cross-building userspace (i.e. non-kernel) programs isn't supported, and a"
+            _pmn_note "    C++ project like this one needs it. Where the list above offers an AArch64"
+            _pmn_note "    or 32-bit ARM cross compiler on dnf, it's from lantw44's COPR instead (a"
+            _pmn_note "    full GCC+glibc build, not Fedora's own package) -- accepting it enables"
+            _pmn_note "    that community repository, with its own separate confirmation. It can lag"
+            _pmn_note "    a new Fedora release by a while, so a just-released Fedora may not have a"
+            _pmn_note "    build there yet. MinGW (Windows) cross-compilation is a separate, complete"
+            _pmn_note "    Fedora project and works fine through Fedora's own mingw64-gcc-c++ /"
+            _pmn_note "    mingw32-gcc-c++ -- no COPR needed."
+            ;;
+        pacman)
+            if [ "$PMN_ARCH" = x64 ] && [ "$(_pmn_tool_status xc-arm32 | cut -d' ' -f1)" != ok ]; then
+                _pmn_note "    32-bit ARM cross compiler (linux-arm32-*): no official Arch package. The AUR"
+                _pmn_note "    has ARM's own prebuilt GNU toolchain split into four packages"
+                _pmn_note "    (arm-linux-gnueabihf-{binutils,glibc-headers,glibc,gcc}-bin): a download of a"
+                _pmn_note "    couple of hundred MB, not a compile. It is offered as its own question when"
+                _pmn_note "    you run this interactively; breeze/scripts/setup.sh --everything does it without"
+                _pmn_note "    asking. (Installing just arm-linux-gnueabihf-gcc-bin through an AUR helper"
+                _pmn_note "    builds the source-built binutils and glibc instead -- hours, and a toolchain"
+                _pmn_note "    whose parts don't fit together.)"
+            elif [ "$PMN_ARCH" = arm64 ]; then
+                _pmn_note "    32-bit ARM cross compiler (linux-arm32-*): not offered here -- the prebuilt"
+                _pmn_note "    AUR toolchain (arm-linux-gnueabihf-*-bin) is ARM's x86-64-hosted build, which"
+                _pmn_note "    can't run on an arm64 machine. ARM publishes an AArch64-hosted build of the"
+                _pmn_note "    same toolchain (developer.arm.com, GNU toolchain downloads) to unpack by hand."
+            fi
+            ;;
+    esac
+    case "$PMN_PM" in
+        dnf|pacman)
+            if [ "$PMN_ARCH" = arm64 ]; then
+                _pmn_note "    x86-64 cross compiler (linux-x64-* built from arm64): apt ships one"
+                _pmn_note "    (g++-x86-64-linux-gnu); no dnf or pacman equivalent is known to exist yet."
+            fi
+            ;;
+    esac
+}
+
+# -----------------------------------------------------------------------
+# Does a cross compiler WORK, or does it merely exist?
+#
+# `command -v arm-linux-gnueabihf-g++` can't tell, and a half-installed
+# toolchain passes it: setup.sh used to report the 32-bit ARM compiler as
+# installed while its g++ couldn't assemble a single file -- the assembler
+# and C library on the machine came from a different package set than the
+# compiler (see _pmn_aur_arm32_build). So the cross-compiler rows compile
+# and LINK a small C++ program, which needs every piece a real build needs
+# (the target's assembler, headers, libstdc++, crt1.o and libc), and
+# anything that fails reads "partial" instead of "ok". What comes out is a
+# foreign-architecture executable, so nothing is run.
+# -----------------------------------------------------------------------
+
+# _pmn_cross_probe <compiler>: 0 if <compiler> builds and links a C++
+# program for its target. Otherwise 1, with the compiler's first error line
+# on stdout.
+_pmn_cross_probe() {
+    local cxx="$1" dir out="" rc=0 line
+    dir="$(mktemp -d 2>/dev/null)" || return 0    # can't probe: don't cry wolf
+    printf '#include <iostream>\nint main() { std::cout << 1; }\n' > "$dir/probe.cpp"
+    if _pmn_have timeout; then
+        out="$(timeout 120 "$cxx" "$dir/probe.cpp" -o "$dir/probe" 2>&1 </dev/null)" || rc=$?
+    else
+        out="$("$cxx" "$dir/probe.cpp" -o "$dir/probe" 2>&1 </dev/null)" || rc=$?
+    fi
+    rm -rf "$dir"
+    [ "$rc" = 0 ] && return 0
+    line="$(printf '%s\n' "$out" | grep -i -m1 'error')" || line=""
+    [ -n "$line" ] || line="$(printf '%s\n' "$out" | sed -n '1p')"
+    [ -n "$line" ] || line="exit status $rc"
+    printf '%s\n' "$line" | sed 's/^[[:space:]]*//' | cut -c1-160
+    return 1
+}
+
+# _pmn_cross_status <triplet>: the catalog status ("ok", "missing" or
+# "partial <detail>") of <triplet>-g++.
+_pmn_cross_status() {
+    local cxx="$1-g++" why
+    if ! _pmn_have "$cxx"; then echo missing; return 0; fi
+    if why="$(_pmn_cross_probe "$cxx")"; then
+        echo ok
+    else
+        echo "partial can't build a test program: $why"
+    fi
+}
+
+# _pmn_cross_diagnose <compiler>: the facts that explain a cross compiler
+# that doesn't work -- which target it was built for, which sysroot and
+# assembler it looks for, and which of its packages are installed. Readable
+# as it is, and complete enough to paste into a bug report.
+_pmn_cross_diagnose() {
+    local cxx="$1" opt triplet
+    triplet="${cxx%-g++}"
+    for opt in -dumpmachine -print-sysroot -print-prog-name=as; do
+        _pmn_note "      $cxx $opt  ->  $("$cxx" "$opt" 2>&1 </dev/null | sed -n '1p')"
+    done
+    if _pmn_have pacman; then
+        _pmn_note "      installed ${triplet}-* packages: $(pacman -Qq 2>/dev/null | grep "^${triplet}-" | tr '\n' ' ')"
+    fi
+}
+
+# -----------------------------------------------------------------------
+# Never answered for you: the slow or third-party extras (today, the AUR
+# toolchain below). _pmn_confirm takes `--all`, and an earlier "a", as a
+# yes; these don't count here -- only --everything (which never reaches
+# this) or a y typed at this very question. 0 for yes.
+# -----------------------------------------------------------------------
+_pmn_confirm_heavy() {
+    local ans
+    [ "$_PMN_ANS_QUIT" = 1 ] && return 1
+    [ "$_PMN_ANS_SKIP_OPT" = 1 ] && return 1
+    [ -t 0 ] || return 1
+    if ! IFS= read -r -p "  $1 [y/N] " ans; then
+        echo
+        _PMN_ANS_QUIT=1
+        return 1
+    fi
+    case "$ans" in y|Y|yes|YES|Yes) return 0 ;; esac
+    return 1
+}
+
+# After a failed AUR build or install: what the usual causes look like, and
+# what to do about each. This script can't tell them apart from an exit
+# status alone.
+_pmn_note_aur_hint() {
+    _pmn_note "    If the output above ends in a key error ('PGP keys need importing', 'problem"
+    _pmn_note "    importing keys', 'unknown public key'): import the key it names (gpg --recv-keys"
+    _pmn_note "    <ID>; for a kernel.org address, gpg --auto-key-locate nodefault,wkd --locate-keys"
+    _pmn_note "    <address>) and run this again. If it ends in a conflict ('are in conflict',"
+    _pmn_note "    'conflicting files', 'exists in filesystem'): remove the package that owns the"
+    _pmn_note "    file or that is named, and run this again. Either way the packages' pages say"
+    _pmn_note "    more: https://aur.archlinux.org/packages/arm-linux-gnueabihf-gcc-bin"
+}
+
+# -----------------------------------------------------------------------
+# The 32-bit ARM cross compiler on Arch (x64 hosts).
+#
+# Arch has no official package for it. The AUR has two families:
+#
+#   * arm-linux-gnueabihf-{binutils,linux-api-headers,gcc-stage1,
+#     glibc-headers,gcc-stage2,glibc,gcc}: GCC bootstrapped from source,
+#     stage by stage. Hours of compiling, and each stage conflicts with the
+#     one before it.
+#   * arm-linux-gnueabihf-{binutils,glibc-headers,glibc,gcc}-bin: ARM's own
+#     x86-64-hosted GNU toolchain (arm-none-linux-gnueabihf, 15.2.rel1),
+#     prebuilt and split into four packages that each `provide` the name of
+#     their source-built twin. A download, not a compile -- and x86-64 only,
+#     which is why arm64 hosts aren't offered it.
+#
+# `yay -S arm-linux-gnueabihf-gcc-bin` -- what this script used to run, in
+# three steps -- looks like the second family and builds the first. The
+# package's dependencies are written as the generic names (binutils, glibc,
+# glibc-headers); a helper looks for a package of exactly that name first,
+# finds the source-built one, and only then at what merely provides it. The
+# result was hours of compiling and a MIXED toolchain: ARM's prebuilt
+# compiler (which looks for its assembler and C library where ARM's layout
+# puts them) next to a source-built binutils and glibc (which put them
+# somewhere else). It "compiled okay" and then failed every use:
+#
+#   linux-arm32-gcc    "Fatal error: invalid -march= option: `armv7-a+simd'"
+#                      -- that is the host's x86 assembler: the compiler
+#                      couldn't find its own, so it fell back to PATH.
+#   linux-arm32-clang  "Scrt1.o: file not recognized" -- the sysroot the
+#                      compiler reports (/arm-none-linux-gnueabihf/libc)
+#                      isn't there, so the linker found the host's.
+#
+# So the four -bin packages are installed by name, as ONE pacman
+# transaction: build each from its AUR repository with makepkg (no
+# dependency resolution by an AUR helper to get wrong -- and none needed,
+# which is also why no helper has to be installed), then `pacman -U` them
+# together, so every dependency among them is satisfied by another of the
+# four and nothing is built from source. --ask 4 is pacman's pre-answer-yes
+# for "X and Y are in conflict. Remove Y?" (its default, which --noconfirm
+# takes, is No): the -bin packages conflict with their source-built twins,
+# and an earlier source build is exactly the state a repair starts from. It
+# answers yes for any conflicting package in that transaction, not only
+# those, and the prompt says so.
+# -----------------------------------------------------------------------
+_PMN_ARM32_AUR_PACKAGES="arm-linux-gnueabihf-binutils-bin arm-linux-gnueabihf-glibc-headers-bin arm-linux-gnueabihf-glibc-bin arm-linux-gnueabihf-gcc-bin"
+
+# _pmn_aur_arm32_build: clones the four AUR repositories, builds them with
+# makepkg, and installs them together. The work directory is removed on
+# success; after a failure it stays, with the (shared) source download in it,
+# so running this again doesn't fetch ARM's toolchain a second time.
+_pmn_aur_arm32_build() {
+    local work pkg dir stage staged=() files=() f
+    if [ "$(id -u)" = 0 ]; then
+        _pmn_say "    ${_PMN_RED}can't build an AUR package as root${_PMN_RESET} -- makepkg refuses to."
+        _pmn_say "    Re-run as a normal user with sudo."
+        return 1
+    fi
+    if [ "$PMN_SUDO" = "?" ]; then
+        _pmn_say "    ${_PMN_RED}cannot install the packages:${_PMN_RESET} installing needs root, and sudo isn't available."
+        return 1
+    fi
+    if ! { _pmn_have git && _pmn_have makepkg && _pmn_have fakeroot; }; then
+        _pmn_pkg_install "git base-devel" || return 1
+    fi
+
+    # Under the cache directory, not /tmp: /tmp is RAM-backed on Arch, and
+    # ARM's toolchain unpacks to well over a gigabyte.
+    work="${XDG_CACHE_HOME:-$HOME/.cache}/pmn-aur-arm32"
+    mkdir -p "$work/src" "$work/git" "$work/pkgs" || return 1
+    rm -f "$work"/pkgs/*
+
+    # All four PKGBUILDs download the same ARM tarball: SRCDEST makes makepkg
+    # fetch it once and reuse it (it reads SRCDEST/PKGDEST from the
+    # environment, ahead of makepkg.conf). --clean drops each build's
+    # unpacked copy as soon as its package exists, so only one is on disk at a
+    # time; --nodeps because these only repackage a binary release -- the
+    # dependency check that matters happens at install, below.
+    for pkg in $_PMN_ARM32_AUR_PACKAGES; do
+        dir="$work/git/$pkg"
+        rm -rf "$dir"
+        _pmn_run_shown git clone --depth 1 "https://aur.archlinux.org/${pkg}.git" "$dir" || return 1
+        # The AUR answers a clone of a name it doesn't have with an empty
+        # repository and a warning, not an error -- which is what a package
+        # that was renamed, merged into another or removed looks like.
+        if [ ! -f "$dir/PKGBUILD" ]; then
+            _pmn_say "    ${_PMN_RED}the AUR repository ${pkg} has no PKGBUILD${_PMN_RESET} -- the package may have been renamed, merged into another or removed."
+            _pmn_say "    Look for what replaced it: https://aur.archlinux.org/packages?K=arm-linux-gnueabihf"
+            return 1
+        fi
+        (cd "$dir" && _pmn_run_shown env SRCDEST="$work/src" PKGDEST="$work/pkgs" \
+            makepkg --force --clean --nodeps --noconfirm) || return 1
+    done
+
+    for f in "$work"/pkgs/*.pkg.tar.*; do
+        [ -e "$f" ] || continue
+        case "$f" in *.sig|*-debug-*) continue ;; esac
+        files+=("$f")
+    done
+    if [ "${#files[@]}" -eq 0 ]; then
+        _pmn_say "    ${_PMN_RED}makepkg finished, but left no package in${_PMN_RESET} $work/pkgs"
+        return 1
+    fi
+
+    # The bootstrap compilers of an earlier source build install the same
+    # /usr/bin/arm-linux-gnueabihf-* names as gcc-bin, with no conflict
+    # declared between them, so they have to go first (plain -R, not -s,
+    # which would also take what was installed for later).
+    for stage in arm-linux-gnueabihf-gcc-stage2 arm-linux-gnueabihf-gcc-stage1; do
+        if pacman -Qq "$stage" >/dev/null 2>&1; then staged+=("$stage"); fi
+    done
+    if [ "${#staged[@]}" -gt 0 ]; then
+        _pmn_run_shown ${PMN_SUDO:+"$PMN_SUDO"} pacman -R --noconfirm "${staged[@]}" || return 1
+    fi
+
+    _pmn_run_shown ${PMN_SUDO:+"$PMN_SUDO"} pacman -U --noconfirm --needed --ask 4 "${files[@]}" || return 1
+    rm -rf "$work"
+}
+
+# _pmn_report_arm32_install: after the install itself reported success --
+# which says nothing about whether the compiler works. Says what it found.
+_pmn_report_arm32_install() {
+    local why
+    if ! _pmn_have arm-linux-gnueabihf-g++; then
+        _pmn_say "    ${_PMN_YELLOW}the packages installed, but arm-linux-gnueabihf-g++ still isn't on PATH${_PMN_RESET} -- check the output above."
+        return 1
+    fi
+    if why="$(_pmn_cross_probe arm-linux-gnueabihf-g++)"; then
+        _pmn_say "    ${_PMN_GREEN}installed${_PMN_RESET} -- and it compiles and links a test program"
+        return 0
+    fi
+    _pmn_say "    ${_PMN_YELLOW}installed, but arm-linux-gnueabihf-g++ can't build a test program:${_PMN_RESET} $why"
+    _pmn_cross_diagnose arm-linux-gnueabihf-g++
+    _pmn_note "    That is what breeze/cmake/toolchains/ would hit too. Paste the lines above into an"
+    _pmn_note "    issue: they say which assembler and sysroot the compiler looks for."
+    return 1
+}
+
+# -----------------------------------------------------------------------
+# _pmn_offer_aur_arm32: the pacman/x64 half of the situation
+# _pmn_arch_extra_notes describes. Offered when the 32-bit ARM compiler is
+# missing -- or present but unable to build anything, the state the old
+# three-step source build left behind; the same install repairs it.
+#
+# Never done without an answer from you: --all and an earlier "a" don't
+# count (see _pmn_confirm_heavy), only --everything or a y at this question.
+# It runs community PKGBUILDs as you and downloads ARM's toolchain, so it
+# is a separate decision from "install the usual tools".
+#
+# Uses bash's dynamic scoping deliberately: `offered` and `skipped_optional`
+# are the CALLER's (_pmn_tools_run's) `local` variables, still in scope
+# here since this is called from within that function, so accepting or
+# declining this folds into the SAME summary the catalog rows use instead
+# of printing a separate one.
+# -----------------------------------------------------------------------
+_pmn_offer_aur_arm32() {
+    [ "$PMN_PM" = pacman ] && [ "$PMN_ARCH" = x64 ] || return 0
+    [ "$_PMN_ANS_QUIT" = 1 ] && return 0
+
+    local state detail label="32-bit ARM cross compiler (AUR, prebuilt)"
+    state="$(_pmn_tool_status xc-arm32)"
+    [ "${state%% *}" = ok ] && return 0
+    detail="${state#* }"; [ "$detail" = "$state" ] && detail=""
+
+    if ! _pmn_heavy_wanted; then
+        if [ "$PMN_TOOLS_ALL" = 1 ] || [ "$_PMN_ANS_SKIP_OPT" = 1 ] || [ ! -t 0 ]; then
+            skipped_optional="${skipped_optional:+$skipped_optional, }$label"
+            return 0
+        fi
+    fi
+
+    offered=$((offered + 1))
+    _pmn_say
+    _pmn_say "  ${_PMN_BOLD}${label}${_PMN_RESET} -- the linux-arm32-* presets, built from this machine"
+    if [ -n "$detail" ]; then
+        _pmn_note "    arm-linux-gnueabihf-g++ is already installed, but it $detail"
+        _pmn_note "    This install repairs that: it replaces the pieces that don't belong together."
+    fi
+    _pmn_note "    No official Arch package exists for this (see the note above). The AUR has"
+    _pmn_note "    ARM's own GNU toolchain (15.2.rel1, x86-64 hosts) repackaged as four prebuilt"
+    _pmn_note "    packages -- arm-linux-gnueabihf-{binutils,glibc-headers,glibc,gcc}-bin: a"
+    _pmn_note "    download of a couple of hundred MB and a few minutes, no compiling. They are"
+    _pmn_note "    community-maintained, not reviewed by Arch, and their PKGBUILDs run as you."
+    _pmn_note "    Each is built from its AUR repository with makepkg (git and base-devel are"
+    _pmn_note "    installed first if missing), then all four are installed in ONE pacman"
+    _pmn_note "    transaction, with --ask 4: pacman's pre-answer-yes for \"X and Y are in"
+    _pmn_note "    conflict. Remove Y?\", whose default (and --noconfirm's) is No. That is how a"
+    _pmn_note "    source-built arm-linux-gnueabihf-binutils or -glibc from an earlier attempt"
+    _pmn_note "    gets replaced; it answers yes for any conflicting package in that transaction,"
+    _pmn_note "    not only those. Leftover gcc-stage1/stage2 compilers are removed first."
+    if _pmn_heavy_wanted || _pmn_confirm_heavy "Build and install these four packages now?"; then
+        if _pmn_aur_arm32_build; then
+            _pmn_report_arm32_install || true
+        else
+            _pmn_say "    ${_PMN_RED}the install failed${_PMN_RESET} -- see the output above."
+            _pmn_note_aur_hint
+        fi
+    else
+        skipped_optional="${skipped_optional:+$skipped_optional, }$label"
+    fi
+}
+
+# Field <n> (1-based) of a catalog row. A `read` into named variables rather
+# than word-splitting the row: the rows contain "*" (linux-*-clang), and an
+# unquoted expansion would be subject to pathname globbing.
+_pmn_field() {
+    local f1 f2 f3 f4 f5 f6 f7 f8
+    IFS='|' read -r f1 f2 f3 f4 f5 f6 f7 f8 <<< "$1"
+    case "$2" in
+        1) printf '%s\n' "$f1" ;; 2) printf '%s\n' "$f2" ;; 3) printf '%s\n' "$f3" ;;
+        4) printf '%s\n' "$f4" ;; 5) printf '%s\n' "$f5" ;; 6) printf '%s\n' "$f6" ;;
+        7) printf '%s\n' "$f7" ;; 8) printf '%s\n' "$f8" ;;
+    esac
+}
+
+# The package(s) that provide a row's tool through the current package
+# manager, or "" if it isn't offered there.
+_pmn_row_packages() {
+    local row="$1" col
+    case "$PMN_PM" in
+        apt) col=5 ;; dnf) col=6 ;; pacman) col=7 ;; brew) col=8 ;; *) return 0 ;;
+    esac
+    local p
+    p="$(_pmn_field "$row" "$col")"
+    [ "$p" = "-" ] && p=""
+    printf '%s\n' "$p"
+}
+
+# ---------------------------------------------------------------------------
+# Asking
+# ---------------------------------------------------------------------------
+
+_pmn_say()  { printf '%s\n' "$*"; }
+_pmn_note() { printf '%s\n' "${_PMN_DIM}$*${_PMN_RESET}"; }
+
+# Would an OPTIONAL tool be offered (asked about, or installed by --all) at
+# this point? If not, the caller skips it silently and mentions it once at
+# the end, instead of printing a "left alone" block for each.
+_pmn_optional_wanted() {
+    if [ "$_PMN_ANS_QUIT" = 1 ] || [ "$_PMN_ANS_SKIP_OPT" = 1 ]; then return 1; fi
+    if [ "$PMN_TOOLS_ALL" = 1 ] || [ "$_PMN_ANS_ALL" = 1 ]; then return 0; fi
+    [ -t 0 ]
+}
+
+# Is "everything" mode on (setup.sh --everything)? A flag only, with no
+# matching answer at the prompts: what it unlocks is slow or third-party
+# enough that it shouldn't be one keystroke at a question about something
+# else.
+_pmn_heavy_wanted() { [ "$PMN_TOOLS_HEAVY" = 1 ]; }
+
+# _pmn_confirm <required|optional> <question>
+#
+# Returns 0 for "install it", 1 for "leave it". Sets _PMN_ANS_* for answers
+# that outlast one prompt (see their comments up top).
+_pmn_confirm() {
+    local kind="$1" question="$2" prompt ans
+
+    if [ "$_PMN_ANS_QUIT" = 1 ]; then return 1; fi
+    if [ "$_PMN_ANS_ALL" = 1 ]; then return 0; fi
+    if [ "$kind" = optional ] && [ "$_PMN_ANS_SKIP_OPT" = 1 ]; then return 1; fi
+
+    # Flags answer for you...
+    if [ "$kind" = required ] && [ "$PMN_TOOLS_YES" = 1 ]; then return 0; fi
+    if [ "$PMN_TOOLS_ALL" = 1 ]; then return 0; fi
+
+    # ...and with no terminal there is nobody to ask.
+    if [ ! -t 0 ]; then
+        _pmn_note "    (not asking: no terminal. Re-run interactively, or pass --yes / --all.)"
+        return 1
+    fi
+
+    if [ "$kind" = required ]; then
+        prompt="  ${question} [Y/n/a/q] "
+    else
+        prompt="  ${question} [y/N/a/s/q] "
+    fi
+    while :; do
+        if ! IFS= read -r -p "$prompt" ans; then
+            # EOF (Ctrl-D): stop asking rather than loop on it.
+            echo
+            _PMN_ANS_QUIT=1
+            return 1
+        fi
+        case "$ans" in
+            y|Y|yes|YES|Yes) return 0 ;;
+            n|N|no|NO|No)    return 1 ;;
+            "")              if [ "$kind" = required ]; then return 0; else return 1; fi ;;
+            a|A|all)         _PMN_ANS_ALL=1; return 0 ;;
+            s|S|skip)        _PMN_ANS_SKIP_OPT=1; return 1 ;;
+            q|Q|quit)        _PMN_ANS_QUIT=1; return 1 ;;
+            *)
+                if [ "$kind" = required ]; then
+                    _pmn_note "    y = install   n = not this one   a = install everything left   q = stop asking"
+                else
+                    _pmn_note "    y = install   n = not this one   a = install everything left   s = skip the rest of the optional tools   q = stop asking"
+                fi
+                ;;
+        esac
+    done
+}
+
+# ---------------------------------------------------------------------------
+# Installing
+# ---------------------------------------------------------------------------
+
+# _pmn_run_shown <command...>: print the command, then run it.
+_pmn_run_shown() {
+    printf '    %s$ %s%s\n' "${_PMN_DIM}" "$*" "${_PMN_RESET}"
+    "$@"
+}
+
+# Sudo, when the package manager needs it. A machine that is neither root
+# nor has sudo can't install system packages; say so once, plainly.
+_pmn_pkg_install() {
+    local pkgs="$1" rc=0
+    if [ "$PMN_SUDO" = "?" ] && [ "$PMN_PM" != brew ]; then
+        _pmn_say "    ${_PMN_RED}cannot install:${_PMN_RESET} this needs root, and sudo isn't available."
+        _pmn_say "    Run this script as root, or install by hand: $pkgs"
+        return 1
+    fi
+    # shellcheck disable=SC2086  # $pkgs is a deliberate word list
+    case "$PMN_PM" in
+        apt)
+            if [ "$_PMN_APT_UPDATED" = 0 ]; then
+                _pmn_run_shown ${PMN_SUDO:+"$PMN_SUDO"} apt-get update || true
+                _PMN_APT_UPDATED=1
+            fi
+            _pmn_run_shown ${PMN_SUDO:+"$PMN_SUDO"} apt-get install -y $pkgs || rc=$?
+            ;;
+        dnf)
+            _pmn_run_shown ${PMN_SUDO:+"$PMN_SUDO"} dnf install -y $pkgs || rc=$?
+            ;;
+        pacman)
+            _pmn_run_shown ${PMN_SUDO:+"$PMN_SUDO"} pacman -S --needed --noconfirm $pkgs || rc=$?
+            ;;
+        brew)
+            _pmn_run_shown brew install $pkgs || rc=$?
+            ;;
+        *)
+            return 1 ;;
+    esac
+    return "$rc"
+}
+
+# macOS: `xcode-select --install` returns immediately after opening a GUI
+# installer, so wait for the developer directory to appear. Enter re-checks
+# right away; otherwise it looks every 5 seconds.
+_pmn_install_clt() {
+    _pmn_run_shown xcode-select --install || true
+    _pmn_say "    A dialog should have opened: click Install and wait for it to finish."
+    _pmn_say "    Waiting for the tools (Enter checks now; Ctrl-C to stop waiting) ..."
+    local waited=0
+    until _pmn_clt_installed; do
+        # Not `read -t 5` with stdin at EOF: that returns at once and would
+        # spin. sleep is the wait; read only makes Enter an early re-check.
+        if [ -t 0 ]; then
+            IFS= read -r -t 5 _ 2>/dev/null || true
+        else
+            sleep 5
+        fi
+        waited=$((waited + 5))
+        if [ "$waited" -ge 3600 ]; then
+            _pmn_say "    Gave up waiting after an hour -- re-run this script once the install has finished."
+            return 1
+        fi
+    done
+    return 0
+}
+
+# Homebrew's own documented installer. It asks for your password and for a
+# RETURN of its own -- those prompts are Homebrew's, and are left alone
+# unless --yes was given (then NONINTERACTIVE=1 tells it not to ask).
+_pmn_install_brew() {
+    if ! _pmn_have curl; then
+        _pmn_say "    curl not found -- see https://brew.sh for manual installation steps."
+        return 1
+    fi
+    printf '    %s$ /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"%s\n' "${_PMN_DIM}" "${_PMN_RESET}"
+    local rc=0
+    if [ "$PMN_TOOLS_YES" = 1 ] || [ "$PMN_TOOLS_ALL" = 1 ]; then
+        NONINTERACTIVE=1 /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)" || rc=$?
+    else
+        /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)" || rc=$?
+    fi
+    # A fresh install isn't on PATH in this shell yet.
+    local b
+    for b in /opt/homebrew/bin/brew /usr/local/bin/brew; do
+        if [ -x "$b" ]; then eval "$("$b" shellenv)"; PMN_PM=brew; break; fi
+    done
+    return "$rc"
+}
+
+# wine on Arch lives in the multilib repository, which is DISABLED by
+# default -- confirmed against the Arch Wiki and Arch Linux Forums, and
+# the standard symptom without it is `pacman -S wine` failing with
+# "error: target not found: wine", which would otherwise look like this
+# script's package name is simply wrong. `pacman-conf --repo-list` is the
+# reliable way to ask pacman which repositories are actually active,
+# rather than grep-ing /etc/pacman.conf by hand (which a comment, or an
+# include from a different file, can easily fool).
+_pmn_pacman_multilib_enabled() {
+    pacman-conf --repo-list 2>/dev/null | grep -qx multilib
+}
+
+# Offers to enable it -- editing /etc/pacman.conf is a bigger step than a
+# normal package install, so it gets its own explicit confirmation, and
+# says exactly what will change, before wine's own "Install wine?"
+# question ever appears.
+#
+# Two ways it can be missing, tried in order: most installs ship the
+# standard commented-out block, which the sed uncomments in place; some
+# minimal/container base images (confirmed against an Arch distrobox
+# image, which is how most people meet this path in practice) strip that
+# block out of /etc/pacman.conf entirely rather than just commenting it,
+# in which case the sed is a same-file no-op (a real edit either finds
+# something to change or it doesn't -- there's no way to tell those apart
+# except checking after) and the same two lines the Arch Wiki documents
+# get appended instead. Only the first method that actually results in
+# multilib being enabled runs pacman -Sy, so a real config error still
+# ends in the honest "enable by hand" message rather than silently
+# appending a second, conflicting [multilib] section.
+_pmn_pacman_enable_multilib() {
+    if [ "$PMN_SUDO" = "?" ]; then
+        _pmn_say "    ${_PMN_RED}cannot enable multilib:${_PMN_RESET} editing /etc/pacman.conf needs root, and sudo isn't available."
+        return 1
+    fi
+    _pmn_say "    wine is in Arch's multilib repository, which isn't enabled on this machine."
+    _pmn_note "    That needs a one-time change to /etc/pacman.conf: uncommenting (or adding)"
+    _pmn_note "      [multilib]"
+    _pmn_note "      Include = /etc/pacman.d/mirrorlist"
+    if ! _pmn_confirm optional "Enable the multilib repository now?"; then
+        return 1
+    fi
+    _pmn_run_shown ${PMN_SUDO:+"$PMN_SUDO"} sed -i \
+        -e '/^#\[multilib\]/s/^#//' \
+        -e '/^\[multilib\]/{n;s/^#//}' \
+        /etc/pacman.conf || return 1
+    if ! _pmn_pacman_multilib_enabled && ! grep -qx '\[multilib\]' /etc/pacman.conf 2>/dev/null; then
+        _pmn_say "    ${_PMN_YELLOW}no [multilib] block found to uncomment${_PMN_RESET} -- appending one instead."
+        _pmn_run_shown ${PMN_SUDO:+"$PMN_SUDO"} sh -c \
+            "printf '\n[multilib]\nInclude = /etc/pacman.d/mirrorlist\n' >> /etc/pacman.conf" || return 1
+    fi
+    if ! _pmn_pacman_multilib_enabled; then
+        _pmn_say "    ${_PMN_YELLOW}/etc/pacman.conf doesn't look like the standard layout this edits${_PMN_RESET} -- enable [multilib] by hand, then re-run."
+        return 1
+    fi
+    _pmn_run_shown ${PMN_SUDO:+"$PMN_SUDO"} pacman -Sy || return 1
+}
+
+# The Fedora-targeting cross toolchains that need a COPR instead of a
+# Fedora-native package (see _pmn_arch_extra_notes for why): prints
+# "<owner>/<project>" for the ids that need one, empty for anything else.
+# One place the confirmation prompt and the install step both read from, so
+# they can't drift apart. lantw44's toolchains are crosstool-NG builds of a
+# full GCC+glibc (C++ included, unlike Fedora's own cross-gcc) -- see
+# https://copr.fedorainfracloud.org/coprs/lantw44/.
+_pmn_dnf_copr_for() {
+    case "$1" in
+        xc-arm64) echo "lantw44/aarch64-linux-gnu-toolchain" ;;
+        xc-arm32) echo "lantw44/arm-linux-gnueabihf-toolchain" ;;
+    esac
+}
+
+# Is <owner>/<project> already enabled? Asking dnf what's enabled, rather
+# than guessing the generated .repo filename on disk, is the same approach
+# _pmn_pacman_multilib_enabled takes with `pacman-conf --repo-list`. Best
+# effort: "no" here on a dnf too old for the copr plugin just means
+# _pmn_dnf_enable_copr asks again next run instead of remembering -- annoying,
+# never unsafe, since enabling an already-enabled COPR is a harmless no-op.
+_pmn_dnf_copr_enabled() {
+    dnf -q repolist --enabled 2>/dev/null | grep -qi "copr.*${1#*/}"
+}
+
+# Offers to enable it -- adding a repository is a bigger step than a normal
+# package install, so like wine's multilib prompt above, it gets its own
+# explicit confirmation, separate from the "install this tool?" question
+# that precedes it. COPR builds happen on Fedora's own servers (nothing
+# compiles on your machine, unlike the AUR case below) but a COPR project is
+# run by its owner, not reviewed by Fedora -- said plainly, once, before
+# anything is added.
+_pmn_dnf_enable_copr() {
+    local repo="$1"
+    if [ "$PMN_SUDO" = "?" ]; then
+        _pmn_say "    ${_PMN_RED}cannot enable this repository:${_PMN_RESET} needs root, and sudo isn't available."
+        return 1
+    fi
+    _pmn_say "    Fedora's own repos have no working cross compiler for this (see above) --"
+    _pmn_say "    this one comes from ${repo}, a community COPR repository:"
+    _pmn_note "      https://copr.fedorainfracloud.org/coprs/${repo}/"
+    _pmn_note "    (built on Fedora's own servers, but not reviewed by Fedora)"
+    if ! _pmn_confirm optional "Enable the ${repo} COPR repository now?"; then
+        return 1
+    fi
+    _pmn_run_shown ${PMN_SUDO:+"$PMN_SUDO"} dnf -y copr enable "$repo" || return 1
+}
+
+# Running a 32-bit Windows binary (the windows-x86-mingw32 preset) under
+# Wine on an x64 Debian/Ubuntu host needs wine32:i386 -- a SEPARATE
+# package from wine/wine64, on a SEPARATE (i386) architecture that apt
+# doesn't register by default. Confirmed against Debian's own wiki and
+# several Debian/Ubuntu bug reports: without this, `wine` installs and
+# runs fine on 64-bit binaries, and only announces the problem the first
+# time it's actually asked to run a 32-bit one -- "it looks like wine32
+# is missing ... multiarch needs to be enabled first" -- which is Wine's
+# own message, not this script's, and by then setup.sh already exited
+# successfully long before, having had no reason to think anything was
+# left to do; there's nothing to detect this from wine's own status. So
+# the apt package list for wine (below) includes wine32:i386 unconditionally
+# whenever wine is offered at all (x64 hosts only -- see _pmn_tools_ids),
+# and this runs first to make that installable, the same two-step
+# separate-confirmation shape as pacman's multilib above.
+_pmn_apt_multiarch_i386_enabled() {
+    dpkg --print-foreign-architectures 2>/dev/null | grep -qx i386
+}
+
+# Is wine32:i386 actually installed? Wine itself (64-bit) runs without it and
+# prints its "it looks like wine32 is missing" complaint on EVERY run, so a
+# machine where wine was installed before wine32 was part of this script's
+# package list would otherwise look finished: wine present -> nothing left
+# to offer. Reported as "partial" (see the report loop) so it gets offered
+# again, and the install is idempotent -- wine is already there, only
+# wine32:i386 (and the i386 architecture it needs) is added.
+_pmn_apt_wine32_installed() {
+    # shellcheck disable=SC2016  # ${Status} is dpkg-query's format syntax, not ours
+    dpkg-query -W -f='${Status}' wine32:i386 2>/dev/null | grep -q '^install ok installed'
+}
+
+# The mirror image of the above, and the one that bit: is wine64 installed?
+# `wine` itself needs only one of wine64 and wine32, so a machine set up with
+# `apt-get install wine wine32:i386` has the 32-bit wine alone -- `wine` is
+# there, wine32 is there, every check above passes -- and can run no 64-bit
+# Windows program: the 32-bit loader can't, and creates a 32-bit prefix even
+# under WINEARCH=win64, then refuses it ("WINEARCH set to win64 but '...' is
+# a 32-bit installation").
+_pmn_apt_wine64_installed() {
+    # shellcheck disable=SC2016  # ${Status} is dpkg-query's format syntax, not ours
+    dpkg-query -W -f='${Status}' wine64 2>/dev/null | grep -q '^install ok installed'
+}
+
+_pmn_apt_enable_multiarch_i386() {
+    if [ "$PMN_SUDO" = "?" ]; then
+        _pmn_say "    ${_PMN_RED}cannot enable the i386 architecture:${_PMN_RESET} needs root, and sudo isn't available."
+        return 1
+    fi
+    _pmn_say "    wine32:i386 -- needed to run 32-bit Windows binaries (the"
+    _pmn_say "    windows-x86-mingw32 preset) under Wine -- needs the i386 foreign"
+    _pmn_say "    architecture registered first (dpkg --add-architecture i386)."
+    if ! _pmn_confirm optional "Register the i386 architecture now?"; then
+        return 1
+    fi
+    _pmn_run_shown ${PMN_SUDO:+"$PMN_SUDO"} dpkg --add-architecture i386 || return 1
+    # A fresh update is needed here specifically: i386's package lists
+    # don't exist yet even if apt-get update already ran this session for
+    # the native architecture, and _pmn_pkg_install's own update only runs
+    # once (_PMN_APT_UPDATED) -- set the flag after so it doesn't run again
+    # right behind this one for nothing.
+    _pmn_run_shown ${PMN_SUDO:+"$PMN_SUDO"} apt-get update || return 1
+    _PMN_APT_UPDATED=1
+}
+
+# _pmn_install_row <row>: install one catalog row; returns its status.
+_pmn_install_row() {
+    local row="$1" id pkgs copr
+    id="$(_pmn_field "$row" 1)"
+    case "$id" in
+        clt)  _pmn_install_clt; return $? ;;
+        brew) _pmn_install_brew; return $? ;;
+    esac
+    if [ "$id" = wine ] && [ "$PMN_PM" = pacman ] && ! _pmn_pacman_multilib_enabled; then
+        _pmn_pacman_enable_multilib || return 1
+    fi
+    if [ "$id" = wine ] && [ "$PMN_PM" = apt ] && ! _pmn_apt_multiarch_i386_enabled; then
+        _pmn_apt_enable_multiarch_i386 || return 1
+    fi
+    if [ "$PMN_PM" = dnf ]; then
+        copr="$(_pmn_dnf_copr_for "$id")"
+        if [ -n "$copr" ] && ! _pmn_dnf_copr_enabled "$copr"; then
+            _pmn_dnf_enable_copr "$copr" || return 1
+        fi
+    fi
+    pkgs="$(_pmn_row_packages "$row")"
+    if [ -z "$pkgs" ]; then
+        _pmn_say "    ${_PMN_YELLOW}no package known for this on ${PMN_PM}${_PMN_RESET} -- install it yourself."
+        return 1
+    fi
+    _pmn_pkg_install "$pkgs"
+}
+
+# What to tell someone whose package manager's CMake is too old (Ubuntu 22.04
+# ships 3.22, Debian 11 ships 3.18). Not run automatically: which of these is
+# right depends on the machine, and each one changes more than a package.
+_pmn_cmake_too_old_help() {
+    _pmn_say "    ${_PMN_YELLOW}CMake $1 is older than the ${PMN_CMAKE_MIN_MAJOR}.${PMN_CMAKE_MIN_MINOR} this project needs.${_PMN_RESET} Any one of:"
+    _pmn_say "      pipx install cmake                      # Kitware's own wheels (pipx from your package manager)"
+    _pmn_say "      sudo snap install cmake --classic        # if you use snap"
+    _pmn_say "      https://cmake.org/download/               # official binary tarball"
+}
+
+# ---------------------------------------------------------------------------
+# Entry point
+# ---------------------------------------------------------------------------
+
+# Rows are collected into an array first, then looped over -- rather than
+# reading a here-doc in the loop -- so a command run inside the loop (a
+# package manager, sudo) can never swallow the rest of the list from stdin.
+_pmn_tools_run() {
+    local rows=() id row kind label why status detail pkgs missing_required=0
+    local failed=""
+    local pm_desc
+
+    _pmn_tools_detect
+
+    case "$PMN_OS" in
+        linux) pm_desc="Linux ${PMN_ARCH:-?}, package manager: ${PMN_PM}" ;;
+        macos) pm_desc="macOS ${PMN_ARCH:-?}, package manager: ${PMN_PM}" ;;
+        *)     pm_desc="$(uname -s) (not supported by this installer)" ;;
+    esac
+    _pmn_say "==> Checking the tools this project builds with (${pm_desc})"
+
+    if [ "$PMN_OS" = other ]; then
+        _pmn_say "    This installer knows Linux and macOS; on Windows use breeze\\scripts\\setup.bat."
+        return 0
+    fi
+    if [ "$PMN_OS" = linux ] && [ "$PMN_PM" = none ]; then
+        _pmn_say "    ${_PMN_YELLOW}No supported package manager found${_PMN_RESET} (apt, dnf and pacman are)."
+        _pmn_say "    Install these yourself: a C++ compiler, git, CMake ${PMN_CMAKE_MIN_MAJOR}.${PMN_CMAKE_MIN_MINOR}+ (and clang-format/clang-tidy, optionally)."
+    fi
+
+    for id in $(_pmn_tools_ids); do
+        row="$(_pmn_row_cat "$id")"
+        [ -n "$row" ] && rows+=("$row")
+    done
+
+    # ---- report ----------------------------------------------------------
+    for row in ${rows[@]+"${rows[@]}"}; do
+        id="$(_pmn_field "$row" 1)"; kind="$(_pmn_field "$row" 2)"; label="$(_pmn_field "$row" 3)"
+        status="$(_pmn_tool_status "$id")"
+        detail="${status#* }"; [ "$detail" = "$status" ] && detail=""
+        case "${status%% *}" in
+            ok)
+                if [ -n "$detail" ]; then
+                    printf '    %s[ ok ]%s  %-30s %s%s%s\n' "$_PMN_GREEN" "$_PMN_RESET" "$label" "$_PMN_DIM" "$detail" "$_PMN_RESET"
+                else
+                    printf '    %s[ ok ]%s  %s\n' "$_PMN_GREEN" "$_PMN_RESET" "$label"
+                fi ;;
+            old)
+                printf '    %s[old ]%s  %-30s %s (needs %s.%s+)\n' "$_PMN_YELLOW" "$_PMN_RESET" "$label" "$detail" "$PMN_CMAKE_MIN_MAJOR" "$PMN_CMAKE_MIN_MINOR" ;;
+            partial)
+                printf '    %s[part]%s  %-30s %s%s%s\n' "$_PMN_YELLOW" "$_PMN_RESET" "$label" "$_PMN_DIM" "$detail" "$_PMN_RESET" ;;
+            *)
+                if [ "$kind" = required ]; then
+                    printf '    %s[ !! ]%s  %-30s missing (required)\n' "$_PMN_RED" "$_PMN_RESET" "$label"
+                else
+                    printf '    %s[ -- ]%s  %-30s missing (optional)\n' "$_PMN_DIM" "$_PMN_RESET" "$label"
+                fi ;;
+        esac
+    done
+    _pmn_arch_extra_notes
+
+    if [ "$PMN_TOOLS_CHECK" = 1 ]; then
+        for row in ${rows[@]+"${rows[@]}"}; do
+            id="$(_pmn_field "$row" 1)"
+            if [ "$(_pmn_field "$row" 2)" = required ] && [ "$(_pmn_tool_status "$id" | cut -d' ' -f1)" != ok ]; then
+                # brew is only "required" for what it installs; not a failure on its own if nothing needs it
+                [ "$id" = brew ] && continue
+                missing_required=1
+            fi
+        done
+        return "$missing_required"
+    fi
+
+    # ---- offer installs, one at a time -----------------------------------
+    local offered=0 skipped_optional=""
+    for row in ${rows[@]+"${rows[@]}"}; do
+        id="$(_pmn_field "$row" 1)"; kind="$(_pmn_field "$row" 2)"; label="$(_pmn_field "$row" 3)"
+        why="$(_pmn_field "$row" 4)"
+
+        # Re-check now: an earlier install may already have provided this
+        # one (dnf's clang-tools-extra is both clang-format and clang-tidy).
+        status="$(_pmn_tool_status "$id")"
+        if [ "${status%% *}" = ok ]; then continue; fi
+
+        if [ "$_PMN_ANS_QUIT" = 1 ]; then break; fi
+
+        # Everything through Homebrew needs Homebrew first.
+        if [ "$PMN_OS" = macos ] && [ "$id" != clt ] && [ "$id" != brew ] && [ "$PMN_PM" != brew ]; then
+            _pmn_say
+            _pmn_say "  ${_PMN_BOLD}${label}${_PMN_RESET} -- ${why}"
+            _pmn_note "    skipped: needs Homebrew, which isn't installed"
+            failed="$failed $id"
+            continue
+        fi
+        if [ "$PMN_OS" = linux ] && [ "$id" != brew ]; then
+            pkgs="$(_pmn_row_packages "$row")"
+            if [ "$PMN_PM" = none ] || [ -z "$pkgs" ]; then
+                continue    # nothing this package manager can do; already said so above
+            fi
+        fi
+
+        if [ "$kind" = optional ] && ! _pmn_optional_wanted; then
+            skipped_optional="${skipped_optional:+$skipped_optional, }$label"
+            continue
+        fi
+
+        offered=$((offered + 1))
+        _pmn_say
+        _pmn_say "  ${_PMN_BOLD}${label}${_PMN_RESET} -- ${why}"
+        if [ "${status%% *}" = old ]; then
+            _pmn_note "    (installed: ${status#* }, but too old)"
+        elif [ "${status%% *}" = partial ]; then
+            _pmn_note "    (already installed, but ${status#* })"
+        fi
+
+        if _pmn_confirm "$kind" "Install ${label}?"; then
+            if _pmn_install_row "$row"; then
+                status="$(_pmn_tool_status "$id")"
+                case "${status%% *}" in
+                    ok)  _pmn_say "    ${_PMN_GREEN}installed${_PMN_RESET}" ;;
+                    old) _pmn_cmake_too_old_help "${status#* }"; failed="$failed $id" ;;
+                    partial) _pmn_say "    ${_PMN_YELLOW}the install finished, but ${status#* }${_PMN_RESET} -- check the output above."
+                         failed="$failed $id" ;;
+                    *)   _pmn_say "    ${_PMN_YELLOW}the install finished, but ${label} still isn't on PATH${_PMN_RESET} -- open a new terminal, or check the output above."
+                         failed="$failed $id" ;;
+                esac
+            else
+                _pmn_say "    ${_PMN_RED}install failed${_PMN_RESET} -- see the output above."
+                failed="$failed $id"
+            fi
+        else
+            # Declined (or quit): nothing to echo back to someone who just
+            # typed it, but an optional one belongs in the closing summary.
+            if [ "$kind" = optional ]; then
+                skipped_optional="${skipped_optional:+$skipped_optional, }$label"
+            fi
+        fi
+    done
+    _pmn_offer_aur_arm32
+    if [ "$offered" -eq 0 ] && [ -z "$skipped_optional" ] && [ "$_PMN_ANS_QUIT" != 1 ]; then
+        _pmn_say "    Nothing to install."
+    fi
+    if [ -n "$skipped_optional" ]; then
+        local install_hint="--all installs them all"
+        [ "$PMN_PM" = pacman ] && install_hint="$install_hint; --everything also installs the AUR extras"
+        _pmn_say
+        _pmn_note "  Optional, not installed: ${skipped_optional}"
+        _pmn_note "  (breeze/scripts/setup.sh, run interactively, offers each one; ${install_hint}.)"
+    fi
+
+    # ---- final verdict ---------------------------------------------------
+    for row in ${rows[@]+"${rows[@]}"}; do
+        id="$(_pmn_field "$row" 1)"
+        if [ "$(_pmn_field "$row" 2)" = required ] && [ "$id" != brew ] \
+            && [ "$(_pmn_tool_status "$id" | cut -d' ' -f1)" != ok ]; then
+            missing_required=1
+            _pmn_say "  ${_PMN_RED}still missing (required):${_PMN_RESET} $(_pmn_field "$row" 3)"
+        fi
+    done
+    return "$missing_required"
+}
+
+# _pmn_tools_offer <id>: offer to install ONE catalog tool -- for callers that
+# find out mid-way that they need it (setup.sh, when there is no pinned Ninja
+# for this machine). Same prompt, same command display, same rules.
+_pmn_tools_offer() {
+    local id="$1" row status
+    _pmn_tools_detect
+    row="$(_pmn_row_cat "$id")"
+    [ -n "$row" ] || return 1
+    status="$(_pmn_tool_status "$id")"
+    [ "${status%% *}" = ok ] && return 0
+    if [ -z "$(_pmn_row_packages "$row")" ] || [ "$PMN_PM" = none ]; then
+        _pmn_say "    Install $(_pmn_field "$row" 3) yourself: $(_pmn_field "$row" 4)."
+        return 1
+    fi
+    _pmn_say
+    _pmn_say "  ${_PMN_BOLD}$(_pmn_field "$row" 3)${_PMN_RESET} -- $(_pmn_field "$row" 4)"
+    if _pmn_confirm "$(_pmn_field "$row" 2)" "Install $(_pmn_field "$row" 3)?"; then
+        if ! _pmn_install_row "$row"; then
+            _pmn_say "    ${_PMN_RED}install failed${_PMN_RESET} -- see the output above."
+            return 1
+        fi
+        if [ "$(_pmn_tool_status "$id" | cut -d' ' -f1)" = ok ]; then
+            _pmn_say "    ${_PMN_GREEN}installed${_PMN_RESET}"
+            return 0
+        fi
+        _pmn_say "    ${_PMN_YELLOW}the install finished, but $(_pmn_field "$row" 3) still isn't on PATH${_PMN_RESET} -- open a new terminal, or check the output above."
+        return 1
+    fi
+    return 1
+}
diff --git a/breeze/scripts/_winenv.bat b/breeze/scripts/_winenv.bat
new file mode 100644
index 0000000..f4792ee
--- /dev/null
+++ b/breeze/scripts/_winenv.bat
@@ -0,0 +1,318 @@
+@echo off
+REM Enters the compiler environment a Windows preset needs, in THIS cmd.exe
+REM session: what opening "x64 Native Tools Command Prompt for VS" or an MSYS2
+REM MINGW64 shell by hand does, without opening a window or leaving the
+REM console you are in.
+REM
+REM Not run directly -- breeze\scripts\build.bat calls it once the preset is known:
+REM   call "breeze\scripts\_winenv.bat" ^<preset^>
+REM It uses no SETLOCAL on purpose: the variables vcvarsall.bat sets (PATH,
+REM INCLUDE, LIB, ...) have to land in the CALLER's session. build.bat's own
+REM SETLOCAL discards them again when it ends, so nothing leaks into the
+REM prompt you started it from.
+REM
+REM   preset                                   environment entered
+REM   windows-x64-msvc, windows-arm64-msvc     the Visual Studio developer
+REM                                            prompt for that target
+REM                                            (vcvarsall.bat from the newest
+REM                                            Visual Studio or Build Tools
+REM                                            that has the C++ tools)
+REM   windows-x64-clang-cl,                    the same, plus clang-cl on PATH
+REM   windows-arm64-clang-cl                   if it is not already (LLVM's own
+REM                                            folder, else the copy Visual
+REM                                            Studio ships)
+REM   windows-x64-mingw64,                     MSYS2's mingw64\bin or
+REM   windows-x86-mingw32                      mingw32\bin first on PATH, unless
+REM                                            that compiler is already there
+REM   windows-x64-clang,                       MSYS2's clang64\bin or
+REM   windows-arm64-clang                      clangarm64\bin first on PATH --
+REM                                            always: a clang++ from anywhere
+REM                                            else targets a different ABI
+REM
+REM After entering a Visual Studio environment it checks that the target's runtime
+REM libraries exist (lib\TARGET\msvcrt.lib), and for arm64 picks the newest Visual
+REM Studio that has the ARM64 component: from an x64 machine that is the only way
+REM to build arm64, as a cross build, and without it the failure would only appear
+REM at CMake's compiler test. MSYS2 has no CLANGARM64 environment on an x64
+REM machine; windows-arm64-clang says so and points at the cross-building presets.
+REM
+REM Left alone: a shell that is already a developer prompt for the right
+REM architecture; any preset not listed (cmake reports an unknown one itself);
+REM and everything, when PMN_NO_ENV is set to anything -- for a toolchain this script does
+REM not know about, or a prompt you have set up yourself.
+REM MSYS2 is looked for in MSYS2_ROOT, else the msys64 folder on the system
+REM drive -- the same place breeze\scripts\setup.bat installs it.
+REM
+REM Exit status: 0 = ready, or nothing to do. 1 = the environment the preset
+REM needs is not available, after saying what to install.
+REM
+REM Flat on purpose: single-line IF and GOTO, no parenthesized blocks. The paths
+REM expanded here can contain "(x86)", and an unquoted close-paren ends a block
+REM early.
+
+if "%~1"=="" exit /b 0
+if defined PMN_NO_ENV exit /b 0
+
+set "_pmn_e_tgt="
+set "_pmn_e_llvm="
+set "_pmn_e_sub="
+set "_pmn_e_exe="
+set "_pmn_e_probe="
+set "_pmn_e_pkg="
+set "_pmn_e_vs="
+set "_pmn_e_arg="
+set "_pmn_e_need="
+
+if /i "%~1"=="windows-x64-msvc"       goto pick_msvc_x64
+if /i "%~1"=="windows-arm64-msvc"     goto pick_msvc_arm64
+if /i "%~1"=="windows-x64-clang-cl"   goto pick_clangcl_x64
+if /i "%~1"=="windows-arm64-clang-cl" goto pick_clangcl_arm64
+if /i "%~1"=="windows-x64-mingw64"    goto pick_mingw64
+if /i "%~1"=="windows-x86-mingw32"    goto pick_mingw32
+if /i "%~1"=="windows-x64-clang"      goto pick_clang64
+if /i "%~1"=="windows-arm64-clang"    goto pick_clangarm64
+goto env_ok
+
+:pick_msvc_x64
+set "_pmn_e_tgt=x64"
+goto run_vs
+:pick_msvc_arm64
+set "_pmn_e_tgt=arm64"
+goto run_vs
+:pick_clangcl_x64
+set "_pmn_e_tgt=x64"
+set "_pmn_e_llvm=1"
+goto run_vs
+:pick_clangcl_arm64
+set "_pmn_e_tgt=arm64"
+set "_pmn_e_llvm=1"
+goto run_vs
+:pick_mingw64
+set "_pmn_e_sub=mingw64"
+set "_pmn_e_exe=g++.exe"
+set "_pmn_e_probe=x86_64-w64-mingw32-g++"
+set "_pmn_e_pkg=mingw-w64-x86_64-gcc"
+goto run_msys
+:pick_mingw32
+set "_pmn_e_sub=mingw32"
+set "_pmn_e_exe=g++.exe"
+set "_pmn_e_probe=i686-w64-mingw32-g++"
+set "_pmn_e_pkg=mingw-w64-i686-gcc"
+goto run_msys
+:pick_clang64
+set "_pmn_e_sub=clang64"
+set "_pmn_e_exe=clang++.exe"
+set "_pmn_e_pkg=mingw-w64-clang-x86_64-clang"
+goto run_msys
+:pick_clangarm64
+set "_pmn_e_sub=clangarm64"
+set "_pmn_e_exe=clang++.exe"
+set "_pmn_e_pkg=mingw-w64-clang-aarch64-clang"
+goto run_msys
+
+REM ---------------------------------------------------------------------
+REM Visual Studio: msvc and clang-cl presets
+REM ---------------------------------------------------------------------
+:run_vs
+if not defined VSCMD_VER goto vs_find
+if /i "%VSCMD_ARG_TGT_ARCH%"=="%_pmn_e_tgt%" goto vs_have
+goto vs_find
+
+:vs_have
+where cl >nul 2>nul
+if errorlevel 1 goto vs_find
+if defined VSINSTALLDIR set "_pmn_e_vs=%VSINSTALLDIR%"
+goto vs_verify
+
+:vs_find
+set "_pmn_e_vs="
+set "_pmn_e_vswhere=%ProgramFiles(x86)%\Microsoft Visual Studio\Installer\vswhere.exe"
+if not exist "%_pmn_e_vswhere%" goto vs_missing
+
+REM Which component provides the target's compilers and libraries: the x86/x64
+REM tools for x64, and for arm64 the ARM64 tools too -- an x64 machine reaches
+REM arm64 through them (a cross build), and an ARM64 machine builds natively.
+REM The newest install that has what the target needs wins, so an older Visual
+REM Studio that has it beats a newer one that does not.
+set "_pmn_e_need=Microsoft.VisualStudio.Component.VC.Tools.x86.x64"
+if /i "%_pmn_e_tgt%"=="arm64" set "_pmn_e_need=Microsoft.VisualStudio.Component.VC.Tools.x86.x64 Microsoft.VisualStudio.Component.VC.Tools.ARM64"
+for /f "usebackq delims=" %%I in (`"%_pmn_e_vswhere%" -latest -products * -requires %_pmn_e_need% -property installationPath`) do set "_pmn_e_vs=%%I"
+if defined _pmn_e_vs goto vs_have_install
+
+REM None has it. Is there a Visual Studio with C++ at all? Then it is only the
+REM target's component that is missing, which has its own message.
+for /f "usebackq delims=" %%I in (`"%_pmn_e_vswhere%" -latest -products * -requires Microsoft.VisualStudio.Component.VC.Tools.x86.x64 -property installationPath`) do set "_pmn_e_vs=%%I"
+if not defined _pmn_e_vs goto vs_missing
+goto vs_target_missing
+
+:vs_have_install
+set "_pmn_e_vcvars=%_pmn_e_vs%\VC\Auxiliary\Build\vcvarsall.bat"
+if not exist "%_pmn_e_vcvars%" goto vs_missing
+
+REM vcvarsall's argument is HOST_TARGET, or just TARGET when the two match.
+set "_pmn_e_host=%PROCESSOR_ARCHITECTURE%"
+if defined PROCESSOR_ARCHITEW6432 set "_pmn_e_host=%PROCESSOR_ARCHITEW6432%"
+if /i "%_pmn_e_host%"=="AMD64" goto vs_arg_amd64
+if /i "%_pmn_e_host%"=="ARM64" goto vs_arg_arm64
+set "_pmn_e_arg=x86_%_pmn_e_tgt%"
+goto vs_enter
+:vs_arg_amd64
+if /i "%_pmn_e_tgt%"=="x64" set "_pmn_e_arg=x64"
+if /i "%_pmn_e_tgt%"=="arm64" set "_pmn_e_arg=x64_arm64"
+goto vs_enter
+:vs_arg_arm64
+if /i "%_pmn_e_tgt%"=="x64" set "_pmn_e_arg=arm64_x64"
+if /i "%_pmn_e_tgt%"=="arm64" set "_pmn_e_arg=arm64"
+goto vs_enter
+
+REM Success is judged by what vcvarsall left behind -- the target it reports
+REM and a cl on PATH, which is what the build needs -- not by its exit status.
+:vs_enter
+set "VSCMD_SKIP_SENDTELEMETRY=1"
+echo ==^> Environment: Visual Studio developer prompt for %_pmn_e_tgt% ^(vcvarsall %_pmn_e_arg%^)
+call "%_pmn_e_vcvars%" %_pmn_e_arg% >"%TEMP%\pmn-vcvarsall.log" 2>&1
+if /i "%VSCMD_ARG_TGT_ARCH%"=="%_pmn_e_tgt%" goto vs_check_cl
+goto vs_failed
+:vs_check_cl
+where cl >nul 2>nul
+if errorlevel 1 goto vs_failed
+if not defined VCToolsInstallDir goto vs_failed
+goto vs_verify
+
+REM The target's runtime libraries must exist: with the target's component
+REM missing, vcvarsall can still report the target and leave a cl on PATH (the
+REM host's x64 one), and the failure only shows up at CMake's compiler test as
+REM "cannot open msvcrt.lib". This catches it first, with the fix.
+:vs_verify
+if not defined VCToolsInstallDir goto vs_after
+if exist "%VCToolsInstallDir%lib\%_pmn_e_tgt%\msvcrt.lib" goto vs_after
+goto vs_target_missing
+
+:vs_after
+del "%TEMP%\pmn-vcvarsall.log" >nul 2>nul
+if not "%_pmn_e_llvm%"=="1" goto env_ok
+where clang-cl >nul 2>nul
+if not errorlevel 1 goto env_ok
+set "_pmn_e_pf=%ProgramW6432%"
+if not defined _pmn_e_pf set "_pmn_e_pf=%ProgramFiles%"
+if exist "%_pmn_e_pf%\LLVM\bin\clang-cl.exe" goto llvm_standalone
+if not defined _pmn_e_vs goto llvm_missing
+if exist "%_pmn_e_vs%\VC\Tools\Llvm\x64\bin\clang-cl.exe" goto llvm_vs_x64
+if exist "%_pmn_e_vs%\VC\Tools\Llvm\ARM64\bin\clang-cl.exe" goto llvm_vs_arm64
+if exist "%_pmn_e_vs%\VC\Tools\Llvm\bin\clang-cl.exe" goto llvm_vs_x86
+goto llvm_missing
+
+:llvm_standalone
+set "PATH=%_pmn_e_pf%\LLVM\bin;%PATH%"
+echo ==^> Environment: clang-cl from %_pmn_e_pf%\LLVM\bin
+goto env_ok
+:llvm_vs_x64
+set "PATH=%_pmn_e_vs%\VC\Tools\Llvm\x64\bin;%PATH%"
+echo ==^> Environment: clang-cl from Visual Studio ^(VC\Tools\Llvm\x64\bin^)
+goto env_ok
+:llvm_vs_arm64
+set "PATH=%_pmn_e_vs%\VC\Tools\Llvm\ARM64\bin;%PATH%"
+echo ==^> Environment: clang-cl from Visual Studio ^(VC\Tools\Llvm\ARM64\bin^)
+goto env_ok
+:llvm_vs_x86
+set "PATH=%_pmn_e_vs%\VC\Tools\Llvm\bin;%PATH%"
+echo ==^> Environment: clang-cl from Visual Studio ^(VC\Tools\Llvm\bin^)
+goto env_ok
+
+:llvm_missing
+echo error: preset %~1 needs clang-cl, and none was found on PATH, in %_pmn_e_pf%\LLVM\bin or in Visual Studio. 1>&2
+echo        Run breeze\scripts\setup.bat to install LLVM, or:  winget install LLVM.LLVM 1>&2
+goto env_fail
+
+:vs_missing
+echo error: preset %~1 needs Visual Studio or Build Tools with the C++ tools ^(workload "Desktop development with C++"^), and none was found. 1>&2
+echo        Run breeze\scripts\setup.bat to install it. If you use a Visual Studio this script cannot find, open its 1>&2
+echo        developer prompt for %_pmn_e_tgt% yourself and set PMN_NO_ENV=1. 1>&2
+if /i "%_pmn_e_tgt%"=="arm64" echo        For ARM64 targets add the "MSVC ARM64 build tools" component in the Visual Studio Installer. 1>&2
+goto env_fail
+
+:vs_target_missing
+echo error: preset %~1 needs the MSVC tools and libraries for %_pmn_e_tgt%, and the Visual Studio install here does not have them. 1>&2
+if defined VCToolsInstallDir echo        %VCToolsInstallDir%lib\%_pmn_e_tgt%\msvcrt.lib is missing. 1>&2
+if exist "%TEMP%\pmn-vcvarsall.log" type "%TEMP%\pmn-vcvarsall.log" 1>&2
+if /i "%_pmn_e_tgt%"=="arm64" goto vs_target_missing_arm64
+echo        Add the component "MSVC ... C++ x64/x86 build tools (Latest)" in the Visual Studio Installer ^(Modify, Individual components^). 1>&2
+goto env_fail
+:vs_target_missing_arm64
+echo        Building for ARM64 -- from an x64 machine that is a cross build -- needs the component 1>&2
+echo        "MSVC ... C++ ARM64/ARM64EC build tools (Latest)". Run breeze\scripts\setup.bat, which offers to add it, or add it in the 1>&2
+echo        Visual Studio Installer: Modify, Individual components, search for ARM64. 1>&2
+goto env_fail
+
+:vs_failed
+echo error: could not enter the Visual Studio environment for %_pmn_e_tgt% ^(vcvarsall %_pmn_e_arg%^). Its output: 1>&2
+if exist "%TEMP%\pmn-vcvarsall.log" type "%TEMP%\pmn-vcvarsall.log" 1>&2
+echo        If this shell is already a developer prompt for another architecture, open a fresh one. 1>&2
+if /i "%_pmn_e_tgt%"=="arm64" echo        ARM64 targets need the "MSVC ARM64 build tools" component of Visual Studio. 1>&2
+goto env_fail
+
+REM ---------------------------------------------------------------------
+REM MSYS2: mingw and clang presets
+REM ---------------------------------------------------------------------
+:run_msys
+set "_pmn_e_root=%MSYS2_ROOT%"
+if not defined _pmn_e_root set "_pmn_e_root=%SystemDrive%\msys64"
+if not defined _pmn_e_probe goto msys_enter
+where %_pmn_e_probe% >nul 2>nul
+if not errorlevel 1 goto env_ok
+
+:msys_enter
+if not exist "%_pmn_e_root%\%_pmn_e_sub%\bin\%_pmn_e_exe%" goto msys_missing
+set "PATH=%_pmn_e_root%\%_pmn_e_sub%\bin;%PATH%"
+echo ==^> Environment: MSYS2 %_pmn_e_sub% ^(%_pmn_e_root%\%_pmn_e_sub%\bin first on PATH^)
+goto env_ok
+
+:msys_missing
+if /i "%_pmn_e_sub%"=="clangarm64" goto msys_missing_arm
+goto msys_missing_pkg
+
+REM MSYS2 has a CLANGARM64 environment only on ARM64 Windows; on an x64 machine
+REM there is nothing to install, so say what to use instead.
+:msys_missing_arm
+set "_pmn_e_host=%PROCESSOR_ARCHITECTURE%"
+if defined PROCESSOR_ARCHITEW6432 set "_pmn_e_host=%PROCESSOR_ARCHITEW6432%"
+if /i "%_pmn_e_host%"=="ARM64" goto msys_missing_pkg
+echo error: preset %~1 needs MSYS2's CLANGARM64 environment, which MSYS2 provides only on ARM64 Windows ^(this machine is %_pmn_e_host%^). 1>&2
+echo        To build for Windows ARM64 from here use windows-arm64-clang-cl or windows-arm64-msvc: they cross-compile 1>&2
+echo        with Visual Studio's ARM64 build tools ^(breeze\scripts\setup.bat offers to add them^). 1>&2
+goto env_fail
+
+:msys_missing_pkg
+echo error: preset %~1 needs MSYS2's %_pmn_e_sub% toolchain, and %_pmn_e_root%\%_pmn_e_sub%\bin\%_pmn_e_exe% was not found. 1>&2
+echo        Run breeze\scripts\setup.bat to install it, or in an MSYS2 shell:  pacman -S %_pmn_e_pkg% 1>&2
+echo        MSYS2 itself:  winget install MSYS2.MSYS2   ^(set MSYS2_ROOT if it lives somewhere other than the msys64 folder on the system drive^) 1>&2
+goto env_fail
+
+REM ---------------------------------------------------------------------
+REM Exits. Every path out goes through one of these two, which clear the
+REM scratch variables this script made (all start with _pmn_e_).
+REM ---------------------------------------------------------------------
+:env_ok
+call :clear
+exit /b 0
+
+:env_fail
+call :clear
+exit /b 1
+
+:clear
+set "_pmn_e_tgt="
+set "_pmn_e_llvm="
+set "_pmn_e_sub="
+set "_pmn_e_exe="
+set "_pmn_e_probe="
+set "_pmn_e_pkg="
+set "_pmn_e_vs="
+set "_pmn_e_arg="
+set "_pmn_e_vswhere="
+set "_pmn_e_vcvars="
+set "_pmn_e_need="
+set "_pmn_e_host="
+set "_pmn_e_pf="
+set "_pmn_e_root="
+goto :eof
diff --git a/breeze/scripts/build.bat b/breeze/scripts/build.bat
new file mode 100644
index 0000000..b21be87
--- /dev/null
+++ b/breeze/scripts/build.bat
@@ -0,0 +1,383 @@
+@echo off
+REM Configure (if needed) and build the project, preferably with Ninja.
+REM
+REM Usage (from the project root):
+REM   breeze\scripts\build.bat [--preset ^<name^>] [BUILD_TYPE] [CMAKE_ARGS...]
+REM   breeze\scripts\build.bat --list-presets
+REM   breeze\scripts\build.bat --help
+REM
+REM   --preset <name>  Use a CMakePresets.json preset. A preset selects that
+REM                    target's toolchain file (breeze\cmake\toolchains\<name>.cmake),
+REM                    which picks the compiler and declares the DIST_TARGET
+REM                    together, instead of you having to pass a matching
+REM                    pair by hand:
+REM                      breeze\scripts\build.bat --preset windows-x64-mingw64
+REM                    Each preset builds in its own directory,
+REM                    out\build\<name>, so switching between presets never
+REM                    invalidates -- or deletes -- another one's build.
+REM                    Run --list-presets to see every preset for your OS.
+REM                    Must come first if given at all; --preset=<name>
+REM                    also works. Given with no value (or a value that
+REM                    looks like another flag), this fails fast with that
+REM                    same preset list shown right there. A value that IS
+REM                    given but isn't a real preset name is instead
+REM                    caught by cmake itself failing to configure, at
+REM                    which point this script shows the preset list too
+REM                    -- see the "configure" step below.
+REM   BUILD_TYPE       Debug^|Release^|RelWithDebInfo^|MinSizeRel
+REM                    (default: project/Configuration.cmake's DEFAULT_BUILD_TYPE)
+REM   CMAKE_ARGS       Anything else is forwarded to `cmake` verbatim, e.g.:
+REM                      breeze\scripts\build.bat --preset windows-x64-mingw64 Debug -DBUILD_TESTS=ON
+REM                      breeze\scripts\build.bat -DBUILD_TESTS=ON
+REM                                (BUILD_TYPE omitted -- recognized by not
+REM                                starting with "-")
+REM
+REM Picking a DIST_TARGET: three ways; the first two set the compiler and the
+REM label together, and this script rejects mixing --preset with a
+REM -DDIST_TARGET rather than leaving it ambiguous which one wins.
+REM   1. --preset <name>       The recommended way; see --list-presets.
+REM   2. -DCMAKE_TOOLCHAIN_FILE=breeze\cmake\toolchains\<name>.cmake
+REM      (no --preset)         What a preset does, by hand, as one of
+REM                            CMAKE_ARGS above.
+REM   3. -DDIST_TARGET=<value> Sets the label alone, as one of CMAKE_ARGS
+REM      (no --preset)         above. Without also passing a matching
+REM                            compiler (or, better, the toolchain file
+REM                            above), DIST_TARGET is auto-detected from
+REM                            whatever compiler CMake finds on its own; if
+REM                            the two disagree, TargetSelection.cmake
+REM                            FATAL_ERRORs rather than silently building
+REM                            the wrong toolchain and mislabeling the
+REM                            result -- see that file and the README.
+REM Passing --preset together with an explicit -DDIST_TARGET=... in
+REM CMAKE_ARGS is rejected by this script before cmake even runs: the
+REM preset's toolchain already declares DIST_TARGET, so a second value
+REM alongside it is always either redundant or contradictory -- never
+REM useful.
+REM
+REM cmd.exe splits %1, %2, ... (and SHIFT) on space, comma, semicolon, AND
+REM "=" -- type "-DFOO=BAR" as an argument and it arrives as TWO separate
+REM parameters, %1=-DFOO %2=BAR, silently, with no way to tell after the
+REM fact. This script never reads a "="-laden argument (or --preset's own
+REM value) through %1 or SHIFT; everything is peeled off of the raw,
+REM unsplit %* instead using FOR /F (which only ever splits on space/tab),
+REM so "=" survives intact -- see the parsing block below. (bash's
+REM "$@"/shift has no such bug -- see build.sh for that half of this same
+REM feature.)
+REM
+REM Compiler environment: for a Windows preset (windows-*-msvc, -clang-cl,
+REM -mingw* and -clang) this script first enters the environment that preset's
+REM compiler needs, for this run only: the Visual Studio developer prompt for the
+REM preset's target (vcvarsall.bat), or MSYS2's toolchain folder first on PATH. So
+REM it works from any prompt -- no need to open the x64 Native Tools Command
+REM Prompt for VS or an MSYS2 shell first. A prompt that is already right is left alone;
+REM set PMN_NO_ENV=1 to skip all of this and use your shell as it is. See
+REM _winenv.bat for exactly what it does.
+REM
+REM Build directory: out\build\<preset> for --preset <preset>; without a
+REM preset, out\build\default (the compiler is auto-detected there, so keep
+REM to one compiler per directory or use presets). Set BUILD_DIR to use an
+REM exact directory of your own instead. breeze\scripts\run.bat, install.bat and
+REM docs.bat use the directory built last, or --preset <name> to pick another.
+setlocal enabledelayedexpansion
+
+REM -h/--help is checked here, off the raw %1, before anything else --
+REM including whether cmake is even on PATH below -- since help shouldn't
+REM depend on that.
+if /i "%~1"=="-h" goto show_help
+if /i "%~1"=="--help" goto show_help
+goto after_help
+
+:show_help
+echo Usage: breeze\scripts\build.bat [--preset ^<name^>] [BUILD_TYPE] [CMAKE_ARGS...]
+echo        breeze\scripts\build.bat --list-presets
+echo        breeze\scripts\build.bat --help
+echo.
+echo   --preset ^<name^>  Use a CMakePresets.json preset: it selects the target's
+echo                     toolchain file ^(compiler and DIST_TARGET together^) and
+echo                     builds in its own directory, out\build\^<name^>. Must come
+echo                     first if given at all; --preset=^<name^> also works. Run
+echo                     --list-presets to see every preset for your OS.
+echo   BUILD_TYPE        Debug^|Release^|RelWithDebInfo^|MinSizeRel
+echo                     ^(default: project/Configuration.cmake's DEFAULT_BUILD_TYPE^)
+echo   CMAKE_ARGS        Anything else is forwarded to `cmake` verbatim, e.g.
+echo                     -DDIST_TARGET=^<value^> or -DBUILD_TESTS=ON.
+echo.
+echo Windows presets: the compiler's environment ^(the Visual Studio developer prompt
+echo                     for the target, or MSYS2's toolchain folder^) is entered for you,
+echo                     for this run only -- no special prompt needed first. Set
+echo                     PMN_NO_ENV=1 to use your shell as it is.
+echo.
+echo Don't combine --preset with an explicit -DDIST_TARGET=... in CMAKE_ARGS --
+echo the preset's toolchain already declares one; see the comment at the top of
+echo this script ^(breeze\scripts\build.bat^) and TargetSelection.cmake's "Target selection"
+echo section for why picking a DIST_TARGET is one or the other, not both.
+echo.
+echo Examples:
+echo   breeze\scripts\build.bat --preset linux-x64-clang
+echo   breeze\scripts\build.bat --preset windows-x64-mingw64 Debug -DBUILD_TESTS=ON
+echo   breeze\scripts\build.bat -DBUILD_TESTS=ON
+exit /b 0
+
+:after_help
+cd /d "%~dp0..\.."
+
+REM An explicit BUILD_DIR from the environment beats the one-directory-per-
+REM preset layout resolved below, and is then also not recorded as "the
+REM build made last" (run/install/docs would otherwise be sent to a
+REM directory the layout doesn't know about).
+set "_pmn_record_build=1"
+if not "%BUILD_DIR%"=="" set "_pmn_record_build=0"
+
+where cmake >nul 2>nul
+if errorlevel 1 (
+    echo error: cmake not found on PATH.
+    exit /b 1
+)
+
+REM Which cmake the user's PATH resolves to, so it can be put back in front after
+REM a Visual Studio environment is entered below: that puts Visual Studio's own
+REM cmake -- often an older one -- ahead of it.
+set "_pmn_cmake_dir="
+for /f "delims=" %%C in ('where cmake') do if not defined _pmn_cmake_dir set "_pmn_cmake_dir=%%~dpC"
+
+REM See the header comment above for why this doesn't use %1/SHIFT.
+set "ALL_ARGS=%*"
+set "PRESET="
+set "BUILD_TYPE="
+set "EXTRA_ARGS="
+if not defined ALL_ARGS goto args_done
+
+for /f "tokens=1,* delims= " %%A in ("%ALL_ARGS%") do (
+    set "_FIRST=%%A"
+    set "_REST=%%B"
+)
+
+if /i "%_FIRST%"=="--list-presets" (
+    cmake --list-presets
+    exit /b !ERRORLEVEL!
+)
+if /i "%_FIRST%"=="--preset" goto preset_space_form
+if /i "%_FIRST:~0,9%"=="--preset=" goto preset_equals_form
+goto no_preset
+
+:preset_space_form
+if not defined _REST (
+    echo error: --preset requires a value, e.g. --preset windows-x64-mingw64
+    echo.
+    cmake --list-presets
+    exit /b 1
+)
+for /f "tokens=1,* delims= " %%A in ("%_REST%") do (
+    set "PRESET=%%A"
+    set "_REST=%%B"
+)
+if "%PRESET:~0,1%"=="-" (
+    echo error: --preset requires a value, e.g. --preset windows-x64-mingw64
+    echo.
+    cmake --list-presets
+    exit /b 1
+)
+goto have_preset
+
+:preset_equals_form
+set "PRESET=%_FIRST:~9%"
+if not defined PRESET (
+    echo error: --preset= requires a value, e.g. --preset=windows-x64-mingw64
+    echo.
+    cmake --list-presets
+    exit /b 1
+)
+goto have_preset
+
+:have_preset
+set "ALL_ARGS=%_REST%"
+if not defined ALL_ARGS goto args_done
+for /f "tokens=1,* delims= " %%A in ("%ALL_ARGS%") do (
+    set "_FIRST=%%A"
+    set "_REST=%%B"
+)
+
+:no_preset
+if "%_FIRST:~0,1%"=="-" (
+    set "EXTRA_ARGS=%ALL_ARGS%"
+) else (
+    set "BUILD_TYPE=%_FIRST%"
+    set "EXTRA_ARGS=%_REST%"
+)
+
+:args_done
+if "%BUILD_TYPE%"=="" call :read_config DEFAULT_BUILD_TYPE BUILD_TYPE
+if "%TOOLCACHE_DIR%"=="" call :read_config TOOLCACHE_DIR TOOLCACHE_DIR
+
+REM One build directory per preset (out\build\<preset>; "default" when no
+REM preset was given), so switching presets never has to reuse -- or wipe -- a
+REM directory configured for another compiler. breeze\cmake\BuildDir.cmake owns the
+REM layout (project/Configuration.cmake's BUILD_OUTPUT_DIR); goto rather than an
+REM if-block for the reason given further down about nesting.
+set "_pmn_name=default"
+if defined PRESET set "_pmn_name=%PRESET%"
+if not "%BUILD_DIR%"=="" goto build_dir_known
+call :resolve_build_dir "%_pmn_name%" BUILD_DIR
+if errorlevel 1 exit /b 1
+:build_dir_known
+
+REM Combining --preset with an explicit -DDIST_TARGET=... in CMAKE_ARGS is
+REM ambiguous (the preset already sets one) -- caught here, before cmake
+REM ever runs, rather than leaving it to whichever of the two CMake
+REM happens to prefer. findstr's /C: does a literal (non-regex) substring
+REM search, which sidesteps cmd.exe's own "=" splitting quirk (see the
+REM header comment) entirely -- there's no argument-parsing involved here,
+REM just a plain string search over EXTRA_ARGS as already assembled.
+if defined PRESET (
+    echo %EXTRA_ARGS%| findstr /C:"-DDIST_TARGET=" >nul
+    if not errorlevel 1 (
+        echo error: both --preset %PRESET% and an explicit -DDIST_TARGET=... were given.
+        echo        A preset's toolchain already declares DIST_TARGET ^(and picks the compiler^) -- pick one:
+        echo          breeze\scripts\build.bat --preset %PRESET%
+        echo          breeze\scripts\build.bat -DCMAKE_TOOLCHAIN_FILE=breeze\cmake\toolchains\^<target^>.cmake
+        echo        See the comment at the top of this script, or TargetSelection.cmake's
+        echo        "Target selection" section, for why these two aren't combined.
+        exit /b 1
+    )
+)
+
+REM Prefer a pinned ninja (fetched by breeze\scripts\setup.bat -- see
+REM breeze\cmake\FetchNinja.cmake) over a system one, same "always the pinned
+REM copy" preference as Doxygen. Needed whether or not --preset is used:
+REM every preset sets its generator to Ninja but doesn't hardcode which
+REM ninja binary to use (that would just be TOOLCACHE_DIR's default
+REM duplicated a third time -- see project/Configuration.cmake) --
+REM CMAKE_MAKE_PROGRAM supplies it either way; only -G Ninja itself is
+REM skipped below when a preset already sets the generator.
+REM
+REM Deliberately goto-based, and deliberately `pushd` + a bare wildcard
+REM rather than `for /d %%D in ("path\*")` -- both tested directly; a
+REM path-prefixed wildcard didn't match here, this form does, and it also
+REM sidesteps nesting a FOR loop inside an if/else block, which
+REM separately corrupts cmd.exe's paren-matching for the enclosing block
+REM (see breeze\scripts\refactor.bat for that one).
+set "NINJA_BIN="
+if not exist "%TOOLCACHE_DIR%" goto check_system_ninja
+
+pushd "%TOOLCACHE_DIR%"
+for /d %%D in (ninja-*) do if exist "%%D\ninja.exe" if not defined NINJA_BIN set "NINJA_BIN=%%~fD\ninja.exe"
+popd
+
+if defined NINJA_BIN goto have_pinned_ninja
+
+:check_system_ninja
+where ninja >nul 2>nul
+if errorlevel 1 goto no_ninja
+echo ==^> Using system ninja
+if not defined PRESET set "GENERATOR_ARGS=-G Ninja"
+goto configure
+
+:have_pinned_ninja
+echo ==^> Using pinned ninja: %NINJA_BIN%
+if defined PRESET (
+    set "GENERATOR_ARGS=-DCMAKE_MAKE_PROGRAM=%NINJA_BIN%"
+) else (
+    set "GENERATOR_ARGS=-G Ninja -DCMAKE_MAKE_PROGRAM=%NINJA_BIN%"
+)
+goto configure
+
+:no_ninja
+if defined PRESET (
+    echo warning: ninja not found ^(no pinned copy, none on PATH^) -- the '%PRESET%'
+    echo          preset requires it; configure will likely fail. Run
+    echo          breeze\scripts\setup.bat to fetch a pinned ninja, or install ninja
+    echo          yourself.
+) else (
+    echo warning: ninja not found ^(no pinned copy, none on PATH^) -- falling back to
+    echo          CMake's default generator for this platform. Run breeze\scripts\setup.bat
+    echo          to fetch a pinned ninja, or install ninja yourself, for a faster
+    echo          and more consistent build. Continuing without it.
+)
+set "GENERATOR_ARGS="
+
+:configure
+if not defined PRESET goto configure_env_done
+call "%~dp0_winenv.bat" "%PRESET%"
+if errorlevel 1 exit /b 1
+if defined _pmn_cmake_dir set "PATH=%_pmn_cmake_dir%;%PATH%"
+:configure_env_done
+echo ==^> Configuring (%BUILD_TYPE%) into %BUILD_DIR%\
+if defined PRESET echo     Preset: %PRESET%
+if defined EXTRA_ARGS echo     Extra CMake arguments: %EXTRA_ARGS%
+if defined PRESET (
+    cmake --preset %PRESET% -S . -B "%BUILD_DIR%" %GENERATOR_ARGS% -DCMAKE_BUILD_TYPE=%BUILD_TYPE% %EXTRA_ARGS%
+) else (
+    cmake %GENERATOR_ARGS% -S . -B "%BUILD_DIR%" -DCMAKE_BUILD_TYPE=%BUILD_TYPE% %EXTRA_ARGS%
+)
+if errorlevel 1 (
+    if defined PRESET (
+        echo.
+        echo error: configuring with preset '%PRESET%' failed -- see the cmake output above.
+        echo        If '%PRESET%' isn't the preset name you meant, here is what --list-presets
+        echo        shows for this OS:
+        echo.
+        cmake --list-presets
+    )
+    exit /b 1
+)
+
+REM Configure succeeded: this is now the build the other scripts default to.
+if "%_pmn_record_build%"=="1" cmake "-DPMN_NAME=%_pmn_name%" -DPMN_RECORD=ON -P breeze\cmake\BuildDir.cmake >nul
+
+echo ==^> Building
+cmake --build "%BUILD_DIR%"
+if errorlevel 1 exit /b 1
+
+echo ==^> Done. Run a module with:  breeze\scripts\run.bat ^<target-name^>
+exit /b 0
+
+REM ---------------------------------------------------------------------
+REM :read_config <ConfigurationVarName> <LocalVarName>
+REM
+REM Reads one value out of project/Configuration.cmake -- this project's single
+REM source of truth -- via breeze\cmake\PrintConfig.cmake, instead of hardcoding
+REM a second copy of a default that can silently drift out of sync, and
+REM stores it into %2 in the CALLER's scope. See breeze\cmake\PrintConfig.cmake
+REM for exactly what's being stripped off of its output below.
+REM ---------------------------------------------------------------------
+:read_config
+setlocal
+set "_pmn_line="
+for /f "usebackq delims=" %%V in (`cmake "-DPRINT_VARS=%~1" -P breeze\cmake\PrintConfig.cmake`) do set "_pmn_line=%%V"
+for /f "tokens=1,* delims==" %%A in ("%_pmn_line%") do set "_pmn_value=%%B"
+endlocal & set "%~2=%_pmn_value%"
+goto :eof
+
+REM ---------------------------------------------------------------------
+REM :resolve_build_dir <name-or-empty> <LocalVarName> [quiet]
+REM
+REM Asks breeze\cmake\BuildDir.cmake which build directory to use -- %1 is a preset
+REM name, or "default"; empty means "discover one" (the build made last, or
+REM the only one) -- and stores it into %2 in the CALLER's scope, with
+REM backslashes. Same shape as :read_config above, and the same
+REM `cmake -P` one-line-answer protocol: "-- BUILD_DIR=<path>" or
+REM "-- ERROR=<text>" (see that file). On failure it prints the reason to
+REM stderr, unless a third argument "quiet" is given, and returns errorlevel 1.
+REM ---------------------------------------------------------------------
+:resolve_build_dir
+setlocal
+set "_pmn_key="
+set "_pmn_val="
+for /f "usebackq tokens=1,* delims==" %%A in (`cmake "-DPMN_NAME=%~1" -P breeze\cmake\BuildDir.cmake`) do (
+    set "_pmn_key=%%A"
+    set "_pmn_val=%%B"
+)
+if "%_pmn_key%"=="-- BUILD_DIR" if defined _pmn_val goto resolve_ok
+if /i "%~3"=="quiet" goto resolve_failed
+if defined _pmn_val (
+    echo error: %_pmn_val% 1>&2
+) else (
+    echo error: breeze\cmake\BuildDir.cmake did not answer. 1>&2
+)
+:resolve_failed
+endlocal
+exit /b 1
+
+:resolve_ok
+endlocal & set "%~2=%_pmn_val:/=\%"
+goto :eof
diff --git a/breeze/scripts/build.sh b/breeze/scripts/build.sh
new file mode 100644
index 0000000..d693365
--- /dev/null
+++ b/breeze/scripts/build.sh
@@ -0,0 +1,289 @@
+#!/usr/bin/env bash
+# Configure (if needed) and build the project, preferably with Ninja.
+#
+# Usage (from the project root):
+#   breeze/scripts/build.sh [--preset <name>] [BUILD_TYPE] [CMAKE_ARGS...]
+#   breeze/scripts/build.sh --list-presets
+#   breeze/scripts/build.sh --help
+#
+#   --preset <name>  Use a CMakePresets.json preset. A preset selects that
+#                    target's toolchain file (breeze/cmake/toolchains/<name>.cmake),
+#                    which picks the compiler and declares the DIST_TARGET
+#                    together, instead of you having to pass a matching
+#                    pair by hand:
+#                      breeze/scripts/build.sh --preset windows-x64-mingw64
+#                    Each preset builds in its own directory,
+#                    out/build/<name>, so switching between presets never
+#                    invalidates -- or deletes -- another one's build.
+#                    Run --list-presets to see every preset for your OS.
+#                    Must come first if given at all; --preset=<name> also
+#                    works. Given with no value, or a value that isn't one
+#                    of --list-presets' own, this fails fast with that
+#                    same preset list shown right there, rather than
+#                    letting a typo fall through to a less obvious `cmake`
+#                    error further down.
+#   BUILD_TYPE       Debug|Release|RelWithDebInfo|MinSizeRel
+#                    (default: project/Configuration.cmake's DEFAULT_BUILD_TYPE)
+#   CMAKE_ARGS       Anything else is forwarded to `cmake` verbatim, e.g.:
+#                      breeze/scripts/build.sh --preset windows-x64-mingw64 Debug -DBUILD_TESTS=ON
+#                      breeze/scripts/build.sh -DBUILD_TESTS=ON
+#                                (BUILD_TYPE omitted -- recognized by not
+#                                starting with "-")
+#
+# Picking a DIST_TARGET: three ways; the first two set the compiler and the
+# label together, and this script rejects mixing --preset with a
+# -DDIST_TARGET rather than leaving it ambiguous which one wins.
+#   1. --preset <name>       The recommended way; see --list-presets.
+#   2. -DCMAKE_TOOLCHAIN_FILE=breeze/cmake/toolchains/<name>.cmake
+#      (no --preset)         What a preset does, by hand, as one of
+#                             CMAKE_ARGS above.
+#   3. -DDIST_TARGET=<value> Sets the label alone, as one of CMAKE_ARGS
+#      (no --preset)         above. Without also passing a matching
+#                             compiler (or, better, the toolchain file
+#                             above), DIST_TARGET is auto-detected from
+#                             whatever compiler CMake finds on its own; if
+#                             the two disagree, TargetSelection.cmake
+#                             FATAL_ERRORs rather than silently building
+#                             the wrong toolchain and mislabeling the
+#                             result -- see that file and the README.
+# Passing --preset together with an explicit -DDIST_TARGET=... in
+# CMAKE_ARGS is rejected by this script before cmake even runs: the
+# preset's toolchain already declares DIST_TARGET, so a second value
+# alongside it is always either redundant (same value) or contradictory
+# (different value) -- never useful.
+#
+# Build directory: out/build/<preset> for --preset <preset>; without a
+# preset, out/build/default (the compiler is auto-detected there, so keep
+# to one compiler per directory or use presets). Set BUILD_DIR to use an
+# exact directory of your own instead. breeze/scripts/run.sh, install.sh and
+# docs.sh use the directory built last, or --preset <name> to pick another.
+set -euo pipefail
+shopt -s nullglob
+
+usage() {
+    cat <<'EOF'
+Usage: breeze/scripts/build.sh [--preset <name>] [BUILD_TYPE] [CMAKE_ARGS...]
+       breeze/scripts/build.sh --list-presets
+       breeze/scripts/build.sh --help
+
+  --preset <name>  Use a CMakePresets.json preset: it selects the target's
+                    toolchain file (compiler and DIST_TARGET together) and
+                    builds in its own directory, out/build/<name>. Must come
+                    first if given at all; --preset=<name> also works. Run
+                    --list-presets to see every preset for your OS.
+  BUILD_TYPE       Debug|Release|RelWithDebInfo|MinSizeRel
+                    (default: project/Configuration.cmake's DEFAULT_BUILD_TYPE)
+  CMAKE_ARGS       Anything else is forwarded to `cmake` verbatim, e.g.
+                   -DDIST_TARGET=<value> or -DBUILD_TESTS=ON.
+
+Don't combine --preset with an explicit -DDIST_TARGET=... in CMAKE_ARGS --
+the preset's toolchain already declares one; see the comment at the top of
+this script (breeze/scripts/build.sh) and TargetSelection.cmake's "Target selection"
+section for why picking a DIST_TARGET is one or the other, not both.
+
+Examples:
+  breeze/scripts/build.sh --preset linux-x64-clang
+  breeze/scripts/build.sh --preset windows-x64-mingw64 Debug -DBUILD_TESTS=ON
+  breeze/scripts/build.sh -DBUILD_TESTS=ON
+EOF
+}
+
+case "${1:-}" in
+    -h|--help)
+        usage
+        exit 0
+        ;;
+esac
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+cd "$SCRIPT_DIR/../.."
+
+command -v cmake >/dev/null 2>&1 || { echo "error: cmake not found on PATH." >&2; exit 1; }
+
+if [ "${1:-}" = "--list-presets" ]; then
+    exec cmake --list-presets
+fi
+
+# _pmn_read_config, _pmn_resolve_build_dir, _pmn_record_build_dir.
+source "$SCRIPT_DIR/_common.sh"
+
+# Prints CMake's own preset listing (already filtered to this OS by each
+# preset's "condition" in CMakePresets.json) to stderr -- used to show the
+# actual options right alongside a preset-related error below, instead of
+# just telling the user to go run --list-presets separately.
+_pmn_show_presets() {
+    echo "" >&2
+    cmake --list-presets >&2
+}
+
+# Membership test against that same listing -- $1 matches a real preset
+# name for this OS only if it appears there as a quoted entry (anchored on
+# both quote characters so e.g. "windows-x64-mingw32" can't false-match a
+# check for "windows-x64-mingw3").
+_pmn_known_preset() {
+    cmake --list-presets 2>/dev/null | grep -qF "\"$1\""
+}
+
+_pmn_has_explicit_dist_target() {
+    local arg
+    for arg in "$@"; do
+        case "$arg" in
+            -DDIST_TARGET=*) return 0 ;;
+        esac
+    done
+    return 1
+}
+
+# --preset must come first if given at all -- see TargetSelection.cmake's
+# and CMakePresets.json's own comments for why this is the recommended
+# way to pick a non-default DIST_TARGET: its toolchain file sets the
+# compiler and the label together, instead of you having to pass both by
+# hand.
+PRESET=""
+case "${1:-}" in
+    --preset)
+        if [ "$#" -lt 2 ] || [[ "$2" == -* ]]; then
+            echo "error: --preset requires a value, e.g. --preset windows-x64-mingw64" >&2
+            _pmn_show_presets
+            exit 1
+        fi
+        PRESET="$2"
+        shift 2
+        ;;
+    --preset=*)
+        PRESET="${1#--preset=}"
+        shift
+        if [ -z "$PRESET" ]; then
+            echo "error: --preset= requires a value, e.g. --preset=windows-x64-mingw64" >&2
+            _pmn_show_presets
+            exit 1
+        fi
+        ;;
+esac
+
+if [ -n "$PRESET" ] && ! _pmn_known_preset "$PRESET"; then
+    echo "error: '${PRESET}' is not a preset --list-presets knows about for this OS." >&2
+    _pmn_show_presets
+    exit 1
+fi
+
+# One build directory per preset (out/build/<preset>; "default" when no
+# preset was given), so switching presets never has to reuse -- or wipe -- a
+# directory configured for another compiler. breeze/cmake/BuildDir.cmake owns the
+# layout (project/Configuration.cmake's BUILD_OUTPUT_DIR); an explicit BUILD_DIR
+# from the environment beats it, and is then also not recorded as "the one
+# built last" (run/install/docs would otherwise be sent to a directory the
+# layout doesn't know about).
+_pmn_record_build=1
+if [ -n "${BUILD_DIR:-}" ]; then
+    _pmn_record_build=0
+else
+    BUILD_DIR="$(_pmn_resolve_build_dir "${PRESET:-default}")"
+fi
+
+# If the first remaining argument doesn't start with "-", it's BUILD_TYPE
+# and everything after it is CMAKE_ARGS; otherwise there's no BUILD_TYPE
+# override and every argument is CMAKE_ARGS. Plain bash "$@"/shift, no
+# special-casing needed: unlike Windows cmd.exe (see build.bat), bash
+# never splits a "-DFOO=BAR"-style argument on its own "=".
+if [ "$#" -gt 0 ] && [[ "$1" != -* ]]; then
+    BUILD_TYPE="$1"
+    shift
+else
+    BUILD_TYPE="$(_pmn_read_config DEFAULT_BUILD_TYPE)"
+fi
+CMAKE_ARGS=("$@")
+
+# ${arr[@]+"${arr[@]}"} rather than a plain "${arr[@]}" wherever an array can be
+# empty: under `set -u`, bash before 4.4 -- which includes the 3.2 that macOS
+# still ships as /bin/bash -- treats expanding an EMPTY array as an unset
+# variable and aborts with "unbound variable".
+if [ -n "$PRESET" ] && _pmn_has_explicit_dist_target ${CMAKE_ARGS[@]+"${CMAKE_ARGS[@]}"}; then
+    echo "error: both --preset ${PRESET} and an explicit -DDIST_TARGET=... were given." >&2
+    echo "       A preset's toolchain already declares DIST_TARGET (and picks the compiler) -- pick one:" >&2
+    echo "         breeze/scripts/build.sh --preset ${PRESET}" >&2
+    echo "         breeze/scripts/build.sh -DCMAKE_TOOLCHAIN_FILE=breeze/cmake/toolchains/<target>.cmake" >&2
+    echo "       See the comment at the top of this script, or TargetSelection.cmake's" >&2
+    echo "       \"Target selection\" section, for why these two aren't combined." >&2
+    exit 1
+fi
+
+# Prefer a pinned ninja (fetched by breeze/scripts/setup.sh -- see
+# breeze/cmake/FetchNinja.cmake) over a system one, same "always the pinned copy"
+# preference as Doxygen. Needed whether or not --preset is used: every
+# preset sets its generator to Ninja but doesn't hardcode which ninja
+# binary to use (that would just be TOOLCACHE_DIR's default duplicated a
+# third time -- see project/Configuration.cmake) -- CMAKE_MAKE_PROGRAM supplies it
+# either way; only -G Ninja itself is skipped below when a preset already
+# sets the generator.
+TOOLCACHE_DIR="${TOOLCACHE_DIR:-$(_pmn_read_config TOOLCACHE_DIR)}"
+NINJA_BIN=""
+for _candidate in "${TOOLCACHE_DIR}"/ninja-*/ninja; do
+    if [ -x "$_candidate" ]; then
+        # Must be absolute: CMake invokes CMAKE_MAKE_PROGRAM from several
+        # different working directories during its own internal
+        # try-compile steps, where a relative path doesn't resolve.
+        NINJA_BIN="$(cd "$(dirname "$_candidate")" && pwd)/$(basename "$_candidate")"
+        break
+    fi
+done
+
+GENERATOR_ARGS=()
+if [ -n "$NINJA_BIN" ]; then
+    echo "==> Using pinned ninja: ${NINJA_BIN}"
+    if [ -z "$PRESET" ]; then
+        GENERATOR_ARGS=(-G Ninja "-DCMAKE_MAKE_PROGRAM=${NINJA_BIN}")
+    else
+        GENERATOR_ARGS=("-DCMAKE_MAKE_PROGRAM=${NINJA_BIN}")
+    fi
+elif command -v ninja >/dev/null 2>&1; then
+    echo "==> Using system ninja: $(command -v ninja)"
+    if [ -z "$PRESET" ]; then
+        GENERATOR_ARGS=(-G Ninja)
+    fi
+else
+    if [ -n "$PRESET" ]; then
+        echo "warning: ninja not found (no pinned copy, none on PATH) -- the '${PRESET}'" >&2
+        echo "         preset requires it; configure will likely fail. Run" >&2
+        echo "         breeze/scripts/setup.sh to fetch a pinned ninja, or install ninja" >&2
+        echo "         yourself." >&2
+    else
+        echo "warning: ninja not found (no pinned copy, none on PATH) -- falling back to" >&2
+        echo "         CMake's default generator for this platform. Run breeze/scripts/setup.sh" >&2
+        echo "         to fetch a pinned ninja, or install ninja yourself, for a faster" >&2
+        echo "         and more consistent build. Continuing without it." >&2
+    fi
+fi
+
+CONFIGURE_ARGS=(-S . -B "${BUILD_DIR}")
+if [ -n "$PRESET" ]; then
+    CONFIGURE_ARGS=(--preset "${PRESET}" "${CONFIGURE_ARGS[@]}")
+fi
+
+echo "==> Configuring (${BUILD_TYPE}) into ${BUILD_DIR}/"
+if [ -n "$PRESET" ]; then
+    echo "    Preset: ${PRESET}"
+fi
+if [ "${#CMAKE_ARGS[@]}" -gt 0 ]; then
+    echo "    Extra CMake arguments: ${CMAKE_ARGS[*]}"
+fi
+# The configure's output is also kept in a temporary file, only so that a
+# failed cross configure can be explained afterwards (_pmn_explain_configure_
+# failure, breeze/scripts/_common.sh). Its exit status is still what decides.
+# If no temporary file can be made the build goes on without the explanation.
+_pmn_cfg_log="$(mktemp "${TMPDIR:-/tmp}/pmn-configure.XXXXXX" 2>/dev/null)" || _pmn_cfg_log=/dev/null
+trap 'if [ -f "$_pmn_cfg_log" ]; then rm -f "$_pmn_cfg_log"; fi' EXIT
+if ! cmake "${CONFIGURE_ARGS[@]}" ${GENERATOR_ARGS[@]+"${GENERATOR_ARGS[@]}"} -DCMAKE_BUILD_TYPE="${BUILD_TYPE}" ${CMAKE_ARGS[@]+"${CMAKE_ARGS[@]}"} 2>&1 | tee "$_pmn_cfg_log"; then
+    _pmn_explain_configure_failure "$_pmn_cfg_log" "${BUILD_DIR:-}"
+    exit 1
+fi
+
+# Configure succeeded: this is now the build the other scripts default to.
+if [ "$_pmn_record_build" = 1 ]; then
+    _pmn_record_build_dir "${PRESET:-default}"
+fi
+
+echo "==> Building"
+cmake --build "${BUILD_DIR}"
+
+echo "==> Done. Run a module with:  breeze/scripts/run.sh <target-name>"
diff --git a/breeze/scripts/docs.bat b/breeze/scripts/docs.bat
new file mode 100644
index 0000000..cc5322e
--- /dev/null
+++ b/breeze/scripts/docs.bat
@@ -0,0 +1,136 @@
+@echo off
+REM Build Doxygen documentation for every module (see breeze\cmake\Documentation.cmake)
+REM and print the path to the landing page. A no-op with a clear message if
+REM Doxygen isn't installed or ENABLE_DOXYGEN=OFF.
+REM
+REM Output goes to out\docs\ (DOCS_OUTPUT_DIR in project/Configuration.cmake) --
+REM note this is a sibling of out\build, not nested inside it, and shared by
+REM every preset: documentation doesn't depend on which compiler built the
+REM code. The docs targets just need SOME configured build directory to run
+REM from, so this uses the one built last unless you pick with --preset. If
+REM you've overridden DOCS_OUTPUT_DIR at configure time, also set DOCS_DIR here
+REM to match so the printed path is correct (docs still land in the right
+REM place either way -- this only affects the message below).
+REM
+REM Usage (from the project root):
+REM   breeze\scripts\docs.bat              REM every module
+REM   breeze\scripts\docs.bat core_lib      REM just one module's docs (docs_<target>)
+REM   breeze\scripts\docs.bat --preset windows-x64-clang-cl   REM ... from that preset's build directory
+REM   breeze\scripts\docs.bat --help
+REM
+REM --preset must come first if given at all; --preset=<name> also works. Set
+REM BUILD_DIR to use an exact build directory instead.
+setlocal
+
+if /i "%~1"=="-h" goto show_help
+if /i "%~1"=="--help" goto show_help
+goto after_help
+
+:show_help
+echo Usage: breeze\scripts\docs.bat [--preset ^<name^>] [module-target-name]
+echo.
+echo Builds Doxygen documentation for every module ^(see breeze\cmake\Documentation.cmake^)
+echo and prints the path to the landing page. A no-op with a clear message if
+echo Doxygen isn't installed or ENABLE_DOXYGEN=OFF.
+echo.
+echo   --preset ^<name^>       Run from that preset's build directory
+echo                         ^(out\build\^<name^>^). Default: the build
+echo                         breeze\scripts\build.bat made last. Must come first if
+echo                         given at all; --preset=^<name^> also works.
+echo   ^(no argument^)         Build docs for every module.
+echo   module-target-name    Build docs for just that one module ^(its own
+echo                         docs_^<name^> target^), e.g.:
+echo                           breeze\scripts\docs.bat core_lib
+echo.
+echo Output goes to out\docs\ ^(DOCS_OUTPUT_DIR in project/Configuration.cmake^), shared
+echo by every preset -- see the comment at the top of this script if you've
+echo overridden that.
+exit /b 0
+
+:after_help
+cd /d "%~dp0..\.."
+
+where cmake >nul 2>nul
+if errorlevel 1 (
+    echo error: cmake not found on PATH.
+    exit /b 1
+)
+
+REM --preset must come first if given at all, same as breeze\scripts\build.bat.
+REM cmd.exe splits "--preset=<name>" into "--preset" and "<name>" on its own
+REM (see build.bat's note on "="), so both spellings arrive here identically
+REM and this one branch handles both.
+set "PRESET="
+if /i not "%~1"=="--preset" goto preset_done
+if "%~2"=="" (
+    echo error: --preset requires a value, e.g. --preset windows-x64-clang-cl 1>&2
+    exit /b 1
+)
+set "PRESET=%~2"
+shift
+shift
+:preset_done
+REM Suffix for the error hints below that say to run build.bat first.
+set "_pmn_hint="
+if defined PRESET set "_pmn_hint= --preset %PRESET%"
+
+REM BUILD_DIR from the environment beats everything; otherwise --preset, else
+REM whichever build was made last (see breeze\cmake\BuildDir.cmake). Explains itself
+REM and stops if there's nothing to pick.
+if not "%BUILD_DIR%"=="" goto build_dir_known
+call :resolve_build_dir "%PRESET%" BUILD_DIR
+if errorlevel 1 exit /b 1
+:build_dir_known
+if "%DOCS_DIR%"=="" set "DOCS_DIR=out\docs"
+
+if not exist "%BUILD_DIR%" (
+    echo error: "%BUILD_DIR%" not found. Run breeze\scripts\build.bat%_pmn_hint% first.
+    exit /b 1
+)
+
+echo ==^> Using build directory %BUILD_DIR%
+
+if "%~1"=="" (
+    cmake --build "%BUILD_DIR%" --target docs
+    if exist "%DOCS_DIR%\index.html" (
+        echo ==^> Open: %DOCS_DIR%\index.html
+    )
+) else (
+    cmake --build "%BUILD_DIR%" --target docs_%1
+    echo ==^> Open: %DOCS_DIR%\%1\html\index.html
+)
+exit /b %ERRORLEVEL%
+
+REM ---------------------------------------------------------------------
+REM :resolve_build_dir <name-or-empty> <LocalVarName> [quiet]
+REM
+REM Asks breeze\cmake\BuildDir.cmake which build directory to use -- %1 is a preset
+REM name, or "default"; empty means "discover one" (the build made last, or
+REM the only one) -- and stores it into %2 in the CALLER's scope, with
+REM backslashes. Same shape as build.bat's, and the same `cmake -P`
+REM one-line-answer protocol: "-- BUILD_DIR=<path>" or "-- ERROR=<text>"
+REM (see that file). On failure it prints the reason to stderr, unless a
+REM third argument "quiet" is given, and returns errorlevel 1.
+REM ---------------------------------------------------------------------
+:resolve_build_dir
+setlocal
+set "_pmn_key="
+set "_pmn_val="
+for /f "usebackq tokens=1,* delims==" %%A in (`cmake "-DPMN_NAME=%~1" -P breeze\cmake\BuildDir.cmake`) do (
+    set "_pmn_key=%%A"
+    set "_pmn_val=%%B"
+)
+if "%_pmn_key%"=="-- BUILD_DIR" if defined _pmn_val goto resolve_ok
+if /i "%~3"=="quiet" goto resolve_failed
+if defined _pmn_val (
+    echo error: %_pmn_val% 1>&2
+) else (
+    echo error: breeze\cmake\BuildDir.cmake did not answer. 1>&2
+)
+:resolve_failed
+endlocal
+exit /b 1
+
+:resolve_ok
+endlocal & set "%~2=%_pmn_val:/=\%"
+goto :eof
diff --git a/breeze/scripts/docs.sh b/breeze/scripts/docs.sh
new file mode 100644
index 0000000..c6c5b93
--- /dev/null
+++ b/breeze/scripts/docs.sh
@@ -0,0 +1,99 @@
+#!/usr/bin/env bash
+# Build Doxygen documentation for every module (see breeze/cmake/Documentation.cmake)
+# and print the path to the landing page. A no-op with a clear message if
+# Doxygen isn't installed or ENABLE_DOXYGEN=OFF.
+#
+# Output goes to out/docs/ (DOCS_OUTPUT_DIR in project/Configuration.cmake) --
+# note this is a sibling of out/build, not nested inside it, and shared by
+# every preset: documentation doesn't depend on which compiler built the
+# code. The docs targets just need SOME configured build directory to run
+# from, so this uses the one built last unless you pick with --preset. If
+# you've overridden DOCS_OUTPUT_DIR at configure time, also set DOCS_DIR here
+# to match so the printed path is correct (docs still land in the right
+# place either way -- this only affects the message below).
+#
+# Usage (from the project root):
+#   breeze/scripts/docs.sh                              # every module
+#   breeze/scripts/docs.sh core_lib                     # just one module's docs (docs_<target>)
+#   breeze/scripts/docs.sh --preset linux-x64-gcc       # ... from that preset's build directory
+#   breeze/scripts/docs.sh --help
+#
+# --preset must come first if given at all; --preset=<name> also works. Set
+# BUILD_DIR to use an exact build directory instead.
+set -euo pipefail
+
+case "${1:-}" in
+    -h|--help)
+        cat <<'HELP'
+Usage: breeze/scripts/docs.sh [--preset <name>] [module-target-name]
+
+Builds Doxygen documentation for every module (see breeze/cmake/Documentation.cmake)
+and prints the path to the landing page. A no-op with a clear message if
+Doxygen isn't installed or ENABLE_DOXYGEN=OFF.
+
+  --preset <name>       Run from that preset's build directory
+                         (out/build/<name>). Default: the build
+                         breeze/scripts/build.sh made last. Must come first if
+                         given at all; --preset=<name> also works.
+  (no argument)         Build docs for every module.
+  module-target-name    Build docs for just that one module (its own
+                         docs_<name> target), e.g.:
+                           breeze/scripts/docs.sh core_lib
+
+Output goes to out/docs/ (DOCS_OUTPUT_DIR in project/Configuration.cmake), shared
+by every preset -- see the comment at the top of this script if you've
+overridden that.
+HELP
+        exit 0
+        ;;
+esac
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+cd "$SCRIPT_DIR/../.."
+
+# _pmn_read_config, _pmn_resolve_build_dir, _pmn_record_build_dir.
+source "$SCRIPT_DIR/_common.sh"
+
+# --preset must come first if given at all, same as breeze/scripts/build.sh.
+PRESET=""
+case "${1:-}" in
+    --preset)
+        if [ "$#" -lt 2 ] || [[ "$2" == -* ]]; then
+            echo "error: --preset requires a value, e.g. --preset linux-x64-gcc" >&2
+            exit 1
+        fi
+        PRESET="$2"
+        shift 2
+        ;;
+    --preset=*)
+        PRESET="${1#--preset=}"
+        shift
+        if [ -z "$PRESET" ]; then
+            echo "error: --preset= requires a value, e.g. --preset=linux-x64-gcc" >&2
+            exit 1
+        fi
+        ;;
+esac
+
+if [ -z "${BUILD_DIR:-}" ]; then
+    # Explains itself and stops if there's nothing to pick.
+    BUILD_DIR="$(_pmn_resolve_build_dir "$PRESET")"
+fi
+DOCS_DIR="${DOCS_DIR:-out/docs}"
+
+if [ ! -d "$BUILD_DIR" ]; then
+    echo "error: '${BUILD_DIR}' not found. Run breeze/scripts/build.sh${PRESET:+ --preset $PRESET} first." >&2
+    exit 1
+fi
+
+echo "==> Using build directory ${BUILD_DIR}"
+if [ $# -ge 1 ]; then
+    TARGET="docs_$1"
+    cmake --build "${BUILD_DIR}" --target "${TARGET}"
+    echo "==> Open: ${DOCS_DIR}/$1/html/index.html"
+else
+    cmake --build "${BUILD_DIR}" --target docs
+    if [ -f "${DOCS_DIR}/index.html" ]; then
+        echo "==> Open: ${DOCS_DIR}/index.html"
+    fi
+fi
diff --git a/breeze/scripts/install.bat b/breeze/scripts/install.bat
new file mode 100644
index 0000000..369d921
--- /dev/null
+++ b/breeze/scripts/install.bat
@@ -0,0 +1,151 @@
+@echo off
+REM Install this project's own build artifacts to
+REM out\install\<platform>-<arch>-<compiler>\ (INSTALL_OUTPUT_DIR in
+REM project/Configuration.cmake; see breeze\cmake\Breeze.cmake's install() DESTINATION paths) --
+REM the same name as the out\build\<preset> directory they came from, since
+REM a preset is named after its target.
+REM
+REM Always passes --component to `cmake --install`. Without it, any
+REM vendored/fetched dependency's own install() rules (see
+REM breeze\cmake\Dependencies.cmake) would also run, typically dumping files under
+REM CMAKE_INSTALL_PREFIX -- COMPONENT is what keeps `cmake --install`
+REM scoped to just this project's own targets.
+REM
+REM Usage (from the project root):
+REM   breeze\scripts\install.bat [--preset <name>] [BUILD_TYPE]
+REM   breeze\scripts\install.bat --help
+REM
+REM   --preset <name>  Install the build made with that preset
+REM                    (out\build\<name>). Without it: the build
+REM                    breeze\scripts\build.bat made last, or the only one that
+REM                    exists. Must come first if given at all;
+REM                    --preset=<name> also works.
+REM   BUILD_TYPE       Debug|Release|RelWithDebInfo|MinSizeRel
+REM                    (default: project/Configuration.cmake's DEFAULT_BUILD_TYPE) --
+REM                    only relevant for a Ninja Multi-Config build.
+REM
+REM Set BUILD_DIR to install from an exact build directory instead.
+setlocal enabledelayedexpansion
+
+if /i "%~1"=="-h" goto show_help
+if /i "%~1"=="--help" goto show_help
+goto after_help
+
+:show_help
+echo Usage: breeze\scripts\install.bat [--preset ^<name^>] [BUILD_TYPE]
+echo.
+echo Installs this project's own build artifacts to
+echo out\install\^<platform^>-^<arch^>-^<compiler^>\ ^(INSTALL_OUTPUT_DIR in
+echo project/Configuration.cmake^), scoped to just this project via `cmake --install
+echo --component` -- see the comment at the top of this script.
+echo.
+echo   --preset ^<name^>  Install the build made with that preset
+echo                    ^(out\build\^<name^>^). Default: the build
+echo                    breeze\scripts\build.bat made last. Must come first if given
+echo                    at all; --preset=^<name^> also works.
+echo   BUILD_TYPE       Debug^|Release^|RelWithDebInfo^|MinSizeRel
+echo                    ^(default: project/Configuration.cmake's DEFAULT_BUILD_TYPE^) --
+echo                    only relevant for a Ninja Multi-Config build.
+exit /b 0
+
+:after_help
+cd /d "%~dp0..\.."
+
+where cmake >nul 2>nul
+if errorlevel 1 (
+    echo error: cmake not found on PATH.
+    exit /b 1
+)
+
+REM --preset must come first if given at all, same as breeze\scripts\build.bat.
+REM cmd.exe splits "--preset=<name>" into "--preset" and "<name>" on its own
+REM (see build.bat's note on "="), so both spellings arrive here identically
+REM and this one branch handles both.
+set "PRESET="
+if /i not "%~1"=="--preset" goto preset_done
+if "%~2"=="" (
+    echo error: --preset requires a value, e.g. --preset windows-x64-clang-cl 1>&2
+    exit /b 1
+)
+set "PRESET=%~2"
+shift
+shift
+:preset_done
+REM Suffix for the error hints below that say to run build.bat first.
+set "_pmn_hint="
+if defined PRESET set "_pmn_hint= --preset %PRESET%"
+
+REM BUILD_DIR from the environment beats everything; otherwise --preset, else
+REM whichever build was made last (see breeze\cmake\BuildDir.cmake). Explains itself
+REM and stops if there's nothing to pick.
+if not "%BUILD_DIR%"=="" goto build_dir_known
+call :resolve_build_dir "%PRESET%" BUILD_DIR
+if errorlevel 1 exit /b 1
+:build_dir_known
+
+REM A plain %~1 is safe here (unlike build.bat's arguments): a build type
+REM like "Debug" never contains "=", so cmd.exe's positional-parameter
+REM splitting on it never comes into play.
+set "BUILD_TYPE=%~1"
+if "%BUILD_TYPE%"=="" call :read_config DEFAULT_BUILD_TYPE BUILD_TYPE
+call :read_config PROJECT_CODE_NAME COMPONENT
+
+if not exist "%BUILD_DIR%" (
+    echo error: "%BUILD_DIR%" not found. Run breeze\scripts\build.bat%_pmn_hint% first.
+    exit /b 1
+)
+
+echo ==^> Installing (component: %COMPONENT%) from %BUILD_DIR%
+cmake --install "%BUILD_DIR%" --config %BUILD_TYPE% --component %COMPONENT%
+exit /b %ERRORLEVEL%
+
+REM ---------------------------------------------------------------------
+REM :read_config <ConfigurationVarName> <LocalVarName>
+REM
+REM Reads one value out of project/Configuration.cmake -- this project's single
+REM source of truth -- via breeze\cmake\PrintConfig.cmake, instead of hardcoding
+REM a second copy of a default that can silently drift out of sync, and
+REM stores it into %2 in the CALLER's scope. See breeze\cmake\PrintConfig.cmake
+REM for exactly what's being stripped off of its output below.
+REM ---------------------------------------------------------------------
+:read_config
+setlocal
+set "_pmn_line="
+for /f "usebackq delims=" %%V in (`cmake "-DPRINT_VARS=%~1" -P breeze\cmake\PrintConfig.cmake`) do set "_pmn_line=%%V"
+for /f "tokens=1,* delims==" %%A in ("%_pmn_line%") do set "_pmn_value=%%B"
+endlocal & set "%~2=%_pmn_value%"
+goto :eof
+
+REM ---------------------------------------------------------------------
+REM :resolve_build_dir <name-or-empty> <LocalVarName> [quiet]
+REM
+REM Asks breeze\cmake\BuildDir.cmake which build directory to use -- %1 is a preset
+REM name, or "default"; empty means "discover one" (the build made last, or
+REM the only one) -- and stores it into %2 in the CALLER's scope, with
+REM backslashes. Same shape as build.bat's, and the same `cmake -P`
+REM one-line-answer protocol: "-- BUILD_DIR=<path>" or "-- ERROR=<text>"
+REM (see that file). On failure it prints the reason to stderr, unless a
+REM third argument "quiet" is given, and returns errorlevel 1.
+REM ---------------------------------------------------------------------
+:resolve_build_dir
+setlocal
+set "_pmn_key="
+set "_pmn_val="
+for /f "usebackq tokens=1,* delims==" %%A in (`cmake "-DPMN_NAME=%~1" -P breeze\cmake\BuildDir.cmake`) do (
+    set "_pmn_key=%%A"
+    set "_pmn_val=%%B"
+)
+if "%_pmn_key%"=="-- BUILD_DIR" if defined _pmn_val goto resolve_ok
+if /i "%~3"=="quiet" goto resolve_failed
+if defined _pmn_val (
+    echo error: %_pmn_val% 1>&2
+) else (
+    echo error: breeze\cmake\BuildDir.cmake did not answer. 1>&2
+)
+:resolve_failed
+endlocal
+exit /b 1
+
+:resolve_ok
+endlocal & set "%~2=%_pmn_val:/=\%"
+goto :eof
diff --git a/breeze/scripts/install.sh b/breeze/scripts/install.sh
new file mode 100644
index 0000000..e6fccf8
--- /dev/null
+++ b/breeze/scripts/install.sh
@@ -0,0 +1,97 @@
+#!/usr/bin/env bash
+# Install this project's own build artifacts to
+# out/install/<platform>-<arch>-<compiler>/ (INSTALL_OUTPUT_DIR in
+# project/Configuration.cmake; see breeze/cmake/Breeze.cmake's install() DESTINATION paths) --
+# the same name as the out/build/<preset> directory they came from, since
+# a preset is named after its target.
+#
+# Always passes --component to `cmake --install`. Without it, any
+# vendored/fetched dependency's own install() rules (see
+# breeze/cmake/Dependencies.cmake) would also run, typically dumping files under
+# CMAKE_INSTALL_PREFIX (e.g. /usr/local) -- COMPONENT is what keeps
+# `cmake --install` scoped to just this project's own targets.
+#
+# Usage (from the project root):
+#   breeze/scripts/install.sh [--preset <name>] [BUILD_TYPE]
+#   breeze/scripts/install.sh --help
+#
+#   --preset <name>  Install the build made with that preset
+#                    (out/build/<name>). Without it: the build
+#                    breeze/scripts/build.sh made last, or the only one that
+#                    exists. Must come first if given at all;
+#                    --preset=<name> also works.
+#   BUILD_TYPE       Debug|Release|RelWithDebInfo|MinSizeRel
+#                    (default: project/Configuration.cmake's DEFAULT_BUILD_TYPE) --
+#                    only relevant for a Ninja Multi-Config build.
+#
+# Set BUILD_DIR to install from an exact build directory instead.
+set -euo pipefail
+
+case "${1:-}" in
+    -h|--help)
+        cat <<'HELP'
+Usage: breeze/scripts/install.sh [--preset <name>] [BUILD_TYPE]
+
+Installs this project's own build artifacts to
+out/install/<platform>-<arch>-<compiler>/ (INSTALL_OUTPUT_DIR in
+project/Configuration.cmake), scoped to just this project via `cmake --install
+--component` -- see the comment at the top of this script.
+
+  --preset <name>  Install the build made with that preset (out/build/<name>).
+                   Default: the build breeze/scripts/build.sh made last. Must come
+                   first if given at all; --preset=<name> also works.
+  BUILD_TYPE       Debug|Release|RelWithDebInfo|MinSizeRel
+                   (default: project/Configuration.cmake's DEFAULT_BUILD_TYPE) --
+                   only relevant for a Ninja Multi-Config build.
+HELP
+        exit 0
+        ;;
+esac
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+cd "$SCRIPT_DIR/../.."
+
+command -v cmake >/dev/null 2>&1 || { echo "error: cmake not found on PATH." >&2; exit 1; }
+
+# _pmn_read_config, _pmn_resolve_build_dir, _pmn_record_build_dir. Reading
+# values out of project/Configuration.cmake this way -- its single source of truth
+# -- is the bug fix that replaced COMPONENT being a literal "demo" here,
+# with a comment warning it had to be kept in sync with PROJECT_CODE_NAME by
+# hand.
+source "$SCRIPT_DIR/_common.sh"
+
+# --preset must come first if given at all, same as breeze/scripts/build.sh.
+PRESET=""
+case "${1:-}" in
+    --preset)
+        if [ "$#" -lt 2 ] || [[ "$2" == -* ]]; then
+            echo "error: --preset requires a value, e.g. --preset linux-x64-gcc" >&2
+            exit 1
+        fi
+        PRESET="$2"
+        shift 2
+        ;;
+    --preset=*)
+        PRESET="${1#--preset=}"
+        shift
+        if [ -z "$PRESET" ]; then
+            echo "error: --preset= requires a value, e.g. --preset=linux-x64-gcc" >&2
+            exit 1
+        fi
+        ;;
+esac
+
+if [ -z "${BUILD_DIR:-}" ]; then
+    # Explains itself and stops if there's nothing to pick.
+    BUILD_DIR="$(_pmn_resolve_build_dir "$PRESET")"
+fi
+BUILD_TYPE="${1:-$(_pmn_read_config DEFAULT_BUILD_TYPE)}"
+COMPONENT="$(_pmn_read_config PROJECT_CODE_NAME)"
+
+if [ ! -d "$BUILD_DIR" ]; then
+    echo "error: '${BUILD_DIR}' not found. Run breeze/scripts/build.sh${PRESET:+ --preset $PRESET} first." >&2
+    exit 1
+fi
+
+echo "==> Installing (component: ${COMPONENT}) from ${BUILD_DIR}"
+cmake --install "${BUILD_DIR}" --config "${BUILD_TYPE}" --component "${COMPONENT}"
diff --git a/breeze/scripts/refactor.bat b/breeze/scripts/refactor.bat
new file mode 100644
index 0000000..7effb4c
--- /dev/null
+++ b/breeze/scripts/refactor.bat
@@ -0,0 +1,104 @@
+@echo off
+REM Applies clang-format and clang-tidy's --fix across this project's own
+REM C/C++ code. The pre-commit hook only CHECKS; this is the "just fix it"
+REM counterpart -- review the result with `git diff` afterward, same as any
+REM auto-formatter.
+REM
+REM Defaults to source\ and c-api\, this template's own-code roots -- NEVER
+REM walks out\, .cache\, vendor\, or .git\ by default, so it can't
+REM accidentally spend minutes reformatting/analyzing a fetched dependency's
+REM entire source tree the way scanning the whole repo from "." would.
+REM
+REM Usage, from the project root: breeze\scripts\refactor.bat [optional path]
+REM   breeze\scripts\refactor.bat              every file under source\ and c-api\
+REM   breeze\scripts\refactor.bat source\Core  just one file or directory -- taken
+REM                                     as given, with no exclusion filter,
+REM                                     so pick a path that doesn't overlap
+REM                                     with out\/.cache\/vendor\/.git\
+REM   breeze\scripts\refactor.bat --help
+setlocal enabledelayedexpansion
+
+if /i "%~1"=="-h" goto show_help
+if /i "%~1"=="--help" goto show_help
+goto after_help
+
+:show_help
+echo Usage: breeze\scripts\refactor.bat [scope]
+echo.
+echo Applies clang-format and clang-tidy's --fix across this project's own
+echo C/C++ code -- review the result with `git diff` afterward. See the
+echo comment at the top of this script for the default scope and why it
+echo never walks out\, .cache\, vendor\, or .git\.
+echo.
+echo   ^(no argument^)  Every file under source\ and c-api\ ^(whichever exist^).
+echo   scope          Just one file or directory, e.g.:
+echo                    breeze\scripts\refactor.bat source\Core
+exit /b 0
+
+:after_help
+cd /d "%~dp0..\.."
+
+where clang-format >nul 2>nul
+set "HAVE_FORMAT=0"
+if not errorlevel 1 set "HAVE_FORMAT=1"
+where clang-tidy >nul 2>nul
+set "HAVE_TIDY=0"
+if not errorlevel 1 set "HAVE_TIDY=1"
+
+if "%HAVE_FORMAT%"=="1" goto have_a_tool
+if "%HAVE_TIDY%"=="1" goto have_a_tool
+echo error: neither clang-format nor clang-tidy found on PATH. Run breeze\scripts\setup.bat for install guidance.
+exit /b 1
+:have_a_tool
+
+set "FILELIST=%TEMP%\refactor_files_%RANDOM%.txt"
+if exist "%FILELIST%" del "%FILELIST%"
+
+REM Collect the file list. Deliberately NOT using an if/else block here --
+REM a for /f or for /r loop nested inside a parenthesized if(...) else(...)
+REM block confuses cmd.exe's paren-matching for the enclosing block (this
+REM was tested and confirmed, not a guess); goto-based branching sidesteps
+REM the problem entirely by never nesting a FOR loop inside another block.
+if not "%~1"=="" goto collect_custom
+
+set "SCOPE_DESC=source and c-api"
+if exist "source" for /r "source" %%F in (*.c *.h *.cpp *.hpp *.cc *.cxx *.tpp) do echo %%F>>"%FILELIST%"
+if exist "c-api" for /r "c-api" %%F in (*.c *.h *.cpp *.hpp *.cc *.cxx *.tpp) do echo %%F>>"%FILELIST%"
+goto collected
+
+:collect_custom
+set "SCOPE_DESC=%~1"
+if not exist "%~1" goto collected
+for /r "%~1" %%F in (*.c *.h *.cpp *.hpp *.cc *.cxx *.tpp) do echo %%F>>"%FILELIST%"
+
+:collected
+if exist "%FILELIST%" goto have_files
+echo No C/C++ files found under: %SCOPE_DESC%
+exit /b 0
+:have_files
+
+echo ==^> Files in scope: %SCOPE_DESC%
+
+if "%HAVE_FORMAT%"=="1" goto do_format
+echo ==^> Skipping clang-format ^(not found on PATH -- see breeze\scripts\setup.bat^)
+goto after_format
+:do_format
+echo ==^> Running clang-format -i
+for /f "usebackq delims=" %%F in ("%FILELIST%") do clang-format -i "%%F"
+:after_format
+
+if "%HAVE_TIDY%"=="1" goto do_tidy
+echo ==^> Skipping clang-tidy ^(not found on PATH -- see breeze\scripts\setup.bat^)
+goto after_tidy
+:do_tidy
+if exist compile_commands.json goto run_tidy
+echo ==^> Skipping clang-tidy ^(no compile_commands.json -- run breeze\scripts\build.bat first^)
+goto after_tidy
+:run_tidy
+echo ==^> Running clang-tidy --fix ^(auto-fixable issues only; build once first if this is stale^)
+for /f "usebackq delims=" %%F in ("%FILELIST%") do clang-tidy --quiet --fix "%%F"
+:after_tidy
+
+del "%FILELIST%" 2>nul
+echo ==^> Done. Review the changes: git diff
+exit /b 0
diff --git a/breeze/scripts/refactor.sh b/breeze/scripts/refactor.sh
new file mode 100644
index 0000000..8e56d7a
--- /dev/null
+++ b/breeze/scripts/refactor.sh
@@ -0,0 +1,103 @@
+#!/usr/bin/env bash
+# Applies clang-format and clang-tidy's --fix across this project's own
+# C/C++ code. The pre-commit hook only CHECKS; this is the "just fix it"
+# counterpart -- review the result with `git diff` afterward, same as any
+# auto-formatter.
+#
+# Defaults to source/ and c-api/ (this template's own-code roots) --
+# NEVER walks out/, .cache/, vendor/, or .git/ by default, so it can't
+# accidentally spend minutes reformatting/analyzing a fetched dependency's
+# entire source tree (e.g. out/build/_deps/*-src/) the way scanning the
+# whole repo from "." would. Passing an explicit scope still excludes
+# those four directories defensively, in case the scope you give overlaps
+# with them.
+#
+# Usage (from the project root):
+#   breeze/scripts/refactor.sh              # every file under source/ and c-api/
+#   breeze/scripts/refactor.sh source/Core  # just one file or directory
+#   breeze/scripts/refactor.sh --help
+set -euo pipefail
+
+case "${1:-}" in
+    -h|--help)
+        cat <<'EOF'
+Usage: breeze/scripts/refactor.sh [scope]
+
+Applies clang-format and clang-tidy's --fix across this project's own
+C/C++ code -- review the result with `git diff` afterward. See the
+comment at the top of this script for the default scope and why it never
+walks out/, .cache/, vendor/, or .git/.
+
+  (no argument)  Every file under source/ and c-api/ (whichever exist).
+  scope          Just one file or directory, e.g.:
+                   breeze/scripts/refactor.sh source/Core
+EOF
+        exit 0
+        ;;
+esac
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+cd "$SCRIPT_DIR/../.."
+
+# _pmn_extend_tool_path: finds Homebrew's keg-only llvm (clang-tidy) on macOS.
+source "$SCRIPT_DIR/_common.sh"
+_pmn_extend_tool_path
+
+if [ $# -ge 1 ]; then
+    scopes=("$1")
+else
+    scopes=()
+    [ -d source ] && scopes+=(source)
+    [ -d c-api ] && scopes+=(c-api)
+fi
+
+if [ "${#scopes[@]}" -eq 0 ]; then
+    echo "No default scope found (expected a source/ and/or c-api/ directory here)." >&2
+    exit 1
+fi
+
+if ! command -v clang-format >/dev/null 2>&1 && ! command -v clang-tidy >/dev/null 2>&1; then
+    echo "error: neither clang-format nor clang-tidy found on PATH. Run breeze/scripts/setup.sh for install guidance." >&2
+    exit 1
+fi
+
+# A read loop rather than mapfile/readarray: those are bash 4+, and macOS
+# ships bash 3.2.
+files=()
+while IFS= read -r _file; do
+    files+=("$_file")
+done < <(
+    find "${scopes[@]}" \
+        \( -path './vendor' -o -path './out' -o -path './.cache' -o -path './.git' \) -prune -o \
+        -type f \( -name '*.c' -o -name '*.h' -o -name '*.cpp' -o -name '*.hpp' -o -name '*.cc' -o -name '*.cxx' -o -name '*.tpp' \) -print \
+    | sed 's|^\./||' | sort
+)
+
+if [ "${#files[@]}" -eq 0 ]; then
+    echo "No C/C++ files found under: ${scopes[*]}"
+    exit 0
+fi
+
+echo "==> ${#files[@]} file(s) in scope: ${scopes[*]}"
+
+if command -v clang-format >/dev/null 2>&1; then
+    echo "==> Running clang-format -i"
+    clang-format -i "${files[@]}"
+else
+    echo "==> Skipping clang-format (not found on PATH -- see breeze/scripts/setup.sh)"
+fi
+
+if command -v clang-tidy >/dev/null 2>&1; then
+    if [ ! -f compile_commands.json ]; then
+        echo "==> Skipping clang-tidy (no compile_commands.json -- run breeze/scripts/build.sh first)"
+    else
+        echo "==> Running clang-tidy --fix (auto-fixable issues only; build once first if this is stale)"
+        for f in "${files[@]}"; do
+            clang-tidy --quiet --fix "$f" || true
+        done
+    fi
+else
+    echo "==> Skipping clang-tidy (not found on PATH -- see breeze/scripts/setup.sh)"
+fi
+
+echo "==> Done. Review the changes: git diff"
diff --git a/breeze/scripts/run.bat b/breeze/scripts/run.bat
new file mode 100644
index 0000000..29b74bb
--- /dev/null
+++ b/breeze/scripts/run.bat
@@ -0,0 +1,185 @@
+@echo off
+REM Run an executable module by its CMake target name (as registered in
+REM that module's own CMakeLists.txt), resolved via the manifest that
+REM _write_module_manifest() generates at configure time -- so this script
+REM never needs updating when modules are added, removed, or renamed.
+REM
+REM Usage (from the project root):
+REM   breeze\scripts\run.bat [--preset <name>] <target-name> [-- program-args...]
+REM
+REM   --preset <name>  Run the build made with that preset (out\build\<name>).
+REM                    Without it: the build breeze\scripts\build.bat made last, or
+REM                    the only one that exists. Must come first if given at
+REM                    all; --preset=<name> also works.
+REM
+REM Examples:
+REM   breeze\scripts\run.bat hello_exe
+REM   breeze\scripts\run.bat --preset windows-x64-clang-cl hello_exe
+REM   breeze\scripts\run.bat farewell_exe -- Ale
+REM
+REM Set BUILD_DIR to run out of an exact build directory instead.
+setlocal enabledelayedexpansion
+
+cd /d "%~dp0..\.."
+
+REM --preset must come first if given at all, same as breeze\scripts\build.bat.
+REM cmd.exe splits "--preset=<name>" into "--preset" and "<name>" on its own
+REM (see build.bat's note on "="), so both spellings arrive here identically
+REM and this one branch handles both.
+set "PRESET="
+if /i not "%~1"=="--preset" goto preset_done
+if "%~2"=="" (
+    echo error: --preset requires a value, e.g. --preset windows-x64-clang-cl 1>&2
+    exit /b 1
+)
+set "PRESET=%~2"
+shift
+shift
+:preset_done
+REM Suffix for the error hints below that say to run build.bat first.
+set "_pmn_hint="
+if defined PRESET set "_pmn_hint= --preset %PRESET%"
+
+if /i "%~1"=="-h" goto show_help
+if /i "%~1"=="--help" goto show_help
+if "%~1"=="" goto usage
+
+set "TARGET_NAME=%~1"
+shift
+
+REM Collect any remaining args to pass through to the program (skipping a
+REM leading "--" separator if present).
+set "PASSTHROUGH="
+set "skip_next_dashes=1"
+:collect
+if "%~1"=="" goto collected
+if "!skip_next_dashes!"=="1" if "%~1"=="--" (
+    set "skip_next_dashes=0"
+    shift
+    goto collect
+)
+set "skip_next_dashes=0"
+set "PASSTHROUGH=!PASSTHROUGH! "%~1""
+shift
+goto collect
+:collected
+
+REM BUILD_DIR from the environment beats everything; otherwise --preset, else
+REM whichever build was made last (see breeze\cmake\BuildDir.cmake). Explains itself
+REM and stops if there's nothing to pick.
+if not "%BUILD_DIR%"=="" goto build_dir_known
+where cmake >nul 2>nul
+if errorlevel 1 (
+    echo error: cmake not found on PATH -- it is needed to work out which build directory to use. 1>&2
+    echo        Put it on PATH, or set BUILD_DIR to the directory explicitly, e.g. out\build\^<preset^>. 1>&2
+    exit /b 1
+)
+call :resolve_build_dir "%PRESET%" BUILD_DIR
+if errorlevel 1 exit /b 1
+:build_dir_known
+
+set "MANIFEST="
+for %%F in ("%BUILD_DIR%\module_manifest-*.txt") do (
+    if not defined MANIFEST set "MANIFEST=%%F"
+)
+if not defined MANIFEST (
+    echo error: no build manifest found in "%BUILD_DIR%". Run breeze\scripts\build.bat%_pmn_hint% first. 1>&2
+    exit /b 1
+)
+
+set "BIN_PATH="
+for /f "usebackq tokens=1,* delims==" %%K in ("%MANIFEST%") do (
+    if "%%K"=="%TARGET_NAME%" set "BIN_PATH=%%L"
+)
+
+if not defined BIN_PATH (
+    echo error: no executable target named "%TARGET_NAME%" in "%BUILD_DIR%". 1>&2
+    echo Available targets: 1>&2
+    for /f "usebackq tokens=1 delims==" %%T in ("%MANIFEST%") do echo   %%T 1>&2
+    exit /b 1
+)
+
+if not exist "%BIN_PATH%" (
+    echo error: "%BIN_PATH%" was not found. Rebuild with breeze\scripts\build.bat%_pmn_hint%. 1>&2
+    exit /b 1
+)
+
+REM Which build this came from -- to stderr, so a program's own stdout stays
+REM clean to pipe.
+echo ==^> Running %TARGET_NAME% ^(%BUILD_DIR%^) 1>&2
+"%BIN_PATH%" !PASSTHROUGH!
+exit /b %ERRORLEVEL%
+
+:usage
+REM Best-effort here: usage should still print with nothing built yet.
+if "%BUILD_DIR%"=="" call :resolve_build_dir "%PRESET%" BUILD_DIR quiet
+echo Usage: %~nx0 [--preset ^<name^>] ^<cmake-target-name^> [-- program-args...] 1>&2
+echo. 1>&2
+echo Available executable targets: 1>&2
+set "found=0"
+for %%F in ("%BUILD_DIR%\module_manifest-*.txt") do (
+    set "found=1"
+    for /f "usebackq tokens=1 delims==" %%T in ("%%F") do echo   %%T 1>&2
+)
+if "!found!"=="0" echo   (none found -- did you run breeze\scripts\build.bat?) 1>&2
+exit /b 1
+
+:show_help
+REM Best-effort here: help should still print with nothing built yet.
+if "%BUILD_DIR%"=="" call :resolve_build_dir "%PRESET%" BUILD_DIR quiet
+echo Usage: %~nx0 [--preset ^<name^>] ^<cmake-target-name^> [-- program-args...]
+echo.
+echo Runs an executable module by its CMake target name, resolved via the
+echo manifest breeze\scripts\build.bat generates at configure time -- see the
+echo comment at the top of this script.
+echo.
+echo   --preset ^<name^>  Run the build made with that preset. Default: the
+echo                    build breeze\scripts\build.bat made last.
+echo.
+echo Available executable targets:
+set "found=0"
+for %%F in ("%BUILD_DIR%\module_manifest-*.txt") do (
+    set "found=1"
+    for /f "usebackq tokens=1 delims==" %%T in ("%%F") do echo   %%T
+)
+if "!found!"=="0" echo   (none found -- did you run breeze\scripts\build.bat?)
+echo.
+echo Examples:
+echo   breeze\scripts\run.bat hello_exe
+echo   breeze\scripts\run.bat --preset windows-x64-clang-cl hello_exe
+echo   breeze\scripts\run.bat farewell_exe -- Ale
+exit /b 0
+
+REM ---------------------------------------------------------------------
+REM :resolve_build_dir <name-or-empty> <LocalVarName> [quiet]
+REM
+REM Asks breeze\cmake\BuildDir.cmake which build directory to use -- %1 is a preset
+REM name, or "default"; empty means "discover one" (the build made last, or
+REM the only one) -- and stores it into %2 in the CALLER's scope, with
+REM backslashes. Same shape as build.bat's, and the same `cmake -P`
+REM one-line-answer protocol: "-- BUILD_DIR=<path>" or "-- ERROR=<text>"
+REM (see that file). On failure it prints the reason to stderr, unless a
+REM third argument "quiet" is given, and returns errorlevel 1.
+REM ---------------------------------------------------------------------
+:resolve_build_dir
+setlocal
+set "_pmn_key="
+set "_pmn_val="
+for /f "usebackq tokens=1,* delims==" %%A in (`cmake "-DPMN_NAME=%~1" -P breeze\cmake\BuildDir.cmake`) do (
+    set "_pmn_key=%%A"
+    set "_pmn_val=%%B"
+)
+if "%_pmn_key%"=="-- BUILD_DIR" if defined _pmn_val goto resolve_ok
+if /i "%~3"=="quiet" goto resolve_failed
+if defined _pmn_val (
+    echo error: %_pmn_val% 1>&2
+) else (
+    echo error: breeze\cmake\BuildDir.cmake did not answer. 1>&2
+)
+:resolve_failed
+endlocal
+exit /b 1
+
+:resolve_ok
+endlocal & set "%~2=%_pmn_val:/=\%"
+goto :eof
diff --git a/breeze/scripts/run.sh b/breeze/scripts/run.sh
new file mode 100644
index 0000000..0fbafa1
--- /dev/null
+++ b/breeze/scripts/run.sh
@@ -0,0 +1,367 @@
+#!/usr/bin/env bash
+# Run an executable module by its CMake target name (as registered in
+# that module's own CMakeLists.txt), resolved via the manifest that
+# _write_module_manifest() generates at configure time -- so this script
+# never needs updating when modules are added, removed, or renamed.
+#
+# Usage (from the project root):
+#   breeze/scripts/run.sh [--preset <name>] <target-name> [-- program-args...]
+#
+#   --preset <name>  Run the build made with that preset (out/build/<name>).
+#                    Without it: the build breeze/scripts/build.sh made last, or
+#                    the only one that exists. Must come first if given at
+#                    all; --preset=<name> also works.
+#
+# Examples:
+#   breeze/scripts/run.sh hello_exe
+#   breeze/scripts/run.sh --preset linux-x64-clang hello_exe
+#   breeze/scripts/run.sh farewell_exe -- Ale
+#
+# Set BUILD_DIR to run out of an exact build directory instead.
+#
+# An executable built for another architecture or OS -- linux-arm64-* on an
+# x64 machine, windows-*-mingw* from Linux -- is run under the emulator its
+# toolchain registered (qemu-user, wine) if one was installed when the build
+# was configured; otherwise it can only run on the target itself.
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+cd "$SCRIPT_DIR/../.."
+
+# _pmn_read_config, _pmn_resolve_build_dir, _pmn_record_build_dir.
+source "$SCRIPT_DIR/_common.sh"
+
+# --preset must come first if given at all, same as breeze/scripts/build.sh.
+PRESET=""
+case "${1:-}" in
+    --preset)
+        if [ "$#" -lt 2 ] || [[ "$2" == -* ]]; then
+            echo "error: --preset requires a value, e.g. --preset linux-x64-gcc" >&2
+            exit 1
+        fi
+        PRESET="$2"
+        shift 2
+        ;;
+    --preset=*)
+        PRESET="${1#--preset=}"
+        shift
+        if [ -z "$PRESET" ]; then
+            echo "error: --preset= requires a value, e.g. --preset=linux-x64-gcc" >&2
+            exit 1
+        fi
+        ;;
+esac
+
+# BUILD_DIR from the environment beats everything; otherwise --preset, else
+# whichever build was made last (see breeze/cmake/BuildDir.cmake). Help and the
+# usage message look it up best-effort -- they should still print on a
+# fresh checkout with nothing built yet -- while actually running
+# something needs a real answer, and stops with the reason if there isn't
+# one.
+_pmn_try_build_dir() {
+    if [ -z "${BUILD_DIR:-}" ]; then
+        BUILD_DIR="$(_pmn_resolve_build_dir "$PRESET" 2>/dev/null || true)"
+    fi
+}
+
+list_targets() {
+    local manifest
+    [ -n "${BUILD_DIR:-}" ] || return 0
+    for manifest in "${BUILD_DIR}"/module_manifest-*.txt; do
+        [ -e "$manifest" ] || continue
+        cut -d= -f1 "$manifest"
+    done | sort -u
+}
+
+usage() {
+    _pmn_try_build_dir
+    echo "Usage: $0 [--preset <name>] <cmake-target-name> [-- program-args...]" >&2
+    echo >&2
+    echo "Available executable targets:" >&2
+    local targets
+    targets="$(list_targets)"
+    if [ -n "$targets" ]; then
+        echo "$targets" | sed 's/^/  /' >&2
+    else
+        echo "  (none found -- did you run breeze/scripts/build.sh?)" >&2
+    fi
+    exit 1
+}
+
+show_help() {
+    _pmn_try_build_dir
+    echo "Usage: $0 [--preset <name>] <cmake-target-name> [-- program-args...]"
+    echo
+    echo "Runs an executable module by its CMake target name, resolved via the"
+    echo "manifest breeze/scripts/build.sh generates at configure time -- see the"
+    echo "comment at the top of this script."
+    echo
+    echo "  --preset <name>  Run the build made with that preset. Default: the"
+    echo "                   build breeze/scripts/build.sh made last."
+    echo
+    echo "Available executable targets:"
+    local targets
+    targets="$(list_targets)"
+    if [ -n "$targets" ]; then
+        echo "$targets" | sed 's/^/  /'
+    else
+        echo "  (none found -- did you run breeze/scripts/build.sh?)"
+    fi
+    echo
+    echo "Examples:"
+    echo "  breeze/scripts/run.sh hello_exe"
+    echo "  breeze/scripts/run.sh --preset linux-x64-clang hello_exe"
+    echo "  breeze/scripts/run.sh farewell_exe -- Ale"
+    exit 0
+}
+
+case "${1:-}" in
+    -h|--help) show_help ;;
+esac
+
+[ $# -ge 1 ] || usage
+
+TARGET_NAME="$1"
+shift
+if [ "${1:-}" = "--" ]; then
+    shift
+fi
+
+if [ -z "${BUILD_DIR:-}" ]; then
+    # Explains itself and stops if there's nothing to pick.
+    BUILD_DIR="$(_pmn_resolve_build_dir "$PRESET")"
+fi
+
+MANIFEST=""
+for m in "${BUILD_DIR}"/module_manifest-*.txt; do
+    [ -e "$m" ] || continue
+    MANIFEST="$m"
+    break
+done
+
+if [ -z "$MANIFEST" ]; then
+    echo "error: no build manifest found in '${BUILD_DIR}'. Run breeze/scripts/build.sh${PRESET:+ --preset $PRESET} first." >&2
+    exit 1
+fi
+
+BIN_PATH="$(grep "^${TARGET_NAME}=" "$MANIFEST" | head -n1 | cut -d= -f2- || true)"
+
+if [ -z "$BIN_PATH" ]; then
+    echo "error: no executable target named '${TARGET_NAME}' in '${BUILD_DIR}'." >&2
+    echo "Available targets:" >&2
+    list_targets | sed 's/^/  /' >&2
+    exit 1
+fi
+
+if [ ! -x "$BIN_PATH" ]; then
+    echo "error: '${BIN_PATH}' was not found or is not executable. Rebuild with breeze/scripts/build.sh${PRESET:+ --preset $PRESET}." >&2
+    exit 1
+fi
+
+# _pmn_pe_kind <file>: what kind of Windows program this is, read from the
+# Machine field of its PE header -- the two bytes after the "PE\0\0"
+# signature, which e_lfanew (the 4 bytes at offset 0x3C) points at. Prints
+# x86 (32-bit), x64 (64-bit x86), or other (ARM64, a file that isn't a PE at
+# all, one that can't be read). `od` rather than `file`, so nothing has to be
+# installed, and byte by byte so the host's endianness doesn't matter.
+_pmn_pe_kind() {
+    local o0 o1 o2 o3 s0 s1 s2 s3 m0 m1 off
+    read -r o0 o1 o2 o3 <<< "$(od -An -tu1 -j60 -N4 "$1" 2>/dev/null || true)"
+    if [ -z "${o3:-}" ]; then
+        echo other
+        return 0
+    fi
+    off=$(( o0 + o1 * 256 + o2 * 65536 + o3 * 16777216 ))
+    read -r s0 s1 s2 s3 m0 m1 <<< "$(od -An -tu1 -j"$off" -N6 "$1" 2>/dev/null || true)"
+    # 80 69 0 0 is "PE\0\0".
+    if [ "${s0:-}" = 80 ] && [ "${s1:-}" = 69 ] && [ "${s2:-}" = 0 ] && [ "${s3:-}" = 0 ] && [ -n "${m1:-}" ]; then
+        case $(( m0 + m1 * 256 )) in
+            332)   echo x86; return 0 ;;    # 0x014c  IMAGE_FILE_MACHINE_I386
+            34404) echo x64; return 0 ;;    # 0x8664  IMAGE_FILE_MACHINE_AMD64
+        esac
+    fi
+    echo other
+}
+
+# _pmn_wine_lacks_wine64 <wine>: 0 if <wine> is Debian/Ubuntu's helper script
+# and this machine has that packaging's 32-bit loader but no 64-bit one -- the
+# state described below -- so that a 64-bit program cannot run here whatever
+# else is tried. Recognised by layout rather than by which version of wine it
+# is: a script under /usr/bin (alternatives -> wine-stable or
+# wine-development) beside a loader directory that holds wine but no wine64.
+_pmn_wine_lacks_wine64() {
+    local emu real dir
+    emu="$(command -v "$1" 2>/dev/null)" || return 1
+    real="$(readlink -f "$emu" 2>/dev/null)" || real="$emu"
+    case "$real" in
+        /usr/bin/wine-development) dir=/usr/lib/wine-development ;;
+        /usr/bin/*)                dir=/usr/lib/wine ;;
+        *)                         return 1 ;;
+    esac
+    [ "$(head -c2 "$real" 2>/dev/null)" = '#!' ] && [ -x "$dir/wine" ] && [ ! -x "$dir/wine64" ]
+}
+
+# _pmn_wine64_loader <wine>: prints a loader that can run 64-bit Windows
+# programs and create a 64-bit prefix for them, given the plain `wine` the
+# toolchain registered -- or fails if it knows of nothing better than <wine>.
+#
+# Plain `wine` isn't always that. On Debian and Ubuntu it is a helper script
+# (alternatives -> wine-stable / wine-development), not a loader, and the one
+# in wine 9.0's packaging runs the 32-bit loader whenever wine32 is installed
+# -- which breeze/scripts/setup.sh makes sure of, for the 32-bit preset. A 32-bit
+# loader with no wine64 to hand over to creates a 32-bit prefix even under
+# WINEARCH=win64 and then refuses it: "WINEARCH set to win64 but '<prefix>'
+# is a 32-bit installation". That is what a machine looks like after
+# `apt-get install wine wine32:i386` (wine only depends on "wine64 | wine32",
+# so wine64 gets left out): reproduced, with that exact output, from that
+# command. The 64-bit loader is a separate file there, /usr/lib/wine/wine64,
+# and nothing puts it on PATH.
+_pmn_wine64_loader() {
+    local emu real w64
+    emu="$(command -v "$1" 2>/dev/null)" || return 1
+    real="$(readlink -f "$emu" 2>/dev/null)" || real="$emu"
+    # A wine64 right next to it: Arch, Fedora, WineHQ's /opt/wine-*/bin, ...
+    for w64 in "${real%/*}/wine64" "${emu%/*}/wine64"; do
+        if [ -x "$w64" ]; then
+            printf '%s\n' "$w64"
+            return 0
+        fi
+    done
+    case "${real##*/}" in
+        wine-stable)      w64=/usr/lib/wine/wine64 ;;
+        wine-development) w64=/usr/lib/wine-development/wine64 ;;
+        *)                return 1 ;;
+    esac
+    if [ -x "$w64" ]; then
+        printf '%s\n' "$w64"
+        return 0
+    fi
+    return 1
+}
+
+# A cross build's toolchain file (breeze/cmake/toolchains/) registers an emulator --
+# qemu-user for another CPU, wine for Windows -- as
+# CMAKE_CROSSCOMPILING_EMULATOR when one is installed, which is also what
+# lets ctest run the same binaries. Use it the same way. It's a
+# ";"-separated list (the emulator, then its arguments).
+RUN_PREFIX=()
+if [ -f "${BUILD_DIR}/CMakeCache.txt" ]; then
+    _pmn_emulator="$(sed -n 's/^CMAKE_CROSSCOMPILING_EMULATOR:[A-Z]*=//p' "${BUILD_DIR}/CMakeCache.txt")"
+    if [ -n "$_pmn_emulator" ]; then
+        IFS=';' read -r -a RUN_PREFIX <<< "$_pmn_emulator"
+    fi
+fi
+
+# Wine refuses to start at all without a valid XDG_RUNTIME_DIR -- "error:
+# XDG_RUNTIME_DIR is invalid or not set in the environment" -- even for a
+# console-only .exe that needs no desktop integration whatsoever; a
+# session manager normally sets this, which containers (confirmed on a
+# distrobox one) typically have no reason to run. Wine only checks that
+# the directory exists with the right ownership/permissions, not that it
+# came from a real session, so a private one under TMPDIR is enough to
+# get past this. Only for wine, and only if nothing is already set -- a
+# real desktop session already has a real one, left alone.
+case "${RUN_PREFIX[0]:-}" in
+    */wine|wine|*/wine64|wine64)
+        if [ -z "${XDG_RUNTIME_DIR:-}" ]; then
+            export XDG_RUNTIME_DIR="${TMPDIR:-/tmp}/xdg-runtime-$(id -u)"
+            mkdir -p "$XDG_RUNTIME_DIR" 2>/dev/null
+            chmod 700 "$XDG_RUNTIME_DIR" 2>/dev/null
+        fi
+
+        # 32-bit or 64-bit, read from the program itself. Everything below
+        # keeps the two apart, because a wine prefix is one or the other from
+        # the moment it is created and is never shared safely between them.
+        _pmn_kind="$(_pmn_pe_kind "$BIN_PATH")"
+
+        # A 64-bit program needs a loader that can build and run a 64-bit
+        # prefix, which plain `wine` isn't everywhere (see
+        # _pmn_wine64_loader).
+        if [ "$_pmn_kind" = x64 ] && [ "${RUN_PREFIX[0]##*/}" = wine ]; then
+            if _pmn_w64="$(_pmn_wine64_loader "${RUN_PREFIX[0]}")"; then
+                RUN_PREFIX[0]="$_pmn_w64"
+            elif _pmn_wine_lacks_wine64 "${RUN_PREFIX[0]}"; then
+                # Nothing below can make this work, and trying only ends in
+                # wine's own "WINEARCH set to win64 but ... is a 32-bit
+                # installation" -- which says nothing about the cause.
+                echo "error: ${TARGET_NAME} is a 64-bit Windows program, but this machine has only the" >&2
+                echo "       32-bit wine, which can neither run it nor create the 64-bit prefix it" >&2
+                echo "       needs. Debian and Ubuntu package the 64-bit part separately:" >&2
+                echo "           sudo apt install wine64        (breeze/scripts/setup.sh installs it too)" >&2
+                exit 1
+            fi
+        fi
+        # Running Debian's own loader directly -- chosen just above, or
+        # already what the build registered -- means going around the helper
+        # script that normally runs it, so do the two things that script does
+        # for wine64: point WINELOADER at it, and quiet wine's "fixme:"
+        # chatter with WINEDEBUG=fixme-all. Each only if nothing set it.
+        case "${RUN_PREFIX[0]}" in
+            /usr/lib/wine/wine64|/usr/lib/wine-development/wine64)
+                if [ -z "${WINELOADER:-}" ]; then export WINELOADER="${RUN_PREFIX[0]}"; fi
+                if [ -z "${WINEDEBUG:-}" ]; then export WINEDEBUG=fixme-all; fi
+                ;;
+        esac
+
+        # Default wine prefix is ~/.wine, shared with every other use of
+        # wine on the machine -- scoping it under .cache/ instead makes a
+        # fresh `rm -rf .cache/wine` the fix for anything that looks like a
+        # wine problem rather than a build one, and keeps this project's
+        # own wine state from mixing with anything else's. One prefix per
+        # kind of program (.cache/wine/x86, .cache/wine/x64): a prefix's
+        # architecture is fixed by whichever program first creates it, so
+        # sharing one made the outcome depend on which preset happened to
+        # run first, and on a wine whose 32-bit loader can only make 32-bit
+        # prefixes, no amount of recreating it helped. Only if WINEPREFIX
+        # isn't already set -- someone who's deliberately pointed it
+        # elsewhere gets left alone, and that includes never deleting it.
+        if [ -z "${WINEPREFIX:-}" ]; then
+            # Older versions used .cache/wine itself as the one prefix. A
+            # prefix has a system.reg at its top, so that is easy to tell
+            # apart from this layout; its content is only a disposable cache.
+            if [ -f "$PWD/.cache/wine/system.reg" ]; then
+                rm -rf "$PWD/.cache/wine"
+            fi
+            export WINEPREFIX="$PWD/.cache/wine/$_pmn_kind"
+            # A 64-bit prefix recorded as 32-bit (a prefix's own system.reg
+            # says which, in a line reading exactly "#arch=win32" or
+            # "#arch=win64") can't be what asked for 64-bit, and wine refuses
+            # to run anything against it once WINEARCH=win64 disagrees --
+            # so it's rebuilt, since it's this project's own cache.
+            if [ "$_pmn_kind" = x64 ] && [ -f "$WINEPREFIX/system.reg" ] \
+                && grep -q '^#arch=win32' "$WINEPREFIX/system.reg" 2>/dev/null; then
+                rm -rf "$WINEPREFIX"
+            fi
+        fi
+        # Wine creates the last component of the prefix path and no more, so
+        # with no .cache/ yet (a fresh checkout) it fails: "wine: chdir to
+        # <prefix> : No such file or directory".
+        mkdir -p "$WINEPREFIX"
+
+        # A 64-bit prefix is asked for outright, so that one that can't be
+        # made fails at once and by name rather than as a 32-bit prefix that
+        # then can't run the program. Left alone for 32-bit programs: any
+        # prefix runs those, and forcing win32 isn't possible on every wine.
+        if [ "$_pmn_kind" = x64 ] && [ -z "${WINEARCH:-}" ]; then
+            export WINEARCH=win64
+        fi
+        ;;
+esac
+
+# Which build this came from -- to stderr, so a program's own stdout stays
+# clean to pipe.
+echo "==> Running ${TARGET_NAME} (${BUILD_DIR})${RUN_PREFIX[0]:+ under ${RUN_PREFIX[0]##*/}}" >&2
+
+# Not `exec`, so a failure to start at all can be explained below.
+_pmn_status=0
+${RUN_PREFIX[@]+"${RUN_PREFIX[@]}"} "$BIN_PATH" "$@" || _pmn_status=$?
+
+# 126 is the shell's "found it, couldn't execute it" -- which is what running
+# a binary built for another architecture or OS looks like.
+if [ "$_pmn_status" -eq 126 ]; then
+    echo "error: '${BIN_PATH}' couldn't be started on this machine. If it is a cross build" >&2
+    echo "       (built for another CPU or OS), run it on the target, or install an" >&2
+    echo "       emulator -- qemu-user for another CPU, wine for Windows -- and reconfigure" >&2
+    echo "       (breeze/scripts/build.sh --preset <name>) so the toolchain picks it up." >&2
+fi
+exit "$_pmn_status"
diff --git a/breeze/scripts/setup.bat b/breeze/scripts/setup.bat
new file mode 100644
index 0000000..e673429
--- /dev/null
+++ b/breeze/scripts/setup.bat
@@ -0,0 +1,226 @@
+@echo off
+REM One-time (or re-run any time) environment setup for this template.
+REM Windows; on Linux and macOS it is breeze/scripts/setup.sh.
+REM
+REM   1. Checks for the tools this project builds with -- Git, CMake 3.25+ and a
+REM      C++ compiler (Visual Studio Build Tools, or MinGW-w64 through MSYS2:
+REM      required), plus LLVM, the MSVC ARM64 build tools and the other MSYS2
+REM      toolchains (optional) -- and
+REM      offers to install whatever is missing, ONE TOOL AT A TIME, showing the
+REM      exact command before running it. Nothing is installed without
+REM      your yes. The work is done by breeze\scripts\_tools.ps1 (PowerShell: prompts,
+REM      PATH handling and winget are far more robust there than in batch).
+REM   2. Fetches the pinned ninja (breeze\cmake\FetchNinja.cmake) -- used by
+REM      breeze\scripts\build.bat if found (see there); a system ninja still
+REM      works fine too, this just avoids needing one installed at all.
+REM   3. Fetches the pinned Doxygen (breeze\cmake\FetchDoxygen.cmake) -- NOT
+REM      required to build the project itself (see breeze\cmake\Documentation.cmake),
+REM      only to run breeze\scripts\docs.bat afterward.
+REM   4. Activates the pre-commit hook (breeze\githooks\pre-commit) for this
+REM      clone, if it's a git repository.
+REM
+REM A failure in step 2 or 3 (no pinned binary for this machine, no network)
+REM is reported and setup carries on -- it used to stop there, before the hook
+REM was activated.
+REM
+REM Usage (from the project root):
+REM   breeze\scripts\setup.bat [--yes] [--all] [--everything] [--check] [--skip-tools]
+REM   breeze\scripts\setup.bat --help
+REM
+REM No delayed expansion in this file, on purpose: PATH is edited below, and
+REM with delayed expansion on, a "!" in any directory name would be eaten.
+setlocal
+
+REM %~dp0 is captured first: a plain SHIFT (used to walk the arguments below)
+REM shifts %0 as well.
+set "_PMN_HERE=%~dp0"
+
+set "_PMN_TOOLS_ARGS="
+set "_PMN_SKIP_TOOLS=0"
+set "_PMN_CHECK=0"
+set "_PMN_TOOLS_RC=0"
+
+:parse_args
+if "%~1"=="" goto args_done
+if /i "%~1"=="-h" goto show_help
+if /i "%~1"=="--help" goto show_help
+if /i "%~1"=="-y" goto opt_yes
+if /i "%~1"=="--yes" goto opt_yes
+if /i "%~1"=="--all" goto opt_all
+REM --everything: on Linux it also does slow extras (AUR builds); nothing on
+REM Windows needs more than --all, so it means the same here.
+if /i "%~1"=="--everything" goto opt_all
+if /i "%~1"=="--check" goto opt_check
+if /i "%~1"=="--skip-tools" goto opt_skip_tools
+echo error: unknown option "%~1" 1>&2
+echo Run breeze\scripts\setup.bat --help for usage. 1>&2
+exit /b 1
+
+:opt_yes
+set "_PMN_TOOLS_ARGS=%_PMN_TOOLS_ARGS% -Yes"
+shift
+goto parse_args
+
+:opt_all
+set "_PMN_TOOLS_ARGS=%_PMN_TOOLS_ARGS% -All"
+shift
+goto parse_args
+
+:opt_check
+set "_PMN_TOOLS_ARGS=%_PMN_TOOLS_ARGS% -Check"
+set "_PMN_CHECK=1"
+shift
+goto parse_args
+
+:opt_skip_tools
+set "_PMN_SKIP_TOOLS=1"
+shift
+goto parse_args
+
+:show_help
+echo Usage: breeze\scripts\setup.bat [--yes] [--all] [--everything] [--check] [--skip-tools]
+echo.
+echo One-time ^(or re-run any time^) environment setup for this template:
+echo   1. Checks the tools the project builds with and offers to install what's
+echo      missing, one tool at a time ^(Git, CMake and a C++ compiler are
+echo      required; LLVM, the MSVC ARM64 build tools and the other MSYS2
+echo      toolchains are optional^). Each
+echo      install shows its exact command and waits for your yes.
+echo   2. Fetches the pinned ninja ^(breeze\cmake\FetchNinja.cmake^).
+echo   3. Fetches the pinned Doxygen ^(breeze\cmake\FetchDoxygen.cmake^).
+echo   4. Activates the pre-commit hook ^(breeze\githooks\pre-commit^) for this clone,
+echo      if it's a git repository.
+echo.
+echo Options:
+echo   -y, --yes       Install the REQUIRED tools without asking. For scripts and
+echo                   CI; without a terminal and without this, nothing is asked
+echo                   and nothing is installed.
+echo       --all       Also install the optional tools without asking ^(implies
+echo                   --yes^).
+echo       --everything  Same as --all here. ^(On Linux, breeze/scripts/setup.sh --everything
+echo                   also does slow extras such as AUR builds; Windows has none.^)
+echo       --check     Only report what is and isn't installed; change nothing,
+echo                   fetch nothing. Exits 1 if a required tool is missing.
+echo       --skip-tools  Skip step 1 and go straight to the pinned downloads.
+echo.
+echo At each question:  y  install it   n  not this one   a  install everything
+echo left   s  skip the rest of the optional tools   q  stop asking.
+echo.
+echo See the comment at the top of this script for more on each step.
+exit /b 0
+
+:args_done
+cd /d "%_PMN_HERE%..\.."
+
+REM ---- 1. tools --------------------------------------------------------------
+if "%_PMN_SKIP_TOOLS%"=="1" goto tools_done
+where powershell >nul 2>nul
+if errorlevel 1 goto no_powershell
+
+set "_PMN_PATHFILE=%TEMP%\pmn-path-%RANDOM%%RANDOM%.txt"
+powershell -NoProfile -ExecutionPolicy Bypass -File "%_PMN_HERE%_tools.ps1" %_PMN_TOOLS_ARGS% -PathOut "%_PMN_PATHFILE%"
+set "_PMN_TOOLS_RC=%ERRORLEVEL%"
+
+REM The installer adds tool folders (CMake, Git, ...) to ITS copy of PATH so
+REM it can use them; a child process can't change ours, so it hands the list
+REM back in a file and they're appended here, for the steps below.
+if exist "%_PMN_PATHFILE%" call :take_path_additions
+echo.
+goto tools_done
+
+:no_powershell
+echo error: powershell.exe not found on PATH -- it runs the tool installer. 1>&2
+echo        Install the tools yourself and re-run with --skip-tools. 1>&2
+exit /b 1
+
+:tools_done
+if not "%_PMN_CHECK%"=="1" goto after_check
+if "%_PMN_TOOLS_RC%"=="0" goto check_ok
+echo ==^> Required tools are missing. Run breeze\scripts\setup.bat to install them.
+exit /b %_PMN_TOOLS_RC%
+:check_ok
+echo ==^> All required tools are present.
+exit /b 0
+:after_check
+
+REM Everything below runs CMake scripts.
+where cmake >nul 2>nul
+if errorlevel 1 goto no_cmake
+goto have_cmake
+:no_cmake
+echo error: cmake not found on PATH -- nothing below can run without it. 1>&2
+if "%_PMN_SKIP_TOOLS%"=="1" goto no_cmake_skip
+echo        Install CMake ^(3.25 or newer^), open a new terminal, and re-run this script. 1>&2
+exit /b 1
+:no_cmake_skip
+echo        Re-run without --skip-tools to be offered an install. 1>&2
+exit /b 1
+:have_cmake
+
+REM ---- 2. pinned ninja -------------------------------------------------------
+echo ==^> Fetching pinned ninja (breeze\cmake\FetchNinja.cmake)
+cmake -P breeze\cmake\FetchNinja.cmake
+if errorlevel 1 goto ninja_failed
+goto ninja_done
+:ninja_failed
+echo.
+echo     No pinned ninja here ^(no upstream binary for this machine, or the
+echo     download failed -- see above^).
+where ninja >nul 2>nul
+if errorlevel 1 goto ninja_missing
+echo     The ninja on PATH will be used instead.
+goto ninja_done
+:ninja_missing
+echo     breeze\scripts\build.bat needs a ninja: e.g.  winget install Ninja-build.Ninja
+:ninja_done
+
+REM ---- 3. pinned Doxygen -----------------------------------------------------
+echo.
+echo ==^> Fetching pinned Doxygen (breeze\cmake\FetchDoxygen.cmake)
+cmake -P breeze\cmake\FetchDoxygen.cmake
+if errorlevel 1 goto doxygen_failed
+goto doxygen_done
+:doxygen_failed
+echo.
+echo     Documentation ^(breeze\scripts\docs.bat^) won't be available: there's no pinned
+echo     Doxygen for this machine, or the download failed -- see above.
+echo     The project itself builds fine without it.
+:doxygen_done
+
+REM ---- 4. pre-commit hook ----------------------------------------------------
+echo.
+git rev-parse --is-inside-work-tree >nul 2>nul
+if errorlevel 1 goto hook_skip
+echo ==^> Activating pre-commit hook
+git config core.hooksPath breeze/githooks
+echo     core.hooksPath = breeze/githooks
+goto hook_done
+:hook_skip
+echo ==^> Skipping pre-commit hook activation ^(not a git repository yet^)
+echo     Once you've run "git init", re-run this script or:
+echo       git config core.hooksPath breeze/githooks
+:hook_done
+
+echo.
+if "%_PMN_TOOLS_RC%"=="0" goto setup_ok
+echo ==^> Setup finished, but a required tool is still missing -- see above.
+exit /b 1
+:setup_ok
+echo ==^> Setup complete. breeze\scripts\build.bat and breeze\scripts\docs.bat are ready to use.
+exit /b 0
+
+REM ---------------------------------------------------------------------
+REM :take_path_additions
+REM
+REM Appends every directory listed in %_PMN_PATHFILE% to PATH, then deletes
+REM the file. One "for /f ... do call" line, deliberately not a parenthesized
+REM block: a directory like "C:\Program Files (x86)\..." would close it early.
+REM ---------------------------------------------------------------------
+:take_path_additions
+for /f "usebackq delims=" %%D in ("%_PMN_PATHFILE%") do call :add_path "%%D"
+del "%_PMN_PATHFILE%" >nul 2>nul
+goto :eof
+
+:add_path
+set "PATH=%PATH%;%~1"
+goto :eof
diff --git a/breeze/scripts/setup.sh b/breeze/scripts/setup.sh
new file mode 100644
index 0000000..792428b
--- /dev/null
+++ b/breeze/scripts/setup.sh
@@ -0,0 +1,175 @@
+#!/usr/bin/env bash
+# One-time (or re-run any time) environment setup for this template. Linux
+# and macOS; on Windows it is breeze\scripts\setup.bat.
+#
+#   1. Checks for the tools this project builds with -- git, CMake 3.25+ and a
+#      C++ compiler (both of which are required), and Clang, clang-format,
+#      clang-tidy, cross compilers, MinGW and emulators (all optional) -- and
+#      offers to install whatever is missing, ONE TOOL AT A TIME, showing
+#      the exact command before running it. Nothing is installed without
+#      your yes. See breeze/scripts/_tools.sh for what it knows and how.
+#   2. Fetches the pinned ninja (breeze/cmake/FetchNinja.cmake) -- used by
+#      breeze/scripts/build.sh / build.bat if found (see there); a system ninja
+#      still works fine too, this just avoids needing one installed at all.
+#      Where upstream ships no ninja binary for your machine, it offers to
+#      install one through your package manager instead.
+#   3. Fetches the pinned Doxygen (breeze/cmake/FetchDoxygen.cmake) -- NOT
+#      required to build the project itself (see breeze/cmake/Documentation.cmake),
+#      only to run breeze/scripts/docs.sh / docs.bat afterward.
+#   4. Activates the pre-commit hook (breeze/githooks/pre-commit) for this
+#      clone, if it's a git repository.
+#
+# A failure in step 2 or 3 (no pinned binary for this machine, no network)
+# is reported and setup carries on -- it used to abort here, before the hook
+# was activated.
+#
+# Usage (from the project root):
+#   breeze/scripts/setup.sh [--yes] [--all] [--everything] [--check] [--skip-tools]
+#   breeze/scripts/setup.sh --help
+set -euo pipefail
+
+_usage() {
+    cat <<'EOF'
+Usage: breeze/scripts/setup.sh [--yes] [--all] [--everything] [--check] [--skip-tools]
+
+One-time (or re-run any time) environment setup for this template:
+  1. Checks the tools the project builds with and offers to install what's
+     missing, one tool at a time (git, CMake and a C++ compiler are
+     required; Clang, clang-format/clang-tidy, cross compilers, MinGW and
+     emulators are optional). Each install shows its exact command and
+     waits for your yes.
+  2. Fetches the pinned ninja (breeze/cmake/FetchNinja.cmake).
+  3. Fetches the pinned Doxygen (breeze/cmake/FetchDoxygen.cmake).
+  4. Activates the pre-commit hook (breeze/githooks/pre-commit) for this clone,
+     if it's a git repository.
+
+Options:
+  -y, --yes       Install the REQUIRED tools without asking. For scripts and
+                  CI; without a terminal and without this, nothing is asked
+                  and nothing is installed.
+      --all       Also install the optional tools without asking (implies
+                  --yes). This includes saying yes to the extra-repository
+                  questions that come with some of them: enabling pacman's
+                  multilib, dnf's COPR for the ARM cross compilers, apt's
+                  i386 architecture for wine32.
+      --everything  Everything --all does, plus the third-party extras that
+                  --all leaves for you to opt into (implies --all). On
+                  Arch: the prebuilt 32-bit ARM cross toolchain from the
+                  AUR -- four packages built with makepkg (git and
+                  base-devel are installed first if missing): a download
+                  and a few minutes, no compiling. Run interactively,
+                  setup asks about it as its own question instead.
+                  Elsewhere there is nothing extra, so it means the same
+                  as --all.
+      --check     Only report what is and isn't installed; change nothing,
+                  fetch nothing. Exits 1 if a required tool is missing.
+      --skip-tools  Skip step 1 and go straight to the pinned downloads.
+
+At each question:  y  install it   n  not this one   a  install everything
+left   s  skip the rest of the optional tools   q  stop asking.
+
+See the comment at the top of this script for more on each step.
+EOF
+}
+
+PMN_TOOLS_YES=0
+PMN_TOOLS_ALL=0
+PMN_TOOLS_HEAVY=0
+PMN_TOOLS_CHECK=0
+SKIP_TOOLS=0
+while [ $# -gt 0 ]; do
+    case "$1" in
+        -h|--help)    _usage; exit 0 ;;
+        -y|--yes)     PMN_TOOLS_YES=1 ;;
+        --all)        PMN_TOOLS_ALL=1; PMN_TOOLS_YES=1 ;;
+        --everything) PMN_TOOLS_HEAVY=1; PMN_TOOLS_ALL=1; PMN_TOOLS_YES=1 ;;
+        --check)      PMN_TOOLS_CHECK=1 ;;
+        --skip-tools) SKIP_TOOLS=1 ;;
+        *)
+            echo "error: unknown option '$1'" >&2
+            echo "Run breeze/scripts/setup.sh --help for usage." >&2
+            exit 1
+            ;;
+    esac
+    shift
+done
+export PMN_TOOLS_YES PMN_TOOLS_ALL PMN_TOOLS_HEAVY PMN_TOOLS_CHECK
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+cd "$SCRIPT_DIR/../.."
+
+# _pmn_tools_run, _pmn_tools_offer and their helpers.
+source "$SCRIPT_DIR/_tools.sh"
+
+# ---- 1. tools --------------------------------------------------------------
+_tools_rc=0
+if [ "$SKIP_TOOLS" = 0 ]; then
+    _pmn_tools_run || _tools_rc=$?
+    echo
+fi
+
+if [ "$PMN_TOOLS_CHECK" = 1 ]; then
+    if [ "$_tools_rc" -ne 0 ]; then
+        echo "==> Required tools are missing. Run breeze/scripts/setup.sh to install them."
+    else
+        echo "==> All required tools are present."
+    fi
+    exit "$_tools_rc"
+fi
+
+# Everything below runs CMake scripts.
+if ! command -v cmake >/dev/null 2>&1; then
+    echo "error: cmake not found on PATH -- nothing below can run without it." >&2
+    if [ "$SKIP_TOOLS" = 1 ]; then
+        echo "       Re-run without --skip-tools to be offered an install." >&2
+    else
+        echo "       Install CMake (3.25 or newer), open a new terminal, and re-run this script." >&2
+    fi
+    exit 1
+fi
+
+# ---- 2. pinned ninja -------------------------------------------------------
+echo "==> Fetching pinned ninja (breeze/cmake/FetchNinja.cmake)"
+if ! cmake -P breeze/cmake/FetchNinja.cmake; then
+    echo
+    echo "    No pinned ninja here (no upstream binary for this machine, or the"
+    echo "    download failed -- see above)."
+    if command -v ninja >/dev/null 2>&1; then
+        echo "    The ninja on PATH will be used instead: $(command -v ninja)"
+    elif [ "$SKIP_TOOLS" = 0 ]; then
+        # A build needs SOME ninja; this is the machine-specific moment to say so.
+        _pmn_tools_offer ninja || echo "    breeze/scripts/build.sh needs a ninja: install one and put it on PATH."
+    else
+        echo "    breeze/scripts/build.sh needs a ninja: install one and put it on PATH."
+    fi
+fi
+
+# ---- 3. pinned Doxygen -----------------------------------------------------
+echo
+echo "==> Fetching pinned Doxygen (breeze/cmake/FetchDoxygen.cmake)"
+if ! cmake -P breeze/cmake/FetchDoxygen.cmake; then
+    echo
+    echo "    Documentation (breeze/scripts/docs.sh) won't be available: there's no pinned"
+    echo "    Doxygen for this machine, or the download failed -- see above."
+    echo "    The project itself builds fine without it."
+fi
+
+# ---- 4. pre-commit hook ----------------------------------------------------
+echo
+if git rev-parse --is-inside-work-tree >/dev/null 2>&1; then
+    echo "==> Activating pre-commit hook"
+    chmod +x breeze/githooks/pre-commit
+    git config core.hooksPath breeze/githooks
+    echo "    core.hooksPath = breeze/githooks"
+else
+    echo "==> Skipping pre-commit hook activation (not a git repository yet)"
+    echo "    Once you've run 'git init', re-run this script or:"
+    echo "      chmod +x breeze/githooks/pre-commit && git config core.hooksPath breeze/githooks"
+fi
+
+echo
+if [ "$_tools_rc" -ne 0 ]; then
+    echo "==> Setup finished, but a required tool is still missing -- see above."
+    exit 1
+fi
+echo "==> Setup complete. breeze/scripts/build.sh and breeze/scripts/docs.sh are ready to use."
diff --git a/c-api/.clang-tidy b/c-api/.clang-tidy
new file mode 100644
index 0000000..95e1c5e
--- /dev/null
+++ b/c-api/.clang-tidy
@@ -0,0 +1,57 @@
+---
+# c-api/.clang-tidy
+# Place this file at the root of whatever directory holds your Part II
+# (C API) surface — e.g. c-api/, public-include/, or wherever your extern "C"
+# headers and shims live. clang-tidy always uses the closest .clang-tidy file
+# up the directory tree, so files under this directory pick up these
+# snake_case naming rules instead of the PascalCase/camelCase rules in the
+# repo-root .clang-tidy, without any extra flags or per-file configuration.
+#
+# Formatting (tabs, Allman braces, line length) still comes from the single
+# root-level .clang-format — only naming differs between Part I and Part II,
+# per style guide §15 (Indentation and Braces).
+InheritParentConfig: true
+
+Checks: >
+  readability-identifier-naming,
+  bugprone-exception-escape
+
+CheckOptions:
+  # --- C API naming — style guide §13 ---
+  # Every public symbol uses snake_case with a library/module prefix
+  # (e.g. net_manager_connect, NET_MAX_RETRIES). clang-tidy can enforce the
+  # casing; the prefix itself is a code-review convention.
+  - key: readability-identifier-naming.FunctionCase
+    value: lower_case
+  - key: readability-identifier-naming.VariableCase
+    value: lower_case
+  - key: readability-identifier-naming.ParameterCase
+    value: lower_case
+  - key: readability-identifier-naming.LocalVariableCase
+    value: lower_case
+
+  - key: readability-identifier-naming.StructCase
+    value: CamelCase
+  - key: readability-identifier-naming.EnumCase
+    value: CamelCase
+  # Enum values — ALL_CAPS_SNAKE_CASE with a library + enum prefix
+  # (e.g. NET_STATE_CONNECTED).
+  - key: readability-identifier-naming.EnumConstantCase
+    value: UPPER_CASE
+
+  - key: readability-identifier-naming.GlobalConstantCase
+    value: UPPER_CASE
+  - key: readability-identifier-naming.MacroDefinitionCase
+    value: UPPER_CASE
+
+  # Internal (non-exported) global/static variables — style guide §13's
+  # g_/s_ rows. Only applies to mutable state; GlobalConstantCase above
+  # still governs const globals, which stay UPPER_CASE with no prefix.
+  - key: readability-identifier-naming.GlobalVariableCase
+    value: lower_case
+  - key: readability-identifier-naming.GlobalVariablePrefix
+    value: g_
+  - key: readability-identifier-naming.StaticVariableCase
+    value: lower_case
+  - key: readability-identifier-naming.StaticVariablePrefix
+    value: s_
diff --git a/project/Configuration.cmake b/project/Configuration.cmake
new file mode 100644
index 0000000..ec2a3de
--- /dev/null
+++ b/project/Configuration.cmake
@@ -0,0 +1,168 @@
+# =============================================================================
+# project/Configuration.cmake
+#
+# The project's own settings: the one file to edit to say who this project is
+# and where its output goes. Everything that makes the build work is the
+# template's -- breeze/ -- and is replaced wholesale when the template is
+# updated; nothing in this file is. Change a value here, or override a cache
+# variable with -D<NAME>=... at configure time, instead of hunting through
+# CMakeLists.txt, breeze/cmake/*.cmake -- or a script under breeze/scripts/ --
+# for a hardcoded copy. If you find yourself typing a value this file already
+# defines anywhere else, that's a bug: read it from here instead (see "How
+# scripts read this file" below for the non-CMake side of that).
+#
+# What is NOT here: the target selection (DIST_TARGET, PLATFORM, ARCHITECTURE,
+# COMPILER_ID). That is the template's, in breeze/cmake/TargetSelection.cmake.
+#
+# -----------------------------------------------------------------------
+# Project identity
+# -----------------------------------------------------------------------
+#   PROJECT_CODE_NAME   machine-friendly identifier baked into every
+#                        target as PROJECT_NAME_CODE (BuildHelpers.cmake's
+#                        _finalize_module_target) and used as the
+#                        `cmake --install --component` name (CMakeLists.txt's
+#                        install() calls, breeze/scripts/install.sh / install.bat).
+#   DEFAULT_BUILD_TYPE   what CMAKE_BUILD_TYPE (single-config Ninja) and
+#                        the scripts' own BUILD_TYPE argument default to
+#                        when nothing else is specified.
+#
+# -----------------------------------------------------------------------
+# Output layout
+# -----------------------------------------------------------------------
+# Everything this project generates lives under one OUT_DIR:
+#
+#   out/
+#     build/<preset>/                  CMAKE_BINARY_DIR -- one build tree per
+#                                       preset (BUILD_OUTPUT_DIR is the
+#                                       root), so switching presets never
+#                                       reuses, invalidates or wipes another
+#                                       preset's cache. CMakePresets.json's
+#                                       binaryDir and breeze/scripts/build.sh
+#                                       (-B out/build/<preset>) agree on it;
+#                                       without a preset the scripts use
+#                                       out/build/default. Compiled
+#                                       artifacts land in
+#                                       <build>/<RUNTIME_OUTPUT_SUBDIR> and
+#                                       <build>/<ARCHIVE_OUTPUT_SUBDIR>
+#                                       during normal day-to-day builds.
+#     install/<DIST_TARGET>/{bin,lib}  what `cmake --install` / breeze/scripts/
+#                                       install.sh populates -- the same
+#                                       name as build/<preset>, since a
+#                                       preset is named after its target.
+#     dist/                            reserved for packaged/archived
+#                                       output (e.g. a future CPack
+#                                       integration) -- not populated by
+#                                       this project yet, but the path is
+#                                       configured and ready.
+#     docs/<module>/html, docs/index.html   generated Doxygen output
+#                                       (breeze/cmake/Documentation.cmake).
+#
+# One thing lives outside OUT_DIR on purpose: .cache/tools/ (TOOLCACHE_DIR)
+# caches downloaded, pinned build tools (currently Ninja and Doxygen), kept
+# separate so a clean `rm -rf out/` doesn't force a re-download.
+#
+# .gitignore is kept in sync with the paths below automatically, every
+# configure -- see the bottom of this file.
+#
+# -----------------------------------------------------------------------
+# How scripts read this file
+# -----------------------------------------------------------------------
+# breeze/scripts/build.sh|build.bat and breeze/scripts/install.sh|install.bat need
+# values from here too (the install component name, the default build type,
+# where the tool cache lives) but are running before any CMake configure exists
+# to ask. They get them from breeze/cmake/PrintConfig.cmake, a tiny `cmake -P`
+# script that includes this file and prints one value -- see that file for the
+# exact mechanism, and any of the four scripts above for how each shell dialect
+# calls it. Choosing WHICH build directory a script works on (a --preset, or the
+# one built last) is the same kind of job and is done the same way, by
+# breeze/cmake/BuildDir.cmake, so that logic exists once for both shell
+# dialects. That's what makes this file a *real* source of truth end to end:
+# nothing outside it -- not a .cmake module, not a shell script, not
+# .gitignore -- hardcodes a second copy of a value defined here.
+#
+# One consequence: a plain `cmake -P` script never runs project() and so never
+# gets real compiler detection -- WIN32, CMAKE_CXX_COMPILER_ID,
+# CMAKE_SIZEOF_VOID_P etc. can't be trusted there. That is why this file holds
+# settings only: everything that needs a compiler is the template's, in
+# breeze/cmake/TargetSelection.cmake, which only a real configure includes (as
+# it does the .gitignore sync and the other file system side effects). Keep it
+# that way: anything added here must be evaluable without a compiler, must
+# not touch the disk and must not message(STATUS ...) -- a script reads the
+# output of its query, and a query runs far more often than a real configure.
+#
+# Included by CMakeLists.txt before project() (project() takes its arguments
+# from the identity settings below), again by breeze/cmake/Breeze.cmake (a
+# no-op, see include_guard), and directly by the `cmake -P` scripts named
+# above -- a bare invocation like that never goes through CMakeLists.txt's own
+# cmake_minimum_required(), so without one of its own here, this file's
+# `IN_LIST` checks (and BuildDir.cmake's) would run under whatever policy
+# CMake defaults to outside a project -- OLD on any CMake still old enough to
+# make that a real choice (CMP0057 -- IN_LIST inside if() -- was NEW-only-by-
+# default for a long stretch of CMake versions before finally being removed
+# outright in CMake 4.0), which turns `if(x IN_LIST y)` into a straight parse
+# error. Repeating the same version CMakeLists.txt already requires is a
+# harmless no-op there; it's what makes every OTHER way into this file safe
+# too.
+# =============================================================================
+
+cmake_minimum_required(VERSION 3.25)
+include_guard(GLOBAL)
+
+# -------------------------------------------------------
+# Project identity
+# -------------------------------------------------------
+# What CMakeLists.txt hands to project(): the name, version, description and
+# languages, and the C++ standard breeze/cmake/Breeze.cmake then applies.
+set(PROJECT_TITLE          "BreezeCLI")
+set(PROJECT_VERSION_NUMBER "0.1.0")
+set(PROJECT_SUMMARY        "Global command line tool for breeze projects, SDKs and tools")
+set(PROJECT_LANGUAGES      CXX)
+set(PROJECT_CXX_STANDARD   20)
+
+# -------------------------------------------------------
+set(PROJECT_CODE_NAME "breeze" CACHE STRING
+    "Machine-friendly identifier: baked into targets as PROJECT_NAME_CODE and used as the `cmake --install` component name")
+
+set(DEFAULT_BUILD_TYPE "Release" CACHE STRING
+    "CMAKE_BUILD_TYPE / scripts BUILD_TYPE default when none is given")
+
+# -------------------------------------------------------
+# Output paths
+# -------------------------------------------------------
+set(OUT_DIR "${CMAKE_SOURCE_DIR}/out" CACHE PATH
+    "Root directory for everything this project generates: build artifacts, install trees, docs, and reserved dist packaging output")
+
+set(DIST_OUTPUT_DIR "${OUT_DIR}/dist" CACHE PATH
+    "Reserved for packaged/archived distribution output (e.g. a future CPack integration). Not populated by this project yet.")
+
+set(BUILD_OUTPUT_DIR "${OUT_DIR}/build" CACHE PATH
+    "Root of the build trees: one subdirectory (the CMAKE_BINARY_DIR) per preset, so switching presets never reuses or wipes another preset's build")
+
+set(INSTALL_OUTPUT_DIR "${OUT_DIR}/install" CACHE PATH
+    "Root of the cmake --install destination tree, one subdirectory per DIST_TARGET")
+
+set(DOCS_OUTPUT_DIR "${OUT_DIR}/docs" CACHE PATH
+    "Root of generated Doxygen documentation, one subdirectory per module")
+
+set(COMPILE_COMMANDS_DESTINATION "${CMAKE_SOURCE_DIR}/compile_commands.json" CACHE FILEPATH
+    "Where compile_commands.json is copied to after every build, for clangd/clang-tidy tooling (see CMakeLists.txt)")
+
+# Deliberately NOT under OUT_DIR: this caches downloaded, pinned build
+# tools (Ninja and Doxygen -- see breeze/cmake/FetchNinja.cmake and
+# breeze/cmake/FetchDoxygen.cmake), which are machine-local and expensive to
+# re-fetch, not build output. Keeping it separate means a clean `rm -rf
+# out/` (a normal "start fresh" gesture) doesn't force a re-download.
+set(TOOLCACHE_DIR "${CMAKE_SOURCE_DIR}/.cache/tools" CACHE PATH
+    "Where pinned build tools (currently Ninja and Doxygen) are cached, kept separate from OUT_DIR")
+
+
+# Subdirectory NAMES only (not full paths) for where compiled artifacts
+# land inside whatever the current build directory is (CMAKE_BINARY_DIR) --
+# these apply correctly no matter where -B points, including if you build
+# outside out/build/<preset> entirely. LIBRARY defaults to the same subdirectory as
+# RUNTIME because shared libraries need to sit next to the executables
+# that load them via the project's $ORIGIN-relative RPATH strategy (see
+# CMakeLists.txt).
+set(RUNTIME_OUTPUT_SUBDIR "bin" CACHE STRING "Build-dir subdirectory for runtime artifacts (executables, .dll, .so)")
+set(LIBRARY_OUTPUT_SUBDIR "bin" CACHE STRING "Build-dir subdirectory for shared-library artifacts")
+set(ARCHIVE_OUTPUT_SUBDIR "lib" CACHE STRING "Build-dir subdirectory for static/import-library artifacts (.a, .lib)")
diff --git a/source/Breeze/CMakeLists.txt b/source/Breeze/CMakeLists.txt
new file mode 100644
index 0000000..4538224
--- /dev/null
+++ b/source/Breeze/CMakeLists.txt
@@ -0,0 +1,3 @@
+# The `breeze` command: registers every command with CLIForge and hands the work to
+# breeze_core. Nothing here decides anything; main.cpp and Commands.cpp are only the command line.
+add_exe_module(breeze_exe OUTPUT_NAME "breeze" DEPENDS cliforge breeze_core)
diff --git a/source/Breeze/Commands.cpp b/source/Breeze/Commands.cpp
new file mode 100644
index 0000000..950c31f
--- /dev/null
+++ b/source/Breeze/Commands.cpp
@@ -0,0 +1,872 @@
+#include "Commands.hpp"
+
+#include <cstdint>
+
+#include <iomanip>
+#include <iostream>
+#include <set>
+
+#include "breeze/Build.hpp"
+#include "breeze/Cli.hpp"
+#include "breeze/Config.hpp"
+#include "breeze/Error.hpp"
+#include "breeze/Fs.hpp"
+#include "breeze/Modules.hpp"
+#include "breeze/Presets.hpp"
+#include "breeze/Process.hpp"
+#include "breeze/Project.hpp"
+#include "breeze/Sdks.hpp"
+#include "breeze/Text.hpp"
+#include "breeze/Tools.hpp"
+
+namespace breeze::cli
+{
+
+	int& exitCode()
+	{
+		static int s_code = 0;
+		return s_code;
+	}
+
+	namespace
+	{
+		using Str = std::optional<std::string>;
+		using Strs = std::vector<std::string>;
+
+		// ---------------------------------------------------------------- project
+
+		void showOrSet(Setting which, const Str& set)
+		{
+			Project project = requireProject();
+			if (set)
+			{
+				std::string before = readSetting(project, which);
+				writeSetting(project, which, *set);
+				std::cout << before << " -> " << *set << "\n";
+			}
+			else
+			{
+				std::cout << readSetting(project, which) << "\n";
+			}
+		}
+
+		// ---------------------------------------------------------------- config
+
+		void configValue(const char* key, const Str& set)
+		{
+			GlobalConfig cfg = GlobalConfig::load();
+			if (set)
+			{
+				if (*set == "none")
+					cfg.erase(key);
+				else
+					cfg.set(key, *set);
+				cfg.save();
+				std::cout << key << " = " << (*set == "none" ? "<not set>" : *set) << "\n";
+				return;
+			}
+			std::optional<std::string> value = cfg.effective(key);
+			std::cout << (value ? *value : "<not set>") << "\n";
+		}
+
+		// ---------------------------------------------------------------- defaults
+
+		void defaultsBuild(const char* key, const Str& set)
+		{
+			Project project = requireProject();
+			Defaults defaults = Defaults::load(project);
+			if (!set)
+			{
+				std::optional<std::string> v = defaults.build(key);
+				std::cout << (v ? *v : "<not set>") << "\n";
+				return;
+			}
+			if (*set == "none")
+			{
+				defaults.clearBuild(key);
+			}
+			else
+			{
+				std::string value = *set;
+				std::string k = key;
+				if (k == "mode")
+					value = buildTypeFor(value) == "RelWithDebInfo" ? "ReleaseDebugSymbols"
+																	: buildTypeFor(value);
+				if (k == "preset")
+				{
+					std::optional<std::string> canonical;
+					for (const Preset& p : listPresets(project))
+					{
+						if (text::normalized(p.name) == text::normalized(value))
+							canonical = p.name;
+					}
+					if (!canonical)
+						throw Error("'" + value +
+									"' is not a preset of this project for this machine "
+									"(see `cmake --list-presets`)");
+					value = *canonical;
+				}
+				defaults.setBuild(key, value);
+			}
+			defaults.save(project);
+			std::cout << "default build " << key << " = "
+					  << defaults.build(key).value_or("<not set>") << "\n";
+		}
+
+		void defaultsRun(const Str& set)
+		{
+			Project project = requireProject();
+			Defaults defaults = Defaults::load(project);
+			if (!set)
+			{
+				std::optional<std::string> v = defaults.run();
+				std::cout << (v ? *v : "<not set>") << "\n";
+				return;
+			}
+			if (*set == "none")
+			{
+				defaults.clearRun();
+			}
+			else
+			{
+				std::vector<Module> modules = scanModules(project);
+				const Module* m = findModule(modules, *set);
+				if (m == nullptr || (m->kind != ModuleKind::Exec && m->kind != ModuleKind::Test &&
+									 m->kind != ModuleKind::Example))
+					throw Error("'" + *set + "' is not an executable module of this project");
+				defaults.setRun(m->id);
+			}
+			defaults.save(project);
+			std::cout << "default run = "
+					  << (*set == "none" ? "<not set>" : defaults.run().value_or("")) << "\n";
+		}
+
+		// ---------------------------------------------------------------- generation
+
+		PresetQuery queryOf(const Str& preset, const Str& platform, const Str& arch,
+							const Str& compiler)
+		{
+			PresetQuery q;
+			q.preset = preset;
+			q.platform = platform;
+			q.arch = arch;
+			q.compiler = compiler;
+			return q;
+		}
+
+		void clean(bool noBuild, bool docs)
+		{
+			Project project = requireProject();
+			std::vector<std::string> removed = breeze::clean(project, noBuild, docs);
+			if (removed.empty())
+				std::cout << "nothing to clean\n";
+			for (const std::string& r : removed)
+				std::cout << "removed " << r << "\n";
+		}
+
+		BuildRequest requestOf(const Str& platform, const Str& arch, const Str& compiler,
+							   const Str& mode, const std::optional<std::int32_t>& jobs,
+							   const Str& preset, const Strs& cargs, const Strs& bargs,
+							   bool noConfigure, bool noBuild)
+		{
+			BuildRequest r;
+			r.preset = queryOf(preset, platform, arch, compiler);
+			r.mode = mode;
+			if (jobs)
+			{
+				if (*jobs < 1)
+					throw Error("--jobs must be at least 1");
+				r.jobs = *jobs;
+			}
+			r.configureArgs = cargs;
+			r.buildArgs = bargs;
+			r.noConfigure = noConfigure;
+			r.noBuild = noBuild;
+			return r;
+		}
+
+		void build(const Str& platform, const Str& arch, const Str& compiler, const Str& mode,
+				   const std::optional<std::int32_t>& jobs, const Str& preset, const Strs& cargs,
+				   const Strs& bargs, bool noConfigure)
+		{
+			exitCode() = breeze::build(requireProject(),
+									   requestOf(platform, arch, compiler, mode, jobs, preset,
+												 cargs, bargs, noConfigure, false));
+		}
+
+		void install(const Str& platform, const Str& arch, const Str& compiler, const Str& mode,
+					 const std::optional<std::int32_t>& jobs, const Str& preset, const Strs& cargs,
+					 const Strs& bargs, bool noConfigure, bool noBuild)
+		{
+			exitCode() = breeze::install(requireProject(),
+										 requestOf(platform, arch, compiler, mode, jobs, preset,
+												   cargs, bargs, noConfigure, noBuild));
+		}
+
+		void docs()
+		{
+			exitCode() = breeze::docs(requireProject());
+		}
+
+		void runOne(const Str& id, const Str& preset, const Str& platform, const Str& arch,
+					const Str& compiler, const Str& mode, const Strs& args)
+		{
+			(void)mode; // the SDK keeps one build directory per preset, so the mode is part of what
+						// was built
+			exitCode() =
+				breeze::run(requireProject(), id, queryOf(preset, platform, arch, compiler), args);
+		}
+
+		void runDefault(const Str& preset, const Str& platform, const Str& arch,
+						const Str& compiler, const Str& mode, const Strs& args)
+		{
+			runOne(std::nullopt, preset, platform, arch, compiler, mode, args);
+		}
+
+		void runById(const std::string& id, const Str& preset, const Str& platform, const Str& arch,
+					 const Str& compiler, const Str& mode, const Strs& args)
+		{
+			runOne(id, preset, platform, arch, compiler, mode, args);
+		}
+
+		void setup(bool required, bool all)
+		{
+			exitCode() = breeze::setup(requireProject(), required, all);
+		}
+
+		// ---------------------------------------------------------------- modules
+
+		void add(ModuleKind kind, const std::string& name, const Str& id, const Strs& deps,
+				 LibType type)
+		{
+			Project project = requireProject();
+			NewModule request;
+			request.kind = kind;
+			request.name = name;
+			request.id = id;
+			request.deps = deps;
+			request.libType = type;
+			Module m = addModule(project, request);
+			std::cout << "added " << kindName(m.kind) << " module '" << m.id << "' in "
+					  << fs::generic(std::filesystem::relative(m.dir, project.root)) << "\n";
+		}
+
+		void addExec(const std::string& name, const Str& id, const Strs& deps)
+		{
+			add(ModuleKind::Exec, name, id, deps, LibType::Unspecified);
+		}
+
+		void addLib(const std::string& name, const Str& id, const Strs& deps, bool isStatic,
+					bool isShared)
+		{
+			if (isStatic == isShared)
+				throw Error("a library is either --static or --shared; say which (not both)");
+			add(ModuleKind::Lib, name, id, deps, isShared ? LibType::Shared : LibType::Static);
+		}
+
+		void addObj(const std::string& name, const Str& id, const Strs& deps)
+		{
+			add(ModuleKind::Obj, name, id, deps, LibType::Unspecified);
+		}
+
+		void addTest(const std::string& name, const Str& id, const Strs& deps)
+		{
+			add(ModuleKind::Test, name, id, deps, LibType::Unspecified);
+		}
+
+		void addExample(const std::string& name, const Str& id, const Strs& deps)
+		{
+			add(ModuleKind::Example, name, id, deps, LibType::Unspecified);
+		}
+
+		void deleteIt(const std::string& id, bool yes)
+		{
+			Project project = requireProject();
+			std::vector<Module> modules = scanModules(project);
+			const Module* m = findModule(modules, id);
+			if (m == nullptr)
+				throw Error("there is no module '" + id + "' (see `breeze ls`)");
+			std::string where = fs::generic(std::filesystem::relative(m->dir, project.root));
+			if (!yes)
+			{
+				if (!proc::stdinIsTerminal())
+					throw Error("deleting '" + m->id + "' removes " + where +
+								"; pass --yes to do it without asking");
+				std::cout << "Delete module '" << m->id << "' and everything in " << where
+						  << "? [y/N] " << std::flush;
+				std::string answer;
+				std::getline(std::cin, answer);
+				if (text::lower(text::trim(answer)) != "y" &&
+					text::lower(text::trim(answer)) != "yes")
+				{
+					std::cout << "not deleted\n";
+					return;
+				}
+			}
+			deleteModule(project, id);
+			std::cout << "deleted " << where << "\n";
+		}
+
+		void rename(const std::string& id, const Str& name, const Str& newId)
+		{
+			Project project = requireProject();
+			RenameResult r = renameModule(project, id, name, newId);
+			if (r.oldDir != r.newDir)
+				std::cout << "directory " << r.oldDir << " -> " << r.newDir << "\n";
+			if (r.oldId != r.newId)
+				std::cout << "id " << r.oldId << " -> " << r.newId << "\n";
+			for (const std::string& d : r.updatedDependents)
+				std::cout << "updated DEPENDS in " << d << "\n";
+		}
+
+		void list(const Str& filter, bool exec, bool obj, bool lib, bool test, bool example,
+				  bool isShared, bool isStatic)
+		{
+			Project project = requireProject();
+			std::vector<Module> modules = scanModules(project);
+			bool anyKind = exec || obj || lib || test || example;
+			std::size_t idWidth = 2;
+			std::size_t dirWidth = 3;
+			std::size_t kindWidth = 4;
+			std::vector<const Module*> shown;
+			for (const Module& m : modules)
+			{
+				bool kindOk = !anyKind || (m.kind == ModuleKind::Exec && exec) ||
+							  (m.kind == ModuleKind::Obj && obj) ||
+							  (m.kind == ModuleKind::Lib && lib) ||
+							  (m.kind == ModuleKind::Test && test) ||
+							  (m.kind == ModuleKind::Example && example);
+				if (!kindOk)
+					continue;
+				if (isShared && !(m.kind == ModuleKind::Lib && m.libType == LibType::Shared))
+					continue;
+				if (isStatic && !(m.kind == ModuleKind::Lib && m.libType == LibType::Static))
+					continue;
+				if (filter && text::lower(m.id).find(text::lower(*filter)) == std::string::npos &&
+					text::lower(m.dirName).find(text::lower(*filter)) == std::string::npos)
+					continue;
+				shown.push_back(&m);
+				kindWidth = std::max(
+					kindWidth,
+					kindName(m.kind).size() +
+						(m.kind == ModuleKind::Lib && m.libType != LibType::Unspecified ? 7 : 0));
+				idWidth = std::max(idWidth, m.id.size());
+				dirWidth = std::max(
+					dirWidth, fs::generic(std::filesystem::relative(m.dir, project.root)).size());
+			}
+			if (shown.empty())
+			{
+				std::cout << "no modules\n";
+				return;
+			}
+			std::cout << std::left << std::setw(static_cast<int>(idWidth) + 2) << "ID"
+					  << std::setw(static_cast<int>(kindWidth) + 2) << "KIND"
+					  << std::setw(static_cast<int>(dirWidth) + 2) << "DIRECTORY" << "DEPENDS\n";
+			for (const Module* m : shown)
+			{
+				std::string kind = kindName(m->kind);
+				if (m->kind == ModuleKind::Lib && m->libType != LibType::Unspecified)
+					kind += m->libType == LibType::Shared ? "/shared" : "/static";
+				std::string dir = fs::generic(std::filesystem::relative(m->dir, project.root));
+				std::cout << std::left << std::setw(static_cast<int>(idWidth) + 2) << m->id
+						  << std::setw(static_cast<int>(kindWidth) + 2) << kind;
+				if (m->deps.empty())
+					std::cout << dir << "\n";
+				else
+					std::cout << std::setw(static_cast<int>(dirWidth) + 2) << dir
+							  << text::join(m->deps, " ") << "\n";
+			}
+		}
+
+		void printTree(const std::vector<Module>& modules, const std::string& id, bool dependencies,
+					   int depth, std::set<std::string>& onPath)
+		{
+			const Module* m = findModule(modules, id);
+			std::vector<std::string> next;
+			if (m != nullptr)
+			{
+				next = dependencies ? m->deps : dependentsOf(modules, *m, false);
+			}
+			for (const std::string& n : next)
+			{
+				bool known = findModule(modules, n) != nullptr;
+				std::cout << std::string(static_cast<std::size_t>(depth) * 2, ' ') << n
+						  << (known ? "" : " (external)") << "\n";
+				if (known && onPath.insert(n).second)
+				{
+					printTree(modules, n, dependencies, depth + 1, onPath);
+					onPath.erase(n);
+				}
+			}
+		}
+
+		void deps(bool of, const std::string& module, bool recursive)
+		{
+			Project project = requireProject();
+			std::vector<Module> modules = scanModules(project);
+			const Module* m = findModule(modules, module);
+			if (m == nullptr)
+				throw Error("there is no module '" + module + "' (see `breeze ls`)");
+			std::vector<std::string> direct =
+				of ? dependenciesOf(modules, *m, false) : dependentsOf(modules, *m, false);
+			if (direct.empty())
+			{
+				std::cout << (of ? m->id + " depends on nothing\n"
+								 : "nothing depends on " + m->id + "\n");
+				return;
+			}
+			if (!recursive)
+			{
+				for (const std::string& d : direct)
+					std::cout << d << (findModule(modules, d) != nullptr ? "" : " (external)")
+							  << "\n";
+				return;
+			}
+			std::set<std::string> onPath{m->id};
+			printTree(modules, m->id, of, 0, onPath);
+		}
+
+		void sdkVersion()
+		{
+			Project project = requireProject();
+			std::cout << project.sdk.describe() << "\n";
+		}
+
+		void sdkUpdate()
+		{
+			sdk::update(requireProject());
+		}
+
+		void sdkUpgrade()
+		{
+			sdk::upgrade(requireProject());
+		}
+
+		void sdkMigrate(const std::string& version)
+		{
+			sdk::migrate(requireProject(), version);
+		}
+
+		// ---------------------------------------------------------------- cli
+
+		void cliVersion()
+		{
+			std::cout << self::version() << "\n";
+		}
+
+		void cliPick(const std::string& version)
+		{
+			self::pick(version);
+		}
+
+		void cliInstall(const std::string& version)
+		{
+			self::install(version);
+		}
+
+		void cliUninstall(const std::string& version)
+		{
+			self::uninstall(version);
+		}
+
+		void cliList()
+		{
+			self::list();
+		}
+
+		// ---------------------------------------------------------------- tools
+
+		void toolInstall(const std::string& repo)
+		{
+			tools::install(requireProject(), repo);
+		}
+
+		void toolUninstall(const std::string& id)
+		{
+			tools::uninstall(requireProject(), id);
+		}
+
+		void toolUpdate(const std::string& id)
+		{
+			tools::update(requireProject(), id);
+		}
+
+		void toolUpgrade(const std::string& id)
+		{
+			tools::upgrade(requireProject(), id);
+		}
+
+		void toolMigrate(const std::string& id, const std::string& version)
+		{
+			tools::migrate(requireProject(), id, version);
+		}
+
+		void toolList()
+		{
+			tools::list(requireProject());
+		}
+
+		// Only here so that `breeze --help` shows it: main() hands `tool <id> ...` to the tool
+		// before CLIForge sees it.
+		void toolRun(const std::string& /*id*/, const Strs& /*arguments*/)
+		{
+		}
+
+		void projectNew(const std::string& name, const Str& id, const Str& sdkVersion)
+		{
+			sdk::createProject(name, id, sdkVersion);
+		}
+	}
+
+	void registerCommands(cliforge::Engine& cli)
+	{
+		using std::int32_t;
+
+		// ---- cli
+		cli.command()
+			.keyword("cli")
+			.keyword("version")
+			.describe("Shows this CLI's version")
+			.action(&cliVersion);
+		cli.command()
+			.keyword("cli")
+			.keyword("pick")
+			.parameter<std::string>("version", "An installed CLI version")
+			.describe("Picks the CLI version that runs from now on")
+			.action(&cliPick);
+		cli.command()
+			.keyword("cli")
+			.keyword("install")
+			.parameter<std::string>("version", "The CLI version to install")
+			.describe(
+				"Installs a CLI version (this program's own, or a release from the CLI source)")
+			.action(&cliInstall);
+		cli.command()
+			.keyword("cli")
+			.keyword("uninstall")
+			.parameter<std::string>("version", "An installed CLI version")
+			.describe("Uninstalls a CLI version")
+			.action(&cliUninstall);
+		cli.command()
+			.keyword("cli")
+			.keyword("ls")
+			.describe("Lists the installed CLI versions")
+			.action(&cliList);
+
+		// ---- project
+		cli.command()
+			.keyword("project")
+			.keyword("new")
+			.parameter<std::string>("name", "The new project's name (and directory)")
+			.option<std::string>("id", '\0', "The project's id (default: the name in lower case)")
+			.option<std::string>("sdk", '\0', "The SDK version to start from (default: the latest)")
+			.describe("Creates a new project")
+			.action(&projectNew);
+		cli.command()
+			.keyword("project")
+			.keyword("version")
+			.option<std::string>("set", '\0', "Sets the project's version (major.minor[.patch])")
+			.describe("Shows or sets the project's version")
+			.action([](const Str& set) { showOrSet(Setting::Version, set); });
+		cli.command()
+			.keyword("project")
+			.keyword("name")
+			.option<std::string>("set", '\0', "Sets the project's name")
+			.describe("Shows or sets the project's name (the CMake project() name)")
+			.action([](const Str& set) { showOrSet(Setting::Name, set); });
+		cli.command()
+			.keyword("project")
+			.keyword("id")
+			.option<std::string>("set", '\0', "Sets the project's id")
+			.describe("Shows or sets the project's id (lower-case; the install component)")
+			.action([](const Str& set) { showOrSet(Setting::Id, set); });
+
+		// ---- setup
+		cli.command()
+			.keyword("setup")
+			.flag("required", '\0', "Install the required tools without asking")
+			.flag("all", '\0', "Also install the optional tools without asking")
+			.describe(
+				"Checks the tools the project builds with and offers to install what is missing")
+			.action(&setup);
+
+		// ---- config
+		cli.command()
+			.keyword("config")
+			.keyword("editor")
+			.option<std::string>("set", '\0', "Sets the editor ('none' clears it)")
+			.describe("Shows or sets the editor the CLI opens files with")
+			.action([](const Str& set) { configValue(config::Editor, set); });
+		cli.command()
+			.keyword("config")
+			.keyword("sdk-source")
+			.option<std::string>("set", '\0',
+								 "Sets the SDK source: a git repository (URL or path), or a "
+								 "directory of versions ('none' clears it)")
+			.describe("Shows or sets where SDK versions come from")
+			.action([](const Str& set) { configValue(config::SdkSource, set); });
+		cli.command()
+			.keyword("config")
+			.keyword("cli-source")
+			.option<std::string>(
+				"set", '\0',
+				"Sets the CLI source: a URL or directory of releases ('none' clears it)")
+			.describe("Shows or sets where CLI versions come from")
+			.action([](const Str& set) { configValue(config::CliSource, set); });
+
+		// ---- generation
+		cli.command()
+			.keyword("clean")
+			.flag("no-build", 'b', "Do not clean build artifacts")
+			.flag("docs", 'd', "Clean documentation artifacts")
+			.describe("Cleans build artifacts")
+			.action(&clean);
+
+		cli.command()
+			.keyword("build")
+			.option<std::string>("platform", 'P', "The desired platform (Windows, macOS, Linux)")
+			.option<std::string>("arch", 'A', "The desired architecture (x64, x86, arm32, arm64)")
+			.option<std::string>(
+				"compiler", 'C',
+				"The desired compiler (MSVC, Clang, ClangCl, GCC, MinGW32, MinGW64, ...)")
+			.option<std::string>("mode", 'M',
+								 "The configuration (Release, Debug, ReleaseDebugSymbols)")
+			.option<int32_t>("jobs", 'j', "The job count for the compilation")
+			.option<std::string>("preset", 'p', "The CMake preset to use")
+			.option<std::string>("cargs", '\0', "CMake configuration arguments", true)
+			.option<std::string>("bargs", '\0', "CMake build arguments", true)
+			.flag("no-configure", '\0', "Do not perform CMake configure")
+			.describe("Configures and builds the project")
+			.action(&build);
+
+		cli.command()
+			.keyword("install")
+			.option<std::string>("platform", 'P', "The desired platform (Windows, macOS, Linux)")
+			.option<std::string>("arch", 'A', "The desired architecture (x64, x86, arm32, arm64)")
+			.option<std::string>(
+				"compiler", 'C',
+				"The desired compiler (MSVC, Clang, ClangCl, GCC, MinGW32, MinGW64, ...)")
+			.option<std::string>("mode", 'M',
+								 "The configuration (Release, Debug, ReleaseDebugSymbols)")
+			.option<int32_t>("jobs", 'j', "The job count for the compilation")
+			.option<std::string>("preset", 'p', "The CMake preset to use")
+			.option<std::string>("cargs", '\0', "CMake configuration arguments", true)
+			.option<std::string>("bargs", '\0', "CMake build arguments", true)
+			.flag("no-configure", '\0', "Do not perform CMake configure")
+			.flag("no-build", '\0', "Do not perform CMake build")
+			.describe("Configures, builds and installs the project")
+			.action(&install);
+
+		cli.command().keyword("docs").describe("Builds the project documentation").action(&docs);
+
+		// ---- defaults
+		for (const char* key : {"platform", "arch", "compiler", "preset", "mode"})
+		{
+			cli.command()
+				.keyword("defaults")
+				.keyword("build")
+				.keyword(key)
+				.option<std::string>("set", '\0',
+									 "Sets this default to the given value ('none' clears it)")
+				.describe(std::string("Gets or sets the project default build ") + key)
+				.action([key](const Str& set) { defaultsBuild(key, set); });
+		}
+		cli.command()
+			.keyword("defaults")
+			.keyword("run")
+			.option<std::string>("set", '\0',
+								 "Sets this default to the given value ('none' clears it)")
+			.describe(
+				"Gets or sets the default executable to run if no `id` is given to `breeze run`")
+			.action(&defaultsRun);
+
+		// ---- run (the id is optional: two commands)
+		cli.command()
+			.keyword("run")
+			.option<std::string>("preset", 'p', "The preset to run")
+			.option<std::string>("platform", 'P', "The desired platform (Windows, macOS, Linux)")
+			.option<std::string>("arch", 'A', "The desired architecture (x64, x86, arm32, arm64)")
+			.option<std::string>(
+				"compiler", 'C',
+				"The desired compiler (MSVC, Clang, ClangCl, GCC, MinGW32, MinGW64, ...)")
+			.option<std::string>("mode", 'M',
+								 "The configuration (Release, Debug, ReleaseDebugSymbols)")
+			.option<std::string>("args", 'x', "The arguments to pass to the executable", true)
+			.describe("Runs the default executable (see `breeze defaults run`)")
+			.action(&runDefault);
+		cli.command()
+			.keyword("run")
+			.parameter<std::string>("id", "The executable module to run")
+			.option<std::string>("preset", 'p', "The preset to run")
+			.option<std::string>("platform", 'P', "The desired platform (Windows, macOS, Linux)")
+			.option<std::string>("arch", 'A', "The desired architecture (x64, x86, arm32, arm64)")
+			.option<std::string>(
+				"compiler", 'C',
+				"The desired compiler (MSVC, Clang, ClangCl, GCC, MinGW32, MinGW64, ...)")
+			.option<std::string>("mode", 'M',
+								 "The configuration (Release, Debug, ReleaseDebugSymbols)")
+			.option<std::string>("args", 'x', "The arguments to pass to the executable", true)
+			.describe("Runs an executable (primary executable, test or example)")
+			.action(&runById);
+
+		// ---- modules
+		cli.command()
+			.keyword("add")
+			.keyword("exec")
+			.parameter<std::string>("name", "The module's name (its directory)")
+			.option<std::string>("id", '\0', "The CMake target id (default: <name>_exe)")
+			.option<std::string>("deps", '\0', "Modules or targets it depends on", true)
+			.describe("Adds an executable module")
+			.action(&addExec);
+		cli.command()
+			.keyword("add")
+			.keyword("lib")
+			.parameter<std::string>("name", "The module's name (its directory)")
+			.option<std::string>("id", '\0', "The CMake target id (default: <name>_lib)")
+			.option<std::string>("deps", '\0', "Modules or targets it depends on", true)
+			.flag("static", '\0', "A static library")
+			.flag("shared", '\0', "A shared library")
+			.describe("Adds a library module")
+			.action(&addLib);
+		cli.command()
+			.keyword("add")
+			.keyword("obj")
+			.parameter<std::string>("name", "The module's name (its directory)")
+			.option<std::string>("id", '\0', "The CMake target id (default: <name>_obj)")
+			.option<std::string>("deps", '\0', "Modules or targets it depends on", true)
+			.describe("Adds an objects module: compiled to object files that a library or "
+					  "executable takes in")
+			.action(&addObj);
+		cli.command()
+			.keyword("add")
+			.keyword("test")
+			.parameter<std::string>("name", "The module's name (its directory)")
+			.option<std::string>("id", '\0', "The CMake target id (default: <name>_test)")
+			.option<std::string>("deps", '\0', "Modules or targets it depends on", true)
+			.describe("Adds a test module")
+			.action(&addTest);
+		cli.command()
+			.keyword("add")
+			.keyword("example")
+			.parameter<std::string>("name", "The module's name (its directory)")
+			.option<std::string>("id", '\0', "The CMake target id (default: <name>_example)")
+			.option<std::string>("deps", '\0', "Modules or targets it depends on", true)
+			.describe("Adds an example module")
+			.action(&addExample);
+
+		cli.command()
+			.keyword("delete")
+			.parameter<std::string>("id", "The module's id (or directory name)")
+			.flag("yes", 'y', "Delete without asking")
+			.describe("Deletes a module")
+			.action(&deleteIt);
+		cli.command()
+			.keyword("rename")
+			.parameter<std::string>("id", "The module's id (or directory name)")
+			.option<std::string>("name", '\0', "The new name (directory)")
+			.option<std::string>("id", '\0', "The new id")
+			.describe(
+				"Renames a module's directory and/or id, updating the modules that depend on it")
+			.action(&rename);
+		cli.command()
+			.keyword("ls")
+			.option<std::string>("filter", '\0',
+								 "Only modules whose id or directory contains this text")
+			.flag("exec", '\0', "Executable modules")
+			.flag("obj", '\0', "Objects modules")
+			.flag("lib", '\0', "Library modules")
+			.flag("test", '\0', "Test modules")
+			.flag("example", '\0', "Example modules")
+			.flag("shared", '\0', "Only shared libraries")
+			.flag("static", '\0', "Only static libraries")
+			.describe("Lists the project's modules")
+			.action(&list);
+
+		// ---- deps
+		cli.command()
+			.keyword("deps")
+			.keyword("of")
+			.parameter<std::string>("module", "The module's id (or directory name)")
+			.flag("recursive", '\0', "Follow dependencies of dependencies")
+			.describe("Lists what a module depends on")
+			.action([](const std::string& module, bool recursive)
+					{ deps(true, module, recursive); });
+		cli.command()
+			.keyword("deps")
+			.keyword("on")
+			.parameter<std::string>("module", "The module's id (or directory name)")
+			.flag("recursive", '\0', "Follow dependents of dependents")
+			.describe("Lists the modules that depend on a module")
+			.action([](const std::string& module, bool recursive)
+					{ deps(false, module, recursive); });
+
+		// ---- tools
+		cli.command()
+			.keyword("tool")
+			.keyword("install")
+			.parameter<std::string>("repo", "The tool's git repository (URL or path)")
+			.describe("Installs a tool into the project")
+			.action(&toolInstall);
+		cli.command()
+			.keyword("tool")
+			.keyword("uninstall")
+			.parameter<std::string>("id", "The tool's id")
+			.describe("Uninstalls a tool from the project")
+			.action(&toolUninstall);
+		cli.command()
+			.keyword("tool")
+			.keyword("update")
+			.parameter<std::string>("id", "The tool's id")
+			.describe("Looks for newer versions of a tool")
+			.action(&toolUpdate);
+		cli.command()
+			.keyword("tool")
+			.keyword("upgrade")
+			.parameter<std::string>("id", "The tool's id")
+			.describe("Moves a tool to the newest version of its major version")
+			.action(&toolUpgrade);
+		cli.command()
+			.keyword("tool")
+			.keyword("migrate")
+			.parameter<std::string>("id", "The tool's id")
+			.parameter<std::string>("version", "The version to move to")
+			.describe("Moves a tool to a given version")
+			.action(&toolMigrate);
+		cli.command()
+			.keyword("tool")
+			.keyword("ls")
+			.describe("Lists the project's tools")
+			.action(&toolList);
+		cli.command()
+			.keyword("tool")
+			.parameter<std::string>("id", "An installed tool")
+			.parameter<std::string>("arguments", "What the tool is asked to do", true)
+			.describe("Runs a command a tool adds: breeze tool <id> <arguments...>")
+			.action(&toolRun);
+
+		// ---- sdk
+		cli.command()
+			.keyword("sdk")
+			.keyword("version")
+			.describe("Shows the project's SDK version")
+			.action(&sdkVersion);
+		cli.command()
+			.keyword("sdk")
+			.keyword("update")
+			.describe("Looks for newer SDK versions")
+			.action(&sdkUpdate);
+		cli.command()
+			.keyword("sdk")
+			.keyword("upgrade")
+			.describe("Moves the project to the newest SDK version of its major version")
+			.action(&sdkUpgrade);
+		cli.command()
+			.keyword("sdk")
+			.keyword("migrate")
+			.parameter<std::string>("version", "The SDK version to move to")
+			.describe("Moves the project to a given SDK version (across majors, and from the "
+					  "legacy layout)")
+			.action(&sdkMigrate);
+	}
+
+}
diff --git a/source/Breeze/Commands.hpp b/source/Breeze/Commands.hpp
new file mode 100644
index 0000000..008e985
--- /dev/null
+++ b/source/Breeze/Commands.hpp
@@ -0,0 +1,15 @@
+#pragma once
+
+#include <CLIForge/CLIForge.hpp>
+
+namespace breeze::cli
+{
+
+	/// Registers every command of the spec on the engine.
+	void registerCommands(cliforge::Engine& engine);
+
+	/// The exit code the last command that ran a program asked for. Actions can't return one
+	/// (CLIForge ignores what they return), so they leave it here and main() ends with it.
+	int& exitCode();
+
+}
diff --git a/source/Breeze/main.cpp b/source/Breeze/main.cpp
new file mode 100644
index 0000000..793f39e
--- /dev/null
+++ b/source/Breeze/main.cpp
@@ -0,0 +1,56 @@
+#include <iostream>
+#include <string>
+#include <vector>
+
+#include <CLIForge/CLIForge.hpp>
+
+#include "Commands.hpp"
+#include "breeze/Arguments.hpp"
+#include "breeze/Cli.hpp"
+#include "breeze/Error.hpp"
+#include "breeze/Project.hpp"
+#include "breeze/Tools.hpp"
+
+int main(int argc, char** argv)
+{
+	try
+	{
+		std::vector<std::string> given(argv + 1, argv + argc);
+
+		// Another CLI version may be the picked one: it takes over (never for `cli ...`).
+		breeze::self::forwardToPicked(given);
+
+		// `breeze tool <id> ...` is the tool's own command line, which CLIForge knows nothing
+		// about.
+		if (given.size() >= 2 && given[0] == "tool" && given[1].rfind('-', 0) != 0 &&
+			!breeze::tools::isReservedName(given[1]))
+		{
+			breeze::Project project = breeze::requireProject();
+			std::optional<int> rc = breeze::tools::run(
+				project, given[1], std::vector<std::string>(given.begin() + 2, given.end()));
+			if (!rc)
+				throw breeze::Error("there is no tool '" + given[1] +
+									"' installed in this project (see `breeze tool ls`)");
+			return *rc;
+		}
+
+		cliforge::Engine engine("breeze");
+		breeze::cli::registerCommands(engine);
+		std::vector<std::string> args = breeze::cli::normalizeArguments(given);
+		std::vector<char*> forwarded{argv[0]};
+		for (std::string& a : args)
+			forwarded.push_back(a.data());
+		int rc = engine.run(static_cast<int>(forwarded.size()), forwarded.data());
+		return rc != 0 ? rc : breeze::cli::exitCode();
+	}
+	catch (const breeze::Error& e)
+	{
+		std::cerr << "breeze: " << e.what() << "\n";
+		return e.exitCode();
+	}
+	catch (const std::exception& e)
+	{
+		std::cerr << "breeze: unexpected error: " << e.what() << "\n";
+		return 70;
+	}
+}
diff --git a/source/BreezeCore/CMakeLists.txt b/source/BreezeCore/CMakeLists.txt
new file mode 100644
index 0000000..b714259
--- /dev/null
+++ b/source/BreezeCore/CMakeLists.txt
@@ -0,0 +1,20 @@
+# Everything the breeze CLI does that is not reading a command line: finding
+# and reading projects and their SDK, running the SDK's scripts, editing modules,
+# managing CLI versions, SDKs and tools. source/Breeze registers the commands
+# (with CLIForge) and calls into this; source/tests/CoreTests tests it.
+#
+# nlohmann/json: an installed copy (3.11 or newer) if there is one, else the
+# release tarball, pinned by hash.
+add_dependency(nlohmann_json
+    URL https://github.com/nlohmann/json/releases/download/v3.11.3/json.tar.xz
+    URL_HASH SHA256=d6c65aca6b1ed68e7a182f4757257b107ae403032760ed6ef121c9d55e81757d
+    FIND_PACKAGE_ARGS 3.11 NAMES nlohmann_json)
+
+add_lib_module(breeze_core TYPE STATIC OUTPUT_NAME "breeze_core")
+
+# PUBLIC: Config.hpp and Project.hpp have nlohmann::json members, so whoever includes them needs
+# its headers (DEPENDS would link it PRIVATE).
+target_link_libraries(breeze_core PUBLIC nlohmann_json::nlohmann_json)
+
+# The version of the program, from the project's own (project/Configuration.cmake).
+target_compile_definitions(breeze_core PRIVATE BREEZE_CLI_VERSION="${PROJECT_VERSION}")
diff --git a/source/BreezeCore/include/breeze/Arguments.hpp b/source/BreezeCore/include/breeze/Arguments.hpp
new file mode 100644
index 0000000..c427797
--- /dev/null
+++ b/source/BreezeCore/include/breeze/Arguments.hpp
@@ -0,0 +1,15 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+namespace breeze::cli
+{
+
+	/// CLIForge reads every token that starts with '-' as an option, so `--cargs -DBUILD_TESTS=ON`
+	/// would try to find an option called -D. The values of the pass-through options (--cargs,
+	/// --bargs and run's --args/-x) are rewritten to the `--cargs=-DBUILD_TESTS=ON` form CLIForge
+	/// does accept, each taking tokens up to the next option of the command.
+	std::vector<std::string> normalizeArguments(const std::vector<std::string>& args);
+
+}
diff --git a/source/BreezeCore/include/breeze/Build.hpp b/source/BreezeCore/include/breeze/Build.hpp
new file mode 100644
index 0000000..55b4243
--- /dev/null
+++ b/source/BreezeCore/include/breeze/Build.hpp
@@ -0,0 +1,55 @@
+#pragma once
+
+#include <filesystem>
+#include <map>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include "breeze/Presets.hpp"
+#include "breeze/Project.hpp"
+
+/// Building, installing, running and cleaning a project -- by driving the SDK's own scripts, so the
+/// environment they set up (the pinned Ninja, the MSVC environment on Windows) is always the one
+/// used. Where a request needs something the scripts don't offer (extra `cmake --build` arguments,
+/// skipping the configure), the CLI runs `cmake --build` itself against the build the scripts made.
+namespace breeze
+{
+
+	struct BuildRequest
+	{
+		PresetQuery preset;
+		/// Release, Debug, ReleaseDebugSymbols or MinSizeRel (any case).
+		std::optional<std::string> mode;
+		std::optional<int> jobs;
+		std::vector<std::string> configureArgs;
+		std::vector<std::string> buildArgs;
+		bool noConfigure = false;
+		bool noBuild = false;
+	};
+
+	/// The CMake build type for a mode name; throws Error for an unknown one.
+	std::string buildTypeFor(const std::string& mode);
+
+	/// Values of the project's settings (BUILD_OUTPUT_DIR, DOCS_OUTPUT_DIR, ...) as the SDK
+	/// computes them. Falls back to the SDK's defaults for a legacy layout that can't be asked.
+	std::map<std::string, std::string> readConfigVariables(const Project& project,
+														   const std::vector<std::string>& names);
+
+	/// The build directory for the preset (or the one built last), as the SDK defines it.
+	std::filesystem::path buildDirFor(const Project& project,
+									  const std::optional<std::string>& preset);
+
+	/// Each returns the exit code of the command that did the work.
+	int build(const Project& project, const BuildRequest& request);
+	int install(const Project& project, const BuildRequest& request);
+	int docs(const Project& project);
+	int run(const Project& project, const std::optional<std::string>& id, const PresetQuery& where,
+			const std::vector<std::string>& programArgs);
+	int setup(const Project& project, bool required, bool all);
+
+	/// Removes the build directories (unless keepBuild) and the documentation (if alsoDocs).
+	/// Returns the paths removed, relative to the project.
+	std::vector<std::string> clean(const Project& project, bool keepBuild, bool alsoDocs);
+
+}
diff --git a/source/BreezeCore/include/breeze/CMakeText.hpp b/source/BreezeCore/include/breeze/CMakeText.hpp
new file mode 100644
index 0000000..784622a
--- /dev/null
+++ b/source/BreezeCore/include/breeze/CMakeText.hpp
@@ -0,0 +1,49 @@
+#pragma once
+
+#include <cstddef>
+
+#include <functional>
+#include <optional>
+#include <string>
+#include <vector>
+
+/// Just enough of CMake's syntax to find and edit a command call in a CMakeLists.txt or a settings
+/// file without disturbing anything else in it: comments, layout and line endings stay as they
+/// were.
+namespace breeze::cmake
+{
+
+	/// One argument of a call. begin/end are byte offsets of the argument as written (quotes
+	/// included); text is its value without the quotes.
+	struct Token
+	{
+		std::size_t begin = 0;
+		std::size_t end = 0;
+		std::string text;
+		bool quoted = false;
+	};
+
+	/// A command call: name(args...). begin/end span the whole call, "name(" through ")".
+	struct Call
+	{
+		std::string name;
+		std::size_t begin = 0;
+		std::size_t end = 0;
+		std::vector<Token> args;
+	};
+
+	/// Every call in `text`, in order, whose name `wanted` accepts. Comments, quoted strings and
+	/// the arguments of other calls are never mistaken for calls.
+	std::vector<Call> findCalls(const std::string& text,
+								const std::function<bool(const std::string&)>& wanted);
+
+	/// The first set(<variable> ...) call.
+	std::optional<Call> findSet(const std::string& text, const std::string& variable);
+
+	/// `value` as a quoted CMake argument.
+	std::string quote(const std::string& value);
+
+	/// Replaces the token's text in `text` (offsets of later tokens are stale afterwards).
+	void replaceToken(std::string& text, const Token& token, const std::string& replacement);
+
+}
diff --git a/source/BreezeCore/include/breeze/Cli.hpp b/source/BreezeCore/include/breeze/Cli.hpp
new file mode 100644
index 0000000..0f281a8
--- /dev/null
+++ b/source/BreezeCore/include/breeze/Cli.hpp
@@ -0,0 +1,43 @@
+#pragma once
+
+#include <filesystem>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include "breeze/Version.hpp"
+
+/// The CLI managing itself: which versions of it are installed, which one is picked, and running
+/// the picked one. Versions live in <breeze home>/cli/<version>/; `cli/current` names the picked
+/// one, and <breeze home>/bin/breeze is the copy to put on PATH. Whatever `breeze` the shell finds
+/// hands the command to the picked version, so installing or picking never means changing PATH
+/// again.
+namespace breeze::self
+{
+
+	/// The version of this program.
+	std::string version();
+
+	/// Installed versions, oldest first.
+	std::vector<Version> installed();
+
+	/// The version `cli pick` chose, if any.
+	std::optional<Version> picked();
+
+	/// Installs a version: this very program if that is its version, else a release of the
+	/// configured CLI source. The first version installed is picked.
+	void install(const std::string& version);
+
+	void pick(const std::string& version);
+
+	/// Removes a version; un-picks it if it was the picked one.
+	void uninstall(const std::string& version);
+
+	/// Prints the installed versions, marking the picked one and the running one.
+	void list();
+
+	/// If another version is picked, installed and runnable, runs it with `args` and does not
+	/// return. `cli ...` commands always run in the version that was started.
+	void forwardToPicked(const std::vector<std::string>& args);
+
+}
diff --git a/source/BreezeCore/include/breeze/Config.hpp b/source/BreezeCore/include/breeze/Config.hpp
new file mode 100644
index 0000000..97cbc4f
--- /dev/null
+++ b/source/BreezeCore/include/breeze/Config.hpp
@@ -0,0 +1,46 @@
+#pragma once
+
+#include <filesystem>
+#include <optional>
+#include <string>
+
+#include <nlohmann/json.hpp>
+
+/// The CLI's own, global state: where it lives and what the user configured.
+namespace breeze
+{
+
+	/// $BREEZE_HOME, or ~/.breeze. Holds config.json, the installed CLI versions (cli/), the SDK
+	/// snapshots (sdk/) and cached indexes.
+	std::filesystem::path breezeHome();
+
+	/// The keys of config.json. Each can also come from the environment (BREEZE_EDITOR,
+	/// BREEZE_SDK_SOURCE, BREEZE_CLI_SOURCE), which wins.
+	namespace config
+	{
+		inline constexpr const char* Editor = "editor";
+		inline constexpr const char* SdkSource = "sdkSource";
+		inline constexpr const char* CliSource = "cliSource";
+	}
+
+	class GlobalConfig
+	{
+	public:
+		/// Reads config.json (an absent file is an empty configuration).
+		static GlobalConfig load();
+
+		/// The environment's value for the key if set, else the file's.
+		[[nodiscard]] std::optional<std::string> effective(const std::string& key) const;
+
+		/// The file's value only.
+		[[nodiscard]] std::optional<std::string> stored(const std::string& key) const;
+
+		void set(const std::string& key, const std::string& value);
+		void erase(const std::string& key);
+		void save() const;
+
+	private:
+		nlohmann::json m_data = nlohmann::json::object();
+	};
+
+}
diff --git a/source/BreezeCore/include/breeze/Error.hpp b/source/BreezeCore/include/breeze/Error.hpp
new file mode 100644
index 0000000..d6ac703
--- /dev/null
+++ b/source/BreezeCore/include/breeze/Error.hpp
@@ -0,0 +1,24 @@
+#pragma once
+
+#include <stdexcept>
+#include <string>
+
+namespace breeze
+{
+
+	/// Every failure the CLI reports to the user: a message and the process exit code to end with.
+	class Error : public std::runtime_error
+	{
+	public:
+		explicit Error(const std::string& message, int exitCode = 1)
+			: std::runtime_error(message), m_exitCode(exitCode)
+		{
+		}
+
+		[[nodiscard]] int exitCode() const noexcept { return m_exitCode; }
+
+	private:
+		int m_exitCode;
+	};
+
+}
diff --git a/source/BreezeCore/include/breeze/Fs.hpp b/source/BreezeCore/include/breeze/Fs.hpp
new file mode 100644
index 0000000..ce715d8
--- /dev/null
+++ b/source/BreezeCore/include/breeze/Fs.hpp
@@ -0,0 +1,53 @@
+#pragma once
+
+#include <filesystem>
+#include <optional>
+#include <string>
+#include <vector>
+
+/// File system and host helpers. Paths are std::filesystem::path throughout; text files are read
+/// and written as bytes, so the line endings a file has are the ones it keeps.
+namespace breeze::fs
+{
+
+	using std::filesystem::path;
+
+	/// Throws Error when the file can't be read.
+	std::string readText(const path& file);
+	std::optional<std::string> tryReadText(const path& file);
+
+	/// Creates the parent directories, then writes the file (replacing it).
+	void writeText(const path& file, const std::string& text);
+
+	/// Copies `from` into `to` (merging into what is there, overwriting files). Entries whose name
+	/// is in `skipNames` are left out at every level.
+	void copyTree(const path& from, const path& to, const std::vector<std::string>& skipNames = {});
+
+	/// Removes the file or directory tree if it exists. Throws Error on failure.
+	void removeTree(const path& p);
+
+	/// A new, empty directory under the system's temp directory.
+	path makeTempDir(const std::string& prefix);
+
+	/// The user's home directory (HOME, or USERPROFILE on Windows).
+	path homeDir();
+
+	/// Where the running program's executable is.
+	path executablePath();
+
+	/// "linux", "macos" or "windows".
+	std::string hostPlatform();
+
+	/// "x64", "arm64", "arm32" or "x86".
+	std::string hostArch();
+
+	/// chmod +x on POSIX; nothing on Windows.
+	void makeExecutable(const path& file);
+
+	/// True for a regular file that can be run.
+	bool isExecutable(const path& file);
+
+	/// The path with forward slashes, for messages that read the same on every OS.
+	std::string generic(const path& p);
+
+}
diff --git a/source/BreezeCore/include/breeze/Git.hpp b/source/BreezeCore/include/breeze/Git.hpp
new file mode 100644
index 0000000..5cfa21b
--- /dev/null
+++ b/source/BreezeCore/include/breeze/Git.hpp
@@ -0,0 +1,34 @@
+#pragma once
+
+#include <filesystem>
+#include <string>
+#include <vector>
+
+#include "breeze/Version.hpp"
+
+/// The little of git the CLI needs: listing the version tags of a repository and exporting one
+/// tag's files. Repositories are URLs or local paths; git itself must be installed.
+namespace breeze::git
+{
+
+	struct Tag
+	{
+		/// The tag as written in the repository, e.g. "v1.2.0".
+		std::string name;
+		Version version;
+	};
+
+	/// Is `source` something git can clone (a URL, or a local repository) rather than a plain
+	/// directory?
+	bool isRepository(const std::string& source);
+
+	/// The tags of the repository that are versions, in no particular order. Throws Error when the
+	/// repository can't be reached.
+	std::vector<Tag> versionTags(const std::string& repository);
+
+	/// Exports the files of `tag` (the default branch's tip when empty) into `destination`, without
+	/// the repository's own history.
+	void exportTree(const std::string& repository, const std::string& tag,
+					const std::filesystem::path& destination);
+
+}
diff --git a/source/BreezeCore/include/breeze/Modules.hpp b/source/BreezeCore/include/breeze/Modules.hpp
new file mode 100644
index 0000000..7d2827b
--- /dev/null
+++ b/source/BreezeCore/include/breeze/Modules.hpp
@@ -0,0 +1,97 @@
+#pragma once
+
+#include <filesystem>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include "breeze/Project.hpp"
+
+/// A project's modules: the directories under source/ (and source/tests/, source/examples/) that
+/// each register one CMake target with one of the SDK's add_*_module macros. They are read from the
+/// CMakeLists.txt files themselves, so what the CLI shows is what CMake will do, and the files it
+/// writes are the ones a person would have written.
+namespace breeze
+{
+
+	enum class ModuleKind
+	{
+		Exec,
+		Lib,
+		Obj,
+		Test,
+		Example
+	};
+
+	enum class LibType
+	{
+		Unspecified,
+		Static,
+		Shared
+	};
+
+	/// "exec", "lib", "obj", "test" or "example".
+	std::string kindName(ModuleKind kind);
+
+	struct Module
+	{
+		/// The CMake target: what DEPENDS, `breeze run` and `breeze deps` call it.
+		std::string id;
+		/// The directory's name.
+		std::string dirName;
+		std::filesystem::path dir;
+		ModuleKind kind = ModuleKind::Exec;
+		LibType libType = LibType::Unspecified;
+		std::string outputName;
+		std::vector<std::string> deps;
+		/// The macro that registered it, e.g. add_lib_module.
+		std::string macro;
+	};
+
+	/// Every module, main ones first (by directory name), then tests, then examples.
+	std::vector<Module> scanModules(const Project& project);
+
+	/// By id, else by directory name. Null when there is no such module.
+	const Module* findModule(const std::vector<Module>& modules, const std::string& idOrDir);
+
+	struct NewModule
+	{
+		ModuleKind kind = ModuleKind::Exec;
+		std::string name;
+		std::optional<std::string> id;
+		std::vector<std::string> deps;
+		LibType libType = LibType::Unspecified;
+	};
+
+	/// Creates the module's directory, CMakeLists.txt and starter files. Throws Error on anything
+	/// it would have to guess about or overwrite.
+	Module addModule(const Project& project, const NewModule& request);
+
+	/// Removes the module's directory. Refuses while another module still depends on it.
+	void deleteModule(const Project& project, const std::string& idOrDir);
+
+	struct RenameResult
+	{
+		std::string oldId;
+		std::string newId;
+		std::string oldDir;
+		std::string newDir;
+		/// Modules whose CMakeLists.txt had a DEPENDS entry updated.
+		std::vector<std::string> updatedDependents;
+	};
+
+	/// Renames the directory and/or the id, and rewrites DEPENDS entries elsewhere to the new id.
+	RenameResult renameModule(const Project& project, const std::string& idOrDir,
+							  const std::optional<std::string>& newName,
+							  const std::optional<std::string>& newId);
+
+	/// What `module` depends on, without repeats, in the order met (nearest first). Entries that
+	/// are not modules of the project (fmt::fmt, pthread) are included as they were written.
+	std::vector<std::string> dependenciesOf(const std::vector<Module>& modules,
+											const Module& module, bool recursive);
+
+	/// The modules that depend on `module`, directly or (recursive) through others.
+	std::vector<std::string> dependentsOf(const std::vector<Module>& modules, const Module& module,
+										  bool recursive);
+
+}
diff --git a/source/BreezeCore/include/breeze/Presets.hpp b/source/BreezeCore/include/breeze/Presets.hpp
new file mode 100644
index 0000000..b24299d
--- /dev/null
+++ b/source/BreezeCore/include/breeze/Presets.hpp
@@ -0,0 +1,45 @@
+#pragma once
+
+#include <optional>
+#include <string>
+#include <vector>
+
+#include "breeze/Project.hpp"
+
+/// The project's CMake presets, which are what a platform, an architecture and a compiler mean:
+/// every SDK names its configure presets "<platform>-<arch>-<compiler>" (linux-x64-gcc,
+/// windows-x64-clang-cl).
+namespace breeze
+{
+
+	struct Preset
+	{
+		std::string name;
+		std::string description;
+		std::string platform; // linux, macos, windows
+		std::string arch;	  // x64, x86, arm32, arm64
+		std::string compiler; // the rest of the name: gcc, clang, msvc, clang-cl, mingw64, ...
+	};
+
+	/// The configure presets usable on this machine (what `cmake --list-presets` shows).
+	std::vector<Preset> listPresets(const Project& project);
+
+	/// What was asked for; every field is optional and compared ignoring case and punctuation
+	/// ("ClangCl" finds clang-cl).
+	struct PresetQuery
+	{
+		std::optional<std::string> preset;
+		std::optional<std::string> platform;
+		std::optional<std::string> arch;
+		std::optional<std::string> compiler;
+	};
+
+	/// The preset a command should use: the named preset; else one made from the platform,
+	/// architecture and compiler given, the project's defaults and then this machine for whatever
+	/// is missing; else the project's default preset; else none (the SDK's own default). Throws an
+	/// Error that lists the choices when what was asked for doesn't exist. `note` gets a line to
+	/// show the user when the choice involved a guess.
+	std::optional<std::string> resolvePreset(const Project& project, const Defaults& defaults,
+											 const PresetQuery& query, std::string* note = nullptr);
+
+}
diff --git a/source/BreezeCore/include/breeze/Process.hpp b/source/BreezeCore/include/breeze/Process.hpp
new file mode 100644
index 0000000..618bf8b
--- /dev/null
+++ b/source/BreezeCore/include/breeze/Process.hpp
@@ -0,0 +1,56 @@
+#pragma once
+
+#include <filesystem>
+#include <optional>
+#include <string>
+#include <utility>
+#include <vector>
+
+/// Running other programs. Arguments are passed as a vector, never through a shell, so nothing
+/// needs quoting by the caller.
+namespace breeze::proc
+{
+
+	struct Options
+	{
+		/// Working directory; empty keeps the current one.
+		std::filesystem::path cwd;
+		/// Variables set (or replaced) for the child only.
+		std::vector<std::pair<std::string, std::string>> env;
+		/// Collect the child's standard output into Result::output instead of showing it.
+		bool capture = false;
+		/// With capture, standard error is collected too (merged into the same string).
+		bool mergeStderr = false;
+		/// Throw the child's output away.
+		bool silent = false;
+	};
+
+	struct Result
+	{
+		int exitCode = 0;
+		std::string output;
+	};
+
+	/// Runs argv[0] with the rest as arguments (looked up on PATH when it has no directory part)
+	/// and waits. A program that can't be started is exit code 127. Throws Error only for failures
+	/// of this function itself (nothing to run, the system refusing to create a process).
+	Result run(const std::vector<std::string>& argv, const Options& options = {});
+
+	/// Runs a .bat/.cmd script on Windows through cmd.exe, or the script itself elsewhere.
+	Result runScript(const std::filesystem::path& script, const std::vector<std::string>& args,
+					 const Options& options = {});
+
+	/// Replaces this process with argv (POSIX), or runs it and exits with its status (Windows).
+	/// Does not return. Throws Error when it can't be started.
+	[[noreturn]] void execReplace(const std::vector<std::string>& argv);
+
+	/// The first match for `program` on PATH, if any.
+	std::optional<std::filesystem::path> findInPath(const std::string& program);
+
+	/// Sets an environment variable for this process and the programs it starts from now on.
+	void setEnvironment(const std::string& name, const std::string& value);
+
+	bool stdinIsTerminal();
+	bool stdoutIsTerminal();
+
+}
diff --git a/source/BreezeCore/include/breeze/Project.hpp b/source/BreezeCore/include/breeze/Project.hpp
new file mode 100644
index 0000000..0c91a8c
--- /dev/null
+++ b/source/BreezeCore/include/breeze/Project.hpp
@@ -0,0 +1,109 @@
+#pragma once
+
+#include <filesystem>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include <nlohmann/json.hpp>
+
+#include "breeze/Version.hpp"
+
+/// Finding a breeze project, telling which SDK it has, and reading and writing the project's own
+/// settings.
+///
+/// The CLI is global and projects carry their SDK (the template's breeze/ folder), so each project
+/// may be on a different SDK version -- or on the layout before breeze/ existed, with scripts/ and
+/// cmake/ at the root. Everything here asks the project's Sdk where things are instead of assuming.
+namespace breeze
+{
+
+	enum class SdkLayout
+	{
+		/// breeze/ (the SDK) and project/ (the project's settings).
+		Breeze,
+		/// The flat layout that came before: scripts/, cmake/ and Configuration.cmake at the root.
+		Legacy
+	};
+
+	struct Sdk
+	{
+		SdkLayout layout = SdkLayout::Breeze;
+
+		/// breeze/VERSION. Empty for the legacy layout and for a breeze/ that predates the file.
+		std::optional<Version> version;
+
+		/// <root>/breeze, or <root> in the legacy layout.
+		std::filesystem::path dir;
+		std::filesystem::path scriptsDir;
+		std::filesystem::path cmakeDir;
+
+		/// project/Configuration.cmake, or Configuration.cmake in the legacy layout.
+		std::filesystem::path settingsFile;
+
+		/// Does this SDK have add_objects_module?
+		bool supportsObjects = false;
+
+		/// "1.0.0", "unversioned (breeze/ layout)" or "legacy (flat layout, unversioned)".
+		[[nodiscard]] std::string describe() const;
+	};
+
+	struct Project
+	{
+		std::filesystem::path root;
+		Sdk sdk;
+
+		/// <root>/.breeze: what the CLI keeps in the project (defaults, installed tools).
+		[[nodiscard]] std::filesystem::path metaDir() const;
+		[[nodiscard]] std::filesystem::path defaultsFile() const;
+		[[nodiscard]] std::filesystem::path toolsDir() const;
+
+		/// The SDK's script `name` for this OS: scripts/<name>.sh, or .bat on Windows.
+		[[nodiscard]] std::filesystem::path script(const std::string& name) const;
+	};
+
+	/// Does `root` hold a breeze project, and with which SDK?
+	std::optional<Sdk> detectSdk(const std::filesystem::path& root);
+
+	/// The nearest project at or above `start`.
+	std::optional<Project> findProject(const std::filesystem::path& start);
+
+	/// findProject, or an Error explaining that the command needs a project.
+	Project requireProject(const std::filesystem::path& start = std::filesystem::current_path());
+
+	enum class Setting
+	{
+		Name,	 // CMake's project() name
+		Version, // the project's own version, major.minor[.patch[.tweak]]
+		Id		 // the machine-friendly identifier (PROJECT_CODE_NAME)
+	};
+
+	std::string readSetting(const Project& project, Setting which);
+
+	/// Validates the value, then changes just that value in the file, leaving everything else as it
+	/// is.
+	void writeSetting(const Project& project, Setting which, const std::string& value);
+
+	/// The CLI's per-project defaults, in .breeze/defaults.json (meant to be committed).
+	class Defaults
+	{
+	public:
+		static Defaults load(const Project& project);
+
+		/// key: platform, arch, compiler, preset or mode.
+		[[nodiscard]] std::optional<std::string> build(const std::string& key) const;
+		void setBuild(const std::string& key, const std::string& value);
+		void clearBuild(const std::string& key);
+
+		/// The module id `breeze run` runs when it is given none.
+		[[nodiscard]] std::optional<std::string> run() const;
+		void setRun(const std::string& id);
+		void clearRun();
+
+		void save(const Project& project) const;
+
+	private:
+		nlohmann::json m_data = nlohmann::json::object();
+	};
+
+}
diff --git a/source/BreezeCore/include/breeze/Sdks.hpp b/source/BreezeCore/include/breeze/Sdks.hpp
new file mode 100644
index 0000000..777c264
--- /dev/null
+++ b/source/BreezeCore/include/breeze/Sdks.hpp
@@ -0,0 +1,69 @@
+#pragma once
+
+#include <filesystem>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include "breeze/Project.hpp"
+#include "breeze/Version.hpp"
+
+/// SDK versions, where they come from and what moving a project between them means.
+///
+/// An SDK version is a snapshot of the whole template: breeze/ (the SDK proper, replaced as a whole
+/// on a change), plus the files the project owns and starts from (project/Configuration.cmake, the
+/// root CMakeLists.txt, CMakePresets.json, the dot files). Versions come from a *source*, either a
+/// git repository whose tags are versions (v1.2.0, 1.2.0) or a directory with one subdirectory per
+/// version.
+namespace breeze::sdk
+{
+
+	class Source
+	{
+	public:
+		struct Entry
+		{
+			Version version;
+			/// The tag, or the directory name, it was found under.
+			std::string ref;
+		};
+
+		/// The configured source (`breeze config sdk-source`, or BREEZE_SDK_SOURCE); throws Error
+		/// when there is none.
+		static Source configured();
+
+		explicit Source(std::string location);
+
+		[[nodiscard]] const std::string& location() const { return m_location; }
+
+		/// All versions, oldest first.
+		[[nodiscard]] std::vector<Entry> versions() const;
+
+		/// The files of one version, fetched into the CLI's cache on first use.
+		[[nodiscard]] std::filesystem::path snapshot(const Entry& entry) const;
+
+		/// "latest" (or nothing), or a version number: the matching entry. Throws Error, listing
+		/// what exists, when there is no such version.
+		[[nodiscard]] Entry resolve(const std::optional<std::string>& wanted) const;
+
+	private:
+		std::string m_location;
+		bool m_isRepository = false;
+	};
+
+	/// Creates ./<name> from an SDK version: a project with that SDK, the settings set to the new
+	/// project's name and id, no demo modules, and one executable module named after the project.
+	void createProject(const std::string& name, const std::optional<std::string>& id,
+					   const std::optional<std::string>& sdkVersion);
+
+	/// Reports which SDK versions exist and whether the project is behind.
+	void update(const Project& project);
+
+	/// Moves the project to the newest version with the same major as its own.
+	void upgrade(const Project& project);
+
+	/// Moves the project to exactly this version, whichever way and across majors, and a legacy
+	/// (flat) project to the breeze/ layout.
+	void migrate(const Project& project, const std::string& version);
+
+}
diff --git a/source/BreezeCore/include/breeze/Text.hpp b/source/BreezeCore/include/breeze/Text.hpp
new file mode 100644
index 0000000..e6ce76c
--- /dev/null
+++ b/source/BreezeCore/include/breeze/Text.hpp
@@ -0,0 +1,35 @@
+#pragma once
+
+#include <string>
+#include <string_view>
+#include <vector>
+
+/// Small string helpers; nothing here knows about breeze.
+namespace breeze::text
+{
+
+	std::string trim(std::string_view s);
+	std::vector<std::string> split(std::string_view s, char delimiter);
+	std::vector<std::string> splitLines(std::string_view s);
+	std::string join(const std::vector<std::string>& parts, std::string_view separator);
+	std::string lower(std::string_view s);
+	bool startsWith(std::string_view s, std::string_view prefix);
+	bool endsWith(std::string_view s, std::string_view suffix);
+	std::string replaceAll(std::string s, std::string_view from, std::string_view to);
+
+	/// "CoreFarewell" -> "core_farewell", "HTTPServer" -> "http_server", "my-app" -> "my_app".
+	std::string snakeCase(std::string_view s);
+
+	/// Lower-case letters and digits only: "Clang-CL" -> "clangcl". For comparing names loosely.
+	std::string normalized(std::string_view s);
+
+	/// A module or project name: a letter, then letters, digits, '_' (and '-' when allowDash).
+	bool isName(std::string_view s, bool allowDash = false);
+
+	/// A CMake target id as this project writes them: letters, digits, '_', '.', '+', '-' and "::".
+	bool isTargetId(std::string_view s);
+
+	/// "x" for a version-less message, with a '<none>' stand-in for an empty value.
+	std::string orNone(std::string_view s);
+
+}
diff --git a/source/BreezeCore/include/breeze/Tools.hpp b/source/BreezeCore/include/breeze/Tools.hpp
new file mode 100644
index 0000000..c1c9647
--- /dev/null
+++ b/source/BreezeCore/include/breeze/Tools.hpp
@@ -0,0 +1,57 @@
+#pragma once
+
+#include <optional>
+#include <string>
+#include <vector>
+
+#include "breeze/Project.hpp"
+
+/// Tools: extensions a project installs from a repository. A tool is a git repository (or, while it
+/// is being written, a directory) with a `breeze-tool.json` at its root:
+///
+///     { "id": "resembed", "version": "1.0.0", "description": "...", "entry": "bin/resembed.sh" }
+///
+/// `entry` may instead be { "posix": "...", "windows": "..." }. Installed, a tool is copied into
+/// <project>/.breeze/tools/<id>/ and recorded in .breeze/tools.json (meant to be committed). From
+/// then on `breeze tool <id> <arguments...>` runs its entry with those arguments, in the project's
+/// directory, with the project described in environment variables (BREEZE_PROJECT_ROOT,
+/// BREEZE_SDK_DIR, BREEZE_SDK_VERSION, BREEZE_TOOL_ID, BREEZE_TOOL_DIR, BREEZE_CLI, BREEZE_EDITOR).
+/// What commands a tool offers, and what they do, is entirely up to the tool.
+namespace breeze::tools
+{
+
+	struct Tool
+	{
+		std::string id;
+		std::string version;
+		std::string repo;
+		std::string description;
+		std::filesystem::path dir;
+	};
+
+	/// The words after `breeze tool` that belong to the CLI itself and can't be tool ids.
+	bool isReservedName(const std::string& word);
+
+	std::vector<Tool> installed(const Project& project);
+
+	/// Installs the newest version of the tool in `repo`.
+	void install(const Project& project, const std::string& repo);
+	void uninstall(const Project& project, const std::string& id);
+
+	/// Reports whether newer versions of the tool exist.
+	void update(const Project& project, const std::string& id);
+
+	/// Moves the tool to its newest version with the same major version.
+	void upgrade(const Project& project, const std::string& id);
+
+	/// Moves the tool to exactly this version.
+	void migrate(const Project& project, const std::string& id, const std::string& version);
+
+	void list(const Project& project);
+
+	/// Runs the tool's entry with `args`; the entry's exit code, or nullopt when no such tool is
+	/// installed.
+	std::optional<int> run(const Project& project, const std::string& id,
+						   const std::vector<std::string>& args);
+
+}
diff --git a/source/BreezeCore/include/breeze/Version.hpp b/source/BreezeCore/include/breeze/Version.hpp
new file mode 100644
index 0000000..c59a098
--- /dev/null
+++ b/source/BreezeCore/include/breeze/Version.hpp
@@ -0,0 +1,35 @@
+#pragma once
+
+#include <optional>
+#include <string>
+#include <string_view>
+#include <vector>
+
+namespace breeze
+{
+
+	/// A semantic version: major.minor.patch with an optional pre-release tag.
+	/// A pre-release sorts before the release it leads up to (1.0.0-rc1 < 1.0.0).
+	struct Version
+	{
+		int major = 0;
+		int minor = 0;
+		int patch = 0;
+		std::string pre;
+
+		[[nodiscard]] std::string toString() const;
+	};
+
+	/// Accepts "1.2.3", "v1.2.3", "1.2.3-rc1", "1.2" (patch 0) and "1" (minor and patch 0);
+	/// anything else, including build metadata after '+', is dropped or rejected.
+	std::optional<Version> parseVersion(std::string_view text);
+
+	int compare(const Version& a, const Version& b);
+	bool operator<(const Version& a, const Version& b);
+	bool operator==(const Version& a, const Version& b);
+
+	/// The greatest of `versions`; with `sameMajorAs`, only of those with that major version.
+	std::optional<Version> greatest(const std::vector<Version>& versions,
+									std::optional<int> sameMajorAs = std::nullopt);
+
+}
diff --git a/source/BreezeCore/src/Arguments.cpp b/source/BreezeCore/src/Arguments.cpp
new file mode 100644
index 0000000..5e57416
--- /dev/null
+++ b/source/BreezeCore/src/Arguments.cpp
@@ -0,0 +1,48 @@
+#include "breeze/Arguments.hpp"
+
+#include <set>
+
+namespace breeze::cli
+{
+
+	std::vector<std::string> normalizeArguments(const std::vector<std::string>& args)
+	{
+		if (args.empty())
+			return args;
+		const std::string& command = args.front();
+		if (command != "build" && command != "install" && command != "run")
+			return args;
+
+		// The options of these commands that take other programs' arguments.
+		static const std::set<std::string> Passthrough = {"--cargs", "--bargs", "--args", "-x"};
+		// Every option these commands have: where a pass-through list ends.
+		static const std::set<std::string> Known = {
+			"--platform", "-P",		 "--arch", "-A", "--compiler",	   "-C",
+			"--mode",	  "-M",		 "--jobs", "-j", "--preset",	   "-p",
+			"--cargs",	  "--bargs", "--args", "-x", "--no-configure", "--no-build",
+			"--help",	  "-h"};
+
+		std::vector<std::string> out;
+		for (std::size_t i = 0; i < args.size(); ++i)
+		{
+			const std::string& token = args[i];
+			if (i == 0 || Passthrough.count(token) == 0)
+			{
+				out.push_back(token);
+				continue;
+			}
+			// `--cargs=...` written by the user is already in the right form and not in
+			// `Passthrough`.
+			std::string longName = token == "-x" ? "--args" : token;
+			while (i + 1 < args.size() && Known.count(args[i + 1]) == 0)
+			{
+				out.push_back(longName + "=" + args[i + 1]);
+				++i;
+			}
+			if (out.empty() || out.back().rfind(longName + "=", 0) != 0)
+				out.push_back(token); // no values: let CLIForge report that
+		}
+		return out;
+	}
+
+}
diff --git a/source/BreezeCore/src/Build.cpp b/source/BreezeCore/src/Build.cpp
new file mode 100644
index 0000000..352a1d3
--- /dev/null
+++ b/source/BreezeCore/src/Build.cpp
@@ -0,0 +1,321 @@
+#include "breeze/Build.hpp"
+
+#include <iostream>
+
+#include "breeze/Error.hpp"
+#include "breeze/Fs.hpp"
+#include "breeze/Modules.hpp"
+#include "breeze/Process.hpp"
+#include "breeze/Text.hpp"
+
+namespace breeze
+{
+
+	namespace sfs = std::filesystem;
+
+	std::string buildTypeFor(const std::string& mode)
+	{
+		std::string m = text::normalized(mode);
+		if (m == "release")
+			return "Release";
+		if (m == "debug")
+			return "Debug";
+		if (m == "releasedebugsymbols" || m == "relwithdebinfo")
+			return "RelWithDebInfo";
+		if (m == "minsizerel")
+			return "MinSizeRel";
+		throw Error("'" + mode +
+					"' is not a build mode: use Release, Debug, ReleaseDebugSymbols or MinSizeRel");
+	}
+
+	namespace
+	{
+		bool hasFile(const sfs::path& p)
+		{
+			std::error_code ec;
+			return sfs::is_regular_file(p, ec);
+		}
+
+		proc::Options inProject(const Project& project)
+		{
+			proc::Options o;
+			o.cwd = project.root;
+			return o;
+		}
+
+		sfs::path requireScript(const Project& project, const std::string& name)
+		{
+			sfs::path script = project.script(name);
+			if (!hasFile(script))
+				throw Error("this project's SDK (" + project.sdk.describe() + ") has no '" +
+							fs::generic(sfs::relative(script, project.root)) + "'");
+			return script;
+		}
+
+		std::optional<std::string> modeOf(const BuildRequest& request, const Defaults& defaults)
+		{
+			std::optional<std::string> mode = request.mode ? request.mode : defaults.build("mode");
+			if (!mode)
+				return std::nullopt;
+			return buildTypeFor(*mode);
+		}
+
+		std::optional<std::string> presetOf(const Project& project, const Defaults& defaults,
+											const PresetQuery& query)
+		{
+			std::string note;
+			std::optional<std::string> preset = resolvePreset(project, defaults, query, &note);
+			if (!note.empty())
+				std::cerr << "breeze: " << note << "\n";
+			return preset;
+		}
+
+		bool isUnder(const sfs::path& root, const sfs::path& p)
+		{
+			std::error_code ec;
+			sfs::path r = sfs::weakly_canonical(root, ec);
+			sfs::path c = sfs::weakly_canonical(p, ec);
+			auto rel = c.lexically_relative(r);
+			return !rel.empty() && *rel.begin() != "..";
+		}
+	}
+
+	std::map<std::string, std::string> readConfigVariables(const Project& project,
+														   const std::vector<std::string>& names)
+	{
+		std::map<std::string, std::string> values;
+		sfs::path printConfig = project.sdk.cmakeDir / "PrintConfig.cmake";
+		if (hasFile(printConfig))
+		{
+			proc::Options o = inProject(project);
+			o.capture = true;
+			proc::Result r = proc::run(
+				{"cmake", "-DPRINT_VARS=" + text::join(names, ";"), "-P", printConfig.string()}, o);
+			if (r.exitCode == 0)
+			{
+				for (const std::string& line : text::splitLines(r.output))
+				{
+					if (!text::startsWith(line, "-- "))
+						continue;
+					std::size_t eq = line.find('=');
+					if (eq == std::string::npos)
+						continue;
+					values[line.substr(3, eq - 3)] = line.substr(eq + 1);
+				}
+			}
+		}
+		// Anything the SDK couldn't tell: the layout every SDK so far has used.
+		for (const std::string& n : names)
+		{
+			if (values.count(n) != 0 && !values[n].empty())
+				continue;
+			if (n == "BUILD_OUTPUT_DIR")
+				values[n] = fs::generic(project.root / "out" / "build");
+			else if (n == "DOCS_OUTPUT_DIR")
+				values[n] = fs::generic(project.root / "out" / "docs");
+		}
+		return values;
+	}
+
+	sfs::path buildDirFor(const Project& project, const std::optional<std::string>& preset)
+	{
+		sfs::path buildDirScript = project.sdk.cmakeDir / "BuildDir.cmake";
+		if (hasFile(buildDirScript))
+		{
+			proc::Options o = inProject(project);
+			o.capture = true;
+			std::vector<std::string> argv{"cmake"};
+			if (preset)
+				argv.push_back("-DPMN_NAME=" + *preset);
+			argv.push_back("-P");
+			argv.push_back(buildDirScript.string());
+			proc::Result r = proc::run(argv, o);
+			for (const std::string& line : text::splitLines(r.output))
+			{
+				if (text::startsWith(line, "-- BUILD_DIR="))
+					return sfs::path(line.substr(13));
+				if (text::startsWith(line, "-- ERROR="))
+					throw Error(line.substr(9));
+			}
+			throw Error("could not tell which build directory to use (the SDK's BuildDir.cmake "
+						"said nothing)");
+		}
+		std::map<std::string, std::string> vars =
+			readConfigVariables(project, {"BUILD_OUTPUT_DIR"});
+		return sfs::path(vars["BUILD_OUTPUT_DIR"]) / (preset ? *preset : "default");
+	}
+
+	int build(const Project& project, const BuildRequest& request)
+	{
+		Defaults defaults = Defaults::load(project);
+		std::optional<std::string> preset = presetOf(project, defaults, request.preset);
+		std::optional<std::string> type = modeOf(request, defaults);
+
+		proc::Options options = inProject(project);
+		if (request.jobs)
+			options.env.emplace_back("CMAKE_BUILD_PARALLEL_LEVEL", std::to_string(*request.jobs));
+
+		if (request.buildArgs.empty() && !request.noConfigure)
+		{
+			// The ordinary path: the SDK's script configures and builds.
+			std::vector<std::string> args;
+			if (preset)
+			{
+				args.push_back("--preset");
+				args.push_back(*preset);
+			}
+			if (type)
+				args.push_back(*type);
+			args.insert(args.end(), request.configureArgs.begin(), request.configureArgs.end());
+			return proc::runScript(requireScript(project, "build"), args, options).exitCode;
+		}
+
+		// Extra build arguments, or no configure: build the configured directory directly.
+		sfs::path dir = buildDirFor(project, preset);
+		if (!hasFile(dir / "CMakeCache.txt"))
+			throw Error("'" + fs::generic(dir) +
+						"' is not configured yet. Run `breeze build` once without " +
+						(request.noConfigure ? "--no-configure" : "--bargs") + " first");
+		if (request.noConfigure && !request.configureArgs.empty())
+			std::cerr << "breeze: --cargs are ignored with --no-configure\n";
+
+		std::vector<std::string> argv{"cmake", "--build", dir.string()};
+		if (type)
+		{
+			argv.push_back("--config");
+			argv.push_back(*type);
+		}
+		if (request.jobs)
+		{
+			argv.push_back("-j");
+			argv.push_back(std::to_string(*request.jobs));
+		}
+		argv.insert(argv.end(), request.buildArgs.begin(), request.buildArgs.end());
+		return proc::run(argv, options).exitCode;
+	}
+
+	int install(const Project& project, const BuildRequest& request)
+	{
+		if (!request.noBuild)
+		{
+			int rc = build(project, request);
+			if (rc != 0)
+				return rc;
+		}
+		Defaults defaults = Defaults::load(project);
+		std::optional<std::string> preset = presetOf(project, defaults, request.preset);
+		std::optional<std::string> type = modeOf(request, defaults);
+		std::vector<std::string> args;
+		if (preset)
+		{
+			args.push_back("--preset");
+			args.push_back(*preset);
+		}
+		if (type)
+			args.push_back(*type);
+		return proc::runScript(requireScript(project, "install"), args, inProject(project))
+			.exitCode;
+	}
+
+	int docs(const Project& project)
+	{
+		Defaults defaults = Defaults::load(project);
+		std::vector<std::string> args;
+		if (std::optional<std::string> preset = defaults.build("preset"))
+		{
+			args.push_back("--preset");
+			args.push_back(*preset);
+		}
+		int rc = proc::runScript(requireScript(project, "docs"), args, inProject(project)).exitCode;
+		if (rc != 0 && rc != 127)
+			std::cerr << "breeze: the documentation needs a build first: run `breeze build`\n";
+		return rc;
+	}
+
+	int run(const Project& project, const std::optional<std::string>& id, const PresetQuery& where,
+			const std::vector<std::string>& programArgs)
+	{
+		Defaults defaults = Defaults::load(project);
+		std::string target;
+		if (id)
+		{
+			target = *id;
+			// A directory name works too, when the module is there.
+			std::vector<Module> modules = scanModules(project);
+			if (const Module* m = findModule(modules, *id))
+				target = m->id;
+		}
+		else if (std::optional<std::string> d = defaults.run())
+		{
+			target = *d;
+		}
+		else
+		{
+			std::vector<Module> modules = scanModules(project);
+			std::vector<std::string> execs;
+			for (const Module& m : modules)
+			{
+				if (m.kind == ModuleKind::Exec)
+					execs.push_back(m.id);
+			}
+			if (execs.size() != 1)
+				throw Error(std::string(execs.empty() ? "this project has no executable module"
+													  : "which executable? This project has " +
+															text::join(execs, ", ")) +
+							". Give an id, or set a default with `breeze defaults run --set <id>`");
+			target = execs.front();
+		}
+
+		std::optional<std::string> preset = presetOf(project, defaults, where);
+		std::vector<std::string> args;
+		if (preset)
+		{
+			args.push_back("--preset");
+			args.push_back(*preset);
+		}
+		args.push_back(target);
+		if (!programArgs.empty())
+		{
+			args.push_back("--");
+			args.insert(args.end(), programArgs.begin(), programArgs.end());
+		}
+		return proc::runScript(requireScript(project, "run"), args, inProject(project)).exitCode;
+	}
+
+	int setup(const Project& project, bool required, bool all)
+	{
+		std::vector<std::string> args;
+		if (all)
+			args.push_back("--all");
+		else if (required)
+			args.push_back("--yes");
+		return proc::runScript(requireScript(project, "setup"), args, inProject(project)).exitCode;
+	}
+
+	std::vector<std::string> clean(const Project& project, bool keepBuild, bool alsoDocs)
+	{
+		std::vector<std::string> names;
+		if (!keepBuild)
+			names.push_back("BUILD_OUTPUT_DIR");
+		if (alsoDocs)
+			names.push_back("DOCS_OUTPUT_DIR");
+		std::vector<std::string> removed;
+		if (names.empty())
+			return removed;
+		std::map<std::string, std::string> vars = readConfigVariables(project, names);
+		for (const std::string& n : names)
+		{
+			sfs::path dir = vars[n];
+			if (!isUnder(project.root, dir))
+				throw Error("refusing to remove '" + fs::generic(dir) +
+							"': it is outside the project");
+			std::error_code ec;
+			if (!sfs::exists(dir, ec))
+				continue;
+			fs::removeTree(dir);
+			removed.push_back(fs::generic(sfs::relative(dir, project.root)));
+		}
+		return removed;
+	}
+
+}
diff --git a/source/BreezeCore/src/CMakeText.cpp b/source/BreezeCore/src/CMakeText.cpp
new file mode 100644
index 0000000..9197a53
--- /dev/null
+++ b/source/BreezeCore/src/CMakeText.cpp
@@ -0,0 +1,210 @@
+#include "breeze/CMakeText.hpp"
+
+#include <cctype>
+
+#include "breeze/Text.hpp"
+
+namespace breeze::cmake
+{
+
+	namespace
+	{
+		bool isIdentStart(char c)
+		{
+			return std::isalpha(static_cast<unsigned char>(c)) || c == '_';
+		}
+
+		bool isIdentChar(char c)
+		{
+			return std::isalnum(static_cast<unsigned char>(c)) || c == '_';
+		}
+
+		// Skips whitespace and comments from pos; returns the new position.
+		std::size_t skipBlank(const std::string& t, std::size_t pos)
+		{
+			while (pos < t.size())
+			{
+				char c = t[pos];
+				if (std::isspace(static_cast<unsigned char>(c)))
+				{
+					++pos;
+				}
+				else if (c == '#')
+				{
+					// bracket comment: #[[ ... ]] or #[=[ ... ]=]
+					std::size_t eq = pos + 1;
+					if (eq < t.size() && t[eq] == '[')
+					{
+						std::size_t level = 0;
+						std::size_t p = eq + 1;
+						while (p < t.size() && t[p] == '=')
+						{
+							++level;
+							++p;
+						}
+						if (p < t.size() && t[p] == '[')
+						{
+							std::string close = "]" + std::string(level, '=') + "]";
+							std::size_t endPos = t.find(close, p + 1);
+							pos = endPos == std::string::npos ? t.size() : endPos + close.size();
+							continue;
+						}
+					}
+					while (pos < t.size() && t[pos] != '\n')
+						++pos;
+				}
+				else
+				{
+					break;
+				}
+			}
+			return pos;
+		}
+
+		// Parses the arguments of a call whose '(' is at `open`; returns the position just after
+		// the matching ')'.
+		std::size_t parseArgs(const std::string& t, std::size_t open, std::vector<Token>& args)
+		{
+			std::size_t pos = open + 1;
+			int depth = 1;
+			while (pos < t.size())
+			{
+				pos = skipBlank(t, pos);
+				if (pos >= t.size())
+					break;
+				char c = t[pos];
+				if (c == ')')
+				{
+					if (--depth == 0)
+						return pos + 1;
+					++pos;
+					continue;
+				}
+				if (c == '(')
+				{
+					++depth;
+					++pos;
+					continue;
+				}
+				Token tok;
+				tok.begin = pos;
+				if (c == '"')
+				{
+					tok.quoted = true;
+					++pos;
+					while (pos < t.size() && t[pos] != '"')
+					{
+						if (t[pos] == '\\' && pos + 1 < t.size())
+							++pos;
+						tok.text += t[pos++];
+					}
+					if (pos < t.size())
+						++pos; // closing quote
+				}
+				else if (c == '[' && pos + 1 < t.size() && (t[pos + 1] == '[' || t[pos + 1] == '='))
+				{
+					std::size_t p = pos + 1;
+					std::size_t level = 0;
+					while (p < t.size() && t[p] == '=')
+					{
+						++level;
+						++p;
+					}
+					if (p < t.size() && t[p] == '[')
+					{
+						std::string close = "]" + std::string(level, '=') + "]";
+						std::size_t endPos = t.find(close, p + 1);
+						std::size_t contentEnd = endPos == std::string::npos ? t.size() : endPos;
+						tok.quoted = true;
+						tok.text = t.substr(p + 1, contentEnd - p - 1);
+						pos = endPos == std::string::npos ? t.size() : endPos + close.size();
+					}
+					else
+					{
+						tok.text = "[";
+						++pos;
+					}
+				}
+				else
+				{
+					while (pos < t.size() && !std::isspace(static_cast<unsigned char>(t[pos])) &&
+						   t[pos] != ')' && t[pos] != '(' && t[pos] != '#' && t[pos] != '"')
+						tok.text += t[pos++];
+					if (tok.text.empty())
+					{
+						++pos; // a stray character: step over it rather than loop
+						continue;
+					}
+				}
+				tok.end = pos;
+				args.push_back(std::move(tok));
+			}
+			return t.size();
+		}
+	}
+
+	std::vector<Call> findCalls(const std::string& text,
+								const std::function<bool(const std::string&)>& wanted)
+	{
+		std::vector<Call> calls;
+		std::size_t pos = 0;
+		while (pos < text.size())
+		{
+			pos = skipBlank(text, pos);
+			if (pos >= text.size())
+				break;
+			if (!isIdentStart(text[pos]))
+			{
+				++pos;
+				continue;
+			}
+			std::size_t nameBegin = pos;
+			while (pos < text.size() && isIdentChar(text[pos]))
+				++pos;
+			std::string name = text.substr(nameBegin, pos - nameBegin);
+			std::size_t open = pos;
+			while (open < text.size() && (text[open] == ' ' || text[open] == '\t'))
+				++open;
+			if (open >= text.size() || text[open] != '(')
+				continue;
+			Call call;
+			call.name = std::move(name);
+			call.begin = nameBegin;
+			call.end = parseArgs(text, open, call.args);
+			pos = call.end;
+			if (wanted(call.name))
+				calls.push_back(std::move(call));
+		}
+		return calls;
+	}
+
+	std::optional<Call> findSet(const std::string& text, const std::string& variable)
+	{
+		for (Call& call :
+			 findCalls(text, [](const std::string& n) { return text::lower(n) == "set"; }))
+		{
+			if (!call.args.empty() && call.args[0].text == variable)
+				return std::move(call);
+		}
+		return std::nullopt;
+	}
+
+	std::string quote(const std::string& value)
+	{
+		std::string out = "\"";
+		for (char c : value)
+		{
+			if (c == '"' || c == '\\')
+				out += '\\';
+			out += c;
+		}
+		out += '"';
+		return out;
+	}
+
+	void replaceToken(std::string& text, const Token& token, const std::string& replacement)
+	{
+		text.replace(token.begin, token.end - token.begin, replacement);
+	}
+
+}
diff --git a/source/BreezeCore/src/Cli.cpp b/source/BreezeCore/src/Cli.cpp
new file mode 100644
index 0000000..2432ce0
--- /dev/null
+++ b/source/BreezeCore/src/Cli.cpp
@@ -0,0 +1,290 @@
+#include "breeze/Cli.hpp"
+
+#include <algorithm>
+#include <iostream>
+
+#include "breeze/Config.hpp"
+#include "breeze/Error.hpp"
+#include "breeze/Fs.hpp"
+#include "breeze/Process.hpp"
+#include "breeze/Text.hpp"
+
+#ifndef BREEZE_CLI_VERSION
+#define BREEZE_CLI_VERSION "0.0.0"
+#endif
+
+namespace breeze::self
+{
+
+	namespace sfs = std::filesystem;
+
+	std::string version()
+	{
+		return BREEZE_CLI_VERSION;
+	}
+
+	namespace
+	{
+		sfs::path root()
+		{
+			return breezeHome() / "cli";
+		}
+
+		std::string exeName()
+		{
+			return fs::hostPlatform() == "windows" ? "breeze.exe" : "breeze";
+		}
+
+		sfs::path binaryOf(const Version& v)
+		{
+			return root() / v.toString() / exeName();
+		}
+
+		sfs::path shim()
+		{
+			return breezeHome() / "bin" / exeName();
+		}
+
+		Version parseOrThrow(const std::string& text)
+		{
+			std::optional<Version> v = parseVersion(text);
+			if (!v)
+				throw Error("'" + text + "' is not a version (use 1.2.3)");
+			return *v;
+		}
+
+		bool isUrl(const std::string& s)
+		{
+			return text::startsWith(s, "http://") || text::startsWith(s, "https://");
+		}
+
+		// <source>/<version>/breeze-<platform>-<arch>[.exe], a URL or a directory.
+		void obtain(const std::string& source, const Version& v, const sfs::path& destination)
+		{
+			std::string file = "breeze-" + fs::hostPlatform() + "-" + fs::hostArch() +
+							   (fs::hostPlatform() == "windows" ? ".exe" : "");
+			std::string base = source;
+			while (!base.empty() && base.back() == '/')
+				base.pop_back();
+			std::string where = base + "/" + v.toString() + "/" + file;
+
+			std::error_code ec;
+			sfs::create_directories(destination.parent_path(), ec);
+			if (isUrl(source))
+			{
+				if (!proc::findInPath("curl"))
+					throw Error("curl is needed to download CLI versions, and it is not installed");
+				proc::Result r = proc::run({"curl", "--fail", "--silent", "--show-error",
+											"--location", "--output", destination.string(), where});
+				if (r.exitCode != 0)
+					throw Error("cannot download '" + where + "'");
+				return;
+			}
+			if (text::startsWith(where, "file://"))
+				where = where.substr(7);
+			if (!sfs::is_regular_file(where, ec))
+				throw Error("there is no '" + where + "': CLI " + v.toString() +
+							" is not in the CLI source '" + source + "' for " + fs::hostPlatform() +
+							"-" + fs::hostArch());
+			sfs::copy_file(where, destination, sfs::copy_options::overwrite_existing, ec);
+			if (ec)
+				throw Error("cannot copy '" + where + "': " + ec.message());
+		}
+	}
+
+	std::vector<Version> installed()
+	{
+		std::vector<Version> out;
+		std::error_code ec;
+		if (!sfs::is_directory(root(), ec))
+			return out;
+		for (const sfs::directory_entry& e : sfs::directory_iterator(root(), ec))
+		{
+			if (!e.is_directory())
+				continue;
+			std::optional<Version> v = parseVersion(e.path().filename().string());
+			if (v && sfs::exists(binaryOf(*v)))
+				out.push_back(*v);
+		}
+		std::sort(out.begin(), out.end());
+		return out;
+	}
+
+	std::optional<Version> picked()
+	{
+		std::optional<std::string> text = fs::tryReadText(root() / "current");
+		if (!text)
+			return std::nullopt;
+		return parseVersion(text::trim(*text));
+	}
+
+	void install(const std::string& versionText)
+	{
+		Version v = parseOrThrow(versionText);
+		sfs::path binary = binaryOf(v);
+		bool already = sfs::exists(binary);
+
+		if (!already)
+		{
+			// Nothing is left behind when it fails.
+			struct Cleanup
+			{
+				explicit Cleanup(sfs::path d) : dir(std::move(d)) {}
+				Cleanup(const Cleanup&) = delete;
+				Cleanup& operator=(const Cleanup&) = delete;
+				Cleanup(Cleanup&&) = delete;
+				Cleanup& operator=(Cleanup&&) = delete;
+				sfs::path dir;
+				bool armed = true;
+				~Cleanup()
+				{
+					if (armed)
+					{
+						std::error_code ec;
+						sfs::remove_all(dir, ec);
+					}
+				}
+			} cleanup{binary.parent_path()};
+
+			if (std::optional<Version> own = parseVersion(version()); own && *own == v)
+			{
+				// This program is the version asked for: install a copy of it.
+				std::error_code ec;
+				sfs::create_directories(binary.parent_path(), ec);
+				sfs::copy_file(fs::executablePath(), binary, sfs::copy_options::overwrite_existing,
+							   ec);
+				if (ec)
+					throw Error("cannot copy this program to '" + fs::generic(binary) +
+								"': " + ec.message());
+			}
+			else
+			{
+				GlobalConfig cfg = GlobalConfig::load();
+				std::optional<std::string> source = cfg.effective(config::CliSource);
+				if (!source)
+					throw Error("CLI " + v.toString() + " is not this program (" + version() +
+								") and no CLI source "
+								"is configured. Say where releases come from with:\n"
+								"  breeze config cli-source --set <URL or directory>");
+				obtain(*source, v, binary);
+			}
+			fs::makeExecutable(binary);
+
+			// It has to be the version it says it is, and run at all.
+			proc::Options o;
+			o.capture = true;
+			proc::Result r = proc::run({binary.string(), "cli", "version"}, o);
+			if (r.exitCode != 0 || text::trim(r.output) != v.toString())
+			{
+				throw Error("what was installed for " + v.toString() +
+							" does not run, or says it is another version "
+							"(it printed '" +
+							text::trim(r.output) + "'); nothing was installed");
+			}
+			cleanup.armed = false;
+		}
+
+		// The copy to put on PATH, and the first version installed is the one in use.
+		if (!sfs::exists(shim()))
+		{
+			std::error_code ec;
+			sfs::create_directories(shim().parent_path(), ec);
+			sfs::copy_file(binary, shim(), sfs::copy_options::overwrite_existing, ec);
+		}
+		bool first = !picked().has_value();
+		if (first)
+			fs::writeText(root() / "current", v.toString() + "\n");
+
+		std::cout << (already ? "already installed: " : "installed ") << v.toString()
+				  << (first ? " (picked)" : "") << "\n";
+		const char* pathEnv = std::getenv("PATH");
+		std::string binDir = fs::generic(shim().parent_path());
+		if (pathEnv == nullptr ||
+			std::string(pathEnv).find(shim().parent_path().string()) == std::string::npos)
+			std::cout << "to use it from anywhere, put " << binDir << " on your PATH\n";
+	}
+
+	void pick(const std::string& versionText)
+	{
+		Version v = parseOrThrow(versionText);
+		if (!sfs::exists(binaryOf(v)))
+		{
+			std::vector<std::string> names;
+			for (const Version& i : installed())
+				names.push_back(i.toString());
+			throw Error("CLI " + v.toString() + " is not installed (`breeze cli install " +
+						v.toString() + "`). " +
+						(names.empty() ? "Nothing is installed."
+									   : "Installed: " + text::join(names, ", ")));
+		}
+		std::optional<Version> before = picked();
+		fs::writeText(root() / "current", v.toString() + "\n");
+		std::cout << "picked " << v.toString();
+		if (before && !(*before == v))
+			std::cout << " (was " << before->toString() << ")";
+		std::cout << "\n";
+	}
+
+	void uninstall(const std::string& versionText)
+	{
+		Version v = parseOrThrow(versionText);
+		sfs::path dir = root() / v.toString();
+		if (!sfs::exists(dir))
+			throw Error("CLI " + v.toString() + " is not installed");
+		bool wasPicked = picked() && *picked() == v;
+		fs::removeTree(dir);
+		if (wasPicked)
+		{
+			std::error_code ec;
+			sfs::remove(root() / "current", ec);
+		}
+		std::cout << "uninstalled " << v.toString()
+				  << (wasPicked ? " (it was the picked version: none is picked now)" : "") << "\n";
+	}
+
+	void list()
+	{
+		std::vector<Version> all = installed();
+		std::optional<Version> p = picked();
+		std::optional<Version> own = parseVersion(version());
+		if (all.empty())
+		{
+			std::cout << "no versions installed (this program is " << version()
+					  << ": `breeze cli install " << version() << "`)\n";
+			return;
+		}
+		for (const Version& v : all)
+		{
+			std::cout << (p && *p == v ? "* " : "  ") << v.toString();
+			if (own && *own == v)
+				std::cout << "  (this program)";
+			std::cout << "\n";
+		}
+	}
+
+	void forwardToPicked(const std::vector<std::string>& args)
+	{
+		if (std::getenv("BREEZE_NO_FORWARD") != nullptr)
+			return;
+		if (args.empty() || args.front() == "cli")
+			return;
+		std::optional<Version> p = picked();
+		std::optional<Version> own = parseVersion(version());
+		if (!p || (own && *own == *p))
+			return;
+		sfs::path binary = binaryOf(*p);
+		if (!fs::isExecutable(binary))
+		{
+			std::cerr << "breeze: the picked version " << p->toString()
+					  << " is not installed any more; using " << version()
+					  << " (`breeze cli install " << p->toString()
+					  << "` or `breeze cli pick <version>`)\n";
+			return;
+		}
+		proc::setEnvironment("BREEZE_NO_FORWARD", "1");
+		std::vector<std::string> argv{binary.string()};
+		argv.insert(argv.end(), args.begin(), args.end());
+		proc::execReplace(argv);
+	}
+
+}
diff --git a/source/BreezeCore/src/Config.cpp b/source/BreezeCore/src/Config.cpp
new file mode 100644
index 0000000..d6a7e50
--- /dev/null
+++ b/source/BreezeCore/src/Config.cpp
@@ -0,0 +1,83 @@
+#include "breeze/Config.hpp"
+
+#include <cctype>
+#include <cstdlib>
+
+#include "breeze/Error.hpp"
+#include "breeze/Fs.hpp"
+
+namespace breeze
+{
+
+	std::filesystem::path breezeHome()
+	{
+		if (const char* p = std::getenv("BREEZE_HOME"); p != nullptr && *p != '\0')
+			return std::filesystem::path(p);
+		return fs::homeDir() / ".breeze";
+	}
+
+	namespace
+	{
+		std::filesystem::path configFile()
+		{
+			return breezeHome() / "config.json";
+		}
+
+		std::string envName(const std::string& key)
+		{
+			std::string name = "BREEZE_";
+			for (char c : key)
+			{
+				if (std::isupper(static_cast<unsigned char>(c)) && name.back() != '_')
+					name += '_';
+				name += static_cast<char>(std::toupper(static_cast<unsigned char>(c)));
+			}
+			return name;
+		}
+	}
+
+	GlobalConfig GlobalConfig::load()
+	{
+		GlobalConfig c;
+		if (std::optional<std::string> text = fs::tryReadText(configFile()))
+		{
+			nlohmann::json parsed = nlohmann::json::parse(*text, nullptr, false);
+			if (parsed.is_discarded() || !parsed.is_object())
+				throw Error("'" + fs::generic(configFile()) +
+							"' is not valid JSON; fix or delete it");
+			c.m_data = std::move(parsed);
+		}
+		return c;
+	}
+
+	std::optional<std::string> GlobalConfig::stored(const std::string& key) const
+	{
+		auto it = m_data.find(key);
+		if (it == m_data.end() || !it->is_string())
+			return std::nullopt;
+		return it->get<std::string>();
+	}
+
+	std::optional<std::string> GlobalConfig::effective(const std::string& key) const
+	{
+		if (const char* p = std::getenv(envName(key).c_str()); p != nullptr && *p != '\0')
+			return std::string(p);
+		return stored(key);
+	}
+
+	void GlobalConfig::set(const std::string& key, const std::string& value)
+	{
+		m_data[key] = value;
+	}
+
+	void GlobalConfig::erase(const std::string& key)
+	{
+		m_data.erase(key);
+	}
+
+	void GlobalConfig::save() const
+	{
+		fs::writeText(configFile(), m_data.dump(2) + "\n");
+	}
+
+}
diff --git a/source/BreezeCore/src/Fs.cpp b/source/BreezeCore/src/Fs.cpp
new file mode 100644
index 0000000..f7d4893
--- /dev/null
+++ b/source/BreezeCore/src/Fs.cpp
@@ -0,0 +1,211 @@
+#include "breeze/Fs.hpp"
+
+#include <cstdlib>
+
+#include <algorithm>
+#include <fstream>
+#include <random>
+#include <sstream>
+#include <system_error>
+
+#include "breeze/Error.hpp"
+
+#if defined(_WIN32)
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+#include <windows.h>
+#elif defined(__APPLE__)
+#include <mach-o/dyld.h>
+#include <unistd.h>
+#else
+#include <unistd.h>
+#endif
+
+#if !defined(_WIN32)
+#include <sys/stat.h>
+#endif
+
+namespace breeze::fs
+{
+
+	std::optional<std::string> tryReadText(const path& file)
+	{
+		std::ifstream in(file, std::ios::binary);
+		if (!in)
+			return std::nullopt;
+		std::ostringstream buffer;
+		buffer << in.rdbuf();
+		return buffer.str();
+	}
+
+	std::string readText(const path& file)
+	{
+		std::optional<std::string> text = tryReadText(file);
+		if (!text)
+			throw Error("cannot read '" + generic(file) + "'");
+		return *text;
+	}
+
+	void writeText(const path& file, const std::string& text)
+	{
+		std::error_code ec;
+		if (file.has_parent_path())
+			std::filesystem::create_directories(file.parent_path(), ec);
+		std::ofstream out(file, std::ios::binary | std::ios::trunc);
+		if (!out)
+			throw Error("cannot write '" + generic(file) + "'");
+		out << text;
+		if (!out)
+			throw Error("cannot write '" + generic(file) + "'");
+	}
+
+	void copyTree(const path& from, const path& to, const std::vector<std::string>& skipNames)
+	{
+		namespace sfs = std::filesystem;
+		std::error_code ec;
+		sfs::create_directories(to, ec);
+		for (const sfs::directory_entry& entry : sfs::directory_iterator(from))
+		{
+			std::string name = entry.path().filename().string();
+			if (std::find(skipNames.begin(), skipNames.end(), name) != skipNames.end())
+				continue;
+			path target = to / name;
+			if (entry.is_symlink())
+			{
+				sfs::copy_symlink(entry.path(), target, ec);
+				if (ec)
+					throw Error("cannot copy '" + generic(entry.path()) + "': " + ec.message());
+			}
+			else if (entry.is_directory())
+			{
+				copyTree(entry.path(), target, skipNames);
+			}
+			else
+			{
+				sfs::copy_file(entry.path(), target, sfs::copy_options::overwrite_existing, ec);
+				if (ec)
+					throw Error("cannot copy '" + generic(entry.path()) + "': " + ec.message());
+			}
+		}
+	}
+
+	void removeTree(const path& p)
+	{
+		std::error_code ec;
+		std::filesystem::remove_all(p, ec);
+		if (ec)
+			throw Error("cannot remove '" + generic(p) + "': " + ec.message());
+	}
+
+	path makeTempDir(const std::string& prefix)
+	{
+		std::random_device rd;
+		std::mt19937_64 gen(rd());
+		for (int attempt = 0; attempt < 100; ++attempt)
+		{
+			std::ostringstream name;
+			name << prefix << "-" << std::hex << gen();
+			path dir = std::filesystem::temp_directory_path() / name.str();
+			std::error_code ec;
+			if (std::filesystem::create_directory(dir, ec))
+				return dir;
+		}
+		throw Error("cannot create a temporary directory");
+	}
+
+	path homeDir()
+	{
+#if defined(_WIN32)
+		if (const char* p = std::getenv("USERPROFILE"))
+			return path(p);
+#endif
+		if (const char* p = std::getenv("HOME"))
+			return path(p);
+		throw Error("cannot tell where your home directory is (HOME is not set)");
+	}
+
+	path executablePath()
+	{
+#if defined(_WIN32)
+		std::wstring buffer(32768, L'\0');
+		DWORD n = GetModuleFileNameW(nullptr, buffer.data(), static_cast<DWORD>(buffer.size()));
+		buffer.resize(n);
+		return path(buffer);
+#elif defined(__APPLE__)
+		std::uint32_t size = 0;
+		_NSGetExecutablePath(nullptr, &size);
+		std::string buffer(size, '\0');
+		if (_NSGetExecutablePath(buffer.data(), &size) != 0)
+			throw Error("cannot tell where this program is");
+		buffer.resize(std::char_traits<char>::length(buffer.c_str()));
+		std::error_code ec;
+		path canonical = std::filesystem::canonical(buffer, ec);
+		return ec ? path(buffer) : canonical;
+#else
+		std::error_code ec;
+		path p = std::filesystem::read_symlink("/proc/self/exe", ec);
+		if (ec)
+			throw Error("cannot tell where this program is: " + ec.message());
+		return p;
+#endif
+	}
+
+	std::string hostPlatform()
+	{
+#if defined(_WIN32)
+		return "windows";
+#elif defined(__APPLE__)
+		return "macos";
+#else
+		return "linux";
+#endif
+	}
+
+	std::string hostArch()
+	{
+#if defined(__x86_64__) || defined(_M_X64)
+		return "x64";
+#elif defined(__aarch64__) || defined(_M_ARM64)
+		return "arm64";
+#elif defined(__arm__) || defined(_M_ARM)
+		return "arm32";
+#else
+		return "x86";
+#endif
+	}
+
+	void makeExecutable(const path& file)
+	{
+#if !defined(_WIN32)
+		std::error_code ec;
+		std::filesystem::permissions(file,
+									 std::filesystem::perms::owner_exec |
+										 std::filesystem::perms::group_exec |
+										 std::filesystem::perms::others_exec,
+									 std::filesystem::perm_options::add, ec);
+		if (ec)
+			throw Error("cannot make '" + generic(file) + "' executable: " + ec.message());
+#else
+		(void)file;
+#endif
+	}
+
+	bool isExecutable(const path& file)
+	{
+		std::error_code ec;
+		if (!std::filesystem::is_regular_file(file, ec))
+			return false;
+#if defined(_WIN32)
+		return true;
+#else
+		return ::access(file.c_str(), X_OK) == 0;
+#endif
+	}
+
+	std::string generic(const path& p)
+	{
+		return p.generic_string();
+	}
+
+}
diff --git a/source/BreezeCore/src/Git.cpp b/source/BreezeCore/src/Git.cpp
new file mode 100644
index 0000000..4cb89c4
--- /dev/null
+++ b/source/BreezeCore/src/Git.cpp
@@ -0,0 +1,115 @@
+#include "breeze/Git.hpp"
+
+#include <set>
+
+#include "breeze/Error.hpp"
+#include "breeze/Fs.hpp"
+#include "breeze/Process.hpp"
+#include "breeze/Text.hpp"
+
+namespace breeze::git
+{
+
+	namespace sfs = std::filesystem;
+
+	namespace
+	{
+		void requireGit()
+		{
+			if (!proc::findInPath("git"))
+				throw Error("git is needed for this, and it is not installed (or not on PATH)");
+		}
+
+		bool isUrl(const std::string& s)
+		{
+			return text::startsWith(s, "http://") || text::startsWith(s, "https://") ||
+				   text::startsWith(s, "ssh://") || text::startsWith(s, "git://") ||
+				   text::startsWith(s, "file://") || text::startsWith(s, "git@");
+		}
+
+		// A local repository is cloned through a file:// URL, which keeps git from ignoring
+		// --depth.
+		std::string cloneable(const std::string& repository)
+		{
+			if (isUrl(repository))
+				return repository;
+			std::error_code ec;
+			sfs::path abs = sfs::absolute(repository, ec);
+			return "file://" + abs.generic_string();
+		}
+	}
+
+	bool isRepository(const std::string& source)
+	{
+		if (isUrl(source))
+			return true;
+		std::error_code ec;
+		sfs::path p(source);
+		return sfs::is_directory(p / ".git", ec) ||
+			   (sfs::is_regular_file(p / "HEAD", ec) && sfs::is_directory(p / "objects", ec));
+	}
+
+	std::vector<Tag> versionTags(const std::string& repository)
+	{
+		requireGit();
+		proc::Options options;
+		options.capture = true;
+		proc::Result r =
+			proc::run({"git", "ls-remote", "--tags", "--refs", cloneable(repository)}, options);
+		if (r.exitCode != 0)
+			throw Error("cannot read the tags of '" + repository + "' (git ls-remote failed)");
+
+		std::vector<Tag> tags;
+		std::set<std::string> seen;
+		for (const std::string& line : text::splitLines(r.output))
+		{
+			std::size_t pos = line.find("refs/tags/");
+			if (pos == std::string::npos)
+				continue;
+			std::string name = text::trim(line.substr(pos + 10));
+			std::optional<Version> v = parseVersion(name);
+			if (!v || !seen.insert(name).second)
+				continue;
+			tags.push_back({name, *v});
+		}
+		return tags;
+	}
+
+	void exportTree(const std::string& repository, const std::string& tag,
+					const sfs::path& destination)
+	{
+		requireGit();
+		sfs::path tmp = fs::makeTempDir("breeze-git");
+		sfs::path work = tmp / "repo";
+		std::vector<std::string> argv{"git", "clone", "--quiet", "--depth", "1"};
+		if (!tag.empty())
+		{
+			argv.push_back("--branch");
+			argv.push_back(tag);
+		}
+		argv.push_back(cloneable(repository));
+		argv.push_back(work.string());
+		proc::Options options;
+		options.capture = true;
+		options.mergeStderr = true;
+		proc::Result r = proc::run(argv, options);
+		if (r.exitCode != 0)
+		{
+			fs::removeTree(tmp);
+			throw Error("cannot fetch " +
+						(tag.empty() ? std::string("the default branch") : "'" + tag + "'") +
+						" of '" + repository + "':\n" + text::trim(r.output));
+		}
+		fs::removeTree(work / ".git");
+		std::error_code ec;
+		sfs::create_directories(destination.parent_path(), ec);
+		sfs::rename(work, destination, ec);
+		if (ec)
+		{
+			// Different file systems: copy instead.
+			fs::copyTree(work, destination);
+		}
+		fs::removeTree(tmp);
+	}
+
+}
diff --git a/source/BreezeCore/src/Modules.cpp b/source/BreezeCore/src/Modules.cpp
new file mode 100644
index 0000000..c78464e
--- /dev/null
+++ b/source/BreezeCore/src/Modules.cpp
@@ -0,0 +1,580 @@
+#include "breeze/Modules.hpp"
+
+#include <algorithm>
+#include <array>
+#include <set>
+
+#include "breeze/CMakeText.hpp"
+#include "breeze/Error.hpp"
+#include "breeze/Fs.hpp"
+#include "breeze/Text.hpp"
+
+namespace breeze
+{
+
+	namespace sfs = std::filesystem;
+
+	std::string kindName(ModuleKind kind)
+	{
+		switch (kind)
+		{
+			case ModuleKind::Exec:
+				return "exec";
+			case ModuleKind::Lib:
+				return "lib";
+			case ModuleKind::Obj:
+				return "obj";
+			case ModuleKind::Test:
+				return "test";
+			case ModuleKind::Example:
+				return "example";
+		}
+		return "?";
+	}
+
+	namespace
+	{
+		struct MacroInfo
+		{
+			const char* name;
+			ModuleKind kind;
+			LibType libType;
+		};
+
+		const std::array<MacroInfo, 7> Macros = {{
+			{"add_lib_module", ModuleKind::Lib, LibType::Unspecified},
+			{"add_static_lib_module", ModuleKind::Lib, LibType::Static},
+			{"add_shared_lib_module", ModuleKind::Lib, LibType::Shared},
+			{"add_objects_module", ModuleKind::Obj, LibType::Unspecified},
+			{"add_exe_module", ModuleKind::Exec, LibType::Unspecified},
+			{"add_test_module", ModuleKind::Test, LibType::Unspecified},
+			{"add_example_module", ModuleKind::Example, LibType::Unspecified},
+		}};
+
+		const MacroInfo* macroInfo(const std::string& name)
+		{
+			std::string lowered = text::lower(name);
+			for (const MacroInfo& m : Macros)
+			{
+				if (lowered == m.name)
+					return &m;
+			}
+			return nullptr;
+		}
+
+		bool isModuleCall(const std::string& name)
+		{
+			return macroInfo(name) != nullptr;
+		}
+
+		bool isKeyword(const std::string& s)
+		{
+			return s == "OUTPUT_NAME" || s == "TYPE" || s == "DEPENDS" || s == "EXTRA_SOURCES" ||
+				   s == "NO_DOCS";
+		}
+
+		Module toModule(const cmake::Call& call, const sfs::path& dir, ModuleKind /*category*/)
+		{
+			const MacroInfo* info = macroInfo(call.name);
+			Module m;
+			m.macro = text::lower(call.name);
+			m.dir = dir;
+			m.dirName = dir.filename().string();
+			m.kind = info->kind;
+			m.libType = info->libType;
+			std::string mode;
+			bool haveId = false;
+			for (const cmake::Token& t : call.args)
+			{
+				if (!t.quoted && isKeyword(t.text))
+				{
+					mode = t.text;
+					continue;
+				}
+				if (!haveId)
+				{
+					m.id = t.text;
+					haveId = true;
+				}
+				else if (mode == "OUTPUT_NAME")
+				{
+					m.outputName = t.text;
+				}
+				else if (mode == "TYPE")
+				{
+					std::string v = text::lower(t.text);
+					m.libType = v == "shared"	? LibType::Shared
+								: v == "static" ? LibType::Static
+												: m.libType;
+				}
+				else if (mode == "DEPENDS")
+				{
+					m.deps.push_back(t.text);
+				}
+			}
+			return m;
+		}
+
+		void scanDirectory(const sfs::path& container, ModuleKind category,
+						   std::vector<Module>& out, bool skipContainers)
+		{
+			std::error_code ec;
+			if (!sfs::is_directory(container, ec))
+				return;
+			std::vector<sfs::path> dirs;
+			for (const sfs::directory_entry& e : sfs::directory_iterator(container, ec))
+			{
+				if (!e.is_directory())
+					continue;
+				std::string name = e.path().filename().string();
+				if (skipContainers && (name == "tests" || name == "examples") &&
+					!sfs::exists(e.path() / "CMakeLists.txt"))
+					continue;
+				if (sfs::is_regular_file(e.path() / "CMakeLists.txt", ec))
+					dirs.push_back(e.path());
+			}
+			std::sort(dirs.begin(), dirs.end());
+			for (const sfs::path& dir : dirs)
+			{
+				std::optional<std::string> text = fs::tryReadText(dir / "CMakeLists.txt");
+				if (!text)
+					continue;
+				for (const cmake::Call& call : cmake::findCalls(*text, isModuleCall))
+				{
+					if (call.args.empty())
+						continue;
+					out.push_back(toModule(call, dir, category));
+				}
+			}
+		}
+
+		sfs::path moduleDirectory(const Project& project, ModuleKind kind, const std::string& name)
+		{
+			sfs::path source = project.root / "source";
+			if (kind == ModuleKind::Test)
+				return source / "tests" / name;
+			if (kind == ModuleKind::Example)
+				return source / "examples" / name;
+			return source / name;
+		}
+
+		// <name in snake case> plus the kind's suffix, unless the name already ends that way
+		// (a module called UtilTest is util_test, not util_test_test).
+		std::string defaultId(ModuleKind kind, const std::string& name)
+		{
+			std::string base = text::snakeCase(name);
+			std::string suffix = "_" + kindName(kind);
+			if (kind == ModuleKind::Exec)
+				suffix = "_exe";
+			return text::endsWith(base, suffix) ? base : base + suffix;
+		}
+
+		std::string applyTemplate(std::string t, const std::string& name, const std::string& snake)
+		{
+			t = text::replaceAll(std::move(t), "@NAME@", name);
+			t = text::replaceAll(std::move(t), "@SNAKE@", snake);
+			return t;
+		}
+
+		const char* const MainCpp = R"(#include <iostream>
+
+int main()
+{
+	std::cout << "Hello from @NAME@\n";
+	return 0;
+}
+)";
+
+		const char* const LibHeader = R"(#pragma once
+
+#include <string>
+
+namespace @SNAKE@
+{
+
+	/// A placeholder: replace it with the module's real interface.
+	std::string describe();
+
+}
+)";
+
+		const char* const LibSource = R"(#include "@SNAKE@/@NAME@.hpp"
+
+namespace @SNAKE@
+{
+
+	std::string describe()
+	{
+		return "@NAME@";
+	}
+
+}
+)";
+
+		const char* const TestMain =
+			R"(// A test is an executable that exits with 0 when everything holds; ctest runs it.
+int main()
+{
+	return 0;
+}
+)";
+	}
+
+	std::vector<Module> scanModules(const Project& project)
+	{
+		std::vector<Module> modules;
+		sfs::path source = project.root / "source";
+		scanDirectory(source, ModuleKind::Exec, modules, true);
+		scanDirectory(source / "tests", ModuleKind::Test, modules, false);
+		scanDirectory(source / "examples", ModuleKind::Example, modules, false);
+		return modules;
+	}
+
+	const Module* findModule(const std::vector<Module>& modules, const std::string& idOrDir)
+	{
+		for (const Module& m : modules)
+		{
+			if (m.id == idOrDir)
+				return &m;
+		}
+		for (const Module& m : modules)
+		{
+			if (m.dirName == idOrDir)
+				return &m;
+		}
+		// A directory name typed in another case, when only one module could mean it.
+		const Module* found = nullptr;
+		for (const Module& m : modules)
+		{
+			if (text::lower(m.dirName) == text::lower(idOrDir))
+			{
+				if (found != nullptr)
+					return nullptr;
+				found = &m;
+			}
+		}
+		return found;
+	}
+
+	namespace
+	{
+		const Module& require(const std::vector<Module>& modules, const std::string& idOrDir)
+		{
+			if (const Module* m = findModule(modules, idOrDir))
+				return *m;
+			throw Error("there is no module '" + idOrDir + "' (see `breeze ls`)");
+		}
+	}
+
+	Module addModule(const Project& project, const NewModule& request)
+	{
+		if (!text::isName(request.name))
+			throw Error("'" + request.name +
+						"' is not a valid module name: it starts with a letter and has only "
+						"letters, digits and '_' (it becomes a directory and a C++ namespace)");
+		if (request.kind == ModuleKind::Obj && !project.sdk.supportsObjects)
+			throw Error("this project's SDK (" + project.sdk.describe() +
+						") has no objects modules. Move to an SDK that "
+						"has them with " +
+						(project.sdk.layout == SdkLayout::Legacy ? "`breeze sdk migrate <version>`"
+																 : "`breeze sdk upgrade`"));
+		if (request.kind == ModuleKind::Lib && request.libType == LibType::Unspecified)
+			throw Error("a library is either --static or --shared; say which");
+
+		std::string id = request.id ? *request.id : defaultId(request.kind, request.name);
+		if (!text::isTargetId(id))
+			throw Error("'" + id +
+						"' is not a valid module id (letters, digits, '_', '.', '+', '-')");
+
+		std::vector<Module> existing = scanModules(project);
+		for (const Module& m : existing)
+		{
+			if (m.id == id)
+				throw Error("the id '" + id + "' is already taken by the module in source/" +
+							m.dirName + (m.kind == ModuleKind::Test ? " (tests)" : ""));
+		}
+
+		sfs::path dir = moduleDirectory(project, request.kind, request.name);
+		if (sfs::exists(dir))
+			throw Error("'" + fs::generic(sfs::relative(dir, project.root)) + "' already exists");
+
+		std::vector<std::string> deps;
+		for (const std::string& d : request.deps)
+		{
+			if (d == id || d == request.name)
+				throw Error("a module can't depend on itself ('" + d + "')");
+			const Module* dep = findModule(existing, d);
+			if (dep != nullptr)
+			{
+				if (dep->kind == ModuleKind::Exec || dep->kind == ModuleKind::Test ||
+					dep->kind == ModuleKind::Example)
+					throw Error("'" + d + "' is " +
+								(dep->kind == ModuleKind::Exec || dep->kind == ModuleKind::Example
+									 ? "an "
+									 : "a ") +
+								kindName(dep->kind) +
+								" module: only libraries and objects modules can be depended on");
+				deps.push_back(dep->id);
+			}
+			else if (text::isTargetId(d))
+			{
+				deps.push_back(d); // a target from elsewhere: a dependency, a system library
+			}
+			else
+			{
+				throw Error("'" + d + "' is not a module of this project or a valid target name");
+			}
+		}
+
+		std::string snake = text::snakeCase(request.name);
+		std::string call;
+		switch (request.kind)
+		{
+			case ModuleKind::Exec:
+				call = "add_exe_module(" + id + " OUTPUT_NAME " + cmake::quote(snake);
+				break;
+			case ModuleKind::Lib:
+				call = "add_lib_module(" + id + " TYPE " +
+					   (request.libType == LibType::Shared ? "SHARED" : "STATIC") +
+					   " OUTPUT_NAME " + cmake::quote(snake);
+				break;
+			case ModuleKind::Obj:
+				call = "add_objects_module(" + id + " OUTPUT_NAME " + cmake::quote(snake);
+				break;
+			case ModuleKind::Test:
+				call = "add_test_module(" + id;
+				break;
+			case ModuleKind::Example:
+				call = "add_example_module(" + id;
+				break;
+		}
+		if (!deps.empty())
+			call += " DEPENDS " + text::join(deps, " ");
+		call += ")\n";
+
+		const char* comment = nullptr;
+		switch (request.kind)
+		{
+			case ModuleKind::Exec:
+				comment = "# An executable: every .cpp in this directory, headers in include/.\n";
+				break;
+			case ModuleKind::Lib:
+				comment = "# A library: sources in src/, public headers in include/.\n";
+				break;
+			case ModuleKind::Obj:
+				comment = "# An objects module: compiled to object files that whatever names it in "
+						  "DEPENDS takes in.\n";
+				break;
+			case ModuleKind::Test:
+				comment = "# A test: an executable ctest runs (built with BUILD_TESTS=ON).\n";
+				break;
+			case ModuleKind::Example:
+				comment = "# An example: an executable (built with BUILD_EXAMPLES=ON).\n";
+				break;
+		}
+
+		fs::writeText(dir / "CMakeLists.txt", std::string(comment) + call);
+		if (request.kind == ModuleKind::Lib || request.kind == ModuleKind::Obj)
+		{
+			fs::writeText(dir / "include" / snake / (request.name + ".hpp"),
+						  applyTemplate(LibHeader, request.name, snake));
+			fs::writeText(dir / "src" / (request.name + ".cpp"),
+						  applyTemplate(LibSource, request.name, snake));
+		}
+		else if (request.kind == ModuleKind::Test)
+		{
+			fs::writeText(dir / "main.cpp", TestMain);
+		}
+		else
+		{
+			fs::writeText(dir / "main.cpp", applyTemplate(MainCpp, request.name, snake));
+		}
+
+		std::vector<Module> now = scanModules(project);
+		const Module* created = findModule(now, id);
+		if (created == nullptr)
+			throw Error("internal error: the new module '" + id +
+						"' was not found after writing it");
+		return *created;
+	}
+
+	std::vector<std::string> dependentsOf(const std::vector<Module>& modules, const Module& module,
+										  bool recursive)
+	{
+		std::vector<std::string> out;
+		std::set<std::string> seen;
+		std::vector<std::string> queue{module.id};
+		while (!queue.empty())
+		{
+			std::string current = queue.front();
+			queue.erase(queue.begin());
+			for (const Module& m : modules)
+			{
+				if (std::find(m.deps.begin(), m.deps.end(), current) == m.deps.end())
+					continue;
+				if (seen.insert(m.id).second)
+				{
+					out.push_back(m.id);
+					if (recursive)
+						queue.push_back(m.id);
+				}
+			}
+			if (!recursive)
+				break;
+		}
+		return out;
+	}
+
+	std::vector<std::string> dependenciesOf(const std::vector<Module>& modules,
+											const Module& module, bool recursive)
+	{
+		std::vector<std::string> out;
+		std::set<std::string> seen{module.id};
+		std::vector<std::string> queue{module.id};
+		while (!queue.empty())
+		{
+			std::string current = queue.front();
+			queue.erase(queue.begin());
+			const Module* m = findModule(modules, current);
+			if (m == nullptr)
+				continue;
+			for (const std::string& d : m->deps)
+			{
+				if (seen.insert(d).second)
+				{
+					out.push_back(d);
+					if (recursive)
+						queue.push_back(d);
+				}
+			}
+			if (!recursive)
+				break;
+		}
+		return out;
+	}
+
+	void deleteModule(const Project& project, const std::string& idOrDir)
+	{
+		std::vector<Module> modules = scanModules(project);
+		const Module& m = require(modules, idOrDir);
+		std::vector<std::string> users = dependentsOf(modules, m, false);
+		if (!users.empty())
+			throw Error("'" + m.id + "' can't be deleted: " + text::join(users, ", ") +
+						(users.size() == 1 ? " depends" : " depend") + " on it");
+		fs::removeTree(m.dir);
+	}
+
+	namespace
+	{
+		struct Edit
+		{
+			cmake::Token token;
+			std::string value;
+		};
+
+		// Applies replacements from the end of the file backwards so earlier offsets stay valid.
+		void rewrite(const sfs::path& file, std::string text, std::vector<Edit> edits)
+		{
+			std::sort(edits.begin(), edits.end(),
+					  [](const Edit& a, const Edit& b) { return a.token.begin > b.token.begin; });
+			for (const Edit& e : edits)
+				cmake::replaceToken(text, e.token, e.value);
+			fs::writeText(file, text);
+		}
+	}
+
+	RenameResult renameModule(const Project& project, const std::string& idOrDir,
+							  const std::optional<std::string>& newName,
+							  const std::optional<std::string>& newId)
+	{
+		if (!newName && !newId)
+			throw Error("nothing to rename: give --name and/or --id");
+
+		std::vector<Module> modules = scanModules(project);
+		const Module& m = require(modules, idOrDir);
+
+		RenameResult result;
+		result.oldId = m.id;
+		result.newId = newId ? *newId : m.id;
+		result.oldDir = m.dirName;
+		result.newDir = newName ? *newName : m.dirName;
+
+		if (newName && !text::isName(*newName))
+			throw Error("'" + *newName + "' is not a valid module name");
+		if (newId && !text::isTargetId(*newId))
+			throw Error("'" + *newId + "' is not a valid module id");
+		if (result.newId == result.oldId && result.newDir == result.oldDir)
+			throw Error("the module already has that name and id");
+		if (result.newId != result.oldId)
+		{
+			for (const Module& other : modules)
+			{
+				if (other.id == result.newId)
+					throw Error("the id '" + result.newId + "' is already taken");
+			}
+		}
+		sfs::path newDirPath = m.dir.parent_path() / result.newDir;
+		if (result.newDir != result.oldDir && sfs::exists(newDirPath))
+			throw Error("'" + fs::generic(sfs::relative(newDirPath, project.root)) +
+						"' already exists");
+
+		// Everything is rewritten at the files' present locations first; the directory moves last.
+		std::set<sfs::path> files;
+		for (const Module& other : modules)
+			files.insert(other.dir / "CMakeLists.txt");
+
+		for (const sfs::path& file : files)
+		{
+			std::string text = fs::readText(file);
+			std::vector<Edit> edits;
+			bool isOwn = file == m.dir / "CMakeLists.txt";
+			bool touchedDependency = false;
+			for (const cmake::Call& call : cmake::findCalls(text, isModuleCall))
+			{
+				if (call.args.empty())
+					continue;
+				if (isOwn && result.newId != result.oldId && call.args.front().text == result.oldId)
+					edits.push_back({call.args.front(), result.newId});
+				std::string mode;
+				bool first = true;
+				for (const cmake::Token& t : call.args)
+				{
+					if (!t.quoted && isKeyword(t.text))
+					{
+						mode = t.text;
+						continue;
+					}
+					if (first)
+					{
+						first = false;
+						continue;
+					}
+					if (mode == "DEPENDS" && result.newId != result.oldId && t.text == result.oldId)
+					{
+						edits.push_back({t, result.newId});
+						touchedDependency = true;
+					}
+				}
+			}
+			if (edits.empty())
+				continue;
+			rewrite(file, text, std::move(edits));
+			if (touchedDependency)
+			{
+				std::string dirName = file.parent_path().filename().string();
+				if (!isOwn)
+					result.updatedDependents.push_back(dirName);
+			}
+		}
+
+		if (result.newDir != result.oldDir)
+		{
+			std::error_code ec;
+			sfs::rename(m.dir, newDirPath, ec);
+			if (ec)
+				throw Error("cannot rename '" + fs::generic(m.dir) + "': " + ec.message());
+		}
+		return result;
+	}
+
+}
diff --git a/source/BreezeCore/src/Presets.cpp b/source/BreezeCore/src/Presets.cpp
new file mode 100644
index 0000000..aab1e9d
--- /dev/null
+++ b/source/BreezeCore/src/Presets.cpp
@@ -0,0 +1,169 @@
+#include "breeze/Presets.hpp"
+
+#include "breeze/Error.hpp"
+#include "breeze/Fs.hpp"
+#include "breeze/Process.hpp"
+#include "breeze/Text.hpp"
+
+namespace breeze
+{
+
+	namespace
+	{
+		Preset makePreset(const std::string& name, const std::string& description)
+		{
+			Preset p;
+			p.name = name;
+			p.description = description;
+			std::size_t first = name.find('-');
+			std::size_t second = first == std::string::npos ? first : name.find('-', first + 1);
+			if (second != std::string::npos)
+			{
+				p.platform = name.substr(0, first);
+				p.arch = name.substr(first + 1, second - first - 1);
+				p.compiler = name.substr(second + 1);
+			}
+			return p;
+		}
+	}
+
+	std::vector<Preset> listPresets(const Project& project)
+	{
+		std::error_code ec;
+		if (!std::filesystem::exists(project.root / "CMakePresets.json", ec) &&
+			!std::filesystem::exists(project.root / "CMakeUserPresets.json", ec))
+			return {}; // an SDK from before presets
+		proc::Options options;
+		options.cwd = project.root;
+		options.capture = true;
+		proc::Result r = proc::run({"cmake", "--list-presets"}, options);
+		if (r.exitCode != 0)
+			throw Error("`cmake --list-presets` failed in '" + fs::generic(project.root) +
+						"' -- is CMake installed, and is CMakePresets.json valid?");
+
+		std::vector<Preset> presets;
+		for (const std::string& raw : text::splitLines(r.output))
+		{
+			std::string line = text::trim(raw);
+			if (line.size() < 3 || line[0] != '"')
+				continue;
+			std::size_t close = line.find('"', 1);
+			if (close == std::string::npos)
+				continue;
+			std::string name = line.substr(1, close - 1);
+			std::string description;
+			if (std::size_t dash = line.find('-', close); dash != std::string::npos)
+				description = text::trim(line.substr(dash + 1));
+			presets.push_back(makePreset(name, description));
+		}
+		return presets;
+	}
+
+	namespace
+	{
+		bool same(const std::string& a, const std::string& b)
+		{
+			return text::normalized(a) == text::normalized(b);
+		}
+
+		std::string describeChoices(const std::vector<Preset>& presets)
+		{
+			std::string out;
+			for (const Preset& p : presets)
+				out += "  " + p.name + "\n";
+			return out;
+		}
+	}
+
+	std::optional<std::string> resolvePreset(const Project& project, const Defaults& defaults,
+											 const PresetQuery& query, std::string* note)
+	{
+		std::vector<Preset> presets = listPresets(project);
+		if (presets.empty())
+		{
+			if (query.preset || query.platform || query.arch || query.compiler)
+				throw Error("this project's SDK (" + project.sdk.describe() +
+							") has no CMake presets, so there is nothing to choose between. "
+							"Move to a newer SDK with `breeze sdk migrate <version>`");
+			return std::nullopt;
+		}
+
+		auto byName = [&](const std::string& name) -> const Preset*
+		{
+			for (const Preset& p : presets)
+			{
+				if (same(p.name, name))
+					return &p;
+			}
+			return nullptr;
+		};
+
+		if (query.preset)
+		{
+			if (const Preset* p = byName(*query.preset))
+				return p->name;
+			throw Error("'" + *query.preset +
+						"' is not a preset this project has for this machine. "
+						"Choose one of:\n" +
+						describeChoices(presets));
+		}
+
+		bool anyGiven = query.platform || query.arch || query.compiler;
+		std::optional<std::string> dPlatform = defaults.build("platform");
+		std::optional<std::string> dArch = defaults.build("arch");
+		std::optional<std::string> dCompiler = defaults.build("compiler");
+
+		if (!anyGiven)
+		{
+			if (std::optional<std::string> dp = defaults.build("preset"))
+			{
+				if (const Preset* p = byName(*dp))
+					return p->name;
+				throw Error(
+					"the project's default preset '" + *dp +
+					"' does not exist for this machine. "
+					"Choose another with `breeze defaults build preset --set <name>`, from:\n" +
+					describeChoices(presets));
+			}
+			if (!dPlatform && !dArch && !dCompiler)
+				return std::nullopt;
+		}
+
+		std::string platform = query.platform ? *query.platform
+							   : dPlatform	  ? *dPlatform
+											  : fs::hostPlatform();
+		std::string arch = query.arch ? *query.arch : dArch ? *dArch : fs::hostArch();
+		std::optional<std::string> compiler = query.compiler ? query.compiler : dCompiler;
+
+		std::vector<Preset> matches;
+		for (const Preset& p : presets)
+		{
+			if (same(p.platform, platform) && same(p.arch, arch) &&
+				(!compiler || same(p.compiler, *compiler)))
+				matches.push_back(p);
+		}
+		if (matches.empty())
+		{
+			std::vector<Preset> sameTarget;
+			for (const Preset& p : presets)
+			{
+				if (same(p.platform, platform) && same(p.arch, arch))
+					sameTarget.push_back(p);
+			}
+			throw Error("this project has no preset for " + platform + "-" + arch +
+						(compiler ? "-" + *compiler : std::string()) + " on this machine. " +
+						(sameTarget.empty() ? "Available:\n" + describeChoices(presets)
+											: "Presets for " + platform + "-" + arch + ":\n" +
+												  describeChoices(sameTarget)));
+		}
+		if (matches.size() > 1 && note != nullptr)
+		{
+			*note = "no compiler given: using '" + matches.front().name + "' (the others are: ";
+			for (std::size_t i = 1; i < matches.size(); ++i)
+				*note += (i > 1 ? ", " : "") + matches[i].name;
+			*note += "). Pick one with -C or `breeze defaults build compiler --set <name>`.";
+		}
+		return matches.front().name;
+	}
+
+}
diff --git a/source/BreezeCore/src/Process.cpp b/source/BreezeCore/src/Process.cpp
new file mode 100644
index 0000000..ea7161c
--- /dev/null
+++ b/source/BreezeCore/src/Process.cpp
@@ -0,0 +1,353 @@
+#include "breeze/Process.hpp"
+
+#include <cstdio>
+#include <cstdlib>
+
+#include <array>
+#include <iostream>
+
+#include "breeze/Error.hpp"
+#include "breeze/Fs.hpp"
+#include "breeze/Text.hpp"
+
+#if defined(_WIN32)
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+#include <io.h>
+#include <windows.h>
+#else
+#include <fcntl.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#endif
+
+namespace breeze::proc
+{
+
+#if defined(_WIN32)
+
+	namespace
+	{
+		std::wstring widen(const std::string& s)
+		{
+			if (s.empty())
+				return {};
+			int n =
+				MultiByteToWideChar(CP_UTF8, 0, s.data(), static_cast<int>(s.size()), nullptr, 0);
+			std::wstring w(static_cast<std::size_t>(n), L'\0');
+			MultiByteToWideChar(CP_UTF8, 0, s.data(), static_cast<int>(s.size()), w.data(), n);
+			return w;
+		}
+
+		// The Microsoft C runtime's rules for one argument: quote when it has spaces or quotes,
+		// double the backslashes that precede a quote.
+		std::wstring quoteArg(const std::string& arg)
+		{
+			std::wstring w = widen(arg);
+			if (!w.empty() && w.find_first_of(L" \t\n\v\"") == std::wstring::npos)
+				return w;
+			std::wstring out = L"\"";
+			std::size_t backslashes = 0;
+			for (wchar_t c : w)
+			{
+				if (c == L'\\')
+				{
+					++backslashes;
+					continue;
+				}
+				if (c == L'"')
+					out.append(backslashes * 2 + 1, L'\\');
+				else
+					out.append(backslashes, L'\\');
+				backslashes = 0;
+				out += c;
+			}
+			out.append(backslashes * 2, L'\\');
+			out += L'"';
+			return out;
+		}
+
+		Result runCommandLine(std::wstring commandLine, const Options& options)
+		{
+			std::vector<std::pair<std::wstring, std::wstring>> saved;
+			for (const auto& [key, value] : options.env)
+			{
+				std::wstring wk = widen(key);
+				wchar_t previous[32768];
+				DWORD n = GetEnvironmentVariableW(wk.c_str(), previous, 32768);
+				saved.emplace_back(wk,
+								   n > 0 ? std::wstring(previous, n) : std::wstring(L"\x01unset"));
+				SetEnvironmentVariableW(wk.c_str(), widen(value).c_str());
+			}
+
+			SECURITY_ATTRIBUTES sa{sizeof(sa), nullptr, TRUE};
+			HANDLE readEnd = nullptr;
+			HANDLE writeEnd = nullptr;
+			if (options.capture)
+			{
+				CreatePipe(&readEnd, &writeEnd, &sa, 0);
+				SetHandleInformation(readEnd, HANDLE_FLAG_INHERIT, 0);
+			}
+			HANDLE nul = nullptr;
+			if (options.silent)
+				nul = CreateFileW(L"NUL", GENERIC_WRITE, FILE_SHARE_WRITE, &sa, OPEN_EXISTING, 0,
+								  nullptr);
+
+			STARTUPINFOW si{};
+			si.cb = sizeof(si);
+			si.dwFlags = STARTF_USESTDHANDLES;
+			si.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
+			si.hStdOutput = options.capture
+								? writeEnd
+								: (options.silent ? nul : GetStdHandle(STD_OUTPUT_HANDLE));
+			si.hStdError = options.capture && options.mergeStderr
+							   ? writeEnd
+							   : (options.silent ? nul : GetStdHandle(STD_ERROR_HANDLE));
+			PROCESS_INFORMATION pi{};
+			std::wstring cwd = options.cwd.empty() ? std::wstring() : options.cwd.wstring();
+			BOOL ok = CreateProcessW(nullptr, commandLine.data(), nullptr, nullptr, TRUE, 0,
+									 nullptr, cwd.empty() ? nullptr : cwd.c_str(), &si, &pi);
+			if (writeEnd)
+				CloseHandle(writeEnd);
+			if (nul)
+				CloseHandle(nul);
+
+			Result result;
+			if (!ok)
+			{
+				if (readEnd)
+					CloseHandle(readEnd);
+				result.exitCode = 127;
+			}
+			else
+			{
+				if (readEnd)
+				{
+					std::array<char, 4096> buffer{};
+					DWORD got = 0;
+					while (ReadFile(readEnd, buffer.data(), static_cast<DWORD>(buffer.size()), &got,
+									nullptr) &&
+						   got > 0)
+						result.output.append(buffer.data(), got);
+					CloseHandle(readEnd);
+				}
+				WaitForSingleObject(pi.hProcess, INFINITE);
+				DWORD code = 0;
+				GetExitCodeProcess(pi.hProcess, &code);
+				result.exitCode = static_cast<int>(code);
+				CloseHandle(pi.hProcess);
+				CloseHandle(pi.hThread);
+			}
+
+			for (const auto& [key, value] : saved)
+				SetEnvironmentVariableW(key.c_str(),
+										value == L"\x01unset" ? nullptr : value.c_str());
+			return result;
+		}
+	}
+
+	Result run(const std::vector<std::string>& argv, const Options& options)
+	{
+		if (argv.empty())
+			throw Error("internal error: nothing to run");
+		std::wstring line;
+		for (std::size_t i = 0; i < argv.size(); ++i)
+		{
+			if (i != 0)
+				line += L' ';
+			line += quoteArg(argv[i]);
+		}
+		return runCommandLine(std::move(line), options);
+	}
+
+	Result runScript(const std::filesystem::path& script, const std::vector<std::string>& args,
+					 const Options& options)
+	{
+		// cmd.exe strips the outer quotes of what follows /c, so the whole command is wrapped once
+		// more.
+		std::wstring inner = quoteArg(script.string());
+		for (const std::string& a : args)
+			inner += L' ' + quoteArg(a);
+		return runCommandLine(L"cmd.exe /d /s /c \"" + inner + L"\"", options);
+	}
+
+	void execReplace(const std::vector<std::string>& argv)
+	{
+		Result r = run(argv);
+		if (r.exitCode == 127)
+			throw Error("cannot start '" + argv.front() + "'");
+		std::exit(r.exitCode);
+	}
+
+	std::optional<std::filesystem::path> findInPath(const std::string& program)
+	{
+		const char* pathEnv = std::getenv("PATH");
+		if (pathEnv == nullptr)
+			return std::nullopt;
+		static const std::vector<std::string> extensions = {"", ".exe", ".bat", ".cmd", ".com"};
+		for (const std::string& dir : text::split(pathEnv, ';'))
+		{
+			for (const std::string& ext : extensions)
+			{
+				std::filesystem::path candidate = std::filesystem::path(dir) / (program + ext);
+				if (std::filesystem::is_regular_file(candidate))
+					return candidate;
+			}
+		}
+		return std::nullopt;
+	}
+
+	void setEnvironment(const std::string& name, const std::string& value)
+	{
+		_putenv_s(name.c_str(), value.c_str());
+	}
+
+	bool stdinIsTerminal()
+	{
+		return _isatty(_fileno(stdin)) != 0;
+	}
+
+	bool stdoutIsTerminal()
+	{
+		return _isatty(_fileno(stdout)) != 0;
+	}
+
+#else
+
+	Result run(const std::vector<std::string>& argv, const Options& options)
+	{
+		if (argv.empty())
+			throw Error("internal error: nothing to run");
+
+		std::cout.flush();
+		std::cerr.flush();
+		std::fflush(nullptr);
+
+		std::array<int, 2> pipeFds = {-1, -1};
+		if (options.capture && ::pipe(pipeFds.data()) != 0)
+			throw Error("cannot create a pipe");
+
+		pid_t pid = ::fork();
+		if (pid < 0)
+			throw Error("cannot create a process");
+
+		if (pid == 0)
+		{
+			if (!options.cwd.empty() && ::chdir(options.cwd.c_str()) != 0)
+			{
+				std::fprintf(stderr, "breeze: cannot enter '%s'\n", options.cwd.c_str());
+				::_exit(127);
+			}
+			for (const auto& [key, value] : options.env)
+				::setenv(key.c_str(), value.c_str(), 1);
+			if (options.capture)
+			{
+				::dup2(pipeFds[1], STDOUT_FILENO);
+				if (options.mergeStderr)
+					::dup2(pipeFds[1], STDERR_FILENO);
+				::close(pipeFds[0]);
+				::close(pipeFds[1]);
+			}
+			else if (options.silent)
+			{
+				int nul = ::open("/dev/null", O_WRONLY);
+				::dup2(nul, STDOUT_FILENO);
+				::dup2(nul, STDERR_FILENO);
+				::close(nul);
+			}
+			std::vector<char*> args;
+			for (const std::string& a : argv)
+				args.push_back(const_cast<char*>(a.c_str()));
+			args.push_back(nullptr);
+			::execvp(args[0], args.data());
+			std::fprintf(stderr, "breeze: cannot run '%s'\n", args[0]);
+			::_exit(127);
+		}
+
+		Result result;
+		if (options.capture)
+		{
+			::close(pipeFds[1]);
+			std::array<char, 4096> buffer{};
+			ssize_t got = 0;
+			while ((got = ::read(pipeFds[0], buffer.data(), buffer.size())) > 0)
+				result.output.append(buffer.data(), static_cast<std::size_t>(got));
+			::close(pipeFds[0]);
+		}
+		int status = 0;
+		while (::waitpid(pid, &status, 0) < 0)
+		{
+			if (errno != EINTR)
+				throw Error("cannot wait for '" + argv.front() + "'");
+		}
+		if (WIFEXITED(status))
+			result.exitCode = WEXITSTATUS(status);
+		else if (WIFSIGNALED(status))
+			result.exitCode = 128 + WTERMSIG(status);
+		return result;
+	}
+
+	Result runScript(const std::filesystem::path& script, const std::vector<std::string>& args,
+					 const Options& options)
+	{
+		std::vector<std::string> argv;
+		// A project unpacked from a zip often has scripts that lost their executable bit; the SDK's
+		// scripts are bash, so that is how they are run then.
+		if (!fs::isExecutable(script))
+			argv.push_back("bash");
+		argv.push_back(script.string());
+		argv.insert(argv.end(), args.begin(), args.end());
+		return run(argv, options);
+	}
+
+	void execReplace(const std::vector<std::string>& argv)
+	{
+		if (argv.empty())
+			throw Error("internal error: nothing to run");
+		std::cout.flush();
+		std::cerr.flush();
+		std::vector<char*> args;
+		for (const std::string& a : argv)
+			args.push_back(const_cast<char*>(a.c_str()));
+		args.push_back(nullptr);
+		::execv(args[0], args.data());
+		throw Error("cannot start '" + argv.front() + "'");
+	}
+
+	std::optional<std::filesystem::path> findInPath(const std::string& program)
+	{
+		if (program.find('/') != std::string::npos)
+			return fs::isExecutable(program) ? std::optional<std::filesystem::path>(program)
+											 : std::nullopt;
+		const char* pathEnv = std::getenv("PATH");
+		if (pathEnv == nullptr)
+			return std::nullopt;
+		for (const std::string& dir : text::split(pathEnv, ':'))
+		{
+			std::filesystem::path candidate =
+				(dir.empty() ? std::filesystem::path(".") : std::filesystem::path(dir)) / program;
+			if (fs::isExecutable(candidate))
+				return candidate;
+		}
+		return std::nullopt;
+	}
+
+	void setEnvironment(const std::string& name, const std::string& value)
+	{
+		::setenv(name.c_str(), value.c_str(), 1);
+	}
+
+	bool stdinIsTerminal()
+	{
+		return ::isatty(STDIN_FILENO) != 0;
+	}
+
+	bool stdoutIsTerminal()
+	{
+		return ::isatty(STDOUT_FILENO) != 0;
+	}
+
+#endif
+
+}
diff --git a/source/BreezeCore/src/Project.cpp b/source/BreezeCore/src/Project.cpp
new file mode 100644
index 0000000..80d718e
--- /dev/null
+++ b/source/BreezeCore/src/Project.cpp
@@ -0,0 +1,338 @@
+#include "breeze/Project.hpp"
+
+#include <algorithm>
+
+#include "breeze/CMakeText.hpp"
+#include "breeze/Error.hpp"
+#include "breeze/Fs.hpp"
+#include "breeze/Text.hpp"
+
+namespace breeze
+{
+
+	namespace sfs = std::filesystem;
+
+	std::string Sdk::describe() const
+	{
+		if (layout == SdkLayout::Legacy)
+			return "legacy (flat layout, unversioned)";
+		if (version)
+			return version->toString();
+		return "unversioned (breeze/ layout)";
+	}
+
+	sfs::path Project::metaDir() const
+	{
+		return root / ".breeze";
+	}
+
+	sfs::path Project::defaultsFile() const
+	{
+		return metaDir() / "defaults.json";
+	}
+
+	sfs::path Project::toolsDir() const
+	{
+		return metaDir() / "tools";
+	}
+
+	sfs::path Project::script(const std::string& name) const
+	{
+		return sdk.scriptsDir / (name + (fs::hostPlatform() == "windows" ? ".bat" : ".sh"));
+	}
+
+	std::optional<Sdk> detectSdk(const sfs::path& root)
+	{
+		std::error_code ec;
+		if (!sfs::is_regular_file(root / "CMakeLists.txt", ec))
+			return std::nullopt;
+
+		Sdk sdk;
+		if (sfs::is_regular_file(root / "breeze" / "cmake" / "Breeze.cmake", ec) &&
+			sfs::is_regular_file(root / "project" / "Configuration.cmake", ec))
+		{
+			sdk.layout = SdkLayout::Breeze;
+			sdk.dir = root / "breeze";
+			sdk.scriptsDir = sdk.dir / "scripts";
+			sdk.cmakeDir = sdk.dir / "cmake";
+			sdk.settingsFile = root / "project" / "Configuration.cmake";
+			if (std::optional<std::string> v = fs::tryReadText(sdk.dir / "VERSION"))
+				sdk.version = parseVersion(*v);
+		}
+		else if (sfs::is_regular_file(root / "Configuration.cmake", ec) &&
+				 sfs::is_regular_file(root / "cmake" / "BuildHelpers.cmake", ec))
+		{
+			sdk.layout = SdkLayout::Legacy;
+			sdk.dir = root;
+			sdk.scriptsDir = root / "scripts";
+			sdk.cmakeDir = root / "cmake";
+			sdk.settingsFile = root / "Configuration.cmake";
+		}
+		else
+		{
+			return std::nullopt;
+		}
+
+		if (std::optional<std::string> helpers =
+				fs::tryReadText(sdk.cmakeDir / "BuildHelpers.cmake"))
+			sdk.supportsObjects = helpers->find("macro(add_objects_module") != std::string::npos;
+		return sdk;
+	}
+
+	std::optional<Project> findProject(const sfs::path& start)
+	{
+		std::error_code ec;
+		sfs::path dir = sfs::weakly_canonical(start, ec);
+		if (ec)
+			dir = start;
+		while (true)
+		{
+			if (std::optional<Sdk> sdk = detectSdk(dir))
+				return Project{dir, *sdk};
+			if (!dir.has_parent_path() || dir.parent_path() == dir)
+				return std::nullopt;
+			dir = dir.parent_path();
+		}
+	}
+
+	Project requireProject(const sfs::path& start)
+	{
+		if (std::optional<Project> p = findProject(start))
+			return *p;
+		throw Error(
+			"this is not inside a breeze project (no CMakeLists.txt with a breeze SDK found in '" +
+			fs::generic(start) + "' or above). Create one with: breeze project new <name>");
+	}
+
+	namespace
+	{
+		const char* variableOf(Setting which)
+		{
+			switch (which)
+			{
+				case Setting::Name:
+					return "PROJECT_TITLE";
+				case Setting::Version:
+					return "PROJECT_VERSION_NUMBER";
+				case Setting::Id:
+					return "PROJECT_CODE_NAME";
+			}
+			return "";
+		}
+
+		bool isCmakeVersion(const std::string& v)
+		{
+			std::vector<std::string> parts = text::split(v, '.');
+			if (parts.empty() || parts.size() > 4)
+				return false;
+			return std::all_of(parts.begin(), parts.end(),
+							   [](const std::string& p)
+							   {
+								   return !p.empty() &&
+										  std::all_of(p.begin(), p.end(),
+													  [](char c) { return c >= '0' && c <= '9'; });
+							   });
+		}
+
+		void validate(Setting which, const std::string& value)
+		{
+			switch (which)
+			{
+				case Setting::Name:
+					if (!text::isName(value, true))
+						throw Error(
+							"'" + value +
+							"' is not a valid project name: it starts with a letter and has "
+							"only letters, digits, '_' and '-'");
+					break;
+				case Setting::Version:
+					if (!isCmakeVersion(value))
+						throw Error("'" + value +
+									"' is not a valid project version: use numbers separated by "
+									"dots, like 1.2.0 (CMake's project(VERSION))");
+					break;
+				case Setting::Id:
+					if (!text::isName(value) || std::any_of(value.begin(), value.end(), [](char c)
+															{ return c >= 'A' && c <= 'Z'; }))
+						throw Error(
+							"'" + value +
+							"' is not a valid project id: lower-case letters, digits and '_', "
+							"starting with a letter");
+					break;
+			}
+		}
+
+		// Where a setting is set: the settings file, except in older legacy projects that kept the
+		// id in CMakeLists.txt.
+		sfs::path settingFile(const Project& project, Setting which)
+		{
+			std::optional<std::string> text = fs::tryReadText(project.sdk.settingsFile);
+			if (text && cmake::findSet(*text, variableOf(which)))
+				return project.sdk.settingsFile;
+			if (project.sdk.layout == SdkLayout::Legacy)
+			{
+				std::optional<std::string> cmakeLists =
+					fs::tryReadText(project.root / "CMakeLists.txt");
+				if (cmakeLists && cmake::findSet(*cmakeLists, variableOf(which)))
+					return project.root / "CMakeLists.txt";
+			}
+			return project.sdk.settingsFile;
+		}
+
+		// The name and the version of a legacy project live in the project() call of
+		// CMakeLists.txt.
+		struct LegacyProjectCall
+		{
+			cmake::Call call;
+			std::string text;
+		};
+
+		LegacyProjectCall legacyProjectCall(const Project& p)
+		{
+			std::string text = fs::readText(p.root / "CMakeLists.txt");
+			std::vector<cmake::Call> calls = cmake::findCalls(
+				text, [](const std::string& n) { return text::lower(n) == "project"; });
+			if (calls.empty() || calls.front().args.empty())
+				throw Error("CMakeLists.txt has no project() call to read the project's name and "
+							"version from");
+			return {calls.front(), std::move(text)};
+		}
+
+		std::size_t versionArgIndex(const cmake::Call& call)
+		{
+			for (std::size_t i = 0; i + 1 < call.args.size(); ++i)
+			{
+				if (call.args[i].text == "VERSION")
+					return i + 1;
+			}
+			return call.args.size();
+		}
+	}
+
+	std::string readSetting(const Project& project, Setting which)
+	{
+		if (project.sdk.layout == SdkLayout::Legacy && which != Setting::Id)
+		{
+			LegacyProjectCall lp = legacyProjectCall(project);
+			if (which == Setting::Name)
+				return lp.call.args[0].text;
+			std::size_t idx = versionArgIndex(lp.call);
+			if (idx >= lp.call.args.size())
+				throw Error("the project() call in CMakeLists.txt has no VERSION");
+			return lp.call.args[idx].text;
+		}
+
+		sfs::path file = settingFile(project, which);
+		std::string text = fs::readText(file);
+		std::optional<cmake::Call> set = cmake::findSet(text, variableOf(which));
+		if (!set || set->args.size() < 2)
+			throw Error(std::string("'") + fs::generic(file) + "' does not set " +
+						variableOf(which));
+		return set->args[1].text;
+	}
+
+	void writeSetting(const Project& project, Setting which, const std::string& value)
+	{
+		validate(which, value);
+
+		if (project.sdk.layout == SdkLayout::Legacy && which != Setting::Id)
+		{
+			LegacyProjectCall lp = legacyProjectCall(project);
+			const cmake::Token* token = nullptr;
+			if (which == Setting::Name)
+			{
+				token = &lp.call.args[0];
+			}
+			else
+			{
+				std::size_t idx = versionArgIndex(lp.call);
+				if (idx >= lp.call.args.size())
+					throw Error("the project() call in CMakeLists.txt has no VERSION to change");
+				token = &lp.call.args[idx];
+			}
+			std::string text = lp.text;
+			cmake::replaceToken(text, *token, value);
+			fs::writeText(project.root / "CMakeLists.txt", text);
+			return;
+		}
+
+		sfs::path file = settingFile(project, which);
+		std::string text = fs::readText(file);
+		std::optional<cmake::Call> set = cmake::findSet(text, variableOf(which));
+		if (!set || set->args.size() < 2)
+			throw Error(std::string("'") + fs::generic(file) + "' does not set " +
+						variableOf(which));
+		cmake::replaceToken(text, set->args[1], cmake::quote(value));
+		fs::writeText(file, text);
+	}
+
+	Defaults Defaults::load(const Project& project)
+	{
+		Defaults d;
+		if (std::optional<std::string> text = fs::tryReadText(project.defaultsFile()))
+		{
+			nlohmann::json parsed = nlohmann::json::parse(*text, nullptr, false);
+			if (parsed.is_discarded() || !parsed.is_object())
+				throw Error("'" + fs::generic(project.defaultsFile()) +
+							"' is not valid JSON; fix or delete it");
+			d.m_data = std::move(parsed);
+		}
+		return d;
+	}
+
+	std::optional<std::string> Defaults::build(const std::string& key) const
+	{
+		auto b = m_data.find("build");
+		if (b == m_data.end() || !b->is_object())
+			return std::nullopt;
+		auto it = b->find(key);
+		if (it == b->end() || !it->is_string())
+			return std::nullopt;
+		return it->get<std::string>();
+	}
+
+	void Defaults::setBuild(const std::string& key, const std::string& value)
+	{
+		m_data["build"][key] = value;
+	}
+
+	void Defaults::clearBuild(const std::string& key)
+	{
+		if (m_data.contains("build"))
+		{
+			m_data["build"].erase(key);
+			if (m_data["build"].empty())
+				m_data.erase("build");
+		}
+	}
+
+	std::optional<std::string> Defaults::run() const
+	{
+		auto it = m_data.find("run");
+		if (it == m_data.end() || !it->is_string())
+			return std::nullopt;
+		return it->get<std::string>();
+	}
+
+	void Defaults::setRun(const std::string& id)
+	{
+		m_data["run"] = id;
+	}
+
+	void Defaults::clearRun()
+	{
+		m_data.erase("run");
+	}
+
+	void Defaults::save(const Project& project) const
+	{
+		if (m_data.empty())
+		{
+			std::error_code ec;
+			sfs::remove(project.defaultsFile(), ec);
+			return;
+		}
+		fs::writeText(project.defaultsFile(), m_data.dump(2) + "\n");
+	}
+
+}
diff --git a/source/BreezeCore/src/Sdks.cpp b/source/BreezeCore/src/Sdks.cpp
new file mode 100644
index 0000000..df9d8d6
--- /dev/null
+++ b/source/BreezeCore/src/Sdks.cpp
@@ -0,0 +1,616 @@
+#include "breeze/Sdks.hpp"
+
+#include <cstdint>
+
+#include <algorithm>
+#include <array>
+#include <iostream>
+#include <sstream>
+
+#include "breeze/CMakeText.hpp"
+#include "breeze/Config.hpp"
+#include "breeze/Error.hpp"
+#include "breeze/Fs.hpp"
+#include "breeze/Git.hpp"
+#include "breeze/Modules.hpp"
+#include "breeze/Process.hpp"
+#include "breeze/Text.hpp"
+
+namespace breeze::sdk
+{
+
+	namespace sfs = std::filesystem;
+
+	namespace
+	{
+		// What a snapshot never hands to a project.
+		const std::vector<std::string> Skip = {".git", "out", ".cache", "compile_commands.json"};
+
+		// Root files the tools look for there, so they stay at the root and belong to the project.
+		const std::array<const char*, 4> DotFiles = {".clang-format", ".clang-tidy",
+													 ".editorconfig", ".gitattributes"};
+
+		std::string hashOf(const std::string& s)
+		{
+			std::uint64_t h = 1469598103934665603ULL; // FNV-1a
+			for (unsigned char c : s)
+			{
+				h ^= c;
+				h *= 1099511628211ULL;
+			}
+			std::ostringstream out;
+			out << std::hex << h;
+			return out.str();
+		}
+
+		bool isBreezeSnapshot(const sfs::path& snap)
+		{
+			std::error_code ec;
+			return sfs::is_regular_file(snap / "breeze" / "cmake" / "Breeze.cmake", ec) &&
+				   sfs::is_regular_file(snap / "project" / "Configuration.cmake", ec) &&
+				   sfs::is_regular_file(snap / "CMakeLists.txt", ec);
+		}
+
+		const Source::Entry* findEntry(const std::vector<Source::Entry>& all, const Version& v)
+		{
+			for (const Source::Entry& e : all)
+			{
+				if (e.version == v)
+					return &e;
+			}
+			return nullptr;
+		}
+
+		// The newest release (a pre-release only when there is no release), optionally of one major
+		// version.
+		const Source::Entry* newest(const std::vector<Source::Entry>& all, std::optional<int> major)
+		{
+			const Source::Entry* best = nullptr;
+			for (int pass = 0; pass < 2 && best == nullptr; ++pass)
+			{
+				for (const Source::Entry& e : all)
+				{
+					if (major && e.version.major != *major)
+						continue;
+					if (pass == 0 && !e.version.pre.empty())
+						continue;
+					if (best == nullptr || best->version < e.version)
+						best = &e;
+				}
+			}
+			return best;
+		}
+
+		std::string list(const std::vector<Source::Entry>& all)
+		{
+			std::vector<std::string> names;
+			for (const Source::Entry& e : all)
+				names.push_back(e.version.toString());
+			return text::join(names, ", ");
+		}
+
+		Source::Entry requireSnapshot(const Source& source, const Source::Entry& entry,
+									  sfs::path& snapshot)
+		{
+			snapshot = source.snapshot(entry);
+			if (!isBreezeSnapshot(snapshot))
+				throw Error("SDK " + entry.version.toString() + " (" + source.location() +
+							") has no breeze/ folder with project/Configuration.cmake: it is not a "
+							"template this "
+							"CLI can install");
+			return entry;
+		}
+
+		// Replaces the first value of set(<var> ...) in `text` by `raw` (already in CMake syntax).
+		bool setRaw(std::string& text, const std::string& var, const std::string& raw)
+		{
+			std::optional<cmake::Call> set = cmake::findSet(text, var);
+			if (!set || set->args.size() < 2)
+				return false;
+			cmake::replaceToken(text, set->args[1], raw);
+			return true;
+		}
+
+		// Settings the snapshot defines and the project's file does not yet: appended, as written.
+		std::vector<std::string> mergeMissingSettings(const sfs::path& projectFile,
+													  const sfs::path& snapshotFile)
+		{
+			std::string project = fs::readText(projectFile);
+			std::string snapshot = fs::readText(snapshotFile);
+			std::vector<std::string> added;
+			for (const cmake::Call& call : cmake::findCalls(snapshot, [](const std::string& n)
+															{ return text::lower(n) == "set"; }))
+			{
+				if (call.args.empty())
+					continue;
+				const std::string& var = call.args[0].text;
+				if (cmake::findSet(project, var))
+					continue;
+				if (!project.empty() && project.back() != '\n')
+					project += '\n';
+				project += "\n# Added by `breeze sdk`: new in this SDK version.\n" +
+						   snapshot.substr(call.begin, call.end - call.begin) + "\n";
+				added.push_back(var);
+			}
+			if (!added.empty())
+				fs::writeText(projectFile, project);
+			return added;
+		}
+
+		std::vector<std::string> differingDotFiles(const sfs::path& root, const sfs::path& snapshot)
+		{
+			std::vector<std::string> differing;
+			for (const char* name : DotFiles)
+			{
+				std::optional<std::string> mine = fs::tryReadText(root / name);
+				std::optional<std::string> theirs = fs::tryReadText(snapshot / name);
+				if (mine && theirs && *mine != *theirs)
+					differing.push_back(name);
+			}
+			return differing;
+		}
+
+		void moveAside(const sfs::path& from, const sfs::path& to)
+		{
+			std::error_code ec;
+			sfs::create_directories(to.parent_path(), ec);
+			fs::removeTree(to);
+			sfs::rename(from, to, ec);
+			if (ec)
+			{
+				if (sfs::is_directory(from))
+					fs::copyTree(from, to);
+				else
+					sfs::copy_file(from, to, sfs::copy_options::overwrite_existing, ec);
+				fs::removeTree(from);
+			}
+		}
+
+		void keepBackupsOutOfGit(const Project& project)
+		{
+			sfs::path ignore = project.metaDir() / ".gitignore";
+			if (!sfs::exists(ignore))
+				fs::writeText(ignore, "backup/\n");
+		}
+
+		std::string fromLabel(const Project& project)
+		{
+			return project.sdk.version ? project.sdk.version->toString() : "unversioned";
+		}
+
+		// ----------------------------------------------------------- moving a breeze/ project
+		// between versions
+
+		void applyBreeze(const Project& project, const sfs::path& snapshot,
+						 const Source::Entry& entry)
+		{
+			sfs::path backup = project.metaDir() / "backup" / ("breeze-" + fromLabel(project));
+			moveAside(project.root / "breeze", backup);
+			keepBackupsOutOfGit(project);
+			fs::copyTree(snapshot / "breeze", project.root / "breeze");
+
+			std::vector<std::string> added = mergeMissingSettings(
+				project.sdk.settingsFile, snapshot / "project" / "Configuration.cmake");
+			std::vector<std::string> dotFiles = differingDotFiles(project.root, snapshot);
+
+			std::cout << "SDK " << fromLabel(project) << " -> " << entry.version.toString() << "\n";
+			std::cout << "  breeze/ replaced (the old one is in "
+					  << fs::generic(sfs::relative(backup, project.root)) << ")\n";
+			for (const std::string& a : added)
+				std::cout << "  added the setting " << a << " to project/Configuration.cmake\n";
+			for (const std::string& d : dotFiles)
+				std::cout << "  " << d
+						  << " differs from the new SDK's; compare them if you want its changes\n";
+			std::cout
+				<< "  delete out/build/ if the next build complains about a stale configuration\n";
+		}
+
+		// ----------------------------------------------------------- moving a legacy (flat)
+		// project to breeze/
+
+		struct OldProject
+		{
+			std::string name;
+			std::string version;
+			std::string description;
+			std::vector<std::string> languages;
+			std::string cxxStandard;
+		};
+
+		OldProject readOldProject(const std::string& cmakeLists)
+		{
+			std::vector<cmake::Call> calls = cmake::findCalls(
+				cmakeLists, [](const std::string& n) { return text::lower(n) == "project"; });
+			if (calls.empty() || calls.front().args.empty())
+				throw Error("the project's CMakeLists.txt has no project() call to read the name "
+							"and version from");
+			OldProject old;
+			old.name = calls.front().args.front().text;
+			std::string mode;
+			for (std::size_t i = 1; i < calls.front().args.size(); ++i)
+			{
+				const cmake::Token& t = calls.front().args[i];
+				if (!t.quoted && (t.text == "VERSION" || t.text == "DESCRIPTION" ||
+								  t.text == "LANGUAGES" || t.text == "HOMEPAGE_URL"))
+				{
+					mode = t.text;
+					continue;
+				}
+				if (mode == "VERSION")
+					old.version = t.text;
+				else if (mode == "DESCRIPTION")
+					old.description = t.text;
+				else if (mode == "LANGUAGES")
+					old.languages.push_back(t.text);
+			}
+			if (std::optional<cmake::Call> std = cmake::findSet(cmakeLists, "CMAKE_CXX_STANDARD");
+				std && std->args.size() > 1)
+				old.cxxStandard = std->args[1].text;
+			return old;
+		}
+
+		void migrateLegacy(const Project& project, const sfs::path& snapshot,
+						   const Source::Entry& entry)
+		{
+			const sfs::path& root = project.root;
+			std::string oldCmake = fs::readText(root / "CMakeLists.txt");
+			std::string oldConfig = fs::readText(root / "Configuration.cmake");
+			OldProject old = readOldProject(oldCmake);
+
+			// The new settings: the snapshot's file with what this project said put in.
+			std::string settings = fs::readText(snapshot / "project" / "Configuration.cmake");
+			setRaw(settings, "PROJECT_TITLE", cmake::quote(old.name));
+			if (!old.version.empty())
+				setRaw(settings, "PROJECT_VERSION_NUMBER", cmake::quote(old.version));
+			if (!old.description.empty())
+				setRaw(settings, "PROJECT_SUMMARY", cmake::quote(old.description));
+			if (!old.languages.empty())
+				setRaw(settings, "PROJECT_LANGUAGES", text::join(old.languages, " "));
+			if (!old.cxxStandard.empty())
+				setRaw(settings, "PROJECT_CXX_STANDARD", old.cxxStandard);
+			// Every other setting the project had changed, by name: collected first, applied after,
+			// because each edit moves the offsets of what follows.
+			std::vector<std::pair<std::string, std::string>> changes;
+			for (const cmake::Call& call : cmake::findCalls(settings, [](const std::string& n)
+															{ return text::lower(n) == "set"; }))
+			{
+				if (call.args.size() < 2)
+					continue;
+				const std::string var = call.args[0].text;
+				if (var.rfind("PROJECT_", 0) == 0 && var != "PROJECT_CODE_NAME")
+					continue;
+				for (const std::string* source : {&oldConfig, &oldCmake})
+				{
+					std::optional<cmake::Call> was = cmake::findSet(*source, var);
+					if (!was || was->args.size() < 2)
+						continue;
+					std::string raw =
+						source->substr(was->args[1].begin, was->args[1].end - was->args[1].begin);
+					std::string now =
+						settings.substr(call.args[1].begin, call.args[1].end - call.args[1].begin);
+					if (raw != now)
+						changes.emplace_back(var, raw);
+					break;
+				}
+			}
+			std::vector<std::string> carried;
+			for (const auto& [var, raw] : changes)
+			{
+				setRaw(settings, var, raw);
+				carried.push_back(var);
+			}
+
+			// What the project had of the template's goes aside, nothing is thrown away.
+			sfs::path backup =
+				project.metaDir() / "backup" / ("legacy-to-" + entry.version.toString());
+			fs::removeTree(backup);
+			// Only what the template owned: the project's README.md and any other documents stay.
+			for (const char* name : {"CMakeLists.txt", "CMakePresets.json", "Configuration.cmake",
+									 "cmake", "scripts", ".githooks", "StyleGuide.md"})
+			{
+				sfs::path p = root / name;
+				if (sfs::exists(p))
+					moveAside(p, backup / name);
+			}
+			keepBackupsOutOfGit(project);
+
+			fs::copyTree(snapshot / "breeze", root / "breeze");
+			sfs::copy_file(snapshot / "CMakeLists.txt", root / "CMakeLists.txt",
+						   sfs::copy_options::overwrite_existing);
+			sfs::copy_file(snapshot / "CMakePresets.json", root / "CMakePresets.json",
+						   sfs::copy_options::overwrite_existing);
+			fs::writeText(root / "project" / "Configuration.cmake", settings);
+			for (const char* name : DotFiles)
+			{
+				if (!sfs::exists(root / name) && sfs::exists(snapshot / name))
+					sfs::copy_file(snapshot / name, root / name);
+			}
+
+			std::cout << "legacy layout -> SDK " << entry.version.toString()
+					  << " (breeze/ layout)\n";
+			std::cout << "  breeze/ and project/Configuration.cmake created; the new root "
+						 "CMakeLists.txt and "
+						 "CMakePresets.json are the SDK's\n";
+			std::cout << "  the old CMakeLists.txt, Configuration.cmake, cmake/, scripts/ and "
+						 ".githooks/ are in "
+					  << fs::generic(sfs::relative(backup, root)) << "\n";
+			std::cout << "  carried over: project name '" << old.name << "'"
+					  << (old.version.empty() ? "" : ", version " + old.version)
+					  << (carried.empty() ? "" : ", " + text::join(carried, ", ")) << "\n";
+
+			// The git hook directory moved.
+			if (sfs::exists(root / ".git"))
+			{
+				proc::Options o;
+				o.cwd = root;
+				o.capture = true;
+				proc::Result r = proc::run({"git", "config", "core.hooksPath"}, o);
+				if (r.exitCode == 0 && text::trim(r.output) == ".githooks")
+				{
+					proc::Options q;
+					q.cwd = root;
+					q.silent = true;
+					proc::run({"git", "config", "core.hooksPath", "breeze/githooks"}, q);
+					std::cout << "  git hooks now come from breeze/githooks\n";
+				}
+			}
+
+			// Build directories made by the old scripts point at files that are gone.
+			if (sfs::exists(root / "out" / "build"))
+			{
+				fs::removeTree(root / "out" / "build");
+				std::cout << "  removed out/build/ (it was configured by the old layout)\n";
+			}
+			std::cout << "next: breeze setup, then breeze build\n";
+		}
+	}
+
+	// ----------------------------------------------------------------------- Source
+
+	Source Source::configured()
+	{
+		GlobalConfig cfg = GlobalConfig::load();
+		std::optional<std::string> location = cfg.effective(config::SdkSource);
+		if (!location)
+			throw Error("no SDK source is configured. Say where SDK versions come from with:\n"
+						"  breeze config sdk-source --set <git repository (URL or path) | "
+						"directory of versions>");
+		return Source(*location);
+	}
+
+	Source::Source(std::string location) : m_location(std::move(location))
+	{
+		if (git::isRepository(m_location))
+			m_isRepository = true;
+		else if (!sfs::is_directory(m_location))
+			throw Error("the SDK source '" + m_location +
+						"' is neither a git repository nor a directory");
+	}
+
+	std::vector<Source::Entry> Source::versions() const
+	{
+		std::vector<Entry> out;
+		if (m_isRepository)
+		{
+			for (const git::Tag& t : git::versionTags(m_location))
+				out.push_back({t.version, t.name});
+		}
+		else
+		{
+			for (const sfs::directory_entry& e : sfs::directory_iterator(m_location))
+			{
+				if (!e.is_directory())
+					continue;
+				if (std::optional<Version> v = parseVersion(e.path().filename().string()))
+					out.push_back({*v, e.path().filename().string()});
+			}
+		}
+		std::sort(out.begin(), out.end(),
+				  [](const Entry& a, const Entry& b) { return a.version < b.version; });
+		return out;
+	}
+
+	sfs::path Source::snapshot(const Entry& entry) const
+	{
+		if (!m_isRepository)
+			return sfs::path(m_location) / entry.ref;
+		sfs::path cache = breezeHome() / "sdk" / hashOf(m_location) / entry.version.toString();
+		if (sfs::exists(cache / "breeze"))
+			return cache;
+		std::cout << "fetching SDK " << entry.version.toString() << " from " << m_location << "\n";
+		fs::removeTree(cache);
+		git::exportTree(m_location, entry.ref, cache);
+		return cache;
+	}
+
+	Source::Entry Source::resolve(const std::optional<std::string>& wanted) const
+	{
+		std::vector<Entry> all = versions();
+		if (all.empty())
+			throw Error("the SDK source '" + m_location + "' has no versions (tags like v1.0.0)");
+		if (!wanted || text::lower(*wanted) == "latest")
+			return *newest(all, std::nullopt);
+		std::optional<Version> v = parseVersion(*wanted);
+		if (!v)
+			throw Error("'" + *wanted + "' is not a version (use 1.2.3, or latest)");
+		if (const Entry* e = findEntry(all, *v))
+			return *e;
+		throw Error("there is no SDK " + v->toString() + " in '" + m_location +
+					"'. Available: " + list(all));
+	}
+
+	// ----------------------------------------------------------------------- commands
+
+	namespace
+	{
+		std::string moduleNameFor(const std::string& projectName)
+		{
+			std::string out;
+			bool upper = true;
+			for (char c : projectName)
+			{
+				if (c == '-' || c == '_')
+				{
+					upper = true;
+					continue;
+				}
+				out += upper ? static_cast<char>(std::toupper(static_cast<unsigned char>(c))) : c;
+				upper = false;
+			}
+			return out;
+		}
+
+		std::string idFor(const std::string& projectName)
+		{
+			return text::replaceAll(text::lower(projectName), "-", "_");
+		}
+	}
+
+	void createProject(const std::string& name, const std::optional<std::string>& id,
+					   const std::optional<std::string>& sdkVersion)
+	{
+		if (!text::isName(name, true))
+			throw Error(
+				"'" + name +
+				"' is not a valid project name: it starts with a letter and has only letters, "
+				"digits, '_' and '-'");
+		std::string projectId = id ? *id : idFor(name);
+		sfs::path dest = sfs::current_path() / name;
+		std::error_code ec;
+		if (sfs::exists(dest, ec) && !sfs::is_empty(dest, ec))
+			throw Error("'" + name + "' already exists and is not empty");
+
+		Source source = Source::configured();
+		Source::Entry entry = source.resolve(sdkVersion);
+		sfs::path snapshot;
+		requireSnapshot(source, entry, snapshot);
+
+		fs::copyTree(snapshot, dest, Skip);
+		// A new project starts without the template's demonstration code.
+		for (const char* dir : {"source", "vendor"})
+		{
+			fs::removeTree(dest / dir);
+		}
+		fs::writeText(dest / "source" / ".gitkeep", "");
+
+		std::optional<Sdk> detected = detectSdk(dest);
+		if (!detected)
+			throw Error("internal error: the project made from SDK " + entry.version.toString() +
+						" is not recognised as one");
+		Project project{dest, *detected};
+		writeSetting(project, Setting::Name, name);
+		writeSetting(project, Setting::Id, projectId);
+		writeSetting(project, Setting::Version, "0.1.0");
+		{
+			std::string settings = fs::readText(project.sdk.settingsFile);
+			setRaw(settings, "PROJECT_SUMMARY", cmake::quote(name));
+			fs::writeText(project.sdk.settingsFile, settings);
+		}
+		fs::writeText(
+			dest / "README.md",
+			"# " + name +
+				"\n\nThe project's own README: say what it is here. Doxygen uses this file as "
+				"the documentation's main page.\n\nBuilt with the breeze SDK "
+				"(breeze/):\n\n```sh\nbreeze setup  "
+				"# once, to check the tools\nbreeze build\nbreeze run\n```\n");
+
+		NewModule first;
+		first.kind = ModuleKind::Exec;
+		first.name = moduleNameFor(name);
+		addModule(project, first);
+		fs::removeTree(dest / "source" / ".gitkeep");
+
+		std::cout << "created " << name << " with SDK " << entry.version.toString() << "\n";
+		std::cout << "  an executable module '" << first.name << "' to start from\n";
+		std::cout << "next:\n  cd " << name << "\n  breeze setup\n  breeze build\n  breeze run\n";
+	}
+
+	void update(const Project& project)
+	{
+		Source source = Source::configured();
+		std::vector<Source::Entry> all = source.versions();
+		std::cout << "this project's SDK: " << project.sdk.describe() << "\n";
+		std::cout << "source: " << source.location() << "\n";
+		if (all.empty())
+		{
+			std::cout << "the source has no versions\n";
+			return;
+		}
+		std::cout << "available: " << list(all) << "\n";
+
+		const Source::Entry* latest = newest(all, std::nullopt);
+		if (project.sdk.layout == SdkLayout::Legacy)
+		{
+			std::cout << "this project has the legacy layout: `breeze sdk migrate "
+					  << latest->version.toString() << "` moves it to the breeze/ layout\n";
+			return;
+		}
+		if (!project.sdk.version)
+		{
+			std::cout << "this SDK has no version file: `breeze sdk upgrade` moves to "
+					  << latest->version.toString() << "\n";
+			return;
+		}
+		const Version& current = *project.sdk.version;
+		const Source::Entry* compatible = newest(all, current.major);
+		bool behind = compatible != nullptr && current < compatible->version;
+		if (behind)
+			std::cout << "update available: " << compatible->version.toString()
+					  << " (`breeze sdk upgrade`)\n";
+		if (latest->version.major > current.major)
+			std::cout << "a newer major version exists: " << latest->version.toString()
+					  << " (`breeze sdk migrate " << latest->version.toString() << "`)\n";
+		if (!behind && latest->version.major <= current.major)
+			std::cout << "up to date\n";
+	}
+
+	void upgrade(const Project& project)
+	{
+		if (project.sdk.layout == SdkLayout::Legacy)
+			throw Error("this project has the legacy layout, which has no upgrades: `breeze sdk "
+						"migrate <version>` "
+						"moves it to the breeze/ layout (see `breeze sdk update`)");
+		Source source = Source::configured();
+		std::vector<Source::Entry> all = source.versions();
+		if (all.empty())
+			throw Error("the SDK source '" + source.location() + "' has no versions");
+		const Source::Entry* target = project.sdk.version ? newest(all, project.sdk.version->major)
+														  : newest(all, std::nullopt);
+		if (project.sdk.version && (target == nullptr || !(*project.sdk.version < target->version)))
+		{
+			std::cout << "SDK " << project.sdk.describe()
+					  << " is the newest of its major version\n";
+			const Source::Entry* latest = newest(all, std::nullopt);
+			if (latest->version.major > project.sdk.version->major)
+				std::cout << "a newer major version exists: `breeze sdk migrate "
+						  << latest->version.toString() << "`\n";
+			return;
+		}
+		sfs::path snapshot;
+		requireSnapshot(source, *target, snapshot);
+		applyBreeze(project, snapshot, *target);
+	}
+
+	void migrate(const Project& project, const std::string& version)
+	{
+		Source source = Source::configured();
+		Source::Entry entry = source.resolve(version);
+		sfs::path snapshot;
+		requireSnapshot(source, entry, snapshot);
+		if (project.sdk.layout == SdkLayout::Legacy)
+		{
+			migrateLegacy(project, snapshot, entry);
+			return;
+		}
+		if (project.sdk.version && *project.sdk.version == entry.version)
+		{
+			std::cout << "this project is already on SDK " << entry.version.toString() << "\n";
+			return;
+		}
+		if (project.sdk.version && entry.version < *project.sdk.version)
+			std::cout << "note: this is an older SDK than the project's (" << fromLabel(project)
+					  << ")\n";
+		applyBreeze(project, snapshot, entry);
+	}
+
+}
diff --git a/source/BreezeCore/src/Text.cpp b/source/BreezeCore/src/Text.cpp
new file mode 100644
index 0000000..3ff1ca0
--- /dev/null
+++ b/source/BreezeCore/src/Text.cpp
@@ -0,0 +1,168 @@
+#include "breeze/Text.hpp"
+
+#include <cctype>
+
+#include <algorithm>
+
+namespace breeze::text
+{
+
+	std::string trim(std::string_view s)
+	{
+		std::size_t b = 0;
+		std::size_t e = s.size();
+		while (b < e && std::isspace(static_cast<unsigned char>(s[b])))
+			++b;
+		while (e > b && std::isspace(static_cast<unsigned char>(s[e - 1])))
+			--e;
+		return std::string(s.substr(b, e - b));
+	}
+
+	std::vector<std::string> split(std::string_view s, char delimiter)
+	{
+		std::vector<std::string> out;
+		std::size_t start = 0;
+		while (true)
+		{
+			std::size_t pos = s.find(delimiter, start);
+			if (pos == std::string_view::npos)
+			{
+				out.emplace_back(s.substr(start));
+				return out;
+			}
+			out.emplace_back(s.substr(start, pos - start));
+			start = pos + 1;
+		}
+	}
+
+	std::vector<std::string> splitLines(std::string_view s)
+	{
+		std::vector<std::string> lines = split(s, '\n');
+		for (std::string& line : lines)
+		{
+			if (!line.empty() && line.back() == '\r')
+				line.pop_back();
+		}
+		if (!lines.empty() && lines.back().empty())
+			lines.pop_back();
+		return lines;
+	}
+
+	std::string join(const std::vector<std::string>& parts, std::string_view separator)
+	{
+		std::string out;
+		for (std::size_t i = 0; i < parts.size(); ++i)
+		{
+			if (i != 0)
+				out += separator;
+			out += parts[i];
+		}
+		return out;
+	}
+
+	std::string lower(std::string_view s)
+	{
+		std::string out(s);
+		std::transform(out.begin(), out.end(), out.begin(),
+					   [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+		return out;
+	}
+
+	bool startsWith(std::string_view s, std::string_view prefix)
+	{
+		return s.size() >= prefix.size() && s.substr(0, prefix.size()) == prefix;
+	}
+
+	bool endsWith(std::string_view s, std::string_view suffix)
+	{
+		return s.size() >= suffix.size() && s.substr(s.size() - suffix.size()) == suffix;
+	}
+
+	std::string replaceAll(std::string s, std::string_view from, std::string_view to)
+	{
+		if (from.empty())
+			return s;
+		std::size_t pos = 0;
+		while ((pos = s.find(from, pos)) != std::string::npos)
+		{
+			s.replace(pos, from.size(), to);
+			pos += to.size();
+		}
+		return s;
+	}
+
+	std::string snakeCase(std::string_view s)
+	{
+		std::string out;
+		for (std::size_t i = 0; i < s.size(); ++i)
+		{
+			unsigned char c = static_cast<unsigned char>(s[i]);
+			if (c == '-' || c == ' ' || c == '.')
+				c = '_';
+			if (std::isupper(c))
+			{
+				bool prevLowerOrDigit =
+					i > 0 && (std::islower(static_cast<unsigned char>(s[i - 1])) ||
+							  std::isdigit(static_cast<unsigned char>(s[i - 1])));
+				bool acronymEnds = i > 0 && std::isupper(static_cast<unsigned char>(s[i - 1])) &&
+								   i + 1 < s.size() &&
+								   std::islower(static_cast<unsigned char>(s[i + 1]));
+				if ((prevLowerOrDigit || acronymEnds) && !out.empty() && out.back() != '_')
+					out += '_';
+				out += static_cast<char>(std::tolower(c));
+			}
+			else
+			{
+				if (c == '_' && (out.empty() || out.back() == '_'))
+					continue;
+				out += static_cast<char>(c);
+			}
+		}
+		while (!out.empty() && out.back() == '_')
+			out.pop_back();
+		return out;
+	}
+
+	std::string normalized(std::string_view s)
+	{
+		std::string out;
+		for (char c : s)
+		{
+			unsigned char u = static_cast<unsigned char>(c);
+			if (std::isalnum(u))
+				out += static_cast<char>(std::tolower(u));
+		}
+		return out;
+	}
+
+	bool isName(std::string_view s, bool allowDash)
+	{
+		if (s.empty() || !std::isalpha(static_cast<unsigned char>(s[0])))
+			return false;
+		return std::all_of(s.begin(), s.end(),
+						   [allowDash](char c)
+						   {
+							   unsigned char u = static_cast<unsigned char>(c);
+							   return std::isalnum(u) || c == '_' || (allowDash && c == '-');
+						   });
+	}
+
+	bool isTargetId(std::string_view s)
+	{
+		if (s.empty() || !(std::isalpha(static_cast<unsigned char>(s[0])) || s[0] == '_'))
+			return false;
+		return std::all_of(s.begin(), s.end(),
+						   [](char c)
+						   {
+							   unsigned char u = static_cast<unsigned char>(c);
+							   return std::isalnum(u) || c == '_' || c == '.' || c == '+' ||
+									  c == '-' || c == ':';
+						   });
+	}
+
+	std::string orNone(std::string_view s)
+	{
+		return s.empty() ? std::string("<none>") : std::string(s);
+	}
+
+}
diff --git a/source/BreezeCore/src/Tools.cpp b/source/BreezeCore/src/Tools.cpp
new file mode 100644
index 0000000..08c15ff
--- /dev/null
+++ b/source/BreezeCore/src/Tools.cpp
@@ -0,0 +1,422 @@
+#include "breeze/Tools.hpp"
+
+#include <algorithm>
+#include <array>
+#include <iostream>
+
+#include <nlohmann/json.hpp>
+
+#include "breeze/Config.hpp"
+#include "breeze/Error.hpp"
+#include "breeze/Fs.hpp"
+#include "breeze/Git.hpp"
+#include "breeze/Process.hpp"
+#include "breeze/Text.hpp"
+#include "breeze/Version.hpp"
+
+namespace breeze::tools
+{
+
+	namespace sfs = std::filesystem;
+	using nlohmann::json;
+
+	bool isReservedName(const std::string& word)
+	{
+		static const std::array<const char*, 6> Reserved = {"install", "uninstall", "update",
+															"upgrade", "migrate",	"ls"};
+		return std::any_of(Reserved.begin(), Reserved.end(),
+						   [&](const char* r) { return word == r; });
+	}
+
+	namespace
+	{
+		sfs::path registryFile(const Project& project)
+		{
+			return project.metaDir() / "tools.json";
+		}
+
+		json loadRegistry(const Project& project)
+		{
+			json registry = json::object();
+			if (std::optional<std::string> text = fs::tryReadText(registryFile(project)))
+			{
+				registry = json::parse(*text, nullptr, false);
+				if (registry.is_discarded() || !registry.is_object())
+					throw Error("'" + fs::generic(registryFile(project)) +
+								"' is not valid JSON; fix or delete it");
+			}
+			if (!registry.contains("tools") || !registry["tools"].is_object())
+				registry["tools"] = json::object();
+			return registry;
+		}
+
+		void saveRegistry(const Project& project, const json& registry)
+		{
+			if (registry["tools"].empty())
+			{
+				std::error_code ec;
+				sfs::remove(registryFile(project), ec);
+				return;
+			}
+			fs::writeText(registryFile(project), registry.dump(2) + "\n");
+		}
+
+		struct Manifest
+		{
+			std::string id;
+			std::string version;
+			std::string description;
+			std::string entry; // relative to the tool's directory, for this OS
+		};
+
+		Manifest readManifest(const sfs::path& dir)
+		{
+			std::optional<std::string> text = fs::tryReadText(dir / "breeze-tool.json");
+			if (!text)
+				throw Error("this is not a breeze tool: it has no breeze-tool.json at its root");
+			json j = json::parse(*text, nullptr, false);
+			if (j.is_discarded() || !j.is_object())
+				throw Error("breeze-tool.json is not valid JSON");
+			Manifest m;
+			m.id = j.value("id", "");
+			m.version = j.value("version", "");
+			m.description = j.value("description", "");
+			if (!text::isName(m.id, true))
+				throw Error("breeze-tool.json needs an \"id\" (letters, digits, '_', '-'; starting "
+							"with a letter)");
+			if (isReservedName(m.id))
+				throw Error("'" + m.id + "' can't be a tool id: `breeze tool " + m.id +
+							"` is a command of the CLI");
+			if (j.contains("entry") && j["entry"].is_string())
+			{
+				m.entry = j["entry"].get<std::string>();
+			}
+			else if (j.contains("entry") && j["entry"].is_object())
+			{
+				m.entry =
+					j["entry"].value(fs::hostPlatform() == "windows" ? "windows" : "posix", "");
+			}
+			if (m.entry.empty())
+				throw Error("breeze-tool.json needs an \"entry\" for this OS (a path, or { "
+							"\"posix\": ..., \"windows\": ... })");
+			if (!sfs::is_regular_file(dir / m.entry))
+				throw Error("the tool's entry '" + m.entry + "' is not in the repository");
+			return m;
+		}
+
+		struct Fetched
+		{
+			sfs::path dir; // a temporary directory holding the tool's files
+			Manifest manifest;
+			std::string version;
+		};
+
+		enum class Pick
+		{
+			Newest,
+			SameMajor,
+			Exact
+		};
+
+		// Gets the tool from `repo`: the version wanted, if the repository has version tags; else
+		// its files as they are.
+		Fetched fetch(const std::string& repo, Pick pick, const std::optional<Version>& basis)
+		{
+			sfs::path tmp = fs::makeTempDir("breeze-tool");
+			sfs::path dir = tmp / "tool";
+			std::string version;
+			try
+			{
+				if (git::isRepository(repo))
+				{
+					std::vector<git::Tag> tags = git::versionTags(repo);
+					const git::Tag* chosen = nullptr;
+					for (int pass = 0; pass < 2 && chosen == nullptr; ++pass)
+					{
+						for (const git::Tag& t : tags)
+						{
+							if (pick == Pick::Exact && basis && !(t.version == *basis))
+								continue;
+							if (pick == Pick::SameMajor && basis && t.version.major != basis->major)
+								continue;
+							if (pass == 0 && pick != Pick::Exact && !t.version.pre.empty())
+								continue;
+							if (chosen == nullptr || chosen->version < t.version)
+								chosen = &t;
+						}
+					}
+					if (pick == Pick::Exact && chosen == nullptr)
+					{
+						std::vector<std::string> names;
+						for (const git::Tag& t : tags)
+							names.push_back(t.version.toString());
+						std::sort(names.begin(), names.end());
+						throw Error(
+							"there is no version " + basis->toString() + " of the tool in '" +
+							repo + "'. Available: " +
+							(names.empty() ? std::string("none") : text::join(names, ", ")));
+					}
+					git::exportTree(repo, chosen ? chosen->name : "", dir);
+					if (chosen)
+						version = chosen->version.toString();
+				}
+				else if (sfs::is_directory(repo))
+				{
+					fs::copyTree(repo, dir, {".git"});
+				}
+				else
+				{
+					throw Error("'" + repo + "' is neither a git repository nor a directory");
+				}
+				Manifest manifest = readManifest(dir);
+				if (version.empty())
+					version = manifest.version.empty() ? "0.0.0" : manifest.version;
+				return {dir, manifest, version};
+			}
+			catch (...)
+			{
+				fs::removeTree(tmp);
+				throw;
+			}
+		}
+
+		void discard(const Fetched& f)
+		{
+			fs::removeTree(f.dir.parent_path());
+		}
+
+		// Puts fetched files in the project and records them.
+		void place(const Project& project, const Fetched& f, const std::string& repo)
+		{
+			sfs::path target = project.toolsDir() / f.manifest.id;
+			fs::removeTree(target);
+			std::error_code ec;
+			sfs::create_directories(target.parent_path(), ec);
+			fs::copyTree(f.dir, target);
+			fs::makeExecutable(target / f.manifest.entry);
+			json registry = loadRegistry(project);
+			registry["tools"][f.manifest.id] = {{"repo", repo}, {"version", f.version}};
+			saveRegistry(project, registry);
+		}
+
+		Tool toolFrom(const Project& project, const std::string& id, const json& entry)
+		{
+			Tool t;
+			t.id = id;
+			t.repo = entry.value("repo", "");
+			t.version = entry.value("version", "");
+			t.dir = project.toolsDir() / id;
+			if (std::optional<std::string> text = fs::tryReadText(t.dir / "breeze-tool.json"))
+			{
+				json j = json::parse(*text, nullptr, false);
+				if (j.is_object())
+					t.description = j.value("description", "");
+			}
+			return t;
+		}
+
+		Tool requireTool(const Project& project, const std::string& id)
+		{
+			json registry = loadRegistry(project);
+			if (!registry["tools"].contains(id))
+				throw Error("the tool '" + id +
+							"' is not installed in this project (see `breeze tool ls`)");
+			return toolFrom(project, id, registry["tools"][id]);
+		}
+
+		Version versionOf(const Tool& t)
+		{
+			std::optional<Version> v = parseVersion(t.version);
+			return v ? *v : Version{};
+		}
+	}
+
+	std::vector<Tool> installed(const Project& project)
+	{
+		std::vector<Tool> out;
+		json registry = loadRegistry(project);
+		for (auto it = registry["tools"].begin(); it != registry["tools"].end(); ++it)
+			out.push_back(toolFrom(project, it.key(), it.value()));
+		return out;
+	}
+
+	void install(const Project& project, const std::string& repo)
+	{
+		Fetched f = fetch(repo, Pick::Newest, std::nullopt);
+		try
+		{
+			json registry = loadRegistry(project);
+			if (registry["tools"].contains(f.manifest.id))
+				throw Error("the tool '" + f.manifest.id +
+							"' is already installed (`breeze tool upgrade " + f.manifest.id + "`)");
+			place(project, f, repo);
+		}
+		catch (...)
+		{
+			discard(f);
+			throw;
+		}
+		discard(f);
+		std::cout << "installed " << f.manifest.id << " " << f.version << "\n";
+		if (!f.manifest.description.empty())
+			std::cout << "  " << f.manifest.description << "\n";
+		std::cout << "run it with: breeze tool " << f.manifest.id << " ...\n";
+	}
+
+	void uninstall(const Project& project, const std::string& id)
+	{
+		Tool t = requireTool(project, id);
+		fs::removeTree(t.dir);
+		json registry = loadRegistry(project);
+		registry["tools"].erase(id);
+		saveRegistry(project, registry);
+		std::error_code ec;
+		sfs::remove(project.toolsDir(),
+					ec); // only when empty; so is .breeze/ then, if nothing else is in it
+		sfs::remove(project.metaDir(), ec);
+		std::cout << "uninstalled " << id << "\n";
+	}
+
+	void update(const Project& project, const std::string& id)
+	{
+		Tool t = requireTool(project, id);
+		if (!git::isRepository(t.repo))
+		{
+			std::cout << id << " " << t.version
+					  << " comes from a directory, which has no versions to look for\n";
+			return;
+		}
+		Version current = versionOf(t);
+		std::vector<git::Tag> tags = git::versionTags(t.repo);
+		const git::Tag* sameMajor = nullptr;
+		const git::Tag* newest = nullptr;
+		for (const git::Tag& tag : tags)
+		{
+			if (!tag.version.pre.empty())
+				continue;
+			if (newest == nullptr || newest->version < tag.version)
+				newest = &tag;
+			if (tag.version.major == current.major &&
+				(sameMajor == nullptr || sameMajor->version < tag.version))
+				sameMajor = &tag;
+		}
+		std::cout << id << " " << t.version << " (" << t.repo << ")\n";
+		bool behind = sameMajor != nullptr && current < sameMajor->version;
+		if (behind)
+			std::cout << "update available: " << sameMajor->version.toString()
+					  << " (`breeze tool upgrade " << id << "`)\n";
+		if (newest != nullptr && newest->version.major > current.major)
+			std::cout << "a newer major version exists: " << newest->version.toString()
+					  << " (`breeze tool migrate " << id << " " << newest->version.toString()
+					  << "`)\n";
+		if (!behind && (newest == nullptr || newest->version.major <= current.major))
+			std::cout << "up to date\n";
+	}
+
+	void upgrade(const Project& project, const std::string& id)
+	{
+		Tool t = requireTool(project, id);
+		Version current = versionOf(t);
+		Fetched f = fetch(t.repo, Pick::SameMajor, current);
+		if (!(current < *parseVersion(f.version)) && git::isRepository(t.repo))
+		{
+			discard(f);
+			std::cout << id << " " << t.version << " is the newest of its major version\n";
+			return;
+		}
+		try
+		{
+			if (f.manifest.id != id)
+				throw Error("the repository now says its tool is '" + f.manifest.id + "', not '" +
+							id + "'");
+			place(project, f, t.repo);
+		}
+		catch (...)
+		{
+			discard(f);
+			throw;
+		}
+		discard(f);
+		std::cout << id << " " << t.version << " -> " << f.version << "\n";
+	}
+
+	void migrate(const Project& project, const std::string& id, const std::string& version)
+	{
+		Tool t = requireTool(project, id);
+		std::optional<Version> wanted = parseVersion(version);
+		if (!wanted)
+			throw Error("'" + version + "' is not a version (use 1.2.3)");
+		if (!git::isRepository(t.repo))
+			throw Error("'" + id + "' comes from a directory, which has only one version");
+		Fetched f = fetch(t.repo, Pick::Exact, wanted);
+		try
+		{
+			if (f.manifest.id != id)
+				throw Error("that version says its tool is '" + f.manifest.id + "', not '" + id +
+							"'");
+			place(project, f, t.repo);
+		}
+		catch (...)
+		{
+			discard(f);
+			throw;
+		}
+		discard(f);
+		std::cout << id << " " << t.version << " -> " << f.version << "\n";
+	}
+
+	void list(const Project& project)
+	{
+		std::vector<Tool> all = installed(project);
+		if (all.empty())
+		{
+			std::cout << "no tools installed (`breeze tool install <repository>`)\n";
+			return;
+		}
+		std::size_t idWidth = 2;
+		std::size_t versionWidth = 7;
+		for (const Tool& t : all)
+		{
+			idWidth = std::max(idWidth, t.id.size());
+			versionWidth = std::max(versionWidth, t.version.size());
+		}
+		for (const Tool& t : all)
+		{
+			std::cout << t.id << std::string(idWidth - t.id.size() + 2, ' ') << t.version
+					  << std::string(versionWidth - t.version.size() + 2, ' ') << t.repo << "\n";
+			if (!t.description.empty())
+				std::cout << "    " << t.description << "\n";
+		}
+	}
+
+	std::optional<int> run(const Project& project, const std::string& id,
+						   const std::vector<std::string>& args)
+	{
+		json registry = loadRegistry(project);
+		if (!registry["tools"].contains(id))
+			return std::nullopt;
+		Tool t = toolFrom(project, id, registry["tools"][id]);
+		Manifest manifest = readManifest(t.dir);
+		sfs::path entry = t.dir / manifest.entry;
+
+		proc::Options options;
+		options.cwd = project.root;
+		GlobalConfig cfg = GlobalConfig::load();
+		options.env = {
+			{"BREEZE_PROJECT_ROOT", project.root.string()},
+			{"BREEZE_SDK_DIR", project.sdk.dir.string()},
+			{"BREEZE_SDK_VERSION", project.sdk.version ? project.sdk.version->toString() : ""},
+			{"BREEZE_TOOL_ID", id},
+			{"BREEZE_TOOL_DIR", t.dir.string()},
+			{"BREEZE_CLI", fs::executablePath().string()},
+			{"BREEZE_HOME", breezeHome().string()},
+			{"BREEZE_EDITOR", cfg.effective(config::Editor).value_or("")}};
+		std::string ext = text::lower(entry.extension().string());
+		if (fs::hostPlatform() == "windows" && (ext == ".bat" || ext == ".cmd"))
+			return proc::runScript(entry, args, options).exitCode;
+		std::vector<std::string> argv{entry.string()};
+		argv.insert(argv.end(), args.begin(), args.end());
+		return proc::run(argv, options).exitCode;
+	}
+
+}
diff --git a/source/BreezeCore/src/Version.cpp b/source/BreezeCore/src/Version.cpp
new file mode 100644
index 0000000..bf28572
--- /dev/null
+++ b/source/BreezeCore/src/Version.cpp
@@ -0,0 +1,100 @@
+#include "breeze/Version.hpp"
+
+#include <algorithm>
+#include <array>
+#include <charconv>
+
+#include "breeze/Text.hpp"
+
+namespace breeze
+{
+
+	std::string Version::toString() const
+	{
+		std::string s =
+			std::to_string(major) + "." + std::to_string(minor) + "." + std::to_string(patch);
+		if (!pre.empty())
+			s += "-" + pre;
+		return s;
+	}
+
+	namespace
+	{
+		bool parseNumber(std::string_view s, int& out)
+		{
+			if (s.empty())
+				return false;
+			auto [ptr, ec] = std::from_chars(s.data(), s.data() + s.size(), out);
+			return ec == std::errc() && ptr == s.data() + s.size() && out >= 0;
+		}
+	}
+
+	std::optional<Version> parseVersion(std::string_view text)
+	{
+		std::string t = text::trim(text);
+		if (!t.empty() && (t[0] == 'v' || t[0] == 'V'))
+			t.erase(0, 1);
+		if (std::size_t plus = t.find('+'); plus != std::string::npos)
+			t.erase(plus);
+
+		Version v;
+		if (std::size_t dash = t.find('-'); dash != std::string::npos)
+		{
+			v.pre = t.substr(dash + 1);
+			t.erase(dash);
+			if (v.pre.empty())
+				return std::nullopt;
+		}
+
+		std::vector<std::string> parts = text::split(t, '.');
+		if (parts.empty() || parts.size() > 3)
+			return std::nullopt;
+		std::array<int*, 3> fields = {&v.major, &v.minor, &v.patch};
+		for (std::size_t i = 0; i < parts.size(); ++i)
+		{
+			if (!parseNumber(parts[i], *fields[i]))
+				return std::nullopt;
+		}
+		return v;
+	}
+
+	int compare(const Version& a, const Version& b)
+	{
+		if (a.major != b.major)
+			return a.major < b.major ? -1 : 1;
+		if (a.minor != b.minor)
+			return a.minor < b.minor ? -1 : 1;
+		if (a.patch != b.patch)
+			return a.patch < b.patch ? -1 : 1;
+		if (a.pre.empty() != b.pre.empty())
+			return a.pre.empty() ? 1 : -1; // a release is newer than its own pre-release
+		if (a.pre != b.pre)
+			return a.pre < b.pre ? -1 : 1;
+		return 0;
+	}
+
+	bool operator<(const Version& a, const Version& b)
+	{
+		return compare(a, b) < 0;
+	}
+
+	bool operator==(const Version& a, const Version& b)
+	{
+		return compare(a, b) == 0;
+	}
+
+	std::optional<Version> greatest(const std::vector<Version>& versions,
+									std::optional<int> sameMajorAs)
+	{
+		std::optional<Version> best;
+		for (const Version& v : versions)
+		{
+			if (sameMajorAs && v.major != *sameMajorAs)
+				continue;
+			if (!best || *best < v)
+				best = v;
+		}
+		return best;
+	}
+
+}
diff --git a/source/CLIForge/CMakeLists.txt b/source/CLIForge/CMakeLists.txt
new file mode 100644
index 0000000..0072ca1
--- /dev/null
+++ b/source/CLIForge/CMakeLists.txt
@@ -0,0 +1 @@
+add_lib_module(cliforge OUTPUT_NAME "cliforge")
diff --git a/source/CLIForge/include/CLIForge/CLIForge.hpp b/source/CLIForge/include/CLIForge/CLIForge.hpp
new file mode 100644
index 0000000..2ea7a56
--- /dev/null
+++ b/source/CLIForge/include/CLIForge/CLIForge.hpp
@@ -0,0 +1,8 @@
+#pragma once
+
+#include "Command.hpp"
+#include "Engine.hpp"
+#include "FunctionTraits.hpp"
+#include "Levenshtein.hpp"
+#include "Slot.hpp"
+#include "Value.hpp"
diff --git a/source/CLIForge/include/CLIForge/Command.hpp b/source/CLIForge/include/CLIForge/Command.hpp
new file mode 100644
index 0000000..1532bcd
--- /dev/null
+++ b/source/CLIForge/include/CLIForge/Command.hpp
@@ -0,0 +1,499 @@
+#pragma once
+
+// Command is the fluent builder AND the parser for one CLI command. A
+// command is built like:
+//
+//   engine.command()
+//       .keyword("project")
+//       .parameter<std::string>("name", "Project name")
+//       .keyword("delete")
+//       .flag("force", 'f', "Skip the confirmation prompt")
+//       .option<std::string>("reason", 'r', "Why it's being deleted")
+//       .describe("Delete a project by name")
+//       .action(&deleteProject);
+//
+// Every parameter/option is explicitly typed where it's declared, so the
+// engine never has to invent a type from the bound function -- `.action()`
+// instead *validates* that the function's corresponding argument is a
+// consistent binding (bool for a flag; T, std::optional<T>, or
+// std::vector<T> for a parameter/option; by value, by reference, or by
+// const reference all work). Mismatches are RegistrationErrors caught at
+// startup, not silent surprises at run time.
+
+#include <cctype>
+
+#include <algorithm>
+#include <functional>
+#include <optional>
+#include <sstream>
+#include <string>
+#include <string_view>
+#include <tuple>
+#include <type_traits>
+#include <typeindex>
+#include <vector>
+
+#include "FunctionTraits.hpp"
+#include "Levenshtein.hpp"
+#include "Slot.hpp"
+#include "Value.hpp"
+
+namespace cliforge
+{
+	namespace detail
+	{
+		// --- small type-trait helpers used only for action() binding ----------
+
+		template <typename T> struct IsOptional : std::false_type
+		{
+		};
+
+		template <typename T> struct IsOptional<std::optional<T>> : std::true_type
+		{
+			using Inner = T;
+		};
+
+		template <typename T> inline constexpr bool IsOptionalV = IsOptional<T>::value;
+
+		template <typename T> struct IsVector : std::false_type
+		{
+		};
+
+		template <typename T> struct IsVector<std::vector<T>> : std::true_type
+		{
+			using Inner = T;
+		};
+
+		template <typename T> inline constexpr bool IsVectorV = IsVector<T>::value;
+
+		template <typename T>
+		inline constexpr bool IsBuiltinScalarV =
+			std::is_same_v<T, int8_t> || std::is_same_v<T, uint8_t> || std::is_same_v<T, int16_t> ||
+			std::is_same_v<T, uint16_t> || std::is_same_v<T, int32_t> ||
+			std::is_same_v<T, uint32_t> || std::is_same_v<T, int64_t> ||
+			std::is_same_v<T, uint64_t> || std::is_same_v<T, float> || std::is_same_v<T, double> ||
+			std::is_same_v<T, std::string> || std::is_same_v<T, char> || std::is_same_v<T, bool>;
+
+		// A token is where the unstructured (flags/options) part begins if it
+		// starts with a dash and isn't shaped like a negative number -- that way
+		// `build -5 -3 -1` (variadic int parameters) still works even though the
+		// tokens start with '-'.
+		bool looksLikeOptionStart(std::string_view tok);
+
+		bool isValidKeyword(std::string_view s);
+
+		// A human-readable name for a bound action() argument type, used in
+		// RegistrationError messages. Only built-in scalars and enums are ever
+		// legal here (anything else is already rejected by parameter<T>()'s own
+		// static_assert), so this never needs to handle the general case.
+		template <typename T> std::string friendlyTypeName()
+		{
+			if constexpr (IsBuiltinScalarV<T>)
+			{
+				return TypeOf<T>::get().displayName;
+			}
+			else if constexpr (std::is_enum_v<T>)
+			{
+				return "a different enum type";
+			}
+			else
+			{
+				return "an unsupported type";
+			}
+		}
+	}
+
+	// Result of trying to line a command's structured (keyword+parameter)
+	// signature up against the front of the user's token list.
+	struct StructuredMatch
+	{
+		bool success = false;
+		std::size_t consumed = 0; // tokens belonging to the structured part
+		int keywordScore = 0;	  // number of literal keywords matched
+		std::vector<Value> paramValues;
+		// Set when every literal keyword matched but a parameter's value
+		// either failed to parse or was never given -- lets the Engine
+		// surface this specific, actionable error instead of a generic
+		// "no match" + fuzzy suggestions.
+		std::string error;
+	};
+
+	class Command
+	{
+	public:
+		// Keywords carry no description of their own -- .describe() on the
+		// command is what shows up in help; a keyword is purely a literal
+		// token to match.
+		Command& keyword(const std::string& literal);
+
+		// T is explicit and required: every parameter is typed at the point
+		// it's declared, not inferred later from action(). Called before any
+		// flag()/option(), this is a fixed-position structured parameter;
+		// called after, it's a "loose" parameter matched positionally among
+		// other loose parameters regardless of where flags/options fall
+		// around it.
+		template <typename T>
+		Command& parameter(std::string name, std::string description, bool variadic = false)
+		{
+			if (name.empty())
+			{
+				throw RegistrationError("parameter name may not be empty");
+			}
+
+			Slot s;
+			s.kind = SlotKind::Parameter;
+			s.name = std::move(name);
+			s.description = std::move(description);
+			s.variadic = variadic;
+			s.cppType = std::type_index(typeid(T));
+			if constexpr (std::is_enum_v<T>)
+			{
+				s.awaitingChoices = true; // choices<T>(...) must follow immediately
+			}
+			else
+			{
+				static_assert(detail::IsBuiltinScalarV<T>,
+							  "cliforge: unsupported parameter type -- use a fixed-width int, "
+							  "float/double, std::string, char, bool, or an enum (with "
+							  "choices<T>() called immediately after)");
+				s.type = TypeOf<T>::get();
+			}
+			if (!m_unstructuredStarted)
+			{
+				if (m_structuredSealed)
+				{
+					throw RegistrationError("can't declare parameter('" + s.name +
+											"') after a variadic parameter -- a variadic parameter "
+											"must be the last thing in the structured part");
+				}
+				m_structured.push_back(std::move(s));
+				m_lastSlot = &m_structured.back();
+				if (variadic)
+					m_structuredSealed = true;
+			}
+			else
+			{
+				if (m_looseSealed)
+				{
+					throw RegistrationError("can't declare parameter('" + s.name +
+											"') after a variadic parameter -- a variadic parameter "
+											"must be the last parameter declared");
+				}
+
+				m_unstructured.push_back(std::move(s));
+				m_lastSlot = &m_unstructured.back();
+				if (variadic)
+					m_looseSealed = true;
+			}
+			return *this;
+		}
+
+		// shortName is 0 (the default) for "no short form".
+		Command& flag(std::string longName, char shortName, const std::string& description);
+
+		// T is explicit and required, same as parameter<T>(). Options are
+		// always optional in the calling convention (see action()) -- there
+		// is no way to declare a "required" option, by design.
+		template <typename T>
+		Command& option(std::string longName, char shortName, std::string description,
+						bool variadic = false)
+		{
+			longName = stripDashes(std::move(longName));
+			validateLongName(longName);
+			validateShortName(shortName);
+			checkNameFree(longName, shortName);
+			Slot s;
+			s.kind = SlotKind::Option;
+			s.name = std::move(longName);
+			s.shortName = shortName;
+			s.description = std::move(description);
+			s.variadic = variadic;
+			s.cppType = std::type_index(typeid(T));
+			if constexpr (std::is_enum_v<T>)
+			{
+				s.awaitingChoices = true;
+			}
+			else
+			{
+				static_assert(detail::IsBuiltinScalarV<T>,
+							  "cliforge: unsupported option type -- use a fixed-width int, "
+							  "float/double, std::string, char, bool, or an enum (with "
+							  "choices<T>() called immediately after)");
+				s.type = TypeOf<T>::get();
+			}
+			m_unstructured.push_back(std::move(s));
+			m_lastSlot = &m_unstructured.back();
+			m_unstructuredStarted = true;
+			return *this;
+		}
+
+		Command& describe(const std::string& description);
+
+		// Restricts the most-recently-declared parameter/option to a fixed
+		// set of named values -- this is how custom enums plug in (T is
+		// deduced from the initializer list, no need to spell it out again),
+		// and it doubles as a generic "choice" restriction for any type. T
+		// must match the type declared at parameter<T>()/option<T>().
+		template <typename T>
+		Command& choices(std::initializer_list<std::pair<std::string, T>> values,
+						 std::string typeName = "")
+		{
+			if (m_lastSlot == nullptr ||
+				(m_lastSlot->kind != SlotKind::Parameter && m_lastSlot->kind != SlotKind::Option))
+			{
+				throw RegistrationError("choices<>() must directly follow the parameter<T>() or "
+										"option<T>() it restricts");
+			}
+
+			if (!m_lastSlot->cppType || *m_lastSlot->cppType != std::type_index(typeid(T)))
+			{
+				throw RegistrationError("choices<>() type doesn't match the type declared for '" +
+										m_lastSlot->name + "'");
+			}
+
+			std::vector<std::pair<std::string, T>> table(values);
+			m_lastSlot->type = makeChoiceTypeInfo<T>(
+				typeName.empty() ? std::string("enum") : std::move(typeName), table);
+			m_lastSlot->awaitingChoices = false;
+			return *this;
+		}
+
+		// Binds this command to a free function (or captureless/capturing
+		// lambda, or std::function). Argument types are validated against
+		// what was already declared via parameter<T>()/option<T>()/flag() --
+		// action() never invents a type, it only checks consistency -- and
+		// matched, in order, to [parameters in declaration order] then
+		// [flags/options/loose-parameters in declaration order]. Arguments
+		// may be taken by value, by reference, or by const reference.
+		template <typename Func> Command& action(Func f)
+		{
+			using Traits = detail::FunctionTraits<std::decay_t<Func>>;
+			if (m_structured.empty() ||
+				std::none_of(m_structured.begin(), m_structured.end(),
+							 [](const Slot& s) { return s.kind == SlotKind::Keyword; }))
+			{
+				throw RegistrationError("a command must declare at least one keyword() so it can "
+										"be identified on the command line");
+			}
+
+			for (const Slot& s : m_structured)
+				checkNotAwaitingChoices(s);
+			for (const Slot& s : m_unstructured)
+				checkNotAwaitingChoices(s);
+
+			std::vector<Slot*> ordered = orderedBindableSlots();
+			if (ordered.size() != Traits::Arity)
+			{
+				throw RegistrationError(
+					"action() function takes " + std::to_string(Traits::Arity) +
+					" argument(s) but this command declared " + std::to_string(ordered.size()) +
+					" parameter/flag/option slot(s) -- these must match 1:1, "
+					"in declaration order (parameters first, then flags/options)");
+			}
+
+			bindArgs(std::function{f}, ordered, std::make_index_sequence<Traits::Arity>{});
+			m_sealed = true;
+			return *this;
+		}
+
+		[[nodiscard]] bool sealed() const;
+		[[nodiscard]] const std::string& description() const;
+
+		// --- matching / parsing entry points, used by Engine -------------
+
+		[[nodiscard]] StructuredMatch tryMatchStructured(
+			const std::vector<std::string>& tokens) const;
+
+		// Parses the (order-agnostic) flags/options/loose-parameters tail.
+		// Throws CliError (with a specific ErrorKind) describing exactly what
+		// went wrong: an unrecognized flag/option, a missing option value, a
+		// missing/extra positional argument, or a type mismatch.
+		[[nodiscard]] std::vector<Value> parseUnstructured(
+			const std::vector<std::string>& tokens) const;
+
+		void invoke(std::vector<Value> allValues) const;
+
+		[[nodiscard]] std::size_t structuredSlotCount() const;
+
+		// Lenient prefix check used only for --help / `help <words>` : does
+		// `tokens` look like the start of (or a complete instance of) this
+		// command, without requiring every required argument to actually be
+		// present? Keywords still must match exactly; parameter slots accept
+		// any token; running out of input mid-command is fine (that's exactly
+		// what makes it a "prefix"). Used to find *every* command consistent
+		// with what's been typed so far, so an ambiguous prefix can show help
+		// for all of them instead of guessing one.
+		[[nodiscard]] bool couldMatchPrefix(const std::vector<std::string>& tokens) const;
+
+		// --- help / usage --------------------------------------------------
+
+		[[nodiscard]] std::string usageLine() const;
+
+		[[nodiscard]] std::string helpText(const std::string& progName) const;
+
+		[[nodiscard]] std::vector<std::string> flagOptionNames() const;
+
+		// Fuzzy structural distance used for "did you mean...?" suggestions.
+		struct FuzzyScore
+		{
+			std::size_t distance = 0;
+			std::size_t keywordChars = 0; // denominator for a relative threshold
+		};
+
+		[[nodiscard]] FuzzyScore fuzzyStructuralDistance(
+			const std::vector<std::string>& tokens) const;
+
+	private:
+		std::vector<Slot> m_structured;
+		std::vector<Slot> m_unstructured;
+		std::string m_description;
+		std::function<void(std::vector<Value>&)> m_invoke;
+		Slot* m_lastSlot = nullptr;
+		bool m_unstructuredStarted = false;
+		bool m_structuredSealed = false;
+		bool m_looseSealed = false;
+		bool m_sealed = false;
+
+		static std::string stripDashes(std::string s);
+
+		void validateLongName(const std::string& s) const;
+
+		void validateShortName(char c) const;
+
+		void checkNameFree(const std::string& longName, char shortName) const;
+
+		static void checkNotAwaitingChoices(const Slot& s);
+
+		std::vector<Slot*> orderedBindableSlots();
+
+		// Validates (never invents) that a slot's declared type matches T.
+		template <typename T> static void checkTypeMatches(const Slot& slot)
+		{
+			if (!slot.cppType || *slot.cppType != std::type_index(typeid(T)))
+			{
+				throw RegistrationError("'" + slot.name + "' was declared as " +
+										slot.type.displayName + " but action() expects " +
+										detail::friendlyTypeName<T>());
+			}
+		}
+
+		// ArgT is the *raw* action() parameter type, e.g. `const std::string&`
+		// or `std::vector<int32_t>` -- validated after stripping cv/ref.
+		template <typename ArgT> static void configureSlot(Slot& slot)
+		{
+			using Stripped = std::remove_cvref_t<ArgT>;
+			if (slot.kind == SlotKind::Flag)
+			{
+				if constexpr (!std::is_same_v<Stripped, bool>)
+				{
+					throw RegistrationError("flag '--" + slot.name +
+											"' must bind to bool in action()");
+				}
+				return;
+			}
+			if constexpr (detail::IsOptionalV<Stripped>)
+			{
+				using Inner = typename detail::IsOptional<Stripped>::Inner;
+				if (slot.kind == SlotKind::Parameter)
+				{
+					throw RegistrationError("parameter '<" + slot.name +
+											">' can't bind to std::optional<> -- positional "
+											"parameters are always required");
+				}
+				if (slot.variadic)
+				{
+					throw RegistrationError(
+						"option '--" + slot.name +
+						"' is variadic; bind it to std::vector<>, not std::optional<>");
+				}
+				checkTypeMatches<Inner>(slot);
+			}
+			else if constexpr (detail::IsVectorV<Stripped>)
+			{
+				using Inner = typename detail::IsVector<Stripped>::Inner;
+				if (!slot.variadic)
+				{
+					throw RegistrationError(
+						"'" + slot.name +
+						"' binds to std::vector<> but wasn't declared variadic=true");
+				}
+				checkTypeMatches<Inner>(slot);
+			}
+			else
+			{
+				if (slot.variadic)
+				{
+					throw RegistrationError(
+						"'" + slot.name + "' was declared variadic=true; bind it to std::vector<>");
+				}
+				if (slot.kind == SlotKind::Option)
+				{
+					throw RegistrationError(
+						"option '--" + slot.name +
+						"' must bind to std::optional<T> (or std::vector<T> if "
+						"variadic) -- options are always optional, never required");
+				}
+				checkTypeMatches<Stripped>(slot);
+			}
+		}
+
+		template <typename ArgT> static ArgT extractArg(const Value& v)
+		{
+			if constexpr (std::is_same_v<ArgT, bool>)
+			{
+				return v.as<bool>();
+			}
+			else if constexpr (detail::IsOptionalV<ArgT>)
+			{
+				using Inner = typename detail::IsOptional<ArgT>::Inner;
+				return v.hasValue() ? std::optional<Inner>(v.as<Inner>()) : std::nullopt;
+			}
+			else if constexpr (detail::IsVectorV<ArgT>)
+			{
+				using Inner = typename detail::IsVector<ArgT>::Inner;
+				return v.asVector<Inner>();
+			}
+			else
+			{
+				return v.as<ArgT>();
+			}
+		}
+
+		// Extracted values are materialized into a tuple of *value* types
+		// first, then handed to f via std::apply -- std::get on that (named,
+		// lvalue) tuple yields lvalues, which is what lets f's parameters be
+		// declared by value, by reference, or by const reference and all
+		// still bind correctly.
+		template <typename Ret, typename... Args, std::size_t... I>
+		void bindArgs(std::function<Ret(Args...)> f, std::vector<Slot*>& ordered,
+					  std::index_sequence<I...>)
+		{
+			(configureSlot<Args>(*ordered[I]), ...);
+			m_invoke = [f = std::move(f)](std::vector<Value>& values)
+			{
+				std::tuple<std::remove_cvref_t<Args>...> extracted{
+					extractArg<std::remove_cvref_t<Args>>(values[I])...};
+				std::apply(f, extracted);
+			};
+		}
+
+		[[nodiscard]] int findByLong(std::string_view name) const;
+
+		[[nodiscard]] int findByShort(char c) const;
+
+		[[nodiscard]] std::string suggestFlagOption(const std::string& given) const;
+
+		[[noreturn]] void throwUnknown(std::string_view tok) const;
+
+		static std::string describeType(const Slot& slot);
+
+		static std::string padRight(const std::string& s, std::size_t width);
+
+		static void consumeSlot(const Command& self, int idxIn, bool hasInline,
+								std::string_view inlineValue,
+								const std::vector<std::string>& tokens, std::size_t& i,
+								std::vector<bool>& provided,
+								std::vector<std::vector<Scalar>>& collected,
+								std::string_view tokForError);
+	};
+}
diff --git a/source/CLIForge/include/CLIForge/Engine.hpp b/source/CLIForge/include/CLIForge/Engine.hpp
new file mode 100644
index 0000000..e062025
--- /dev/null
+++ b/source/CLIForge/include/CLIForge/Engine.hpp
@@ -0,0 +1,56 @@
+#pragma once
+
+// Engine owns every registered Command and is the single entry point:
+//
+//   Engine cli;
+//   cli.describe("A demo CLI");
+//   cli.command()....action(&fn);
+//   return cli.run(argc, argv);
+
+#include <algorithm>
+#include <iostream>
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include "Command.hpp"
+#include "Levenshtein.hpp"
+
+namespace cliforge
+{
+
+	class Engine
+	{
+	public:
+		explicit Engine(std::string programName = "");
+
+		Engine& describe(const std::string& description);
+
+		// Registers a new, empty command and returns a reference to it so it
+		// can be built up with the fluent .keyword()/.parameter()/... API.
+		// The Engine owns it for the rest of the program's lifetime.
+		Command& command();
+
+		int run(int argc, char** argv);
+
+	private:
+		std::string m_programName;
+		std::string m_description;
+		std::vector<std::unique_ptr<Command>> m_commands;
+
+		static std::string basename(const std::string& path);
+		static std::string join(const std::vector<std::string>& tokens);
+
+		// Finds every command consistent with `queryTokens` as a prefix and
+		// shows its help -- one command's help if there's exactly one match,
+		// all of them (clearly separated) if the prefix is genuinely
+		// ambiguous, or the global command list plus a hint if there's none.
+		[[nodiscard]] int showHelp(const std::vector<std::string>& queryTokens) const;
+
+		void printGlobalHelp(std::ostream& os) const;
+		void suggestCommands(const std::vector<std::string>& tokens, std::ostream& os) const;
+		static std::string firstLine(const std::string& s);
+		static std::string padRight(const std::string& s, std::size_t width);
+	};
+}
diff --git a/source/CLIForge/include/CLIForge/FunctionTraits.hpp b/source/CLIForge/include/CLIForge/FunctionTraits.hpp
new file mode 100644
index 0000000..07bae73
--- /dev/null
+++ b/source/CLIForge/include/CLIForge/FunctionTraits.hpp
@@ -0,0 +1,61 @@
+#pragma once
+
+// Deduces the return type and argument-type pack of "anything callable":
+// plain free-function pointers, non-generic lambdas (captureless or
+// capturing), and std::function instances. This is what lets
+// Command::action() figure out, at compile time, exactly which C++ types
+// it needs to convert parsed CLI tokens into -- without the user ever
+// having to spell the types out twice.
+
+#include <cstddef>
+
+#include <functional>
+#include <tuple>
+
+namespace cliforge::detail
+{
+
+	template <typename T> struct FunctionTraits;
+
+	// Plain free function: void foo(std::string, int)
+	template <typename Ret, typename... Args> struct FunctionTraits<Ret (*)(Args...)>
+	{
+		using ReturnType = Ret;
+		static constexpr std::size_t Arity = sizeof...(Args);
+		template <std::size_t I> using Arg = std::tuple_element_t<I, std::tuple<Args...>>;
+		using ArgsTuple = std::tuple<Args...>;
+	};
+
+	// std::function<void(std::string, int)>
+	template <typename Ret, typename... Args> struct FunctionTraits<std::function<Ret(Args...)>>
+	{
+		using ReturnType = Ret;
+		static constexpr std::size_t Arity = sizeof...(Args);
+		template <std::size_t I> using Arg = std::tuple_element_t<I, std::tuple<Args...>>;
+		using ArgsTuple = std::tuple<Args...>;
+	};
+
+	// Pointer-to-member-function of operator(), const and non-const, used to
+	// peel apart lambdas (which are just anonymous functors under the hood).
+	template <typename C, typename Ret, typename... Args>
+	struct FunctionTraits<Ret (C::*)(Args...) const>
+	{
+		using ReturnType = Ret;
+		static constexpr std::size_t Arity = sizeof...(Args);
+		template <std::size_t I> using Arg = std::tuple_element_t<I, std::tuple<Args...>>;
+		using ArgsTuple = std::tuple<Args...>;
+	};
+
+	template <typename C, typename Ret, typename... Args> struct FunctionTraits<Ret (C::*)(Args...)>
+	{
+		using ReturnType = Ret;
+		static constexpr std::size_t Arity = sizeof...(Args);
+		template <std::size_t I> using Arg = std::tuple_element_t<I, std::tuple<Args...>>;
+		using ArgsTuple = std::tuple<Args...>;
+	};
+
+	// Fallback: any other callable (lambda, functor) -- peel off operator().
+	template <typename F> struct FunctionTraits : FunctionTraits<decltype(&F::operator())>
+	{
+	};
+}
diff --git a/source/CLIForge/include/CLIForge/Levenshtein.hpp b/source/CLIForge/include/CLIForge/Levenshtein.hpp
new file mode 100644
index 0000000..1097363
--- /dev/null
+++ b/source/CLIForge/include/CLIForge/Levenshtein.hpp
@@ -0,0 +1,21 @@
+#pragma once
+
+// Plain edit-distance + a small "closest matches" helper, used to power
+// the "did you mean...?" suggestions for unknown commands, flags and
+// options.
+
+#include <algorithm>
+#include <string>
+#include <vector>
+
+namespace cliforge::detail
+{
+	std::size_t levenshtein(const std::string& a, const std::string& b);
+
+	// Returns up to `limit` candidates from `pool` that are close to `query`,
+	// ordered by distance. Anything farther than a generous relative
+	// threshold is dropped so we never suggest something wildly unrelated.
+	std::vector<std::string> closestMatches(const std::string& query,
+											const std::vector<std::string>& pool,
+											std::size_t limit = 3);
+}
diff --git a/source/CLIForge/include/CLIForge/Slot.hpp b/source/CLIForge/include/CLIForge/Slot.hpp
new file mode 100644
index 0000000..7eb3f8e
--- /dev/null
+++ b/source/CLIForge/include/CLIForge/Slot.hpp
@@ -0,0 +1,64 @@
+#pragma once
+
+// A `Slot` is one piece of a command's signature: a literal keyword, a
+// typed positional parameter, a boolean flag, or a typed option. The
+// same struct is reused for all four so Command can keep them in plain
+// vectors and the matcher/parser code doesn't need four parallel types.
+
+#include <optional>
+#include <string>
+#include <typeindex>
+
+#include "Value.hpp"
+
+namespace cliforge
+{
+	enum class SlotKind
+	{
+		Keyword,
+		Parameter,
+		Flag,
+		Option
+	};
+
+	struct Slot
+	{
+		SlotKind kind{};
+
+		// Keyword: the literal text the user must type (e.g. "delete").
+		// Parameter: the display name (e.g. "name" -> shown as <name>).
+		// Flag/Option: the long name WITHOUT the leading "--" (e.g. "force").
+		std::string name;
+
+		// Flags/Options only: single-letter short name (e.g. 'f'), or '\0'
+		// if no short form was registered. A plain char instead of a string
+		// avoids a heap allocation (and the temptation to compare via
+		// std::string) for what is always exactly zero or one character.
+		char shortName = '\0';
+
+		std::string description;
+
+		// Parameter/Option only: may this slot consume more than one token?
+		// Only the *last* structured parameter, or the *last* loose
+		// parameter, or any option, may be variadic.
+		bool variadic = false;
+
+		// Set immediately by parameter<T>()/option<T>(), or by choices<T>(),
+		// never deferred -- so the type is always known and displayable even
+		// before action() is called.
+		TypeInfo type;
+
+		// The exact C++ type T declared via parameter<T>()/option<T>(), kept
+		// so action() can *validate* (not invent) the bound function's
+		// corresponding argument type. Unset for Keyword/Flag slots.
+		std::optional<std::type_index> cppType;
+
+		// True from parameter<T>()/option<T>() (when T is an enum) until the
+		// matching choices<T>() call supplies the name table; action() checks
+		// this is false for every slot before binding.
+		bool awaitingChoices = false;
+
+		[[nodiscard]] std::string longFlag() const;
+		[[nodiscard]] std::string shortFlag() const;
+	};
+}
diff --git a/source/CLIForge/include/CLIForge/Value.hpp b/source/CLIForge/include/CLIForge/Value.hpp
new file mode 100644
index 0000000..d0a5e8c
--- /dev/null
+++ b/source/CLIForge/include/CLIForge/Value.hpp
@@ -0,0 +1,367 @@
+#pragma once
+
+// The type system. A `Scalar` is a closed variant over every primitive
+// type the engine understands. A `Value` wraps either a single Scalar
+// (for ordinary parameters/options) or a vector of them (for variadic
+// parameters/options). `TypeInfo` bundles a display name with a parser:
+// for the built-in scalar types this is a *plain stateless function
+// pointer* (no heap allocation, unlike std::function), and only the
+// rarer enum/choice-restricted case pays for a one-time, shared, heap
+// allocation to hold its name table.
+
+#include <cstdint>
+
+#include <algorithm>
+#include <charconv>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <variant>
+#include <vector>
+
+namespace cliforge
+{
+
+	// ---------------------------------------------------------------------
+	// Exceptions
+	// ---------------------------------------------------------------------
+
+	// Every distinct reason a run-time parse can fail. Exposed on CliError so
+	// callers (and Engine internally, for its own error-selection logic) can
+	// branch on *why* something failed, not just read a free-text message.
+	enum class ErrorKind
+	{
+		Generic,
+		UnknownOption,	  // a flag/option name isn't recognized for this command
+		TooManyArguments, // more positional values than the command declares
+		MissingArgument,  // a required positional value (or option value) was never given
+		MissingValue,	  // an option/flag was named but its value token is missing
+		TypeMismatch,	  // a token couldn't convert to the slot's declared type
+	};
+
+	// Base of every error the engine raises while registering commands or
+	// parsing user input. Engine::run() catches CliError and prints it
+	// nicely instead of letting it escape as an unhandled exception.
+	class CliError : public std::runtime_error
+	{
+	public:
+		explicit CliError(const std::string& msg, ErrorKind kind = ErrorKind::Generic);
+		[[nodiscard]] ErrorKind kind() const noexcept;
+
+	private:
+		ErrorKind m_kind;
+	};
+
+	// A token couldn't be converted to the type a slot expects -- always
+	// ErrorKind::TypeMismatch.
+	class ParseError : public CliError
+	{
+	public:
+		explicit ParseError(const std::string& msg);
+	};
+
+	// Something is wrong with how a command was *built* (mismatched arity
+	// between declared slots and the bound function, duplicate names, a
+	// choices<T>() call whose T doesn't match the declared type, an option
+	// bound to a non-optional type, an action() parameter type that doesn't
+	// match what was declared, etc). These fire at program startup (many of
+	// them at compile time via static_assert), not at end-user parse time.
+	struct RegistrationError : CliError
+	{
+		explicit RegistrationError(const std::string& msg);
+	};
+
+	// ---------------------------------------------------------------------
+	// Enum storage
+	// ---------------------------------------------------------------------
+
+	// Custom enums aren't a native Scalar alternative (there are infinitely
+	// many enum types), so when a slot is restricted to an enum via
+	// choices<T>(), the underlying value is boxed here. Value::as<T>() knows
+	// to unbox + static_cast back to the caller's real enum type.
+	struct EnumTag
+	{
+		long long value;
+	};
+
+	// ---------------------------------------------------------------------
+	// Scalar: the closed set of representable primitive values
+	// ---------------------------------------------------------------------
+
+	using Scalar = std::variant<int8_t, uint8_t, int16_t, uint16_t, int32_t, uint32_t, int64_t,
+								uint64_t, float, double, std::string, char, bool, EnumTag>;
+
+	enum class Kind
+	{
+		I8,
+		U8,
+		I16,
+		U16,
+		I32,
+		U32,
+		I64,
+		U64,
+		F32,
+		F64,
+		Str,
+		Char,
+		Bool,
+		Enum
+	};
+
+	// ---------------------------------------------------------------------
+	// TypeInfo: how to parse + describe one type
+	// ---------------------------------------------------------------------
+
+	// Holds the name table for an enum/choice-restricted slot. Built once at
+	// registration time (a single, amortized allocation via shared_ptr);
+	// parsing against it never allocates beyond the error path.
+	struct ChoiceTable
+	{
+		std::vector<std::pair<std::string, Scalar>> entries;
+
+		[[nodiscard]] Scalar parse(std::string_view token, std::string_view label) const;
+	};
+
+	struct TypeInfo
+	{
+		Kind kind{};
+		std::string displayName;
+		// Stateless parser for built-in scalar types -- a plain function
+		// pointer costs nothing to store or copy, unlike std::function.
+		Scalar (*parsePlain)(std::string_view token, std::string_view label) = nullptr;
+		// Populated only for choices<T>()-restricted slots.
+		std::shared_ptr<const ChoiceTable> choiceTable;
+
+		[[nodiscard]] bool valid() const;
+		[[nodiscard]] Scalar parse(std::string_view token, std::string_view label) const;
+	};
+
+	namespace detail
+	{
+		template <typename Int>
+		Int parseInteger(std::string_view token, std::string_view label, std::string_view typeName)
+		{
+			Int out{};
+			auto [ptr, ec] = std::from_chars(token.data(), token.data() + token.size(), out);
+			if (ec != std::errc{} || ptr != token.data() + token.size())
+			{
+				throw ParseError("type mismatch for '" + std::string(label) + "': got '" +
+								 std::string(token) + "', expected " + std::string(typeName));
+			}
+			return out;
+		}
+
+		template <typename Float>
+		Float parseFloating(std::string_view token, std::string_view label,
+							std::string_view typeName)
+		{
+			Float out{};
+			auto [ptr, ec] = std::from_chars(token.data(), token.data() + token.size(), out);
+			if (ec != std::errc{} || ptr != token.data() + token.size())
+			{
+				throw ParseError("type mismatch for '" + std::string(label) + "': got '" +
+								 std::string(token) + "', expected " + std::string(typeName));
+			}
+			return out;
+		}
+
+		std::string toLower(std::string_view s);
+	}
+
+	// Maps a C++ type T to its Kind + a ready-to-use TypeInfo. Specialized
+	// below for every built-in type; enums go through choices<T>() instead
+	// since they need a name<->value table supplied by the caller.
+	template <typename T> struct TypeOf; // intentionally undefined for unsupported T
+
+#define CLIFORGE_INT_TYPE(CPP_T, KIND, NAME)                                                       \
+	template <> struct TypeOf<CPP_T>                                                               \
+	{                                                                                              \
+		static TypeInfo get()                                                                      \
+		{                                                                                          \
+			TypeInfo t;                                                                            \
+			t.kind = Kind::KIND;                                                                   \
+			t.displayName = NAME;                                                                  \
+			t.parsePlain = [](std::string_view tok, std::string_view lbl) -> Scalar                \
+			{ return Scalar{detail::parseInteger<CPP_T>(tok, lbl, NAME)}; };                       \
+			return t;                                                                              \
+		}                                                                                          \
+	};
+
+	CLIFORGE_INT_TYPE(int8_t, I8, "int8")
+	CLIFORGE_INT_TYPE(uint8_t, U8, "uint8")
+	CLIFORGE_INT_TYPE(int16_t, I16, "int16")
+	CLIFORGE_INT_TYPE(uint16_t, U16, "uint16")
+	CLIFORGE_INT_TYPE(int32_t, I32, "int32")
+	CLIFORGE_INT_TYPE(uint32_t, U32, "uint32")
+	CLIFORGE_INT_TYPE(int64_t, I64, "int64")
+	CLIFORGE_INT_TYPE(uint64_t, U64, "uint64")
+#undef CLIFORGE_INT_TYPE
+
+	template <> struct TypeOf<float>
+	{
+		static TypeInfo get()
+		{
+			TypeInfo t;
+			t.kind = Kind::F32;
+			t.displayName = "float32";
+			t.parsePlain = [](std::string_view tok, std::string_view lbl) -> Scalar
+			{ return Scalar{detail::parseFloating<float>(tok, lbl, "float32")}; };
+			return t;
+		}
+	};
+
+	template <> struct TypeOf<double>
+	{
+		static TypeInfo get()
+		{
+			TypeInfo t;
+			t.kind = Kind::F64;
+			t.displayName = "float64";
+			t.parsePlain = [](std::string_view tok, std::string_view lbl) -> Scalar
+			{ return Scalar{detail::parseFloating<double>(tok, lbl, "float64")}; };
+			return t;
+		}
+	};
+
+	template <> struct TypeOf<std::string>
+	{
+		static TypeInfo get()
+		{
+			TypeInfo t;
+			t.kind = Kind::Str;
+			t.displayName = "string";
+			t.parsePlain = [](std::string_view tok, std::string_view) -> Scalar
+			{ return Scalar{std::string(tok)}; };
+			return t;
+		}
+	};
+
+	template <> struct TypeOf<char>
+	{
+		static TypeInfo get()
+		{
+			TypeInfo t;
+			t.kind = Kind::Char;
+			t.displayName = "char";
+			t.parsePlain = [](std::string_view tok, std::string_view lbl) -> Scalar
+			{
+				if (tok.size() != 1)
+				{
+					throw ParseError("type mismatch for '" + std::string(lbl) + "': got '" +
+									 std::string(tok) + "', expected a single char");
+				}
+				return Scalar{tok[0]};
+			};
+			return t;
+		}
+	};
+
+	template <> struct TypeOf<bool>
+	{
+		static TypeInfo get()
+		{
+			TypeInfo t;
+			t.kind = Kind::Bool;
+			t.displayName = "bool";
+			t.parsePlain = [](std::string_view tok, std::string_view lbl) -> Scalar
+			{
+				std::string lower = detail::toLower(tok);
+				if (lower == "true" || lower == "1" || lower == "yes" || lower == "on")
+				{
+					return Scalar{true};
+				}
+				if (lower == "false" || lower == "0" || lower == "no" || lower == "off")
+				{
+					return Scalar{false};
+				}
+				throw ParseError("type mismatch for '" + std::string(lbl) + "': got '" +
+								 std::string(tok) +
+								 "', expected bool (true/false, 1/0, yes/no, on/off)");
+			};
+			return t;
+		}
+	};
+
+	// Builds a TypeInfo for a `choices<T>()` restricted slot: only the
+	// listed string keys are accepted, each mapped to a T. Works both for
+	// genuine C++ enums (boxed into EnumTag) and for restricting a built-in
+	// type (e.g. a string option limited to a fixed set of values). The
+	// choice table is converted to type-erased Scalars once, here, so
+	// nothing downstream needs to be templated on T again.
+	template <typename T>
+	TypeInfo makeChoiceTypeInfo(std::string typeName,
+								const std::vector<std::pair<std::string, T>>& choices)
+	{
+		auto table = std::make_shared<ChoiceTable>();
+		table->entries.reserve(choices.size());
+		for (const auto& [name, val] : choices)
+		{
+			if constexpr (std::is_enum_v<T>)
+			{
+				table->entries.emplace_back(name, Scalar{EnumTag{static_cast<long long>(val)}});
+			}
+			else
+			{
+				table->entries.emplace_back(name, Scalar{val});
+			}
+		}
+		TypeInfo t;
+		t.kind = Kind::Enum;
+		t.displayName = std::move(typeName);
+		t.choiceTable = std::move(table);
+		return t;
+	}
+
+	// ---------------------------------------------------------------------
+	// Value: what actually flows out of the parser and into bound functions
+	// ---------------------------------------------------------------------
+
+	class Value
+	{
+	public:
+		Value();
+
+		static Value ofScalar(Scalar s);
+		static Value ofVector(std::vector<Scalar> v);
+		[[nodiscard]] bool hasValue() const;
+		[[nodiscard]] bool isVector() const;
+
+		template <typename T> [[nodiscard]] T as() const
+		{
+			const Scalar& s = std::get<Scalar>(m_data);
+			if constexpr (std::is_enum_v<T>)
+			{
+				return static_cast<T>(std::get<EnumTag>(s).value);
+			}
+			else
+			{
+				return std::get<T>(s);
+			}
+		}
+
+		template <typename T> std::vector<T> asVector() const
+		{
+			const auto& vec = std::get<std::vector<Scalar>>(m_data);
+			std::vector<T> out;
+			out.reserve(vec.size());
+			for (const Scalar& s : vec)
+			{
+				if constexpr (std::is_enum_v<T>)
+				{
+					out.push_back(static_cast<T>(std::get<EnumTag>(s).value));
+				}
+				else
+				{
+					out.push_back(std::get<T>(s));
+				}
+			}
+			return out;
+		}
+
+	private:
+		std::variant<std::monostate, Scalar, std::vector<Scalar>> m_data;
+	};
+}
diff --git a/source/CLIForge/src/Command.cpp b/source/CLIForge/src/Command.cpp
new file mode 100644
index 0000000..38091a0
--- /dev/null
+++ b/source/CLIForge/src/Command.cpp
@@ -0,0 +1,705 @@
+#include "CLIForge/Command.hpp"
+
+namespace cliforge
+{
+	namespace detail
+	{
+		bool looksLikeOptionStart(std::string_view tok)
+		{
+			if (tok.size() < 2 || tok[0] != '-')
+				return false;
+			if (tok[1] == '-')
+				return true; // "--foo"
+			if (std::isdigit(static_cast<unsigned char>(tok[1])))
+				return false; // "-5"
+			return true;	  // "-n", "-ndi"
+		}
+
+		bool isValidKeyword(std::string_view s)
+		{
+			if (s.empty())
+				return false;
+			if (s[0] == '-')
+				return false; // reserved for flags/options
+			for (char c : s)
+			{
+				if (!(std::isalnum(static_cast<unsigned char>(c)) || c == '.' || c == '_' ||
+					  c == '-'))
+				{
+					return false;
+				}
+			}
+			return true;
+		}
+	}
+
+	Command& Command::keyword(const std::string& literal)
+	{
+		if (m_unstructuredStarted)
+		{
+			throw RegistrationError("can't declare keyword('" + literal +
+									"') after a flag()/option() was added -- keywords must "
+									"come entirely before the unstructured part");
+		}
+		if (m_structuredSealed)
+		{
+			throw RegistrationError("can't declare keyword('" + literal +
+									"') after a variadic parameter -- a variadic parameter "
+									"must be the last thing in the structured part");
+		}
+		if (!detail::isValidKeyword(literal))
+		{
+			throw RegistrationError("invalid keyword '" + literal +
+									"': keywords may contain letters, digits, '.', '_' and "
+									"'-', and may not start with '-'");
+		}
+		Slot s;
+		s.kind = SlotKind::Keyword;
+		s.name = std::move(literal);
+		m_structured.push_back(std::move(s));
+		m_lastSlot = &m_structured.back();
+		return *this;
+	}
+
+	// shortName is 0 (the default) for "no short form".
+	Command& Command::flag(std::string longName, char shortName, const std::string& description)
+	{
+		longName = stripDashes(std::move(longName));
+		validateLongName(longName);
+		validateShortName(shortName);
+		checkNameFree(longName, shortName);
+		Slot s;
+		s.kind = SlotKind::Flag;
+		s.name = std::move(longName);
+		s.shortName = shortName;
+		s.description = std::move(description);
+		m_unstructured.push_back(std::move(s));
+		m_lastSlot = &m_unstructured.back();
+		m_unstructuredStarted = true;
+		return *this;
+	}
+
+	Command& Command::describe(const std::string& description)
+	{
+		m_description = std::move(description);
+		return *this;
+	}
+
+	bool Command::sealed() const
+	{
+		return m_sealed;
+	}
+
+	const std::string& Command::description() const
+	{
+		return m_description;
+	}
+
+	// --- matching / parsing entry points, used by Engine -------------
+
+	StructuredMatch Command::tryMatchStructured(const std::vector<std::string>& tokens) const
+	{
+		StructuredMatch m;
+		std::size_t i = 0;
+		try
+		{
+			for (std::size_t s = 0; s < m_structured.size(); ++s)
+			{
+				const Slot& slot = m_structured[s];
+				bool isLast = (s + 1 == m_structured.size());
+				if (slot.kind == SlotKind::Keyword)
+				{
+					if (i >= tokens.size() || tokens[i] != slot.name)
+						return StructuredMatch{};
+					++i;
+					++m.keywordScore;
+				}
+				else
+				{
+					if (slot.variadic && isLast)
+					{
+						std::vector<Scalar> collected;
+						while (i < tokens.size() && !detail::looksLikeOptionStart(tokens[i]))
+						{
+							collected.push_back(slot.type.parse(tokens[i], slot.name));
+							++i;
+						}
+
+						m.paramValues.push_back(Value::ofVector(std::move(collected)));
+					}
+					else
+					{
+						if (i >= tokens.size() || detail::looksLikeOptionStart(tokens[i]))
+						{
+							// Every keyword up to here matched literally, so
+							// this is almost certainly the intended command
+							// -- just missing a required argument.
+							throw CliError("missing required argument '<" + slot.name +
+											   ">': expected a value of type " +
+											   slot.type.displayName,
+										   ErrorKind::MissingArgument);
+						}
+
+						m.paramValues.push_back(
+							Value::ofScalar(slot.type.parse(tokens[i], slot.name)));
+						++i;
+					}
+				}
+			}
+		}
+		catch (const CliError& e)
+		{
+			// Either a type mismatch (ParseError, a CliError) or the
+			// MissingArgument thrown just above -- both mean "this is the
+			// command you meant, but something about the value is wrong",
+			// so remember it instead of treating it as a plain non-match.
+			m.success = false;
+			m.error = e.what();
+			return m;
+		}
+		m.success = true;
+		m.consumed = i;
+		return m;
+	}
+
+	// Parses the (order-agnostic) flags/options/loose-parameters tail.
+	// Throws CliError (with a specific ErrorKind) describing exactly what
+	// went wrong: an unrecognized flag/option, a missing option value, a
+	// missing/extra positional argument, or a type mismatch.
+	std::vector<Value> Command::parseUnstructured(const std::vector<std::string>& tokens) const
+	{
+		std::vector<bool> provided(m_unstructured.size(), false);
+		std::vector<std::vector<Scalar>> collected(m_unstructured.size());
+		std::vector<std::string_view> looseTokens; // views into `tokens`, which outlives this call
+		looseTokens.reserve(tokens.size());
+
+		std::size_t i = 0;
+		while (i < tokens.size())
+		{
+			std::string_view tok = tokens[i];
+			if (!detail::looksLikeOptionStart(tok))
+			{
+				// Not flag/option syntax (includes negative numbers like
+				// "-5") -- it's a value for the next loose parameter.
+				looseTokens.push_back(tok);
+				++i;
+				continue;
+			}
+			if (tok[1] == '-')
+			{
+				std::string_view rest = tok.substr(2);
+				auto eq = rest.find('=');
+				bool hasInline = (eq != std::string_view::npos);
+				std::string_view longName = hasInline ? rest.substr(0, eq) : rest;
+				std::string_view inlineValue = hasInline ? rest.substr(eq + 1) : std::string_view{};
+				int idx = findByLong(longName);
+				if (idx < 0)
+					throwUnknown(tok);
+				++i;
+				consumeSlot(*this, idx, hasInline, inlineValue, tokens, i, provided, collected,
+							tok);
+			}
+			else
+			{
+				std::string_view rest = tok.substr(1);
+				if (rest.size() == 1)
+				{
+					int idx = findByShort(rest[0]);
+					if (idx < 0)
+						throwUnknown(tok);
+					++i;
+					consumeSlot(*this, idx, false, std::string_view{}, tokens, i, provided,
+								collected, tok);
+				}
+				else
+				{
+					// Combined short flags, e.g. "-ndi" == -n -d -i.
+					for (char c : rest)
+					{
+						int idx = findByShort(c);
+						if (idx < 0)
+						{
+							throw CliError(std::string("unknown flag '-") + c +
+											   "' in combined group '" + std::string(tok) + "'" +
+											   suggestFlagOption(std::string("-") + c),
+										   ErrorKind::UnknownOption);
+						}
+						if (m_unstructured[static_cast<size_t>(idx)].kind != SlotKind::Flag)
+						{
+							throw CliError(std::string("'-") + c + "' in combined group '" +
+										   std::string(tok) +
+										   "' is an option (needs a value), so it can't "
+										   "be combined with other short flags");
+						}
+						provided[static_cast<size_t>(idx)] = true;
+					}
+					++i;
+				}
+			}
+		}
+
+		// Assign the collected loose tokens to any declared loose
+		// Parameter slots, positionally, in declaration order -- this is
+		// independent of where those tokens fell relative to flags/options.
+		std::vector<std::size_t> looseParamIdx;
+		for (std::size_t idx = 0; idx < m_unstructured.size(); ++idx)
+		{
+			if (m_unstructured[idx].kind == SlotKind::Parameter)
+				looseParamIdx.push_back(idx);
+		}
+		std::vector<Value> looseValues(looseParamIdx.size());
+		std::size_t li = 0;
+		for (std::size_t k = 0; k < looseParamIdx.size(); ++k)
+		{
+			const Slot& slot = m_unstructured[looseParamIdx[k]];
+			bool isLastLoose = (k + 1 == looseParamIdx.size());
+			if (slot.variadic && isLastLoose)
+			{
+				std::vector<Scalar> vals;
+				vals.reserve(looseTokens.size() > li ? looseTokens.size() - li : 0);
+				while (li < looseTokens.size())
+				{
+					vals.push_back(slot.type.parse(looseTokens[li], slot.name));
+					++li;
+				}
+				looseValues[k] = Value::ofVector(std::move(vals));
+			}
+			else
+			{
+				if (li >= looseTokens.size())
+				{
+					throw CliError("missing required argument '<" + slot.name +
+									   ">': expected a value of type " + slot.type.displayName,
+								   ErrorKind::MissingArgument);
+				}
+				looseValues[k] = Value::ofScalar(slot.type.parse(looseTokens[li], slot.name));
+				++li;
+			}
+		}
+		if (li < looseTokens.size())
+		{
+			std::size_t extra = looseTokens.size() - li;
+			std::string msg =
+				"too many arguments: unexpected '" + std::string(looseTokens[li]) + "'";
+			if (extra > 1)
+				msg += " (and " + std::to_string(extra - 1) + " more)";
+			throw CliError(msg, ErrorKind::TooManyArguments);
+		}
+
+		// Assemble the final values in m_unstructured's declaration order --
+		// this is what gets paired with the bound function's arguments.
+		std::vector<Value> out;
+		out.reserve(m_unstructured.size());
+		std::size_t looseCursor = 0;
+		for (std::size_t idx = 0; idx < m_unstructured.size(); ++idx)
+		{
+			const Slot& slot = m_unstructured[idx];
+			if (slot.kind == SlotKind::Parameter)
+			{
+				out.push_back(std::move(looseValues[looseCursor++]));
+			}
+			else if (slot.kind == SlotKind::Flag)
+			{
+				out.push_back(Value::ofScalar(Scalar{provided[idx]}));
+			}
+			else if (slot.variadic)
+			{
+				out.push_back(Value::ofVector(collected[idx]));
+			}
+			else if (provided[idx])
+			{
+				out.push_back(Value::ofScalar(collected[idx][0]));
+			}
+			else
+			{
+				out.push_back(Value{}); // options are always optional -> unset means nullopt
+			}
+		}
+		return out;
+	}
+
+	void Command::invoke(std::vector<Value> allValues) const
+	{
+		m_invoke(allValues);
+	}
+
+	std::size_t Command::structuredSlotCount() const
+	{
+		return m_structured.size();
+	}
+
+	bool Command::couldMatchPrefix(const std::vector<std::string>& tokens) const
+	{
+		std::size_t i = 0;
+		for (std::size_t s = 0; s < m_structured.size(); ++s)
+		{
+			if (i >= tokens.size())
+				break; // ran out of input -- a valid, incomplete prefix
+			const Slot& slot = m_structured[s];
+			bool isLast = (s + 1 == m_structured.size());
+			if (slot.kind == SlotKind::Keyword)
+			{
+				if (tokens[i] != slot.name)
+					return false;
+				++i;
+			}
+			else if (slot.variadic && isLast)
+			{
+				while (i < tokens.size() && !detail::looksLikeOptionStart(tokens[i]))
+					++i;
+			}
+			else
+			{
+				if (detail::looksLikeOptionStart(tokens[i]))
+					break; // structured part left incomplete
+				++i;
+			}
+		}
+		// Whatever tokens remain must be plausible flags/options (assumed
+		// fine without deep validation) or fit a declared loose parameter.
+		std::vector<const Slot*> looseParams;
+		for (const Slot& s : m_unstructured)
+		{
+			if (s.kind == SlotKind::Parameter)
+				looseParams.push_back(&s);
+		}
+		std::size_t looseIdx = 0;
+		for (; i < tokens.size(); ++i)
+		{
+			if (detail::looksLikeOptionStart(tokens[i]))
+				continue;
+			if (looseIdx >= looseParams.size())
+				return false; // nothing left to absorb this token
+			if (!looseParams[looseIdx]->variadic)
+				++looseIdx;
+		}
+		return true;
+	}
+
+	// --- help / usage --------------------------------------------------
+
+	std::string Command::usageLine() const
+	{
+		std::ostringstream os;
+		for (std::size_t s = 0; s < m_structured.size(); ++s)
+		{
+			const Slot& slot = m_structured[s];
+			if (s)
+				os << ' ';
+			if (slot.kind == SlotKind::Keyword)
+			{
+				os << slot.name;
+			}
+			else
+			{
+				os << '<' << slot.name << (slot.variadic ? "..." : "") << '>';
+			}
+		}
+		bool anyFlagOrOption =
+			std::any_of(m_unstructured.begin(), m_unstructured.end(),
+						[](const Slot& s) { return s.kind != SlotKind::Parameter; });
+		if (anyFlagOrOption)
+			os << " [OPTIONS]";
+		for (const Slot& slot : m_unstructured)
+		{
+			if (slot.kind != SlotKind::Parameter)
+				continue;
+			os << " <" << slot.name << (slot.variadic ? "..." : "") << '>';
+		}
+		return os.str();
+	}
+
+	std::string Command::helpText(const std::string& progName) const
+	{
+		std::ostringstream os;
+		os << "Usage: " << progName << " " << usageLine() << "\n";
+		if (!m_description.empty())
+			os << "\n" << m_description << "\n";
+
+		bool anyParams = std::any_of(m_structured.begin(), m_structured.end(),
+									 [](const Slot& s) { return s.kind == SlotKind::Parameter; }) ||
+						 std::any_of(m_unstructured.begin(), m_unstructured.end(),
+									 [](const Slot& s) { return s.kind == SlotKind::Parameter; });
+		if (anyParams)
+		{
+			os << "\nArguments:\n";
+			for (const Slot& slot : m_structured)
+			{
+				if (slot.kind != SlotKind::Parameter)
+					continue;
+				std::string label = "<" + slot.name + (slot.variadic ? "..." : "") + ">";
+				os << "  " << padRight(label, 22) << describeType(slot) << slot.description << "\n";
+			}
+			for (const Slot& slot : m_unstructured)
+			{
+				if (slot.kind != SlotKind::Parameter)
+					continue;
+				std::string label = "<" + slot.name + (slot.variadic ? "..." : "") + ">";
+				os << "  " << padRight(label, 22) << describeType(slot) << slot.description << "\n";
+			}
+		}
+
+		bool anyFlagOrOption =
+			std::any_of(m_unstructured.begin(), m_unstructured.end(),
+						[](const Slot& s) { return s.kind != SlotKind::Parameter; });
+		os << "\nOptions:\n";
+		if (anyFlagOrOption)
+		{
+			for (const Slot& slot : m_unstructured)
+			{
+				if (slot.kind == SlotKind::Parameter)
+					continue;
+				std::string names = slot.shortName == '\0'
+										? ("    --" + slot.name)
+										: (std::string("-") + slot.shortName + ", --" + slot.name);
+				if (slot.kind == SlotKind::Option)
+				{
+					names += " <" + slot.type.displayName + (slot.variadic ? "...>" : ">");
+				}
+				os << "  " << padRight(names, 28) << slot.description << "\n";
+			}
+		}
+		os << "  " << padRight("-h, --help", 28) << "Show this help message\n";
+		return os.str();
+	}
+
+	std::vector<std::string> Command::flagOptionNames() const
+	{
+		std::vector<std::string> out;
+		for (const Slot& s : m_unstructured)
+		{
+			if (s.kind == SlotKind::Parameter)
+				continue;
+			out.push_back("--" + s.name);
+			if (s.shortName != '\0')
+				out.push_back(std::string("-") + s.shortName);
+		}
+		return out;
+	}
+
+	Command::FuzzyScore Command::fuzzyStructuralDistance(
+		const std::vector<std::string>& tokens) const
+	{
+		std::size_t i = 0;
+		FuzzyScore score;
+		for (std::size_t s = 0; s < m_structured.size(); ++s)
+		{
+			const Slot& slot = m_structured[s];
+			bool isLast = (s + 1 == m_structured.size());
+			if (slot.kind == SlotKind::Keyword)
+			{
+				score.keywordChars += slot.name.size();
+				if (i >= tokens.size())
+				{
+					score.distance += slot.name.size(); // command is longer than what was typed
+					continue;
+				}
+				score.distance += detail::levenshtein(tokens[i], slot.name);
+				++i;
+			}
+			else if (slot.variadic && isLast)
+			{
+				while (i < tokens.size() && !detail::looksLikeOptionStart(tokens[i]))
+					++i;
+			}
+			else if (i < tokens.size() && !detail::looksLikeOptionStart(tokens[i]))
+			{
+				++i; // parameters are wildcards: any token "fits", no penalty
+			}
+		}
+		score.distance += (tokens.size() > i) ? (tokens.size() - i) : 0; // leftover tokens
+		return score;
+	}
+
+	std::string Command::stripDashes(std::string s)
+	{
+		while (!s.empty() && s.front() == '-')
+			s.erase(s.begin());
+		return s;
+	}
+
+	void Command::validateLongName(const std::string& s) const
+	{
+		if (s.empty())
+			throw RegistrationError("a flag/option needs a non-empty long name");
+		if (s == "help")
+		{
+			throw RegistrationError("'help' is reserved for the built-in --help flag");
+		}
+		for (char c : s)
+		{
+			if (!(std::isalnum(static_cast<unsigned char>(c)) || c == '-' || c == '_'))
+			{
+				throw RegistrationError("invalid long name '--" + s + "'");
+			}
+		}
+	}
+
+	void Command::validateShortName(char c) const
+	{
+		if (c == '\0')
+			return; // no short form
+		if (!std::isalnum(static_cast<unsigned char>(c)))
+		{
+			throw RegistrationError(
+				std::string("short names must be a single letter/digit, got '-") + c + "'");
+		}
+		if (c == 'h')
+			throw RegistrationError("'-h' is reserved for the built-in --help flag");
+	}
+
+	void Command::checkNameFree(const std::string& longName, char shortName) const
+	{
+		for (const Slot& s : m_unstructured)
+		{
+			if (s.kind == SlotKind::Parameter)
+				continue; // different namespace (bare, not "--name")
+			if (s.name == longName)
+			{
+				throw RegistrationError("duplicate long name '--" + longName + "'");
+			}
+			if (shortName != '\0' && s.shortName == shortName)
+			{
+				throw RegistrationError(std::string("duplicate short name '-") + shortName + "'");
+			}
+		}
+	}
+
+	void Command::checkNotAwaitingChoices(const Slot& s)
+	{
+		if (s.awaitingChoices)
+		{
+			throw RegistrationError("'" + s.name +
+									"' is a custom enum type and needs choices<T>(...) "
+									"called right after it is declared");
+		}
+	}
+
+	std::vector<Slot*> Command::orderedBindableSlots()
+	{
+		std::vector<Slot*> out;
+		for (Slot& s : m_structured)
+		{
+			if (s.kind == SlotKind::Parameter)
+				out.push_back(&s);
+		}
+		for (Slot& s : m_unstructured)
+			out.push_back(&s);
+		return out;
+	}
+
+	int Command::findByLong(std::string_view name) const
+	{
+		for (std::size_t i = 0; i < m_unstructured.size(); ++i)
+		{
+			if (m_unstructured[i].kind != SlotKind::Parameter && m_unstructured[i].name == name)
+			{
+				return static_cast<int>(i);
+			}
+		}
+		return -1;
+	}
+
+	int Command::findByShort(char c) const
+	{
+		if (c == '\0')
+			return -1;
+		for (std::size_t i = 0; i < m_unstructured.size(); ++i)
+		{
+			if (m_unstructured[i].kind != SlotKind::Parameter && m_unstructured[i].shortName == c)
+			{
+				return static_cast<int>(i);
+			}
+		}
+		return -1;
+	}
+
+	std::string Command::suggestFlagOption(const std::string& given) const
+	{
+		auto names = flagOptionNames();
+		names.push_back("--help");
+		names.push_back("-h");
+		auto close = detail::closestMatches(given, names, 1);
+		if (close.empty())
+			return "";
+		return " -- did you mean '" + close.front() + "'?";
+	}
+
+	[[noreturn]] void Command::throwUnknown(std::string_view tok) const
+	{
+		throw CliError("unknown flag/option '" + std::string(tok) + "' for this command" +
+						   suggestFlagOption(std::string(tok)),
+					   ErrorKind::UnknownOption);
+	}
+
+	std::string Command::describeType(const Slot& slot)
+	{
+		return "<" + slot.type.displayName + "> ";
+	}
+
+	std::string Command::padRight(const std::string& s, std::size_t width)
+	{
+		if (s.size() >= width)
+			return s + " ";
+		return s + std::string(width - s.size(), ' ');
+	}
+
+	void Command::consumeSlot(const Command& self, int idxIn, bool hasInline,
+							  std::string_view inlineValue, const std::vector<std::string>& tokens,
+							  std::size_t& i, std::vector<bool>& provided,
+							  std::vector<std::vector<Scalar>>& collected,
+							  std::string_view tokForError)
+	{
+		std::size_t idx = static_cast<std::size_t>(idxIn);
+		const Slot& slot = self.m_unstructured[idx];
+		if (slot.kind == SlotKind::Flag)
+		{
+			if (hasInline)
+				throw CliError("flag '--" + slot.name + "' does not take a value");
+			provided[idx] = true;
+			return;
+		}
+		// Option
+		if (hasInline)
+		{
+			collected[idx].push_back(slot.type.parse(inlineValue, slot.name));
+			provided[idx] = true;
+			if (slot.variadic)
+			{
+				while (i < tokens.size() && !detail::looksLikeOptionStart(tokens[i]))
+				{
+					collected[idx].push_back(slot.type.parse(tokens[i], slot.name));
+					++i;
+				}
+			}
+			return;
+		}
+		if (slot.variadic)
+		{
+			std::size_t before = i;
+			while (i < tokens.size() && !detail::looksLikeOptionStart(tokens[i]))
+			{
+				collected[idx].push_back(slot.type.parse(tokens[i], slot.name));
+				++i;
+			}
+			if (i == before)
+			{
+				throw CliError("option '" + std::string(tokForError) +
+								   "' requires at least one value",
+							   ErrorKind::MissingValue);
+			}
+			provided[idx] = true;
+		}
+		else
+		{
+			if (i >= tokens.size() || detail::looksLikeOptionStart(tokens[i]))
+			{
+				throw CliError("option '" + std::string(tokForError) + "' requires a value",
+							   ErrorKind::MissingValue);
+			}
+			collected[idx] = {slot.type.parse(tokens[i], slot.name)};
+			provided[idx] = true;
+			++i;
+		}
+	};
+}
diff --git a/source/CLIForge/src/Engine.cpp b/source/CLIForge/src/Engine.cpp
new file mode 100644
index 0000000..6415a74
--- /dev/null
+++ b/source/CLIForge/src/Engine.cpp
@@ -0,0 +1,296 @@
+#include "CLIForge/Engine.hpp"
+
+namespace cliforge
+{
+	Engine::Engine(std::string programName) : m_programName(std::move(programName))
+	{
+	}
+
+	Engine& Engine::describe(const std::string& description)
+	{
+		m_description = std::move(description);
+		return *this;
+	}
+
+	// Registers a new, empty command and returns a reference to it so it
+	// can be built up with the fluent .keyword()/.parameter()/... API.
+	// The Engine owns it for the rest of the program's lifetime.
+	Command& Engine::command()
+	{
+		m_commands.push_back(std::make_unique<Command>());
+		return *m_commands.back();
+	}
+
+	int Engine::run(int argc, char** argv)
+	{
+		if (m_programName.empty() && argc > 0)
+			m_programName = basename(argv[0]);
+		for (auto& cmd : m_commands)
+		{
+			if (!cmd->sealed())
+			{
+				std::cerr << "cliforge BUG: a command was registered without calling .action() "
+							 "on it -- every command must be bound to a function.\n";
+				return 2;
+			}
+		}
+
+		std::vector<std::string> tokens;
+		for (int i = 1; i < argc; ++i)
+			tokens.emplace_back(argv[i]);
+
+		if (tokens.empty())
+		{
+			printGlobalHelp(std::cout);
+			return 0;
+		}
+
+		// Centralized help handling: `help [words...]`, or --help/-h
+		// appearing anywhere. Both funnel into the same prefix search, so
+		// an ambiguous prefix (e.g. "project --help" matching create/
+		// delete/info) shows help for every command it's consistent with,
+		// instead of silently picking one or matching nothing.
+		std::optional<std::vector<std::string>> helpQuery;
+		if (tokens[0] == "help")
+		{
+			helpQuery = std::vector<std::string>(tokens.begin() + 1, tokens.end());
+		}
+		else if (auto it = std::find_if(tokens.begin(), tokens.end(), [](const std::string& t)
+										{ return t == "--help" || t == "-h"; });
+				 it != tokens.end())
+		{
+			std::vector<std::string> q = tokens;
+			q.erase(q.begin() + (it - tokens.begin()));
+			helpQuery = std::move(q);
+		}
+		if (helpQuery)
+		{
+			return showHelp(*helpQuery);
+		}
+
+		struct Candidate
+		{
+			Command* cmd{};
+			StructuredMatch match;
+		};
+		std::vector<Candidate> candidates;
+		std::string bestPartialError;
+		std::vector<Command*> bestPartialCmds; // every command tied for the best partial score
+		int bestPartialScore = -1;
+		for (auto& cmd : m_commands)
+		{
+			StructuredMatch m = cmd->tryMatchStructured(tokens);
+			if (m.success)
+			{
+				candidates.push_back({cmd.get(), std::move(m)});
+			}
+			else if (!m.error.empty())
+			{
+				if (m.keywordScore > bestPartialScore)
+				{
+					bestPartialScore = m.keywordScore;
+					bestPartialError = m.error;
+					bestPartialCmds.clear();
+					bestPartialCmds.push_back(cmd.get());
+				}
+				else if (m.keywordScore == bestPartialScore)
+				{
+					// Genuinely tied -- e.g. "project" alone is an equally
+					// incomplete prefix of create/delete/info, all of which
+					// report the identical "missing <name>" error. Rather
+					// than silently picking whichever was registered first
+					// (which read as an arbitrary, misleading suggestion),
+					// remember all of them and show every option.
+					bestPartialCmds.push_back(cmd.get());
+				}
+			}
+		}
+
+		if (candidates.empty())
+		{
+			if (!bestPartialCmds.empty())
+			{
+				// Every keyword matched some command, just with a bad or
+				// missing argument value -- this is much more actionable
+				// than a generic "no command matches" + fuzzy suggestions.
+				std::cerr << "Error: " << bestPartialError << "\n";
+				if (bestPartialCmds.size() == 1)
+				{
+					std::cerr << "Usage: " << m_programName << " "
+							  << bestPartialCmds.front()->usageLine() << "\n";
+				}
+				else
+				{
+					std::cerr << "'" << join(tokens) << "' matches " << bestPartialCmds.size()
+							  << " commands:\n";
+					for (auto* cmd : bestPartialCmds)
+					{
+						std::string line = m_programName + " " + cmd->usageLine();
+						std::cerr << "  " << padRight(line, 46) << firstLine(cmd->description())
+								  << "\n";
+					}
+				}
+				return 1;
+			}
+			std::cerr << "Error: no command matches '" << join(tokens) << "'.\n";
+			suggestCommands(tokens, std::cerr);
+			return 1;
+		}
+
+		std::sort(candidates.begin(), candidates.end(),
+				  [](const Candidate& a, const Candidate& b)
+				  {
+					  if (a.match.keywordScore != b.match.keywordScore)
+						  return a.match.keywordScore > b.match.keywordScore;
+					  return a.cmd->structuredSlotCount() > b.cmd->structuredSlotCount();
+				  });
+
+		std::string firstError;
+		Command* firstErrorCmd = nullptr;
+		bool haveError = false;
+		for (auto& c : candidates)
+		{
+			std::vector<std::string> remaining(tokens.begin() + static_cast<long>(c.match.consumed),
+											   tokens.end());
+			try
+			{
+				std::vector<Value> values = c.cmd->parseUnstructured(remaining);
+				std::vector<Value> all = c.match.paramValues;
+				for (auto& v : values)
+					all.push_back(std::move(v));
+				c.cmd->invoke(std::move(all));
+				return 0;
+			}
+			catch (const CliError& e)
+			{
+				// Candidates are ranked best-first (most keyword matches
+				// first), so the *first* failure is the one most likely to
+				// be what the user actually meant -- keep that, not
+				// whichever candidate happens to fail last.
+				if (!haveError)
+				{
+					firstError = e.what();
+					firstErrorCmd = c.cmd;
+					haveError = true;
+				}
+			}
+		}
+
+		std::cerr << "Error: " << firstError << "\n";
+		if (firstErrorCmd)
+			std::cerr << "Usage: " << m_programName << " " << firstErrorCmd->usageLine() << "\n";
+		return 1;
+	}
+
+	std::string Engine::basename(const std::string& path)
+	{
+		auto pos = path.find_last_of("/\\");
+		return pos == std::string::npos ? path : path.substr(pos + 1);
+	}
+
+	std::string Engine::join(const std::vector<std::string>& tokens)
+	{
+		std::string out;
+		for (std::size_t i = 0; i < tokens.size(); ++i)
+		{
+			if (i)
+				out += ' ';
+			out += tokens[i];
+		}
+		return out;
+	}
+
+	// Finds every command consistent with `queryTokens` as a prefix and
+	// shows its help -- one command's help if there's exactly one match,
+	// all of them (clearly separated) if the prefix is genuinely
+	// ambiguous, or the global command list plus a hint if there's none.
+	int Engine::showHelp(const std::vector<std::string>& queryTokens) const
+	{
+		if (queryTokens.empty())
+		{
+			printGlobalHelp(std::cout);
+			return 0;
+		}
+		std::vector<Command*> matches;
+		for (auto& cmd : m_commands)
+		{
+			if (cmd->couldMatchPrefix(queryTokens))
+				matches.push_back(cmd.get());
+		}
+		if (matches.empty())
+		{
+			std::cout << "No command matches '" << join(queryTokens) << "'.\n\n";
+			printGlobalHelp(std::cout);
+			return 1;
+		}
+		if (matches.size() == 1)
+		{
+			std::cout << matches.front()->helpText(m_programName);
+			return 0;
+		}
+		std::cout << "'" << join(queryTokens) << "' matches " << matches.size() << " commands:\n\n";
+		for (std::size_t i = 0; i < matches.size(); ++i)
+		{
+			if (i)
+				std::cout << "\n";
+			std::cout << matches[i]->helpText(m_programName);
+		}
+		return 0;
+	}
+
+	void Engine::printGlobalHelp(std::ostream& os) const
+	{
+		os << "Usage: " << m_programName << " <command> [ARGUMENTS] [OPTIONS]\n";
+		if (!m_description.empty())
+			os << "\n" << m_description << "\n";
+		os << "\nCommands:\n";
+		for (auto& cmd : m_commands)
+		{
+			std::string line = m_programName + " " + cmd->usageLine();
+			os << "  " << padRight(line, 46) << firstLine(cmd->description()) << "\n";
+		}
+		os << "\nRun '" << m_programName << " help <command>' or add --help/-h to any command "
+		   << "for details.\n";
+	}
+
+	void Engine::suggestCommands(const std::vector<std::string>& tokens, std::ostream& os) const
+	{
+		std::vector<std::pair<double, Command*>> scored;
+		for (auto& cmd : m_commands)
+		{
+			Command::FuzzyScore s = cmd->fuzzyStructuralDistance(tokens);
+			double ratio = s.keywordChars ? static_cast<double>(s.distance) /
+												static_cast<double>(s.keywordChars)
+										  : 1.0;
+			scored.emplace_back(ratio, cmd.get());
+		}
+		std::sort(scored.begin(), scored.end(), [](auto& a, auto& b) { return a.first < b.first; });
+
+		std::vector<Command*> close;
+		for (auto& [ratio, cmd] : scored)
+		{
+			if (close.size() >= 3)
+				break;
+			if (ratio <= 0.5)
+				close.push_back(cmd);
+		}
+		if (close.empty())
+			return;
+		os << "\nDid you mean:\n";
+		for (auto* cmd : close)
+			os << "  " << m_programName << " " << cmd->usageLine() << "\n";
+	}
+
+	std::string Engine::firstLine(const std::string& s)
+	{
+		auto pos = s.find('\n');
+		return pos == std::string::npos ? s : s.substr(0, pos);
+	}
+
+	std::string Engine::padRight(const std::string& s, std::size_t width)
+	{
+		if (s.size() >= width)
+			return s + " ";
+		return s + std::string(width - s.size(), ' ');
+	}
+}
diff --git a/source/CLIForge/src/Levenshtein.cpp b/source/CLIForge/src/Levenshtein.cpp
new file mode 100644
index 0000000..7c03662
--- /dev/null
+++ b/source/CLIForge/src/Levenshtein.cpp
@@ -0,0 +1,58 @@
+#include "CLIForge/Levenshtein.hpp"
+
+namespace cliforge::detail
+{
+	std::size_t levenshtein(const std::string& a, const std::string& b)
+	{
+		const std::size_t n = a.size(), m = b.size();
+		std::vector<std::size_t> prev(m + 1), cur(m + 1);
+		for (std::size_t j = 0; j <= m; ++j)
+			prev[j] = j;
+		for (std::size_t i = 1; i <= n; ++i)
+		{
+			cur[0] = i;
+			for (std::size_t j = 1; j <= m; ++j)
+			{
+				std::size_t cost = (a[i - 1] == b[j - 1]) ? 0 : 1;
+				cur[j] = std::min({prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + cost});
+			}
+			std::swap(prev, cur);
+		}
+		return prev[m];
+	}
+
+	// Returns up to `limit` candidates from `pool` that are close to `query`,
+	// ordered by distance. Anything farther than a generous relative
+	// threshold is dropped so we never suggest something wildly unrelated.
+	std::vector<std::string> closestMatches(const std::string& query,
+											const std::vector<std::string>& pool, std::size_t limit)
+	{
+		std::vector<std::pair<std::size_t, std::string>> scored;
+		scored.reserve(pool.size());
+		for (const auto& candidate : pool)
+		{
+			std::size_t d = levenshtein(query, candidate);
+			// A prefix relationship (e.g. "--arch" for "--architectures") is a
+			// very strong signal -- treat it as near-identical even though its
+			// raw edit distance is large, so common abbreviations still surface.
+			if (query.size() >= 2 && candidate.size() > query.size() &&
+				candidate.compare(0, query.size(), query) == 0)
+			{
+				d = std::min<std::size_t>(d, 1);
+			}
+			scored.emplace_back(d, candidate);
+		}
+		std::sort(scored.begin(), scored.end(), [](auto& a, auto& b) { return a.first < b.first; });
+
+		std::size_t threshold = std::max<std::size_t>(3, query.size() / 2);
+		std::vector<std::string> out;
+		for (auto& [dist, name] : scored)
+		{
+			if (out.size() >= limit)
+				break;
+			if (dist <= threshold)
+				out.push_back(name);
+		}
+		return out;
+	}
+}
diff --git a/source/CLIForge/src/Slot.cpp b/source/CLIForge/src/Slot.cpp
new file mode 100644
index 0000000..5d2fee6
--- /dev/null
+++ b/source/CLIForge/src/Slot.cpp
@@ -0,0 +1,13 @@
+#include "CLIForge/Slot.hpp"
+
+namespace cliforge
+{
+	std::string Slot::longFlag() const
+	{
+		return "--" + name;
+	}
+	std::string Slot::shortFlag() const
+	{
+		return shortName ? std::string("-") + shortName : std::string();
+	}
+}
diff --git a/source/CLIForge/src/Value.cpp b/source/CLIForge/src/Value.cpp
new file mode 100644
index 0000000..548e79b
--- /dev/null
+++ b/source/CLIForge/src/Value.cpp
@@ -0,0 +1,85 @@
+#include "CLIForge/Value.hpp"
+
+namespace cliforge
+{
+	CliError::CliError(const std::string& msg, ErrorKind kind)
+		: std::runtime_error(msg), m_kind(kind)
+	{
+	}
+
+	ErrorKind CliError::kind() const noexcept
+	{
+		return m_kind;
+	}
+
+	ParseError::ParseError(const std::string& msg) : CliError(msg, ErrorKind::TypeMismatch)
+	{
+	}
+
+	RegistrationError::RegistrationError(const std::string& msg) : CliError(msg, ErrorKind::Generic)
+	{
+	}
+
+	Scalar ChoiceTable::parse(std::string_view token, std::string_view label) const
+	{
+		for (const auto& [name, val] : entries)
+		{
+			if (name == token)
+				return val;
+		}
+		std::string allowed;
+		for (size_t i = 0; i < entries.size(); ++i)
+		{
+			if (i)
+				allowed += ", ";
+			allowed += entries[i].first;
+		}
+		throw ParseError("type mismatch for '" + std::string(label) + "': got '" +
+						 std::string(token) + "', expected one of: " + allowed);
+	}
+
+	bool TypeInfo::valid() const
+	{
+		return parsePlain != nullptr || choiceTable != nullptr;
+	}
+
+	Scalar TypeInfo::parse(std::string_view token, std::string_view label) const
+	{
+		return choiceTable ? choiceTable->parse(token, label) : parsePlain(token, label);
+	}
+
+	namespace detail
+	{
+		std::string toLower(std::string_view s)
+		{
+			std::string out(s);
+			std::transform(out.begin(), out.end(), out.begin(),
+						   [](unsigned char c) { return std::tolower(c); });
+			return out;
+		}
+	}
+
+	Value::Value() = default;
+
+	Value Value::ofScalar(Scalar s)
+	{
+		Value v;
+		v.m_data = std::move(s);
+		return v;
+	}
+	Value Value::ofVector(std::vector<Scalar> v)
+	{
+		Value out;
+		out.m_data = std::move(v);
+		return out;
+	}
+
+	bool Value::hasValue() const
+	{
+		return !std::holds_alternative<std::monostate>(m_data);
+	}
+	bool Value::isVector() const
+	{
+		return std::holds_alternative<std::vector<Scalar>>(m_data);
+	}
+}
diff --git a/source/tests/CoreTests/CMakeLists.txt b/source/tests/CoreTests/CMakeLists.txt
new file mode 100644
index 0000000..976f46e
--- /dev/null
+++ b/source/tests/CoreTests/CMakeLists.txt
@@ -0,0 +1,3 @@
+# Unit tests of breeze_core: what can be checked without running the SDK's scripts. The end-to-end
+# test (tests/e2e.sh at the project root) covers the rest against the built program.
+add_test_module(core_tests DEPENDS breeze_core)
diff --git a/source/tests/CoreTests/main.cpp b/source/tests/CoreTests/main.cpp
new file mode 100644
index 0000000..471431c
--- /dev/null
+++ b/source/tests/CoreTests/main.cpp
@@ -0,0 +1,500 @@
+// A small harness and the tests of breeze_core's logic: text, versions, CMake editing, projects and
+// their settings, modules, argument handling and process running. A test is a function that checks;
+// the program exits with the number of failed checks (0 when all hold).
+
+#include <filesystem>
+#include <functional>
+#include <iostream>
+#include <source_location>
+#include <string>
+#include <vector>
+
+#include "breeze/Arguments.hpp"
+#include "breeze/CMakeText.hpp"
+#include "breeze/Error.hpp"
+#include "breeze/Fs.hpp"
+#include "breeze/Modules.hpp"
+#include "breeze/Process.hpp"
+#include "breeze/Project.hpp"
+#include "breeze/Text.hpp"
+#include "breeze/Version.hpp"
+
+namespace
+{
+
+	int g_failures = 0;
+
+	void check(bool condition, std::source_location where = std::source_location::current())
+	{
+		if (!condition)
+		{
+			++g_failures;
+			std::cerr << where.file_name() << ":" << where.line() << ": check failed\n";
+		}
+	}
+
+	template <typename A, typename E>
+	void checkEq(const A& actual, const E& expected,
+				 std::source_location where = std::source_location::current())
+	{
+		if (!(actual == expected))
+		{
+			++g_failures;
+			std::cerr << where.file_name() << ":" << where.line() << ": was '" << actual
+					  << "', expected '" << expected << "'\n";
+		}
+	}
+
+	template <typename F> bool throwsError(F&& f)
+	{
+		try
+		{
+			f();
+		}
+		catch (const breeze::Error&)
+		{
+			return true;
+		}
+		return false;
+	}
+
+	namespace sfs = std::filesystem;
+
+	struct TempDir
+	{
+		TempDir() = default;
+		TempDir(const TempDir&) = delete;
+		TempDir& operator=(const TempDir&) = delete;
+		TempDir(TempDir&&) = delete;
+		TempDir& operator=(TempDir&&) = delete;
+		sfs::path path = breeze::fs::makeTempDir("breeze-unit");
+		~TempDir()
+		{
+			std::error_code ec;
+			sfs::remove_all(path, ec);
+		}
+	};
+
+	void write(const sfs::path& file, const std::string& text)
+	{
+		breeze::fs::writeText(file, text);
+	}
+
+	// A project with the breeze/ layout and these settings and modules.
+	sfs::path makeProject(const sfs::path& root)
+	{
+		write(root / "CMakeLists.txt", "cmake_minimum_required(VERSION 3.25)\n");
+		write(root / "breeze" / "cmake" / "Breeze.cmake", "# sdk\n");
+		write(root / "breeze" / "cmake" / "BuildHelpers.cmake",
+			  "macro(add_objects_module NAME)\nendmacro()\n");
+		write(root / "breeze" / "VERSION", "1.2.3\n");
+		write(root / "project" / "Configuration.cmake",
+			  "# settings\n"
+			  "set(PROJECT_TITLE          \"Demo\")\n"
+			  "set(PROJECT_VERSION_NUMBER \"0.1.0\")\n"
+			  "set(PROJECT_CODE_NAME \"demo\" CACHE STRING\n"
+			  "    \"A machine-friendly name.\")\n");
+		return root;
+	}
+
+	// -----------------------------------------------------------------------------------------
+	// text
+
+	void textHelpers()
+	{
+		using namespace breeze::text;
+		checkEq(snakeCase("CoreFarewell"), "core_farewell");
+		checkEq(snakeCase("HelloApp"), "hello_app");
+		checkEq(snakeCase("HTTPServer"), "http_server");
+		checkEq(snakeCase("my-app"), "my_app");
+		checkEq(snakeCase("already_snake"), "already_snake");
+		checkEq(snakeCase("Util"), "util");
+		checkEq(normalized("Clang-CL"), "clangcl");
+		checkEq(normalized("MinGW64"), "mingw64");
+		check(isName("Core"));
+		check(isName("my_mod2"));
+		check(!isName("9lives"));
+		check(!isName("bad name"));
+		check(!isName("with-dash"));
+		check(isName("with-dash", true));
+		check(isTargetId("fmt::fmt"));
+		check(isTargetId("core_lib"));
+		check(!isTargetId("bad id"));
+		checkEq(trim("  x \n"), "x");
+		checkEq(join({"a", "b", "c"}, ", "), "a, b, c");
+		checkEq(replaceAll("a-b-c", "-", "+"), "a+b+c");
+		checkEq(splitLines("one\r\ntwo\nthree\n").size(), std::size_t(3));
+		check(startsWith("breeze", "bre"));
+		check(endsWith("breeze", "eze"));
+	}
+
+	// --------------------------------------------------------------------------------------
+	// versions
+
+	void versions()
+	{
+		using namespace breeze;
+		checkEq(parseVersion("1.2.3")->toString(), "1.2.3");
+		checkEq(parseVersion("v1.2.3")->toString(), "1.2.3");
+		checkEq(parseVersion("1.2")->toString(), "1.2.0");
+		checkEq(parseVersion("2")->toString(), "2.0.0");
+		checkEq(parseVersion("1.0.0-rc1")->toString(), "1.0.0-rc1");
+		checkEq(parseVersion("1.0.0+build5")->toString(), "1.0.0");
+		check(!parseVersion("a.b.c"));
+		check(!parseVersion("1.2.3.4"));
+		check(!parseVersion(""));
+		check(!parseVersion("notaversion"));
+		check(*parseVersion("1.0.0-rc1") < *parseVersion("1.0.0"));
+		check(*parseVersion("1.9.0") < *parseVersion("1.10.0"));
+		check(*parseVersion("1.2.3") == *parseVersion("v1.2.3"));
+		std::vector<Version> all{*parseVersion("1.0.0"), *parseVersion("1.2.0"),
+								 *parseVersion("2.0.0"), *parseVersion("1.1.5")};
+		checkEq(greatest(all)->toString(), "2.0.0");
+		checkEq(greatest(all, 1)->toString(), "1.2.0");
+		check(!greatest(all, 3));
+	}
+
+	// ----------------------------------------------------------------------------------- cmake
+	// text
+
+	void cmakeText()
+	{
+		using namespace breeze::cmake;
+		std::string text = "# add_exe_module(in_a_comment)\n"
+						   "message(\"add_exe_module(in_a_string)\")\n"
+						   "#[[ add_exe_module(in_a_bracket_comment) ]]\n"
+						   "add_exe_module(real_one OUTPUT_NAME \"real\"\n"
+						   "    DEPENDS a   # trailing comment\n"
+						   "            b::c)\n"
+						   "set(NAME \"old value\" CACHE STRING\n"
+						   "    \"doc\")\n";
+		auto wanted = [](const std::string& n) { return n == "add_exe_module"; };
+		std::vector<Call> calls = findCalls(text, wanted);
+		checkEq(calls.size(), std::size_t(1));
+		if (calls.size() == 1)
+		{
+			checkEq(calls[0].args.size(), std::size_t(6));
+			checkEq(calls[0].args[0].text, "real_one");
+			checkEq(calls[0].args[2].text, "real");
+			check(calls[0].args[2].quoted);
+			checkEq(calls[0].args[5].text, "b::c");
+		}
+
+		std::optional<Call> set = findSet(text, "NAME");
+		check(set.has_value());
+		if (set)
+		{
+			checkEq(set->args[1].text, "old value");
+			std::string edited = text;
+			replaceToken(edited, set->args[1], quote("new \"value\""));
+			check(edited.find("set(NAME \"new \\\"value\\\"\" CACHE STRING\n    \"doc\")") !=
+				  std::string::npos);
+			check(edited.find("# add_exe_module(in_a_comment)") !=
+				  std::string::npos); // everything else untouched
+		}
+		check(!findSet(text, "MISSING"));
+	}
+
+	// ------------------------------------------------------------------------------------ projects
+
+	void projectDetection()
+	{
+		using namespace breeze;
+		TempDir t;
+		makeProject(t.path);
+		std::optional<Sdk> sdk = detectSdk(t.path);
+		check(sdk.has_value());
+		if (sdk)
+		{
+			check(sdk->layout == SdkLayout::Breeze);
+			checkEq(sdk->version->toString(), "1.2.3");
+			check(sdk->supportsObjects);
+			checkEq(sdk->describe(), "1.2.3");
+		}
+		write(t.path / "source" / "Mod" / "x.cpp", "");
+		std::optional<Project> found = findProject(t.path / "source" / "Mod");
+		check(found.has_value());
+		if (found)
+			check(found->root == sfs::weakly_canonical(t.path));
+		TempDir empty;
+		check(!detectSdk(empty.path));
+		check(throwsError([&] { requireProject(empty.path); }));
+
+		// the layout before breeze/: scripts/, cmake/ and Configuration.cmake at the root
+		TempDir legacy;
+		write(legacy.path / "CMakeLists.txt", "project(Old VERSION 3.4.5)\n");
+		write(legacy.path / "Configuration.cmake", "set(PROJECT_CODE_NAME \"old\")\n");
+		write(legacy.path / "cmake" / "BuildHelpers.cmake", "# no objects\n");
+		std::optional<Sdk> old = detectSdk(legacy.path);
+		check(old.has_value());
+		if (old)
+		{
+			check(old->layout == SdkLayout::Legacy);
+			check(!old->supportsObjects);
+			check(!old->version.has_value());
+		}
+	}
+
+	void settings()
+	{
+		using namespace breeze;
+		TempDir t;
+		makeProject(t.path);
+		Project p = *findProject(t.path);
+		checkEq(readSetting(p, Setting::Name), "Demo");
+		checkEq(readSetting(p, Setting::Version), "0.1.0");
+		checkEq(readSetting(p, Setting::Id), "demo");
+		writeSetting(p, Setting::Name, "Renamed");
+		writeSetting(p, Setting::Version, "2.0.1");
+		writeSetting(p, Setting::Id, "renamed_id");
+		checkEq(readSetting(p, Setting::Name), "Renamed");
+		checkEq(readSetting(p, Setting::Version), "2.0.1");
+		checkEq(readSetting(p, Setting::Id), "renamed_id");
+		std::string file = fs::readText(p.sdk.settingsFile);
+		check(file.find("CACHE STRING\n    \"A machine-friendly name.\")") !=
+			  std::string::npos); // the rest is kept
+		check(throwsError([&] { writeSetting(p, Setting::Version, "1.x"); }));
+		check(throwsError([&] { writeSetting(p, Setting::Id, "Upper"); }));
+		check(throwsError([&] { writeSetting(p, Setting::Name, "bad name"); }));
+
+		TempDir legacy;
+		write(legacy.path / "CMakeLists.txt",
+			  "cmake_minimum_required(VERSION 3.25)\nproject(Old VERSION 3.4.5 LANGUAGES CXX)\n");
+		write(legacy.path / "Configuration.cmake",
+			  "set(PROJECT_CODE_NAME \"old\" CACHE STRING \"x\")\n");
+		write(legacy.path / "cmake" / "BuildHelpers.cmake", "");
+		Project lp = *findProject(legacy.path);
+		checkEq(readSetting(lp, Setting::Name), "Old");
+		checkEq(readSetting(lp, Setting::Version), "3.4.5");
+		checkEq(readSetting(lp, Setting::Id), "old");
+		writeSetting(lp, Setting::Version, "4.0");
+		writeSetting(lp, Setting::Name, "Newer");
+		check(fs::readText(legacy.path / "CMakeLists.txt")
+				  .find("project(Newer VERSION 4.0 LANGUAGES CXX)") != std::string::npos);
+	}
+
+	void defaults()
+	{
+		using namespace breeze;
+		TempDir t;
+		makeProject(t.path);
+		Project p = *findProject(t.path);
+		Defaults d = Defaults::load(p);
+		check(!d.build("preset"));
+		d.setBuild("preset", "linux-x64-gcc");
+		d.setRun("hello_exe");
+		d.save(p);
+		Defaults again = Defaults::load(p);
+		checkEq(*again.build("preset"), "linux-x64-gcc");
+		checkEq(*again.run(), "hello_exe");
+		again.clearBuild("preset");
+		again.clearRun();
+		again.save(p);
+		check(!sfs::exists(p.defaultsFile())); // nothing left to keep: the file goes
+	}
+
+	// ------------------------------------------------------------------------------------ modules
+
+	void modules()
+	{
+		using namespace breeze;
+		TempDir t;
+		makeProject(t.path);
+		write(t.path / "source" / "Core" / "CMakeLists.txt",
+			  "add_lib_module(core_lib TYPE SHARED OUTPUT_NAME \"core\" DEPENDS fmt::fmt "
+			  "core_pieces)\n");
+		write(t.path / "source" / "CorePieces" / "CMakeLists.txt",
+			  "add_objects_module(core_pieces)\n");
+		write(t.path / "source" / "App" / "CMakeLists.txt",
+			  "add_exe_module(app_exe DEPENDS core_lib)\n");
+		write(t.path / "source" / "tests" / "CoreTest" / "CMakeLists.txt",
+			  "add_test_module(core_test DEPENDS core_pieces)\n");
+		Project p = *findProject(t.path);
+
+		std::vector<Module> mods = scanModules(p);
+		checkEq(mods.size(), std::size_t(4));
+		const Module* core = findModule(mods, "core_lib");
+		check(core != nullptr);
+		if (core)
+		{
+			check(core->kind == ModuleKind::Lib);
+			check(core->libType == LibType::Shared);
+			checkEq(core->outputName, "core");
+			checkEq(core->deps.size(), std::size_t(2));
+		}
+		check(findModule(mods, "CorePieces") != nullptr); // by directory
+		check(findModule(mods, "corepieces") != nullptr); // by directory, another case
+		check(findModule(mods, "core_pieces")->kind == ModuleKind::Obj);
+		check(findModule(mods, "core_test")->kind == ModuleKind::Test);
+
+		// dependency queries
+		checkEq(dependenciesOf(mods, *findModule(mods, "app_exe"), false).size(), std::size_t(1));
+		std::vector<std::string> all = dependenciesOf(mods, *findModule(mods, "app_exe"), true);
+		checkEq(all.size(), std::size_t(3)); // core_lib, fmt::fmt, core_pieces
+		checkEq(dependentsOf(mods, *findModule(mods, "core_pieces"), false).size(), std::size_t(2));
+		checkEq(dependentsOf(mods, *findModule(mods, "core_pieces"), true).size(), std::size_t(3));
+
+		// adding
+		NewModule lib;
+		lib.kind = ModuleKind::Lib;
+		lib.name = "Strings";
+		lib.libType = LibType::Static;
+		lib.deps = {"core_pieces", "fmt::fmt"};
+		Module made = addModule(p, lib);
+		checkEq(made.id, "strings_lib");
+		check(sfs::exists(t.path / "source" / "Strings" / "include" / "strings" / "Strings.hpp"));
+		check(sfs::exists(t.path / "source" / "Strings" / "src" / "Strings.cpp"));
+		NewModule test;
+		test.kind = ModuleKind::Test;
+		test.name = "StringsTest";
+		checkEq(addModule(p, test).id, "strings_test"); // not strings_test_test
+		check(sfs::exists(t.path / "source" / "tests" / "StringsTest" / "main.cpp"));
+		NewModule noType;
+		noType.kind = ModuleKind::Lib;
+		noType.name = "NoType";
+		check(throwsError([&] { addModule(p, noType); }));
+		NewModule duplicate;
+		duplicate.kind = ModuleKind::Exec;
+		duplicate.name = "Other";
+		duplicate.id = "app_exe";
+		check(throwsError([&] { addModule(p, duplicate); }));
+		NewModule onExe;
+		onExe.kind = ModuleKind::Exec;
+		onExe.name = "OnExe";
+		onExe.deps = {"app_exe"};
+		check(throwsError([&] { addModule(p, onExe); }));
+		NewModule badName;
+		badName.kind = ModuleKind::Exec;
+		badName.name = "9bad";
+		check(throwsError([&] { addModule(p, badName); }));
+
+		// renaming: the id, the directory, and the DEPENDS of whoever names it
+		RenameResult r =
+			renameModule(p, "core_pieces", std::string("Pieces"), std::string("pieces_obj"));
+		checkEq(r.newId, "pieces_obj");
+		check(sfs::exists(t.path / "source" / "Pieces" / "CMakeLists.txt"));
+		check(!sfs::exists(t.path / "source" / "CorePieces"));
+		mods = scanModules(p);
+		check(findModule(mods, "pieces_obj") != nullptr);
+		check(findModule(mods, "core_pieces") == nullptr);
+		checkEq(findModule(mods, "core_lib")->deps[1], "pieces_obj");
+		checkEq(findModule(mods, "core_test")->deps[0], "pieces_obj");
+		checkEq(findModule(mods, "strings_lib")->deps[0], "pieces_obj");
+		check(throwsError([&] { renameModule(p, "app_exe", std::nullopt, std::nullopt); }));
+		check(throwsError([&]
+						  { renameModule(p, "app_exe", std::nullopt, std::string("core_lib")); }));
+
+		// deleting: refused while something depends on it
+		check(throwsError([&] { deleteModule(p, "pieces_obj"); }));
+		deleteModule(p, "app_exe");
+		check(!sfs::exists(t.path / "source" / "App"));
+		check(throwsError([&] { deleteModule(p, "app_exe"); }));
+	}
+
+	void objectsNeedSdkSupport()
+	{
+		using namespace breeze;
+		TempDir t;
+		makeProject(t.path);
+		write(t.path / "breeze" / "cmake" / "BuildHelpers.cmake",
+			  "# an SDK from before objects modules\n");
+		Project p = *findProject(t.path);
+		NewModule obj;
+		obj.kind = ModuleKind::Obj;
+		obj.name = "Pieces";
+		check(throwsError([&] { addModule(p, obj); }));
+	}
+
+	// ------------------------------------------------------------------------------------
+	// arguments
+
+	void arguments()
+	{
+		using breeze::cli::normalizeArguments;
+		using V = std::vector<std::string>;
+		check(normalizeArguments({"build", "--cargs", "-DA=1", "-DB=2", "-j", "4"}) ==
+			  V({"build", "--cargs=-DA=1", "--cargs=-DB=2", "-j", "4"}));
+		check(normalizeArguments({"run", "hello_exe", "-x", "--verbose", "-q"}) ==
+			  V({"run", "hello_exe", "--args=--verbose", "--args=-q"}));
+		check(normalizeArguments({"build", "--cargs=-DA=1"}) ==
+			  V({"build", "--cargs=-DA=1"})); // already in the form
+		check(normalizeArguments({"build", "--cargs"}) ==
+			  V({"build", "--cargs"})); // nothing: CLIForge reports it
+		check(normalizeArguments({"ls", "--cargs", "-D"}) ==
+			  V({"ls", "--cargs", "-D"})); // not a build command
+		check(normalizeArguments({}).empty());
+	}
+
+	// ------------------------------------------------------------------------------------
+	// processes
+
+	void processes()
+	{
+#ifndef _WIN32
+		using namespace breeze;
+		proc::Options o;
+		o.capture = true;
+		proc::Result r = proc::run({"sh", "-c", "echo out; echo err >&2; exit 3"}, o);
+		checkEq(r.exitCode, 3);
+		checkEq(r.output, "out\n");
+		o.mergeStderr = true;
+		r = proc::run({"sh", "-c", "echo out; echo err >&2"}, o);
+		check(r.output.find("err") != std::string::npos);
+		proc::Options env;
+		env.capture = true;
+		env.env = {{"BREEZE_TEST_VARIABLE", "present"}};
+		checkEq(proc::run({"sh", "-c", "printf %s \"$BREEZE_TEST_VARIABLE\""}, env).output,
+				"present");
+		TempDir t;
+		proc::Options in;
+		in.capture = true;
+		in.cwd = t.path;
+		checkEq(
+			sfs::weakly_canonical(
+				proc::run({"pwd"}, in).output.substr(0, proc::run({"pwd"}, in).output.size() - 1)),
+			sfs::weakly_canonical(t.path));
+		proc::Options quiet;
+		quiet.silent = true;
+		checkEq(proc::run({"sh", "-c", "echo hidden; exit 5"}, quiet).exitCode, 5);
+		checkEq(proc::run({"/no/such/program"}).exitCode, 127);
+		check(proc::findInPath("sh").has_value());
+		check(!proc::findInPath("no-such-program-anywhere").has_value());
+#endif
+	}
+
+	struct Case
+	{
+		const char* name;
+		std::function<void()> run;
+	};
+
+}
+
+int main()
+{
+	const std::vector<Case> cases = {
+		{"text helpers", textHelpers}, {"versions", versions},
+		{"cmake text", cmakeText},	   {"project detection", projectDetection},
+		{"settings", settings},		   {"defaults", defaults},
+		{"modules", modules},		   {"objects modules need SDK support", objectsNeedSdkSupport},
+		{"arguments", arguments},	   {"processes", processes},
+	};
+	for (const Case& c : cases)
+	{
+		int before = g_failures;
+		try
+		{
+			c.run();
+		}
+		catch (const std::exception& e)
+		{
+			++g_failures;
+			std::cerr << c.name << ": unexpected exception: " << e.what() << "\n";
+		}
+		std::cout << (g_failures == before ? "ok    " : "FAIL  ") << c.name << "\n";
+	}
+	std::cout << (g_failures == 0 ? "all tests passed"
+								  : std::to_string(g_failures) + " check(s) failed")
+			  << "\n";
+	return g_failures == 0 ? 0 : 1;
+}
diff --git a/tests/e2e.sh b/tests/e2e.sh
new file mode 100644
index 0000000..49caa71
--- /dev/null
+++ b/tests/e2e.sh
@@ -0,0 +1,187 @@
+#!/usr/bin/env bash
+# End-to-end test of the breeze CLI: drives the built program through every command group against a
+# throw-away home directory, SDK source, tool and project. Needs cmake, a compiler and git; no network.
+#
+#   tests/e2e.sh [path/to/breeze]        (default: out/build/linux-x64-gcc/bin/breeze)
+#
+# Exits with the number of failed checks.
+set -u
+
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+B="$(cd "$(dirname "${1:-$HERE/out/build/linux-x64-gcc/bin/breeze}")" && pwd)/$(basename "${1:-$HERE/out/build/linux-x64-gcc/bin/breeze}")"
+[ -x "$B" ] || { echo "no executable at $B (build first, or pass the path)"; exit 2; }
+
+WORK="$(mktemp -d)"
+trap 'rm -rf "$WORK"' EXIT
+export BREEZE_HOME="$WORK/home"
+unset BREEZE_NO_FORWARD BREEZE_EDITOR BREEZE_SDK_SOURCE BREEZE_CLI_SOURCE
+
+passed=0
+failed=0
+report() { # ok|FAIL description [detail]
+	if [ "$1" = ok ]; then passed=$((passed + 1)); printf 'ok    %s\n' "$2"; else failed=$((failed + 1)); printf 'FAIL  %s\n' "$2"; [ -n "${3:-}" ] && printf '      %s\n' "$3"; fi
+}
+# expect <description> <substring that must be in the output> <command...>   (the command must succeed)
+expect() {
+	local d="$1" want="$2"; shift 2
+	local out; out="$("$@" 2>&1)"; local rc=$?
+	if [ $rc -eq 0 ] && [[ "$out" == *"$want"* ]]; then report ok "$d"; else report FAIL "$d" "rc=$rc, wanted '$want', got: $(echo "$out" | head -3 | tr '\n' '|')"; fi
+}
+# refuse <description> <substring> <command...>   (the command must fail, saying that)
+refuse() {
+	local d="$1" want="$2"; shift 2
+	local out; out="$("$@" 2>&1)"; local rc=$?
+	if [ $rc -ne 0 ] && [[ "$out" == *"$want"* ]]; then report ok "$d"; else report FAIL "$d" "rc=$rc, wanted '$want', got: $(echo "$out" | head -3 | tr '\n' '|')"; fi
+}
+check() { # check <description> <test command...>
+	local d="$1"; shift
+	if "$@" >/dev/null 2>&1; then report ok "$d"; else report FAIL "$d"; fi
+}
+
+# ------------------------------------------------------------------------------ an SDK source
+# Two versions of the template: this project's own SDK and settings, without its modules.
+mkdir -p "$WORK/sdks"
+for v in 1.0.0 1.0.1; do
+	d="$WORK/sdks/$v"; mkdir -p "$d"
+	cp -a "$HERE/breeze" "$HERE/project" "$HERE/CMakeLists.txt" "$HERE/CMakePresets.json" "$d/"
+	for f in .clang-format .clang-tidy .editorconfig .gitattributes .gitignore; do cp "$HERE/$f" "$d/" 2>/dev/null; done
+	echo "$v" > "$d/breeze/VERSION"
+done
+printf '\n# New in 1.0.1.\nset(PROJECT_E2E_SETTING "added")\n' >> "$WORK/sdks/1.0.1/project/Configuration.cmake"
+echo "# changed" >> "$WORK/sdks/1.0.1/.clang-format"
+
+cd "$WORK" || exit 2
+
+echo "== cli =="
+expect  "cli version prints the version" "0." "$B" cli version
+expect  "cli ls with nothing installed says so" "no versions installed" "$B" cli ls
+refuse  "no SDK source configured is explained" "breeze config sdk-source" "$B" project new Nope
+expect  "config sdk-source is stored" "$WORK/sdks" "$B" config sdk-source --set "$WORK/sdks"
+expect  "config editor round trip" "code --wait" bash -c "'$B' config editor --set 'code --wait' >/dev/null && '$B' config editor"
+
+echo "== project new =="
+expect  "project new creates the project" "created E2eProj with SDK 1.0.0" "$B" project new E2eProj --sdk 1.0.0
+refuse  "project new refuses a bad name" "not a valid project name" "$B" project new "bad name"
+refuse  "project new refuses an existing directory" "already exists" "$B" project new E2eProj
+refuse  "project new refuses an unknown SDK" "no SDK 9.9.9" "$B" project new Other --sdk 9.9.9
+cd E2eProj || exit 2
+expect  "sdk version" "1.0.0" "$B" sdk version
+expect  "project name" "E2eProj" "$B" project name
+expect  "project id defaults to the lower-case name" "e2eproj" "$B" project id
+check   "the demo code is gone, one module is there" bash -c "[ \"\$('$B' ls | wc -l)\" = 2 ]"
+
+echo "== project settings =="
+expect  "project version --set" "0.1.0 -> 3.2.1" "$B" project version --set 3.2.1
+expect  "project version reads it back" "3.2.1" "$B" project version
+refuse  "project version --set rejects junk" "not a valid project version" "$B" project version --set 1.x
+expect  "project id --set" "-> e2e_id" "$B" project id --set e2e_id
+
+echo "== modules =="
+expect  "add lib --static" "added lib module 'strings_lib'" "$B" add lib Strings --static
+expect  "add obj" "added obj module 'pieces_obj'" "$B" add obj Pieces
+expect  "add exec with deps" "added exec module 'tool_exe'" "$B" add exec Tool --deps strings_lib pieces_obj
+expect  "add test (suffix not doubled)" "'strings_test'" "$B" add test StringsTest --deps strings_lib
+expect  "add example" "'demo_example'" "$B" add example Demo --deps strings_lib
+refuse  "add lib needs --static or --shared" "--static or --shared" "$B" add lib Broken
+refuse  "add refuses a duplicate id" "already taken" "$B" add exec Other --id tool_exe
+refuse  "add refuses a dependency on an executable" "only libraries and objects" "$B" add exec Other2 --deps tool_exe
+expect  "ls lists them all" "pieces_obj" "$B" ls
+expect  "ls --obj filters" "pieces_obj" "$B" ls --obj
+expect  "ls --lib --static filters" "strings_lib" "$B" ls --lib --static
+expect  "ls --filter" "tool_exe" "$B" ls --filter tool
+expect  "deps of" "pieces_obj" "$B" deps of tool_exe
+expect  "deps on, recursive" "demo_example" "$B" deps on strings_lib --recursive
+refuse  "delete refuses while depended on" "depend" "$B" delete strings_lib --yes
+expect  "rename id and directory" "id strings_lib -> text_lib" "$B" rename strings_lib --id text_lib --name Text
+expect  "rename updated the dependents" "text_lib" "$B" deps of tool_exe
+check   "rename moved the directory" test -d source/Text
+
+echo "== build, run, defaults, clean =="
+expect  "build" "Done" "$B" build --cargs -DBUILD_TESTS=ON -DBUILD_EXAMPLES=ON
+expect  "run an executable by id with arguments" "Hello from Tool" "$B" run tool_exe -x one two
+expect  "run by directory name" "Hello from Tool" "$B" run Tool
+expect  "run a test" "Running" "$B" run strings_test
+refuse  "run without an id and several executables" "which executable" "$B" run
+expect  "defaults run --set" "default run = tool_exe" "$B" defaults run --set tool_exe
+expect  "run uses the default" "Hello from Tool" "$B" run
+expect  "defaults build mode --set" "Debug" "$B" defaults build mode --set debug
+expect  "defaults build mode reads back" "Debug" "$B" defaults build mode
+expect  "defaults file is in .breeze" "tool_exe" cat .breeze/defaults.json
+expect  "build --no-configure builds the configured directory" "ninja" bash -c "'$B' build --no-configure --bargs --verbose 2>&1 | head -50 | grep -m1 -o ninja || '$B' build --no-configure 2>&1"
+refuse  "build rejects a mode it does not know" "not a build mode" "$B" build -M fancy
+refuse  "build rejects a preset that doesn't exist" "no preset" "$B" build -P linux -A x64 -C nonexistent
+expect  "defaults build mode --set none" "<not set>" "$B" defaults build mode --set none
+expect  "clean removes the build directory" "removed out/build" "$B" clean
+check   "clean really did" test ! -d out/build
+
+echo "== sdk =="
+expect  "sdk update sees the newer version" "update available: 1.0.1" "$B" sdk update
+expect  "sdk upgrade" "SDK 1.0.0 -> 1.0.1" "$B" sdk upgrade
+expect  "sdk version after" "1.0.1" "$B" sdk version
+check   "the new setting was added to project/Configuration.cmake" grep -q PROJECT_E2E_SETTING project/Configuration.cmake
+check   "the old breeze/ was kept aside" test -d .breeze/backup/breeze-1.0.0
+check   "the scripts stayed executable" test -x breeze/scripts/build.sh
+expect  "sdk upgrade again is a no-op" "newest of its major version" "$B" sdk upgrade
+expect  "sdk migrate back" "1.0.1 -> 1.0.0" "$B" sdk migrate 1.0.0
+refuse  "sdk migrate to an unknown version" "no SDK 7.0.0" "$B" sdk migrate 7.0.0
+expect  "the project still builds after moving SDKs" "Done" "$B" build
+
+echo "== tools =="
+mkdir -p "$WORK/tool/bin"
+printf '{ "id": "echo", "version": "1.0.0", "description": "Echoes", "entry": "bin/echo.sh" }\n' > "$WORK/tool/breeze-tool.json"
+printf '#!/bin/sh\necho "echo-tool [$*] in $(basename "$PWD") project=$(basename "$BREEZE_PROJECT_ROOT")"\nexit ${ECHO_EXIT:-0}\n' > "$WORK/tool/bin/echo.sh"
+expect  "tool install from a directory" "installed echo 1.0.0" "$B" tool install "$WORK/tool"
+expect  "tool ls" "Echoes" "$B" tool ls
+expect  "tool run passes arguments, cwd and environment" "echo-tool [say hi --flag] in E2eProj project=E2eProj" "$B" tool echo say hi --flag
+expect  "tool --help goes to the tool" "echo-tool [--help]" "$B" tool echo --help
+check   "tool exit code propagates" bash -c "ECHO_EXIT=7 '$B' tool echo >/dev/null 2>&1; [ \$? = 7 ]"
+refuse  "tool install twice" "already installed" "$B" tool install "$WORK/tool"
+refuse  "unknown tool" "no tool 'ghost'" "$B" tool ghost
+expect  "tool uninstall" "uninstalled echo" "$B" tool uninstall echo
+check   "tools.json is gone with the last tool" test ! -e .breeze/tools.json
+
+echo "== cli versions =="
+cd "$WORK" || exit 2
+V="$("$B" cli version)"
+expect  "cli install (this program)" "installed $V (picked)" "$B" cli install "$V"
+mkdir -p "$WORK/releases/9.0.0"
+printf '#!/bin/sh\nif [ "$1" = cli ] && [ "$2" = version ]; then echo 9.0.0; else echo "ninety: $*"; fi\n' > "$WORK/releases/9.0.0/breeze-linux-x64"
+"$B" config cli-source --set "$WORK/releases" >/dev/null
+expect  "cli install from the CLI source" "installed 9.0.0" "$B" cli install 9.0.0
+expect  "cli ls marks the picked version" "* $V" "$B" cli ls
+expect  "cli pick" "picked 9.0.0" "$B" cli pick 9.0.0
+expect  "commands now run in the picked version" "ninety: ls" "$B" ls
+expect  "cli commands never forward" "$V" "$B" cli version
+expect  "the copy in bin/ forwards too" "ninety: build" "$BREEZE_HOME/bin/breeze" build
+expect  "cli pick back" "picked $V" "$B" cli pick "$V"
+expect  "cli uninstall" "uninstalled 9.0.0" "$B" cli uninstall 9.0.0
+refuse  "cli pick of what is not installed" "not installed" "$B" cli pick 9.0.0
+refuse  "cli install of what the source lacks" "is not in the CLI source" "$B" cli install 8.0.0
+
+echo "== legacy layout migration =="
+L="$WORK/Legacy"; mkdir -p "$L/cmake" "$L/scripts" "$L/source/App"
+printf 'cmake_minimum_required(VERSION 3.25)\nproject(Legacy VERSION 0.9.0 DESCRIPTION "An old project" LANGUAGES CXX)\nset(CMAKE_CXX_STANDARD 17)\n' > "$L/CMakeLists.txt"
+printf 'set(PROJECT_CODE_NAME "legacy" CACHE STRING "id")\n' > "$L/Configuration.cmake"
+printf '# the old template\n' > "$L/cmake/BuildHelpers.cmake"
+printf '#!/bin/sh\n' > "$L/scripts/build.sh"
+printf 'add_exe_module(app_exe)\n' > "$L/source/App/CMakeLists.txt"
+printf '#include <iostream>\nint main() { std::cout << "legacy app\\n"; }\n' > "$L/source/App/main.cpp"
+printf '# Legacy\nMy own readme.\n' > "$L/README.md"
+cd "$L" || exit 2
+expect  "a legacy project is recognised" "legacy (flat layout, unversioned)" "$B" sdk version
+expect  "its name and version are read from project()" "Legacy" "$B" project name
+refuse  "upgrade of a legacy project points at migrate" "sdk migrate" "$B" sdk upgrade
+expect  "migrate moves it to breeze/" "legacy layout -> SDK 1.0.1" "$B" sdk migrate latest
+check   "breeze/ and project/ exist" test -f breeze/cmake/Breeze.cmake -a -f project/Configuration.cmake
+check   "the old template went to the backup" test -f .breeze/backup/legacy-to-1.0.1/Configuration.cmake
+check   "the project's README stayed" grep -q "My own readme" README.md
+expect  "name carried over" "Legacy" "$B" project name
+expect  "version carried over" "0.9.0" "$B" project version
+expect  "id carried over" "legacy" "$B" project id
+check   "C++ standard carried over" grep -q 'PROJECT_CXX_STANDARD   *17' project/Configuration.cmake
+expect  "the migrated project builds" "Done" "$B" build
+expect  "and runs" "legacy app" "$B" run app_exe
+
+echo
+echo "$passed passed, $failed failed"
+exit "$failed"