scripts/asset_runtime/agilent_1260infinity.py

"""CHEM-094 Agilent 1260 Infinity III SFC system (G4301A SFC Control Module, G4782A SFC Binary Pump, G4767A SFC Multisampler,
G7116A Multicolumn Thermostat, G7115A DAD WR with SFC flow cell, solvent cabinet) - process runtime.

Physics (SI; the host's step(dt_s) is the only clock):
* CO2 path: host-connected cylinder (40-70 bar documented supply) -> control-module chiller (first order to a 278.15 K target inside the
  documented -20...9 degC range) -> booster -> pump channel A; modifier from bottle B1/B2 on channel B (high-pressure binary mixing).
* Hydraulics: pump pressure = BPR set pressure + Kozeny-Carman column drop (log-blended CO2/modifier viscosity) + extra-column drop;
  600 bar pump limit trips the pump (documented 600 bar); BPR 100-400 bar, 40-70 degC (documented G4301A ranges).
* Column oven: first-order heating / cooling with time constants derived from the documented MCT rates (ambient->40 degC ~5 min,
  40->20 degC ~10 min).
* Retention: per analyte, column and modifier the intercept a of log10 k = a - m log10(phi) comes from the measured CC BY 4.0
  retention times of the template library (back-solved, evidence 'derived'); the run integrates band migration
  dz/dt = 1 / (t0 (1 + k(phi(t - t_D - z t0)))) for the configured program, with t0 = eps_T * column volume / flow, the documented
  600-900 uL pump delay volume, and a density correction from a Peng-Robinson CO2 equation of state (NIST critical constants).
* Detection: DAD absorbance A = eps(lambda) * 10 mm * c(t) (documented SFC flow cell 10 mm / 13 uL); eps from NIST UV curves where the
  library holds one, else an assumed 1e3 m^2/mol (flagged); documented +-0.7e-5 AU noise and 0.9e-3 AU/h drift.
* Ledgers: vial volume and species moles (vial -> column -> waste/exhaust), modifier volume (bottle -> waste), CO2 mass (cylinder -> vent).

Sessions filter visibility: agents never see the vial composition, process truths or ledgers; template.read only returns public reference
data.  Matterix bridge: RECIPES module="asset_runtime.agilent_1260infinity", cls="Agilent1260infinityRuntime", instance_in_ctor=True, advance=STEP_DT.
"""
from __future__ import annotations

import copy
import hashlib
import json
import math
from functools import lru_cache
from pathlib import Path

import numpy as np

try:
    from asset_runtime import _annotations as _ann
except ImportError:  # pragma: no cover - imported as a plain module
    _ann = None

PROTOCOL_VERSION = '1.0.0'
ASSET_TYPE_ID = 'instrument.agilent_1260infinity'
CATALOG_ID = 'CHEM-094'
ROOT = Path(__file__).resolve().parents[2]
LIBRARY_REL = 'assets/reactions/agilent_1260infinity_sfc_retention_library/sfc_retention_library.json'

# ------------------------------------------------------------------------------------------------ documented specifications
FLOW_MIN, FLOW_MAX = 0.001e-6 / 60, 5.0e-6 / 60            # m^3/s, G4782A settable 0.001-5 mL/min
PUMP_MAX_PA = 600e5                                          # G4782A / system: 600 bar up to 5 mL/min
BPR_MIN_PA, BPR_MAX_PA = 100e5, 400e5                        # G4301A BPR settable 100-400 bar
BPR_T_MIN, BPR_T_MAX = 313.15, 343.15                        # G4301A BPR thermal range 40-70 degC
SUPPLY_MIN_PA, SUPPLY_MAX_PA = 40e5, 70e5                    # G4301A CO2 supply pressure 40-70 bar
CHILLER_TARGET_K = 278.15                                    # inside the documented -20...9 degC chiller range (assumption: 5 degC)
INJ_MIN, INJ_MAX, INJ_STEP = 0.1e-9, 90e-9, 0.1e-9           # G4767A SFC mode 0.1-90 uL in 0.1 uL steps
INJECT_CYCLE_S = 13.0                                        # G4767A SFC injection cycle < 13 s (1 uL)
COL_T_MAX = 358.15                                           # G7116A up to 85 degC; lower limit ambient - 10 K, >= 4 degC
COL_T_ABS_MIN = 277.15
N_COLUMN_POSITIONS = 4                                       # G7116A four columns up to 300 mm, 4-column selection valve
N_DRAWERS, N_VIAL_POSITIONS = 4, 108                         # 4 x 2H drawers, 432 x 2 mL vials in total (G4767A)
VIAL_CAPACITY_M3 = 2e-6
LAMBDA_MIN, LAMBDA_MAX = 190e-9, 950e-9                      # G7115A 190-950 nm
FLOW_CELL_PATH_M, FLOW_CELL_VOLUME_M3, FLOW_CELL_MAX_PA = 0.010, 13e-9, 400e5   # SFC flow cell 10 mm, 13 uL, 400 bar
DAD_NOISE_AU, DAD_DRIFT_AU_S = 0.7e-5, 0.9e-3 / 3600.0       # G7115A noise < +-0.7e-5 AU, drift < 0.9e-3 AU/h
DELAY_MIN_M3, DELAY_MAX_M3 = 600e-9, 900e-9                  # G4782A delay volume 600-900 uL incl. 400 uL mixer, depending on back pressure
MAX_PROGRAM_ROWS = 20                                        # assumption: table length (G4301A documents 20 BPR timetable entries)
# derived from documented MCT rates: ambient(25)->40 degC in ~5 min, 40->20 degC in ~10 min (to within 0.5 K)
COL_TAU_HEAT_S = 300.0 / math.log(15.0 / 0.5)
COL_TAU_COOL_S = 600.0 / math.log(20.0 / 0.5)

# ------------------------------------------------------------------------------------------------ assumptions (flagged)
TOTAL_POROSITY = 0.65            # eps_T of fully porous packed columns (t0 = eps_T * V_column / F)
BED_POROSITY = 0.40              # interparticle porosity (Kozeny-Carman)
LOGLOG_SLOPE_M = 1.5             # log10 k vs log10(phi) slope (Snyder-Soczewinski type), same for all analytes
PHI_MIN = 0.01                   # lower bound of the modifier fraction in the retention law
DENSITY_COEFF = 2.0              # d ln k / d(rho/rho_ref)
REF_FLOW_M3_S = 1.5e-6 / 60      # 1.5 mL/min of the source runs (documented in the articles)
REF_DWELL_S = 18.0               # UPC2 gradient delay of the source runs (0.45 mL at 1.5 mL/min) - not documented, assumption
REF_COLUMN_K, REF_BPR_PA = 313.15, 13.0e6                    # source runs: 40 degC, BPR 13 MPa (documented)
PLATE_HEIGHT_DP = 3.0            # reduced plate height h = H / dp
ETA_CO2_PA_S = 6.5e-5            # CO2 viscosity near 40 degC / 150 bar (engineering value)
ETA_MEOH_PA_S = 5.44e-4          # methanol, 25 degC (CRC Handbook)
EXTRA_COLUMN_R = 4.0e13          # Pa s/m^3 per 1e-4 Pa s: tubing + flow cell drop (~10 bar at 1.5 mL/min)
PRESSURE_TAU_S, FLOW_TAU_S, BPR_HEAT_TAU_S, CHILLER_TAU_S = 3.0, 1.0, 60.0, 300.0
ASSUMED_EPSILON_M2_MOL = 1.0e3   # 1e4 L/(mol cm) when no NIST UV curve is available
VIAL_DEAD_VOLUME_M3 = 10e-9      # needle cannot draw the last 10 uL
READY_TOL_PA, READY_TOL_K, READY_FLOW_FRACTION = 5e5, 1.0, 0.98
CO2_PUMP_DENSITY_KG_M3 = 900.0   # chilled liquid CO2 at the pump head (approx., used for CO2 mass consumption)

# CO2 critical constants (NIST WebBook / Span & Wagner 1996) for the Peng-Robinson density
CO2_TC, CO2_PC, CO2_OMEGA, CO2_M = 304.1282, 7.3773e6, 0.22394, 0.0440095
R_GAS = 8.314462618

MODULES = ('control', 'pump', 'sampler', 'mct', 'dad')
MODIFIERS = ('methanol', 'methanol_ammonia_10mM', 'methanol_water_2pct')
PHASES = ('idle', 'injecting', 'running', 'succeeded', 'cancelled', 'failed')
MECH = {  # mechanism -> (state id, unit, upper limit, component)
    'sampler_door': ('sampler_door.angle_rad', 'rad', 1.75, 'sampler_door'),
    'drawer_1': ('drawer_1.position_m', 'm', 0.30, 'drawer_1'),
    'drawer_2': ('drawer_2.position_m', 'm', 0.30, 'drawer_2'),
    'drawer_3': ('drawer_3.position_m', 'm', 0.30, 'drawer_3'),
    'drawer_4': ('drawer_4.position_m', 'm', 0.30, 'drawer_4'),
    'mct_door': ('mct_door.angle_rad', 'rad', 1.50, 'mct_door'),
}


class ActionRejected(ValueError):
    """Precondition / argument failure; the runtime state is unchanged.  Messages never disclose sample identity."""


# --------------------------------------------------------------------------------------------------------------- schemas
def number(unit, lo=None, hi=None):
    d = {'type': 'number', 'x-unit': unit}
    if lo is not None:
        d['minimum'] = lo
    if hi is not None:
        d['maximum'] = hi
    return d


def integer(lo, hi):
    return {'type': 'integer', 'x-unit': '1', 'minimum': lo, 'maximum': hi}


def obj(props, required=None):
    return {'type': 'object', 'properties': props, 'required': list(props) if required is None else required, 'additionalProperties': False}


def arr(items, lo=None, hi=None):
    d = {'type': 'array', 'items': items}
    if lo is not None:
        d['minItems'] = lo
    if hi is not None:
        d['maxItems'] = hi
    return d


def nullable(s):
    return {'anyOf': [s, {'type': 'null'}]}


def enum(values):
    return {'type': 'string', 'enum': list(values)}


BOOL, TEXT = {'type': 'boolean'}, {'type': 'string'}
COLUMN_IDS = ('silica', 'bridged_ethylene_hybrid', 'diol', 'c18_hss_sb', 'pfp_csh', 'pgc')
PROGRAM_ROW = obj({'time_s': number('s', 0, 3600), 'modifier_fraction': number('1', 0.0, 1.0)})
METHOD = obj({
    'flow_m3_s': number('m^3/s', FLOW_MIN, FLOW_MAX), 'modifier_channel': enum(['B1', 'B2']),
    'program': arr(PROGRAM_ROW, 1, MAX_PROGRAM_ROWS), 'bpr_pa': number('Pa', BPR_MIN_PA, BPR_MAX_PA),
    'bpr_temperature_k': number('K', BPR_T_MIN, BPR_T_MAX), 'column_temperature_k': number('K', COL_T_ABS_MIN, COL_T_MAX),
    'column_position': integer(1, N_COLUMN_POSITIONS), 'injection_volume_m3': number('m^3', INJ_MIN, INJ_MAX),
    'wavelength_m': number('m', LAMBDA_MIN, LAMBDA_MAX), 'run_time_s': number('s', 10, 3600), 'data_rate_hz': number('Hz', 0.5, 10)})
