chronaxis 0.1.0.dev0__py3-none-any.whl → 0.1.0.dev2__py3-none-any.whl

chronaxis/__init__.py

@@ -24,7 +24,7 @@ __all__ = [
     "parse_datetime_ns", "parse_duration", "shift_times_reference", "time_deltas_reference",
     "AnalysisPlan", "PlanValidationError", "load_analysis_plan", "validate_analysis_plan", "explain_analysis_plan",
     "PresetSpec", "PlanFragment", "build_preset", "resolve_preset_roles",
-    "AnalysisResult", "OutputManifest", "RunMetadata", "AnalysisError", "ResultClosedError",
+    "AnalysisResult", "OutputManifest", "ExportManifest", "RunMetadata", "AnalysisError", "ResultClosedError",
     "AnalysisRunner",
     "BatchJob", "BatchJobResult", "BatchReport", "BatchRunner", "BatchPlan", "load_batch_plan", "run_batch",
 ]
@@ -52,10 +52,10 @@ def __getattr__(name: str):
         # 取得类本身不创建session或输入；validate/explain仍只消费冻结计划声明。
         from .runner import AnalysisRunner
         return AnalysisRunner
-    if name in ('AnalysisResult', 'OutputManifest', 'RunMetadata', 'AnalysisError', 'ResultClosedError'):
+    if name in ('AnalysisResult', 'OutputManifest', 'ExportManifest', 'RunMetadata', 'AnalysisError', 'ResultClosedError'):
         # 结果层只依赖标准库和核心模型，访问入口也不启动任何读取或发布。
