chronaxis 0.1.0.dev0__py3-none-any.whl

chronaxis/planning/intervals.py

@@ -0,0 +1,242 @@
+"""声明计算所用的间隔及可选诊断，不读取报文或建立额外时间轴。
+
+输入是配置中的intervals/diagnostics和已编译计划。输出为冻结选择，
+记录每个消费者采用actual、fixed或dbc，以及明确的驱动信号。
+DBC周期只在运行初始化读取；这里检查来源种类和完整报文定位。
+当前配置3支持这些声明；执行是否就绪由公共能力报告判断。
+"""
+
+from dataclasses import dataclass, replace
+
+from ..core.validation import require_identifier
+from ..sources.can_spec import can_field_from_key
+from .checks import PlanValidationError, duration_at, model_at, object_at
+from .sequences import sequence_dependencies
+
+
+@dataclass(frozen=True)
+class IntervalChoice:
+    """选择一次计时依据；step_ns仅用于fixed，driver为原信号别名。
+
+    actual沿既有真实时间推进，不额外指定驱动。fixed/dbc的驱动可以在
+    配置解析时按唯一候选补齐；不在对象中保存逐帧时间或DBC实例。
+    """
+
+    mode: str = 'actual'  # 实际差、固定值或运行时读取的DBC周期。
+    step_ns: int | None = None  # 仅fixed使用的正纳秒数；DBC在这里不提前填值。
+    driver: str | None = None  # 推进累计的原信号别名；不存另一列时间。
+
+    def __post_init__(self):
+        """拒绝矛盾字段、布尔间隔及溢出；无I/O或隐式数值转换。
+
+        参数: 无，读取mode、step_ns和driver。返回: None。异常: TypeError/ValueError为模式、纳秒范围或信号名错误。副作用: 无。
+        """
+        if type(self.mode) is not str or self.mode not in ('actual', 'fixed', 'dbc'):
+            raise ValueError('interval.mode需要actual、fixed或dbc')
+        if self.mode == 'fixed':
+            if type(self.step_ns) is not int or not 0 < self.step_ns <= (1 << 63) - 1:
+                raise ValueError('fixed间隔需要int64范围内正整数纳秒')
+        elif self.step_ns is not None:
+            raise ValueError('只有fixed接受间隔数值')
+        if self.driver is not None:
+            require_identifier(self.driver, 'interval.driver')
+            if self.mode == 'actual':
+                raise ValueError('actual沿既有更新时间推进，不接受driver')
+
+
+@dataclass(frozen=True)
+class IntervalPlan:
+    """保存任务默认、显式覆盖及已解析的消费者选择。
+
+    三组数据均为有限配置，不是样本历史。resolved按声明顺序列出实际
+    消费者；legacy_sum自带period，不进入普通间隔解析。
+    """
+
+    default: IntervalChoice = IntervalChoice()  # 任务级缺省选择。
+    overrides: tuple[tuple[str, IntervalChoice], ...] = ()  # 按稳定节点ID的显式选择。
+    resolved: tuple[tuple[str, IntervalChoice], ...] = ()  # 当前消费者的唯一有效选择。
+
+    def __post_init__(self):
+        """检查冻结容器、唯一节点与选择类型，防止typed替换引入可变对象。
+
+        参数: 无，读取default、overrides及resolved。返回: None。异常: TypeError/ValueError为非冻结选择、节点重复或非法名称。副作用: 无。
+        """
+        if type(self.default) is not IntervalChoice:
+            raise TypeError('intervals.default需要IntervalChoice')
+        for label, entries in (('overrides', self.overrides), ('resolved', self.resolved)):
+            if type(entries) is not tuple:
+                raise TypeError('intervals.' + label + '需要tuple')
+            names = set()
+            for entry in entries:
+                if (type(entry) is not tuple or len(entry) != 2
+                        or type(entry[1]) is not IntervalChoice):
+                    raise TypeError('interval选择需要(node_id, IntervalChoice)')
+                require_identifier(entry[0], 'interval.node_id')
+                if entry[0] in names:
+                    raise ValueError('interval节点重复：' + entry[0])
+                names.add(entry[0])
+
+
+@dataclass(frozen=True)
+class DiagnosticPlan:
+    """分别声明详细追溯、完整性诊断及现场留存，全部默认关闭。
+
+    这些开关不取消必要输入检查，不代替outputs.contributions，彼此不捆绑。
+    此对象不分配暂存或执行核验；实际资源能力接线前必须拒绝执行。
+    """
+
+    trace: bool = False  # 请求详细追溯，独立于贡献明细。
+    integrity: bool = False  # 请求额外完整性诊断，不代替必要输入检查。
+    retain_work: bool = False  # 请求保留本次自有现场，不授权保留无关用户数据。
+
+    def __post_init__(self):
+        """仅接受原生bool；不把0/1或文本解释成开关。
+
+        参数: 无，读取三个独立开关。返回: None。异常: TypeError为任一值不是原生bool。副作用: 无。
+        """
+        if any(type(value) is not bool for value in (self.trace, self.integrity, self.retain_work)):
+            raise TypeError('diagnostics各项需要bool')
+
+
+def parse_diagnostics(value) -> DiagnosticPlan:
+    """解析可选诊断对象；未知键或非bool报配置错误，不打开文件。
+
+    参数: value(dict)为可省略的三个bool开关。返回: DiagnosticPlan，省略项为False。异常: PlanValidationError为未知键或非bool。副作用: 无。
+    """
+    raw = object_at(value, '$.diagnostics', (), ('trace', 'integrity', 'retain_work'))
+    return model_at(DiagnosticPlan, '$.diagnostics', **raw)
+
+
+def _choice(value, path) -> IntervalChoice:
+    """将显式单位数值解析为纳秒；不查询DBC或猜测缺失的fixed数值。
+
+    参数: value(dict)为mode及可选带单位value/driver；path(str)定位错误。返回: IntervalChoice，固定间隔以整数ns保存。异常: PlanValidationError为缺项、矛盾、单位或类型错误。副作用: 无。
+    """
+    raw = object_at(value, path, ('mode',), ('value', 'driver'))
+    if 'driver' in raw and type(raw['driver']) is not str:
+        raise PlanValidationError(path + '.driver', '显式driver需要原信号名称，不能为null或其他类型')
+    if (raw['mode'] == 'fixed') != ('value' in raw):
+        raise PlanValidationError(path + '.value', 'fixed必须给value，其他模式不接受value')
+    step = duration_at(raw['value'], path + '.value', positive=True) if 'value' in raw else None
+    return model_at(IntervalChoice, path, raw['mode'], step, raw.get('driver'))
+
+
+def _consumers(plan):
+    """列出规则、配对、窗口和需时长指标的原信号依赖，保持计划顺序。
+
+    返回(node_id, aliases)元组。样本min/max/select与旧逐消息求和没有
+    普通dt消费者；对它们单独配置覆盖属于无效需求，不能静默忽略。
+
+    参数: plan(AnalysisPlan)为已校验引用的计划。返回: tuple，每项为节点ID及原信号别名tuple，无消费者为空。异常: 错误typed引用的KeyError/StopIteration由外层验证报告捕获。副作用: 无。
+    """
+    rules = {rule.rule_id: rule for rule in plan.rules}
+    # 纯上升/下降沿不使用帧间时长，不能因任务默认fixed而强迫它选择驱动。
+    entries = [(rule.rule_id, rule.dependencies) for rule in plan.rules
+               if rule.rule_type not in ('rising_edge', 'falling_edge')]
+    entries.extend((item.sequence_id, sequence_dependencies(item, plan.rules, plan.bindings))
+                   for item in plan.sequences)
+    entries.extend((item.window_id, rules[item.event].dependencies) for item in plan.windows)
+    for item in plan.calculations:
+        if item.operation not in ('integral', 'duration', 'time_weighted_mean', 'min_time', 'max_time'):
+            continue
+        aliases = {alias for expression in (item.signal, item.condition)
+                   if expression is not None for alias in expression.dependencies}
+        # event/segment的区间也由父规则决定，不能漏掉其唯一驱动或多源歧义。
+        if item.scope != 'session':
+            scope, target = item.scope.split(':', 1)
+            event = target if scope == 'event' else next(window.event for window in plan.windows if window.window_id == target)
+            aliases.update(rules[event].dependencies)
+        entries.append((item.calculation_id, tuple(sorted(aliases))))
+    return tuple(entries)
+
+
+def _driver_key(plan, alias):
+    """按真实报文定位合并同帧信号候选；已解析信号各自独立。
+
+    返回来源与报文身份或来源与字段；只读已校验声明，不加载DBC。
+
+    参数: plan为当前计划，alias为原信号别名。返回: tuple物理更新身份。异常: 无效别名/报文定位的ValueError或缺来源StopIteration。副作用: 无。
+    """
+    definition = plan.bindings.resolve(alias)
+    source = next(item for item in plan.sources if item.name == definition.source)
+    if source.source_type in ('can_blf', 'can_asc', 'asc_or_blf', 'raw_can_csv'):
+        field = can_field_from_key(definition.field)
+        return (source.name, field.channel, field.frame_id, field.is_extended, field.is_fd)
+    return (source.name, definition.field)
+
+
+def _resolve(plan, choice, aliases, path):
+    """选定唯一驱动，检查DBC适用性；多候选/常量无驱动时要求明确填写。
+
+    参数: plan为当前计划；choice为IntervalChoice；aliases为原依赖tuple；path为错误位置。返回: 补齐driver的IntervalChoice，actual原样返回。异常: PlanValidationError为歧义、未知驱动、时基不符或DBC不适用。副作用: 无。
+    """
+    if choice.mode == 'actual':
+        return choice
+    driver = choice.driver
+    if driver is None:
+        candidates = {}
+        for alias in aliases:
+            candidates.setdefault(_driver_key(plan, alias), alias)
+        if len(candidates) != 1:
+            raise PlanValidationError(path + '.driver', '需要显式指定驱动信号；候选数量=' + str(len(candidates)))
+        driver = next(iter(candidates.values()))
+    # 显式驱动允许作为独立时钟信号，但必须是当前原信号，而非派生名称。
+    declared = {item.definition.name: item.definition for item in plan.signals}
+    if driver not in declared:
+        raise PlanValidationError(path + '.driver', 'driver必须是当前已声明的原信号')
+    source = next(item for item in plan.sources if item.name == declared[driver].source)
+    # 独立时钟驱动也必须与表达式来源可比较，不能把不同相对起点直接计成同一段。
+    model_at(plan.bindings.require_synchronized, path + '.driver',
+             tuple(dict.fromkeys((*aliases, driver))))
+    if choice.mode == 'dbc' and source.source_type not in ('can_blf', 'can_asc', 'asc_or_blf', 'raw_can_csv'):
+        raise PlanValidationError(path + '.mode', 'DBC周期仅适用于原始报文，已解析数据不可选择')
+    return replace(choice, driver=driver)
+
+
+def resolve_intervals(plan, default, overrides) -> IntervalPlan:
+    """把有限声明解析为消费者选择；typed校验与JSON解析共用本函数。
+
+    输入是已构造的计划和冻结选择；返回新的IntervalPlan。未知节点、
+    无用覆盖或不适用DBC报ValueError/PlanValidationError；无数据读取。
+
+    参数: plan为当前计划；default为IntervalChoice；overrides为(node_id, choice)冻结tuple。返回: IntervalPlan，resolved保持消费者声明顺序。异常: TypeError/ValueError及PlanValidationError为非法声明或不明确驱动。副作用: 无。
+    """
+    declared = IntervalPlan(default, overrides)
+    consumers = _consumers(plan)
+    names = {name for name, _ in consumers}
+    unknown = set(dict(overrides)) - names
+    if unknown:
+        raise PlanValidationError('$.intervals.overrides', '不是间隔消费者：' + ', '.join(sorted(unknown)))
+    if not consumers and default != IntervalChoice():
+        raise PlanValidationError('$.intervals.default', '本任务没有普通间隔消费者；legacy_sum保留表达式period')
+    lookup = dict(declared.overrides)
+    resolved = tuple((name, _resolve(plan, lookup.get(name, default), aliases,
+                                    '$.intervals.overrides.' + name)) for name, aliases in consumers)
+    return IntervalPlan(default, overrides, resolved)
+
+
+def parse_intervals(value, plan) -> IntervalPlan:
+    """解析任务默认和节点覆盖；显式null与未知字段均拒绝，缺省使用actual。
+
+    参数: value(dict)为default及overrides；plan为已解析消费者的计划。返回: IntervalPlan。异常: PlanValidationError为结构、取值或引用错误。副作用: 无。
+    """
+    raw = object_at(value, '$.intervals', (), ('default', 'overrides'))
+    default = _choice(raw.get('default', {'mode': 'actual'}), '$.intervals.default')
+    overrides = raw.get('overrides', {})
+    if type(overrides) is not dict:
+        raise PlanValidationError('$.intervals.overrides', '需要以节点ID为键的对象')
+    entries = tuple((name, _choice(choice, '$.intervals.overrides.' + name))
+                    for name, choice in overrides.items())
+    return model_at(resolve_intervals, '$.intervals', plan, default, entries)
+
+
+def require_interval_declarations(plan):
+    """核对类型化计划中的间隔和诊断声明未被替换为不一致的解析结果。
+
+    参数: plan为待验证的AnalysisPlan。返回: None。异常: TypeError/ValueError为版本、新类型或解析结果不一致；引用错误由公共报告收集。副作用: 无，不重编译表达式。
+    """
+    if type(plan.intervals) is not IntervalPlan or type(plan.diagnostics) is not DiagnosticPlan:
+        raise TypeError('当前计划需要IntervalPlan与DiagnosticPlan')
+    expected = resolve_intervals(plan, plan.intervals.default, plan.intervals.overrides)
+    if expected != plan.intervals:
+        raise ValueError('intervals.resolved与当前消费者或驱动不一致')

