scripts/basic40_templates/multiwave_7101.py

"""Template-backed digestion path for the Anton Paar Multiwave 7101 (24 x 8 mL rack) thermal runtime.

Library: assets/reactions/multiwave_7101_digestion_library/templates.json (EPA SW-846 3051A/3052/3015A programs,
NIST SRM certified mass fractions, EPA 3051A measured recoveries, reagent properties, IAPWS water saturation curve).

Adds three agent capabilities to ``basic40_runtime_thermal.Multiwave7101Session`` (hooked in the runtime file):
* ``template.read``           public reference lookup by template id; reveals nothing about any loaded vessel.
* ``digestion.load_template`` declare the contents of one rack vessel (reference material id, sample mass, acid
                              volume, EPA method id); door open and heating off, vessel present in the slot.
* ``digestion.evaluate``      compare the host-tracked thermal history (indicated temperature, shared lumped node)
                              with the method program (window, ramp, hold) and list the analytes expected in the
                              digest from the certificate / EPA recovery tables.
The lumped thermal model itself is unchanged: loading template contents does not alter heat capacity or power.
The host step hook ``track_step`` integrates time-in-window exactly by bisection on the runtime's own closed-form
``_advance`` (the single-node trajectory is monotone within one host step).
"""
from __future__ import annotations

import copy
import json
import math
from functools import lru_cache
from typing import Any

try:  # scripts/ on sys.path (tests, Matterix runtime bridge)
    from template_library import index_by_id, library_sha256, load_library, provenance
except ImportError:  # imported as scripts.basic40_templates.*
    from scripts.template_library import index_by_id, library_sha256, load_library, provenance

TEMPLATE_REL = "assets/reactions/multiwave_7101_digestion_library/templates.json"
RACK24_FILL_LIMIT_M3 = 5e-6      # manufacturer brochure 2026 PDF p.5, Rack 24 column (contract source manufacturer_brochure_2026)
RACK24_SAMPLE_LIMIT_KG = 2e-4    # same table: 0.2 g sample for Rack 24
RACK24_VIAL_VOLUME_M3 = 8e-6
CAPABILITIES = ("template.read", "digestion.load_template", "digestion.evaluate")
STATE_KEY = "template_digestion"
SOLID_MATRIX_TO_METHOD = {  # library CRM matrix -> matrix words used in the EPA scope sections
    "soil": ("soils",), "marine_sediment": ("sediments",), "estuarine_sediment": ("sediments",), "river_sediment": ("sediments",),
    "plant_leaves": ("biological tissues",), "animal_tissue": ("biological tissues",), "oil": ("oils",),
}
RECOVERY_MATERIAL_MATRIX = {"nist_srm_2704": "river_sediment", "nist_srm_4355": "soil", "nist_srm_1084a": "oil"}
SYNTHETIC_PARTS = ["thermal history: shared lumped single-node surrogate of the Multiwave 7101 runtime (assumed absorbed power/UA)",
                   "digest volume assumed equal to the declared acid volume (sample water, evaporation and dilution not modelled)"]
LIMITATIONS = [
    "No digestion kinetics: an analyte is listed as expected only after the method hold time has been met in the method window; partial programs return null amounts.",
    "Certified values are total mass fractions; EPA 3051A/3015A are leaching methods. Expected 3051A amounts use the EPA 3051A Table 1-3 measured means where they exist, else the certificate CLP study median (USEPA 200.7/3050B hot-plate leach, a proxy), else null.",
    "Rack 24 (8 mL vials, 5 mL fill, 0.2 g sample) is a scale-down of EPA methods written for >=45 mL vessels and 0.5 g; vessel volume and sample mass deviations are reported, not hidden.",
    "Shared cavity temperature: all 24 vessels see the same simulated node; no per-vessel heating, pressure, venting or acid-vapour model; the water saturation curve is only a lower bound for vessel pressure.",
    "Elemental volatility (Hg, As, Se, B with HF), insoluble fluorides and incomplete matrix destruction are not modelled.",
]


# ---------------------------------------------------------------- library access ------------------------------------
@lru_cache(maxsize=None)
def records() -> dict[str, dict]:
    return index_by_id(TEMPLATE_REL)


