2026.11.9.1: targets and providers; a platform defines rows; mcpp#911 G1–G12, B1–B3; tests are mtest's

.agents/docs/README.md

@@ -18,7 +18,7 @@ superseded_by: 2026-09-07-....md  # when status is superseded
 ---
 ```
 
-355 records.
+356 records.
 
 ## By subject
 
@@ -138,6 +138,10 @@ Records that declare one. Everything else is listed by date below.
 - [#674 设计方案评审：`-include unistd.h` 在 Windows + `presents = "posix"` 上的可行性](2026-09-20-issue-674-design-review.md) — active
 - [`__cxa_thread_atexit` 在 openkal-Windows 上:两层都已定位并修复](2026-09-20-cxa-thread-atexit-finding.md) — landed
 
+### target-model
+
+- [目标与提供者：统一的目标模型（结合 mcpp#911）](2026-11-09-target-model-design.md) — active
+
 ### targets
 
 - [A verified Web run that asked the host for node](2026-09-12-a-verified-web-run-that-asked-the-host-for-node.md) — landed
@@ -179,6 +183,7 @@ Records that declare one. Everything else is listed by date below.
 
 ### 2026-11
 
+- [目标与提供者：统一的目标模型（结合 mcpp#911）](2026-11-09-target-model-design.md) — active
 - [生态顶层方案：#885 收尾之后的工作流、原则与依赖](2026-11-08-ecosystem-top-level-design.md) — active
 - [#885 收尾补充方案：目标角色、平台事实、系统接口与版本书写](2026-11-08-ecosystem-885-supplement-design.md) — active
 - [生态 #885 收尾设计：核心、插件、openkal、语言服务与编辑器的一轮闭合](2026-11-07-ecosystem-885-closeout-design.md) — active

.gitattributes

@@ -1,2 +1,4 @@
 # The cross-host admission compares the exact source bytes compiled by each host.
 tests/fixtures/openkal-hosted-threads/src/main.cpp.in text eol=lf
+# The rows' snapshot is compared line by line with what the engine answers, in its own bytes.
+tests/fixtures/target-rows.snapshot text eol=lf

.github/actions/bootstrap-mcpp/action.yml

@@ -107,6 +107,7 @@ runs:
       env:
         XLINGS_NON_INTERACTIVE: '1'
         XLINGS_VERSION: ${{ inputs.xlings-version }}
+        GITHUB_TOKEN: ${{ github.token }}
       run: |
         REPO_DIR="$(pwd)"
         # Always install the pinned version — the cache may hold an older
@@ -231,6 +232,7 @@ runs:
       env:
         XLINGS_NON_INTERACTIVE: '1'
         XLINGS_VERSION: ${{ inputs.xlings-version }}
+        GITHUB_TOKEN: ${{ github.token }}
       run: |
         REPO_DIR="$(pwd)"
         # FAST PATH: see the unix leg for the reasoning. The cost on Windows is

.github/actions/e2e-mtest/action.yml

@@ -1,7 +1,7 @@
 name: e2e-mtest
 description: >
   mtest for the e2e suite (design 2026-11-08 W8; tests/e2e/mtest.toml): the
-  release this action pins, its sha256 checked, and the stores main's last
+  release this action pins, installed by xlings, and the stores main's last
   successful CI run kept for this host, taken into tests/e2e/.mtest so that
   `--shard` divides the suite by measured time and a run orders its tests
   longest first. Exports E2E_MTEST for run_all.sh. A run with no store of main
@@ -12,13 +12,13 @@ inputs:
     description: the host's name in the stores' artifact names (linux, macos, windows)
     required: true
   version:
-    description: the mtest release
+    description: the mtest release, an xlings package (xim:mtest), whose sha256 the index states
     required: false
-    default: '0.4.0'
+    default: '0.5.2'
   sha256:
-    description: sha256 of mtest-<version>-openkal-bundle-all.tar.gz
+    description: sha256 of mtest-<version>-openkal-bundle-all.tar.gz, for the release taken when xlings cannot install it
     required: false
-    default: 'b62e4ac7cd76b20dbdc48a5d041d377444e8815ee7a4ff1e7686145d13acc925'
+    default: 'be443f8c546b3f4628dcd3f1eb6f45b4d698a7f805232f966349faf8250863c6'
   token:
     description: a token that reads this repository's actions
     required: false
@@ -27,24 +27,41 @@ inputs:
 runs:
   using: composite
   steps:
+    # THE ENGINE IS AN XLINGS PACKAGE (xim:mtest), installed as the job installs
+    # mcpp, verified by the index's sha256, and kept in the job's xlings cache:
+    # by the configured mirror (GLOBAL), then by CN (GitCode first), each with a
+    # refreshed index; else the release bundle itself (fetch_release.sh: the
+    # web address, then the API's), checked against the pinned sha256.
     - name: mtest
       shell: bash
       env:
         MTEST_VERSION: ${{ inputs.version }}
         MTEST_SHA256: ${{ inputs.sha256 }}
+        GITHUB_TOKEN: ${{ inputs.token }}
       run: |
         set -euo pipefail
-        archive="mtest-$MTEST_VERSION-openkal-bundle-all.tar.gz"
-        temp="$RUNNER_TEMP"; python=python3
-        if [ "$RUNNER_OS" = Windows ]; then temp=$(cygpath -u "$RUNNER_TEMP"); python=python; fi
-        curl -fsSL --retry 5 --retry-all-errors --retry-delay 5 -o "$temp/$archive" \
-          "https://github.com/mcpp-community/mtest/releases/download/v$MTEST_VERSION/$archive"
-        actual=$("$python" -c "import hashlib,sys; print(hashlib.sha256(open(sys.argv[1],'rb').read()).hexdigest())" "$temp/$archive")
-        [ "$actual" = "$MTEST_SHA256" ] || { echo "::error::$archive: sha256 $actual, the action pins $MTEST_SHA256"; exit 1; }
-        mkdir -p "$temp/mtest" && tar xzf "$temp/$archive" -C "$temp/mtest"
-        launcher="$temp/mtest/mtest-$MTEST_VERSION-openkal-bundle-all/bin/mtest"
-        [ "$RUNNER_OS" = Windows ] && launcher="$launcher.exe"
-        "$launcher" --version
+        launcher=""
+        for mirror in GLOBAL CN; do
+          xlings config --mirror "$mirror" > /dev/null 2>&1 || true
+          xlings update > /dev/null 2>&1 || true
+          if xlings install "mtest@$MTEST_VERSION" -y; then launcher=$(command -v mtest); break; fi
+        done
+        xlings config --mirror GLOBAL > /dev/null 2>&1 || true
+        if [ -z "$launcher" ]; then
+          echo "::warning::xlings could not install mtest $MTEST_VERSION; taking the release itself"
+          archive="mtest-$MTEST_VERSION-openkal-bundle-all.tar.gz"
+          temp="$RUNNER_TEMP"; python=python3
+          if [ "$RUNNER_OS" = Windows ]; then temp=$(cygpath -u "$RUNNER_TEMP"); python=python; fi
+          bash "$GITHUB_WORKSPACE/.github/tools/fetch_release.sh" \
+            "https://github.com/mcpp-community/mtest/releases/download/v$MTEST_VERSION/$archive" "$temp/$archive"
+          actual=$("$python" -c "import hashlib,sys; print(hashlib.sha256(open(sys.argv[1],'rb').read()).hexdigest())" "$temp/$archive")
+          [ "$actual" = "$MTEST_SHA256" ] || { echo "::error::$archive: sha256 $actual, the action pins $MTEST_SHA256"; exit 1; }
+          mkdir -p "$temp/mtest" && tar xzf "$temp/$archive" -C "$temp/mtest"
+          launcher="$temp/mtest/mtest-$MTEST_VERSION-openkal-bundle-all/bin/mtest"
+          [ "$RUNNER_OS" = Windows ] && launcher="$launcher.exe"
+        fi
+        "$launcher" --version | grep -qF "$MTEST_VERSION" \
+          || { echo "::error::the mtest at $launcher is not $MTEST_VERSION: $("$launcher" --version)"; exit 1; }
         echo "E2E_MTEST=$launcher" >> "$GITHUB_ENV"
     # The pull request's change, for the `pr` set: the base's tip and HEAD's
     # parents, so that `git diff <base>...HEAD` has its merge base. When they

.github/actions/setup-macos-llvm/action.yml

@@ -51,17 +51,25 @@ runs:
       env:
         XLINGS_NON_INTERACTIVE: '1'
         XLINGS_VERSION: ${{ inputs.xlings-version }}
+        GITHUB_TOKEN: ${{ github.token }}
       run: |
-        WORK=$(mktemp -d)
-        tarball="xlings-${XLINGS_VERSION}-macosx-arm64.tar.gz"
-        # Retried and verified — .github/tools/fetch_release.sh. A bare curl
-        # here is the `curl: (52) Empty reply from server` flake.
-        bash "$GITHUB_WORKSPACE/.github/tools/fetch_release.sh" \
-          "https://github.com/d2learn/xlings/releases/download/v${XLINGS_VERSION}/${tarball}" \
-          "${WORK}/${tarball}"
-        tar -xzf "${WORK}/${tarball}" -C "${WORK}"
-        XLINGS_DIR="${WORK}/xlings-${XLINGS_VERSION}-macosx-arm64"
-        "$XLINGS_DIR/subos/default/bin/xlings" self install
+        # THE CACHE ALREADY HOLDS THE PINNED XLINGS (its key names the version):
+        # nothing is downloaded, as bootstrap-mcpp's fast path does. This step
+        # fetched the release on every run, a cache hit or not, and a 504 of
+        # that fetch failed the job (2026-11-09).
+        XL="$HOME/.xlings/subos/default/bin/xlings"
+        if ! { [ -x "$XL" ] && "$XL" --version 2>/dev/null | head -1 | grep -qF "$XLINGS_VERSION"; }; then
+          WORK=$(mktemp -d)
+          tarball="xlings-${XLINGS_VERSION}-macosx-arm64.tar.gz"
+          # Retried and verified, and by the API's address when the web's
+          # fails — .github/tools/fetch_release.sh.
+          bash "$GITHUB_WORKSPACE/.github/tools/fetch_release.sh" \
+            "https://github.com/d2learn/xlings/releases/download/v${XLINGS_VERSION}/${tarball}" \
+            "${WORK}/${tarball}"
+          tar -xzf "${WORK}/${tarball}" -C "${WORK}"
+          XLINGS_DIR="${WORK}/xlings-${XLINGS_VERSION}-macosx-arm64"
+          "$XLINGS_DIR/subos/default/bin/xlings" self install
+        fi
         export PATH="$HOME/.xlings/subos/default/bin:$PATH"
         xlings --version
         echo "PATH=$HOME/.xlings/subos/default/bin:$PATH" >> "$GITHUB_ENV"

.github/tools/check_e2e_coverage.py

@@ -18,6 +18,10 @@
 under tests/e2e:
 
   ran        some report says pass, fail or timeout;
+  unaffected no report ran it, and a run narrowed to a set (`E2E_SET`, the
+             `pr` set of a pull request) says the change does not affect it:
+             the full runs of main are its coverage, and this run's claim is
+             about the tests the change reaches;
   job        no report ran it, but a workflow names it outside a comment, as a
              whole token: by file name, by name without `.sh`, or by its number
              as an `E2E_ONLY` pattern such as `239_*.sh`. A dedicated job runs it
@@ -34,7 +38,8 @@
 calls a target row `verified` when CI builds and runs its artefact, and the
 `*-openkal` rows claim that for every system. tests/e2e/host-requirements.tsv
 lists such a test with the hosts its result must come from; a listed test that
-did not pass on one of them, or that does not exist, fails the check.
+did not pass on one of them, or that does not exist, fails the check; one a
+set left out on that host as unaffected meets it for that run.
 
 With --timings-out DIR it writes `<host>.tsv`, the measured duration of every
 test that ran, merged across that host's shards, in the format run_all.sh reads
@@ -133,6 +138,7 @@ def main() -> int:
     ran: dict[str, set[str]] = defaultdict(set)
     passed: dict[str, set[str]] = defaultdict(set)
     skipped: dict[str, set[str]] = defaultdict(set)
+    unaffected: dict[str, set[str]] = defaultdict(set)
     shard_ms: dict[tuple[str, int], int] = defaultdict(int)
     timings: dict[str, dict[str, int]] = defaultdict(dict)
     reports = 0
@@ -146,6 +152,8 @@ def main() -> int:
             timings[host][test] = ms
         elif status == "skip":
             skipped[test].add(f"{host}: {detail}")
+        elif status == "unaffected":
+            unaffected[test].add(host)
     if reports == 0:
         print(f"no report under {args.reports}: nothing can be said about coverage")
         return 1
@@ -157,6 +165,8 @@ def main() -> int:
             counts["ran"] += 1
             if test in exceptions:
                 stale.append(f"{test} is excused but ran on {', '.join(sorted(ran[test]))}")
+        elif test in unaffected:
+            counts["unaffected"] += 1
         elif named_by_a_workflow(test, workflows):
             counts["job"] += 1
         elif test in exceptions:
@@ -171,13 +181,14 @@ def main() -> int:
         if test not in tests:
             stale.append(f"{test} is required on hosts but does not exist")
             continue
-        for host in sorted(hosts - passed[test]):
+        for host in sorted(hosts - passed[test] - unaffected[test]):
             why = [d for d in skipped[test] if d.startswith(f"{host}: ")]
             unmet.append(f"{test} did not pass on {host}"
                          f"{' (' + '; '.join(why) + ')' if why else (' (it ran and did not pass)' if host in ran[test] else ' (no report of it there)')}")
 
-    print(f"{len(tests)} tests: {counts['ran']} ran on a shard, {counts['job']} run by a "
-          f"dedicated job, {counts['excused']} excused, {len(uncovered)} uncovered")
+    print(f"{len(tests)} tests: {counts['ran']} ran on a shard, {counts['unaffected']} unaffected by "
+          f"the change, {counts['job']} run by a dedicated job, {counts['excused']} excused, "
+          f"{len(uncovered)} uncovered")
     for (host, shard), ms in sorted(shard_ms.items()):
         print(f"  {host} shard {shard}: {ms / 60000:.1f} min of tests")
     for line in uncovered:

.github/tools/check_target_tiers.py

@@ -1,8 +1,8 @@
 #!/usr/bin/env python3
 """Every documented tier agrees with the target table.
 
-WHY THIS EXISTS. `kKnownTargets` in modules/toolchain-model/src/triple.cppm is
-the single source for a row's tier, and four documents restate it: both
+WHY THIS EXISTS. The built-in rows, modules/toolchain-model/data/builtin.toml
+(SPEC-016 §2.2), are the single source for a row's tier, and four documents restate it: both
 READMEs, both copies of docs/21. When `wasm32-emscripten` became `verified` and
 the Android rows gained tiers, docs/21 was updated and the READMEs were not --
 so the front page told a reader that three targets were `planned` while the
@@ -16,17 +16,19 @@
 """
 import re
 import sys
+import tomllib
 from pathlib import Path
 
 ROOT = Path(__file__).resolve().parents[2]
-TABLE = ROOT / "modules/toolchain-model/src/triple.cppm"
+TABLE = ROOT / "modules/toolchain-model/data/builtin.toml"
 TIERS = ("verified", "preview", "planned")
 
 # The engine's answer.
 rows = {}
-for m in re.finditer(r'^\s*\{\s*"([a-z0-9_.+-]+)",\s*"(verified|preview|planned)"',
-                     TABLE.read_text(), re.M):
-    rows[m.group(1)] = m.group(2)
+with TABLE.open("rb") as f:
+    for row in tomllib.load(f).get("platform", {}).get("define", []):
+        if row.get("tier") in TIERS:
+            rows[row["triple"]] = row["tier"]
 if len(rows) < 20:
     sys.exit(f"ERROR: only {len(rows)} rows parsed from {TABLE.name}; "
              "the pattern no longer matches the table")

.github/tools/check_windows_home_legacy.py

@@ -14,22 +14,23 @@
 assert original.count(marker) == 1, 'identify the test-only code-page setting explicitly'
 
 
-def run_case(pattern, passed_case):
-    result = subprocess.run([os.environ['MCPP'], '--offline', 'test', pattern], cwd=root,
+def run_case(passed_case):
+    # The case by its identifier (mtest's): it runs in the process of its file.
+    result = subprocess.run([os.environ['MCPP'], '--offline', 'test', '--case', passed_case], cwd=root,
                             capture_output=True, text=True, encoding='utf-8', errors='replace',
                             timeout=600)
     sys.stdout.write(result.stdout)
     sys.stderr.write(result.stderr)
     assert result.returncode == 0, result.returncode
     output = re.sub(r'\x1b\[[0-9;]*m', '', result.stdout + result.stderr)
-    assert '[       OK ] ' + passed_case in output, \
+    assert re.search(r'^\s*ok\s+' + re.escape(passed_case) + r'\s*$', output, re.M), \
         'the legacy ACP case did not pass; a UTF-8-only skip is not proof'
 
 
 try:
     manifest.write_bytes(original.replace(marker, b'windows_code_page = "legacy"', 1))
-    run_case('home', 'HomeSelection.UnicodeLocatorRoundTripDoesNotNarrowTheSelectedPath')
-    run_case('bmi_cache', 'BMICacheMaintenance.RunnerCachePathDoesNotUseTheWindowsAnsiCodePage')
+    run_case('HomeSelection/UnicodeLocatorRoundTripDoesNotNarrowTheSelectedPath')
+    run_case('BMICacheMaintenance/RunnerCachePathDoesNotUseTheWindowsAnsiCodePage')
 finally:
     manifest.write_bytes(original)
 print('PASS: home and runner-cache paths ran under legacy Windows ACP; manifest restored')

.github/tools/fetch_release.sh

@@ -45,6 +45,33 @@ verify() {
     esac
 }
 
+# THE SAME FILE BY GITHUB'S API. The web address of a release asset
+# (`github.com/<owner>/<repo>/releases/download/<tag>/<name>`) answered 504 for
+# minutes at a time while the API's address of the same asset answered 200
+# (measured 2026-11-09 on xlings-2026.10.26.1-macosx-arm64.tar.gz, three times
+# each). A failed web attempt is followed by the API's, with the job's token
+# where there is one (the API's anonymous limit is 60 requests an hour).
+api_fetch() {
+    local rest="${url#https://github.com/}"
+    [ "$rest" != "$url" ] || return 1
+    local owner repo releases download tag name
+    IFS=/ read -r owner repo releases download tag name <<<"$rest"
+    [ "$releases/$download" = "releases/download" ] && [ -n "$name" ] || return 1
+    local auth=()
+    local token="${GITHUB_TOKEN:-${GH_TOKEN:-}}"
+    [ -z "$token" ] || auth=(-H "Authorization: Bearer $token")
+    local id
+    id=$(curl -fsSL --retry 3 --retry-all-errors --connect-timeout 20 --max-time 60 "${auth[@]}" \
+            "https://api.github.com/repos/$owner/$repo/releases/tags/$tag" \
+         | python3 -c 'import json,sys; n=sys.argv[1]; print(next((str(a["id"]) for a in json.load(sys.stdin)["assets"] if a["name"] == n), ""))' "$name") \
+        || return 1
+    [ -n "$id" ] || return 1
+    echo "fetch_release: the web address failed; asking the API for asset $id" >&2
+    curl -fsSL --retry 3 --retry-delay 2 --retry-all-errors --connect-timeout 20 --max-time 600 \
+         "${auth[@]}" -H "Accept: application/octet-stream" \
+         -o "$dest" "https://api.github.com/repos/$owner/$repo/releases/assets/$id"
+}
+
 for i in $(seq 1 "$attempts"); do
     rm -f "$dest"
     # --retry-all-errors is what covers exit 52; the rest bound how long a single
@@ -53,7 +80,7 @@ for i in $(seq 1 "$attempts"); do
     if curl -fsSL \
             --retry 3 --retry-delay 2 --retry-all-errors \
             --connect-timeout 20 --max-time 600 \
-            -o "$dest" "$url"; then
+            -o "$dest" "$url" || { rm -f "$dest"; api_fetch; }; then
         if verify; then
             [ "$i" -eq 1 ] || echo "fetch_release: succeeded on attempt $i" >&2
             exit 0