chronaxis 0.1.0.dev0__py3-none-any.whl

chronaxis/execution/memory_reader.py

@@ -0,0 +1,247 @@
+"""在既有内存适配器之外预留输入、批次与协议状态预算。
+
+输入SourceSpec本来已完整存在于调用方内存；封装构造前核算它和信号声明，
+不声称控制过去的分配或全进程RSS。输出为既有适配器实际SignalBatch，
+归一化次数、backend、分批、原顺序、watermark/EOF和异常原因不改变。
+每请求预留最坏两个交接批次及来源pending状态，再创建/推进内部生成器；
+NumPy字符串按最大原宽度×N核算Unicode数组/临时副本，不能只计原字符串总长。
+超限明确失败，不偷偷减小batch_rows、切换后端或丢样本。所有预算至EOF/close释放，
+外部长期保存owned批次不在本封装内部预算保证内；不读取CSV、旧日志或DBC。
+"""
+
+# 原适配器和结构模型负责输入契约，资源账本仅控制新执行层开销。
+from collections.abc import Iterator
+from ..core.binding import SignalDefinition
+from ..core.models import SourceSpec
+from ..results.budget import ResourceBudget
+from ..results.spool import _cleanup_owner, _reserve_owned_ram, _release_owned_ram
+from ..sources.memory import MemorySourceAdapter
+from ..sources.models import ReadRequest, SignalBatch, SourceDescription
+from ..sources.protocol import SourceClosedError
+from .history import _metadata_bytes
+
+
+class BudgetedMemorySourceAdapter:
+    """共享一个输入预留，为各读取请求保留独立批次/协议最坏预算。
+
+adapter只在预留成功后建立；info存每别名实际投影总数与最大原字符串字符数。
+active登记活动请求，close尝试关闭全部并释放输入引用，原SourceSpec不修改。
+_uninstalled_read保构造或登记未返回的真实请求；_closing先拒绝新读，closed仅在
+所有子请求、原适配器及本层_input_cost实际释放后成立。
+"""
+
+    def __init__(self, budget: ResourceBudget, source: SourceSpec, session_id: str,
+                 signals: tuple[SignalDefinition, ...], *, backend: str = 'numpy', clock_only=(), retain_original=True):
+        """核算已有完整输入后建立原适配器，不提前生成数组。
+
+        参数: budget为共享账本；source/session_id/signals/backend与既有内存入口相同。
+            clock_only只取时间；retain_original=False不生成原值列，默认仍保留旧行为。
+        返回: 新封装。异常: 配置/预算/原适配器初始化原错；持续清理失败附
+            memory_source_cleanup_owner，恢复后从该真实owner重试close。
+        """
+        if not isinstance(budget, ResourceBudget) or not isinstance(source, SourceSpec) or type(signals) is not tuple or any(not isinstance(item, SignalDefinition) for item in signals):
+            raise TypeError('预算内存来源需要账本/SourceSpec/typed信号tuple')
+        # 所有保留输入和固定描述保守计数，未知对象不参与任意序列化。
+        cost = 16384 + _metadata_bytes((source, session_id, signals)) * 16
+        self.budget = self._budget = budget
+        self.closed = self._closing = False
+        self._input_cost = self._held_cost = 0
+        self._adapter = self._uninstalled_read = None
+        self.active: set[_BudgetedBatches] = set()
+        self.info = {}
+        try:
+            # 直接申请返回途中取消也由同一槽登记；不靠子调用后的共享余额补账。
+            _reserve_owned_ram(self, cost, '_input_cost')
+            self._adapter = MemorySourceAdapter(source, session_id, signals, backend=backend,
+                clock_only=clock_only,retain_original=retain_original)
+            self.info = {item.name: [0, 0] for item in signals}
+            # 只遍历已经提供的memory原行，不重新读取旧输入或进行归一化。
+            for row in source.rows if signals else ():
+                for item in signals:
+                    if item.field in row.values:
+                        self.info[item.name][0] += 1
+                        value = None if item.name in clock_only else row.values[item.field]
+                        if type(value) is str:
+                            self.info[item.name][1] = max(self.info[item.name][1], len(value))
+        except BaseException as exc:
+            _cleanup_owner(self, exc, 'memory_source_cleanup_owner', '预算内存来源构造')
+            raise
+
+    def _ensure_open(self) -> None:
+        """拒绝已关闭来源，不以空批掩盖错误。
+
+        参数: 无。返回: None。异常: SourceClosedError为已关闭。
+        """
+        if self.closed or self._closing:
+            raise SourceClosedError('预算内存来源已关闭或正在清理')
+
+    def describe(self) -> SourceDescription:
+        """直接返回原适配器静态描述，不提升来源能力或观测证据状态。
+
+        参数: 无。返回: SourceDescription。异常: 关闭/原描述错误传播。
+        """
+        self._ensure_open()
+        return self._adapter.describe()
+
+    def _request_cost(self, request: ReadRequest) -> int:
+        """计算一个读取请求在全部next期间持有的最坏预留。
+
+        参数: request为当前会话/投影/批次上限。返回: 保守bytes，非RSS。
+        异常: ValueError为请求会话/别名错误，其他预算错误由申请点报告。
+        """
+        self._ensure_open()
+        if not isinstance(request, ReadRequest) or request.session_id != self._adapter.session_id or any(name not in self.info for name in request.signal_names):
+            raise ValueError('预算内存来源请求会话/投影错误')
+        total = sum(self.info[name][0] for name in request.signal_names)
+        size = min(total, request.batch_rows)
+        max_chars = max((self.info[name][1] for name in request.signal_names), default=0)
+        # nbytes至多time/sequence各8、values8、valid1、quality2；4096覆盖复制、装箱/分组。
+        per_batch = 65536 + len(request.signal_names) * 8192 + size * 4096
+        if self._adapter.backend == 'numpy':
+            # 原str可能形成(N,) UTF32定宽列，八倍覆盖原列/转换及模型验证临时副本。
+            per_batch += size * max_chars * 4 * 8
+        # yield时原生成器仍保留当前批，next构造下一批存在交接重叠，不只申请一套数组。
+        # 协议pending最坏保留全部原投影身份并复制set；memory总样本数是已知有限事实。
+        return per_batch * 2 + total * 512 + len(request.signal_names) * 2048
+
+    def iter_batches(self, request: ReadRequest) -> Iterator[SignalBatch]:
+        """预留整次请求的最坏缓冲/状态，再创建实际批次生成器。
+
+        参数: request为既有读取请求，不改变batch_rows。返回: 独立预算游标。
+        异常: 请求/预算/原来源错误传播；超限在数组归一化之前失败，持续清理
+            失败附memory_read_cleanup_owner，来源也保留未返回read槽。
+        """
+        cost = self._request_cost(request)
+        if self._uninstalled_read is not None:
+            raise SourceClosedError('预算内存来源尚有未返回请求待清理')
+        try:
+            iterator = _BudgetedBatches(self, request, cost)
+        except BaseException as exc:
+            # 构造未返回的真实read先归来源，不能只保费用而遗失原生成器。
+            self._uninstalled_read = getattr(exc, 'memory_read_cleanup_owner', None)
+            raise
+        self._uninstalled_read = iterator
+        try:
+            self.active.add(iterator)
+        except BaseException as exc:
+            # add可能在登记前或后抛错；只关当前read，原注册错误不被close取消替代。
+            _cleanup_owner(iterator, exc, 'memory_read_cleanup_owner', '预算内存请求登记')
+            raise
+        self._uninstalled_read = None
+        return iterator
+
+    def close(self) -> None:
+        """关闭所有请求及原适配器，释放本封装预留并保留调用方原输入。
+
+        参数: 无。返回: None，幂等。异常: 首个原关闭错误附memory_source_cleanup_owner；
+            其他独立read也尝试关闭，子责任未完成时保留来源合同与全部未释放槽。
+        """
+        if self.closed:
+            return
+        self._closing = True
+        try:
+            first_error = None
+            # 未登记read仍属于本来源；显式槽与活动set可指向同对象，close幂等。
+            if self._uninstalled_read is not None:
+                try:
+                    self._uninstalled_read.close()
+                except BaseException as exc:
+                    first_error = exc
+            for iterator in tuple(self.active):
+                try:
+                    iterator.close()
+                except BaseException as exc:
+                    if first_error is None:
+                        first_error = exc
+                    else:
+                        first_error.add_note(f'其他内存请求关闭失败: {type(exc).__name__}')
+            if first_error is not None:
+                raise first_error
+            if self._adapter is not None:
+                self._adapter.close()
+                self._adapter = None
+            # 子生成器与原来源全关后才丢输入引用；固定费逐笔确认释放前后取消。
+            self.info.clear()
+            _release_owned_ram(self, self._input_cost, '_input_cost')
+            if self._held_cost == 0:
+                self.closed = True
+        except BaseException as exc:
+            exc.memory_source_cleanup_owner = self
+            raise
+
+
+class _BudgetedBatches:
+    """持有一请求的预留/原生成器/当前批，EOF或close时抵销一次预留。"""
+
+    def __init__(self, owner: BudgetedMemorySourceAdapter, request: ReadRequest, cost: int):
+        """先申请再创建原请求，构造失败不保留请求状态。
+
+        参数: owner为预算来源；request为原请求；cost为最坏预留。返回: 独立游标。
+        异常: 预算或原请求初始化原错，持续清理失败附memory_read_cleanup_owner；
+            未实际入账不抵销，返回途中取消仍登记原cost槽。
+        """
+        self.owner, self.closed, self.current = owner, False, None
+        self._budget, self._held_cost, self.cost = owner.budget, 0, 0
+        self.iterator = None
+        self._closing = False
+        try:
+            # 先装恢复槽再申请；旧最坏整次请求费用公式保持原数值。
+            _reserve_owned_ram(self, cost, 'cost')
+            self.iterator = owner._adapter.iter_batches(request)
+        except BaseException as exc:
+            _cleanup_owner(self, exc, 'memory_read_cleanup_owner', '预算内存请求构造')
+            raise
+
+    def __iter__(self) -> '_BudgetedBatches':
+        """返回本独立游标。
+
+        参数: 无。返回: self。异常: 无。
+        """
+        return self
+
+    def __next__(self) -> SignalBatch:
+        """在整次预留覆盖下推进原适配器，不重复归一化或改进度。
+
+        参数: 无。返回: 原适配器实际批次。异常: EOF/关闭/原来源错误，故障清理保留根因。
+        """
+        self.owner._ensure_open()
+        if self.closed:
+            raise StopIteration
+        if self._closing:
+            raise SourceClosedError('预算内存请求正在清理')
+        try:
+            self.current = next(self.iterator)
+            return self.current
+        except StopIteration:
+            # 真实耗尽后关闭失败必须传播该失败，不能用StopIteration伪报正常完成。
+            self.close()
+            raise
+        except BaseException as exc:
+            _cleanup_owner(self, exc, 'memory_read_cleanup_owner', '预算内存请求推进')
+            raise
+
+    def close(self) -> None:
+        """关闭本请求原生成器，释放当前批引用和最坏预留，其他请求保持独立。
+
+        参数: 无。返回: None，幂等。异常: 原生成器或释放错误附memory_read_cleanup_owner；
+            原生成器未成功关闭时保留原对象和费用，其他请求保持独立。
+        """
+        if self.closed:
+            return
+        self._closing = True
+        try:
+            if self.iterator is not None:
+                self.iterator.close()
+                # 未开始生成器close不执行finally，只解除本read的原登记，不动平行read。
+                if self.owner._adapter is not None:
+                    self.owner._adapter.active.discard(self.iterator)
+            self.current = self.iterator = None
+            _release_owned_ram(self, self.cost, 'cost')
+            # 费用真正抵销后才从父解除，释放后取消可重试而不会重复扣账。
+            self.owner.active.discard(self)
+            if self.owner._uninstalled_read is self:
+                self.owner._uninstalled_read = None
+            self.closed = True
+        except BaseException as exc:
+            exc.memory_read_cleanup_owner = self
+            raise

