solverpilot 0.1__py3-none-any.whl

solverpilot/runtime/auto.py

@@ -0,0 +1,193 @@
+from __future__ import annotations
+
+from dataclasses import asdict, replace
+from time import perf_counter
+
+from solverpilot.diagnose import diagnose_infeasibility
+from solverpilot.validate import PublicStatus
+from solverpilot.backends import (
+    Backend,
+    BackendRegistry,
+    BackendHealthReport,
+    ScipyHighsBackend,
+    ScipyHighsLPBackend,
+    ScipySLSQPQPBackend,
+    HighspyNativeBackend,
+    OSQPNativeBackend,
+    PySCIPOptNativeBackend,
+    NLoptNativeBackend,
+    CasadiOSQPBridgeBackend,
+    CasadiHighsBridgeBackend,
+    CasadiCBCBridgeBackend,
+    BundledOSQPCAPIBackend,
+    BundledHighsCAPIBackend,
+)
+from solverpilot.inspect import inspect_problem
+from solverpilot.plan import HealthPolicy, PlannerContext, SolveBudget, SolveIntent, plan_solve, PerformancePolicy, ProductionEvidence, M22_OFFICIAL_EVIDENCE, ProductionDecision, plan_production_solve
+from solverpilot.problem import LinearProblem, QuadraticProblem
+from solverpilot.trace import PhaseTimings
+
+from .budgeting import apply_budget
+from .executor import execute
+from .result import SolveResult
+
+
+def builtin_backend_candidates() -> tuple[Backend, ...]:
+    """Return all supported adapter candidates, including unavailable/verification-only ones.
+
+    This audit surface is intentionally broader than ``default_registry``: verification
+    bridges and unavailable optional native packages remain visible for provenance and
+    health checks, while production solving still excludes verification-only adapters.
+    """
+
+    return (
+        HighspyNativeBackend(),
+        OSQPNativeBackend(),
+        PySCIPOptNativeBackend(),
+        ScipyHighsLPBackend(method="highs-ds"),
+        ScipyHighsLPBackend(method="highs-ipm"),
+        ScipyHighsBackend(),
+        ScipySLSQPQPBackend(),
+        NLoptNativeBackend(),
+        CasadiOSQPBridgeBackend(),
+        CasadiHighsBridgeBackend(),
+        CasadiCBCBridgeBackend(),
+        BundledOSQPCAPIBackend(),
+        BundledHighsCAPIBackend(),
+    )
+
+
+def default_registry() -> BackendRegistry:
+    """Create the conservative built-in runtime registry.
+
+    The registry contains only adapters that can actually be imported in the base
+    dependency set.  Native highspy/OSQP/SCIP backends are intentionally not
+    invented when their dependencies are absent.
+    """
+
+    registry = BackendRegistry()
+    for backend in builtin_backend_candidates():
+        # Optional native adapters remain absent from the solving registry when their
+        # dependency is absent. ``builtin_backend_candidates`` is the explicit audit surface.
+        if backend.manifest.metadata.get("native_adapter") and not backend.is_available():
+            continue
+        if backend.manifest.metadata.get("verification_only") is True:
+            continue
+        registry.register(backend)
+    return registry
+
+
+def solve(
+    problem: LinearProblem | QuadraticProblem,
+    *,
+    registry: BackendRegistry | None = None,
+    backend: str | Backend | None = None,
+    intent: SolveIntent | str = SolveIntent.BALANCED,
+    budget: SolveBudget | None = None,
+    context: PlannerContext | None = None,
+    health_reports: tuple[BackendHealthReport, ...] | None = None,
+    health_policy: HealthPolicy | str = HealthPolicy.IGNORE,
+    diagnose_infeasible: bool = False,
+) -> SolveResult:
+    """Solve a problem either with an explicit backend or the deterministic planner."""
+
+    total_t0 = perf_counter()
+    registry = default_registry() if registry is None else registry
+
+    inspect_t0 = perf_counter()
+    fingerprint = inspect_problem(problem)
+    inspect_s = perf_counter() - inspect_t0
+
+    plan_s = 0.0
+    plan = None
+    if backend is None:
+        plan_t0 = perf_counter()
+        plan = plan_solve(
+            problem,
+            registry,
+            intent=intent,
+            budget=budget,
+            fingerprint=fingerprint,
+            context=context,
+            health_reports=health_reports,
+            health_policy=health_policy,
+        )
+        plan_s = perf_counter() - plan_t0
+        chosen = registry.get(plan.selected_backend)
+    elif isinstance(backend, str):
+        chosen = registry.get(backend)
+    else:
+        chosen = backend
+
+    chosen = apply_budget(chosen, budget)
+    result = execute(problem, chosen)
+
+    diagnose_s = 0.0
+    diagnostics = None
+    if diagnose_infeasible and result.status is PublicStatus.INFEASIBLE and isinstance(problem, LinearProblem):
+        diagnose_t0 = perf_counter()
+        diagnostics = diagnose_infeasibility(
+            problem,
+            backend=chosen,
+            time_limit_s=None if budget is None else budget.wall_time_s,
+        )
+        diagnose_s = perf_counter() - diagnose_t0
+        result = replace(result, diagnostics=diagnostics)
+
+    total_s = perf_counter() - total_t0
+    old = result.trace.timings
+    timings = PhaseTimings(
+        inspect_s=inspect_s,
+        plan_s=plan_s,
+        backend_build_s=old.backend_build_s,
+        solve_s=old.solve_s,
+        validate_s=old.validate_s,
+        diagnose_s=old.diagnose_s + diagnose_s,
+        total_s=total_s,
+    )
+    trace = replace(
+        result.trace,
+        timings=timings,
+        fingerprint=asdict(fingerprint),
+        planner_selected_backend=None if plan is None else plan.selected_backend,
+        planner_evidence_level=None if plan is None else plan.evidence_level,
+        planner_health_policy=None if plan is None else plan.health_policy.value,
+    )
+    return replace(result, trace=trace, plan=plan)
+
+
+# Backward-compatible internal alias retained for M1-M7 regression tests and callers
+# that imported the previous private helper. New code should import apply_budget from
+# solverpilot.runtime.
+_apply_budget = apply_budget
+
+
+def solve_production(
+    problem: LinearProblem | QuadraticProblem,
+    *,
+    registry: BackendRegistry | None = None,
+    intent: SolveIntent | str = SolveIntent.BALANCED,
+    budget: SolveBudget | None = None,
+    context: PlannerContext | None = None,
+    health_reports: tuple[BackendHealthReport, ...] | None = None,
+    health_policy: HealthPolicy | str = HealthPolicy.PREFER_HEALTHY,
+    evidence: ProductionEvidence = M22_OFFICIAL_EVIDENCE,
+    performance_policy: PerformancePolicy | str = PerformancePolicy.REQUIRE_COMPARATIVE,
+    performance_override: dict[str, str] | None = None,
+    diagnose_infeasible: bool = False,
+) -> tuple[SolveResult, ProductionDecision]:
+    """Conservative proof-safe solve plus the auditable production routing decision."""
+    registry = default_registry() if registry is None else registry
+    fingerprint = inspect_problem(problem)
+    decision = plan_production_solve(
+        problem, registry, evidence=evidence, intent=intent, budget=budget,
+        fingerprint=fingerprint, context=context, health_reports=health_reports,
+        health_policy=health_policy, performance_policy=performance_policy,
+        performance_override=performance_override,
+    )
+    result = solve(
+        problem, registry=registry, backend=decision.plan.selected_backend, intent=intent,
+        budget=budget, context=context, health_reports=health_reports,
+        health_policy=health_policy, diagnose_infeasible=diagnose_infeasible,
+    )
+    return replace(result, plan=decision.plan), decision