@lru_cache(maxsize=None)
def materials() -> dict[str, dict]:
    """material_id -> {name, matrix, analytes: {symbol: crm record}, recoveries: {symbol: method_recovery record}}."""
    out: dict[str, dict] = {}
    for rec in load_library(TEMPLATE_REL)["templates"]:
        if rec["record_type"] == "crm_certified_value":
            m = out.setdefault(rec["material_id"], {"name": rec["material_name"], "matrix": rec["matrix"], "analytes": {}, "recoveries": {}})
            m["analytes"][rec["analyte"]] = rec
        elif rec["record_type"] == "method_recovery":
            m = out.setdefault(rec["material_id"], {"name": rec["material_name"], "matrix": RECOVERY_MATERIAL_MATRIX.get(rec["material_id"]),
                                                    "analytes": {}, "recoveries": {}})
            m["recoveries"][rec["analyte"]] = rec
    return out


def methods() -> dict[str, dict]:
    return {k: v for k, v in records().items() if v["record_type"] == "digestion_method"}


def _water_curve() -> dict | None:
    return records().get("water_saturation_pressure_373_573K")


def water_saturation_pressure_pa(temperature_k: float) -> float | None:
    """Linear interpolation in the cached IAPWS-95 (NIST WebBook) table, 373.15-573.15 K; None outside."""
    c = _water_curve()
    if not c:
        return None
    ts, ps = c["temperature_K"], c["saturation_pressure_Pa"]
    if not ts[0] <= temperature_k <= ts[-1]:
        return None
    for i in range(1, len(ts)):
        if temperature_k <= ts[i]:
            f = (temperature_k - ts[i - 1]) / (ts[i] - ts[i - 1])
            return ps[i - 1] + f * (ps[i] - ps[i - 1])
    return ps[-1]


# ---------------------------------------------------------------- schemas ------------------------------------------
def _obj(props: dict, required: list | None = None) -> dict:
    return {"type": "object", "properties": props, "required": list(props) if required is None else required, "additionalProperties": False}


def _num(unit: str, minimum=None, maximum=None, nullable=False) -> dict:
    s: dict[str, Any] = {"type": ["number", "null"] if nullable else "number", "x-unit": unit}
    if minimum is not None:
        s["minimum"] = minimum
    if maximum is not None:
        s["maximum"] = maximum
    return s


TEXT = {"type": "string"}
NTEXT = {"type": ["string", "null"]}
BOOL = {"type": "boolean"}
NBOOL = {"type": ["boolean", "null"]}
SLOT = {"type": "integer", "minimum": 0, "maximum": 23, "x-unit": "1"}
ANALYTE = _obj({
    "analyte": TEXT, "value_category": TEXT,
    "certified_mass_fraction": _num("kg/kg", 0, 1, nullable=True), "expanded_uncertainty": _num("kg/kg", 0, 1, nullable=True),
    "basis": TEXT, "expected_mass_fraction": _num("kg/kg", 0, 1, nullable=True), "expected_mass_kg": _num("kg", 0, nullable=True),
    "expected_concentration_kg_m3": _num("kg/m^3", 0, nullable=True), "evidence": TEXT, "source": TEXT, "locator": TEXT, "note": NTEXT})
PROGRAM = _obj({
    "target_temperature_K": _num("K"), "temperature_tolerance_K": _num("K"), "window_low_K": _num("K"), "window_high_K": _num("K"),
    "setpoint_K": _num("K"), "setpoint_in_window": BOOL,
    "required_ramp_s": _num("s"), "ramp_tolerance_s": _num("s", nullable=True), "ramp_time_max_s": _num("s", nullable=True),
    "heating_started_s": _num("s", nullable=True), "entered_window_s": _num("s", nullable=True), "measured_ramp_s": _num("s", nullable=True),
    "ramp_within_spec": NBOOL, "required_hold_s": _num("s"), "hold_in_window_s": _num("s", 0), "left_window_after_entry": BOOL,
    "max_indicated_temperature_K": _num("K"), "exceeded_window": BOOL, "program_complete": BOOL,
    "water_saturation_pressure_at_target_Pa": _num("Pa", 0, nullable=True), "reagents_boiling_below_target": {"type": "array", "items": TEXT},
    "synthetic": BOOL})