METHOD_EXAMPLE = dict(flow_m3_s=REF_FLOW_M3_S, modifier_channel='B1',
                      program=[dict(time_s=0.0, modifier_fraction=0.02), dict(time_s=60.0, modifier_fraction=0.02),
                               dict(time_s=300.0, modifier_fraction=0.45), dict(time_s=360.0, modifier_fraction=0.45)],
                      bpr_pa=REF_BPR_PA, bpr_temperature_k=333.15, column_temperature_k=REF_COLUMN_K, column_position=1,
                      injection_volume_m3=2e-9, wavelength_m=254e-9, run_time_s=420.0, data_rate_hz=5.0)
SUPPLY = obj({'connected': BOOL, 'supply_pa': number('Pa', 0, 80e5), 'cylinder_co2_kg': number('kg', 0, 60), 'ambient_k': number('K', 288.15, 303.15)})
SUPPLY_EXAMPLE = dict(connected=True, supply_pa=57e5, cylinder_co2_kg=10.0, ambient_k=298.15)
BOTTLE = obj({'channel': enum(['B1', 'B2']), 'modifier': enum(MODIFIERS), 'volume_m3': number('m^3', 0, 2e-3)})
BOTTLE_EXAMPLE = dict(channel='B1', modifier='methanol', volume_m3=1e-3)
COLUMN_INSTALL = obj({'position': integer(1, N_COLUMN_POSITIONS), 'column': enum(list(COLUMN_IDS) + ['none'])})
VIAL = obj({'drawer': integer(1, N_DRAWERS), 'position': integer(1, N_VIAL_POSITIONS), 'volume_m3': number('m^3', 1e-8, VIAL_CAPACITY_M3),
            'composition_mol_m3': {'type': 'object', 'additionalProperties': number('mol/m^3', 0, 1000), 'maxProperties': 16}})
VIAL_EXAMPLE = dict(drawer=1, position=1, volume_m3=1e-6, composition_mol_m3={'caffeine': 0.257, 'vanillin': 0.329})
VIAL_REF = obj({'drawer': integer(1, N_DRAWERS), 'position': integer(1, N_VIAL_POSITIONS)})
PEAK = obj({'retention_time_s': number('s', 0), 'area_au_s': number('AU*s'), 'height_au': number('AU'), 'width_half_height_s': number('s', 0)})
CHROM = obj({'run_id': TEXT, 'phase': enum(PHASES), 'elapsed_s': number('s', 0), 'time_s': arr(number('s', 0)),
             'absorbance_au': arr(number('AU')), 'peaks': arr(PEAK), 'complete': BOOL, 'wavelength_m': nullable(number('m')),
             'template_source': TEXT, 'evidence': TEXT, 'warnings': arr(TEXT)})
QUANT_IN = obj({'calibration': arr(obj({'concentration_mol_m3': number('mol/m^3', 0, 1000), 'area_au_s': number('AU*s')}), 2, 20),
                'retention_window_s': arr(number('s', 0, 3600), 2, 2)})
QUANT_OUT = obj({'slope_au_s_m3_mol': number('AU*s*m^3/mol'), 'intercept_au_s': number('AU*s'), 'r_squared': number('1', 0, 1),
                 'peak_area_au_s': nullable(number('AU*s')), 'concentration_mol_m3': nullable(number('mol/m^3')), 'quality': TEXT})
TEMPLATE_OUT = obj({'substance_id': TEXT, 'name': TEXT, 'cas': nullable(TEXT), 'molecular_weight_g_mol': nullable(number('g/mol')),
                    'reference_retention_s': {'type': 'object', 'additionalProperties': {'type': 'object', 'additionalProperties': nullable(number('s', 0))}},
                    'uv_curve': BOOL, 'template_source': TEXT, 'evidence': TEXT, 'licence': TEXT})
LEDGER = obj({'vial_volume_m3': number('m^3', 0), 'injected_volume_m3': number('m^3', 0), 'volume_residual_m3': number('m^3'),
              'species_residual_mol': number('mol'), 'injected_mol': number('mol', 0), 'column_mol': number('mol', 0), 'eluted_mol': number('mol', 0),
              'modifier_drawn_m3': number('m^3', 0), 'modifier_residual_m3': number('m^3'), 'co2_used_kg': number('kg', 0), 'co2_residual_kg': number('kg'),
              'waste_m3': number('m^3', 0)})
EMPTY = obj({})

# capability -> (input, output, components, meaning, kind, visibility, example, effects)
CAPS = {}


def _cap(key, inp, out, comps, meaning, kind='device_command', vis='agent', example=None, effects=()):
    CAPS[key] = (inp, out, list(comps), meaning, kind, vis, example if example is not None else {}, list(effects))


_cap('power.set', obj({'enabled': BOOL}), obj({'enabled': BOOL}), ['pump_power_switch', 'sampler_power_switch', 'mct_power_switch', 'dad_power_switch', 'control_power_switch'],
     '整套五个模块统一通断电（软件/机器人整体操作）；断电停泵、取消运行，保留已注入物质', example={'enabled': True},
     effects=['power.enabled', 'pump.enabled', 'run.phase'] + [f'power.{m}' for m in MODULES])
_cap('power.toggle', obj({'module': enum(MODULES)}), obj({'module': enum(MODULES), 'enabled': BOOL}),
     ['pump_power_switch', 'sampler_power_switch', 'mct_power_switch', 'dad_power_switch', 'control_power_switch'],
     '单个模块前面板（控制模块为背面）电源开关翻转；任一模块断电取消进行中的运行，仅泵或控制模块断电清除泵运行目标', example={'module': 'pump'},
     effects=['power.enabled', 'pump.enabled', 'run.phase'] + [f'power.{m}' for m in MODULES])
_cap('supply.configure', SUPPLY, obj({'configured': BOOL}), ['co2_inlet', 'control_housing'],
     '宿主连接CO2气瓶：供气表压、可用CO2质量与环境温度（实验室管路边界，非机器人动作）', 'configuration', 'evaluator', SUPPLY_EXAMPLE,
     ['supply.connected', 'supply.pressure_pa', 'co2.ready'])
_cap('solvent.configure', BOTTLE, obj({'configured': BOOL}), ['bottle_b1', 'bottle_b2', 'solvent_cabinet'],
     '宿主在溶剂柜放置改性剂瓶B1/B2（甲醇、甲醇+10 mmol/L氨、甲醇+2%水）及体积', 'configuration', 'evaluator', BOTTLE_EXAMPLE, ['solvent.b1', 'solvent.b2'])
_cap('column.install', COLUMN_INSTALL, obj({'position': integer(1, N_COLUMN_POSITIONS), 'column': enum(list(COLUMN_IDS) + ['none'])}),
     ['column_1', 'column_2', 'column_3', 'column_4', 'mct_door'],
     '在柱温箱四个柱位安装/拆下模板库六种固定相之一（100×3.0 mm）；要求柱温箱门打开且泵停', 'configuration', 'evaluator',
     {'position': 1, 'column': 'silica'}, ['column.installed'])
_cap('sample.register_vial', VIAL, obj({'registered': BOOL}), ['drawer_1', 'drawer_2', 'drawer_3', 'drawer_4', 'vial_tray_1'],
     '宿主登记已放入抽屉托盘的样品瓶：体积与真值组成（物质为模板库substance_id）；要求该抽屉拉出', 'configuration', 'evaluator', VIAL_EXAMPLE,
     ['sample.vial_count'])
_cap('sample.remove_vial', VIAL_REF, obj({'returned_m3': number('m^3', 0)}), ['drawer_1', 'drawer_2', 'drawer_3', 'drawer_4'],
     '取走样品瓶（返还剩余液体，已注入部分留在账本中）；要求抽屉拉出', 'configuration', 'evaluator', {'drawer': 1, 'position': 1}, ['sample.vial_count'])
_cap('method.configure', METHOD, obj({'configured': BOOL, 'delay_volume_m3': number('m^3', DELAY_MIN_M3, DELAY_MAX_M3)}),
     ['pump_head_a', 'pump_head_b', 'column_valve', 'bpr_unit', 'flow_cell', 'sampler_housing'],
     '写入方法目标：流量、改性剂通道与梯度表、背压与背压阀温度、柱温、柱位、进样体积、检测波长、运行时间与采样率；只写目标，实际值随step演化',
     'configuration', 'agent', METHOD_EXAMPLE,
     ['method.configured', 'pump.flow_target_m3_s', 'bpr.target_pa', 'bpr.temperature_target_k', 'column.target_k', 'column.selected', 'detector.wavelength_m'])
_cap('pump.set', obj({'enabled': BOOL}), obj({'enabled': BOOL}), ['pump_head_a', 'pump_head_b', 'booster_unit'],
     '泵运行目标（平衡/冲洗按方法初始组成）；需全部模块通电、CO2就绪、已配置方法且所选柱位有柱', example={'enabled': True}, effects=['pump.enabled'])
for _m, (_sid, _unit, _hi, _comp) in MECH.items():
    _arg = 'angle_rad' if _unit == 'rad' else 'position_m'
    _cap(f'{_m}.set', obj({_arg: number(_unit, 0, _hi)}), obj({_arg: number(_unit, 0, _hi)}), [_comp],
         '宿主/场景权威机构位置（0=关闭）；运行或进样中拒绝打开进样器门、抽屉与柱温箱门', example={_arg: 0.0}, effects=[_sid])
_cap('run.start', VIAL_REF, obj({'phase': enum(PHASES), 'operation_id': TEXT}), ['needle_assembly', 'sampler_housing', 'column_valve', 'flow_cell'],
     '从指定抽屉/瓶位进样并开始采集：系统就绪（流量、背压、柱温在容差内）、门和该抽屉关闭、瓶内余量足够；异步，按step推进到运行时间结束',
     example={'drawer': 1, 'position': 1}, effects=['run.phase', 'run.elapsed_s', 'sample.vial_count'])
_cap('run.abort', EMPTY, obj({'phase': enum(PHASES)}), ['needle_assembly', 'flow_cell'], '取消当前进样/采集，保留已采集数据与物料账本',
     effects=['run.phase'])
_cap('chromatogram.read', obj({'max_points': integer(10, 40000)}, required=[]), CHROM, ['flow_cell', 'dad_housing'],
     '读取最近一次运行已采集的色谱图与峰表（无物质身份）；纯读取，不推进时钟', 'query', example={'max_points': 2000})
_cap('peaks.quantify', QUANT_IN, QUANT_OUT, ['flow_cell'],
     '用调用者提供的外标点（浓度-峰面积）线性拟合，并对最近完成运行中保留时间窗内最大峰定量；不访问样品真值', 'analysis', example=dict(
         calibration=[dict(concentration_mol_m3=0.1, area_au_s=0.01), dict(concentration_mol_m3=0.5, area_au_s=0.05)], retention_window_s=[100.0, 200.0]))
_cap('template.read', obj({'substance_id': TEXT}), TEMPLATE_OUT, ['flow_cell'],
     '查询公开的SFC保留时间模板（参考方法下六种柱×三种改性剂的实测首次进样保留时间）；与样品身份无关', 'query', example={'substance_id': 'caffeine'})
_cap('ledger.read', EMPTY, LEDGER, ['vial_tray_1', 'column_1', 'waste_port', 'co2_inlet'],
     '私有物料账本：样品瓶体积与物质（瓶→柱→废液/排气）、改性剂、CO2与废液守恒残差', 'query', 'evaluator')