solverpilot/runtime/budgeting.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from dataclasses import is_dataclass, replace
+
+from solverpilot.backends import Backend
+from solverpilot.plan import SolveBudget
+from solverpilot.exceptions import BudgetNotSupportedError
+
+
+def apply_budget(backend: Backend, budget: SolveBudget | None) -> Backend:
+    if budget is None:
+        return backend
+    if budget.memory_mb is not None:
+        raise BudgetNotSupportedError(
+            "memory budgets are modeled but are not yet enforceable by built-in backends"
+        )
+
+    updates: dict[str, object] = {}
+    if budget.wall_time_s is not None:
+        if backend.manifest.metadata.get("supports_wall_time_budget") is False:
+            raise BudgetNotSupportedError(
+                f"backend {backend.manifest.name!r} has no verified wall-time budget mapping"
+            )
+        if not hasattr(backend, "time_limit_s"):
+            raise BudgetNotSupportedError(
+                f"backend {backend.manifest.name!r} cannot enforce a wall-time budget"
+            )
+        updates["time_limit_s"] = float(budget.wall_time_s)
+
+    if budget.threads is not None:
+        if not hasattr(backend, "threads"):
+            raise BudgetNotSupportedError(
+                f"backend {backend.manifest.name!r} cannot enforce a thread budget"
+            )
+        updates["threads"] = int(budget.threads)
+
+    if not updates:
+        return backend
+    if not is_dataclass(backend):
+        raise TypeError(
+            f"backend {backend.manifest.name!r} exposes budget fields but is not safely cloneable"
+        )
+    return replace(backend, **updates)