chronaxis/execution/message_bindings.py

@@ -0,0 +1,293 @@
+"""完整核验独立解码消息仓，为当前消息表达式取得有预算的运行绑定。
+
+输入为已经冻结的MessageDeclarations及调用方拥有的sealed DecodedMessageStore。
+工厂借用原声明和仓，先预约有限元数据，默认以一个独立reader逐条核验真实文件；
+首次核验只有在实际EOF、全流SHA/count以及reader的FD和费用均成功关闭后，才开放
+MessageBindings。首末时间来自全部decoded记录，空仓保持None；不根据表达式
+别名裁剪仓、不要求每个字段出现，也不重读BLF、DBC或普通history。
+同一实际sealed仓可借用已完成lease的核验结果；仍核同预算、封口事实和文件状态，
+为新声明创建独立绑定及自有费用，不复用旧DBC解码或跨任务缓存。后续实际计算仍核全流EOF/SHA。
+
+本域保留原SignalDefinition身份，执行数值转换和表达式由其他模块负责；这里
+不应用TTL、保持、同刻去重或原请求范围筛选。profile/read_identity是仓已保存
+的显式标签，真实文件EOF不证明该仓来自某次CAN读取或旧求值触发。
+
+lease只拥有固定元数据及自己取得的reader，不关闭借用store、预算或其他reader，
+不删除文件。原store的reader发生错误时仍会按原政策poison/清理父仓；本工厂
+保留该最高恢复owner，不把这一原生行为误称为借仓在失败后必定仍开放。
+未返回reader始终由实际store的pending/readers槽保活，不伪造半初始化对象。
+
+预算仅覆盖本层新增摘要、身份编码及有限状态，单行费用由实际reader承担；
+原声明、原仓元数据和调用方保留的异常诊断属于借用输入或输出，不代表RSS。
+本模块只使用轻量预算helper、消息模型和原仓，不导入history/codec/spool或旧IO。
+"""
+
+# 模型只接独立消息域；原仓负责严格行编码及全流校验，工厂不复制这些算法。
+from ..core.message_binding import MessageBindings, MessageDeclarations, MessageSourceEvidence
+from ..legacy.message_store import DecodedMessageStore, StoredDecodedMessage
+from ..results.budget import ResourceBudget, _cleanup_owner, _release_owned_ram, _reserve_owned_ram
+from ..results.errors import ResultClosedError, ResultFormatError
+
+
+def _fixed_estimate(declarations: MessageDeclarations, store: DecodedMessageStore) -> int:
+    """在创建本层身份副本前按原生长度估算有限元数据及编码临时空间。
+
+    参数: declarations为借用的冻结消息声明；store为借用的活sealed仓。
+    返回: 保守bytes金额，不遍历原信号定义、参数树、raw_config或逐条记录。
+    异常: TypeError/ValueError为仓公开元数据已变成非原生文本或非法条数；
+        本函数不strip、encode、repr或创建字段副本，不为估费先建立大文本。
+    """
+    # 声明身份已由调用方构造；本层只支付新evidence和运行身份所需的有限编码。
+    if type(declarations.identity) is not str:
+        raise TypeError('消息声明identity必须为原生文本')
+    characters = len(declarations.identity)
+    for name in ('source_name', 'session_id', 'decoder_profile', 'read_identity', 'sha256'):
+        value = getattr(store, name)
+        if type(value) is not str:
+            raise TypeError('解码仓绑定元数据必须为原生文本')
+        characters += len(value)
+    # 条数编码空间随整数位数计入；端点受int64约束，其固定空间已在基数内。
+    if type(store.count) is not int or store.count < 0:
+        raise ValueError('解码仓绑定条数必须为非负原生int')
+    return 32768 + 32 * (characters + store.count.bit_length() + 1)
+
+
+def _file_snapshot(store: DecodedMessageStore) -> tuple[int, ...]:
+    """记录新消息暂存文件的有限状态，防止把已变化路径当作先前核验的同一文件。
+
+    参数: store为已经封口的实际消息仓。返回: 设备、文件身份、大小及系统提供的时间信息tuple。
+    异常: 原stat错误传播。边界: 这不是持续监控或新内容摘要，计算reader仍须核完整EOF/SHA；
+        stat对象及tuple在lease固定元数据预算内，不接触原BLF或DBC。
+    """
+    state = None
+    try:
+        state = store.file_path.stat()
+        return state.st_dev, state.st_ino, state.st_size, state.st_mtime_ns, state.st_ctime_ns
+    finally:
+        # 取消异常可保留本frame，不让已结束预算的stat对象留在诊断局部变量中。
+        state = None
+
+
+class MessageBindingLease:
+    """持有自有reader和固定费，完整核验或同仓复用后借出不可变消息运行绑定。
+
+    _fixed_cost/_held_cost只记录本层直接交易，reader的费用由原reader独立负责。
+    _opening_reader标记取得子对象的窗口；未返回子仍属于借用store的真实责任槽。
+    _verified_*保留同一借用仓的有限核验快照，仅供建立独立新绑定，不替其他lease付款。
+    开始关闭或失败后不可借出bindings，只有自身子和费用都清完才closed。
+    """
+
+    def __init__(self, budget: ResourceBudget):
+        """先安装全部责任槽，不预约费用，也不打开文件。
+
+        参数: budget为实际消息仓使用的ResourceBudget。
+        返回: 尚未完成的lease，供唯一工厂继续初始化。
+        异常: TypeError为非ResourceBudget；不会接收已经支付却无owner的裸金额。
+        """
+        # 所有槽在首次预算或reader回调之前存在，预约返回后取消仍可恢复同一owner。
+        self._budget = budget
+        self._fixed_cost = self._held_cost = 0
+        self._reader = self._current = self._bindings = None
+        self._store = self._declarations = self._facts = self._evidence = None
+        # 成功核验的有限证据保在本lease；借用仓不由它关闭，关闭lease即解除这些引用。
+        self._verified_store = self._verified_facts = self._verified_file = None
+        self._opening_reader = False
+        self._closed = self._closing = self._failed = False
+        if not isinstance(budget, ResourceBudget):
+            raise TypeError('消息绑定lease需要ResourceBudget')
+
+    @property
+    def bindings(self) -> MessageBindings:
+        """取得完整核验后形成的不可变消息绑定，不借出半成品。
+
+        参数: 无。返回: 原MessageBindings对象。
+        异常: ResultClosedError为尚未完成、已失败、关闭中或已经关闭。
+        """
+        # 即使bindings曾经创建成功，清理中的owner也不能继续参与新的求值。
+        if self._closed or self._closing or self._failed or self._bindings is None:
+            raise ResultClosedError('消息运行绑定未完成、已失败或正在关闭')
+        return self._bindings
+
+    @property
+    def closed(self) -> bool:
+        """读取本lease的实际清理状态。
+
+        参数: 无。返回: reader和自有费用均清完时为True。
+        异常: 无；不把借用store是否关闭混成本lease的状态。
+        """
+        return self._closed
+
+    def _require_store(self) -> None:
+        """核本次借用仓的当前合同及封口事实，拒绝回读期间替换元数据。
+
+        参数: 无，读取本lease保存的原store、声明和有限事实。
+        返回: None；不读取源CAN或额外打开仓文件。
+        异常: 原仓生命周期错误；ValueError为来源、会话或预算不对应；
+            ResultFormatError为本次回读前后封口事实被替换。
+        """
+        # 原仓必须真实仍可读；普通声明身份不代替其当前文件和生命周期。
+        store, declarations = self._store, self._declarations
+        store._require('sealed')
+        if store.budget is not self._budget or store._budget is not self._budget:
+            raise ValueError('消息仓绑定的原共享budget已被替换')
+        if store.source_name != declarations.source or store.session_id != declarations.declarations.session_id:
+            raise ValueError('消息仓来源或会话与当前消息声明不符')
+        # 路径只作同一输入对象的保护，不把路径文本冒充内容SHA或CAN认证。
+        current = (store.source_name, store.session_id, store.decoder_profile, store.read_identity,
+                   store.sha256, store.count, store.file_path, store.max_row_bytes, store.sparse_sequences, store.line_limit)
+        if self._facts is not None and current != self._facts:
+            raise ResultFormatError('消息仓回读期间封口身份或条数已改变')
+
+    def _close_reader(self) -> None:
+        """关闭唯一已安装的真实reader，未完成责任保在原槽供重试。
+
+        参数: 无。返回: None；正常EOF已关闭的reader也按原幂等接口收尾。
+        异常: 原FD或费用释放错误；实际关闭后才取消时清槽，避免重复抵销。
+        """
+        # 当前记录必须先结束引用，子reader才可归还覆盖单行的实际费用。
+        self._current = None
+        if self._reader is None:
+            return
+        try:
+            self._reader.close()
+        except BaseException:
+            if self._reader.closed:
+                self._reader = None
+            raise
+        else:
+            self._reader = None
+
+    def _clear_temporary(self) -> None:
+        """结束本工厂有限临时引用，不清调用方的原对象或异常traceback。
+
+        参数: 无。返回: None。
+        异常: 无主动异常；借用store与声明只解除引用，不执行它们的close。
+        """
+        # 临时槽解除引用；成功后用于同仓复用的少量事实由_verified_*持有并计入固定费。
+        self._current = self._facts = self._evidence = None
+        self._store = self._declarations = None
+
+    def close(self) -> None:
+        """只关闭本lease的实际reader，再归还逐笔自有固定费。
+
+        参数: 无。返回: None，实际完成后重复调用幂等。
+        异常: 原FD或预算取消错误，可恢复后在同一owner上重试；
+            释放后取消按实际槽记账，不重复抵销其他借用费用。
+        副作用: 不显式关闭借用仓、其他reader或共享budget，不删除任何文件。
+        """
+        # 关闭中禁止重新借出绑定；子FD持续失败时保留子及其实际责任，不先报closed。
+        if self._closed:
+            return
+        self._closing = True
+        try:
+            self._close_reader()
+            self._bindings = None
+            self._clear_temporary()
+            self._verified_store = self._verified_facts = self._verified_file = None
+            self._opening_reader = False
+            _release_owned_ram(self, self._fixed_cost, '_fixed_cost')
+            self._closed = True
+        except BaseException as exc:
+            # 直接close也交出同一真实lease；不递归清理，不覆盖原store恢复属性。
+            exc.message_binding_lease_cleanup_owner = self
+            raise
+
+
+def bind_message_store(declarations: MessageDeclarations, store: DecodedMessageStore, *,
+                       verified_by: MessageBindingLease | None = None) -> MessageBindingLease:
+    """完整核验消息仓，或在同一未变仓上借用真实已完成核验，返回独立有预算绑定。
+
+    参数: declarations为冻结MessageDeclarations；store为调用方拥有的实际
+        DecodedMessageStore，须仍活且sealed，source/session与原声明一致；verified_by
+        可为已成功且未关闭的真实lease，仅同一仓/预算/封口及文件状态一致时复用核验结果。
+    返回: MessageBindingLease，其bindings包含实际仓SHA/count/首末及显式标签；
+        空仓首末为None，所有decoded帧都计数，不按字段缺失或请求范围筛掉。
+    异常: TypeError/ValueError为类型及声明不对应；原仓状态、IO、预算、取消错误
+        原样传播；ResultFormatError为未完成真实EOF或当前封口事实变化。
+        原错误附message_binding_lease_cleanup_owner；未返回reader的责任保在
+        原decoded_message_store_cleanup_owner，不擅自关闭借用父仓。
+    """
+    # 只接现有真实仓与消息声明，不以普通history、结构证据或同名字符串伪装输入。
+    if not isinstance(declarations, MessageDeclarations) or not isinstance(store, DecodedMessageStore):
+        raise TypeError('消息运行绑定需要MessageDeclarations和DecodedMessageStore')
+    if verified_by is not None and type(verified_by) is not MessageBindingLease:
+        raise TypeError('共享核验需要真实MessageBindingLease，不能用结构证据代替')
+    store._require('sealed')
+    owner = MessageBindingLease(store.budget)
+    previous = evidence = None
+    try:
+        # 长标签先按原生长度付费，随后才创建事实tuple、模型及身份编码临时副本。
+        owner._store, owner._declarations = store, declarations
+        _reserve_owned_ram(owner, _fixed_estimate(declarations, store), '_fixed_cost')
+        owner._require_store()
+        owner._facts = (store.source_name, store.session_id, store.decoder_profile, store.read_identity,
+                        store.sha256, store.count, store.file_path, store.max_row_bytes, store.sparse_sequences, store.line_limit)
+        if verified_by is not None:
+            # bindings属性拒绝未完成/失败/关闭的lease；对象身份和原封口事实防跨仓借证。
+            previous = verified_by.bindings
+            if (verified_by._budget is not owner._budget or verified_by._verified_store is not store
+                    or verified_by._verified_facts != owner._facts):
+                raise ResultFormatError('共享核验的消息仓、预算或封口事实已改变')
+            owner._verified_file = _file_snapshot(store)
+            if verified_by._verified_file != owner._verified_file:
+                raise ResultFormatError('共享核验的消息仓文件状态已改变')
+            evidence = previous.evidence
+            owner._evidence = MessageSourceEvidence(evidence.source, evidence.session_id,
+                evidence.decoder_profile, evidence.read_identity, evidence.store_sha256,
+                evidence.record_count, evidence.first_time_ns, evidence.last_time_ns)
+            owner._bindings = MessageBindings(declarations, owner._evidence)
+            owner._require_store()
+            if _file_snapshot(store) != owner._verified_file:
+                raise ResultFormatError('共享绑定创建期间消息仓文件状态已改变')
+            owner._verified_store, owner._verified_facts = store, owner._facts
+            owner._clear_temporary()
+            return owner
+        owner._verified_file = _file_snapshot(store)
+        count = 0
+        first_time_ns = last_time_ns = None
+        # 此窗口内未返回的真实reader仍在store.pending/readers中，不制造第二个父owner。
+        owner._opening_reader = True
+        owner._reader = store.iter_records()
+        owner._opening_reader = False
+        for owner._current in owner._reader:
+            if not isinstance(owner._current, StoredDecodedMessage):
+                raise ResultFormatError('消息仓回读返回非StoredDecodedMessage')
+            if first_time_ns is None:
+                first_time_ns = owner._current.time_ns
+            last_time_ns = owner._current.time_ns
+            count += 1
+            # 下一次next可能在真实EOF释放子费用，不能跨该动作保留上一行完整values。
+            owner._current = None
+        # 提前close同样能使for停止；只有真EOF与实际FD/费用关闭才允许生成运行证据。
+        if not owner._reader.verified_eof or not owner._reader.closed:
+            raise ResultFormatError('消息绑定未完成真实仓EOF及reader关闭')
+        owner._require_store()
+        digest = owner._reader._digest.hexdigest()
+        if count != owner._facts[5] or owner._reader._count != count or digest != owner._facts[4]:
+            raise ResultFormatError('消息绑定实际SHA或条数与原封口事实不符')
+        if _file_snapshot(store) != owner._verified_file:
+            raise ResultFormatError('消息仓核验期间文件状态已改变')
+        owner._close_reader()
+        # 首末取全仓实际行，时间已在仓中映射，不施offset、TTL或连续观测域裁剪。
+        owner._evidence = MessageSourceEvidence(source=store.source_name, session_id=store.session_id,
+            decoder_profile=store.decoder_profile, read_identity=store.read_identity,
+            store_sha256=digest, record_count=count, first_time_ns=first_time_ns,
+            last_time_ns=last_time_ns)
+        owner._bindings = MessageBindings(declarations, owner._evidence)
+        owner._verified_store, owner._verified_facts = store, owner._facts
+        owner._clear_temporary()
+        return owner
+    except BaseException as exc:
+        # 先断开本层单行引用，原输入与必要异常诊断仍归调用方；不清他人traceback帧。
+        owner._current = None
+        owner._failed = True
+        if owner._opening_reader and owner._reader is None:
+            # 调用返回到父赋值之间取消时，原仓仍登记实际子；父属性只供调用方恢复。
+            if getattr(exc, 'decoded_message_store_cleanup_owner', None) is None:
+                exc.decoded_message_store_cleanup_owner = store
+        exc.message_binding_lease_cleanup_owner = owner
+        _cleanup_owner(owner, exc, 'message_binding_lease_cleanup_owner', '消息绑定工厂')
+        raise
+    finally:
+        # 原异常可能长期保留；不由本层frame继续保活其他lease已交接的绑定/证据。
+        previous = evidence = None