UNSUPPORTED = ('chiral.separate', 'ms.detect', 'hardware.connect', 'sample_thermostat.set')
for _k, _z in (('chiral.separate', '手性柱与对映体分离：模板库无手性固定相实测数据，未实现'),
               ('ms.detect', '质谱联用：本配置只有DAD，MS未实现'),
               ('hardware.connect', '真实仪器（OpenLab CDS/RC.NET）连接未实现'),
               ('sample_thermostat.set', '进样器样品恒温器为选配件，本配置未建模')):
    _cap(_k, EMPTY, EMPTY, ['sampler_housing' if 'sample' in _k else 'control_housing'], _z)

# state slots: key -> (schema, unit, origin, visibility, components, write (cap, arg) or None, meaning_zh)
SLOTS = {}


def _slot(key, schema, unit, origin, vis, comps, write=None, meaning=''):
    SLOTS[key] = (schema, unit, origin, vis, list(comps), write, meaning)


_slot('power.enabled', BOOL, '1', 'derived', 'agent', ['pump_power_switch'], None, '五个模块全部通电时为true')
for _m in MODULES:
    _slot(f'power.{_m}', BOOL, '1', 'setpoint', 'agent', [f'{_m}_power_switch'], None, f'{_m}模块电源开关状态')
    _slot(f'status.{_m}', enum(['off', 'not_ready', 'ready', 'run', 'error']), '1', 'derived', 'agent', [f'{_m}_status_led'], None,
          f'{_m}模块状态指示灯代理（off/not_ready黄/ready绿/run/error红）')
_slot('supply.connected', BOOL, '1', 'scene', 'agent', ['co2_inlet'], None, 'CO2气瓶是否接到控制模块进口')
_slot('supply.pressure_pa', number('Pa', 0), 'Pa', 'derived', 'agent', ['co2_inlet'], None, 'CO2供气表压（气瓶空时为0）')
_slot('co2.ready', BOOL, '1', 'derived', 'agent', ['chiller_unit'], None, '供气压力在40–70 bar且冷却器≤9 °C时CO2调理就绪')
_slot('chiller.temperature_k', number('K', 0), 'K', 'process_truth', 'evaluator', ['chiller_unit'], None, 'CO2再液化冷却器温度真值')
_slot('booster.pressure_pa', number('Pa', 0), 'Pa', 'process_truth', 'evaluator', ['booster_unit'], None, '增压泵出口表压真值（略低于柱头压力）')
_slot('method.configured', BOOL, '1', 'setpoint', 'agent', ['sampler_housing'])
_slot('pump.enabled', BOOL, '1', 'setpoint', 'agent', ['pump_head_a'], ('pump.set', 'enabled'))
_slot('pump.flow_target_m3_s', nullable(number('m^3/s', FLOW_MIN, FLOW_MAX)), 'm^3/s', 'setpoint', 'agent', ['pump_head_a'])
_slot('pump.flow_m3_s', number('m^3/s', 0), 'm^3/s', 'derived', 'agent', ['pump_head_a'], None, '泵实际总体积流量（泵头条件，未作压缩性换算）')
_slot('pump.modifier_fraction', number('1', 0, 1), '1', 'derived', 'agent', ['pump_head_b'], None, '泵出口改性剂体积分数（梯度表当前值）')
_slot('pump.pressure_pa', number('Pa', 0), 'Pa', 'process_truth', 'evaluator', ['pump_head_a'], None, '泵出口表压真值')
_slot('pump.indicated_pressure_pa', number('Pa', 0), 'Pa', 'derived', 'agent', ['pump_head_a'], None, '泵压力显示（0.1 bar量化）')
_slot('bpr.target_pa', nullable(number('Pa', BPR_MIN_PA, BPR_MAX_PA)), 'Pa', 'setpoint', 'agent', ['bpr_unit'])
_slot('bpr.pressure_pa', number('Pa', 0), 'Pa', 'process_truth', 'evaluator', ['bpr_unit'], None, '背压阀入口表压真值（系统出口压力）')
_slot('bpr.indicated_pressure_pa', number('Pa', 0), 'Pa', 'derived', 'agent', ['bpr_unit'], None, '背压显示（±0.25 bar精度代理，0.01 bar量化）')
_slot('bpr.temperature_target_k', nullable(number('K', BPR_T_MIN, BPR_T_MAX)), 'K', 'setpoint', 'agent', ['bpr_unit'])
_slot('bpr.temperature_k', number('K', 0), 'K', 'process_truth', 'evaluator', ['bpr_unit'], None, '背压阀加热头温度真值')
_slot('column.target_k', nullable(number('K', COL_T_ABS_MIN, COL_T_MAX)), 'K', 'setpoint', 'agent', ['mct_housing'])
_slot('column.temperature_k', number('K', 0), 'K', 'process_truth', 'evaluator', ['mct_housing'], None, '柱温箱温区温度真值（单节点）')
_slot('column.indicated_k', number('K', 0), 'K', 'derived', 'agent', ['mct_housing'], None, '柱温显示（0.1 K量化）')
_slot('column.selected', nullable(integer(1, N_COLUMN_POSITIONS)), '1', 'setpoint', 'agent', ['column_valve'])
_slot('column.installed', {'type': 'array', 'items': enum(list(COLUMN_IDS) + ['none']), 'minItems': 4, 'maxItems': 4}, '1', 'scene', 'agent',
      ['column_1', 'column_2', 'column_3', 'column_4'], None, '四个柱位安装的固定相类型（实验室配置，agent可见）')
_slot('mobile_phase.co2_density_kg_m3', nullable(number('kg/m^3', 0)), 'kg/m^3', 'process_truth', 'evaluator', ['column_1'], None,
      '柱温与背压下纯CO2密度（Peng-Robinson）')
_slot('detector.wavelength_m', nullable(number('m', LAMBDA_MIN, LAMBDA_MAX)), 'm', 'setpoint', 'agent', ['flow_cell'])
_slot('detector.absorbance_au', number('AU'), 'AU', 'derived', 'agent', ['flow_cell'], None, '流通池当前吸光度（含噪声与漂移）')
_slot('system.ready', BOOL, '1', 'derived', 'agent', ['control_status_led'], None, '流量、背压、柱温均到达方法目标容差内')
_slot('system.fault', TEXT, '1', 'derived', 'agent', ['control_status_led'], None, '最近故障代码（空串=无）')
_slot('run.phase', enum(PHASES), '1', 'derived', 'agent', ['dad_status_led'])
_slot('run.elapsed_s', number('s', 0), 's', 'derived', 'agent', ['dad_status_led'], None, '自进样阀切换（采集零点）起的运行时间')
_slot('run.count', integer(0, 10 ** 9), '1', 'derived', 'agent', ['dad_status_led'], None, '已启动的运行次数')
_slot('sample.vial_count', integer(0, N_DRAWERS * N_VIAL_POSITIONS), '1', 'scene', 'agent', ['vial_tray_1'], None, '已登记样品瓶数')
for _m, (_sid, _unit, _hi, _comp) in MECH.items():
    _slot(_sid, number(_unit, 0, _hi), _unit, 'scene', 'agent', [_comp], (f'{_m}.set', 'angle_rad' if _unit == 'rad' else 'position_m'))
_slot('solvent.b1', nullable(enum(MODIFIERS)), '1', 'scene', 'agent', ['bottle_b1'], None, 'B1瓶改性剂类型')
_slot('solvent.b2', nullable(enum(MODIFIERS)), '1', 'scene', 'agent', ['bottle_b2'], None, 'B2瓶改性剂类型')
_slot('truth.bottle_b1_m3', number('m^3', 0), 'm^3', 'process_truth', 'evaluator', ['bottle_b1'], None, 'B1瓶剩余改性剂体积')
_slot('truth.bottle_b2_m3', number('m^3', 0), 'm^3', 'process_truth', 'evaluator', ['bottle_b2'], None, 'B2瓶剩余改性剂体积')
_slot('truth.cylinder_co2_kg', number('kg', 0), 'kg', 'process_truth', 'evaluator', ['co2_inlet'], None, '气瓶剩余CO2质量')
_slot('truth.vented_co2_kg', number('kg', 0), 'kg', 'process_truth', 'evaluator', ['exhaust_port'], None, '经背压阀排出的CO2累计质量')
_slot('truth.waste_m3', number('m^3', 0), 'm^3', 'process_truth', 'evaluator', ['waste_port'], None, '废液（改性剂+样品溶剂）累计体积')
_slot('truth.column_mol', number('mol', 0), 'mol', 'process_truth', 'evaluator', ['column_1'], None, '已注入但尚未流出色谱柱的物质总量')
_slot('truth.eluted_mol', number('mol', 0), 'mol', 'process_truth', 'evaluator', ['waste_port'], None, '已流出到废液/排气的物质总量')

REFERENCE_ZH = {
    'supply.pressure_pa': '表压；CO2供气相对环境大气压。厂家40–70 bar（580–1000 psi）按表压解释，这是本资产的假设。',
    'booster.pressure_pa': '表压；相对环境大气压。', 'pump.pressure_pa': '表压；相对环境大气压，=背压+柱压降+柱外压降。',
    'pump.indicated_pressure_pa': '表压；相对环境大气压。厂家600 bar上限按表压解释。',
    'bpr.target_pa': '表压；背压阀设定相对环境大气压（厂家100–400 bar）。', 'bpr.pressure_pa': '表压；相对环境大气压。',
    'bpr.indicated_pressure_pa': '表压；相对环境大气压。',
    'pump.flow_target_m3_s': '泵头条件下的总体积流量（CO2+改性剂），与厂家mL/min设定一致；未作可压缩性换算。',
    'pump.flow_m3_s': '泵头条件下的总体积流量（CO2+改性剂）；色谱模型按柱内体积流量近似使用。',
    'mobile_phase.co2_density_kg_m3': '纯CO2在柱温与背压（绝压=表压+101325 Pa）下的Peng-Robinson密度；忽略改性剂对密度的影响。',
}


# ------------------------------------------------------------------------------------------------------ physical models
def co2_density(temperature_k, pressure_abs_pa):
    """Peng-Robinson density of pure CO2 (dense root).  NIST critical constants; ~5-10 % below reference data in the dense region."""
    a = 0.45724 * R_GAS ** 2 * CO2_TC ** 2 / CO2_PC
    b = 0.07780 * R_GAS * CO2_TC / CO2_PC
    kappa = 0.37464 + 1.54226 * CO2_OMEGA - 0.26992 * CO2_OMEGA ** 2
    alpha = (1 + kappa * (1 - math.sqrt(temperature_k / CO2_TC))) ** 2
    A = a * alpha * pressure_abs_pa / (R_GAS * temperature_k) ** 2
    B = b * pressure_abs_pa / (R_GAS * temperature_k)
    roots = np.roots([1.0, -(1 - B), A - 3 * B ** 2 - 2 * B, -(A * B - B ** 2 - B ** 3)])
    real = sorted(r.real for r in roots if abs(r.imag) < 1e-9 and r.real > B)
    z = real[0]
    return float(pressure_abs_pa * CO2_M / (z * R_GAS * temperature_k))


@lru_cache(maxsize=1)
def _rho_ref():
    return co2_density(REF_COLUMN_K, REF_BPR_PA + 101325.0)


def void_time_s(length_m, inner_diameter_m, flow_m3_s):
    return TOTAL_POROSITY * math.pi * (inner_diameter_m / 2) ** 2 * length_m / flow_m3_s