EVALUATE_OUT = _obj({
    "slot_index": SLOT, "material_id": TEXT, "material_name": TEXT, "matrix": TEXT, "method_id": TEXT, "method_scope": TEXT,
    "matrix_in_method_scope": BOOL, "sample_mass_kg": _num("kg", 0), "acid_volume_m3": _num("m^3", 0),
    "acid_to_sample_ratio_m3_kg": _num("m^3/kg", 0), "method_acid_to_sample_ratio_m3_kg": _num("m^3/kg", 0, nullable=True),
    "method_deviations": {"type": "array", "items": TEXT}, "method_conformant": BOOL, "program": PROGRAM,
    "expected_analytes": {"type": "array", "items": ANALYTE}, "status": {"type": "string", "enum": ["complete", "incomplete_program"]},
    "template_source": TEXT, "library_sha256": TEXT, "evidence": TEXT, "synthetic": BOOL, "synthetic_parts": {"type": "array", "items": TEXT},
    "limitations": {"type": "array", "items": TEXT}})
READ_OUT = _obj({"template_id": TEXT, "record_type": TEXT, "name": TEXT, "cas": NTEXT, "evidence": TEXT, "source": TEXT,
                 "locator": NTEXT, "accessed": TEXT, "record_json": TEXT, "template_source": TEXT, "library_sha256": TEXT})
LOAD_IN = _obj({"slot_index": SLOT, "material_id": TEXT, "method_id": TEXT,
                "sample_mass_kg": _num("kg", 1e-6, RACK24_SAMPLE_LIMIT_KG), "acid_volume_m3": _num("m^3", 1e-7, RACK24_FILL_LIMIT_M3)})
LOAD_OUT = _obj({"slot_index": SLOT, "material_id": TEXT, "method_id": TEXT, "method_scope": TEXT, "sample_mass_kg": _num("kg"),
                 "acid_volume_m3": _num("m^3"), "method_deviations": {"type": "array", "items": TEXT}})

ERRORS = {
    "UNKNOWN_REFERENCE": "template_id, material_id or method_id is not in the digestion library.",
    "METHOD_MATRIX_MISMATCH": "Method is written for aqueous samples (EPA 3015A) but the reference material is a solid.",
    "TEMPLATE_SAMPLE_REQUIRED": "No template contents declared for this rack slot.",
}


def capability_specs() -> dict[str, dict]:
    """Runtime-metadata entries in the same shape as export_multiwave_7101_metadata() capabilities."""
    load_pre = [{"description_zh": "门打开且微波加热关闭（装样时）。", "state_ids": ["door.closed", "microwave.enabled"], "enforced_by": "adapter",
                 "check": "not door.closed and not microwave.enabled"},
                {"description_zh": "该槽位已放入消解管（rack.set_slot occupied=True）。", "state_ids": ["rack.occupied_slots"], "enforced_by": "adapter",
                 "check": "rack.occupied_slots[slot_index]"}]
    eval_pre = [{"description_zh": "该槽位已声明模板内容。", "state_ids": [], "enforced_by": "adapter", "check": "slot has digestion.load_template contents"}]
    common = {"availability": "implemented", "visibility": "agent", "scene_backend_required": False,
              "completion_criterion_zh": "同步返回；不推进宿主时钟，不改变热状态。"}
    return {
        "template.read": {**common, "kind": "query", "description_zh": "按模板ID读取公开参考记录（EPA方法程序、NIST SRM认证值、试剂性质）；不透露任何消解管内容。",
                          "component_ids": ["controller"], "input_schema": _obj({"template_id": TEXT}), "output_schema": READ_OUT,
                          "example_arguments": [{"template_id": "epa_3051a_hno3"}], "observes": [], "state_effects": [], "preconditions": [],
                          "binding": "basic40_runtime_thermal.Multiwave7101Session.invoke(instance_id=..., capability_id='template.read', arguments={'template_id': ...}, request_id=...)"},
        "digestion.load_template": {**common, "kind": "configuration", "description_zh": "声明某槽消解管的内容：标准物质ID、称样量、酸体积与EPA方法ID；只记录过程模板，不改热容或功率。",
                                    "component_ids": ["rack"], "input_schema": LOAD_IN, "output_schema": LOAD_OUT,
                                    "example_arguments": [{"slot_index": 0, "material_id": "nist_srm_2711a", "method_id": "epa_3051a_hno3", "sample_mass_kg": 0.0002, "acid_volume_m3": 4e-06}],
                                    "observes": [], "state_effects": [], "preconditions": load_pre,
                                    "binding": "basic40_runtime_thermal.Multiwave7101Session.invoke(instance_id=..., capability_id='digestion.load_template', arguments=..., request_id=...)"},
        "digestion.evaluate": {**common, "kind": "analysis", "description_zh": "对照方法温窗、升温与保持时间检查已运行的显示温度历史，并按证书/EPA回收率表列出消解液中预期的分析元素。",
                               "component_ids": ["controller", "rack"], "input_schema": _obj({"slot_index": SLOT}), "output_schema": EVALUATE_OUT,
                               "example_arguments": [{"slot_index": 0}], "observes": ["thermal.indicated_temperature_k", "thermal.target_k"], "state_effects": [],
                               "preconditions": eval_pre,
                               "binding": "basic40_runtime_thermal.Multiwave7101Session.invoke(instance_id=..., capability_id='digestion.evaluate', arguments={'slot_index': 0}, request_id=...)"},
    }


