exclude docs from wheel; harden bundle item handling; single-source version

build/release/preflight.py

@@ -8,12 +8,13 @@ Steps, in order:
 
 1. ``repo-state``           - git repository, clean working tree, recorded commit
 2. ``version-consistency``  - __version__ == pyproject dynamic attr == wheel names
-3. ``duplicate-guard``      - SDK/<version>/ already populated; optionally PyPI
-4. ``tests``                - pytest (slow/hardware markers excluded)
-5. ``bundle-precheck``      - every bundle item resolves; required assets present
-6. ``wheel-inspection``     - static metadata/content assertions per wheel
-7. ``wheel-runtime``        - isolated venv: bundled assets load and real frames
-                              flow through the public pipeline
+3. ``version-strings``      - no stale version literal left in tracked prose
+4. ``duplicate-guard``      - already-released version (git tag, optionally PyPI)
+5. ``tests``                - pytest (slow/hardware markers excluded)
+6. ``bundle-precheck``      - every bundle item resolves; required assets present
+7. ``wheel-inspection``     - static metadata/content assertions per wheel
+8. ``wheel-runtime``        - one isolated venv per wheel: bundled assets load and
+                              real frames flow through the public pipeline
 
 Output lands in ``build/release/reports/<version>/preflight.{json,txt}``.
 """
@@ -39,8 +40,7 @@ from common.pyproject_utils import bundle_items, get_version  # noqa: E402
 from common.verify.wheel import (  # noqa: E402
     DEFAULT_RUNTIME_CONFIG,
     default_verification_video,
-    verify_wheel_assets,
-    verify_wheel_runtime,
+    verify_wheel,
 )
 from common.verify.wheel_contents import inspect_wheel  # noqa: E402
 from release import report as report_mod  # noqa: E402
@@ -108,7 +108,9 @@ class Preflight:
             self.version = get_version(self.repo_root)
             self.version_source = "pyproject.toml dynamic attr"
         else:
-            self.version = "0.0.0"
+            # Not version-shaped on purpose: this is a sentinel for "unresolved",
+            # and it must not look like a release version to the version-string scan.
+            self.version = "unknown"
             self.version_source = "unresolved"
 
         self.report_dir = report_mod.reports_root(self.repo_root, options.report_dir) / self.version
@@ -270,6 +272,34 @@ class Preflight:
             detail += "\n" + "\n".join(problems)
         return Step("duplicate-guard", not problems, detail)
 
+    def _version_strings(self) -> Step:
+        """Keep the version out of prose: one source, everything else derived.
+
+        Scans tracked text for version-looking literals that disagree with the
+        release version. Dependency constraints are ignored by design; deliberate
+        exceptions live in ``version.VERSION_STRING_ALLOWLIST``.
+        """
+        findings = version_mod.find_version_literals(self.repo_root, self.version)
+        if not findings:
+            scanned = len(version_mod.tracked_text_files(self.repo_root))
+            return Step(
+                "version-strings",
+                True,
+                f"no stale version literal in {scanned} scanned file(s); "
+                f"version {self.version} lives only where it is derived from",
+            )
+
+        by_file: dict[str, list[str]] = {}
+        for path, lineno, literal in findings:
+            by_file.setdefault(path, []).append(f"{path}:{lineno} -> {literal}")
+        detail = (
+            f"{len(findings)} version literal(s) disagree with {self.version}. "
+            "Update them, or make the file version-agnostic, or add a documented "
+            "entry to build/release/version.py::VERSION_STRING_ALLOWLIST:\n"
+            + "\n".join(line for lines in by_file.values() for line in lines)
+        )
+        return Step("version-strings", False, detail, data={"count": len(findings)})
+
     def _tests(self) -> Step:
         if self.options.skip_tests:
             return Step(
@@ -439,17 +469,16 @@ class Preflight:
         for tag, wheel, executable in targets:
             label = f"{tag} {wheel.name}"
             try:
-                if self.options.no_assets:
-                    assets_out = "asset check skipped (--no-assets)"
-                else:
-                    assets_out = verify_wheel_assets(wheel, python_executable=executable)
-                runtime_out = verify_wheel_runtime(
+                # One venv per wheel: it runs the import smoke test, the bundled
+                # asset check and the frame pipeline together.
+                record = verify_wheel(
                     wheel,
                     video=video,
                     config_name=self.options.config_name,
                     frames=self.options.frames,
                     python_executable=executable,
                     offline=self.options.offline,
+                    check_assets=not self.options.no_assets,
                 )
             except subprocess.CalledProcessError as exc:
                 problems.append(f"{label}: command failed ({exc})")
@@ -458,8 +487,11 @@ class Preflight:
                 problems.append(f"{label}: {type(exc).__name__}: {exc}")
                 continue
 
-            lines.append(f"{label}: {assets_out} | frames={runtime_out['frames']} flow={runtime_out['flow_shape']}")
-            self.runtime_records.append({"tag": tag, "wheel": wheel.name, **runtime_out})
+            lines.append(
+                f"{label}: {record['assets']} | frames={record['frames']} "
+                f"flow={record['flow_shape']}"
+            )
+            self.runtime_records.append({"tag": tag, **record})
 
         detail = "\n".join(lines)
         if problems:
@@ -480,6 +512,7 @@ class Preflight:
             for step_fn in (
                 self._repo_state,
                 self._version_consistency,
+                self._version_strings,
                 self._duplicate_guard,
                 self._tests,
                 self._bundle_precheck,