def delay_volume_m3(bpr_pa):
    """Documented 600-900 uL 'depending on back pressure'; linear in the 100-400 bar BPR range (mapping is an assumption)."""
    f = min(1.0, max(0.0, (bpr_pa - BPR_MIN_PA) / (BPR_MAX_PA - BPR_MIN_PA)))
    return DELAY_MIN_M3 + f * (DELAY_MAX_M3 - DELAY_MIN_M3)


def mixture_viscosity(phi):
    phi = min(1.0, max(0.0, phi))
    return math.exp(phi * math.log(ETA_MEOH_PA_S) + (1 - phi) * math.log(ETA_CO2_PA_S))


def column_pressure_drop(flow_m3_s, phi, column):
    """Kozeny-Carman drop over the packed bed (Pa)."""
    area = math.pi * (column['inner_diameter_m'] / 2) ** 2
    u_s = flow_m3_s / area
    e = BED_POROSITY
    return 180.0 * mixture_viscosity(phi) * u_s * column['length_m'] * (1 - e) ** 2 / (e ** 3 * column['particle_m'] ** 2)


def program_value(program, t):
    """Piecewise-linear modifier fraction; holds the first value before t=0 and the last after the table."""
    times = np.array([p[0] for p in program], float)
    vals = np.array([p[1] for p in program], float)
    return np.interp(t, times, vals)


def migrate(a, m, program, t0_s, delay_s, t_end_s, dt_s=0.05, extra_ln_k=0.0):
    """Vectorised band migration under a gradient.  a: array of log10 k at phi = 1.  Returns (t_R, k at elution, phi at elution);
    NaN where the band has not left the column by t_end_s."""
    a = np.atleast_1d(np.asarray(a, float))
    z = np.zeros_like(a)
    tr = np.full_like(a, np.nan)
    ke = np.full_like(a, np.nan)
    pe = np.full_like(a, np.nan)
    times = np.array([p[0] for p in program], float)
    vals = np.array([p[1] for p in program], float)
    t = 0.0
    while t < t_end_s and np.isnan(tr).any():
        phi = np.interp(t - delay_s - z * t0_s, times, vals)
        k = 10.0 ** (a - m * np.log10(np.maximum(phi, PHI_MIN))) * math.exp(extra_ln_k)
        v = 1.0 / (t0_s * (1.0 + k))
        z_new = z + v * dt_s
        done = (z_new >= 1.0) & np.isnan(tr)
        if done.any():
            frac = (1.0 - z[done]) / (z_new[done] - z[done])
            tr[done] = t + frac * dt_s
            ke[done] = k[done]
            pe[done] = phi[done]
        z = np.where(np.isnan(tr), z_new, z)
        t += dt_s
    return tr, ke, pe


@lru_cache(maxsize=1)
def library():
    data = json.loads((ROOT / LIBRARY_REL).read_text(encoding='utf-8'))
    return data


@lru_cache(maxsize=1)
def library_sha256():
    return hashlib.sha256((ROOT / LIBRARY_REL).read_bytes()).hexdigest()


@lru_cache(maxsize=1)
def columns():
    """Stationary phases of the source data by id (stored as a list in the library so that column ids are never mistaken for compound ids)."""
    return {c['column_id']: c for c in library()['columns']}


@lru_cache(maxsize=1)
def templates():
    return {r['substance_id']: r for r in library()['templates']}


def epsilon(sid, wavelength_m):
    """(epsilon m^2/mol, evidence) at the wavelength: NIST curve when the library has one covering it, else the flagged assumption."""
    uv = templates()[sid].get('uv_vis')
    if uv and uv['wavelength_m'][0] <= wavelength_m <= uv['wavelength_m'][-1]:
        log_eps = float(np.interp(wavelength_m, uv['wavelength_m'], uv['log10_epsilon_l_mol_cm']))
        return 10.0 ** log_eps * 0.1, 'measured_nist_uv'          # L/(mol cm) -> m^2/mol
    return ASSUMED_EPSILON_M2_MOL, 'assumption'


def baseline(time_s, signal, segment_s=30.0):
    """Slowly varying baseline: 20th percentile of each segment, linearly interpolated (removes detector drift before peak picking)."""
    t = np.asarray(time_s, float)
    y = np.asarray(signal, float)
    if len(t) < 3:
        return np.zeros_like(y)
    edges = np.arange(t[0], t[-1] + segment_s, segment_s)
    cx, cy = [], []
    for lo, hi in zip(edges[:-1], edges[1:]):
        sel = (t >= lo) & (t < hi)
        if sel.sum() >= 3:
            cx.append(float(t[sel].mean()))
            cy.append(float(np.percentile(y[sel], 20)))
    if not cx:
        return np.full_like(y, float(np.percentile(y, 20)))
    return np.interp(t, cx, cy)


def detect_peaks(time_s, signal, threshold):
    """Baseline-corrected local maxima above threshold; area by trapezoid between the neighbouring minima (or the trace ends)."""
    t = np.asarray(time_s, float)
    y = np.asarray(signal, float) - baseline(time_s, signal)
    peaks = []
    if len(y) < 5:
        return peaks
    i = 1
    while i < len(y) - 1:
        if y[i] >= threshold and y[i] >= y[i - 1] and y[i] > y[i + 1]:
            lo = i
            while lo > 0 and y[lo - 1] <= y[lo] and y[lo - 1] > threshold * 0.2:
                lo -= 1
            hi = i
            while hi < len(y) - 1 and y[hi + 1] <= y[hi] and y[hi + 1] > threshold * 0.2:
                hi += 1
            seg_t, seg_y = t[max(0, lo - 1):hi + 2], y[max(0, lo - 1):hi + 2]
            area = float(np.trapezoid(seg_y, seg_t)) if len(seg_t) > 1 else 0.0
            half = y[i] / 2
            above = np.where(seg_y >= half)[0]
            width = float(seg_t[above[-1]] - seg_t[above[0]]) if len(above) > 1 else 0.0
            peaks.append(dict(retention_time_s=float(t[i]), area_au_s=area, height_au=float(y[i]), width_half_height_s=width))
            i = hi + 1
        else:
            i += 1
    return peaks


def validate(schema, value):
    if 'anyOf' in schema:
        for s in schema['anyOf']:
            try:
                validate(s, value)
                return
            except ActionRejected:
                pass
        raise ActionRejected('INVALID_ARGUMENT')
    t = schema.get('type')
    if t in ('number', 'integer'):
        if isinstance(value, bool) or not isinstance(value, (int, float)) or not math.isfinite(value):
            raise ActionRejected('INVALID_ARGUMENT')
        if t == 'integer' and (not isinstance(value, int)):
            raise ActionRejected('INVALID_ARGUMENT')
        if value < schema.get('minimum', -math.inf) or value > schema.get('maximum', math.inf):
            raise ActionRejected('INVALID_ARGUMENT')
    elif t == 'boolean':
        if type(value) is not bool:
            raise ActionRejected('INVALID_ARGUMENT')
    elif t == 'string':
        if not isinstance(value, str):
            raise ActionRejected('INVALID_ARGUMENT')
    elif t == 'null':
        if value is not None:
            raise ActionRejected('INVALID_ARGUMENT')
    elif t == 'array':
        if not isinstance(value, list) or not schema.get('minItems', 0) <= len(value) <= schema.get('maxItems', math.inf):
            raise ActionRejected('INVALID_ARGUMENT')
        for v in value:
            validate(schema['items'], v)
    elif t == 'object':
        if not isinstance(value, dict) or not set(schema.get('required', [])) <= set(value):
            raise ActionRejected('INVALID_ARGUMENT')
        if len(value) > schema.get('maxProperties', math.inf):
            raise ActionRejected('INVALID_ARGUMENT')
        props = schema.get('properties', {})
        for k, v in value.items():
            if not isinstance(k, str):
                raise ActionRejected('INVALID_ARGUMENT')
            sub = props.get(k, schema.get('additionalProperties', True))
            if sub is False:
                raise ActionRejected('INVALID_ARGUMENT')
            if isinstance(sub, dict):
                validate(sub, v)
    if 'enum' in schema and value not in schema['enum']:
        raise ActionRejected('INVALID_ARGUMENT')