chronaxis/execution/message_delivery.py

@@ -0,0 +1,37 @@
+"""在读取器已有预算内同步交付必要消息，不建立额外历史或结果副本。"""
+
+from ..results.budget import _reserve_owned_ram, _release_owned_ram
+from .history import _metadata_bytes
+
+
+def deliver_message(owner, projection, consumer, frame, sequence, values, time_ns, *, canonical_keys=False):
+    """先付本次投影费用，再同步调用消费者，返回后释放临时消息。
+
+    参数: owner为拥有_update_cost槽的读取器；projection为有限CAN投影；
+        consumer为同步可调用对象；其余为当前原帧、序号、已解码值及实际时间。
+        canonical_keys说明文本入口的规范字段键。消费者如需保留对象，须自行
+        取得保存费用；此调用只借出当前对象，不承诺历史生命周期。
+    返回: None，非目标帧不构造消息。异常: 预算/值/消费者及清理错误原样传播。
+    """
+    fields = projection.fields_for(frame)
+    if not projection.accepts_frame(frame):
+        return
+    update = None
+    # 费用只取所选字段；无关解码值不遍历、不复制进计算输入。
+    cost = 16384 + sum(1024 + 16 * _metadata_bytes(values.get(
+        field.key if canonical_keys else field.signal)) for field in fields)
+    _reserve_owned_ram(owner, cost, '_update_cost')
+    try:
+        update = projection.build(frame, sequence, values, time_ns, canonical_keys=canonical_keys)
+        consumer(update)
+    except BaseException as error:
+        update = None
+        try:
+            _release_owned_ram(owner, owner._update_cost, '_update_cost')
+        except BaseException as cleanup:
+            # 原消费者错误优先；尚未释放的费用留在同一read槽，供外层关闭重试。
+            error.add_note('消息投影费用清理失败：' + type(cleanup).__name__)
+        raise
+    else:
+        update = None
+        _release_owned_ram(owner, owner._update_cost, '_update_cost')