chronaxis/planning/legacy_execution.py

@@ -0,0 +1,38 @@
+"""在读取前校验逐消息计划的时间域与CAN读取策略；不选择历史兼容路径。"""
+
+from ..core.models import Interval
+from ..sources.can_spec import LegacyCANSpec
+from .checks import PlanValidationError
+
+
+def require_can_decode_scope(plan) -> None:
+    """在资源创建前检查请求时间域及CAN策略，不自动更换执行方式。
+
+    参数: plan为完整AnalysisPlan；直接构造或replace的typed声明同样接受检查。
+    返回: None；requested按统一需求接普通、消息和原帧消费者，all保留显式完整诊断。
+    异常: PlanValidationError定位时间域、陈旧绑定或来源策略错误；其他属性错误原样传播。
+    边界: 不读文件、DBC或信号值；纯参数指标和空signals仍可请求其指标报文。
+    """
+    # typed replace不重新绑定表达式；不能借改dataset静默增删原声明的时间筛选。
+    domain = plan.dataset.domain
+    if domain is not None and not isinstance(domain, Interval):
+        raise PlanValidationError('$.dataset.domain', '请求时间域需要Interval或整文件None声明')
+    if type(plan.dataset.domain_explicit) is not bool:
+        raise PlanValidationError('$.dataset.domain', 'domain_explicit需要原生bool')
+    if plan.dataset.domain_explicit != (domain is not None):
+        raise PlanValidationError('$.dataset.domain', 'domain_explicit必须与实际domain声明一致')
+    if plan.bindings.domain != domain:
+        raise PlanValidationError('$.dataset.domain', '请求时间域与原声明绑定不一致，需重新构建计划')
+    # 先核有限静态选项；需要真实来源类型的其他约束仍由原计划校验承担。
+    for index, source in enumerate(plan.sources):
+        if source.source_type != 'can_blf' or not isinstance(source.config, LegacyCANSpec):
+            continue
+        scope = source.config.decode_scope
+        path = f'$.sources[{index}].decode_scope'
+        if type(scope) is not str or scope not in ('all', 'requested'):
+            raise PlanValidationError(path, '需要all或requested')
+        # 同一前置门禁也拒绝绕过dataclass构造器的typed检查范围替换。
+        check = source.config.input_check
+        if type(check) is not str or check not in ('auto', 'full'):
+            raise PlanValidationError(f'$.sources[{index}].input_check', '需要auto或full')
+        # 实际字段、普通样本、消息触发和原帧导出分别规划；不得因混合任务静默退回all。