-        from .results import AnalysisResult, OutputManifest, RunMetadata, AnalysisError, ResultClosedError
-        return {'AnalysisResult': AnalysisResult, 'OutputManifest': OutputManifest, 'RunMetadata': RunMetadata,
+        from .results import AnalysisResult, OutputManifest, ExportManifest, RunMetadata, AnalysisError, ResultClosedError
+        return {'AnalysisResult': AnalysisResult, 'OutputManifest': OutputManifest, 'ExportManifest': ExportManifest, 'RunMetadata': RunMetadata,
                 'AnalysisError': AnalysisError, 'ResultClosedError': ResultClosedError}[name]
     if name in ('PresetSpec', 'PlanFragment', 'build_preset', 'resolve_preset_roles'):
         # 预设是外部领域构建层，根包普通导入仍仅加载标准库时间协议。

chronaxis/__main__.py

@@ -1,7 +1,7 @@
 """将python -m chronaxis委托给同一个CLI入口。
 
 输入为进程参数，输出及退出码由cli.main定义。作为模块导入时不运行命令；
-实际执行只加载CLI，再由用户命令决定检查计划、运行发布或导入旧INI。
+实际执行只加载CLI，再由用户命令决定检查配置、运行分析或处理结果。
 本文件不另写计算逻辑、加载CAN或注册额外后台动作。
 """
 

chronaxis/_batch_worker.py

@@ -0,0 +1,69 @@
+"""批量工作进程控制消息；只在收到对应任务时加载计算实现。"""
+from dataclasses import replace
+import os
+from pathlib import Path
+import signal
+from threading import Event
+
+def _diagnostics(error) -> tuple[str, ...]:
+    """保留有限异常链而不持有栈。参数: error原异常。返回: 文本tuple。异常: 原异常格式错误。"""
+    seen, details = set(), []
+    while error is not None and id(error) not in seen:
+        seen.add(id(error))
+        details.append(type(error).__name__ + ': ' + str(error))
+        details.extend(getattr(error, '__notes__', ()))
+        error = error.__cause__
+    return tuple(details)
+
+
+def worker_main(connection, fast_cancel=None):
+    """处理run/cleanup/close命令。参数: 私有管道。返回: None。异常: 断管退出，父进程负责树清理。"""
+    if fast_cancel is None:
+        from .batch.runner import _run_job
+        from .batch.process_transport import restore_job
+        from .batch.models import BatchJobResult
+    # Ctrl+C只由调度主进程接收，正在写结果的工作进程继续完整收尾。
+    signal.signal(signal.SIGINT, signal.SIG_IGN)
+    recovery = None
+    try:
+        while True:
+            command = connection.recv()
+            if command[0] == 'close':
+                if recovery is not None:
+                    recovery.close()
+                return
+            if command[0] == 'cleanup':
+                try:
+                    if recovery is not None:
+                        recovery.close()
+                    recovery = None
+                    connection.send(('cleaned', None))
+                except BaseException as error:
+                    connection.send(('cleanup_failed', _diagnostics(error)))
+                continue
+            if recovery is not None:
+                raise RuntimeError('存在未关闭资源的工作进程不能接收新任务')
+            _, packet, directory, backend = command
+            if fast_cancel is not None:
+                if command[0] != 'fast':
+                    raise RuntimeError('fast 工作进程收到未知命令')
+                from .fast.worker import file_response
+                connection.send(file_response(packet, Path(directory), fast_cancel))
+                continue
+            try:
+                job = restore_job(packet)
+                outcome = _run_job(job, Path(directory), backend, Event(), Event())
+            except BaseException as error:
+                outcome = BatchJobResult(packet['job_id'], 'failed',
+                    plan_path=packet.get('path'), error_type=type(error).__name__,
+                    error_message=str(error), error_chain=_diagnostics(error))
+            recovery = outcome.recovery
+            pending = recovery is not None and not recovery.closed
+            # 只发送冻结的纯结果字段；CleanupHandle的原资源必须留在拥有它的进程。
+            response = ('result', replace(outcome, recovery=None, worker_pid=os.getpid()), pending)
+            connection.send(response)
+    except EOFError:
+        if recovery is not None:
+            recovery.close()
+    finally:
+        connection.close()

chronaxis/analysis_cli.py

@@ -4,7 +4,7 @@
 validate和explain直接调用同一AnalysisRunner接口，不读取CSV、DBC或旧日志，不建立
 运行目录。序列化逐项选择公开报告字段，不遍历任意对象或另做一套配置校验。
 报告中的预算和有效期是声明，execution_ready不证明实际输入已核实。
-run先检查新输出与工作路径，再交给AnalysisRunner运行，在同一结果上write并关闭。
+run先检查输出根与独占工作路径，再交给AnalysisRunner运行，在同一结果上write并关闭。
 只有真实关闭成功才打印成功摘要；失败保留原原因链和现存产物，不假报回滚。
 
 本模块仅在实际计划命令时加载；CLI帮助与参数错误仍只需要标准库。
@@ -95,7 +95,7 @@ def run_static(arguments) -> int:
 
 
 def _new_output(arguments) -> Path:
-    """在扫描来源前拒绝已有输出、历史目录和必然冲突的工作路径。
+    """在扫描来源前检查可复用输出根、历史目录和冲突工作路径。
 
     参数: arguments包含output和可选work_dir，由argparse限定为路径文本。
     返回: 绝对输出Path；不创建目录，工作目录实际分配仍归AnalysisRunner。
@@ -115,12 +115,14 @@ def _new_output(arguments) -> Path:
             raise PlanValidationError('$.cli.work_dir', '工作目录不能等于输出目录或位于输出目录内部')
     for path in candidates:
         try:
-            # 两个参数自身都必须全新，不能跟随已有的悬空工作链接创建其目标。
+            # 工作路径必须新建；输出允许已有目录，悬空链接不允许。
             # 最终输出安装的竞态仍由原write检查，运行会话也保留原工作目录检查。
             path.lstat()
         except FileNotFoundError:
             continue
-        raise FileExistsError('输出或工作目标已存在，拒绝使用：' + str(path))
+        if path == output and path.is_dir() and not path.is_symlink():
+            continue
+        raise FileExistsError('工作目录须新建，输出目标须为目录：' + str(path))
     return output
 
 
@@ -143,15 +145,16 @@ def _cause_chain(error) -> tuple:
 def run_analysis(arguments) -> int:
     """复用真实分析和发布，成功关闭所有结果资源后才报告completed。
 
-    参数: arguments含plan、output、可选backend及work_dir；输出必须为全新目录。
+    参数: arguments含plan、output、可选backend及work_dir；输出目录可复用。
     返回: 成功0；已知分析/发布/关闭失败1，并说明输出可能已经发布。
     异常: 配置/路径错误交主CLI分类；取消原样传播；MemoryError及已知编程错误
         的直接或AnalysisError原因链继续抛出，不伪装成普通业务错误。
-    副作用: AnalysisRunner建立专用暂存并读来源，write按原合同安装新目录；不删除产物。
+    副作用: AnalysisRunner建立专用暂存并读来源，write在输出根新增本次文件；不删除已有产物。
     """
     plan = load_analysis_plan(arguments.plan)
     output = _new_output(arguments)
     runner = AnalysisRunner(backend=arguments.backend)
+    manifest = None
     try:
         # 结果拥有其真实仓和资源；write不重新运行来源，退出上下文完成实际close。
         with runner.run(plan, work_dir=arguments.work_dir) as result:
@@ -172,6 +175,11 @@ def run_analysis(arguments) -> int:
         if any(isinstance(item, (MemoryError, TypeError, AttributeError, AssertionError, NameError)) for item in chain):
             raise
         causes = ' <- '.join(type(item).__name__ + ': ' + str(item).replace('\n', ' ') for item in chain)
+        completed = manifest or next((getattr(item, 'completed_manifest') for item in chain
+                                      if getattr(item, 'completed_manifest', None) is not None), None)
+        if completed is not None:
+            print('结果已发布，清单：' + str(completed.manifest_path) + '；收尾失败：' + causes, file=sys.stderr)
+            return 1
         # 目录可能已安装后才发生close错误，非零退出不证明输出被撤销。
         print('分析或发布失败（输出可能已发布，请核对目标目录 ' + str(output) + '）：' + causes,
               file=sys.stderr)

chronaxis/batch/api.py

@@ -13,7 +13,7 @@ from .publication import write_batch_report
 def run_batch(plan: BatchPlan, output_dir, *, process_count: int | None = None, cancel_event=None, device_label='pending'):
     """运行并发布批量报告。
 
-    参数: plan为load_batch_plan取得的BatchPlan，规定本次独立任务及调度设置；process_count为可选正整数覆盖，None沿用计划；output_dir全新目录；cancel_event为可选Event；device_label为实际标签。
+    参数: plan为load_batch_plan取得的BatchPlan，规定本次独立任务及调度设置；process_count为可选正整数覆盖，None沿用计划；output_dir可复用目录；cancel_event为可选Event；device_label为实际标签。
     返回: BatchReport；failed/cancelled保留在报告，不伪装全部成功。
     异常: TypeError为非BatchPlan或取消对象类型不符；ValueError为无效并发、后端或
         任务声明；目录创建、调度、报告发布错误按原类型传播。单任务失败记录在jobs中，
@@ -33,14 +33,21 @@ def run_batch(plan: BatchPlan, output_dir, *, process_count: int | None = None,
             report = replace(report, infrastructure_error=type(error).__name__ + ': ' + str(error))
             error.batch_report = report
             try:
-                write_batch_report(report)
+                report = replace(report, report_path=write_batch_report(report))
+                error.batch_report = report
             except BaseException as diagnostic:
-                error.add_note('批量失败报告未发布: ' + type(diagnostic).__name__)
+                if hasattr(diagnostic, 'published_report_path'):
+                    report = replace(report, report_path=diagnostic.published_report_path)
+                    error.batch_report = report
+                error.add_note(('批量报告已发布但收尾失败: ' if hasattr(diagnostic, 'published_report_path')
+                                else '批量失败报告未发布: ') + type(diagnostic).__name__)
         raise
     try:
-        write_batch_report(report)
+        report = replace(report, report_path=write_batch_report(report))
     except BaseException as error:
         # 已完成任务绝不因汇总文件失败而丢失，未清理资源仍可从原异常恢复。
+        if hasattr(error, 'published_report_path'):
+            report = replace(report, report_path=error.published_report_path)
         error.batch_report = report
         raise
     return report

chronaxis/batch/cli.py

@@ -41,7 +41,7 @@ def run_batch_cli(arguments) -> int:
         print('批量结果清理失败：' + type(error).__name__ + ': ' + str(error), file=sys.stderr)
     document = report.to_dict()
     print(json.dumps(dict(status=report.status, counts=document['counts'],
-        output=str(report.output_dir), report=str(report.output_dir/'batch_report.json'),
+        output=str(report.output_dir), report=str(report.report_path),
         cleanup_pending=cleanup_failed, device_label=label), ensure_ascii=False, allow_nan=False))
     if cleanup_failed or report.status == 'failed':
         return 1

chronaxis/batch/models.py

@@ -84,6 +84,23 @@ class BatchPlan:
         返回: 冻结BatchPlan。异常: PlanValidationError定位字段；不读取业务报文，模板可读取DBC元数据。
         """
         from ..planning.checks import object_at, array_at, text_at, model_at, PlanValidationError, number_at, choice_at
+        from ..planning.diagnostic_collection import DiagnosticCollection
+        from ..planning.checks import require_json_value
+        require_json_value(config, '$')
+        diagnostics = DiagnosticCollection(config, 'batch-v1.schema.json')
+        names = set()
+        if type(config) is dict and type(config.get('jobs')) is list:
+            for index, job in enumerate(config['jobs']):
+                path = f'$.jobs[{index}]'
+                if type(job) is not dict or not diagnostics.usable(path):
+                    continue
+                name = job.get('name', f'job_{index+1}').casefold()
+                if name in names:
+                    diagnostics.add(PlanValidationError(path+'.name', '任务名称不能重复或仅大小写不同',
+                        'duplicate_id', hint='为每个独立任务指定唯一name'))
+                names.add(name)
+        # 批量自身结构一次报告；jobs子计划仍在工作进程启动时才加载。
+        diagnostics.finish()
         if type(config) is dict and ('workers' in config or 'max_workers' in config):
             raise PlanValidationError('$.process_count', '请使用process_count设置分析工作进程数；workers/max_workers不再接受')
         raw = object_at(config, '$', ('batch_version',), ('jobs', 'template', 'inputs', 'source', 'process_count', 'fail_fast', 'backend'))
@@ -129,6 +146,7 @@ class BatchJobResult:
     input_identity: str | None = None  # 只有实际分析返回后才记录。
     run_id: str | None = None  # 同计划重跑仍有独立运行身份。
     output_dir: Path | None = None  # 实际发布成功的目录，不预填未生成输出。
+    manifest_path: Path | None = None  # 本次任务实际完成清单，不猜固定文件名。
     error_type: str | None = None  # 原异常类型或未启动取消原因。
     error_message: str | None = None  # 原错误说明，不用成功值覆盖失败。
     error_chain: tuple[str, ...] = ()  # cause链和清理notes，保留错误来源。
@@ -151,6 +169,7 @@ class BatchJobResult:
                  'elapsed_seconds', 'memory_budget_bytes', 'worker_pid')
         result = {name: getattr(self, name) for name in names}
         result.update(output_dir=None if self.output_dir is None else str(self.output_dir),
+                      manifest_path=None if self.manifest_path is None else str(self.manifest_path),
                       error_chain=list(self.error_chain),
                       cleanup_pending=self.recovery is not None and not self.recovery.closed)
         return result
