Repository navigation
Tags
Tags
2026.11.18.1: a row's object format and names are data (row, system, … …format); openkal-platform 0.29.2 is the default (#951) ## The defect The engine answered a row's object format and artifact names by a branch per system (`windows`, `macos`, `linux`, `openkal`, `emscripten`), and a built-in row without a branch took the host's naming. A platform's rows were read from data. On a Windows host a FreeBSD row's program was therefore `bin/<name>.exe` and its archives `.lib`, while the NetBSD and OpenBSD rows a platform package defines built there at once. Measured in mcpp-community/mcpp-platforms#4: with the FreeBSD sysroot's revision 2 the build of `x86_64-freebsd` finished on `windows-2025` and no `bin/hello` existed. 21 rows of the snapshot answered with the host's naming (FreeBSD, bare metal, iOS). It was not seen in #949 because e2e 1116, the case about this, carried the capability `llvm`, which is a Linux one: the case never ran on the two hosts it is about. ## The change One reading for every row, built-in or a platform's (SPEC-016 v1.5; design record §12): - `object-format`, `exe-suffix` and `shared-suffix` are read in three steps, the first statement taken: the row, its system (`[[platform.system]]`), the convention of the object format (elf, mach-o, pe, coff, wasm). The engine names no system for it, and the host's naming answers only for a triple that is neither a row nor of a system the table states. - `[[platform.system]]` accepts the three keys, in the built-in table and in a platform package alike. A `[[platform.define]]` row may leave `object-format` unstated: it is its system's, then ELF. - The built-in table states what the branches expressed: `pe` on the system `windows`, `mach-o` on `macos` and on the iOS rows, `.oke`/`.okso` on the ok image rows, `.js` on `wasm32-emscripten`. The rows snapshot is identical before and after that move, and the system-name baseline falls (linux 63→62, macos 51→49, windows 72→70, emscripten 18→17, ios 24→23). - `mcpplibs.openkal-platform@0.29.2` is the default platform of the rows openkal serves: it states the hosts of each runner, so `x86_64-windows-musl` on a Windows host runs with no runner without the project stating the release. ## Tests - `tests/unit/test_artifact_naming.cpp`: a FreeBSD row and a row of each format from a bogus host; row before system before format, over a platform's definitions; a triple of a stated system that is no row. - `tests/unit/test_platform.cpp`: the manifest reads the three system keys and a row without `object-format`. - e2e 1116 runs wherever the LLVM payload is (`scan-deps`), and holds the program to the row's exact name; it needs mcpplibs/mcpp-index#818 (the platform package's entry listed Linux hosts only). - e2e 1118: a platform's system states `exe-suffix`; a row that states none takes it, a row that states its own keeps it. ## With it The FreeBSD rows link on a Windows host with the sysroot packages' revision 2 (openxlings/xim-pkgindex#1184: zlib-compressed debug sections of the crt objects and static archives, which the lld of the Windows LLVM payload does not read, are held decompressed). No change of mcpp was needed for that. ## Compatibility Published platform packages were read row by row: their PE and COFF rows state `exe-suffix`, their ELF rows state none, and the three steps give them the names they had. Two readings differ for rows no published package has: a platform's PE row without `exe-suffix` is `.exe` (was no suffix), and a platform's row without `object-format` takes its system's before ELF. Version 2026.11.18.1; CHANGELOG, SPEC-016, docs/35 and the design record state the change.
ninja 1.12.1-mcpp.1, mcpp.buildopt (BMI and object cutoff on every ho… …st, the private module fragment as a unit, the register), BSD rows off Linux hosts, workspace publishing (#949) * Design record: patched ninja for #945, the module cascade (#946), workspace publishing (#947), and part 2's remaining items (for review) * Revise the ninja, cascade and publish supplement after review (v2) * Supplement design v3: the engine-side choice for ninja#2662, one pull request per repository with checkpoint commits * The BMI cutoff holds outside UTC: a stamp is masked to its terminator, with any zone abbreviation (#946 O1) * Pin ninja 1.12.1-mcpp.1 and state how a ninja that names no step ended (#945); a runner is taken on the hosts it states; a platform selected by a layer is warned of; the engine's default openkal-platform is 0.29.1; --strict names the key itself * mcpp.bmi: the cutoff by BMI content as a package, with GCC's file format in a module of its own; a GCC BMI whose line maps alone moved is kept (bmi_cutoff, #946 O2) and a run states what changed (O6) * e2e 1110: an importer follows a GCC interface, not its clock or its line maps; 1109: a runner is taken on the hosts it states * publish: a sibling's own version, archives and descriptors by identity, --tag, the index's descriptor shape, --workspace and -p with SHA256SUMS (#947) * The exit note names no host: an NTSTATUS and a signal are told by the status's value * 2026.11.17.2: SPEC-018 (the rebuild of modules), SPEC-013 v1.12, chapters 04, 11 and 50 in both languages, CHANGELOG * Design record v4: what the implementation measured * Design record: the BSD rows' hosts, each failure read from its record * The upgrade lane admits the pinned ninja once; e2e 846 names the stand-in by its dotted number * The executor keeps the previous BMI and the previous object on every host (O7, O5); a target that parses is ELF unless it says otherwise; the scan writes a file of its own * Tests follow what they state: archives by identity, the rows openkal-platform 0.29 serves, the canary cell that passes * mcpp.buildopt: the register, keep, schedule and source in one package; a private module fragment is built as a unit of its own * buildopt: the advice of a one-file module, the fragment's e2e cases, ninja's update in one line * SPEC-019, chapters 13 and 26, the package's README, the design record v5 * A package has one command line under every workspace member: usage is carried dependencies first, feature defines by name (mcpp#945); an install says what it repaired * e2e 1116: a system's own ELF row builds on a host of any format * A unit built for a source names the source: the compile database has the file as written, and a change of it selects the tests of its units * Design record: what an upgraded home is told * xlings 2026.11.17.1: directory links on Windows (openxlings/xlings#719) * e2e 330 changes the test it expects linked again * Tests change the source they expect linked again; the record of the three passes on the real workspace * A unit built for a source answers as the source where a manifest names a file: the lib root, a feature's sources, the published interface (e2e 1117) * e2e 1112 reads the compile database's file as JSON writes it on Windows * A failed Linux shard prints the home's runtime links and what xlings did in it * xlings 2026.11.17.2: a home reached through a link is the home it was created as; e2e 237 keeps what it writes in its own home * The design record states the cold-cache failure and its two causes
2026.11.17.1: deploy entries, license files in every pack, run files,… … the index's platform column, N48 (#944) * design record: N43-N47 (UEFI Shell arguments, the DOS first stack, N9 and dist-web 0.20.0, a run's input files, the UEFI payload disk) and the layers of further target rows * design record: ecosystem gap supplement, part 2 -- the roles of a file, a run's inputs, the manifest's writing and part 1's remaining items (for review) * Design record: part 2 revised after a multi-angle review (v2) * Design record: part 2 v3, the decided points and a two-way review against the verification project * Design record: part 2 v4, N48, the FreeBSD runner, setup-mcpp, and the implementation plan with its review * Design record: part 2 v4, mark the settled sections * Design record: part 2 v5, the plan is settled and new repositories go through their first pull request * N48: a row's fixed executable suffix ends a templated name A row states exe-suffix-fixed = true when its executable suffix is part of loading its programs. A name template (a build program's artifact_name, link.exe) then decides what precedes the suffix, and the name ends in it once: artifact_name("exe", "{name}") gives app.js beside app.wasm on wasm32-emscripten, where it gave a bare app, and {name}.js gives app.js, not app.js.js. The built-in wasm32-emscripten row states it; a platform states it for its own rows. The key is read by the built-in table's generator and by the platform reader alike. Spec: targets-and-providers v1.4 (2.1). Test: e2e web 1101. * deploy: an entry is a path or a table; globs, name, and stale copies removed [runtime] deploy takes a string, which is { from = <string> }, or a { from, to, name } table, in mcpp.toml and in descriptors. from may be a glob of the engine's one dialect; a match lands under to at its path below the glob's fixed directory (a literal path's is its parent, so every existing entry lands where it did). name renames the one match. A glob matching nothing and a name over several files are refused, naming the package and the entry; a literal path may still be generated by the build. deploy_files globs expand by the same rule. The expansion runs when the build is planned and enters the graph; placed.list beside build.ninja remembers the destinations, and a copy the new graph no longer places is removed from beside the program. SPEC-004 §15 (v1.20); docs/04 in both languages; unit tests for the readers and expand_deploy_entry; e2e runtime/deploy 1102. * license_files: every pack stages each package's license files [package] license_files names a package's license and notice files as globs relative to its root; a descriptor writes the same key in its mcpp segment. Unset, the engine's default {LICENSE,LICENCE,COPYING, NOTICE}* applies. The build plan records each package of the graph with its patterns, and every pack, in every mode, stages them under share/licenses/<package>/ with the role metadata: static libraries are covered as shared ones are. A package for which nothing is found is named in the report; a declared glob that selects nothing is warned about. This replaces collect_licenses, which ran only in self-contained packs, under seven fixed names, and said nothing when it found none. That mode still looks for the default files beside the shared objects it bundles that no package declares, and names those without. SPEC-004 §15.6-7, SPEC-014 §4.5.1 (v2.6); docs/04 and docs/10 in both languages; unit tests for both readers; e2e pack/modes 1103. * run files: mcpp run --file, [test] files, and the run's working directory mcpp run --file FROM[=TO] (repeatable, dirun's spelling) and [test] files (the deploy entry grammar, with [target.'<sel>'.test] files) name the files a run finds in its working directory. With them, the program runs in run/<id>/ of the build tree, into which they are copied (never linked): mcpp run waits for the program and removes the directory; a test program's directory is shared by its split parts, removed when it passes, kept and named when it fails. The directory is prepared before the launch is composed, so --print-launch and a test's launch name a directory that holds the files. Without run files nothing changes. A runner receives them as run_files in MCPP_RUN_CLOSURE (schema 2) and in MCPP_RUNTIME_FILES beside the runtime files, which is now derived as the union: where the program has a file system of its own, its directory is its working directory. Both fast paths decline when run files are named. SPEC-002 §6.2 and §6.2.1 (v1.9), SPEC-017 B1.6 and B5 (2.4); docs/04, docs/08 and docs/09 in both languages; unit test for [test] files; e2e run/contract 1104 and test/selection 1105; 927 reads schema 2. * platform: a row the built-in table has no platform for takes the one the index lists A platform package's index entry lists the rows it serves (`platform_rows = { "x86_64-uefi", ... }`). Step 5 of the platform choice, the target table's platform column, consults the index when the built-in table has no answer: a row the engine does not know, a row a platform defines, or a `planned` row. The package is selected as a series (`<ns>.<name>@*`), so its release is chosen, locked and updated as any platform series is, and the report names the source `index`. - The project's own indices ([indices], .mcpp/) rank before the shared ones; within one rank two claims are named and the first is taken. - A row the table answers is unchanged, and every statement of the project, the machine, the environment and the command line still comes first. - The entries are scanned once per command, and only for such a row (about 0.05 s for the whole refusal over ~400 entries). - mcpp 2026.11.16.1 reads an entry carrying the field and ignores it (measured with openkal-platform's entry). Tests: e2e 1106 (unknown row, planned row, the project first, two claims, no column), PlatformSelect unit. SPEC-013 v1.11 (§3.1, §14, criterion 16), docs/35 en/zh; the openkal-platform example uses multi-line inline tables. * docs: multi-line inline tables are 2026.11.17.1+, and the changelog says so (#929) * Design record: part 2 v6, measurements and the decisions taken while implementing * 2026.11.17.1: the version and the changelog's section * Design record: part 2 is active; the .agents/docs index; the dirun test's cause * platform: a manifest's [[platform.system]] reaches the platform reader * tests: 1104's runner is declared for the host's own row; 1105 states its host file for Windows too and names its copy apart from the original on case-insensitive file systems; the design record states the dirun test's cause as found * platform: the index's column is scanned with no lock held, so a leg that holds the home's lock does not wait on another; the scan is cached per set of roots * skills: a pull request that needs the full CI is labelled ci:full before its push * platform: a row the table holds with no platform and no built-in provider of that row here (x86_64-freebsd) takes the index's platform rather than a sibling row; table_answers decides it in both places * Design record: the timeouts' cause is open; the fourth kind of row the index answers; illumos and OpenBSD findings * SPEC-013 §14: which rows an entry's platform_rows lists, and that a host's own row is never among them * test: a package's programs are planned with its dev-dependencies, as its tests are, so a shared module is not compiled again over itself; a failure naming no step shows ninja's last lines (#945) * test: the programs a test runs request no [test] features (#941 stands); the testing chapter says the programs are planned with the dev-dependencies * tests: 1104 takes the host's row from its build directory (mcpp has no --print-target) * Design record: the timeouts did not recur with the scan's lock released; i686-openkal is the planned row a set's legs scan for * run files: the run's directory is removed by the interrupt watcher too, so a request that ends mcpp leaves no run-<pid>-<n> behind * Bases: a version directory with a manifest is the package root; a base's C++ library leaves the link when another package supplies the C++ layer An OpenBSD sysroot holds only usr/ beside its mcpp.toml, and the payload resolution descended into usr/ as into an extracted tarball (payload_root, unit PmPayloadRoot). A NetBSD program built with libc++ from source (the provider's layers) still linked the base's libstdc++ through the base's ldflags (SPEC-002 §2.5, e2e 1108). * Design record: the OpenBSD package root, the image profile, and NetBSD's import std through libc++ from source * A cfg selector names the platform of a row only that platform defines The early selection read only tables keyed by the triple, so [target.'cfg(any(os = "netbsd", os = "openbsd"))'] platform was refused as an unknown target. Until a row defines the triple, a selector is answered by its words, <arch>-<os>[-<env>] (SPEC-013 §3.1, e2e 1040). * runner = true | false: an override's consent alone, { enabled = ... }; the refusal names it and the platform-wide selector A runner's statement (a platform's, a provider's) states its command; an override table may enable or disable it by a boolean (e2e 1092 G, H). * Revert the programs planned with the dev-dependencies (#945): a dev-dependency's objects reached the programs' link CI showed the change wrong: a dev-dependency that supplies main (gtest_main) was linked into the program (duplicate symbol main, e2e graph/78), and the programs' plan no longer matched mcpp build's, so the test fast path declined (e2e 1069). The programs are planned as mcpp build plans them, as before. The diagnostic for a failure that names no step stays. * Docs: runner = true | false, and a runner's statement and its consent as two layers (SPEC-013 §10, docs/41, docs/04) * Matrix: i686-linux-musl and i686-openkal are named a platform by the index's column (measured on all four hosts) * A test plan that configures a package otherwise than mcpp build builds in a directory of its own; a build program's unchanged output keeps its time (#945) The tests' configuration axis (#test=) enters the fingerprint when the tests ask a package for features ([test] features, or a dev-dependency entry that asks a package the manifest also depends on). One directory held both configurations, whose interfaces and objects are named by module and package, and each plan compiled over the other. A build program rerun when its cached answer was another configuration's rewrote its generated source with a new time. e2e 1107: one compile per configuration, none again.
2026.11.16.1: ecosystem gap supplement -- launchers, naming, build de… …pendencies, runners, test selection and features (#940) * design: the ecosystem gap supplement (2026-11-15) The record of the cross-platform port gaps, the runner model and the plan this pull request implements, with the findings made while implementing it (section 13). * m1: two build-dependency requests no version satisfies are refused by name (N29) A build dependency is a module of a build program, which the module rename does not separate. The rename was tried and failed on the requester's sources with a message about staging; the refusal now names both requesters, the merge's reason and the override line. * m2: launchers by the system table, one per program, and the program a format provider states - N20: the POSIX launcher names the system by the system table's uname column; a package that carries its runner runs only its own and exits 126 naming what it holds (POSIX and Windows). - N11: --all-programs of an ok image gives every program its own pair of launchers. - N30: mcpp::pack_program (protocol 19) states the program a pack-format provider assembles from; a provider that submits nothing has the warnings it stated in the refusal. * m3: a stated program name on every row, one linked file, resources for Windows programs - N9: the statement's program and library names are followed on a built-in row as on a platform's; the temporary link name keeps the file's extension, so DJGPP writes one file. - N16: [resources] is compiled for a PE row whose execution system is Windows, not for UEFI. * m4: execution relations, the row's exception model and companions (N23, N26, N33) - [[platform.executes]] states which architectures a machine executes besides its own; a same-arch runner is built for the artifact's architecture there, and both package launchers fall back to it. linux-x86_64 executes i686. - A planned row the platform lists with its toolchain is built as a carrier. - A row's exceptions model applies where the project states none; wasm32-emscripten states wasm, and its long jump follows. - A row's companions (.wasm beside app.js) are removed before each link and staged when written; -sSINGLE_FILE=1 links and packs without a module. - [resources] compile where the system table states resources = true, which replaces the literal system name in the resource gate. - link-output moves aside only when the edge asks (--aside). * m5: runners enabled on request, and named runners as tables (R1, X1, R2) - A runner states enabled = false when its first use fetches a machine image or an emulator, or leaves state outside the build tree and the store. run refuses it with status 2 and test leaves the tests built and not run, naming [runner-not-enabled], what it installs and how to enable it, before anything is installed. - A table without cmd in config.toml or the project adjusts the runner below it; cmd, requires and enabled are one statement; the environment's MCPP_TARGET_<TRIPLE>_RUNNER_ENABLED enables it once; --runner <name> enables the runner it names. - A named runner takes the default runner's table and merge rule; longlived is a key of the table; a provider's runner states host and enabled. - The MinGW providers state Wine on linux-x86_64, same-arch, not enabled. * m6, m7: a runner as one statement in a build program, and the program a runner names (R2, N21, N27) - mcpp::runner_spec states a runner as the table of data (protocol 19): .arg(), .require(), .hosts(), host, longlived, exclusive, enabled; one runner-spec payload, refused when not a runner or when the name is also stated by the token calls. {pkg:<name>} names a program outside a package's bin/, its package in requires. - docs/30 and docs/41 state one lookup rule: name the program; requires, then the graph's payloads, then PATH, never the current directory. - On Windows a name with a directory and no suffix takes the system's suffixes; a script the system starts through its command interpreter (the system table's command-scripts, .bat and .cmd) is refused an argument holding the interpreter's syntax. - docs/04 states the order of the flag lists (measured); docs/24 states the terminal under node (measured: a terminal read fails with EIO). - The directive unit tests name protocol 19; the agents index is regenerated; design records N38 for review. * m9: the guide reads the resolved graph, a group's programs are planned together, a missing source named by its path is refused (#932, #936, #938) - mcpp test --guide reads the test frameworks from the resolved graph (resolve_graph: the phases of prepare_build up to the graph) and plans, scans and builds nothing; several members are resolved by configuration group and their frameworks united (collect_test_frameworks, shared with the plan). - mcpp test over several members plans a group's programs together, as mcpp build --workspace does; a member is planned alone only to attribute a failure. A shared module was compiled three times a run before. - A sources entry without a pattern that names no file is a scan error naming the table that states it. - Design record 13.4 (analysis) and 13.5 (N39, for review); docs 04, 08; e2e 1094, 1095, 1096. * m8: x86_64-linux-android runs in the Android Emulator on request (G7) - The android-ndk provider is two entries, one per architecture; the x86_64 one states a runner: dirun with the API 34 system image package's profile, the emulator and adb from their packages, same-arch, exclusive, not enabled by default. The aarch64 row states none: the emulator package serves no aarch64 machine. - A provider's runner states exclusive (generator, schema, statement). - e2e 653 (case and script): with no table the row's exception model (N26) catches; exceptions = false aborts at the throw and refuses a dependency that requires exceptions. - Unit: the Android row's runner data. Docs 41, SPEC-016 1.3, design. * 2026.11.16.1: a named system where no single file is made is refused before the build; design notes for op, N17 and N40 - single_file_unmade: the one reading of a named system before the build and of --systems all (a row this mcpp builds no program for, or a carrier where the platform's runner does not exist). A planned row the platform serves is built since N23, so a named --systems macos for an x86_64 image passed the pre-build check and was refused after the build (e2e 956 on macOS). - e2e sets 986: the pair without a carrier is said with its row. - Version 2026.11.16.1; CHANGELOG section. - Design record: op scope (runners that boot a machine enabled on request, hosted rows' runners as full providers), N17 located (openkal-dos#3), N40 for review. * #938: a missing source named by its path is refused in an editable tree and warned of in a fetched package The scanner states the entries (unnamed_sources) and the prepare step decides their weight by whose tree the package is, the line state.editablePackage draws for a dependency's lints: a published package's tarball cannot be changed by its consumer, and refusing it would refuse a release that built before. e2e 1097 asserts the fetched side. * design: X3 located and fixed in the musl recipe * A link holds a permit of the build's compiler limit, and a POSIX link is published by one command Under bmi_schedule = "on" with GCC ninja runs six jobs per compiler and the generation's semaphore bounded only the compilers, so every link a build reached at once ran at once: mcpp's 26 test programs relinked together at 1 to 1.8 GB each and the 16 GB CI runner ran out of memory (unit-linux-archive, on every commit of this branch). A link now takes a permit of the same semaphore; the graph still names no number (e2e 861). The permit's transaction judges its output when the held command exits, so the permit wraps the whole publication: a POSIX link is published through a temporary name by mcpp link-output --temporary rather than a shell sequence whose rename followed the linker, which recovery took for an uncommitted output and removed. The tests are built by the pinned bootstrap, which predates this: ci-unit builds the archive with bmi_schedule off for a bootstrap older than 2026.11.16.1, whose ordinary job count bounds links. Measured from main's restored test build at MCPP_JOBS=4: the bootstrap ran up to 7 links at once in 539 s, this engine at most 4 in 360 s. * design: N41, mcpp's bundled xlings moves to 2026.11.16.1 (for review) * The bundled xlings is 2026.11.16.1 On Windows it replaces a SubOS description and the other state files while another process reads them; this branch's Windows e2e failed on exactly that (sources/100: Failed to write file: ...\.xlings.json, xlings#715). A shim starts its program without cmd.exe, so an argument holding ", &, % or ^ reaches it whole. Between 2026.10.26.1 and 2026.11.16.1 xlings has three commits (#716, #717, #718); the interface mcpp calls is unchanged. * A package's tests are selected by target and built with the features [test] features names (#942, #941) [target.'<sel>'.test] discover adds globs to [test] discover for the targets the predicate selects, as a conditional [build] sources adds sources; a ! glob removes tests there. It holds discover alone: the other [test] keys shape the test build rather than add to its inputs. The tests are discovered before dependencies resolve, so a predicate on a target-side layer is refused. The evaluation is an implementation unit of mcpp.build.test_targets: with the evaluator in the interface, GCC 16.1 failed internally at main.cpp's import of mcpp.cli. [test] features is the request of the package's tests, a consumer of it: resolved in a test plan alone, on the root's request for one package and on the member's own edge in a workspace, so mcpp build, the programs the tests run and every other consumer keep the defaults. An undeclared feature is refused at load, as --features refuses it. The unchanged-tests fast path compares the request with them. Unit: Manifest/TestFeaturesNameDeclaredFeatures, Manifest/AConditionalTestTableCarriesDiscoverAlone; e2e 1098, 1099, 1100. * e2e: an inherited home's subos is the case's own copy, its links kept Linked whole, the user's subos was state shared between the cases of a run: on a CI runner whose home was cold (the xlings version is in the sandbox cache key), a case beside llvm/36 installed into the user's home, and llvm/36's glibc configuration found lib/Scrt1.o in its subos unrecorded and refused it as user-owned; a case's installs also wrote into the user's subos. The subos is copied with its links kept (about 1600 links on a developer's home), in the support library and in _inherit_toolchain.sh alike, as the package directories already were. * e2e: a case installs no toolchain into the shared home; a process that ends while read is skipped commands/231 named llvm@23.1.3 in the user's home: on a cold home it installed llvm there while llvm/36, beside it, inherited the half-made payload and its own glibc install refused the inherited sysroot links. The leg now measures an llvm the home holds, as 671 does. processes() read /proc/<pid>/cmdline of a process that ended meanwhile; the read fails with ESRCH and libstdc++ throws. Such a process is skipped. * e2e: llvm's payload check requires the file; a missing file's permissions are every bit executable() read only the owner-exec bit of fs::status, and a missing file has perms::unknown, every bit set: llvm/36 ran on a home without llvm, installed it in its inherited home, and glibc refused the inherited sysroot links. Reproduced with a home holding only gcc; the check now asks for a regular file, as the other cases' helpers do.
2026.11.15.1: CI time cost — main's test build reused, the tests at p… …rofile ci, a long case divided while it pays (mtest 0.9.0), the matrix scan side by side; the built-in platform openkal-platform 0.28.0 (#937) * 2026.11.15.1: a long case divided by the cases it declared; the tests built with profile ci; main's test build reused; the matrix scan side by side; a cancelled run releases its group * mtest 0.9.0: the tests of this package and the scaffold of mcpp new, so a long case is divided by the cases it declares * test: the concurrent-children rounds compare warm starts; a program's first start on a fresh Windows runner outlasted the slow child * An install for a project takes the home's state turn: it saves the home's environment too, and collided on Windows with another project's install * A host tool built by two builds of one home is published by both; the legacy code-page check runs the tests as the job built them (profile ci) * A case is divided only while its division measured shorter: parts record the case they divide, the store keeps the case whole and its longest part On CI the two e2e suites' cases share what the first fills; each part paid it again (sets 1375 s whole, 909/1109/1306 s as three parts). Design 6.3 records the measurements. * design 6.3: main's first run after the merge measures the division once * The built-in platform is openkal-platform 0.28.0: the group on openkal 0.25.3 and the 32-bit, UEFI and DOS rows The e2e case of the default platform reads the engine's pin from its data; the target-row snapshot and the matrix's runtime cells follow the group. * A polyglot pack of every system leaves out the systems the file is not started on (uefi, dos); one touch helper for the e2e cases, past the present
2026.11.14.1: MCPP_TARGET_SDK; a planned row served by the chosen pla… …tform; Windows runner lookup; test discovery skips a package below tests/; release publishes GitHub, index PR, then optional GitCode (#935) * 2026.11.14.1: the SDK a link names, and a release that publishes without GitCode A build program reads MCPP_TARGET_SDK, the Apple SDK the link names with -isysroot (empty when it names none), from the same function as the link line. A package that supplies a libSystem stub for a link without an SDK asks this instead of MCPP_TARGET_REQUESTED, which on a Mac with --target said the SDK was absent while the link carried it. The release mirrors GitHub, then opens the xim-pkgindex pull request from the sealed mcpp-release.json (index_pr.py, with the updater's marker), and mirrors GitCode last and only when dispatched with `gitcode`. bump_index.sh is removed. Design: .agents/docs/2026-11-14-release-publication-and-macos-sdk-design.md * A runner's bare name on Windows is the program with the system's suffix, never the launcher beside it * A planned row is served by the chosen platform whose statement lists it with a toolchain * Test discovery leaves out a directory below the package root that holds its own mcpp.toml
2026.11.13.1: toolchain payloads as data, build directories by lineag… …e, UEFI through openkal, test feedback (mcpp#927), end-to-end cases in C++ with places and capabilities (mtest 0.8.0), canaries (#930) * wip: a row's GCC payload as data (gcc-triple); the COFF object format * tests/support and the first C++ end-to-end case; mtest 0.7.1 tests/support (mcpp.test.support) is the support of the end-to-end cases (design 2026-11-12 §5.9): a project as a table of files, mcpp run with the shared home or a fresh one, the readings of a file's lines, a JSON document and an executable's header (ELF, PE, Mach-O) made by this process. A case file imports mcpplibs.mtest itself, which begins it at mtest's entry. tests/e2e/basics holds 02 (new, build, run) as the first case. mtest 0.7.1 is the dev-dependency and the engine CI pins; the unit suite holds under it (169 programs, 2627 cases). * e2e: the migration inventory of the 752 scripts and the keep baseline tests/e2e/MIGRATION.tsv gives each script its subsystem (25 directory-style names), its class (sink, merge, keep; design 2026-11-12 §5.9) and its planned destination: e2e/<subsystem> for a merged case, unit/<file> for a sunk one, keep for a script that stays. Assigned from each script's name, header and the commands it runs. merge 707, sink 12, keep 33. tests/e2e/keep.tsv is the baseline of the keep class (emulators, a physical device, upgrades and machine-state homes, CI-only and measurement legs); it may only shrink. * e2e: the test subsystem as C++ cases (38 scripts) The 38 scripts MIGRATION.tsv assigns to `test` (mcpp test: discovery, selection, reports, the JSON stream, timeouts, workspaces, --no-run and archives, the launch description, the mtest protocol, the store, the fast path) are 39 cases of the program e2e/test (tests/e2e/test/*.cpp, 12 files, one process each). Each case is named by its script's sentence and keeps its number; its `# requires:` words are its tags, and a case skips with "missing capability: <word>" where the machine lacks one. The scripts are removed and MIGRATION.tsv names each one's case. Scripts: 15 16 17 18 72 78 90 94 152 153 154 155 157 158 159 160 164 178 213 673 745 854 855 856 865 989 993 1026 1034 1035 1037 1038 1050 1052 1065 1068 1069 1070. Old run (the scripts, against this branch's mcpp, Linux x86_64, gcc and llvm in ~/.mcpp): 37 passed, 1 skipped (94 requires macos; started directly it exits 0 on Linux, its otool leg being conditional). Sequential time 227 s. New run (`mcpp test e2e/test`): 38 passed, 0 failed, 1 skipped (94, missing capability: macos). 72 s of runs, 12 programs at once. tests/support gains: has(word) and needs({...}) (run_all.sh's capability probes; an unknown word fails the case), on_path, glob (a shell's `*` per component), has_line/no_line (grep -E per line), lacks, contains_nocase, count_lines, ninja_log_outputs, mcpp_command (a mcpp for an e2e::session) and project::scaffold (`mcpp new` in the case's directory). Every assertion is kept. Where a reading changed: - 159: `grep -qv '"test":"01-b/0"'` held for any line without the record; the case asserts what it meant, that no line has it (stronger). - 989: the evidence the script printed after a failure (file, xattr, codesign) is a diagnostic, not an assertion; not carried over. - 1070 O8: the script compared the output after the shell had stripped its trailing newline; the case accepts the text with or without it. - 993 is two cases: A-E, and the named-runner leg, which keeps `requires:python3` because its runner is a Python program. - python3 (993 A-E, 1026, 1035, 1037, 1050, 1065, 1070) read JSON for the scripts; the cases read it with nlohmann::json and no longer require it. - 90: its `requires: gcc` stood on line 8, which run_all.sh does not read, so it ran on every host; the case does not require gcc either. - 1052 sourced _toolchain_env.sh without using it; dropped. - 178 and 1068 drive concurrent mcpp processes through e2e::session instead of `&`, a fifo and kill. 1026 still unpacks with tar, 1038 still uses git, 94 still reads otool. * e2e: the build-program subsystem as C++ cases (66 scripts) The 66 scripts MIGRATION.tsv assigns to `build-program` (build.mcpp: its directives and protocol, its environment and cache, dependencies' programs, host tools and host modules, build plugins and the build programs' graph, accelerator requests and the probe channel, payload overrides) are 66 cases of the program e2e/build-program (tests/e2e/build-program/*.cpp, 6 files: accel, cross, deps, graph, hosttools, protocol). Each case is named by its script's sentence and keeps its number; its `# requires:` words are its tags. Scripts: 58 89 92 110 111 112 125 139 143 144 145 168 181 186 187 189 193 194 309 310 311 312 334 600 605 612 617 618 622 624 625 626 632 633 651 665 683 693 698 712 720 775 779 800 802 804 823 824 826 831 859 873 874 877 902 903 904 905 906 908 910 958 997 1011 1036 1051. 168 and 804 keep their scripts: ci-aarch64-fresh-install.yml runs them by path. The other 64 are removed. Old run (the scripts, against this branch's mcpp, Linux x86_64): 65 passed, 1 failed (779). New run (`mcpp test e2e/build-program`): 65 passed, 1 failed (779), 0 skipped. 779 fails on this host in both runs for one reason outside mcpp: it builds its plugin with the `gcc` PATH names, here an xlings subos gcc whose shared objects record NEEDED libc.so (the linker script), which the loader cannot load; /usr/bin/gcc records none. Under the script the plugin built and `mcpp run` failed loading it; under `mcpp test` PATH names another subos gcc that does not find crti.o. tests/support gains: home kinds `linked` (the case's home with the shared registry linked, as `ln -s ~/.mcpp/registry`), `inherited` (_inherit_toolchain.sh) and `payloads` (the same without config and subos), made under the system's temporary directory (glibc refuses an install directory over 255 bytes, which a case's own directory exceeds); case_home, shared_home, newest_payload, payload_root, family_version (and llvm_version, gcc_version, musl_gcc_version, mingw_cross_version: _toolchain_env.sh), repository, listing, newest_file, write_executable, run, has_line_nocase, last_line, last_starting, count_matching. Every assertion is kept. Where a reading changed: - `mcpp run 2>&1 | tail -1` is read as the last line of the program's standard output (the shell's interleaving put the program's line last). - 168: `file`'s "statically linked" and readelf's interpreter are read from the ELF header: no PT_INTERP and no DT_NEEDED. - 802: readelf's NEEDED is read from the header; 804: the .comment strings are read from the file's bytes (`clang version <llvm version>`, `GCC: (...) 16.1.0`), the llvm version being the one _toolchain_env.sh chooses (23.1.3 here, the literal the script grepped). - 310: `strings -a` and `nm -C` become the file's bytes and `nm -C` when PATH has it. - 720, 877, 903: python3 read JSON for the scripts; the cases read it with nlohmann::json and no longer require python3. 1011 required python3 and did not use it; the case does not require it. - 600, 605, 612, 626, 1036 and the other `mcpp new` fixtures keep `mcpp new`; fixtures the scripts wrote whole are written whole. - 698's Windows long-path reading runs powershell where the script did. * e2e: the deps subsystem as C++ cases (49 scripts) The 49 merge scripts MIGRATION.tsv assigns to `deps` (path, git and index dependencies, how a dependency is named and resolved, mcpp.lock, tool packages a graph declares twice, floors a dependency states, patches and `embed`, entry targets, the advice an edge states) are 49 cases of the program e2e/deps (tests/e2e/deps/*.cpp, 12 files: advice, edges, entry, floors, git, graph, identity, lock, names, path, resolve, tools). Each case is named by its script's sentence and keeps its number; its `# requires:` words are its tags. Scripts: 09 12 24 27 31 32 33 61 62 63 79 161 162 163 165 196 203 326 603 627 628 629 661 679 682 713 816 821 822 844 939 943 944 945 946 948 980 990 1001 1002 1018 1027 1032 1046 1048 1060 1066 1071 1074. No workflow runs any of them by path; all 49 are removed. 23_remove_update.sh is a sink row and stays for the sink step. Old run (the scripts, against this branch's mcpp, Linux x86_64): 49 passed. New run (`mcpp test e2e/deps`): 49 passed, 0 failed, 0 skipped. Every assertion is kept. Where a reading changed: - python3 read JSON or rewrote a lock for 679, 682, 844, 1002, 1027 and 1071; the cases do it in C++ (nlohmann::json, the FNV-1a digest, the lock entry's lines) and 844, 939 (which did not use it) and 1071 no longer require python3. 844's os.utime is std::filesystem::last_write_time. - 628 read `mcpp why toolchain --format json` with jq only when jq was on PATH; the case always reads it. - `ls -1 <store> | wc -l` (627) counts the store's own entries; `touch -d '30 days ago'` (945) sets the time 30 days back. - 822 took its own release from `mcpp --version | awk '{print $2}'`, the case from the second word of that line. - 816's `LC_ALL=C grep $'\r'` and `$'\x1b'` are byte searches of the output. - 713 skips when git is missing, as the script did (exit 77); the other git cases skip the same way. - Diagnostics the scripts printed on failure (`<(find ...)`, `diff`) are not kept; the failing comparison shows both sides instead. - Homes the scripts made with `MCPP_HOME=$TMP/home` (627, 628, 629) are fresh case homes; `_inherit_toolchain.sh` homes are `home::inherited`. docs/specs and docs/06 still name 163, 603, 627, 628 and 679 as the tests of their rules; this change does not touch docs/. * e2e: the actions subsystem as C++ cases (37 scripts) The 37 scripts MIGRATION.tsv assigns to `actions` (actions a build program declares and their roles, checks and their stamps, `prepare`, generated files, device sources and the actions that consume them, rule packages, project build hooks, what an action writes and reads, action progress) are 37 cases of the program e2e/actions (tests/e2e/actions/*.cpp, 10 files: checks, commands, declared, devices, generated, hooks, outputs, prepare, progress, rules). Each case is named by its script's sentence and keeps its number; its `# requires:` words are its tags. Scripts: 51 107 124 142 188 313 314 315 317 606 607 608 609 610 611 613 619 623 630 631 648 659 660 780 790 791 792 793 798 799 808 827 896 897 982 1013 1015. No workflow runs any of them by path; all 37 are removed. Old run (the scripts, against this branch's mcpp, Linux x86_64): 36 passed, 1 failed (790). New run (`mcpp test e2e/actions`): 36 passed, 1 failed (790), 0 skipped. 790 fails on this host in both runs for the reason 779 does (batch 2): its install.sh links a shared library with the `gcc` PATH names, an xlings subos gcc whose objects record NEEDED libc.so, a linker script the loader cannot load ("invalid ELF header" when the program runs, under the script); under `mcpp test` PATH names a subos gcc that does not find crti.o. tests/support gains archive_members and archive_symbols: an `ar` archive's members and its symbol index, read by this process (System V/GNU and BSD). Every assertion is kept. Where a reading changed: - 608's `ar t` and `nm` are read from the archive (its members and its symbol index); the script read nm only when PATH had it. - 606 read `mcpp why toolchain --format json` with jq; 808, 897 and 982 read JSON with python3 without requiring it. The cases use nlohmann::json. - 896's mtime in nanoseconds (python3) and 142/188/660's `stat %Y` are std::filesystem::last_write_time; 827's `find -newer <ref>` compares the destination's time with the one it had. - 1013 and 1015 keep their Python drivers: the actions they declare run Python workers, and 1013 drives the build through a terminal and a process group. Each case writes its script's driver unchanged and runs python3 on it; both keep requiring python3. - 317's Ctrl-C leg sends SIGINT through `sh -c` as the script did (Unix only, as before). - 659's `type -P true` is the `true` PATH names; 799's `pwd -P` is the canonical path. - `mcpp run 2>&1 | grep '^X=' | tail -1` is the last such line of the program's standard output. * e2e: the features subsystem as C++ cases (37 scripts) The 37 scripts MIGRATION.tsv assigns to `features` (feature activation, the --strict schema gate, feature defines and their propagation, capabilities and their providers, feature-deps, target-conditional configuration, feature-gated sources, default features and forwarding, layer predicates) are 37 cases of the program e2e/features (tests/e2e/features/*.cpp, 5 files: activation, conditional, defaults, layers, sources). Each case is named by its script's sentence and keeps its number; its `# requires:` words are its tags. Scripts: 67 71 80 81 82 83 85 86 100 106 108 119 126 127 128 138 146 149 195 247 308 328 601 615 637 654 677 710 711 714 739 813 895 1007 1012 1019 1045. No workflow runs any of them by path; all 37 are removed. Old run (the scripts, against this branch's mcpp, Linux x86_64): 37 passed. New run (`mcpp test e2e/features`): 37 passed, 0 failed, 0 skipped. Every assertion is kept. Where a reading changed: - python3 and jq readings of JSON are nlohmann::json. - 108 reads the host architecture from the compiler's predefined macros instead of `uname -m`. - 739's shell glob over the whole failed build (`*"sdk.h"*"No such file"*`) is the same search: "sdk.h", then one of the three phrases after it. - 813's `grep -rl` over the home's std-module records reads the records in sorted order, so "the first record holding the flag" is one record on every run (the script took find's order). - sed's line edits (1012, 711, 813) are the same edits on the manifest text; a fixture line an edit needs and does not find fails the case. * e2e: the pack subsystem as C++ cases (37 scripts) The 37 scripts MIGRATION.tsv assigns to `pack` (the packing modes and the closures they carry, library packages and the gate a prebuilt package keeps, formats a package provides, the report and the axes of a package, packs over workspace members) are 37 cases of the program e2e/pack (tests/e2e/pack/*.cpp, 4 files: formats, library, members, modes). Each case is named by its script's sentence and keeps its number; its `# requires:` words are its tags. Scripts: 30 215 216 242 243 244 245 249 250 251 252 253 254 261 264 265 638 649 652 662 669 689 722 723 801 828 829 841 867 868 869 870 871 954 1008 1043 1061. No workflow runs any of them by path; all 37 are removed. Old run (the scripts, against this branch's mcpp, Linux x86_64): 36 passed, 1 failed (669). New run (`mcpp test e2e/pack`): 36 passed, 1 failed (669), 0 skipped. 669 fails on this host in both runs at the step 779 and 790 fail at (batches 2 and 4): it links a prebuilt library with the `g++` PATH names. Under the script that is an xlings subos g++ whose library records NEEDED libc.so, so the pack refuses it; under `mcpp test` the subos g++ does not find crti.o. tests/support gains readers for what the scripts asked of binutils, tar, zip and python3: ELF sections and symbol tables (defined or all), DT_SONAME and whether a search path is DT_RPATH or DT_RUNPATH; a tar archive's members and their extraction (by the machine's tar); a zip's central directory; SHA-256. Every assertion is kept. Where a reading changed: - `file`, readelf, nm and the scripts' python3 ELF readers (read_tag, has_symtab, elf_facts) are read from the files by these readers; 243's `ar t` is read from the archive (the script read it when ar worked). - python3 readings of JSON (723, 841, 869, 870, 954) are nlohmann::json; 954's tarfile/zipfile/hashlib readings are tar's member list, the zip central directory and SHA-256. - 871 compares compile intervals on the .ninja_log's absolute clock (each edge ends at its output's recorded mtime and begins its duration earlier), allowing 50 ms for the write that precedes a compiler's exit. `mcpp test` runs ninja twice (the program, then the tests) and each run appends with its own relative clock, so the script's comparison of the relative columns paired edges of different runs; on this host its awk compared them as strings and found nothing either way. Two compiles run at once here overlap by about 300 ms. - `find | head -1` is the first path in sorted order. - sed edits of a manifest (244's abi tag, 828, 1043, 1061) are the same edits on its text; 244's runs per line, as sed's does. - `cp -r` copies (638) keep links as links. * e2e: the build subsystem as C++ cases (45 scripts) The 45 scripts MIGRATION.tsv assigns to `build` (a new project built and run, incremental rebuilds, libraries, convention mode, C and assembly sources, profiles, package-owned and per-target flags, include directories, response files and link inputs, the C driver, link flags as written, paths with spaces or no UTF-8 spelling, serial and concurrent plans) are 45 cases of the program e2e/build (tests/e2e/build/*.cpp, 4 files: basics, flags, link, sources). Each case is named by its script's sentence and keeps its number; its `# requires:` words are its tags. Scripts: 02 04 07 08 25 26 50 54 68 70 73 87 104 105 109 115 116 117 123 141 148 179 190 191 238 246 316 620 765 776 777 795 861 882 894 907 909 929 938 991 1003 1006 1047 1054 1062. No workflow runs any of them by path; all 45 are removed. Old run (the scripts, against this branch's mcpp, Linux x86_64): 45 passed. New run (`mcpp test e2e/build`): 45 passed, 0 failed, 0 skipped (907 passed on its rerun after a fixture edit in the case was corrected). Every assertion is kept. Where a reading changed: - `file`, readelf, nm (238's `nm -D --defined-only`), `ar t` (07) and `strings -a` (929) are read from the files by tests/support's readers; 929's `strings` is the printable runs of four or more bytes, as strings prints them. - python3 readings of JSON (765, 894) are nlohmann::json; 148's python3 fixture generators are C++ that writes the same files. - `sleep 1; touch f` (04, 104) moves the file's time two seconds on. - 938 starts the program from a thread of the case while it relinks, as the script did from a background subshell. - `find | head -1` is the first path in sorted order. * cfg: interface, the kernel-abi layer's provided interfaces A layer key answered by membership in the resolved kernel-abi provider's [kernel-abi] provides-interfaces, as accelerator is a set. A provider that states no list provides every interface; a graph without the layer provides none. A package selects its sources by what the implementation beneath it provides and names no implementation. The provider lookup is one function, shared with the requires-interfaces check. * design: toolchain payloads as data (section 16) * design: gcc 16.2.0 and the 17 trunk snapshot (section 16.4) * toolchain: payloads as data, and any package of the index as a toolchain Which package a family's toolchain is for a target on a host is the [[toolchain.payload]] table of data/builtin.toml (name, aliases, family, serves, hosts with exclusion, frontend directory and names, builds-for, glibc-fixup, family-version), and [[toolchain.offer]] what a host is offered. mcpp.toolchain.payloads reads both directions: to_xim_package, identify_xim_payload, available_toolchain_indexes and the payload names normalize_spec accepts. No payload is named in compat, and registry names none. xim:<name>@<version> accepts any package: it is installed and resolved as path:<root> with the table its .mcpp-toolchain.json states (schema 2: family, prefix, sysroot, tools, each inside the payload); the family is the descriptor's or its C++ driver's. check_payload_names.py counts the table's payload names in the sources against a baseline, as check_system_names.py counts systems; the refactor lowers the system-name baseline. * docs: the payload table, a family's versions and trunk snapshots, any package as a toolchain * design: workspace concurrency, the build directory named by its lineage, and its size (section 17) * build directory named by its lineage; lock wait in Finished; split debug in clean --report; debug = "lines" A configuration's build directory is named by its lineage (compiler family, target, standard library family, standard, configuration flags). The evolving parts (mcpp, compiler build, standard library version, runtime contract) are recorded inside it. An upgrade keeps every path the commands name, so ninja compiles only what the release changed. Before, the directory took the whole fingerprint's name, and its takeover changed every member's commands. A compiler build that differs empties the directory in place. Finished states the time spent waiting for a build directory. clean --report gives split debug information its own column. [profile] debug = "lines" keeps the line tables alone (-g1). Design 2026-11-12 section 17. * the graph runs mcpp through the build directory's link to it A build directory's graph names mcpp as engine/epoch-<N>/mcpp, a hard link (else a copy) the planner makes the running engine under the directory's lock. mcpp's own path holds its version under xlings, and every command that ran it -- the capped compile, BMI comparison, link wrapping, staging, module bindings -- changed with each release. Measured on a two-member workspace, an engine that differs in its version alone: 18 of 153 objects and BMIs compiled again before, none after. The link's path carries kCacheEpoch. Fast-path admission accepts a link to this engine; a self-contained home is stated for the programs mcpp starts, since it cannot be derived from the link's place. In-flight compiler records are dropped when another engine wrote them. * tests: the build directory's lineage, its engine link and an upgrade that compiles nothing e2e 1000 gains G-I: the directory named by its lineage and recording the fingerprint, the graph running mcpp through engine/epoch-<N>/mcpp, the same mcpp from another path compiling nothing, and a compiler change emptying the directory in place. 878 states that the program a graph runs is the engine that wrote it. 960 and the accel cases read the new configuration-change warning. unit/test_graph_engine covers the link. * design: workspace test feedback, mcpp#927 (section 18) * e2e: the cli subsystem as C++ cases (17 scripts) The 17 scripts MIGRATION.tsv assigns to `cli` and that migrate here (--help and --version, the error paths of a manifest and a source, usage errors kept off standard output, the exit-code contract, --jobs and the `--` boundary, --toolchain on run, test and pack, package templates and a transactional scaffold, a build's output and status streams, a terminal's status row, the control contract, and mcpp under signals) are 17 cases of the program e2e/cli (tests/e2e/cli/*.cpp, 5 files: commands, output, signals, templates, terminal). Each case is named by its script's sentence and keeps its number; its `# requires:` words are its tags, and 936's `# resources: machine` its resource. Scripts: 01 05 48 69 202 204 231 329 340 671 842 843 864 866 936 941 1016. No workflow runs any of them by path; all 17 are removed. 845 (--play-game restores the terminal) is kept as a script: its case finds the prepare action alive three seconds after a Ctrl-C ended mcpp, which criterion G3 forbids, while the script's own G3 check compares a directory name with pgrep's list of pids and cannot fail. MIGRATION.tsv records it; it waits for the engine owner. Old run (the 18 scripts, against this branch's mcpp, Linux x86_64): 18 passed. New run (`mcpp test e2e/cli`): 17 passed, 0 failed, 0 skipped. tests/support gains `process`: a program held by its pid, signalled alone, whose standard streams are a pseudo-terminal, one pipe for both streams, a file, /dev/null or a pipe whose reader has ended, and which starts with every signal at its default; `processes()` reads /proc; `strip_escapes` removes CSI sequences. Every assertion is kept. Where a reading changed: - `2>&1 | cat` and `2>&1 | tee` (864, 866) are both standard streams of mcpp on one pipe of `process`; the shell's `&`, `kill` and `wait` (340, 936 H, 1016) and Python's subprocess with `restore_signals` (941) are `process`; 941 B's `returncode == -SIGPIPE` is the signal `process` reports. - Python's pseudo-terminals (843, 866 D) are `process` with a terminal; 843's screen model is C++ with the same rules (carriage return, line feed, CSI A, J, K), over the code points of the UTF-8 the terminal received. - 842 R5's Python timer reads the pipe in 50 ms steps and takes the time at which the `error: build failed` line first appears and at which mcpp ends. - python3 readings of JSON (866 B, 936) are nlohmann::json; 936's `normcase(normpath(...))` comparisons are `lexically_normal` path comparisons, which do not fold case on Windows. - 69's `sed | grep -oE '"targets":[...]'` is a regular expression over the log after `\"` is unescaped; 01's awk reading of mcpp.toml is a regular expression. - `sleep 1; touch mark; find -newer mark` (231) is the clock's time taken after a second's wait, compared with each object's write time. - 05's build with no manifest runs in a directory outside the repository, and 202 runs in a project of its own: a case's directory lies inside the repository, whose mcpp.toml mcpp would find, and `mcpp pack --pkg-format bogus` builds the project it finds before it refuses the value (the script, run from tests/e2e, built the repository). * e2e: the modules subsystem as C++ cases (30 scripts) The 30 scripts MIGRATION.tsv assigns to `modules` (several modules and partitions built and run, the p1689 scanner and ninja's dyndep, module units in .cpp files, transitive and indirect imports, the std module compiled once, what the scanner reads, `[build] module_extensions` and the lib root that follows it, BMIs and their cache and staging, the split schedule, and modules across programs, members and homes) are 30 cases of the program e2e/modules (tests/e2e/modules/*.cpp, 5 files: basics, bmi, extensions, programs, scanner). Each case is named by its script's sentence and keeps its number; its `# requires:` words are its tags, and the `# resources: machine` of 170, 234 and 1039 their resource. Scripts: 03 19 20 21 49 113 118 167 170 171 217 218 234 236 260 263 634 635 636 639 807 847 849 857 858 898 924 940 1039 1064. No workflow runs any of them by path; all 30 are removed. Old run (the scripts, against this branch's mcpp, Linux x86_64): 29 passed, 1 failed. 218 fails on its reading alone: it looks for the graph in `target/*/<fingerprint>/build.ninja`, and the build directory is named by the configuration's lineage since this branch's engine (2da705cd); with that one line reading the lineage instead, the script passes. New run (`mcpp test e2e/modules`): 30 passed, 0 failed, 0 skipped. tests/support gains `another_home` (a further home of a case, for a script that exported MCPP_HOME again) and `file_identity` (`stat -c '%i %Y %s'`). Every assertion is kept. Where a reading changed: - 218 finds the graph in the directory `--print-fingerprint` names as `Lineage:`; its assertion that module_extensions leaves the fingerprint unchanged is kept. - python3 readings (924's module maps, 1039's newest std-module record, 49's entry.json) are C++ and nlohmann::json; 234's inline replay check is C++ (write times and tests/support's sha256), and its sections 6, 8 and 9 run tests/e2e/helpers' Python checks as the script did. - 1039's two background builds are two threads of the case, each running mcpp. 1039 is a case of bmi beside 170 and 171: it removes the shared home's std entry they stage from, and its `machine` resource keeps them apart only within one program (in another program, 171 found the entry gone); 858's `export MCPP_HOME` to a second and a third home is `another_home`. - 171's `stat -c '%i %Y %s'` is `file_identity`, `chmod 444` is a permission change, `cmp` a comparison of the bytes, and its Windows holder the same PowerShell command run as an `e2e::session`; 170's `cmp` likewise. - `touch` of an existing file (170, 171, 234, 858) sets its write time to now; `sleep 1; touch marker; find -newer marker` (218, 847) is the clock's time taken before a second's wait, compared with the file's write time. - `ls -d target/x86_64-linux-*/` and `./target/*/*/bin/app` (20, 21, 849) are globs; `[ -d "$LLVM_ROOT" ]` (118, 217) is the llvm payload's directory; 635's `head -c 3 | od` compares the first three bytes; 639's `printf '%b'` sources are C++ string literals. - The commands that name no project (858's cache commands, 171's `mcpp stage`) run in a directory outside the repository, as the scripts' did: a case's directory lies inside the repository, whose mcpp.toml mcpp would find. * a toolchain named with --toolchain opts a planned row in The planned refusal says no toolchain is published for the row; a build that names one on the command line has one, as a build whose [target.<row>] section names one does. MCPP_TOOLCHAIN, a standing preference, does not opt in. A platform's conformance run (openkal-platform's i686-linux-musl row) named its toolchain with --toolchain and was refused. * the planned opt-in counts MCPP_TOOLCHAIN; a carrier reads its row's object format and suffix --toolchain is stated as MCPP_TOOLCHAIN, so the two are one statement and both opt a planned row in. The carrier of a system a platform defines took its section directive and program suffix from the system's name: a PE row such as x86_64-uefi was assembled as ELF and named without .efi. Both now come from the row (Triple::object_format, artifact_naming). * cenv answers by the row's container; cfg(object-format = ...) selects by it * tests: case directories under the system's temporary directory A case made its files in mtest::temp_dir(), which `mcpp test` places under the repository's target/ (test-protocol/<run>/<case>). mcpp run there in a directory with no manifest of its own found the repository's mcpp.toml above it and built the repository: one such run took over the released engine's build directory. tests/support gains `case_dir()`: the directory of the case under the system's temporary directory (`mcpp-e2e-case-XXXXXXXX`), made on first use. `project` and `project::scaffold` make their files there, and the cases of the earlier subsystems use it in place of mtest::temp_dir() (222 uses in 54 files; no case depended on the old location). The case's homes and its directory are filed under the runner's directory of the case, which mtest removes when the case ends: a directory whose case has ended is removed at the next use of the support, and the rest when the program ends. * e2e: the cache subsystem as C++ cases (22 scripts) The 22 scripts MIGRATION.tsv assigns to `cache` (the global build cache across projects and keyed by what an entry was compiled against, its modes and maintenance commands, an entry's layout and a hit's std BMI, the fast path and what it compares, a configuration's build directory over time, `clean --stale` and `clean --report`, the sweeps by age and by budget, and what a build writes once) are 22 cases of the program e2e/cache (tests/e2e/cache/*.cpp, 3 files: entries, fastpath, directories). Each case is named by its script's sentence and keeps its number; its `# requires:` words are its tags. No script declared a resource. Scripts: 172 173 174 184 212 324 609 645 832 878 879 935 959 998 999 1000 1005 1022 1028 1029 1030 1031. No workflow runs any of them by path; all 22 are removed. Old run (the scripts, against this branch's mcpp, Linux x86_64): 20 passed, 2 failed. 174 fails on an engine defect of this branch: `mcpp build --cache=off` empties the build directory after the plan made its link to the engine (`engine/epoch-<N>/mcpp`, design 2026-11-12 §17), and every step then fails with "not found" (a project, `mcpp build`, then `mcpp build --cache=off`). 832 failed once with a SIGSEGV of mcpp in nlohmann's lexer while resolving the toolchain in the shared home, during a concurrent run; it passed when run again. New run (`mcpp test e2e/cache`): 22 passed (21 ok, 174 an expected failure), 0 failed, 0 skipped. 174 carries `known_gap{"build --cache=off removes the engine link the graph runs", "2026-12-15"}`: every assertion is kept, the run reports it as xfail, and from 2026-12-16 it is judged as any case. Every assertion is kept. Where a reading changed: - python3 readings (174's `cache list --json` and entry.json, 935's result record, 998's programs.json) are nlohmann::json; 174's strip of the `[build] cache` override writes the manifest without it; 1029's os.utime walk sets the write times of the entry's files and directories. - `touch -d '<n> days ago'` and `touch -t 200001010000` (609, 1000, 1005, 998) set write times; 1000's `find -mtime -1` compares the write time with a day ago; 174's `touch -d @1000` sets the time 1000 s after the epoch. - `sleep` is a wait of the case; 935's two background builds are a thread of the case and the case itself, each running mcpp. - 878's and 1000's engine at another path is the program under test copied there and started by its path with the same environment; 878's `grep -v '^engine='` and awk rewrite of `$mcpp`, and 879's awk ageing of `depSources=`, are line rewrites of the record and the graph. - `ar t` (998) is `archive_members`; `stat -c %i` (998) is the inode of `file_identity`; `readelf -S` (998, 999), `readelf --debug-dump` (173) and `gdb` (999) run as the scripts ran them, where the machine has them; git (1028) likewise. - 1022's `cp -a` is a copy of the tree that keeps its links and its write times; 1031's `cp -R` is a recursive copy. - 645's "NOT MEASURED" exit 0 when an unchanged second build is not replayed is a skip naming the recorded request; its machine-default leg without a second installed version ends the case as passed, as the script's exit 0 did. 324's NOTE (the warm build not replayed) printed and asserted nothing, and is left out. - 1029's cache commands, which name no project, run in the case's directory, outside the repository. * a defined row states its link emulation without its machine; design: UEFI converges into openkal (section 19) * design: the measured UEFI result and the interface-selected optional interfaces (section 19) * a provider states the link, base and runner of its identities over either base * a runner named by the environment replaces the requirements of the one it replaces * build: make the graph's engine link again after a cold build clears the directory A cold build (--cache off, --no-cache) removed the output directory after the plan had named its link to the engine, so every step of the graph failed on a mcpp that was not there. The link is made again where the link spec is regenerated. Where the running engine's file was replaced while it ran, the link is copied from the running image. * e2e: cache 174 is judged as any case again `build --cache off` makes the graph's engine link again after the cold build clears the build directory (ac9fba36), so 174 no longer carries `known_gap{"build --cache=off removes the engine link the graph runs", "2026-12-15"}`; its MIGRATION.tsv row drops the gap's note. Every assertion is unchanged. Run (this branch's mcpp, Linux x86_64): - `mcpp test e2e/cache`: 22 passed (174 an ordinary pass), 0 failed, 0 skipped. - `mcpp test e2e/features`: 37 passed, 0 failed, 0 skipped; 739, which failed on the same defect, passes. * e2e: the workspace subsystem as C++ cases (25 scripts) The 25 scripts MIGRATION.tsv assigns to `workspace` (the members a command takes, what a member inherits from its workspace at every position of the graph and however it was fetched, where a workspace's statements are written and what they reach, and the workspace as one graph per configuration) are 25 cases of the program e2e/workspace (tests/e2e/workspace/*.cpp, 4 files: members, inheritance, statements, graph). Each case is named by its script's sentence and keeps its number; its `# requires:` words are its tags. No script declared a resource. Scripts: 35 122 321 770 772 773 774 805 806 833 834 836 839 850 851 852 853 860 872 880 885 893 900 911 912. No workflow runs any of them by path; all 25 are removed. Old run (the scripts, against this branch's mcpp, Linux x86_64): 25 passed, 0 failed, 0 skipped. New run (`mcpp test e2e/workspace`): 25 passed, 0 failed, 0 skipped. tests/support gains `cdb_arguments` (the words of a compile database's entry for a file: its `arguments`, else its `command` split), which 321, 770, 774, 805 and 893 read and the cdb subsystem will. Every assertion is kept. Where a reading changed: - python3 readings of compile_commands.json (321's entry_of, 770's count and before, 774's and 805's checks, 893's release entry) are `cdb_arguments`; 872's comparison of two build databases and its argument-file check are nlohmann::json. 900's tomllib reading of the archived manifest runs as the script ran it (python3 -I), the support having no TOML reader. - 805's `ls xim-x-gcc | sort -V | tail -1` of the case's inherited home is `newest_payload("xim-x-gcc")`, the shared home's newest gcc, which the inherited home links. - `tar -xzf -O` (772, 900) is an extraction into the case's directory and a read; `cmp` and `sha256sum` (772) compare bytes and `sha256`. - `.ninja_log` readings (833's grep -c and tail -n +N, 851's and 852's awk, 872's compiles_after, 912's count) are `ninja_log_outputs`, counted from the number of outputs recorded before; 860's start and end columns are the log's rows read whole. - `find target -mindepth 2 -maxdepth 2 -type d ! -name '.*'` (833) is a glob of `*/*` kept to directories; `find -path '*/bin/*' -name` (850, 872, 880, 893) is the first file of that name under a `bin` directory; 872's newest release `.ninja_log` is the graph directory beside the dev one. - 834's wall time measured by a python3 wrapper is the outcome's duration. - 885's awk extraction of a ninja build statement and its indented lines is a line walk of build.ninja; its `gsub(...) > 1` per line is a count per line. - 880's and 885's home with `[xlings] home` naming the shared registry is a fresh home of the case holding that config.toml. - `sleep 1.1` (833) is a wait of the case; `touch` (839) sets the write time to now; 850's and 880's `sed` rewrites of a manifest are string rewrites. - 772's released client ($MCPP_BOOT) runs when the variable names a released mcpp other than this one, as the script's did; otherwise that leg is left out, as the script's SKIP line printed and asserted nothing. * e2e: the run subsystem as C++ cases (19 scripts) The 19 scripts MIGRATION.tsv assigns to `run` (the environment `run` and `test` give a program, the runner of a target and its named and feature-chosen runners, what `run` hands back of the program, and what a runner receives) are 19 cases of the program e2e/run (tests/e2e/run/*.cpp, 4 files: environment, runners, program, contract). Each case is named by its script's sentence and keeps its number; its `# requires:` words are its tags. No script declared a resource; 927 carries `resource{"machine"}`, since it appends to the shared home's config.toml for one run and restores it, and it is the only case of the subsystem that needs the machine. Scripts: 62 65 74 114 156 166 330 333 337 339 656 672 674 684 862 863 883 927 1024. No workflow runs any of them by path; all 19 are removed. Old run (the scripts, against this branch's mcpp, Linux x86_64): 18 passed, 1 failed. 62 fails on this machine's host `gcc` (the xlings shim, gcc 16.1.0 built from source): the plugin it links with `gcc -shared` records DT_NEEDED `libc.so` (the linker script's name), so the program's dlopen() reaches the private glibc's `libc.so` and fails with "invalid ELF header"; the case fails the same way. An environment failure, not an engine one. New run (`mcpp test e2e/run`): 18 passed, 1 failed (62, as above), 0 skipped. Every assertion is kept. Where a reading changed: - `ls target | head -1` (330, 339, 656, 672, 674) is the first entry of target/ whose name does not start with a dot, as `ls` lists them. - python3 readings (333's launch description and SBOM, 1024's descriptions, record rewrite and NDJSON stream) are nlohmann::json. - 883's drive.py (pty.fork) is `process` on a pseudo-terminal of a new session; its subprocess return codes of a signal death (negative in Python) are the shell status and the signal `process` reports; its check that the terminated program is gone (`os.kill(pid, 0)`) is the absence of /proc/<pid>; the piped run is the command's input. - `dd ... seek=18 conv=notrunc` and `od -j18 -N2` (330) write and read the two bytes at offset 18; `chmod -x` / `+x` (863) remove and restore the execute permissions; `file`'s interpreter (74) is the ELF header's PT_INTERP; `realpath` (62) is the canonical path. - `cmp` of captured streams (862) compares the outcome's standard output and standard error with the program's own; `head -c`, `tail -c`, `tail -n 2` and the line after `Running` are string prefixes, suffixes and the following line. - `sed -i` rewrites of a manifest or a lock (330, 333, 339, 674) write the rewritten text, or the text kept before the append; 337's `awk` of `features=` in .build_cache is the last such line, the record holding one. - `uname -m` (684, 927) runs as the scripts ran it; 927's PATH prefix and RECORD are the run's environment; 166's look at `$HOME/.mcpp` is kept. - `touch` (114, 330) sets the write time to now; `sleep 1.1` (114) is a wait of the case; `$TMP/runner.log` truncation (330) truncates the file. * e2e: the cdb subsystem as C++ cases, first part (8 scripts) Eight of the scripts MIGRATION.tsv assigns to `cdb` (the root compile database a build writes and when, `build --configure-only`, and `emit build-database`'s S1 document) are 8 cases of the program e2e/cdb (tests/e2e/cdb/*.cpp, 3 files: root, configure, emit). Each case is named by its script's sentence and keeps its number; its `# requires:` words are its tags. No script declared a resource. The other 15 scripts of the subsystem are still scripts: 11 to follow, and 783 784 785 786, which ci-linux-e2e.yml's llvm step runs by path and holds to the lines they print. Scripts: 47 76 77 211 688 781 782 937. No workflow runs any of them by path; all 8 are removed. Old run (the 23 scripts of the subsystem, against this branch's mcpp, Linux x86_64): 23 passed, 0 failed, 0 skipped. New run (`mcpp test e2e/cdb`): 8 passed, 0 failed, 0 skipped. Every assertion is kept. Where a reading changed: - jq (47) and python3 readings of the databases and envelopes (76, 211, 688) are nlohmann::json; 47's skip when jq is absent is gone, the reading needing nothing of the machine. 688's schema check runs tests/e2e/_json_schema_subset.py with python3 -I, as the script ran it. - 688's tree_digest (os.walk and hashlib) is the case's listing of the tree and `sha256` of each file; its WORK_DIR (the planning pass's directory) is removed by the case, as the script's trap removed it; its cold home is the case's inherited home; `cp -R` is a recursive copy. - 781's `touch .before-build2; sleep 1; find -newer` is the clock's time taken before a second's wait, compared with each graph's write time; `diff` and `cmp` (781, 937) compare the files' text. - 937's `grep -v '^compile_commands = '` rewrite leaves `[build]` without the key, as the script's did; `unset MCPP_COMPILE_COMMANDS` removes the variable from each run. - `touch` (782, 937) sets the write time to now; `printf >>` appends. * e2e: the cdb subsystem as C++ cases, second part (11 scripts; 4 kept) The other scripts MIGRATION.tsv assigns to `cdb` (what `emit build-database` describes when planning fails or defers, the words of a flag, what a rule generates, the private work directory, the sets of a workspace's database and of the build programs, and what emit watches) are 11 further cases of the program e2e/cdb, now 19 cases in 5 files (root, configure, emit, planning, sets). Each case is named by its script's sentence and keeps its number; its `# requires:` words are its tags. No script declared a resource. Scripts: 731 736 787 788 789 809 815 817 840 913 921. No workflow runs any of them by path; all 11 are removed. Kept: 783 784 785 786. ci-linux-e2e.yml's llvm step ("Compile database e2e that needs llvm") runs each by path and holds it to the lines it prints, since no e2e shard has llvm; they move when that step runs the e2e/cdb cases instead. MIGRATION.tsv marks them `keep` with that reason, and keep.tsv lists them. Old run (the 23 scripts of the subsystem, against this branch's mcpp, Linux x86_64): 23 passed, 0 failed, 0 skipped. New run (`mcpp test e2e/cdb`): 19 passed, 0 failed, 0 skipped. Every assertion is kept. Where a reading changed: - python3 readings of envelopes, databases and compile_commands.json (736, 787, 788, 789, 809, 815, 817, 840's check.py and root.py, 913, 921) are nlohmann::json and `cdb_arguments`; 736's walk of every list of strings is a recursive walk of the document. - 817's tree_digest is the case's listing and `sha256`; its config.toml rewrite (`grep -v '^binary' | sed '/^\[xlings\]/d'`, then [xlings] binary) is the same line filter; its xlings stub is written as the script wrote it. - 921's os.utime(ns=10**18) sets that time on each host lock through the file clock; the comparison of time and text is kept. - 913's `find -maxdepth 2` is a relative depth of at most two; its realpath comparison is `weakly_canonical`. - 731's pipeline (`mcpp emit ... | { readlink /proc/self/fd/0; cat; }`) runs as the script's shell ran it, by `sh -c`: the reader's pipe is a property of that pipeline. - `touch` (736) sets the write time to now; `printf >>` appends. * e2e: the cdb subsystem as C++ cases, third part (4 scripts; the llvm step runs the cases) The four scripts kept for ci-linux-e2e.yml's llvm step (one database per configuration, the database replayed from its directory, a module interface's language, and the std unit with its emit agreement, provides and build-id) are 4 cases of the program e2e/cdb, in a new suite `toolchains` (tests/e2e/cdb/toolchains.cpp); e2e/cdb is now 23 cases in 6 files. Each case is named by its script's sentence and keeps its number. No script declared a resource. Scripts: 783 784 785 786, all removed. MIGRATION.tsv marks them merged; keep.tsv no longer lists them. The hermetic job's step "Compile database e2e that needs llvm" now runs `"$MCPP_BOOT" test e2e/cdb --case toolchains` with the PATH it set before and the llvm the job installed before, and holds the run to the `ok` line of each of the four cases and to "4 passed, 0 failed, 0 skipped": a skip or a failure fails the step, as a missing PASS line did. The bootstrap drives the test so that the test build reuses the step "Build PR mcpp from source"; the mcpp under test is that build's binary (MCPP_BIN_MCPP). The step no longer installs python3, which no case reads with. This step is unverified in CI. Old run (783-786, against this branch's mcpp, Linux x86_64): 4 passed, 0 failed, 0 skipped. New run (`mcpp test e2e/cdb`): 23 passed, 0 failed, 0 skipped (`--case toolchains`: 4 passed). Every assertion is kept; the lines the step required are each a case's assertions. Where a reading changed: - The capability words: 783 and 784 declared `gcc`, which the probe reads as g++ on PATH; they run no g++ of the PATH but the home's gcc@16.1.0 toolchain, and the hermetic container that runs them has no g++ on PATH (it ran them by path, where the word was not read). 786 declared `python3`, which only its readings used. The four cases require `llvm`. - python3 readings of compile_commands.json and of the S1 document are nlohmann::json; 784's and 785's subprocess replays of an entry's arguments in its directory are `e2e::run` with that argv and directory; 784's commonpath test is a relative path from the canonical project that does not leave it. - 786's `list(ide.toolchains.values())[0]` is the first toolchain in the document's key order, the document having one. * e2e: the index subsystem as C++ cases (34 scripts) The 34 scripts MIGRATION.tsv assigns to `index` (what the index commands state and the [indices] forms, a project's local path index and a home's own index, the routes an index takes into a build, when an index is refreshed and what a failed resolution says, and what a project asks of xlings) are 34 cases of the program e2e/index (tests/e2e/index/*.cpp, 5 files: listing, local, routes, refresh, xlings). Each case is named by its script's sentence and keeps its number; its `# requires:` words are its tags. 614 declared `resources: machine` and carries resource{"machine"}; it is the one case of the subsystem that does, and mtest serialises that resource only within one test program, which `mcpp test e2e/index` runs per file. Scripts: 06 11 22 42 43 44 52 53 60 75 76 93 120 121 147 169 173 185 192 210 327 331 335 614 730 732 733 734 735 737 803 812 949 1067. No workflow runs any of them by path (two workflow comments name 53); all 34 are removed. The index 173 is this subsystem's; the cache 173 was migrated before. Sinks: MIGRATION.tsv marked 06, 42, 43, 44 and 93 to sink into unit tests (test_emit_xpkg, test_indices, test_lockfile, test_xpkg_parse). No earlier batch sank a script into a unit, and each of the five asserts a command's output or file effect (`emit xpkg` and its --output, `index list`, `index pin` and `index unpin` rewriting mcpp.toml, `xpkg parse` and its --json and --format json), which the unit layer reaches only through the parsers. They are e2e cases of e2e/index::listing; their rows say so. Old run (the 34 scripts, against this branch's mcpp, Linux x86_64): 34 passed, 0 failed, 0 skipped. New run (`mcpp test e2e/index`): 34 passed, 0 failed, 0 skipped. Every assertion is kept, including those on files a script wrote itself (43's and 44's lockfiles). Where a reading changed: - python3 readings (93's parse documents, 733's effects and codes, 735's first diagnostic, 803's FNV-1a of the declared address) are nlohmann::json and a 64-bit FNV-1a loop; 733's `grep -w` stays a word match over each effect and each code. - `touch -d '30 days ago'` (173, 949) sets the write time thirty days back. - Line rewrites keep their filters: 733's, 734's and 812's config.toml (`grep -v '^binary'`, `sed '/^\[xlings\]/d'`, 734 also `^auto_refresh` and `^\[index\]$`, then [xlings] binary), 22's repo line, 169's and 735's dependency lines. The xlings stubs (52, 60, 732, 733, 734, 812) are written as the scripts wrote them; 812's unquoted heredoc is its text with the index directory substituted. - 732's background mcpp and `kill -TERM` are a process of the case and its signal; `kill -0` runs by `sh -c`; `bounded 60` is the command's 60 s timeout; `date +%s` is the steady clock. - 185's `grep -A 4 "<first 40 characters of the last error>"` reads those characters as a fixed string (grep read them as a basic expression) and looks at each match and the four lines after it. - `find` counts and searches (120's build.ninja outside .build-mcpp, 147's accel_*.o, 737's ld-linux-* loaders) are the case's directory walks and globs; 614's `ls | sort -V -r` orders the versions by numeric components. - 737's `mv a b` into an existing directory b keeps that meaning (the second shaping moves the payload into the first one's directory). - 22's cold home and its inherited home are two homes of the case (the script inherited into the cold one after its checks); `cache dir` is compared with the second. 52's fake registry links the shared home's payloads and 803's home links the shared home's registry, where the scripts named $HOME/.mcpp. - 1067's `cmp -s` is a byte comparison and its `grep borrower` looks for the borrowing home's directory name. - Skips: 730's SKIP (exit 77, no compat descriptor) and 614's SKIP lines (which exited 0 and passed) are skips of the case naming the same reason. - 06's lua check runs where lua is on PATH, as the script's did; 22's git runs as the script ran it. * e2e: the self subsystem as C++ cases (17 scripts) The 17 scripts MIGRATION.tsv assigns to `self` to merge (a home's configuration and its index migration, a project's xlings environment, a SubOS without its description, the doctor offline, [index.repos.<name>] in an existing home, the shell's active SubOS, the vendored xlings, a home selection, the doctor's resource checks, a SubOS selection that is root-local, a suggested command's quoting, and a home at a spaced or non-ASCII path) are 17 cases of the program e2e/self (tests/e2e/self/*.cpp, 4 files: config, subos, machine, homes). Each case is named by its script's sentence and keeps its number; its `# requires:` words are its tags. 205 and 931 declared `resources: machine`; they carry resource{"machine"} and are the two cases of machine.cpp, since mtest serialises that resource only within one test program and `mcpp test e2e/self` runs each file as one. Scripts: 10 38 39 46 88 151 205 221 237 604 681 686 687 919 920 931 932, all removed, with tests/e2e/_home_selection.py and _doctor_network.py, which only 919 and 920 ran. No workflow runs any of them by path. Kept (unchanged, keep.tsv): 27 30 846 914 915 916 917 918, machine state and upgrades of a home, as MIGRATION.tsv states. tests/support gains `local_server` and `connection`: a TCP server on 127.0.0.1 at a port the system chooses, each connection handled on its own thread (POSIX; constructing one on Windows fails the case). 920 uses it for the HTTP resource that refuses, stalls and trickles and for the TLS peer that refuses the handshake, which _doctor_network.py served with http.server and socketserver. Old run (the 17 scripts, against this branch's mcpp, Linux x86_64, with MCPP_HOME=~/.mcpp and MCPP_VENDORED_XLINGS set as the e2e job sets them): 17 passed, 0 failed, 0 skipped. New run (`mcpp test e2e/self`): 17 passed, 0 failed, 0 skipped. Every assertion is kept. Where a reading changed: - 919's and 920's Python programs are the cases themselves: subprocess runs are `e2e::run` with the same environment, working directory and timeouts; 919's four concurrent writers are processes of the case; Path.resolve() is weakly_canonical; json readings are nlohmann::json. 919's write-fault leg keeps its two branches (Windows: a read-only locator; POSIX: a 0500 origin, and no proof where the account bypasses directory permissions). - 920's provider is the first of MCPP_NETWORK_PROVIDER, MCPP_VENDORED_XLINGS and XLINGS_BIN that names a file, else the shared home's registry/bin/xlings; without one the case skips naming them (the script raised KeyError, and on a machine whose XLINGS_BIN names the xlings bin directory it failed to start that directory). On Windows the case skips: its oracle is the POSIX server. - python3 readings (151's entry checks, 237's runtime and rewritten description, 681's entry_url, same_json and re.sub rewrites) are nlohmann::json and std::regex with the same patterns. - `cmp -s` (151, 681) is a byte comparison; `cp -R` (205) is a recursive copy keeping links; `ln -s` makes links; `mkdir` of an empty directory (221) is made by writing and removing a file in it. - 205's field11 (`sed -n 's/^[[:space:]]*\[11\][[:space:]]*//p' | tail -1`) is the last such line; 931's `eval` of the suggested command runs it by `bash -c` with the program under test in place of `mcpp`. - 687's MCPP_INHERIT_CONFIG=0 is the inherited home with its copied config.toml removed; its `PATH=/usr/bin:/bin command -v xlings` is a look for xlings in those two directories; `env -u` removes the variable. - 237's MCPP_HOME_REAL default is $HOME/.mcpp, as the script's; 88's and 205's $MCPP_HOME is the shared home. - The python3 word stays a tag and a requirement of 151, 919 and 920, as the scripts declared it. * a compiler without C++ modules refuses the graph's C++ sources before the first compile GCC before 14 has neither -fmodules nor P1689 scanning (-fdeps-format), through which every C++ unit is built; DJGPP's GCC 12.2.0 failed at the first scan with four unrecognised options. The capability now follows the version, and prepare refuses a graph with C++ units on such a compiler, naming it, the first C++ source and the remedy. C units build as before. * an interrupt asks each program to end before ending its unit; waits poll with the lock free Ctrl-C ended ninja's unit outright, which does not reach the commands ninja starts in process groups of their own, and an action outlived mcpp (e2e 845). Each program is now asked to end (terminate), given up to 2 s, and what still runs is then ended with its unit. The waits of a started program poll with the wait lock released between polls: a blocking or timed wait held it, and the request to end the program, which takes it, waited behind the program (an __action-stamp ignored SIGTERM for as long as its action ran). Measured: an interrupted build leaves no action running. * test programs by package, the test summary by segment, an index reader that waits, the size of a directory left beside (mcpp#927) - [test] programs = "package": the files a package discovers are one program, named by the first glob's fixed directory; "directory" notes the files it leaves as programs of their own, and a setting that changes no program is a degradation --strict refuses (2026-11-12 §18 P1). - The test summary states plan, programs, build and run, adding up to the total (§18 P2). - A process that skips the index refresh another holds, and has no index, waits for that refresh instead of reading none (§18 P3). - The configuration-changed warning gives the size of the directory left beside and the command that drops it (§18 P6). * cli: mcpplibs.cmdline 0.0.4; actions return their status and the run dispatches at any depth The adaptation 0.0.1 required is gone: a wrapper that captured each action's status through a shared local, and a dispatch table in each parent command (emit, xpkg, cache, index, self). Each subcommand states its own action; a parent named without a subcommand is answered by cmdline (the subcommands, on standard error, status 2). * design: implementation record for 2026.11.13.1 (§15.3, §18.3, §19.3) * docs: test programs by package, the test summary by segment, the size of a test build; CHANGELOG 2026.11.13.1 * release: 2026.11.13.1 * build: the engine link reads a replaced image where procfs presents it, without naming a system; system-names baseline shrinks * canaries: tests/canary (c, cxx), the matrix with its measured expectations, the nightly workflow (design 2026-11-12 §5.7) * AGENTS.md: the canaries and their matrix * spec test B1.2: programs = "package", and the note of "directory" * test parts named by their path below the program's directory; a test program's other files take part in the object census A package's program holds files of several directories: tests/b.cpp and tests/unit/b.cpp were two parts named tests/b and two compile edges of obj/b.cpp.ddi, which ninja refused. A part is named by its file's path below the common directory of the program's files (the stem in a program of one directory, as before), recorded for the fast path and the archive; the census that disambiguates object paths counts a test program's other files. Unit test: a GCC's modules by its version. * docs: a package's parts by their path; design record * e2e: test programs by package and the note of directory (1081, 1082), the size of a directory left beside (1083), a command without its subcommand, the summary by segment * run: a program that ends during an interrupt ends its unit with it The request asks each program to end and ends the units of those still running after two seconds; a program that ended within them was no longer live, and what it had started in its unit outlived mcpp (the shared compiler cap's cancellation check: the compiler under the driver stayed alive). * e2e: the openkal subsystem as C++ cases (45 scripts; 6 kept beside their cases) The 45 scripts MIGRATION.tsv assigns to `openkal` (the openkal stack as packages, the target side's layers, the target base, ok images, platform packages, target sets and the legs of a pack, and the packages of images) are 45 cases of the program e2e/openkal (tests/e2e/openkal/*.cpp, 8 files: stack, layers, bases, images, machine, platforms, sets, trees). Each case is named by its script's sentence and keeps its number; its `# requires:` words are its tags (1033 declared none and has none). 951 declared `resources: machine`; it carries resource{"machine"} and is the case of machine.cpp. Files: stack 269 285 286 287 289 1073; layers 305 743 950 994 1056 1059; bases 925 926 930; images 942 947 953 960 996 1009 1033; machine 951; platforms 952 1020 1021 1025 1040 1049 1057; sets 963 964 983 984 985 986 987; trees 955 956 957 961 962 992 995 1078. Removed (39): 269 305 743 925 926 930 942 947 950 951 952 953 955 956 957 960 961 962 963 964 983 984 985 986 987 994 995 996 1009 1020 1021 1025 1040 1049 1056 1057 1059 1073 1078, and tests/e2e/_sysroot_fixture.sh, which only 925 and 930 sourced. Kept beside their cases (6), as batch 2 kept 168 and 804: 285 287 289 (openkal-cross.yml runs them by path and holds them to their lines), 286 (openkal-cross.yml, ci-aarch64-fresh-install.yml and .github/tools/check_published_arm64_cn_ecosystem.sh run it by path), 992 (cross-build-test.yml runs it by path for its wine leg) and 1033 (host-requirements.tsv requires its result on linux, macos and windows, and check_e2e_coverage.py reads that from the scripts' reports). They go when those steps run the cases. MIGRATION.tsv says so in their rows. No workflow, doc or coverage list names a removed script. Old run (the 45 scripts, against this branch's mcpp, Linux x86_64, with MCPP_HOME=~/.mcpp and MCPP_VENDORED_XLINGS set as the e2e job sets them): 43 passed, 2 failed, 0 skipped. 287 failed on this machine's PATH llvm-nm, an xlings shim that cannot load libz.so.1 (with it off PATH the script passes). 925 failed at S2: "the stated base reused the default output directory". New run (`mcpp test e2e/openkal`, suite by suite): 44 passed, 1 failed, 0 skipped. 925 fails at the same assertion; with S2's and S4's directory assertions made non-fatal, those two are the only checks of its 36 that fail. Since 2026.11.13.1 a build directory is named by its lineage and the base is part of the runtime contract, which evolves: a stated sysroot, and a sysroot rewritten in place, take over the default base's directory. The assertions are kept. Every assertion is kept. Where a reading changed: - `file -b` readings (286, 287, 289, 1073) are the header read here: "statically linked" is no interpreter and no needed library, "LSB executable" is ET_EXEC, "PE32+" a wide PE; 1073's "FreeBSD" is EI_OSABI 9 or a FreeBSD note. readelf -l/-d/-h (286, 925, 926, 930, 1040, 1057) are the interpreter, RUNPATH, needed libraries and class from that header; 996's `readelf -S | grep ' C '` is SHF_COMPRESSED read from the section headers; 947's `readelf -h` entry is e_entry, its symbol address still the llvm payload's llvm-nm. - nm (287, 950) is the symbol tables read here; 287 no longer depends on the nm on PATH. 287's objdump is the one the script chose. - python3 and jq readings (305, 942, 951, 952, 953, 955-964, 983-987, 994, 1025) are nlohmann::json, std::regex and the header reader; 994's subprocess compiles are `e2e::run` in the case directory; 1025's re.sub is the first match replaced; 957's and 985's tarfile readings are the machine's tar; 957's zipfile reading of contents is `python3 -I -m zipfile -e` (python3 is its declared word). - 925's make_glibc_sysroot (_sysroot_fixture.sh) is the case's function with the same layout and linker-script rewrite; `touch -d '2001-01-01'` sets that local time; the S3 sed rewrites each __GLIBC_MINOR__ line. Its machine-default leg appends [target.x86_64-linux-gnu] to the case's inherited home's config.toml, where the script appended to the shared home's and restored it. - 1009's MCPP_HOME and 1020's and 1021's _inherit_toolchain.sh homes are the case's fresh and inherited homes. - `env -i HOME PATH=/usr/bin:/bin` runs the launcher by env -i; `cmp`/cksum (942, 951) compare bytes; `grep -A<n>` (951, 1021) looks at the line and the n after it; `tail -c` (952) reads the file's last bytes; 992's dd of one byte writes the copy with that byte changed, and its trap's chmod -R u+w is the case's guard (956 has it too). - `uname -m`/`uname -s` are the build's architecture and system; a script's SKIP (exit 77) is a skip of the case with the same reason; 285's guard SKIP lines (one exited 0) are skips; its guards keep the script's whole-text order (`*"kernel-abi"*"graph"*`); 289 skips when no row built. * a compiler without C++ modules builds the C++ units that need none A GCC before 14 (DJGPP's 12.2.0) has neither -fmodules nor P1689. Its units that declare and import no module are compiled as translation units without module flags, from mcpp's own scan; th…
2026.11.12.1: system facts as data, one arrangement per provider entr… …y, a base package's single reading, runners as provider statements (#924) mcpp 2026.11.12.1 (design record: .agents/docs/2026-11-12-ecosystem-architecture-optimization-design.md). - A provider entry states one arrangement: `glibc-sysroot` serves aarch64-linux-gnu on linux-x86_64 from the base package xim:aarch64-linux-gnu-sysroot (revision 3); the request aarch64-linux is answered as before on every host. - The link model is rendered, not inferred again; a base package has one reading; a dynamic artifact this machine does not load names the row's loader and carries no RUNPATH of this machine. - System facts are data: [[platform.system]], provider `system-headers`, `tier` and `runner`, platform `runner.built-as`, row `loader` and `execution`; the engine's sources name fewer systems (ratchet in CI). - A provider's runner is the lowest tier of the runner statement; its `requires` are installed on the first run. - A program of another system with no runner is built, not run (exit 2), before anything is started. - `[target.<sel>.abi] longjmp`. - MSVC ABI with clang: the C line states the C library model and the C standard as two words. - mcpplibs.mwrap.xz 5.8.3.1: `mcpp pack --compress xz` no longer faults on Windows. - The openkal targets' platform is openkal-platform 0.27.1. - Tests: a script that does not apply exits 77 and is a skip (mtest 0.6.2); the coverage check has `owed`. Six scripts that ran on no runner run again (13, 28, 31, 650, 653, 657). Pull request: #924 (its body holds the self-review).
2026.11.10.2: FreeBSD's musl identity; cfg barewords from the rows; #918 ; MSVC's C library is ucrt; the test fast path names the host (#920) * The compiler witness asks again for a record Windows refuses; the matrix scan reports supervision lines * test: a test of an unchanged project that this host cannot execute names the host's target * prepare_inputs: the bareword vocabulary precedes the comment of unknown_tokens * A platform refused for a row names the rows its providers serve * Matrix: the FreeBSD musl rows and the 0.26.0 version group * README: the FreeBSD musl rows are preview * CHANGELOG and design record: barewords, #918, the chosen platform * A platform chosen for a request serves it, by whichever selector chose it * A namespace's package may be named version, path, git or workspace (#918) * cfg barewords are the rows' systems, and a row states its family * Design notes: K9 and the I1 correction in the implementation record * 2026.11.10.2: FreeBSD's musl identity over openkal-platform 0.26.0 * The MSVC payload's C library is ucrt, as the MinGW payload's is Co-authored-by: speak-agent <248744407+speak-agent@users.noreply.github.com>
2026.11.10.1: base packages, Windows GNU-ABI from every host, FreeBSD… … rows, foreign packing, test records for any framework; mcpp#911 N1–N8, #913, #902, #917 (#916) * E2, E13, E14: an entry per program's flags; the kernel-abi provider's interfaces for build programs; layer suppliers may not require one another in a circle * E1: rows a platform defines are read as the built-in ones are; nothing of the payload's host side reaches a row whose C library a platform describes * E3: a GNU-ABI Windows row finds its resource compiler in the paired payload or uses llvm-rc; a quoted toolchain header is the toolchain's * E4: FreeBSD's identities are built-in data with their compiler triple; the rows' systems are words of the language; a platform-served row names the platform as its remedy * E5: a base package states the C++ run-time and compiler run-time it holds beside its C library; its headers, libraries and std module stand where the payload's would * E6: a patched member of a git repository is patched in a copy of the repository, so its edges to sibling members hold * E7: a foreign artifact's closure is read from its DT_NEEDED; --mode static links and checks a static program A program for another system was handed to the host's ldd (exit 127). Its closure is now read from the file: a library this build produced travels beside it, every other name is the target system's. `--mode static` sets force_static and checks the file, so a dynamic program is never packed under the `-static` name; a row whose C library a platform describes supports a full static link. * E8: [platform.link] flags that a compiler link does not use are named; docs/04 states per-target object variants The words are given to ld.lld only; a platform with driver = "compiler" now receives a warning that names [platform.build] ldflags. docs/04 states the per-target object variants and per-program entry objects instead of the retired compile-once sentence. * E9: a MinGW-w64 base package serves the GNU-ABI Windows rows beside llvm on every host; the unserved-target remedy names a spelling the parser accepts The mingw-llvm provider names xim:mingw-w64-sysroot (the target side of llvm-mingw: MinGW-w64 on UCRT, libc++, libunwind, compiler-rt) for x86_64-windows-gnu and the new aarch64-windows-gnu row, below the gcc payload where that exists. A base package on a MinGW row is the driver's sysroot with the run-times its layers state; its compiler runtime is read from the directory the base names (compiler-runtime-dir), and a static link takes its archives. A provider's sysroot package is the base statement of last resort. The unserved-target diagnosis names [toolchain] <host> = { path, prefix } instead of [target.X] toolchain = "<path>" (mcpp#913). * E10: a scan override of a file this build excludes is kept for the builds that compile it (mcpp#902) A [scan_overrides] glob whose files exist and take no part in this build -- a feature that is off, a ! rule of a [target.<selector>.build] -- is no longer refused; a glob that matches no file of the package still is. * E11: the 32-bit hosted identities (i686-linux-musl, i686-linux-gnu, i686-openkal) are registered intent Planned rows: a request is refused as planned rather than as an unknown target, and an explicit [target.<row>] toolchain opts in early. No payload of the index targets them, and openkal's 32-bit class is a design discussion. * docs: SPEC-002 v1.6 (base packages, layer-cycle), SPEC-006 v0.11, SPEC-013 v1.7, SPEC-014 v2.2, SPEC-016 v1.1; MCPP_KERNEL_ABI_INTERFACES and layer-cycle in docs/30 and docs/50 * docs: base packages (docs/22), the targets every host reaches (docs/21), foreign ELF closure and the static check (docs/10), defined rows, served FreeBSD rows and link.flags (docs/35); en and zh * 2026.11.10.1: version, CHANGELOG; CI bootstraps from 2026.11.9.1 * AGENTS.md: the repository's rules in their shortest form, linked to the documents that state them; design record 2026-11-10 (cross-platform ecosystem, fourth version) * E5: a base package is an ordinary package -- provides answers its layers, [build] states them, the package root is the sysroot; a provider's sysroot is its identity's base The [base] table (an architecture-keyed roots map, include-dirs, libs by link form, compiler-runtime-dir) is replaced by the manifest vocabulary every layer supplier uses: include_dirs, ldflags, std-module*, and one new [build] key, compiler_runtime_dir (-resource-dir for clang, -B for gcc). One base package is the sysroot of one identity; a platform's provider takes sysroot as a package or { path }, ahead of the platform's own. The mingw-llvm provider names xim:mingw-w64-sysroot@20261104-1. * tests: the rows E4, E9 and E11 add -- capability pins, the windows set, the rows snapshot; freebsd is a platform name * README: the rows this release adds; graph.cpp stays within its length limit * A provider's base yields to a graph-supplied system; a carrier that names no hosts exists where the platform's runner does CI on #916: a carrier for windows-aarch64 was built now that aarch64-windows-gnu is a row, over the mingw-llvm base beneath openkal-windows (an x86_64 implementation). The provider's sysroot, an engine default, is no longer a statement when the graph supplies the system, as the row's toolchain convention already is not; and a carrier that names no hosts is built only where the platform's runner exists (runner.hosts), so --systems all leaves the others out with the reason. * mcpp test states what its programs report as they report it: parts, case records, metrics and bounds; SPEC-017 (mcpp#917) The runner's side of the test protocol, for any framework that implements it: - test-parts: --cases names the parts [test] split runs a program as (parts), and each part's record names its program (part_of); - test-case-stream: the report is read while the program runs (P5.1), and a case record states each case's beginning and end before the program's record; - test-metrics: the cases' kind, tags, metrics and bounds and the program's usage reach the records, and the run kept under target/mtest carries them with each case's start and its failures' expected and actual values (P6, P10.2, P12), so a Bench case's measurements reach mtest analyze trend. The --list main keeps its meaning. SPEC-017 states the runner, the protocol it reads, the records and the store, framework-neutral. * Windows resources: the subjects of the plan are collected by their own function step13_windows_resources stays within the 400-line function limit. * A provider's base is kept only once the graph is known; a paired sysroot is stated wherever no cfg is trusted The base statement was memoised when first asked, before the dependency graph was loaded, so a provider's base did not yield to a graph that supplies the C library (x86_64-windows-gnu over openkal on hosts the mingw-llvm provider serves). The compile side stated a paired provider's sysroot only when a cfg was bypassed; the Windows llvm payload has no cfg, so aarch64-windows-gnu found no libc++ headers there. The link side already stated it unconditionally. * Target matrix: the cells of the mingw-llvm provider and the planned rows; e2e 1063 runs in the wine job * Two mcpp processes of one home install one package once; e2e 182 states the MSVC ABI it asks for A dependency is installed under the home's install turn (registry/.install.lock, re-entered for the package's own dependencies); a process that waited for the turn looks for the package again before installing it. A second process was told the install succeeded while the first was still placing the package, and stopped with "install path missing after fetch" (two e2e workers fetching one package into one home). e2e 182: llvm alone is not a request for the MSVC ABI now that clang pairs with the MinGW-w64 payload and compiles against it on a host without a cfg; the project writes x86_64-windows-msvc as its target. * docs/25: a home's install turn * A base package's C library is reported by the name its manifest states; the mingw-llvm provider names mingw-w64-sysroot 20261104-2 (mcpp:c-abi=ucrt) The c-abi layer of a base package was reported by the package's name (mingw-w64-sysroot); it is the C library its provides states. Revision 2 of the MinGW-w64 base states ucrt, the name mcpp's vocabulary gives the Windows C library and the one the MinGW-w64 payload answers, so that one requirement (compat.glfw's Win32 backend) is met by either. The design records I1 in that form, and the defects CI exposed. * The base statement decided before the graph is kept as provisional, not dropped base_statement_text points into the memo; an answer that was not kept left it pointing at another target's statement or at none. The engine tier's answer is kept and marked provisional, and asked again once the dependency graph is loaded. * A paired system's C++ library is stated on C++ commands only -stdlib= rode the toolchain words every C and assembly command shares, so a C unit of a paired target drew clang's unused-argument warning, an error under -Werror. paired_stdlib_flag() is appended to the C++ flags and to the module scan; the std module build asks for it as before. * A payload not found after its install names the directories it was looked for in The error "install path missing after fetch" now lists each version directory the lookup tried, in its order, so that a provider that placed the payload elsewhere is seen at once. e2e 15 prints the output of a failing mcpp test. * A version a merge replaces withdraws the requests it made A resolved record keeps its constraints by requester, and a merge that replaces <ns>.<name>@<old> records that version as superseded: the items it queued are not walked, and its constraints no longer bound a merge. The graph os 0.4.4 -> 0.4.1 (pinned) was refused with "irreconcilable versions" between openkal 0.24.0 and a request of openkal-linux 0.26.0, a version no longer in it. e2e 1066 reproduces the order. * mcpp test: the cases counted beside the programs, and the failures as an index The summary states the cases that check (a case that declared cases is told by them): cases: N passed, N failed, N skipped (in N programs). The failures list each failed program and under it the failed leaf cases at the place of their first failure; the per-program repetition of the case failures, which the framework's own output already shows under the program's line, is gone. The program count keeps its words. * cenv: FreeBSD and NetBSD present POSIX as Linux does The BSDs' ELF triples predefine __unix__ and are LP64 with a 32-bit wchar_t, so a C library's posix/arch-default declaration is realised with no token (<arch>-freebsd-musl: a C library above openkal-freebsd). docs/22 states the row. * The missing-payload diagnostic names the configuration its stores come from * Design: tests and dependency resolution, a supplement (mcpp, mcpp test, mtest, mcpp-ide) * Design: tests and dependency resolution, second revision (layers, the test session, case output and checks, self-review) * Design: tests and dependency resolution, third revision (mcpp test spec with base and optional capabilities, the session as an optional capability, the global review) * build: a package's root is its own file (package_root.cpp) makePackageRoot and the expansion of include directories move out of graph.cpp, which had passed the 2,500-line limit; the graph's steps and the later phases take a root from there. * config: a borrowed registry keeps the index places its owner recorded A home whose [xlings] home names an existing registry wrote its own index directory and store into that registry's configuration. The e2e homes under a temporary directory did, and later builds over the shared registry were sent to a store deleted with its home ("install path missing after fetch" on Windows and macOS). Such a home now records no place of its own there; e2e 1067 fails before and passes after. * e2e 1066: the replaced family's implementation is absent on every system The test named openkal-linux; on Windows and macOS the pinned os brings the 0.24 family's implementation of that system instead. * CHANGELOG: requests of a replaced version, the case summary, BSD C environments, borrowed registries * test: release the build directory before running; build programs by the fast path; state only work done - The build directory's lock is dropped once the tests are built, and each invocation reports into its own protocol directory, test-protocol/<pid>-<start>/, removed when it ends and swept when its process is gone (#915). e2e 1068 runs a build and a second test beside a running one; it fails before and passes after. - The programs a test finds as MCPP_BIN_<NAME> are built by try_fast_build when no override applies, which now hands back the recorded programs. - The packages are no longer announced before the build; Phase A's report names a package when one of its steps runs, and a test's Compiling line is written when the bulk pass ran a step of its own. - The test graph is written to test.ninja (set on the three test plans). * build: the test graph is test.ninja, and a scan both graphs name has one command BuildPlan::graphFile names the file the backend writes and drives (-f). test.ninja shares the directory's objects, .ninja_log and .ninja_deps with build.ninja, so an output both graphs name with different commands is rebuilt rather than reused. The dyndep rule's text no longer depends on the plan: $module_map carries its own leading separator, and obj/main.cpp.ddi.dd was rescanned on every switch between mcpp build and mcpp test because its command differed by a space. The e2e that read the test graph from build.ninja read test.ninja. * targets: the built-in platform of the openkal targets is openkal-platform 0.25.0 openkal-platform 0.25.0 (mcpp-index#751) groups openkal 0.25.0, openkal-image 0.5.5, openkal-musl 0.29.0 and the implementations of the 0.25 family; its mcpp floor is 2026.11.9.1. * CHANGELOG: test.ninja, the programs' fast path, Compiling lines, the released build directory, platform 0.25.0 * test: the tests of an unchanged project run from the plan's record A full mcpp test writes test-plan.json beside test.ninja (every test of the package: its program, its own sources, its protocol or the objects that state it, its guide; the runtime directories and the tool directory; [test] split and store) and a build-cache entry for the test graph (selection @test). The next mcpp test admits that entry through admit_recorded_build, which now takes the graph it replays, asks that the discovered tests are the recorded ones, that nothing under tests/ is newer than the graph and that ninja has nothing to do for the selected tests, and runs them from the record; the environment, the arguments after -- and the programs' places are joined at run time. A workspace's root package matches its own record (selection and group '.') on both fast paths. e2e 1069 fails before and passes after; on a workspace of 1,500 sources one program's unchanged tests went from 5.8 s to 0.13 s. * e2e 1068: a test that builds its own project neither waits nor plans (#915) The issue's shape: the test runs mcpp build in its project with the test's environment. Measured for T9 on 2026.11.9.1 and 2026.11.10.1, with gcc and with an llvm workspace: the test's environment (the subos's bin first on PATH, its library variables, MTEST_*) leaves the configuration's fingerprint as it is; the rebuilds the issue saw were the test graph written over build.ninja and the lock held through the run. * test spec: SPEC-017 v2.0, launch records, framework capabilities and sessions, check details, a case's output docs/specs/test.md is the mcpp test spec: SPEC-017 v1, the mtest protocol's normative text (P1-P12 kept) and the [test] keys, as base capabilities B1-B6 and optional ones O1-O9; test-runner.md is folded into it. B5: --no-run records carry each program's launch. B6: an entry target's test-capabilities and test-session, reported by --guide. O3: failure source and fatal, case checks, in records and the store. O8: a case's output from the program's output events, or from a program that ran that case alone; the output of several cases is not divided by arrival, which a buffered stream does not allow (measured). Features test-launch-records, test-frameworks, test-checks, test-output. e2e 1070 fails before and passes after. * pack: the generated launchers depend on mcpplibs.os 0.4.4; e2e 1068 and 1069 on every host The Windows launcher and the single-file launcher pinned mcpplibs.os 0.4.1, of the openkal 0.24 family, which the built-in platform 0.25.0 refuses (cross/mingw-cross, e2e 988); 0.4.4 ranges over the 0.24 and 0.25 families. e2e 1068 bounds its commands without timeout(1), which macOS lacks; e2e 1069 asserts that no dev-dependency is resolved, since the programs' build plans on hosts where mcpp build plans each time (macOS). * dependencies: the root overrides a package for the whole graph (#914) override = true on a root's dependency or in [workspace.dependencies] answers every request for the package in the graph its table governs ([dependencies]: build and tests; [dev-dependencies]: tests; [build-dependencies]: build programs). A replaced request that does not already admit the override is named once (Overrode); mcpp.lock marks the package and --locked reads the marker; an override of a platform version group's member is taken with a warning; a library's override is ignored and said to be. A refusal of two irreconcilable versions names the overriding line; a library's exact pin of a package every consumer shares (a target-side layer, a kernel ABI) is noted to its users and refused by mcpp publish. src/build/prepare/overrides.cpp holds the steps. e2e 1071 fails before and passes after. * unit: the Windows launcher's manifest names mcpplibs.os 0.4.4 * manifest: test-capabilities and test-session are known target keys An entry target that states them is not warned of an unsupported key. * e2e 1070: the framework's path in host spelling * link: the toolchain's C++ archives built for another target are not linked flags.cppm reads the triple of the directory the payload's libc++.a was found in; another architecture or system marks MechanismInput::foreignCxxArchives, and resolve() links no C++ runtime there and states that the row's is a package's (mcpp:c++-abi). Measured on aarch64-freebsd-musl from a Linux host: ld.lld: libc++.a(algorithm.cpp.o) is incompatible. The OpenKal conformance suite now takes openkal-llvm-runtime there (openkal-freebsd). * bench: mcpp's own costs as mtest Bench cases with a history (no-op build, why flags, one interface edit) bench/tests/engine.cpp times the mcpp under test (MCPP) on a small module fixture; each cost enters the mtest store as a metric with its samples. The engine comparisons remain the standard set run by hand. * CI: mtest pinned once and every test run reported through it .github/versions.env pins mtest (MTEST_VERSION, MTEST_SHA256); the composite action mtest installs it and exports MTEST, and e2e-mtest takes it from there. test-report merges the stores mcpp test kept in a job, writes the job's Markdown report into its summary and uploads the store; the unit jobs of the three hosts and the Linux bench run use it. Each e2e shard writes its report, run_all.sh groups the shards by the workflow run, and ci.yml's test-report job renders one report over every job (mtest ci report). * Design notes: implementation records of the ecosystem plan and its supplement * CI: mtest is installed into the global subos, so the report runs it outside the repository * resources: a cross gcc's Windows headers are the toolchain's; an include nothing provides is the script's own - system_include_dirs reads a cross gcc's own <root>/<triple>-w64-mingw32/include when no payload is paired: under the mingw provider, a script's "winres.h" was taken for a file of the project that no action produces, and the build failed in ninja (e2e 1058, the cross gcc case). - A quoted include found in no directory is an input only when a build action writes it; otherwise the script's preprocessing decides (#if __has_include) and the resource compiler names a missing one with the script and line (e2e 1072). - docs/04 (en, zh) and CHANGELOG. * Design notes: the resource findings of the validation in the implementation record
PreviousNext