# ---------------------------------------------------------------- capability handlers -------------------------------
class Rejected(Exception):
    def __init__(self, code: str):
        super().__init__(code)
        self.code = code


def _finite(x) -> bool:
    return type(x) in (int, float) and math.isfinite(x)


def template_read(args: dict) -> dict:
    tid = args.get("template_id")
    if not isinstance(tid, str):
        raise Rejected("INVALID_ARGUMENT")
    rec = records().get(tid)
    if rec is None:
        raise Rejected("UNKNOWN_REFERENCE")
    prov = provenance(TEMPLATE_REL, rec)
    return {"template_id": tid, "record_type": rec["record_type"], "name": rec.get("name") or tid, "cas": rec.get("cas"),
            "evidence": rec.get("evidence") or "", "source": rec.get("source") or "", "locator": rec.get("locator"),
            "accessed": rec.get("accessed") or "", "record_json": json.dumps(rec, ensure_ascii=False, sort_keys=True),
            "template_source": prov["template_source"], "library_sha256": prov["library_sha256"]}


def _method_volume(method: dict) -> float:
    return sum(r.get("volume_m3") or 0.0 for r in method["reagents"])


def _method_ratio(method: dict) -> float | None:
    mass = (method.get("max_sample_mass_kg") or {})
    solid = mass.get("soils_sediments_sludges") or mass.get("soils_ash_sediments_sludges_siliceous_wastes")
    return _method_volume(method) / solid if solid else None


def plan(args: dict) -> dict:
    """Validate digestion.load_template arguments; returns the slot record (no state is touched here)."""
    slot, mid, meth, mass, vol = (args.get(k) for k in ("slot_index", "material_id", "method_id", "sample_mass_kg", "acid_volume_m3"))
    if type(slot) is not int or not 0 <= slot <= 23 or not isinstance(mid, str) or not isinstance(meth, str):
        raise Rejected("INVALID_ARGUMENT")
    if not _finite(mass) or not 1e-6 <= mass <= RACK24_SAMPLE_LIMIT_KG or not _finite(vol) or not 1e-7 <= vol <= RACK24_FILL_LIMIT_M3:
        raise Rejected("INVALID_ARGUMENT")
    if mid not in materials() or meth not in methods():
        raise Rejected("UNKNOWN_REFERENCE")
    method, material = methods()[meth], materials()[mid]
    if method.get("sample_volume_m3") is not None:  # EPA 3015A: aqueous samples only
        raise Rejected("METHOD_MATRIX_MISMATCH")
    deviations = []
    min_vol = (method.get("vessel_requirements") or {}).get("min_internal_volume_m3")
    if min_vol and RACK24_VIAL_VOLUME_M3 < min_vol:
        deviations.append(f"vessel 8 mL below method minimum internal volume {min_vol * 1e6:g} mL (Rack 24 scale-down)")
    ratio, method_ratio = vol / mass, _method_ratio(method)
    if method_ratio and ratio < method_ratio * (1 - 1e-9):
        deviations.append(f"acid/sample ratio {ratio:.4g} m^3/kg below method {method_ratio:.4g} m^3/kg")
    scope_words = SOLID_MATRIX_TO_METHOD.get(material["matrix"], ())
    if not any(w in method.get("matrices", []) for w in scope_words):
        deviations.append(f"matrix '{material['matrix']}' not listed in {method.get('method', meth)} scope")
    return {"slot_index": slot, "material_id": mid, "method_id": meth, "sample_mass_kg": float(mass), "acid_volume_m3": float(vol),
            "method_deviations": deviations, "heating_started_s": None, "entered_window_s": None, "hold_in_window_s": 0.0,
            "left_window_after_entry": False, "max_indicated_temperature_K": None, "exceeded_window": False}