solverpilot/runtime/executor.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+from dataclasses import replace
+from time import perf_counter
+
+from solverpilot.backends import Backend
+from solverpilot.exceptions import BackendUnavailableError, CapabilityMismatchError
+from solverpilot.capabilities import compatible, requirements_for
+from solverpilot.problem import LinearProblem, QuadraticProblem
+from solverpilot.trace import PhaseTimings, SolveTrace
+from solverpilot.validate import CandidateSolution, PublicStatus, validate_solution
+
+from .result import OptimalityEvidence, SolveResult
+
+
+def _problem_class(problem: LinearProblem | QuadraticProblem) -> str:
+    if isinstance(problem, QuadraticProblem):
+        return "convex_qp"
+    return "milp" if problem.has_integer_variables else "lp"
+
+
+def _normalize_status(backend_status: str, validation_valid: bool | None) -> PublicStatus:
+    if validation_valid is False:
+        return PublicStatus.INVALID_SOLUTION
+    if backend_status == "optimal":
+        return PublicStatus.VALID_OPTIMAL if validation_valid else PublicStatus.ERROR
+    if backend_status == "converged_candidate":
+        return PublicStatus.VALID_FEASIBLE if validation_valid else PublicStatus.ERROR
+    if backend_status == "limit_feasible":
+        return PublicStatus.FEASIBLE_LIMIT if validation_valid else PublicStatus.ERROR
+    if backend_status == "infeasible":
+        return PublicStatus.INFEASIBLE
+    if backend_status == "unbounded":
+        return PublicStatus.UNBOUNDED
+    if backend_status == "infeasible_or_unbounded":
+        return PublicStatus.INFEASIBLE_OR_UNBOUNDED
+    if backend_status in {"solver_error", "limit_no_solution"}:
+        return PublicStatus.ERROR
+    return PublicStatus.UNKNOWN
+
+
+def execute(
+    problem: LinearProblem | QuadraticProblem,
+    backend: Backend,
+) -> SolveResult:
+    total_t0 = perf_counter()
+    if not backend.is_available():
+        raise BackendUnavailableError(f"backend is unavailable: {backend.manifest.name}")
+    requirements = requirements_for(problem)
+    if not compatible(backend.manifest, requirements):
+        raise CapabilityMismatchError(
+            f"backend {backend.manifest.name!r} is incompatible with "
+            f"required capabilities {sorted(x.value for x in requirements.required)}"
+        )
+
+    solve_t0 = perf_counter()
+    backend_result = backend.solve(problem)
+    solve_s = perf_counter() - solve_t0
+
+    validation = None
+    validate_s = 0.0
+    if backend_result.x is not None:
+        validate_t0 = perf_counter()
+        validation = validate_solution(
+            problem,
+            CandidateSolution(
+                x=backend_result.x,
+                objective_reported=backend_result.objective_reported,
+            ),
+        )
+        validate_s = perf_counter() - validate_t0
+
+    public_status = _normalize_status(
+        backend_result.backend_status,
+        None if validation is None else validation.valid,
+    )
+    total_s = perf_counter() - total_t0
+
+    raw = backend_result.raw_statistics or {}
+    reuse_applied_raw = raw.get("reuse_applied")
+    reuse_applied = reuse_applied_raw if isinstance(reuse_applied_raw, bool) else None
+    reuse_mode_raw = raw.get("reuse_mode")
+    reuse_mode = str(reuse_mode_raw) if reuse_mode_raw is not None else None
+
+    trace = SolveTrace(
+        problem_structural_hash=problem.structural_hash,
+        problem_data_hash=problem.data_hash,
+        problem_class=_problem_class(problem),
+        backend=backend.manifest.name,
+        backend_version=backend.manifest.version,
+        timings=PhaseTimings(solve_s=solve_s, validate_s=validate_s, total_s=total_s),
+        termination=backend_result.backend_status,
+        validation_valid=None if validation is None else validation.valid,
+        reuse_applied=reuse_applied,
+        reuse_mode=reuse_mode,
+        warnings=() if validation is None else validation.warnings,
+    )
+
+    objective = None if validation is None else validation.objective_recomputed
+    raw_stats = dict(backend_result.raw_statistics or {})
+    evidence = OptimalityEvidence(
+        backend_reported_optimal=backend_result.backend_status == "optimal",
+        primal_validated=bool(validation is not None and validation.valid),
+        # Backend statistics are claims, not an independently checked proof.
+        # Keep them in raw_stats, but only a canonical verifier may promote them.
+        dual_verified=False,
+        gap_verified=False,
+        certificate_verified=False,
+    )
+    raw_stats["solverpilot_trust"] = {
+        "backend_reported_optimal": evidence.backend_reported_optimal,
+        "primal_validated": evidence.primal_validated,
+        "dual_verified": evidence.dual_verified,
+        "gap_verified": evidence.gap_verified,
+        "certificate_verified": evidence.certificate_verified,
+        "independently_verified_optimal": evidence.independently_verified_optimal,
+    }
+    return SolveResult(
+        status=public_status,
+        x=backend_result.x,
+        objective=objective,
+        backend_status=backend_result.backend_status,
+        validation=validation,
+        trace=trace,
+        raw_statistics=raw_stats,
+    )

