cf-bootstrap-instance 0.1.8__py3-none-any.whl

cf_bootstrap_instance/service_executor.py

@@ -0,0 +1,178 @@
+"""The bounded first installer-service operation."""
+
+from __future__ import annotations
+
+import sys
+import importlib
+import hashlib
+import json
+import os
+import stat
+from pathlib import Path
+from collections.abc import Mapping
+
+from .layout import read_marker
+
+OPERATION = "urn:cf:service:accept_bootstrap_handoff"
+CAPABILITY = "urn:cf:service:BootstrapInstallationHandoff"
+PROFILED_OPERATION = "urn:cf:service:accept_profiled_bootstrap_handoff"
+PROFILED_CAPABILITY = "urn:cf:service:ProfiledBootstrapInstallationHandoff"
+PYPI_PROFILED_OPERATION = "urn:cf:service:accept_pypi_profiled_bootstrap_handoff"
+PYPI_PROFILED_CAPABILITY = "urn:cf:service:PublicPyPIProfiledBootstrapInstallationHandoff"
+
+
+def _helpers():
+    envelopes = importlib.import_module("cf_" + "service_client.envelopes")
+    executor = importlib.import_module("cf_" + "service_client.executor")
+    return envelopes.error_result, envelopes.json_output, envelopes.ok_result, executor.parse_executor_request
+
+
+def _canonical(value: object) -> bytes:
+    return (json.dumps(value, sort_keys=True, separators=(",", ":")) + "\n").encode()
+
+
+def _digest(value: object) -> str:
+    return "sha256:" + hashlib.sha256(_canonical(value)).hexdigest()
+
+
+def _link_free(path: Path) -> bool:
+    current = path
+    components: list[Path] = []
+    while current != Path(current.anchor):
+        components.append(current)
+        current = current.parent
+    for component in reversed(components):
+        if component.is_symlink():
+            return False
+        if os.name == "nt" and component.exists():
+            try:
+                if os.lstat(component).st_file_attributes & stat.FILE_ATTRIBUTE_REPARSE_POINT:
+                    return False
+            except OSError:
+                return False
+    return True
+
+
+def _accepted_handoff(root: Path, inputs: Mapping[str, object], marker: Mapping[str, object]) -> dict[str, str]:
+    bundle = Path(str(inputs["post_handoff_artifact_root"]))
+    if not bundle.is_absolute() or not _link_free(bundle) or bundle.is_symlink() or not bundle.is_dir():
+        raise ValueError("post-handoff artifact root is missing or unsafe")
+    bundle = bundle.resolve()
+    environment = Path(sys.prefix).resolve()
+    source = inputs.get("artifact_source")
+    checkout = inputs.get("checkout_path")
+    protected = [root.resolve(), environment, Path(str(inputs["cogniflow_home"])).resolve()]
+    if checkout is not None:
+        protected.append(Path(str(checkout)).resolve())
+    if any(bundle == item or bundle.is_relative_to(item) or item.is_relative_to(bundle) for item in protected):
+        raise ValueError("post-handoff artifact root overlaps a protected root")
+    payload = {
+        "schema": "cf.bootstrap.accepted-handoff.v3" if source is not None else "cf.bootstrap.accepted-handoff.v2",
+        "instance_id": str(inputs["instance_id"]),
+        "installation_root": str(root),
+        "target_python": str(Path(sys.executable).resolve()),
+        "plan_digest": str(inputs["plan_digest"]),
+        "bootstrap_host_artifact_set_digest": str(inputs["artifact_set_digest"]),
+        "profile": str(inputs["profile"]),
+        **({"profile_digest": str(inputs["profile_digest"])} if source is None else {"artifact_source": dict(source)}),
+        "bootstrap_selection_digest": str(inputs["selection_digest"]),
+        "cogniflow_home": str(Path(str(inputs["cogniflow_home"])).resolve()),
+        **({"checkout_path": str(Path(str(checkout)).resolve())} if checkout is not None else {}),
+        "post_handoff_artifact_root": str(bundle),
+        "post_handoff_artifact_set_digest": str(inputs["post_handoff_artifact_set_digest"]),
+        "post_handoff_selection_digest": str(inputs["post_handoff_selection_digest"]),
+        "post_handoff_profile_digest": str(inputs.get("post_handoff_profile_digest", inputs["artifact_set_digest"])),
+        "post_handoff_catalog_digest": str(inputs.get("post_handoff_catalog_digest", inputs["artifact_set_digest"])),
+        "post_handoff_repository_source_digest": str(inputs.get("post_handoff_repository_source_digest", _digest(source))),
+        "post_handoff_index_digest": str(inputs.get("post_handoff_index_digest", _digest("https://pypi.org/simple"))),
+        **({"recovery_manifest_path": str(marker["recovery_manifest_path"]), "recovery_manifest_digest": str(marker["recovery_manifest_digest"])} if "recovery_manifest_path" in marker else {}),
+
+    }
+    payload["record_digest"] = _digest(payload)
+    path = root / ".cogniflow-profile-handoff.json"
+    raw = _canonical(payload)
+    if path.exists():
+        if path.is_symlink() or not path.is_file() or path.read_bytes() != raw:
+            raise ValueError("accepted handoff record differs from the existing record")
+    else:
+        from .layout import atomic_write
+        atomic_write(path, raw)
+    return payload
+
+
+def execute(request: Mapping[str, object]) -> dict[str, object]:
+    error_result, json_output, ok_result, parse_executor_request = _helpers()
+    try:
+        parsed = parse_executor_request(request)
+        operation = request["operation"]
+        if not isinstance(operation, Mapping):
+            return error_result("UNSUPPORTED_OPERATION", "operation is not the bootstrap handoff operation")
+        local_profiled = operation.get("iri") == PROFILED_OPERATION and operation.get("toolName") == "accept_profiled_bootstrap_handoff" and operation.get("capability") == PROFILED_CAPABILITY
+        pypi_profiled = operation.get("iri") == PYPI_PROFILED_OPERATION and operation.get("toolName") == "accept_pypi_profiled_bootstrap_handoff" and operation.get("capability") == PYPI_PROFILED_CAPABILITY
+        profiled = local_profiled or pypi_profiled
+        legacy = operation.get("iri") == OPERATION and operation.get("toolName") == "accept_bootstrap_handoff" and operation.get("capability") == CAPABILITY
+        if not (profiled or legacy):
+            return error_result("UNSUPPORTED_OPERATION", "operation is not a supported bootstrap handoff operation")
+        if parsed.parameters:
+            return error_result("INVALID_ARGUMENT", "parameters are not accepted")
+        expected = {"instance_id", "installation_root", "plan_digest", "artifact_set_digest"}
+        pypi = pypi_profiled
+        if profiled:
+            expected |= ({"profile", "selection_digest", "cogniflow_home", "artifact_source", "post_handoff_artifact_root", "post_handoff_artifact_set_digest", "post_handoff_selection_digest", "post_handoff_binding_digest"} if pypi else {"profile", "profile_digest", "selection_digest", "cogniflow_home", "checkout_path", "post_handoff_artifact_root", "post_handoff_artifact_set_digest", "post_handoff_selection_digest", "post_handoff_binding_digest", "post_handoff_profile_digest", "post_handoff_catalog_digest", "post_handoff_repository_source_digest", "post_handoff_index_digest"})
+        source = parsed.inputs.get("artifact_source")
+        if set(parsed.inputs) != expected or any(not isinstance(value, str) or not value for key, value in parsed.inputs.items() if key != "artifact_source") or (pypi and (not isinstance(source, dict) or set(source) != {"mode", "package", "version"} or source.get("mode") != "pypi" or any(not isinstance(source.get(key), str) or not source[key] for key in ("package", "version")))):
+            return error_result("INVALID_ARGUMENT", "handoff inputs are strict")
+        environment = Path(sys.prefix).resolve()
+        python = Path(sys.executable).resolve()
+        raw_root = Path(parsed.inputs["installation_root"])
+        if not raw_root.is_absolute() or not _link_free(raw_root):
+            return error_result("TARGET_MISMATCH", "installation root is unsafe")
+        root = raw_root.resolve()
+        protected_keys = ("cogniflow_home",) if pypi else ("cogniflow_home", "checkout_path")
+        protected_inputs = {key: Path(parsed.inputs[key]) for key in protected_keys} if profiled else {}
+        if profiled and any(not path.is_absolute() or not _link_free(path) or path == Path(path.anchor) for path in protected_inputs.values()):
+            return error_result("TARGET_MISMATCH", "profiled handoff root is unsafe")
+        marker_path = root / ".cogniflow-instance.json"
+        marker, _ = read_marker(marker_path)
+        if profiled and marker.get("schema") != ("cf.bootstrap.instance-marker.v1" if pypi else "cf.bootstrap.instance-marker.v2"):
+            return error_result("MARKER_MISMATCH", "profiled handoff requires a v2 instance marker")
+        else:
+            marker, _ = read_marker(marker_path)
+        expected_paths = {"installation_root": root, "environment_root": environment, "python_executable": python}
+        if marker["instance_id"] != parsed.inputs["instance_id"] or marker["plan_digest"] != parsed.inputs["plan_digest"] or marker["artifact_set_digest"] != parsed.inputs["artifact_set_digest"]:
+            return error_result("MARKER_MISMATCH", "instance marker digests or identity do not match")
+        if profiled and not pypi and any(marker[key] != parsed.inputs[key] for key in ("profile", "profile_digest", "selection_digest")):
+            return error_result("MARKER_MISMATCH", "profile or selection digests do not match")
+        if profiled:
+            bundle_raw = Path(parsed.inputs["post_handoff_artifact_root"])
+            if not bundle_raw.is_absolute() or not _link_free(bundle_raw):
+                return error_result("ARTIFACT_MISMATCH", "post-handoff artifact root is unsafe")
+            bundle = bundle_raw.resolve()
+            protected = (root, environment, *(path.resolve() for path in protected_inputs.values()))
+            if bundle.is_symlink() or any(bundle == item or bundle.is_relative_to(item) or item.is_relative_to(bundle) for item in protected):
+                return error_result("ARTIFACT_MISMATCH", "post-handoff artifact root is invalid")
+            binding_keys = (("cogniflow_home", "artifact_source", "post_handoff_artifact_root", "post_handoff_artifact_set_digest", "post_handoff_selection_digest") if pypi else ("cogniflow_home", "checkout_path", "post_handoff_artifact_root", "post_handoff_artifact_set_digest", "post_handoff_selection_digest", "post_handoff_profile_digest", "post_handoff_catalog_digest", "post_handoff_repository_source_digest", "post_handoff_index_digest"))
+            binding = {key: parsed.inputs[key] for key in binding_keys}
+            import hashlib, json
+            expected_binding = "sha256:" + hashlib.sha256((json.dumps(binding, sort_keys=True, separators=(",", ":")) + "\n").encode()).hexdigest()
+            if parsed.inputs["post_handoff_binding_digest"] != expected_binding:
+                return error_result("ARTIFACT_MISMATCH", "post-handoff artifact binding is invalid")
+        for key, value in expected_paths.items():
+            if Path(str(marker[key])).resolve() != value:
+                return error_result("TARGET_MISMATCH", "executor is not running in the marked target environment")
+        outputs = [
+            json_output("status", "accepted"), json_output("instance_id", marker["instance_id"]),
+            json_output("installation_root", str(root)), json_output("environment_root", str(environment)),
+            json_output("python_executable", str(python)), json_output("plan_digest", marker["plan_digest"]),
+            json_output("artifact_set_digest", marker["artifact_set_digest"]),
+        ]
+        if profiled:
+            record = _accepted_handoff(root, parsed.inputs, marker)
+            if pypi:
+                outputs.extend((json_output("profile", parsed.inputs["profile"]), json_output("selection_digest", parsed.inputs["selection_digest"])))
+            else:
+                outputs.extend(json_output(key, marker[key]) for key in ("profile", "profile_digest", "selection_digest"))
+            outputs.append(json_output("accepted_handoff_record", record))
+        return ok_result(outputs)
+    except (ValueError, OSError) as error:
+        return error_result("INVALID_REQUEST", str(error))