@@ -160,7 +179,7 @@ class BatchJobResult:
 class BatchReport:
     """按原任务顺序汇总结果；每个任务数值表仍在各自目录，不跨口径归约。"""
 
-    output_dir: Path  # 本批新目录，已有目标不会被覆盖。
+    output_dir: Path  # 可复用的输出根，任务子目录和报告按本批时间区分。
     jobs: tuple[BatchJobResult, ...]  # 最终结果顺序不受工作进程完成先后影响。
     process_count: int  # 本次配置的工作进程上限。
     fail_fast: bool  # 是否在观察到失败后停止派发。
@@ -168,6 +187,8 @@ class BatchReport:
     device_label: str  # 调用方明确提供；缺省pending，不猜测机器。
     worker_process_count: int = 0  # 本次实际启动的工作进程数，空批次为0。
     infrastructure_error: str | None = None  # 调度或汇总基础设施错误，与任务业务失败分开。
+    report_path: Path | None = None  # 成功发布后返回的实际报告路径。
+    _publication: object = field(default=None, repr=False, compare=False)  # 持有本批名称，关闭释放。
 
     @property
     def status(self) -> str:
@@ -190,6 +211,11 @@ class BatchReport:
     def close(self) -> None:
         """重试所有未完清理。参数: 无。返回: None。异常: 首个关闭错误，其他项仍尝试。"""
         first = None