solverpilot/runtime/portfolio.py

@@ -0,0 +1,197 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from time import perf_counter
+from typing import Iterable
+
+from solverpilot.backends import Backend, BackendHealthReport, BackendProbeStatus
+from solverpilot.plan import SolveBudget
+from solverpilot.problem import LinearProblem, ObjectiveSense, QuadraticProblem
+from solverpilot.validate import PublicStatus
+
+from .budgeting import apply_budget
+from .executor import execute
+from .result import SolveResult
+
+
+_VALID_SOLUTION_STATUSES = {
+    PublicStatus.VALID_OPTIMAL,
+    PublicStatus.VALID_FEASIBLE,
+    PublicStatus.FEASIBLE_LIMIT,
+}
+
+
+@dataclass(frozen=True, slots=True)
+class PortfolioAttempt:
+    backend: str
+    status: str | None
+    objective: float | None
+    validation_valid: bool | None
+    duration_s: float
+    error: str | None = None
+    skipped_reason: str | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class PortfolioSolveResult:
+    chosen: SolveResult | None
+    attempts: tuple[PortfolioAttempt, ...]
+    total_s: float
+    stopped_reason: str
+    budget_exhausted: bool
+
+    @property
+    def chosen_backend(self) -> str | None:
+        return None if self.chosen is None else self.chosen.trace.backend
+
+
+def _better(
+    problem: LinearProblem | QuadraticProblem,
+    incumbent: SolveResult | None,
+    candidate: SolveResult,
+) -> bool:
+    if candidate.status not in _VALID_SOLUTION_STATUSES or candidate.objective is None:
+        return False
+    if incumbent is None or incumbent.status not in _VALID_SOLUTION_STATUSES or incumbent.objective is None:
+        return True
+    if problem.objective_sense is ObjectiveSense.MINIMIZE:
+        return float(candidate.objective) < float(incumbent.objective)
+    return float(candidate.objective) > float(incumbent.objective)
+
+
+def _health_map(reports: Iterable[BackendHealthReport] | None) -> dict[str, BackendHealthReport]:
+    return {} if reports is None else {r.backend: r for r in reports}
+
+
+def execute_portfolio(
+    problem: LinearProblem | QuadraticProblem,
+    backends: Iterable[Backend],
+    *,
+    budget: SolveBudget | None = None,
+    stop_on_valid_optimal: bool = True,
+    health_reports: Iterable[BackendHealthReport] | None = None,
+    require_healthy: bool = False,
+) -> PortfolioSolveResult:
+    """Execute a sequential validated backend portfolio.
+
+    The portfolio is deliberately conservative: every candidate goes through the same
+    capability checks and independent validator as :func:`execute`; exceptions are
+    isolated to one attempt. If a global wall-time budget is supplied, remaining time
+    is passed to each backend and backends that cannot enforce it are skipped rather
+    than silently violating the budget.
+
+    This is an execution/fallback primitive, not an empirical solver-selection policy.
+    """
+
+    t0 = perf_counter()
+    attempts: list[PortfolioAttempt] = []
+    chosen: SolveResult | None = None
+    terminal_without_solution: list[SolveResult] = []
+    health = _health_map(health_reports)
+    stopped_reason = "portfolio_exhausted"
+    budget_exhausted = False
+
+    for backend in tuple(backends):
+        name = backend.manifest.name
+        report = health.get(name)
+        if report is not None and report.version != backend.manifest.version:
+            report = None
+        if report is not None and report.status in {BackendProbeStatus.UNHEALTHY, BackendProbeStatus.UNAVAILABLE}:
+            attempts.append(
+                PortfolioAttempt(
+                    backend=name,
+                    status=None,
+                    objective=None,
+                    validation_valid=None,
+                    duration_s=0.0,
+                    skipped_reason=f"health:{report.status.value}",
+                )
+            )
+            continue
+        if require_healthy and (report is None or report.status is not BackendProbeStatus.HEALTHY):
+            attempts.append(
+                PortfolioAttempt(
+                    backend=name,
+                    status=None,
+                    objective=None,
+                    validation_valid=None,
+                    duration_s=0.0,
+                    skipped_reason="health:not_confirmed_healthy",
+                )
+            )
+            continue
+
+        elapsed = perf_counter() - t0
+        remaining: float | None = None
+        if budget is not None and budget.wall_time_s is not None:
+            remaining = float(budget.wall_time_s) - elapsed
+            if remaining <= 0:
+                budget_exhausted = True
+                stopped_reason = "budget_exhausted"
+                break
+
+        attempt_budget = budget
+        if budget is not None and remaining is not None:
+            attempt_budget = SolveBudget(
+                wall_time_s=remaining,
+                memory_mb=budget.memory_mb,
+                threads=budget.threads,
+            )
+
+        a0 = perf_counter()
+        try:
+            configured = apply_budget(backend, attempt_budget)
+            result = execute(problem, configured)
+            duration = perf_counter() - a0
+            attempts.append(
+                PortfolioAttempt(
+                    backend=name,
+                    status=result.status.value,
+                    objective=None if result.objective is None else float(result.objective),
+                    validation_valid=None if result.validation is None else bool(result.validation.valid),
+                    duration_s=duration,
+                )
+            )
+
+            if _better(problem, chosen, result):
+                chosen = result
+            elif chosen is None and result.status in {
+                PublicStatus.INFEASIBLE,
+                PublicStatus.UNBOUNDED,
+                PublicStatus.INFEASIBLE_OR_UNBOUNDED,
+            }:
+                terminal_without_solution.append(result)
+
+            if stop_on_valid_optimal and result.status is PublicStatus.VALID_OPTIMAL:
+                chosen = result
+                stopped_reason = "valid_optimal_found"
+                break
+        except Exception as exc:
+            attempts.append(
+                PortfolioAttempt(
+                    backend=name,
+                    status=None,
+                    objective=None,
+                    validation_valid=None,
+                    duration_s=perf_counter() - a0,
+                    error=f"{type(exc).__name__}: {exc}",
+                )
+            )
+            continue
+
+    if chosen is None and terminal_without_solution:
+        terminal_statuses = {r.status for r in terminal_without_solution}
+        if len(terminal_statuses) == 1:
+            chosen = terminal_without_solution[0]
+        else:
+            stopped_reason = "conflicting_terminal_statuses"
+    total_s = perf_counter() - t0
+    if not attempts:
+        stopped_reason = "no_attempts"
+    return PortfolioSolveResult(
+        chosen=chosen,
+        attempts=tuple(attempts),
+        total_s=total_s,
+        stopped_reason=stopped_reason,
+        budget_exhausted=budget_exhausted,
+    )