cf_bootstrap_instance/transition_authority.py

@@ -0,0 +1,136 @@
+"""Crash-safe authority validation for accepted profile transitions."""
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+from pathlib import Path
+from typing import Any, Mapping
+
+from .layout import atomic_write
+
+_DIGEST = re.compile(r"sha256:[0-9a-f]{64}\Z")
+_PROFILE = re.compile(r"urn:cf:profile:[A-Za-z0-9.-]+\Z")
+_STATE = ".cogniflow-profile-transition.json"
+
+
+def _digest(value: object) -> str:
+    return "sha256:" + hashlib.sha256((json.dumps(value, sort_keys=True, separators=(",", ":")) + "\n").encode()).hexdigest()
+
+
+def _canonical(value: object) -> bytes:
+    return (json.dumps(value, sort_keys=True, separators=(",", ":")) + "\n").encode()
+
+
+def _recovery_path(root: Path) -> Path:
+    return root / "state" / "minimum-service-plane" / "recovery-manifest.json"
+
+
+def _paths(root: Path) -> dict[str, Path]:
+    return {"marker": root / ".cogniflow-instance.json", "handoff": root / ".cogniflow-profile-handoff.json", "manifest": root / ".cogniflow-profile.json", "recovery": _recovery_path(root)}
+
+
+def validate_pair(current: dict[str, Any], target: dict[str, Any]) -> None:
+    required = {"profile", "plan_digest", "bootstrap_selection_digest", "bootstrap_artifact_set_digest", "post_handoff_artifact_set_digest", "post_handoff_selection_digest", "post_handoff_profile_digest", "post_handoff_catalog_digest", "post_handoff_repository_source_digest", "post_handoff_index_digest", "recovery_manifest_digest"}
+    if set(current) != required or set(target) != required or current == target:
+        raise ValueError("authority transition bindings are incomplete")
+    for item in (current, target):
+        if not _PROFILE.fullmatch(str(item["profile"])):
+            raise ValueError("authority profile is invalid")
+        if any(not isinstance(item[key], str) or not _DIGEST.fullmatch(item[key]) for key in required - {"profile"}):
+            raise ValueError("authority transition bindings are invalid")
+
+
+def _read(path: Path) -> dict[str, Any]:
+    if path.is_symlink() or not path.is_file():
+        raise ValueError("authority file is missing or unsafe")
+    raw = path.read_bytes()
+    value = json.loads(raw)
+    if not isinstance(value, dict) or raw != _canonical(value):
+        raise ValueError("authority file is not canonical")
+    return value
+
+
+def _snapshot(root: Path) -> dict[str, str]:
+    return {name: _canonical(_read(path)).decode() for name, path in _paths(root).items()}
+
+
+def _state(root: Path) -> dict[str, Any]:
+    path = root / _STATE
+    if path.is_symlink() or not path.is_file():
+        raise ValueError("profile transition state is missing")
+    raw = path.read_bytes()
+    value = json.loads(raw)
+    if not isinstance(value, dict) or raw != _canonical(value) or value.get("schema") != "cf.bootstrap.profile-transition-authority.v1" or value.get("status") not in {"prepared", "committed"}:
+        raise ValueError("profile transition state is invalid")
+    return value
+
+
+def classify(root: Path) -> str:
+    state = _state(root)
+    actual = _snapshot(root)
+    if actual == state["current"]["files"]:
+        return "complete-a"
+    if actual == state["target"]["files"]:
+        return "complete-b"
+    raise ValueError("profile transition authority is mixed or tampered")
+
+
+def recover(root: Path) -> str:
+    state = _state(root)
+    actual = _snapshot(root)
+    current_files = state.get("current", {}).get("files")
+    target_files = state.get("target", {}).get("files")
+    if not isinstance(current_files, dict) or not isinstance(target_files, dict) or set(current_files) != set(_paths(root)) or set(target_files) != set(_paths(root)):
+        raise ValueError("profile transition state snapshots are invalid")
+    if actual == current_files:
+        classification = "complete-a"
+    elif actual == target_files:
+        classification = "complete-b"
+    elif all(actual[name] in {current_files[name], target_files[name]} for name in actual):
+        classification = "prepared-mixed"
+    else:
+        raise ValueError("profile transition authority is mixed or tampered")
+    if state["status"] == "committed":
+        return "complete-b" if classification == "complete-b" else classify(root)
+    for name, path in _paths(root).items():
+        if actual[name] != current_files[name]:
+            atomic_write(path, current_files[name].encode())
+    (root / _STATE).unlink()
+    return "complete-a"
+
+
+def rebind(root: Path, current: dict[str, Any], target: dict[str, Any], *, marker: dict[str, Any], handoff: dict[str, Any], manifest: dict[str, Any], recovery: dict[str, Any], target_handoff: Mapping[str, Any] | None = None, target_manifest: Mapping[str, Any] | None = None, target_recovery: Mapping[str, Any] | None = None, target_marker: Mapping[str, Any] | None = None) -> None:
+    """Publish complete B authority as one restart-classifiable commit."""
+    legacy = {"profile", "plan_digest", "artifact_set_digest", "recovery_manifest_digest"}
+    def complete(value: dict[str, Any]) -> dict[str, Any]:
+        if set(value) != legacy:
+            return value
+        return {"profile": value["profile"], "plan_digest": value["plan_digest"], "bootstrap_selection_digest": value["artifact_set_digest"], "bootstrap_artifact_set_digest": value["artifact_set_digest"], "post_handoff_artifact_set_digest": value["artifact_set_digest"], "post_handoff_selection_digest": value["artifact_set_digest"], "post_handoff_profile_digest": value["artifact_set_digest"], "post_handoff_catalog_digest": value["artifact_set_digest"], "post_handoff_repository_source_digest": value["artifact_set_digest"], "post_handoff_index_digest": value["artifact_set_digest"], "recovery_manifest_digest": value["recovery_manifest_digest"]}
+    current = complete(current)
+    target = complete(target)
+    validate_pair(current, target)
+    if any(item.get("profile") != current["profile"] for item in (marker, handoff, manifest)):
+        raise ValueError("current authority does not match A")
+    paths = _paths(root)
+    if not paths["recovery"].is_file() or paths["recovery"].read_bytes() != _canonical(recovery):
+        raise ValueError("retained recovery authority does not match A")
+    if current["recovery_manifest_digest"] != "sha256:" + hashlib.sha256(paths["recovery"].read_bytes()).hexdigest():
+        raise ValueError("current recovery authority digest does not match A")
+    marker_value = {**marker, **dict(target_marker or {}), "profile": target["profile"], "plan_digest": target["plan_digest"], "artifact_set_digest": target["bootstrap_artifact_set_digest"], "recovery_manifest_digest": target["recovery_manifest_digest"]}
+    handoff_value = {**handoff, **dict(target_handoff or {}), "profile": target["profile"], "plan_digest": target["plan_digest"], "bootstrap_host_artifact_set_digest": target["bootstrap_artifact_set_digest"], "recovery_manifest_digest": target["recovery_manifest_digest"]}
+    handoff_value.pop("record_digest", None)
+    handoff_value["record_digest"] = _digest(handoff_value)
+    manifest_value = {**manifest, **dict(target_manifest or {}), "profile": target["profile"], "plan_digest": target["plan_digest"], "handoff_record_digest": handoff_value["record_digest"], "bootstrap_host_artifact_set_digest": target["bootstrap_artifact_set_digest"]}
+    recovery_value = {**recovery, **dict(target_recovery or {}), "plan_digest": target["plan_digest"], "artifact_set_digest": target["bootstrap_artifact_set_digest"]}
+    target_recovery_digest = "sha256:" + hashlib.sha256(_canonical(recovery_value)).hexdigest()
+    if target["recovery_manifest_digest"] != target_recovery_digest:
+        raise ValueError("target recovery authority digest does not match B")
+    current_files = _snapshot(root)
+    target_values = {"marker": marker_value, "handoff": handoff_value, "manifest": manifest_value, "recovery": recovery_value}
+    target_files = {name: _canonical(value).decode() for name, value in target_values.items()}
+    state = {"schema": "cf.bootstrap.profile-transition-authority.v1", "status": "prepared", "current": {**current, "files": current_files}, "target": {**target, "files": target_files}}
+    atomic_write(root / _STATE, _canonical(state))
+    for name, value in target_values.items():
+        atomic_write(paths[name], _canonical(value))
+    atomic_write(root / _STATE, _canonical({**state, "status": "committed"}))