+        if self._publication is not None:
+            try:
+                self._publication.close()
+            except BaseException as error:
+                first = error
         for job in self.jobs:
             if job.recovery is not None:
                 try:
@@ -198,5 +224,7 @@ class BatchReport:
                     # 一项失败不能阻止其他独立任务释放资源；原句柄仍由本报告保留。
                     if first is None:
                         first = error
+                    else:
+                        first.add_note('其他批量任务清理失败：' + str(error))
         if first is not None:
             raise first

chronaxis/batch/process_transport.py

@@ -6,15 +6,14 @@
 
 from dataclasses import replace
 import multiprocessing
-import os
 from pathlib import Path
-import signal
-from threading import Event
+from time import monotonic
 
 from ..planning.plan import AnalysisPlan
 from ..planning.checks import json_value
 from .models import BatchJob, BatchJobResult, CleanupHandle
 from .process_tree import ProcessTree
+from .._batch_worker import worker_main
 
 
 def job_packet(job):
@@ -35,60 +34,23 @@ def restore_job(packet):
     return BatchJob(packet['job_id'], plan)
 
 
-def worker_main(connection):
-    """处理run/cleanup/close命令。参数: 私有管道。返回: None。异常: 断管退出，父进程负责树清理。"""
-    from .runner import _run_job, _diagnostics
-    # Ctrl+C只由调度主进程接收，正在写结果的工作进程继续完整收尾。
-    signal.signal(signal.SIGINT, signal.SIG_IGN)
-    recovery = None
-    try:
-        while True:
-            command = connection.recv()
-            if command[0] == 'close':
-                if recovery is not None:
-                    recovery.close()
-                return
-            if command[0] == 'cleanup':
-                try:
-                    if recovery is not None:
-                        recovery.close()
-                    recovery = None
-                    connection.send(('cleaned', None))
-                except BaseException as error:
-                    connection.send(('cleanup_failed', _diagnostics(error)))
-                continue
-            if recovery is not None:
-                raise RuntimeError('存在未关闭资源的工作进程不能接收新任务')
-            _, packet, directory, backend = command
-            try:
-                job = restore_job(packet)
-                outcome = _run_job(job, Path(directory), backend, Event(), Event())
-            except BaseException as error:
-                outcome = BatchJobResult(packet['job_id'], 'failed',
-                    plan_path=packet.get('path'), error_type=type(error).__name__,
-                    error_message=str(error), error_chain=_diagnostics(error))
-            recovery = outcome.recovery
-            pending = recovery is not None and not recovery.closed
-            # 只发送冻结的纯结果字段；CleanupHandle的原资源必须留在拥有它的进程。
-            connection.send(('result', replace(outcome, recovery=None, worker_pid=os.getpid()), pending))
-    except EOFError:
-        if recovery is not None:
-            recovery.close()
-    finally:
-        connection.close()
-
-
 class ProcessWorker:
     """保存一个可复用工作进程、私有管道及其后代的清理责任。"""
 