solverpilot/runtime/result.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+from solverpilot._immutability import deep_freeze, readonly_array
+from solverpilot.plan import SolvePlan
+from solverpilot.trace import SolveTrace
+from solverpilot.validate import PublicStatus, ValidationReport
+
+if TYPE_CHECKING:
+    from solverpilot.diagnose import InfeasibilityReport
+
+
+@dataclass(frozen=True, slots=True)
+class OptimalityEvidence:
+    """Trust metadata for an apparent optimal termination.
+
+    ``VALID_OPTIMAL`` remains a compatibility status meaning the backend reported
+    optimality and the primal candidate passed canonical validation.  It does not
+    imply that SolverPilot independently reconstructed a complete optimality proof.
+    """
+
+    backend_reported_optimal: bool = False
+    primal_validated: bool = False
+    dual_verified: bool = False
+    gap_verified: bool = False
+    certificate_verified: bool = False
+
+    @property
+    def independently_verified_optimal(self) -> bool:
+        return bool(self.primal_validated and self.dual_verified and (self.gap_verified or self.certificate_verified))
+
+
+@dataclass(frozen=True, slots=True)
+class SolveResult:
+    status: PublicStatus
+    x: np.ndarray | None
+    objective: float | None
+    backend_status: str
+    validation: ValidationReport | None
+    trace: SolveTrace
+    raw_statistics: dict[str, object] | None = None
+    plan: SolvePlan | None = None
+    session_revision: int | None = None
+    diagnostics: "InfeasibilityReport | None" = None
+    _optimality_evidence: OptimalityEvidence = field(init=False, repr=False, compare=False)
+
+    def __post_init__(self) -> None:
+        if self.x is not None:
+            object.__setattr__(self, "x", readonly_array(self.x, dtype=np.float64))
+        frozen_raw = None if self.raw_statistics is None else deep_freeze(self.raw_statistics)
+        object.__setattr__(self, "raw_statistics", frozen_raw)
+
+        raw = frozen_raw or {}
+        trust = raw.get("solverpilot_trust", {})
+        if not isinstance(trust, Mapping):
+            trust = {}
+        object.__setattr__(self, "_optimality_evidence", OptimalityEvidence(
+            backend_reported_optimal=bool(trust.get("backend_reported_optimal", self.backend_status == "optimal")),
+            primal_validated=bool(trust.get("primal_validated", self.validation is not None and self.validation.valid)),
+            dual_verified=bool(trust.get("dual_verified", False)),
+            gap_verified=bool(trust.get("gap_verified", False)),
+            certificate_verified=bool(trust.get("certificate_verified", False)),
+        ))
+
+    @property
+    def optimality_evidence(self) -> OptimalityEvidence:
+        return self._optimality_evidence