# --------------------------------------------------------------------------------------------------------------- runtime
class Agilent1260infinityRuntime:
    """Process model of one SFC system instance (host-owned clock)."""

    def __init__(self, instance_id='sfc_01'):
        self.instance_id = instance_id
        self.time_s = 0.0
        self.revision = 0
        self.ambient_k = 298.15
        self.power = {m: False for m in MODULES}
        self.supply = dict(connected=False, supply_pa=0.0, cylinder_co2_kg=0.0)
        self.co2_initial_kg = 0.0
        self.vented_co2_kg = 0.0
        self.bottles = {'B1': None, 'B2': None}
        self.modifier_loaded_m3 = 0.0
        self.modifier_drawn_m3 = 0.0
        self.waste_m3 = 0.0
        self.columns = {p: 'none' for p in range(1, N_COLUMN_POSITIONS + 1)}
        self.mech = {m: 0.0 for m in MECH}
        self.vials = {}
        self.vial_loaded_m3 = 0.0
        self.vial_returned_m3 = 0.0
        self.injected_m3 = 0.0
        self.method = None
        self.pump_enabled = False
        self.chiller_k = 298.15
        self.booster_pa = 0.0
        self.flow = 0.0
        self.pump_pa = 0.0
        self.bpr_pa = 0.0
        self.bpr_k = 298.15
        self.column_k = 298.15
        self.fault = ''
        self.phase = 'idle'
        self.run = None
        self.run_count = 0
        self.operation_id = None
        self.bands = []           # {'sid','mol','t_r','sigma','eluted'}
        self.injected_mol = 0.0
        self.eluted_mol = 0.0
        self.absorbance = 0.0
        self._principals = {'__public_agent__': 'agent'}
        self._requests = {}
        self._owners = {}

    # ---- principals / sessions -------------------------------------------------------------------------
    def register_principal(self, principal_id, visibility='agent'):
        if visibility not in ('agent', 'evaluator', 'debug'):
            raise ActionRejected('INVALID_ARGUMENT')
        if principal_id in self._principals:
            raise ActionRejected('REQUEST_CONFLICT')
        self._principals[principal_id] = visibility

    def session(self, principal_id='__public_agent__'):
        if principal_id not in self._principals:
            raise ActionRejected('ACCESS_DENIED')
        return Agilent1260infinitySession(self, principal_id)

    def describe(self):
        return self.session().describe(instance_id=self.instance_id)

    # ---- derived quantities ---------------------------------------------------------------------------------
    def _column(self):
        if not self.method:
            return None
        cid = self.columns[self.method['column_position']]
        return None if cid == 'none' else dict(columns()[cid], id=cid)

    def _program(self):
        return [(r['time_s'], r['modifier_fraction']) for r in self.method['program']]

    def _phi_now(self):
        if not self.method:
            return 0.0
        prog = self._program()
        if self.phase == 'running' and self.run:
            return float(program_value(prog, self.run['elapsed']))
        return float(prog[0][1])

    def _all_powered(self):
        return all(self.power.values())

    def _co2_ready(self):
        return (self.supply['connected'] and SUPPLY_MIN_PA <= self.supply['supply_pa'] <= SUPPLY_MAX_PA + 1e5
                and self.supply['cylinder_co2_kg'] > 0 and self.chiller_k <= 282.15 and self.power['control'])

    def _ready(self):
        if not (self.method and self.pump_enabled and self._all_powered() and self._co2_ready() and not self.fault):
            return False
        m = self.method
        return (self.flow >= READY_FLOW_FRACTION * m['flow_m3_s'] and abs(self.bpr_pa - m['bpr_pa']) <= READY_TOL_PA
                and abs(self.column_k - m['column_temperature_k']) <= READY_TOL_K)

    def _status(self, module):
        if not self.power[module]:
            return 'off'
        if self.fault:
            return 'error'
        if self.phase in ('injecting', 'running'):
            return 'run'
        return 'ready' if self._ready() else 'not_ready'

    def _density(self):
        if not self.method:
            return None
        return co2_density(self.column_k, max(self.bpr_pa, 1e5) + 101325.0)

    def _values(self):
        m = self.method or {}
        v = {'power.enabled': self._all_powered()}
        for mod in MODULES:
            v[f'power.{mod}'] = self.power[mod]
            v[f'status.{mod}'] = self._status(mod)
        v.update({
            'supply.connected': self.supply['connected'],
            'supply.pressure_pa': self.supply['supply_pa'] if self.supply['connected'] and self.supply['cylinder_co2_kg'] > 0 else 0.0,
            'co2.ready': bool(self._co2_ready()), 'chiller.temperature_k': self.chiller_k, 'booster.pressure_pa': self.booster_pa,
            'method.configured': self.method is not None, 'pump.enabled': self.pump_enabled,
            'pump.flow_target_m3_s': m.get('flow_m3_s'), 'pump.flow_m3_s': self.flow,
            'pump.modifier_fraction': self._phi_now() if self.pump_enabled else 0.0,
            'pump.pressure_pa': self.pump_pa, 'pump.indicated_pressure_pa': round(self.pump_pa / 1e4) * 1e4,
            'bpr.target_pa': m.get('bpr_pa'), 'bpr.pressure_pa': self.bpr_pa, 'bpr.indicated_pressure_pa': round(self.bpr_pa / 1e3) * 1e3,
            'bpr.temperature_target_k': m.get('bpr_temperature_k'), 'bpr.temperature_k': self.bpr_k,
            'column.target_k': m.get('column_temperature_k'), 'column.temperature_k': self.column_k,
            'column.indicated_k': round(self.column_k * 10) / 10, 'column.selected': m.get('column_position'),
            'column.installed': [self.columns[p] for p in range(1, N_COLUMN_POSITIONS + 1)],
            'mobile_phase.co2_density_kg_m3': self._density(), 'detector.wavelength_m': m.get('wavelength_m'),
            'detector.absorbance_au': self.absorbance, 'system.ready': self._ready(), 'system.fault': self.fault,
            'run.phase': self.phase, 'run.elapsed_s': self.run['elapsed'] if self.run else 0.0, 'run.count': self.run_count,
            'sample.vial_count': len(self.vials),
            'solvent.b1': (self.bottles['B1'] or {}).get('modifier'), 'solvent.b2': (self.bottles['B2'] or {}).get('modifier'),
            'truth.bottle_b1_m3': (self.bottles['B1'] or {}).get('volume_m3', 0.0), 'truth.bottle_b2_m3': (self.bottles['B2'] or {}).get('volume_m3', 0.0),
            'truth.cylinder_co2_kg': self.supply['cylinder_co2_kg'], 'truth.vented_co2_kg': self.vented_co2_kg, 'truth.waste_m3': self.waste_m3,
            'truth.column_mol': sum(b['mol'] for b in self.bands if not b['eluted']), 'truth.eluted_mol': self.eluted_mol})
        for name, (sid, *_r) in MECH.items():
            v[sid] = self.mech[name]
        return v

    def read(self, visibility='agent'):
        return copy.deepcopy({k: val for k, val in self._values().items() if SLOTS[k][3] == 'agent' or visibility in ('evaluator', 'debug')})

    def _ledger(self):
        vial = sum(x['volume_m3'] for x in self.vials.values())
        species_in_vials = sum(x['volume_m3'] * sum(x['composition'].values()) for x in self.vials.values())
        column = sum(b['mol'] for b in self.bands if not b['eluted'])
        bottles = sum((b or {}).get('volume_m3', 0.0) for b in self.bottles.values())
        return dict(vial_volume_m3=vial, injected_volume_m3=self.injected_m3,
                    volume_residual_m3=self.vial_loaded_m3 - vial - self.injected_m3 - self.vial_returned_m3,
                    species_residual_mol=self._species_loaded - species_in_vials - self.injected_mol - self._species_returned,
                    injected_mol=self.injected_mol, column_mol=column, eluted_mol=self.eluted_mol,
                    modifier_drawn_m3=self.modifier_drawn_m3, modifier_residual_m3=self.modifier_loaded_m3 - bottles - self.modifier_drawn_m3,
                    co2_used_kg=self.vented_co2_kg, co2_residual_kg=self.co2_initial_kg - self.supply['cylinder_co2_kg'] - self.vented_co2_kg,
                    waste_m3=self.waste_m3)

    _species_loaded = 0.0
    _species_returned = 0.0

    # ---- capabilities -----------------------------------------------------------------------------------------
    def invoke(self, capability, **a):
        if capability not in CAPS:
            raise ActionRejected('UNKNOWN_CAPABILITY')
        if capability in UNSUPPORTED:
            raise ActionRejected('UNSUPPORTED')
        validate(CAPS[capability][0], a)
        if CAPS[capability][4] in ('query', 'analysis'):       # pure reads / caller-data analysis: no state snapshot needed
            result = self._invoke(capability, a)
            validate(CAPS[capability][1], result)
            return copy.deepcopy(result)
        before = copy.deepcopy({k: v for k, v in self.__dict__.items() if k not in ('_principals', '_requests', '_owners')})
        try:
            result = self._invoke(capability, a)
            validate(CAPS[capability][1], result)
        except Exception:
            self.__dict__.update(before)
            raise
        self.revision += 1
        return copy.deepcopy(result)

    def _busy(self):
        return self.phase in ('injecting', 'running')

    def _invoke(self, k, a):
        if k == 'chromatogram.read':
            return self._chromatogram(a.get('max_points', 2000))
        if k == 'ledger.read':
            return self._ledger()
        if k == 'template.read':
            return self._template(a['substance_id'])
        if k == 'peaks.quantify':
            return self._quantify(a)
        if k == 'power.set':
            for m in MODULES:
                self.power[m] = a['enabled']
            if not a['enabled']:
                self._power_lost('control')
            return {'enabled': a['enabled']}
        if k == 'power.toggle':
            self.power[a['module']] = not self.power[a['module']]
            if not self.power[a['module']]:
                self._power_lost(a['module'])
            return {'module': a['module'], 'enabled': self.power[a['module']]}
        if k == 'supply.configure':
            if self.pump_enabled:
                raise ActionRejected('PRECONDITION_FAILED')
            if a['connected'] and not (SUPPLY_MIN_PA <= a['supply_pa'] <= SUPPLY_MAX_PA):
                raise ActionRejected('INVALID_ARGUMENT')
            self.supply = dict(connected=a['connected'], supply_pa=a['supply_pa'] if a['connected'] else 0.0, cylinder_co2_kg=a['cylinder_co2_kg'])
            self.co2_initial_kg = a['cylinder_co2_kg'] + self.vented_co2_kg
            if self.ambient_k != a['ambient_k'] and not any(self.power.values()):
                self.chiller_k = self.bpr_k = self.column_k = a['ambient_k']
            self.ambient_k = a['ambient_k']
            return {'configured': True}
        if k == 'solvent.configure':
            if self.pump_enabled:
                raise ActionRejected('PRECONDITION_FAILED')
            old = (self.bottles[a['channel']] or {}).get('volume_m3', 0.0)
            self.modifier_loaded_m3 += a['volume_m3'] - old
            self.bottles[a['channel']] = dict(modifier=a['modifier'], volume_m3=a['volume_m3'])
            return {'configured': True}
        if k == 'column.install':
            if self.pump_enabled or self._busy() or self.mech['mct_door'] < 0.5:
                raise ActionRejected('PRECONDITION_FAILED')
            self.columns[a['position']] = a['column']
            return dict(a)
        if k == 'sample.register_vial':
            if self.mech[f"drawer_{a['drawer']}"] < 0.15 or (a['drawer'], a['position']) in self.vials:
                raise ActionRejected('PRECONDITION_FAILED')
            comp = a['composition_mol_m3']
            if not comp or any(s not in templates() for s in comp):
                raise ActionRejected('INVALID_ARGUMENT')
            self.vials[(a['drawer'], a['position'])] = dict(volume_m3=a['volume_m3'], composition=dict(comp))
            self.vial_loaded_m3 += a['volume_m3']
            self._species_loaded += a['volume_m3'] * sum(comp.values())
            return {'registered': True}
        if k == 'sample.remove_vial':
            key = (a['drawer'], a['position'])
            if key not in self.vials or self.mech[f"drawer_{a['drawer']}"] < 0.15:
                raise ActionRejected('PRECONDITION_FAILED')
            v = self.vials.pop(key)
            self.vial_returned_m3 += v['volume_m3']
            self._species_returned += v['volume_m3'] * sum(v['composition'].values())
            return {'returned_m3': v['volume_m3']}
        if k == 'method.configure':
            if self._busy():
                raise ActionRejected('BUSY')
            prog = a['program']
            if prog[0]['time_s'] != 0.0 or any(prog[i + 1]['time_s'] <= prog[i]['time_s'] for i in range(len(prog) - 1)):
                raise ActionRejected('INVALID_ARGUMENT')
            if a['column_temperature_k'] < max(COL_T_ABS_MIN, self.ambient_k - 10.0):
                raise ActionRejected('INVALID_ARGUMENT')
            n = a['injection_volume_m3'] / INJ_STEP
            if abs(n - round(n)) > 1e-6:
                raise ActionRejected('INVALID_ARGUMENT')
            if self.pump_enabled:                       # the running pump cannot be switched to an empty bottle or an empty column position
                bottle = self.bottles[a['modifier_channel']]
                if not bottle or bottle['volume_m3'] <= 0 or self.columns[a['column_position']] == 'none':
                    raise ActionRejected('PRECONDITION_FAILED')
            self.method = copy.deepcopy(a)
            return {'configured': True, 'delay_volume_m3': delay_volume_m3(a['bpr_pa'])}
        if k == 'pump.set':
            if a['enabled']:
                if not (self._all_powered() and self._co2_ready() and self.method and self._column()):
                    raise ActionRejected('PRECONDITION_FAILED')
                bottle = self.bottles[self.method['modifier_channel']]
                if not bottle or bottle['volume_m3'] <= 0:
                    raise ActionRejected('PRECONDITION_FAILED')
                self.fault = ''
            elif self._busy():
                self._finish('cancelled')
            self.pump_enabled = a['enabled']
            return {'enabled': a['enabled']}
        if k.endswith('.set') and k[:-4] in MECH:
            name = k[:-4]
            arg = 'angle_rad' if MECH[name][1] == 'rad' else 'position_m'
            opening = a[arg] > 1e-6
            if opening and self._busy():                 # doors / drawers / oven door stay closed while injecting or acquiring
                raise ActionRejected('BUSY')
            self.mech[name] = a[arg]
            return dict(a)
        if k == 'run.start':
            return self._start(a)
        if k == 'run.abort':
            if self._busy():
                self._finish('cancelled')
            return {'phase': self.phase}
        raise ActionRejected('UNKNOWN_CAPABILITY')

    def _power_lost(self, module):
        """A module lost power: any run in progress is cancelled (every module takes part in a run); the pump target is cleared only when
        the pump itself or the control module (CO2 conditioning, BPR) is off - the other modules are independent of the pump."""
        if self._busy():
            self._finish('cancelled')
        if module in ('pump', 'control'):
            self.pump_enabled = False

    def _start(self, a):
        if self._busy():
            raise ActionRejected('BUSY')
        key = (a['drawer'], a['position'])
        if not self._ready() or self.mech['sampler_door'] > 1e-6 or self.mech[f"drawer_{a['drawer']}"] > 1e-6:
            raise ActionRejected('PRECONDITION_FAILED')
        vial = self.vials.get(key)
        m = self.method
        if vial is None or vial['volume_m3'] < m['injection_volume_m3'] + VIAL_DEAD_VOLUME_M3:
            raise ActionRejected('PRECONDITION_FAILED')
        bottle = self.bottles[m['modifier_channel']]
        if not bottle or self._column() is None:
            raise ActionRejected('PRECONDITION_FAILED')
        need = sum(m['flow_m3_s'] * float(program_value(self._program(), t)) * 1.0 for t in np.arange(0, m['run_time_s'] + INJECT_CYCLE_S, 1.0))
        if bottle['volume_m3'] < need:
            raise ActionRejected('PRECONDITION_FAILED')
        self.run_count += 1
        self.operation_id = f'{self.instance_id}:run:{self.run_count}'
        self.run = dict(run_id=self.operation_id, vial=key, elapsed=0.0, inject_left=INJECT_CYCLE_S, t=[], y=[], peaks=[], warnings=[],
                        wavelength=m['wavelength_m'], next_sample=0.0, rng=np.random.default_rng(
                            int(hashlib.sha256(self.operation_id.encode()).hexdigest()[:12], 16)), drift0=0.0)
        self.phase = 'injecting'
        return {'phase': self.phase, 'operation_id': self.operation_id}

    def _inject(self):
        """End of the injection cycle: draw the volume, create the bands from the measured templates and the current conditions."""
        m, run = self.method, self.run
        vial = self.vials[run['vial']]
        vol = m['injection_volume_m3']
        vial['volume_m3'] -= vol
        self.injected_m3 += vol
        self.waste_m3 += vol                                   # the sample solvent leaves with the mobile phase
        col = self._column()
        modifier = self.bottles[m['modifier_channel']]['modifier']
        t0 = void_time_s(col['length_m'], col['inner_diameter_m'], m['flow_m3_s'])
        delay = delay_volume_m3(m['bpr_pa']) / m['flow_m3_s']
        rho = co2_density(self.column_k, m['bpr_pa'] + 101325.0)
        extra = -DENSITY_COEFF * (rho / _rho_ref() - 1.0)
        n_plates = col['length_m'] / (PLATE_HEIGHT_DP * col['particle_m'])
        extra_var = ((FLOW_CELL_VOLUME_M3 / m['flow_m3_s']) ** 2 + (vol / m['flow_m3_s']) ** 2) / 12.0   # flow cell + injection plug (s^2)
        sids, a_vals, mols = [], [], []
        for sid, c in vial['composition'].items():
            moles = c * vol
            self.injected_mol += moles
            entry = templates()[sid]['retention'][col['id']][modifier]
            if entry['status'] != 'eluted' or 'model_fit' not in entry:
                self.bands.append(dict(sid=sid, mol=moles, t_r=None, sigma=None, eps=0.0, eluted=False, done=True, run=run['run_id'],
                                       evidence='not_eluted_in_source_data' if entry['status'] != 'eluted' else 'outside_reference_program'))
                continue
            sids.append(sid)
            a_vals.append(entry['model_fit']['log10_k_at_phi_1'])
            mols.append(moles)
        if sids:
            tr, ke, _ = migrate(np.array(a_vals), LOGLOG_SLOPE_M, self._program(), t0, delay, m['run_time_s'] + 600.0, dt_s=0.05, extra_ln_k=extra)
            for sid, t_r, k_e, moles in zip(sids, tr, ke, mols):
                eps, ev = epsilon(sid, m['wavelength_m'])
                if np.isnan(t_r):
                    self.bands.append(dict(sid=sid, mol=moles, t_r=None, sigma=None, eps=eps, eluted=False, done=True, run=run['run_id'],
                                           evidence='retained_beyond_run'))
                    continue
                sigma = math.sqrt((t0 * (1.0 + float(k_e))) ** 2 / n_plates + extra_var)
                # flow_s: flow-weighted time this band has travelled since injection (it keeps migrating whenever the pump delivers, also after
                # its run ended -> late eluters reach the waste and appear as carry-over peaks in a later run)
                self.bands.append(dict(sid=sid, mol=moles, t_r=float(t_r), sigma=sigma, eps=eps, wl=m['wavelength_m'], eluted=False, done=False,
                                       flow_s=0.0, flow_ref=m['flow_m3_s'], evidence=ev, run=run['run_id']))
        run['t0'] = t0
        run['delay_s'] = delay
        run['flow'] = m['flow_m3_s']

    def _signal(self, t):
        """Absorbance at run time t (inside the current step): every migrating band, including carry-over from earlier runs."""
        run = self.run
        total = 0.0
        lag = run['elapsed'] - t                                    # sample time lies `lag` seconds before the end of this step
        for b in self.bands:
            if b['t_r'] is None or b['done']:
                continue
            fs = b['flow_s'] - lag * (self.flow / b['flow_ref'])
            dz = (fs - b['t_r']) / b['sigma']
            if abs(dz) < 8:
                eps = b['eps'] if b['wl'] == run['wavelength'] else epsilon(b['sid'], run['wavelength'])[0]
                c = b['mol'] / (run['flow'] * b['sigma'] * math.sqrt(2 * math.pi)) * math.exp(-0.5 * dz * dz)
                total += eps * FLOW_CELL_PATH_M * c
        noise = float(run['rng'].normal(0.0, DAD_NOISE_AU / 2.5))
        return total + noise + DAD_DRIFT_AU_S * t

    def _finish(self, phase):
        run = self.run
        self.phase = phase
        if run is not None:
            thr = 10 * DAD_NOISE_AU
            run['peaks'] = detect_peaks(run['t'], run['y'], thr) if phase == 'succeeded' else []
        self.absorbance = 0.0

    def _chromatogram(self, max_points):
        run = self.run
        if run is None:
            return dict(run_id='', phase=self.phase, elapsed_s=0.0, time_s=[], absorbance_au=[], peaks=[], complete=False, wavelength_m=None,
                        template_source=LIBRARY_REL, evidence='no run', warnings=[])
        n = len(run['t'])
        step = max(1, math.ceil(n / max_points))
        return dict(run_id=run['run_id'], phase=self.phase, elapsed_s=run['elapsed'], time_s=list(run['t'][::step]), absorbance_au=list(run['y'][::step]),
                    peaks=copy.deepcopy(run['peaks']), complete=self.phase == 'succeeded', wavelength_m=run['wavelength'],
                    template_source=f'{LIBRARY_REL}#sha256={library_sha256()[:16]}',
                    evidence='retention: measured CC BY 4.0 SFC data (Waters UPC2) transferred with a derived migration model; '
                             'absorbance: NIST UV curves where available, else assumed; peak shape: assumed plate height',
                    warnings=list(run['warnings']) + ['retention transferred from another SFC system; dwell volume and column lot effects are modelled, not measured',
                                                      'peak responses use NIST UV curves where the template library holds one, otherwise an assumed molar '
                                                      'absorptivity; per-peak response evidence is evaluator-only',
                                                      'quantitation requires the caller\'s own external calibration'])

    def _template(self, sid):
        rec = templates().get(sid)
        if rec is None:
            raise ActionRejected('UNKNOWN_REFERENCE')
        ref = {c: {m: v['t_r_first_s'] for m, v in mods.items()} for c, mods in rec['retention'].items()}
        return dict(substance_id=sid, name=rec['name'], cas=rec['cas'], molecular_weight_g_mol=rec['molecular_weight_g_mol'], reference_retention_s=ref,
                    uv_curve=rec['uv_vis'] is not None, template_source=f'{LIBRARY_REL}#{sid}', evidence=rec['evidence'],
                    licence=rec['source']['licence'])

    def _quantify(self, a):
        x = np.array([p['concentration_mol_m3'] for p in a['calibration']], float)
        y = np.array([p['area_au_s'] for p in a['calibration']], float)
        if np.ptp(x) <= 0:
            raise ActionRejected('INVALID_CALIBRATION')
        slope, intercept = np.polyfit(x, y, 1)
        ss = float(np.sum((y - y.mean()) ** 2))
        r2 = 1.0 - float(np.sum((y - (slope * x + intercept)) ** 2)) / ss if ss > 0 else 0.0
        if slope <= 0:
            raise ActionRejected('INVALID_CALIBRATION')
        lo, hi = sorted(a['retention_window_s'])
        peaks = [p for p in (self.run['peaks'] if self.run and self.phase == 'succeeded' else []) if lo <= p['retention_time_s'] <= hi]
        if not peaks:
            return dict(slope_au_s_m3_mol=float(slope), intercept_au_s=float(intercept), r_squared=max(0.0, min(1.0, r2)), peak_area_au_s=None,
                        concentration_mol_m3=None, quality='no_peak_in_window_or_no_completed_run')
        p = max(peaks, key=lambda q: q['area_au_s'])
        conc = (p['area_au_s'] - intercept) / slope
        quality = 'ok' if x.min() <= conc <= x.max() and r2 >= 0.99 else 'extrapolated_or_poor_fit'
        return dict(slope_au_s_m3_mol=float(slope), intercept_au_s=float(intercept), r_squared=max(0.0, min(1.0, r2)), peak_area_au_s=p['area_au_s'],
                    concentration_mol_m3=float(conc), quality=quality)

    # ---- clock ------------------------------------------------------------------------------------------------
    def step(self, dt_s):
        if isinstance(dt_s, bool) or not isinstance(dt_s, (int, float)) or not math.isfinite(dt_s) or dt_s <= 0:
            raise ValueError('dt_s must be finite and positive')
        left = float(dt_s)
        while left > 1e-12:
            h = min(left, 0.1 if self._busy() else 1.0)
            self._advance(h)
            left -= h
        self.revision += 1
        return self.read('evaluator')

    def _advance(self, h):
        amb = self.ambient_k
        m = self.method
        # control module: chiller + booster
        target = CHILLER_TARGET_K if (self.power['control'] and self.supply['connected']) else amb
        self.chiller_k = target + (self.chiller_k - target) * math.exp(-h / CHILLER_TAU_S)
        # BPR heater and column oven
        bt = m['bpr_temperature_k'] if (m and self.power['control']) else amb
        self.bpr_k = bt + (self.bpr_k - bt) * math.exp(-h / BPR_HEAT_TAU_S)
        ct = m['column_temperature_k'] if (m and self.power['mct']) else amb
        if self.mech['mct_door'] > 0.05 and self.power['mct']:
            ct = amb + 0.5 * (ct - amb)                          # door open: oven cannot hold its set point (assumption)
        tau = COL_TAU_HEAT_S if ct > self.column_k else COL_TAU_COOL_S
        self.column_k = ct + (self.column_k - ct) * math.exp(-h / tau)
        # pump, pressures
        running = self.pump_enabled and m is not None and self._all_powered()
        if running and not self._co2_ready():
            self.fault = 'CO2_SUPPLY'
            self.pump_enabled = running = False
            if self._busy():
                self._finish('failed')
        col = self._column()
        f_target = m['flow_m3_s'] if running and col else 0.0
        self.flow = f_target + (self.flow - f_target) * math.exp(-h / FLOW_TAU_S)
        phi = self._phi_now()
        if running and col:
            bpr_target = m['bpr_pa']
            drop = column_pressure_drop(self.flow, phi, col) + EXTRA_COLUMN_R * (mixture_viscosity(phi) / 1e-4) * self.flow
            self.bpr_pa = bpr_target + (self.bpr_pa - bpr_target) * math.exp(-h / PRESSURE_TAU_S)
            p_target = self.bpr_pa + drop
            self.pump_pa = p_target + (self.pump_pa - p_target) * math.exp(-h / PRESSURE_TAU_S)
            self.booster_pa = max(0.0, 0.95 * self.pump_pa)
            if self.pump_pa > PUMP_MAX_PA:
                self.fault = 'OVERPRESSURE'
                self.pump_enabled = False
                if self._busy():
                    self._finish('failed')
            # consumption ledgers
            vol = self.flow * h
            bottle = self.bottles[m['modifier_channel']] or {'volume_m3': 0.0}
            mod = min(bottle['volume_m3'], vol * phi)
            bottle['volume_m3'] -= mod
            self.modifier_drawn_m3 += mod
            self.waste_m3 += mod
            co2 = min(self.supply['cylinder_co2_kg'], vol * (1 - phi) * CO2_PUMP_DENSITY_KG_M3)
            self.supply['cylinder_co2_kg'] -= co2
            self.vented_co2_kg += co2
            for b in self.bands:                                    # bands migrate whenever the pump delivers
                if b['t_r'] is None or b['done']:
                    continue
                b['flow_s'] += h * self.flow / b['flow_ref']
                if not b['eluted'] and b['flow_s'] >= b['t_r'] + 4 * b['sigma']:
                    b['eluted'] = True
                    self.eluted_mol += b['mol']
                if b['flow_s'] >= b['t_r'] + 8 * b['sigma']:
                    b['done'] = True
            if bottle['volume_m3'] <= 0.0 and (phi > 0 or self.bottles[m['modifier_channel']] is None):
                self.fault = 'MODIFIER_EMPTY'
                self.pump_enabled = False
                if self._busy():
                    self._finish('failed')
        else:
            for attr in ('bpr_pa', 'pump_pa', 'booster_pa'):
                setattr(self, attr, getattr(self, attr) * math.exp(-h / 30.0))
        # run state machine
        if self.phase == 'injecting':
            self.run['inject_left'] -= h
            if self.run['inject_left'] <= 1e-9:
                self._inject()
                self.phase = 'running'
        elif self.phase == 'running':
            run = self.run
            run['elapsed'] += h
            period = 1.0 / m['data_rate_hz']
            while run['next_sample'] <= run['elapsed'] + 1e-9 and run['next_sample'] <= m['run_time_s'] + 1e-9:
                y = self._signal(run['next_sample'])
                run['t'].append(round(run['next_sample'], 6))
                run['y'].append(y)
                self.absorbance = y
                run['next_sample'] += period
            if run['elapsed'] >= m['run_time_s'] - 1e-9:
                self._finish('succeeded')
        self.time_s += h