def load_result(rec: dict) -> dict:
    return {"slot_index": rec["slot_index"], "material_id": rec["material_id"], "method_id": rec["method_id"],
            "method_scope": methods()[rec["method_id"]]["scope"], "sample_mass_kg": rec["sample_mass_kg"],
            "acid_volume_m3": rec["acid_volume_m3"], "method_deviations": list(rec["method_deviations"])}


def _window(method: dict) -> tuple[float, float]:
    p = method["program"]
    return p["target_temperature_K"] - p["temperature_tolerance_K"], p["target_temperature_K"] + p["temperature_tolerance_K"]


def _expected(material: dict, method: dict, rec: dict, complete: bool) -> list[dict]:
    out = []
    mass, vol, scope, mid = rec["sample_mass_kg"], rec["acid_volume_m3"], method["scope"], rec["method_id"]
    symbols = sorted(set(material["analytes"]) | set(material["recoveries"]))
    for sym in symbols:
        crm, recov = material["analytes"].get(sym), material["recoveries"].get(sym)
        if crm is not None:
            total, unc, cat, src, loc = crm["value"], crm.get("expanded_uncertainty"), crm["value_category"], crm["source"], crm.get("locator") or ""
        else:
            t = recov["results"]["total"]
            total, unc, cat, src, loc = t["mean"], t.get("uncertainty"), t.get("value_category") or "certified", recov["source"], recov.get("locator") or ""
        frac, basis, evidence, note = None, "", "measured", None
        if scope == "total":
            frac, basis = total, "certified_total (method claims total decomposition)"
        elif recov is not None and mid in recov["results"]:
            frac, basis, evidence = recov["results"][mid]["mean"], f"EPA 3051A measured mean ({mid})", "measured_literature"
            src, loc = recov["source"], recov.get("locator") or ""
        elif crm is not None and crm.get("leachable"):
            key, leach = next(iter(crm["leachable"].items()))
            frac, basis, evidence = leach["median"], f"leachable proxy: {key} median", "measured_literature"
            note = "hot-plate CLP leach (USEPA 200.7/3050B), used as a proxy for microwave 3051A (3051A Sec. 1.1 mimics 3050)"
            loc = f"{loc}; {leach.get('source_locator', '')}"
        else:
            basis, note = "not_documented", "acid-leachable fraction not documented for this material/method; certified total is an upper bound"
        if not complete:
            note = "program incomplete: hold time in method window not reached" + (f"; {note}" if note else "")
        exp_frac = frac if complete else None
        out.append({"analyte": sym, "value_category": cat, "certified_mass_fraction": total, "expanded_uncertainty": unc, "basis": basis,
                    "expected_mass_fraction": exp_frac, "expected_mass_kg": None if exp_frac is None else exp_frac * mass,
                    "expected_concentration_kg_m3": None if exp_frac is None else exp_frac * mass / vol,
                    "evidence": evidence, "source": src, "locator": loc, "note": note})
    return out