solverpilot/session/__init__.py

@@ -0,0 +1,29 @@
+from .mutations import MutationKind, MutationRecord, classify_mutations
+from .reuse import ReuseAssessment, assess_reuse
+from .session import Session
+from .persistent import (
+    MutationDecision,
+    MutationExecutionPath,
+    PersistentBackendBinding,
+    PersistentSession,
+    PersistentSessionError,
+    PersistentSessionTrace,
+    PersistentSolveOutcome,
+    ReuseEvidenceMismatchError,
+    SessionPolicy,
+    bind_persistent_backend,
+    decide_mutation_path,
+)
+from .conformance_v2 import (
+    PersistenceConformanceCheck,
+    PersistenceConformanceReport,
+    conform_persistent_backend,
+)
+
+__all__ = [
+    "MutationKind", "MutationRecord", "ReuseAssessment", "Session", "assess_reuse", "classify_mutations",
+    "MutationDecision", "MutationExecutionPath", "PersistentBackendBinding", "PersistentSession", "PersistentSessionError",
+    "PersistentSessionTrace", "PersistentSolveOutcome", "ReuseEvidenceMismatchError", "SessionPolicy",
+    "bind_persistent_backend", "decide_mutation_path", "PersistenceConformanceCheck", "PersistenceConformanceReport",
+    "conform_persistent_backend",
+]