class Agilent1260infinitySession:
    """Principal-bound protocol session: describe / read / invoke / write / poll / cancel with visibility filtering."""

    def __init__(self, host, principal_id):
        self._host = host
        self._principal = principal_id

    @property
    def _role(self):
        return self._host._principals[self._principal]

    def _target(self, instance_id):
        if instance_id != self._host.instance_id:
            raise ActionRejected('UNKNOWN_INSTANCE')

    def describe(self, *, instance_id=None, asset_type_id=None):
        if (instance_id is None) == (asset_type_id is None):
            raise ActionRejected('INVALID_ARGUMENT')
        if instance_id is not None:
            self._target(instance_id)
        if asset_type_id is not None and asset_type_id != ASSET_TYPE_ID:
            raise ActionRejected('UNKNOWN_INSTANCE')
        meta = export_agilent_1260infinity_contract_metadata()
        agent = self._role == 'agent'
        return dict(protocol_version=PROTOCOL_VERSION, asset_type_id=ASSET_TYPE_ID, asset_version='1.0.0',
                    capabilities={k: v for k, v in meta['capabilities'].items() if v['visibility'] == 'agent' or not agent},
                    state_slots={k: v for k, v in meta['state_slots'].items() if v['visibility'] == 'agent' or not agent})

    def read(self, *, instance_id, state_ids=None):
        self._target(instance_id)
        h = self._host
        vals = h.read(self._role)
        ids = list(vals) if state_ids is None else state_ids
        if not isinstance(ids, list) or any(not isinstance(k, str) for k in ids):
            raise ActionRejected('INVALID_ARGUMENT')
        if any(k not in vals for k in ids):
            raise ActionRejected('ACCESS_DENIED')
        return dict(status='succeeded', instance_id=instance_id, state_revision=h.revision, clock={'domain': 'simulation', 'time_s': h.time_s},
                    observations={k: dict(value=copy.deepcopy(vals[k]), unit=SLOTS[k][1], quality='estimated' if SLOTS[k][2] == 'derived' else 'valid',
                                          sample_time_s=h.time_s, sample_window_s=None) for k in ids})

    def invoke(self, *, instance_id, capability_id, arguments, request_id):
        try:
            return self._invoke(instance_id=instance_id, capability_id=capability_id, arguments=arguments, request_id=request_id)
        except ActionRejected as exc:
            return dict(protocol_version=PROTOCOL_VERSION, instance_id=instance_id, request_id=request_id, operation_id=None, status='rejected',
                        state_revision=self._host.revision, clock={'domain': 'simulation', 'time_s': self._host.time_s}, result={}, observations={},
                        error=dict(code=str(exc), message=str(exc), retryable=False, side_effects='none'))

    def _invoke(self, *, instance_id, capability_id, arguments, request_id):
        self._target(instance_id)
        h = self._host
        if not isinstance(capability_id, str) or capability_id not in CAPS:
            raise ActionRejected('UNKNOWN_CAPABILITY')
        if self._role == 'agent' and CAPS[capability_id][5] != 'agent':
            raise ActionRejected('ACCESS_DENIED')
        if not isinstance(request_id, str) or not request_id or not isinstance(arguments, dict):
            raise ActionRejected('INVALID_ARGUMENT')
        key = (self._principal, instance_id, request_id)
        try:
            digest = json.dumps([capability_id, arguments], sort_keys=True, allow_nan=False)
        except (TypeError, ValueError):
            raise ActionRejected('INVALID_ARGUMENT')
        if key in h._requests:
            old, result = h._requests[key]
            if old != digest:
                raise ActionRejected('REQUEST_CONFLICT')
            return copy.deepcopy(result)
        result = h.invoke(capability_id, **arguments)
        op = result.get('operation_id') if capability_id == 'run.start' else None
        if op:
            h._owners[op] = self._principal
        response = dict(protocol_version=PROTOCOL_VERSION, instance_id=instance_id, request_id=request_id, operation_id=op,
                        status='accepted' if op else 'succeeded', state_revision=h.revision, clock={'domain': 'simulation', 'time_s': h.time_s},
                        result=result, observations={}, error=None)
        if CAPS[capability_id][4] not in ('query', 'analysis'):   # pure queries are recomputed on retry (no unbounded cache of large arrays)
            h._requests[key] = (digest, copy.deepcopy(response))
        return response

    def write(self, *, instance_id, state_id, value, request_id):
        self._target(instance_id)
        if state_id not in SLOTS or not SLOTS[state_id][5]:
            raise ActionRejected('ACCESS_DENIED')
        cap, arg = SLOTS[state_id][5]
        return self.invoke(instance_id=instance_id, capability_id=cap, arguments={arg: value}, request_id=request_id)

    def poll(self, operation_id):
        h = self._host
        if operation_id != h.operation_id or h._owners.get(operation_id) != self._principal:
            raise ActionRejected('ACCESS_DENIED')
        return dict(operation_id=operation_id, status=h.phase, result=h._chromatogram(2000))

    def cancel(self, operation_id, request_id):
        self.poll(operation_id)
        response = self.invoke(instance_id=self._host.instance_id, capability_id='run.abort', arguments={}, request_id=request_id)
        return dict(operation_id=operation_id, status=self._host.phase, result=response['result'])