chronaxis/planning/message_calculations.py

@@ -0,0 +1,171 @@
+"""静态解析当前消息legacy_sum声明，保持解码profile和新计算policy分开。
+
+输入为message_calculations原生JSON数组、当前来源/绑定和计划ID集合；输出冻结的
+MessageCalculationPlan tuple。frame_id必填，channel默认采用来源通道，帧类型可省略；参数按FLOAT64处理，表达式
+只访问本来源、本消息的完整CAN定位，不沿用全局派生、上一条值或普通TTL。
+当前模式明确拒绝cache_policy，旧完整触发/缓存未接线不能靠同名字段冒充。
+可选disjunction另声明方向别名和正负桶；方向可不在expr中，仍须有同一原消息
+的完整定位。它选择本条原解码值，不改表达式、信号转换或旧读写调用。
+
+require_message_calculation只检查已有typed计划与当前来源/声明的关系，供解析和
+validate/explain共用；它不重新解析AST或raw_config。所有操作只处理有限配置，
+不open/stat/resolve，不加载DBC、旧reader或执行流，不读取任何分析输入。
+"""
+
+# 只导入冻结模型、受限表达式及静态字段校验，不加载来源执行组件。
+from ..core.declarations import DeclarationBindings
+from ..core.message_binding import ExpressionParameter, MessageDeclarations
+from ..legacy.records import PROFILE_ID
+from ..legacy.disjunction import LegacyDisjunction
+from ..core.types import SignalDType
+from ..sources.can_spec import LegacyCANSpec, can_field_from_key
+from ..sources.text_can_spec import CANTextSpec
+from .checks import PlanValidationError, array_at, choice_at, model_at, object_at, text_at
+from .models import LegacyMessageSelector, MessageCalculationPlan
+from .nodes import expression_at, register_id
+
+
+def require_message_calculation(calculation, sources, bindings: DeclarationBindings) -> None:
+    """核已有typed逐消息指标与当前计划一致，不借旧配置覆盖typed替换。
+
+    参数: calculation为MessageCalculationPlan；sources为当前SourcePlan tuple；bindings
+        为当前DeclarationBindings。
+        返回: None，来源、帧定位和原声明均一致。
+    异常: TypeError为指标/绑定模型错误；ValueError为来源能力、声明或定位冲突。
+    边界: 不重编译AST，不读DBC；字段存在性和单位实况仍由同次READY另行验证。
+    """
+    if type(calculation) is not MessageCalculationPlan or not isinstance(bindings, DeclarationBindings):
+        raise TypeError('逐消息指标需要MessageCalculationPlan及当前DeclarationBindings')
+    matching = tuple(source for source in sources if source.name == calculation.source)
+    if len(matching) != 1:
+        raise ValueError('逐消息指标必须引用当前唯一来源')
+    source = matching[0]
+    # 计算只取当条解码值；格式仍由各自真实读取profile标识，不能冒充旧解码器。
+    if source.source_type == 'can_blf' and isinstance(source.config, LegacyCANSpec):
+        if (source.config.legacy_profile != PROFILE_ID or source.config.unit != 's'
+                or source.time_unit != 's' or source.timezone_text is not None):
+            raise ValueError('BLF逐消息来源需保原profile和秒时间声明')
+        profile = PROFILE_ID
+    elif (source.source_type in ('can_asc', 'asc_or_blf', 'raw_can_csv')) and (isinstance(source.config, CANTextSpec)):
+        if source.source_type != source.config.source_type:
+            raise ValueError('文本报文来源种类与解析声明不同')
+        profile = 'can-text-v1'
+    else:
+        raise ValueError('逐消息计算需要BLF、ASC或原始报文CSV来源')
+    if source.config.name != source.name or calculation.profile != profile:
+        raise ValueError('逐消息指标profile和名称必须等于实际来源')
+    declared = next((item for item in bindings.sources if item.name == calculation.source), None)
+    if (declared is None or declared.input_identity != source.input_identity
+            or declared.timebase != source.config.timebase or declared.offset_ns != source.config.offset_ns):
+        raise ValueError('逐消息来源定位、原时基或offset与当前完整声明不符')
+    if calculation.update_message.channel != source.config.channel:
+        raise ValueError('逐消息选择器channel与来源声明不一致')
+    declaration = calculation.expr.bindings
+    if (declaration.declarations.identity != bindings.identity or declaration.source != calculation.source
+            or declaration.parameters != calculation.parameters or declaration.derived_names
+            or declaration.message_policy != calculation.message_policy):
+        raise ValueError('逐消息表达式必须属于当前完整原声明、来源和参数')
+    # 依赖必须是编译树的真实别名，不能由外层投影遗漏或偷偷增加其他消息。
+    if type(calculation.expr.dependencies) is not tuple or calculation.expr.dependencies != calculation.expr.root.aliases:
+        raise ValueError('逐消息表达式依赖与静态树不一致')
+    selector = calculation.update_message
+    required_flags = [selector.is_extended, selector.is_fd]
+    # 方向可以独立于公式，但仍必须来自本条同一原消息，不能借缓存跨消息取值。
+    dependencies = calculation.expr.dependencies
+    if calculation.disjunction is not None:
+        direction = bindings.resolve(calculation.disjunction.signal)
+        if direction.dtype not in (SignalDType.INT64, SignalDType.UINT64, SignalDType.FLOAT64, SignalDType.BOOL):
+            raise ValueError('disjunction方向仅接受数值或bool声明，不接受enum')
+        dependencies = tuple(dict.fromkeys((*dependencies, calculation.disjunction.signal)))
+    for alias in dependencies:
+        definition = bindings.resolve(alias)
+        if definition.source != calculation.source or declaration.resolve(alias) is not definition:
+            raise ValueError('逐消息依赖须保当前来源的同一原SignalDefinition')
+        field = can_field_from_key(definition.field)
+        # 静态声明允许省略类型；明确给出的约束不能冲突，实际唯一性由读取阶段检查。
+        if ((field.channel, field.frame_id) != (selector.channel, selector.frame_id)
+                or any(left is not None and right is not None and left != right for left, right in
+                       ((field.is_extended, selector.is_extended), (field.is_fd, selector.is_fd)))):
+            raise ValueError('逐消息依赖的帧定位与update_message不一致')
+        # 未限制的选择器不能掩盖两个依赖相互矛盾的明确帧类型。
+        for index, value in enumerate((field.is_extended, field.is_fd)):
+            if value is not None:
+                if required_flags[index] is not None and required_flags[index] != value:
+                    raise ValueError('逐消息表达式的依赖必须属于同一实际帧类型')
+                required_flags[index] = value
+
+
+def parse_message_calculations(value, sources, bindings, ids) -> tuple[MessageCalculationPlan, ...]:
+    """按声明顺序解析独立逐消息指标，ID与原规则/窗口/指标共用集合。
+
+    参数: value为原生JSON数组；sources/bindings为原计划静态模型；ids为本次
+        已使用ID集合。返回: MessageCalculationPlan tuple。
+    异常: PlanValidationError保具体JSON路径；cache_policy报旧完整缓存能力未接线。
+    副作用: 只向本次局部ids登记名称，不读输入、DBC或执行表达式。
+    """
+    result = []
+    for index, raw in enumerate(array_at(value, '$.message_calculations')):
+        path = f'$.message_calculations[{index}]'
+        # 旧配置即使尚无新policy字段，也先说明旧完整cache模式为何不能运行。
+        if type(raw) is dict and 'cache_policy' in raw:
+            raise PlanValidationError(path + '.cache_policy',
+                '旧profile完整触发/cache模式尚未接线；current_message-v1仅用本条消息，不接受cache_policy',
+                'capability_unavailable')
+        raw = object_at(raw, path, ('name', 'update_message', 'expr', 'unit'),
+                        ('parameters', 'split_by_sign', 'source', 'profile', 'operation', 'message_policy'))
+        calculation_id = register_id(raw['name'], path + '.name', ids)
+        from .input_defaults import source_reference
+        source_name = source_reference(raw, sources, path, can_only=True)
+        source = next((item for item in sources if item.name == source_name), None)
+        if source is None:
+            raise PlanValidationError(path + '.source', '逐消息指标来源不存在')
+        text_source = ((source.source_type in ('can_asc', 'asc_or_blf', 'raw_can_csv')) and (isinstance(source.config, CANTextSpec)))
+        if not text_source and (source.source_type != 'can_blf' or not isinstance(source.config, LegacyCANSpec)):
+            raise PlanValidationError(path + '.source', '逐消息计算需要can_blf、can_asc或raw_can_csv来源', 'capability_unavailable')
+        expected_profile = 'can-text-v1' if text_source else source.config.legacy_profile
+        profile = choice_at(raw.get('profile', expected_profile), (expected_profile,), path + '.profile')
+        if profile != expected_profile:
+            raise PlanValidationError(path + '.profile', 'profile必须等于来源legacy_profile')
+        # 当前只有一种逐消息累计策略；省略采用它，显式未知策略仍拒绝。
+        operation = choice_at(raw.get('operation', 'legacy_sum'), ('legacy_sum',), path + '.operation')
+        policy = choice_at(raw.get('message_policy', 'current_message-v1'), ('current_message-v1',), path + '.message_policy')
+        selector_raw = object_at(raw['update_message'], path + '.update_message',
+                                 ('frame_id',), ('channel', 'is_extended', 'is_fd'))
+        for flag in ('is_extended', 'is_fd'):
+            if flag in selector_raw and type(selector_raw[flag]) is not bool:
+                raise PlanValidationError(path + '.update_message.' + flag, '填写时需要bool，不能为null')
+        from .channels import channel_index
+        channel = (channel_index(selector_raw['channel'], path + '.update_message.channel')
+                   if 'channel' in selector_raw else source.config.channel)
+        selector = model_at(LegacyMessageSelector, path + '.update_message',
+            channel, selector_raw['frame_id'], selector_raw.get('is_extended'), selector_raw.get('is_fd'))
+        if selector.channel != source.config.channel:
+            raise PlanValidationError(path + '.update_message.channel', '选择器channel必须等于来源通道')
+        parameters_raw = raw.get('parameters', {})
+        # 参数名称可由用户声明，但容器及每个value/unit对象仍严格校验。
+        parameters_raw = object_at(parameters_raw, path + '.parameters', (),
+                                   tuple(parameters_raw) if type(parameters_raw) is dict else ())
+        parameters = []
+        for name, item in parameters_raw.items():
+            parameter_path = path + '.parameters.' + name
+            item = object_at(item, parameter_path, ('value', 'unit'))
+            parameters.append(model_at(ExpressionParameter, parameter_path, name, item['value'], item['unit']))
+        parameters = tuple(parameters)
+        # 不接普通全局派生；当前表达式仅原别名与本指标显式参数，没有保持语义。
+        declaration = model_at(MessageDeclarations, path + '.parameters', bindings, source_name, parameters,
+                               message_policy=policy)
+        unit = text_at(raw['unit'], path + '.unit')
+        expression = expression_at(raw['expr'], path + '.expr', declaration, (), unit=unit)
+        # 三字段显式选择原值政策，不把配置缺失、null或自由条件当作分桶。
+        disjunction = None
+        if 'split_by_sign' in raw:
+            item = object_at(raw['split_by_sign'], path + '.split_by_sign', ('signal', 'bucket'), ('value_policy',))
+            disjunction = model_at(LegacyDisjunction, path + '.split_by_sign',
+                item['signal'], item['bucket'], item.get('value_policy', 'raw_decoded-v1'))
+            model_at(bindings.resolve, path + '.split_by_sign.signal', disjunction.signal)
+        calculation = model_at(MessageCalculationPlan, path, calculation_id, source_name, profile, operation,
+                          selector, expression, unit, parameters, policy, disjunction)
+        # 校验共享于validate/explain，typed替换不能绕过跨对象完整定位关系。
+        model_at(require_message_calculation, path + '.expr', calculation, sources, bindings)
+        result.append(calculation)
+    return tuple(result)