-    def __init__(self):
+    def __init__(self, *, fast=False):
         """启动等待命令的spawn进程。参数: 无。返回: 新对象。异常: 启动/树登记失败立即回收。"""
         context = multiprocessing.get_context('spawn')
         self.connection, child = context.Pipe()
-        self.process = context.Process(target=worker_main, args=(child,), daemon=False)
+        self.fast_cancel = context.Event() if fast else None
+        self.cancel_deadline = None
+        self.fast_rows = None
+        args = (child, self.fast_cancel) if fast else (child,)
+        self.process = context.Process(target=worker_main, args=args, daemon=False)
         self.tree = None
         self.closed = False
         self.pending = False
+        self._pipe_lost = False
+        self._stop_requested = False
         try:
             self.process.start()
             self.tree = ProcessTree(self.process.pid)
@@ -107,21 +69,49 @@ class ProcessWorker:
         """发送独立任务。参数: job/目录/后端。返回: None。异常: 转换或通信错误。"""
         self.connection.send(('run', job_packet(job), str(directory), backend))
 
+    def submit_fast(self, job, directory, spec, total):
+        """只传准备完成的文件参数，工作进程不重新解析模板或建立下层进程。"""
+        packet = dict(job_id=job.job_id, spec=spec, total=total,
+                      path=str(job.plan) if isinstance(job.plan, Path) else None)
+        self.connection.send(('fast', packet, str(directory), None))
+
+    def cancel_fast(self):
+        """通知在途文件，协作退出超过五秒才结束本次拥有的进程树。返回是否已强制回收。"""
+        if self.cancel_deadline is None:
+            self.fast_cancel.set()
+            self.cancel_deadline = monotonic() + 5
+        elif monotonic() >= self.cancel_deadline:
+            self._pipe_lost = True
+            self.close()
+            return True
+        return False
+
     def ready(self):
         """查询结果或异常退出。参数: 无。返回: bool。异常: 原管道错误。"""
         try:
             return self.connection.poll() or not self.process.is_alive()
         except (EOFError, OSError) as error:
+            if isinstance(error, (EOFError, BrokenPipeError)):
+                self._pipe_lost = True
             raise ChildProcessError('分析工作进程管道已断开，PID=' + str(self.pid)) from error
 
     def receive(self):
         """取结果并挂远程恢复句柄。参数: 无。返回: BatchJobResult。异常: 进程死亡或协议错误。"""
-        if not self.connection.poll():
-            raise ChildProcessError('分析工作进程异常退出，PID=' + str(self.pid))
         try:
-            kind, result, self.pending = self.connection.recv()
-        except EOFError as error:
+            # Windows 同伴退出时，探测或随后的读取都可能先报告断管。
+            if not self.connection.poll():
+                raise ChildProcessError('分析工作进程异常退出，PID=' + str(self.pid))
+            message = self.connection.recv()
+        except (EOFError, BrokenPipeError) as error:
+            self._pipe_lost = True
             raise ChildProcessError('分析工作进程断开，PID=' + str(self.pid)) from error
+        if len(message) == 4 and getattr(self,'fast_cancel',None) is not None:
+            kind, result, self.pending, self.fast_rows = message
+        else:
+            kind, result, self.pending = message
+        if kind == 'fast_result' and getattr(self,'fast_cancel',None) is not None and isinstance(result,dict):
+            result = BatchJobResult(**result)
+            kind = 'result'
         if kind != 'result' or not isinstance(result, BatchJobResult):
             raise RuntimeError('批量工作进程返回无效结果')
         return replace(result, recovery=CleanupHandle(self) if self.pending else None)
@@ -130,20 +120,36 @@ class ProcessWorker:
         """重试远程清理后关闭进程树。参数: 无。返回: None。异常: 清理失败保留全部所有者。"""
         if self.closed:
             return
-        if self.process.is_alive():
-            if self.pending:
-                self.connection.send(('cleanup',))
-                kind, detail = self.connection.recv()
-                if kind != 'cleaned':
-                    raise RuntimeError('工作进程资源尚未关闭：' + '; '.join(detail))
-                self.pending = False
-            self.connection.send(('close',))
-            self.process.join()
+        if not self._pipe_lost and not self._stop_requested and self.process.is_alive():
+            try:
+                if self.pending:
+                    self.connection.send(('cleanup',))
+                    kind, detail = self.connection.recv()
+                    if kind != 'cleaned':
+                        raise RuntimeError('工作进程资源尚未关闭：' + '; '.join(detail))
+                    self.pending = False
+                self.connection.send(('close',))
+                self._stop_requested = True
+            except (EOFError, BrokenPipeError):
+                self._pipe_lost = True
+        if self._pipe_lost:
+            # 管道可先于进程退出；无法再握手时由父进程先结束本次拥有的树。
+            if not self._stop_requested:
+                if self.tree is not None:
+                    self.tree.close()
+                    self.tree = None
+                elif self.process.is_alive():
+                    self.process.kill()
+                self._stop_requested = True
+            self.process.join(timeout=5)
+            if self.process.is_alive():
+                raise TimeoutError('等待断管工作进程退出超时，PID=' + str(self.pid))
         else:
             self.process.join()