# ------------------------------------------------------------------------------------------------------ contract metadata
PRECONDITIONS = {
    'pump.set': ('开泵：五模块通电、CO2就绪（供气40–70 bar且冷却器≤9 °C）、已配置方法、所选柱位已装柱、所用改性剂瓶有液',
                 ['power.enabled', 'co2.ready', 'method.configured', 'column.installed', 'solvent.b1'], 'all_powered and co2_ready and method and column and bottle>0'),
    'run.start': ('系统就绪（流量≥98%目标、背压±5 bar、柱温±1 K）、进样器门与该抽屉关闭、瓶内余量≥进样体积+10 µL、改性剂足够本次运行',
                  ['system.ready', 'sampler_door.angle_rad', 'drawer_1.position_m', 'run.phase'], 'ready and door==0 and drawer==0 and vial>=inj+dead and phase not busy'),
    'method.configure': ('运行中锁定方法；梯度表时间从0递增；柱温≥环境−10 K且≥4 °C；进样体积为0.1 µL整数倍；泵运行时不得切换到无液改性剂瓶或空柱位',
                         ['run.phase', 'pump.enabled', 'solvent.b1', 'column.installed'], 'phase not busy and (not pump or (bottle>0 and column installed))'),
    'column.install': ('柱温箱门打开（≥0.5 rad）、泵停且不在运行', ['mct_door.angle_rad', 'pump.enabled', 'run.phase'], 'mct_door>=0.5 and not pump and not busy'),
    'sample.register_vial': ('目标抽屉拉出≥0.15 m、瓶位空、物质在模板库', ['drawer_1.position_m', 'sample.vial_count'], 'drawer>=0.15 and free and sid in library'),
    'sample.remove_vial': ('目标抽屉拉出≥0.15 m且瓶位有瓶', ['drawer_1.position_m'], 'drawer>=0.15 and occupied'),
    'supply.configure': ('泵停时才能更换气瓶；连接时供气40–70 bar', ['pump.enabled'], 'not pump and 40e5<=supply<=70e5'),
    'solvent.configure': ('泵停时才能换瓶', ['pump.enabled'], 'not pump'),
    'sampler_door.set': ('进样/采集中不得打开进样器门', ['run.phase'], 'opening -> phase not busy'),
    'mct_door.set': ('进样/采集中不得打开柱温箱门（保留在进样时按当时条件计算）', ['run.phase'], 'opening -> phase not busy'),
}
for _i in range(1, 5):
    PRECONDITIONS[f'drawer_{_i}.set'] = ('进样/采集中不得拉出抽屉', ['run.phase'], 'opening -> phase not busy')