cf_bootstrap_instance/uninstall_authority.py

@@ -0,0 +1,119 @@
+"""Strict accepted-instance authority classification for uninstall."""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+from pathlib import Path
+import re
+import stat
+
+from .layout import read_marker
+from .transition_authority import classify as classify_transition
+
+_DIGEST = re.compile(r"sha256:[0-9a-f]{64}\Z")
+
+
+def _canonical(value: object) -> bytes:
+    return (json.dumps(value, sort_keys=True, separators=(",", ":")) + "\n").encode()
+
+
+def _regular_canonical(path: Path) -> dict[str, object]:
+    try:
+        info = os.lstat(path)
+        if stat.S_ISLNK(info.st_mode) or not stat.S_ISREG(info.st_mode) or (os.name == "nt" and info.st_file_attributes & getattr(stat, "FILE_ATTRIBUTE_REPARSE_POINT", 0x400)):
+            raise ValueError
+        raw = path.read_bytes()
+        value = json.loads(raw)
+    except (OSError, ValueError, json.JSONDecodeError) as error:
+        raise ValueError(f"accepted authority file is missing or unsafe: {path.name}") from error
+    if not isinstance(value, dict) or raw != _canonical(value):
+        raise ValueError(f"accepted authority file is not canonical: {path.name}")
+    return value
+
+
+def _link_free(path: Path) -> bool:
+    current = path
+    while current != Path(current.anchor):
+        try:
+            info = os.lstat(current)
+        except FileNotFoundError:
+            current = current.parent
+            continue
+        if stat.S_ISLNK(info.st_mode) or (os.name == "nt" and info.st_file_attributes & getattr(stat, "FILE_ATTRIBUTE_REPARSE_POINT", 0x400)):
+            return False
+        current = current.parent
+    return True
+
+
+def classify_uninstall(target_python: Path, cogniflow_home: Path) -> dict[str, object]:
+    """Authenticate accepted profiled authority and return only derived identity."""
+    target = Path(target_python).absolute()
+    home = Path(cogniflow_home).absolute()
+    if not target.is_absolute() or not home.is_absolute() or target == Path(target.anchor) or home == Path(home.anchor):
+        raise ValueError("uninstall paths must be absolute non-root paths")
+    root = (target.parent.parent.parent if os.name == "nt" else target.parent.parent).absolute()
+    expected = root / "environment" / ("Scripts/python.exe" if os.name == "nt" else "bin/python")
+    if target != expected or not target.is_file() or not _link_free(root) or not _link_free(home):
+        raise ValueError("target interpreter is not a safe accepted instance path")
+    if root == home or root in home.parents or home in root.parents:
+        raise ValueError("installation root and Cogniflow home must be disjoint")
+
+    transition = root / ".cogniflow-profile-transition.json"
+    if transition.exists() and classify_transition(root) not in {"complete-a", "complete-b"}:
+        raise ValueError("profile transition authority is not complete")
+
+    marker, marker_raw = read_marker(root / ".cogniflow-instance.json")
+    handoff = _regular_canonical(root / ".cogniflow-profile-handoff.json")
+    manifest = _regular_canonical(root / ".cogniflow-profile.json")
+    recovery_path = root / "state" / "minimum-service-plane" / "recovery-manifest.json"
+    recovery = _regular_canonical(recovery_path)
+    if marker.get("schema") != "cf.bootstrap.instance-marker.v2":
+        raise ValueError("uninstall requires an accepted profiled instance")
+    bindings = (
+        marker.get("installation_root") == str(root),
+        marker.get("environment_root") == str(root / "environment"),
+        marker.get("python_executable") == str(target),
+        handoff.get("installation_root") == str(root),
+        handoff.get("target_python") == str(target),
+        handoff.get("cogniflow_home") == str(home),
+        handoff.get("instance_id") == marker.get("instance_id"),
+        handoff.get("profile") == marker.get("profile") == manifest.get("profile"),
+        handoff.get("plan_digest") == marker.get("plan_digest") == manifest.get("plan_digest"),
+        handoff.get("bootstrap_host_artifact_set_digest") == marker.get("artifact_set_digest") == manifest.get("bootstrap_host_artifact_set_digest"),
+        handoff.get("record_digest") == manifest.get("handoff_record_digest"),
+        marker.get("recovery_manifest_path") == str(recovery_path),
+        marker.get("recovery_manifest_digest") == handoff.get("recovery_manifest_digest"),
+        recovery.get("plan_digest") == marker.get("plan_digest"),
+        recovery.get("artifact_set_digest") == marker.get("artifact_set_digest"),
+        manifest.get("host") == marker.get("installed_distributions"),
+        isinstance(manifest.get("installed"), list),
+        isinstance(manifest.get("semantic"), dict),
+    )
+    if not all(bindings):
+        raise ValueError("accepted uninstall authority is mixed or foreign")
+    accepted_digests = {
+        "plan": marker.get("plan_digest"),
+        "bootstrap_artifact_set": marker.get("artifact_set_digest"),
+        "profile": marker.get("profile_digest"),
+        "catalog": marker.get("catalog_digest"),
+        "selection": marker.get("selection_digest"),
+        "handoff": handoff.get("record_digest"),
+        "post_handoff_artifact_set": handoff.get("post_handoff_artifact_set_digest"),
+        "recovery": marker.get("recovery_manifest_digest"),
+        "profile_manifest": "sha256:" + hashlib.sha256(_canonical(manifest)).hexdigest(),
+        "marker": "sha256:" + hashlib.sha256(marker_raw).hexdigest(),
+    }
+    if any(not isinstance(value, str) or not _DIGEST.fullmatch(value) for value in accepted_digests.values()):
+        raise ValueError("accepted uninstall authority digest is invalid")
+    return {
+        "schema": "cf.bootstrap.uninstall-authority.v1",
+        "instance_id": marker["instance_id"],
+        "profile": marker["profile"],
+        "installation_root": str(root),
+        "target_python": str(target),
+        "cogniflow_home": str(home),
+        "accepted_digests": accepted_digests,
+        "installed_distributions": manifest["installed"],
+        "semantic": manifest.get("semantic"),
+    }