def evaluate(rec: dict, state: dict) -> dict:
    method, material = methods()[rec["method_id"]], materials()[rec["material_id"]]
    p = method["program"]
    lo, hi = _window(method)
    complete = rec["hold_in_window_s"] >= p["hold_time_s"] - 1e-9
    ramp = None if rec["entered_window_s"] is None or rec["heating_started_s"] is None else rec["entered_window_s"] - rec["heating_started_s"]
    if ramp is None:
        ramp_ok = None
    elif p.get("ramp_tolerance_s") is not None:
        ramp_ok = abs(ramp - p["ramp_time_s"]) <= p["ramp_tolerance_s"] + 1e-9
    else:
        ramp_ok = ramp <= (p.get("ramp_time_max_s") or p["ramp_time_s"]) + 1e-9
    setpoint = float(state["thermal.target_k"])
    boiling = []
    for reag in method["reagents"]:
        r = records().get(reag["reagent_id"]) or {}
        bp = (r.get("values") or {}).get("azeotrope_boiling_point_K") or (r.get("values") or {}).get("boiling_point_K")
        if bp is not None and bp < p["target_temperature_K"]:
            boiling.append(f"{reag['reagent_id']} ({bp:.2f} K)")
    deviations = list(rec["method_deviations"])
    if not lo <= setpoint <= hi:
        deviations.append(f"setpoint {setpoint:.2f} K outside method window {lo:.2f}-{hi:.2f} K")
    if ramp_ok is False:
        deviations.append(f"ramp {ramp:.1f} s outside method {p['ramp_time_s']:.0f} s spec")
    if rec["exceeded_window"]:
        deviations.append("indicated temperature exceeded the method window")
    if rec["left_window_after_entry"]:
        deviations.append("temperature left the window after first entry (hold interrupted)")
    max_t = rec["max_indicated_temperature_K"] if rec["max_indicated_temperature_K"] is not None else float(state["thermal.indicated_temperature_k"])
    prov = provenance(TEMPLATE_REL, method)
    return {
        "slot_index": rec["slot_index"], "material_id": rec["material_id"], "material_name": material["name"], "matrix": material["matrix"] or "",
        "method_id": rec["method_id"], "method_scope": method["scope"],
        "matrix_in_method_scope": any(w in method.get("matrices", []) for w in SOLID_MATRIX_TO_METHOD.get(material["matrix"], ())),
        "sample_mass_kg": rec["sample_mass_kg"], "acid_volume_m3": rec["acid_volume_m3"],
        "acid_to_sample_ratio_m3_kg": rec["acid_volume_m3"] / rec["sample_mass_kg"], "method_acid_to_sample_ratio_m3_kg": _method_ratio(method),
        "method_deviations": deviations, "method_conformant": complete and not deviations,
        "program": {"target_temperature_K": p["target_temperature_K"], "temperature_tolerance_K": p["temperature_tolerance_K"], "window_low_K": lo,
                    "window_high_K": hi, "setpoint_K": setpoint, "setpoint_in_window": lo <= setpoint <= hi,
                    "required_ramp_s": p["ramp_time_s"], "ramp_tolerance_s": p.get("ramp_tolerance_s"), "ramp_time_max_s": p.get("ramp_time_max_s"),
                    "heating_started_s": rec["heating_started_s"], "entered_window_s": rec["entered_window_s"], "measured_ramp_s": ramp,
                    "ramp_within_spec": ramp_ok, "required_hold_s": p["hold_time_s"], "hold_in_window_s": rec["hold_in_window_s"],
                    "left_window_after_entry": rec["left_window_after_entry"], "max_indicated_temperature_K": max_t,
                    "exceeded_window": rec["exceeded_window"], "program_complete": complete,
                    "water_saturation_pressure_at_target_Pa": water_saturation_pressure_pa(p["target_temperature_K"]),
                    "reagents_boiling_below_target": boiling, "synthetic": True},
        "expected_analytes": _expected(material, method, rec, complete),
        "status": "complete" if complete else "incomplete_program",
        "template_source": TEMPLATE_REL, "library_sha256": prov["library_sha256"],
        "evidence": "measured (NIST SRM certificates) / measured_literature (EPA 3051A tables, CLP study, method programs); thermal history simulated",
        "synthetic": False, "synthetic_parts": list(SYNTHETIC_PARTS), "limitations": list(LIMITATIONS)}