def export_agilent_1260infinity_contract_metadata():
    caps, slots = {}, {}
    for key, (schema, unit, origin, vis, comps, write, meaning) in SLOTS.items():
        slots[key] = dict(component_ids=comps, value_schema=copy.deepcopy(schema), unit=unit, reference_conditions=REFERENCE_ZH.get(key),
                          meaning_zh=meaning or None, origin=origin, visibility=vis, access='read_write' if write else 'read_only',
                          read_binding=dict(backend='host', artifact_id='runtime', accessor=f'Agilent1260infinitySession.read(state_ids=[{key!r}])'),
                          write_via=dict(capability_id=write[0], argument=write[1], fixed_arguments={}) if write else None,
                          sampling=dict(mode='instant', time_domain='simulation', window_description=None),
                          source_ids=['manufacturer_specs', 'simulation_assumption'])
    for key, (inp, out, comps, meaning, kind, vis, example, effects) in CAPS.items():
        unsupported = key in UNSUPPORTED
        is_async = key == 'run.start'
        pre = []
        if key in PRECONDITIONS:
            d, states, check = PRECONDITIONS[key]
            pre = [dict(description_zh=d, state_ids=states, enforced_by='runtime', check=check)]
        caps[key] = dict(
            function_zh=meaning, kind=kind, visibility=vis, component_ids=comps, availability='unsupported' if unsupported else 'implemented',
            input_schema=copy.deepcopy(inp), output_schema=copy.deepcopy(out),
            implementation=dict(process='absent' if unsupported else 'implemented', scene='absent', robot='absent', hardware='absent',
                                host='absent' if unsupported else 'implemented'),
            binding=None if unsupported else dict(backend='host', artifact_id='runtime', entrypoint='asset_runtime.agilent_1260infinity.Agilent1260infinitySession.invoke',
                                                  invocation=f'session.invoke(instance_id="sfc_01", capability_id={key!r}, arguments={example!r}, request_id="unique")'),
            preconditions=pre, state_effects=[dict(state_id=s, timing='on_completion' if is_async else 'immediate', description_zh=meaning) for s in effects],
            observes=[], model_effects=dict(mode='none', description_zh='过程层能力；几何联动由宿主另行绑定并在Matterix场景中验证。', binding_ids=[]),
            execution=dict(mode='asynchronous' if is_async else 'synchronous', time_domain='simulation',
                           completion_criterion='run.phase=succeeded（运行时间结束）；取消/失败保留已采集数据与物料账本' if is_async else
                           ('返回只读结果，不推进时钟' if kind in ('query', 'analysis') else '设定写入；物理量只随step演化'),
                           completion_state_ids=['run.phase'] if is_async else list(effects), timeout_s=None,
                           cancellation='supported' if is_async else 'unsupported', retry='same_request_id',
                           resources=['target_instance', 'principal_request_cache'],
                           partial_failure_zh='拒绝时状态不变；取消/断电/故障不回滚已注入样品、已消耗改性剂与CO2。请求去重只在当前进程内存有效。'),
            errors=[dict(code=e, meaning_zh=e, side_effects='none') for e in
                    ['UNKNOWN_INSTANCE', 'UNKNOWN_CAPABILITY', 'ACCESS_DENIED', 'INVALID_ARGUMENT', 'PRECONDITION_FAILED', 'BUSY', 'REQUEST_CONFLICT',
                     'UNKNOWN_REFERENCE', 'INVALID_CALIBRATION', 'UNSUPPORTED']],
            example_arguments=copy.deepcopy(example), verification=[],
            limitations=['仿真过程模型，无真实硬件连接；进程内会话过滤不能替代文件与进程级部署隔离。'] if not unsupported else ['未实现；调用返回UNSUPPORTED。'],
            source_ids=['manufacturer_specs', 'sfc_retention_data', 'simulation_assumption'])
    p = lambda v, u, z, ev='assumption', src=('simulation_assumption',): dict(value=v, unit=u, meaning_zh=z, evidence=ev, source_ids=list(src), uncertainty=None)  # noqa: E731
    mechanisms = {
        'retention': dict(
            component_ids=['column_1', 'column_2', 'column_3', 'column_4', 'column_valve', 'mct_housing'],
            state_ids=['column.temperature_k', 'mobile_phase.co2_density_kg_m3', 'run.phase', 'truth.column_mol', 'truth.eluted_mol'],
            meaning_zh='梯度SFC谱带迁移：模板库实测保留时间反解的log-log保留截距，按配置梯度、流量、延迟体积、柱温与背压（CO2密度）积分出峰时间',
            implementation='lumped',
            equations=['log10 k = a - m*log10(max(phi, phi_min)) - c_rho*(rho/rho_ref - 1)/ln(10)',
                       'dz/dt = 1/(t0*(1+k(phi(t - t_D - z*t0))))，z=1时出峰',
                       't0 = eps_T*pi*r^2*L/F；t_D = V_delay(BPR)/F，V_delay 600–900 µL',
                       'sigma_t^2 = (t0*(1+k_e))^2/N + ((V_cell/F)^2 + (V_inj/F)^2)/12，N = L/(h*dp)'],
            parameters={'loglog_slope_m': p(LOGLOG_SLOPE_M, '1', 'log k–log φ斜率，所有物质同一值'),
                        'total_porosity': p(TOTAL_POROSITY, '1', '柱总孔隙率（死时间）'),
                        'density_coefficient': p(DENSITY_COEFF, '1', 'ln k对CO2相对密度的系数'),
                        'reference_dwell_s': p(REF_DWELL_S, 's', '源数据UPC2系统梯度延迟（未公开，假设）'),
                        'reduced_plate_height': p(PLATE_HEIGHT_DP, '1', '折合塔板高度h'),
                        'phi_min': p(PHI_MIN, '1', '保留律中改性剂分数下限'),
                        'delay_volume_range': p([DELAY_MIN_M3, DELAY_MAX_M3], 'm^3', 'G4782A延迟体积600–900 µL（随背压，线性映射为假设）', 'documented', ['manufacturer_specs']),
                        'reference_method_flow': p(REF_FLOW_M3_S, 'm^3/s', '源数据方法流量1.5 mL/min', 'documented', ['sfc_retention_data'])},
            source_ids=['sfc_retention_data', 'manufacturer_specs', 'simulation_assumption'],
            limitations=['m、ε_T、密度系数与UPC2延迟为假设；参考方法下保留时间复现实测（残差<0.5 s），其它方法为外推。',
                         '保留时间与峰宽在进样时按当时流量/梯度/柱温/背压一次算定；运行中条件变化不改变已进样谱带（运行中门与方法均锁定）。'
                         '运行结束后泵继续输液时谱带继续迁移（按流量折算），晚出峰进入废液，或在下一次运行中作为残留峰出现。',
                         '源数据中未出峰/未检出、或晚于文献运行终点（2条，未拟合）的组合，按“留在柱上”处理，不代表真实色谱行为已知。',
                         '未建模柱老化（库中有12个月漂移数据但未驱动运行层）、对映体选择性、过载与峰拖尾。']),
        'hydraulics': dict(
            component_ids=['pump_head_a', 'pump_head_b', 'booster_unit', 'chiller_unit', 'bpr_unit', 'column_1'],
            state_ids=['pump.pressure_pa', 'bpr.pressure_pa', 'pump.flow_m3_s', 'chiller.temperature_k', 'booster.pressure_pa'],
            meaning_zh='泵压=背压+Kozeny-Carman柱压降+柱外压降；600 bar跳泵；CO2经冷却再液化与增压后供泵A，改性剂由泵B高压混合',
            implementation='lumped',
            equations=['dP_col = 180*eta_mix*u_s*L*(1-e)^2/(e^3*dp^2)', 'eta_mix = exp(phi*ln eta_MeOH + (1-phi)*ln eta_CO2)',
                       'P_pump -> P_BPR + dP_col + R_extra*(eta/1e-4)*F（一阶，tau=3 s）', 'P_pump > 600 bar -> OVERPRESSURE 停泵'],
            parameters={'pump_max_pa': p(PUMP_MAX_PA, 'Pa', '系统/泵最高压力600 bar', 'documented', ['manufacturer_specs']),
                        'bpr_range_pa': p([BPR_MIN_PA, BPR_MAX_PA], 'Pa', 'BPR可设100–400 bar', 'documented', ['manufacturer_specs']),
                        'supply_range_pa': p([SUPPLY_MIN_PA, SUPPLY_MAX_PA], 'Pa', 'CO2供气40–70 bar', 'documented', ['manufacturer_specs']),
                        'eta_co2_pa_s': p(ETA_CO2_PA_S, 'Pa*s', 'CO2黏度（工程值）'), 'eta_methanol_pa_s': p(ETA_MEOH_PA_S, 'Pa*s', '甲醇25 °C黏度（常用手册值，本资产未列来源，按假设登记）'),
                        'bed_porosity': p(BED_POROSITY, '1', '床层孔隙率'), 'extra_column_resistance': p(EXTRA_COLUMN_R, 'Pa*s/m^3', '柱外阻力（每1e-4 Pa s）'),
                        'pressure_tau_s': p(PRESSURE_TAU_S, 's', '压力一阶时间常数'), 'chiller_target_k': p(CHILLER_TARGET_K, 'K', '冷却器目标（厂家范围−20…9 °C内取5 °C）')},
            source_ids=['manufacturer_specs', 'simulation_assumption'],
            limitations=['流量按泵头条件体积计，未做压缩性补偿；改性剂对CO2密度的影响忽略。']),
        'thermal': dict(
            component_ids=['mct_housing', 'mct_door', 'bpr_unit', 'chiller_unit'], state_ids=['column.temperature_k', 'bpr.temperature_k', 'chiller.temperature_k'],
            meaning_zh='柱温箱一阶升降温，时间常数由厂家速率换算；门打开时只能维持目标与环境差的一半（假设）', implementation='lumped',
            equations=['T -> T_target，升温tau=300 s/ln(30)，降温tau=600 s/ln(40)'],
            parameters={'tau_heat_s': p(COL_TAU_HEAT_S, 's', '由厂家“环境→40 °C约5 min”换算（一阶到0.5 K以内）', 'documented', ['manufacturer_specs']),
                        'tau_cool_s': p(COL_TAU_COOL_S, 's', '由厂家“40→20 °C约10 min”换算（一阶到0.5 K以内）', 'documented', ['manufacturer_specs'])},
            source_ids=['manufacturer_specs'], limitations=['单节点温区；两个独立温区按同一温度处理。']),
        'detection': dict(
            component_ids=['flow_cell', 'dad_housing'], state_ids=['detector.absorbance_au', 'detector.wavelength_m'],
            meaning_zh='DAD吸光度=ε(λ)·10 mm·c(t)，高斯谱带；噪声与漂移取厂家规格', implementation='lumped',
            equations=['c(t) = n/(F*sigma*sqrt(2pi))*exp(-(t-tR)^2/(2 sigma^2))', 'A = eps*l*c + N(0, 0.7e-5/2.5) + drift*t'],
            parameters={'flow_cell_path_m': p(FLOW_CELL_PATH_M, 'm', 'SFC流通池光程10 mm', 'documented', ['manufacturer_specs']),
                        'noise_au': p(DAD_NOISE_AU, 'AU', '噪声<±0.7e-5 AU', 'documented', ['manufacturer_specs']),
                        'assumed_epsilon_m2_mol': p(ASSUMED_EPSILON_M2_MOL, 'm^2/mol', '无NIST紫外曲线时的假设摩尔吸光系数')},
            source_ids=['manufacturer_specs', 'nist_uv', 'simulation_assumption'],
            limitations=['多数物质无NIST紫外曲线，响应为假设（结果warnings中标出）；无检测器饱和与带宽效应。']),
    }
    if _ann is not None:
        _ann.annotate_export('agilent_1260infinity', caps, slots, mechanisms, inputs={'method.configure': (METHOD, METHOD_EXAMPLE), 'supply.configure': (SUPPLY, SUPPLY_EXAMPLE)})
    return dict(asset_type_id=ASSET_TYPE_ID, catalog_id=CATALOG_ID, capabilities=caps, state_slots=slots, mechanisms=mechanisms)