-        # 工作进程已退出后关闭作业，清除故障残余的CAN读取后代。
+        # 正常停止也需关闭作业，清除残余后代；前一步失败时保留所有者供重试。
         if self.tree is not None:
             self.tree.close()
+            self.tree = None
         self.connection.close()
         self.process.close()
-        self.closed = True
+        self.pending, self.closed = False, True

chronaxis/batch/publication.py

@@ -7,16 +7,21 @@
 import json
 from pathlib import Path
 import platform
-from uuid import uuid4
+import tempfile
 from .models import BatchReport
 
 
 def write_batch_report(report: BatchReport) -> Path:
-    """发布固定汇总文件。参数: report实际结果。返回: batch_report.json路径。
+    """发布带本批时间的汇总文件。参数: report实际结果。返回: 实际报告路径。
 
     异常: 类型、只读路径、未支持平台、已有目标或原文件错误；关闭失败不安装正式文件。
     副作用: 只写本批目录的唯一暂存文件，失败不删除任务结果或覆盖已有报告。
     """
+    return _write_batch_report(report, {})
+
+
+def _write_batch_report(report, extra):
+    """先完成可选的 fast 总量计算，再一次发布同一批报告。"""
     if not isinstance(report, BatchReport):
         raise TypeError('需要BatchReport')
     root = report.output_dir.absolute()
@@ -25,17 +30,32 @@ def write_batch_report(report: BatchReport) -> Path:
         raise ValueError('批量报告不能位于RefProjects')
     if platform.system() != 'Windows':
         raise NotImplementedError('批量报告原子发布目前只验收Windows')
-    destination = root / 'batch_report.json'
-    try:
-        destination.lstat()
-    except FileNotFoundError:
-        pass
-    else:
-        raise FileExistsError('批量报告已存在，拒绝覆盖：' + str(destination))
-    temporary = root / ('.batch-report-' + uuid4().hex + '.incomplete.json')
+    from ..results.publication import PublicationNames
+    publication = report._publication or PublicationNames(root, ('batch_report.json',))
+    destination = root / publication.names['batch_report.json']
+    from ..results.owned_directory import directory_identity, remove_owned_directory
+    temporary = identity = None
     # 编码、写入和真实close全部成功才安装；Windows rename在目标已存在时拒绝。
-    with temporary.open('x', encoding='utf-8', newline='') as stream:
-        json.dump(report.to_dict(), stream, ensure_ascii=False, allow_nan=False, indent=2)
-        stream.write('\n')
-    temporary.rename(destination)
-    return destination
+    try:
+        temporary = Path(tempfile.mkdtemp(prefix='.batch-report-', suffix='.incomplete', dir=root))
+        identity = directory_identity(temporary)
+        with (temporary/'batch_report.json').open('x', encoding='utf-8', newline='') as stream:
+            json.dump(dict(report.to_dict(), **extra), stream, ensure_ascii=False, allow_nan=False, indent=2)
+            stream.write('\n')
+        publication.publish(temporary, 'batch_report.json', only=('batch_report.json',))
+        temporary.rmdir()
+        return destination
+    except BaseException as error:
+        if publication.completed:
+            error.published_report_path = destination
+        # 不撤销已完成任务；只清理本次报告临时目录，保留最初的写出错误。
+        try:
+            if temporary is not None and identity is not None:
+                remove_owned_directory(temporary, identity)
+        except BaseException as cleanup:
+            error.add_note('批量报告暂存清理失败：' + str(cleanup))
+        try:
+            publication.close()
+        except BaseException as cleanup:
+            error.add_note('批量命名锁释放失败：' + str(cleanup))
+        raise