def handle(cap: str, args: dict, state: dict, contents: dict | None) -> tuple[dict, dict | None]:
    """Return (result, new_contents_or_None). Raises Rejected with a stable code; never mutates its inputs."""
    if cap == "template.read":
        return template_read(args), None
    if cap == "digestion.load_template":
        if state["door.closed"] or state["microwave.enabled"]:
            raise Rejected("PRECONDITION_FAILED")
        rec = plan(args)
        if not state["rack.occupied_slots"][rec["slot_index"]]:
            raise Rejected("PRECONDITION_FAILED")
        new = copy.deepcopy(contents or {})
        new[str(rec["slot_index"])] = rec
        return load_result(rec), new
    if cap == "digestion.evaluate":
        slot = args.get("slot_index")
        if type(slot) is not int or not 0 <= slot <= 23:
            raise Rejected("INVALID_ARGUMENT")
        rec = (contents or {}).get(str(slot))
        if rec is None:
            raise Rejected("TEMPLATE_SAMPLE_REQUIRED")
        return evaluate(rec, state), None
    raise Rejected("UNKNOWN_CAPABILITY")


# ---------------------------------------------------------------- host step hook -----------------------------------
def _heating(state: dict) -> bool:
    return bool(state["power.enabled"] and state["microwave.enabled"] and state["door.closed"] and state["microwave.power_limit_w"] > 0)


def _crossing(advance, before: dict, dt: float, level: float, rising: bool) -> float:
    """Earliest h in [0, dt] with indicated T(h) >= level (rising) or <= level (falling); trajectory monotone."""
    def reached(h):
        if h <= 0:
            t = before["thermal.indicated_temperature_k"]
        else:
            s = copy.deepcopy(before)
            advance(s, h)
            t = s["thermal.indicated_temperature_k"]
        return t >= level if rising else t <= level
    lo, hi = 0.0, dt
    if reached(0.0):
        return 0.0
    for _ in range(64):
        mid = 0.5 * (lo + hi)
        if reached(mid):
            hi = mid
        else:
            lo = mid
        if hi - lo <= 1e-9 * max(1.0, dt):
            break
    return hi


def track_step(advance, inst: dict, before: dict, t0: float, dt: float) -> None:
    """Update every loaded slot after one host step [t0, t0+dt] (state already advanced in inst['state'])."""
    contents = inst.get(STATE_KEY)
    if not contents or dt <= 0:
        return
    after = inst["state"]
    T0, T1 = before["thermal.indicated_temperature_k"], after["thermal.indicated_temperature_k"]
    heating = _heating(before)
    for rec in contents.values():
        method = methods()[rec["method_id"]]
        lo, hi = _window(method)
        hold_done_before = rec["hold_in_window_s"] >= method["program"]["hold_time_s"] - 1e-9
        if heating and rec["heating_started_s"] is None:
            rec["heating_started_s"] = t0
        if T1 >= T0:  # rising or flat
            if T1 < lo or T0 > hi:
                enter = exit_ = None
            else:
                enter = 0.0 if T0 >= lo else _crossing(advance, before, dt, lo, True)
                exit_ = dt if T1 <= hi else _crossing(advance, before, dt, hi + 1e-9, True)
        else:  # falling
            if T0 < lo or T1 > hi:
                enter = exit_ = None
            else:
                enter = 0.0 if T0 <= hi else _crossing(advance, before, dt, hi, False)
                exit_ = dt if T1 >= lo else _crossing(advance, before, dt, lo - 1e-9, False)
        inside = 0.0 if enter is None else max(0.0, exit_ - enter)
        if inside > 0:
            if rec["entered_window_s"] is None:
                rec["entered_window_s"] = t0 + enter
            rec["hold_in_window_s"] += inside
        hold_done = rec["hold_in_window_s"] >= method["program"]["hold_time_s"] - 1e-9
        if rec["entered_window_s"] is not None and (T1 < lo or T1 > hi) and not (hold_done_before or (hold_done and T1 < lo)):
            rec["left_window_after_entry"] = True  # left before the hold was complete (normal cool-down afterwards is not flagged)
        peak = max(T0, T1)
        rec["max_indicated_temperature_K"] = peak if rec["max_indicated_temperature_K"] is None else max(rec["max_indicated_temperature_K"], peak)
        if peak > hi:
            rec["exceeded_window"] = True