mcpywrap 0.4.1__tar.gz → 0.4.2__tar.gz

{mcpywrap-0.4.1 → mcpywrap-0.4.2}/CHANGELOG.md

@@ -1,5 +1,14 @@
 # 更新记录
 
+## 0.4.2
+
+- 新增统一 `runtime input capabilities/observe/run/status/cancel/stop` 与 `mcpy.input`。键盘组合、独立边沿、玩家与单节点 UI 操作共用 JSON steps、动作注册表、排时和清理；单次 key 快捷命令只生成同一份计划。
+- 保留自动/显式时间规划：delay_ms 相对前一步计划结束，wait 从实际执行时等待；完成型动作保持实际持续时间，边沿可独立重叠，提交顺序按列表，不提供模拟 tick 对齐。
+- 显式 windows-sendinput 特殊后端复用同一状态机，操作由会话 worker 持有，支持幂等查询、取消及失败释放。新旧游戏内输入共享互斥；旧入口隐藏但保留原参数、起点、排序和后端行为。
+- 新增后台按键时间线与可选实机脚本；修复 Python 2 会话升级时事件方法绑定，安装源码分段传输而不扩大原请求上限。
+- Skill 和参考文档以“观察 → 提交 → 查询”为唯一日常入口，明确快照、输入/传输 ID、迟到、实际效果与兼容写法边界；bootstrap 按实际帮助/能力发现隐藏兼容入口。
+- Windows 3.9.0.401155、3.10.0.420447 验证独立按键、持键攻击、菜单、UI 修饰键及特殊设备输入。macOS 旧 Python 2 运行包缺可靠单调时钟时明确不支持新计划；原生适配源码不代表 Mac 二进制绑定和实机验收已完成。
+
 ## 0.4.1
 
 - 修复主动停止游戏后，将 Windows 终止退出码误报为异常退出的问题；Qt 调试窗、终端、本地前台运行及网络会话共用停止请求判定。

{mcpywrap-0.4.1 → mcpywrap-0.4.2}/MANIFEST.in

@@ -3,6 +3,7 @@ include docs/releasing.md
 include docs/runtime-debug.md
 include docs/runtime-ui.md docs/runtime-player.md
 include docs/input-sequence.md
+include docs/runtime-input.md
 include docs/local-dependencies.md docs/engine-discovery.md docs/development.md
 include docs/mcs-auth.md
 include docs/code-libraries.md docs/git-dependencies.md docs/qumod.md
@@ -18,6 +19,7 @@ recursive-include native/mcs_auth *.cs *.c *.cer *.json
 recursive-include mcpywrap/mcstudio/bridge_payload *.exe *.dll *.cer *.json
 recursive-include mcpywrap/mcstudio/window_capture *.exe *.json
 recursive-include native/window_capture *.cpp *.h
+recursive-include native/runtime_input *.h *.md *.patch
 prune test
 prune .git
 global-exclude __pycache__ *.py[cod] *.cppconfig *.log

{mcpywrap-0.4.1/mcpywrap.egg-info → mcpywrap-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcpywrap
-Version: 0.4.1
+Version: 0.4.2
 Summary: A wrapper for Minecraft China Edition Addons management
 Author-email: boybook <boybook@easecation.net>
 License-Expression: MIT
@@ -215,11 +215,12 @@ mcpy --project D:\tests\server stop --session <id> --json
 - “启动这个项目，不弹日志界面，检查客户端和服务端的加载日志。”
 - “启动游戏并截图，模拟组合按键移动，检查 F11 输入模式和 F3 调试信息层。”
 
-Agent 通过 CLI 管理项目和操作游戏。连接后用 `runtime install` 一次注入 `mcpy.ui` / `mcpy.player` / `mcpy.api`：UI 支持文字节点观察与操作，玩家层封装移动、转向、攻击、物品使用、吃东西、射箭和带延迟的连续动作。实际支持能力以安装返回结果为准。详见[游戏内 UI 自动化](docs/runtime-ui.md)和[玩家动作与队列](docs/runtime-player.md)。需要补图且不能占用前台时使用 `screenshot --background-only`。Qt 管理与模板界面用于人工操作。
+Agent通过CLI管理项目和操作游戏。0.4.2起只有一条日常输入流程：runtime install → runtime input capabilities/observe → run --file → status/cancel。键盘组合、独立边沿、玩家与单节点UI操作共用JSON steps与生命周期，实际支持以当前会话能力为准，见[统一输入](docs/runtime-input.md)。需要补图且不能占用前台时用screenshot --background-only；Qt管理界面用于人工操作。
 
-严禁业务代码依赖 `mcpy.*`：这些方法仅存在于临时注入的调试会话，正常游戏运行环境不提供它们；业务实现须使用正式 ModSDK 或项目框架。
+严禁业务代码依赖mcpy.*：这些方法只存在于临时注入的调试会话。默认backend=game；原始设备测试显式设置windows-sendinput。旧player/ui、key/mouse/input-sequence入口仍兼容，但从默认帮助隐藏。
+
+时间规划中at_ms可省略，按前一步计划结束加delay_ms编译；真正的实际停顿用wait。Mac旧运行包缺单调时钟时新计划明确不支持，不自动切后端或回退CPU时间。
 
-连续执行统一先生成时间计划，`at_ms` 可省略并按动作时长与 `delay_ms` 自动计算。允许占用游戏前台的 Windows 键鼠快切测试使用 `input-sequence --file <计划.json>`，一次请求返回输入提交时间与实际偏差；后台游戏语义动作继续使用 `runtime player sequence`。详见 [连续动作编排与输入计时](docs/input-sequence.md)。
 常用入口：`mcpy --project <目录> --non-interactive <命令> --json`。
 
 ## 视频录制与提帧

{mcpywrap-0.4.1 → mcpywrap-0.4.2}/README.md

@@ -187,11 +187,12 @@ mcpy --project D:\tests\server stop --session <id> --json
 - “启动这个项目，不弹日志界面，检查客户端和服务端的加载日志。”
 - “启动游戏并截图，模拟组合按键移动，检查 F11 输入模式和 F3 调试信息层。”
 
-Agent 通过 CLI 管理项目和操作游戏。连接后用 `runtime install` 一次注入 `mcpy.ui` / `mcpy.player` / `mcpy.api`：UI 支持文字节点观察与操作，玩家层封装移动、转向、攻击、物品使用、吃东西、射箭和带延迟的连续动作。实际支持能力以安装返回结果为准。详见[游戏内 UI 自动化](docs/runtime-ui.md)和[玩家动作与队列](docs/runtime-player.md)。需要补图且不能占用前台时使用 `screenshot --background-only`。Qt 管理与模板界面用于人工操作。
+Agent通过CLI管理项目和操作游戏。0.4.2起只有一条日常输入流程：runtime install → runtime input capabilities/observe → run --file → status/cancel。键盘组合、独立边沿、玩家与单节点UI操作共用JSON steps与生命周期，实际支持以当前会话能力为准，见[统一输入](docs/runtime-input.md)。需要补图且不能占用前台时用screenshot --background-only；Qt管理界面用于人工操作。
 
-严禁业务代码依赖 `mcpy.*`：这些方法仅存在于临时注入的调试会话，正常游戏运行环境不提供它们；业务实现须使用正式 ModSDK 或项目框架。
+严禁业务代码依赖mcpy.*：这些方法只存在于临时注入的调试会话。默认backend=game；原始设备测试显式设置windows-sendinput。旧player/ui、key/mouse/input-sequence入口仍兼容，但从默认帮助隐藏。
+
+时间规划中at_ms可省略，按前一步计划结束加delay_ms编译；真正的实际停顿用wait。Mac旧运行包缺单调时钟时新计划明确不支持，不自动切后端或回退CPU时间。
 
-连续执行统一先生成时间计划，`at_ms` 可省略并按动作时长与 `delay_ms` 自动计算。允许占用游戏前台的 Windows 键鼠快切测试使用 `input-sequence --file <计划.json>`，一次请求返回输入提交时间与实际偏差；后台游戏语义动作继续使用 `runtime player sequence`。详见 [连续动作编排与输入计时](docs/input-sequence.md)。
 常用入口：`mcpy --project <目录> --non-interactive <命令> --json`。
 
 ## 视频录制与提帧

mcpywrap-0.4.2/docs/runtime-input.md

@@ -0,0 +1,15 @@
+# 统一输入实现
+
+Agent 的推荐入口是 `runtime input observe → run → status/cancel`；公开协议与示例见 [统一输入](../skills/mcpywrap/references/runtime-input.md)。单键快捷命令生成同一JSON计划，默认后端game，设备测试显式选择windows-sendinput。
+
+`input_plan.py` 保存动作注册表、集中键名映射、字段验证、规范化与限制。能力查询、CLI帮助与schema均从注册表生成；不在客户端、远程和游戏中维护不同参数表。输入源码按原有32KiB上限分段暂存，全部确认后才安装。
+
+`input_executor.py` 是两后端共用的有界状态机：先编译绝对计划时刻，完成型动作等待自身结束，瞬时边沿保留计划持有集合，wait保留实际等待。调度器不改变旧sequence的计划语义，也不把动态目标或完成依赖平铺成静态边沿。
+
+游戏适配复用既有玩家/UI客户端路径，增加新旧入口互斥。UI单节点操作保持快照校验，修饰键在动作前按下、动作结束后释放；菜单键盘不再受player的HUD限制，界面切换仍停止后续计划。玩家语义输入与原始设备输入路径分别记录。
+
+Windows适配在会话worker中保留状态与幂等历史，单个调度线程推进操作；远程input端点只传参数。统一游戏控制层预留防止新旧游戏写请求插入设备计划；已持有的系统键或修饰键拒绝接管。未知释放保持busy，支持stop重试，不扩大为多请求共享输入。
+
+原生Mac时钟primitive和启动器源码补丁在 `native/runtime_input`。旧运行包缺少经过确认的Python单调时钟时，能力明确关闭；实际Apple Silicon的二进制结构规则、编译和实机验收必须单独完成，不以Windows测试代替。原始pointer/text尚未验证的游戏后端能力保持不支持。
+
+验证采用假时钟检查时序、调用顺序、部分失败、取消、幂等和快照；可选实机脚本覆盖真实客户端与服务端读回。旧入口不改变其修饰键排序、时间原点或输入后端；仅从默认发现入口隐藏，兼容参考保留。

{mcpywrap-0.4.1 → mcpywrap-0.4.2}/docs/runtime-player.md

@@ -6,6 +6,8 @@
 
 日常 API、默认时长、坐标/槽位约定、连续计划示例及失败恢复统一维护在 [Skill 玩家操作说明](../skills/mcpywrap/references/runtime-player.md)，主 Skill 直接列出了常用方法，不要求 Agent 自行检索 ModSDK。
 
+全部输入入口的键名、别名、组合/边沿写法与平台兼容见 [按键写法与兼容对照](../skills/mcpywrap/references/input-writing.md)。
+
 ## 实现边界
 
 - 公共 ModSDK 用于状态读取、朝向、移动向量锁定、跳跃。内部 `localplayermodule` 用于真实客户端攻击、选槽、使用物品、挖掘和释放，按实际函数是否存在报告能力，不按引擎版本号限制。接口缺失或调用异常会返回引擎版本与兼容性提示。
@@ -28,6 +30,12 @@
 
 ## 验证
 
+独立按键重叠使用新增 `runtime player timeline` / `mcpy.player.timeline(plan)`，公开契约见 [后台按键时间线](../skills/mcpywrap/references/runtime-key-timeline.md)。同一时刻严格遵循列表顺序，不采用旧 key 的修饰键排序；默认迟到继续并记录，可显式设置 max_lateness 中止。每个计划独占已有写操作槽位，取消/异常只释放本计划持有的键，失败释放可用 stop 重试。接口通过同一客户端 Python 通道，原 sequence 保持串行。
+
+统一安装源码超过单条 32 KiB 限额时分段暂存，确认各段后才执行安装；暂存不注入部分控制器。查询及业务包不依赖暂存模块，不扩大原传输上限。输入消费阶段、暂停期间释放和人工输入归属均不作额外保证，不把脚本回调计数包装为模拟 tick。
+
+`tests/test_runtime_key_timeline.py` 用假时钟验证边沿顺序、独立释放、迟到策略、幂等、互斥及失败清理。`tests/manual_runtime_key_timeline.py` 是显式可选的 Windows 实机验收，三次重复重叠配方，并检查两种修饰键顺序、取消和菜单释放；保存真实跳跃、持续移动及后台观测证据，不进入默认测试或正常启动。
+
 `tests/test_runtime_player.py` 使用有时序的引擎适配器验证：按键逆序释放、移动/疾跑恢复、目标变化与越距拒绝、食物 False 返回但已开始使用、弓蓄力松开、队列延迟、预检失败、步骤断言、取消、重复请求和调用者修改原计划后的隔离。
 
 实机验收脚本为 `tests/manual_runtime_player.py`。先准备独立生存世界、未满的饥饿值、快捷栏食物/普通弓及箭，再运行 `--project <项目> --session <sid> --food-slot 3 --bow-slot 4 --output <新JSON> --require-background`。脚本通过公开 CLI 提交并验证队列，消耗一份食物和一支箭，恢复原朝向和选槽；不会创建物品、改变游戏模式或停止传入会话。

{mcpywrap-0.4.1 → mcpywrap-0.4.2}/mcpywrap/__init__.py

@@ -1,4 +1,4 @@
 # -*- coding: utf-8 -*-
 """mcpywrap - 我的世界中国版 Addon 开发依赖、构建与游戏测试工具。"""
 
-__version__ = '0.4.1'
+__version__ = '0.4.2'

{mcpywrap-0.4.1 → mcpywrap-0.4.2}/mcpywrap/cli.py

@@ -73,6 +73,7 @@ for old_command in (py_cmd, reload_cmd):
     cli.add_command(alias)
 
 from .commands.desktop_cmd import screenshot_cmd, key_cmd, mouse_cmd, input_sequence_cmd
+key_cmd.hidden = mouse_cmd.hidden = input_sequence_cmd.hidden = True
 from .commands.serve_cmd import serve_cmd
 cli.add_command(screenshot_cmd, 'screenshot')
 cli.add_command(key_cmd, 'key')

{mcpywrap-0.4.1 → mcpywrap-0.4.2}/mcpywrap/commands/runtime_cmd.py

@@ -121,8 +121,13 @@ runtime_cmd.add_command(reload_cmd)
 runtime_cmd.add_command(watch_cmd)
 
 from .runtime_ui_cmd import ui_cmd
+ui_cmd.hidden = True
 runtime_cmd.add_command(ui_cmd)
 
 from .runtime_player_cmd import player_cmd, install_cmd as install_runtime_cmd
+player_cmd.hidden = True
 runtime_cmd.add_command(player_cmd)
 runtime_cmd.add_command(install_runtime_cmd, 'install')
+
+from .runtime_input_cmd import input_cmd
+runtime_cmd.add_command(input_cmd)

mcpywrap-0.4.2/mcpywrap/commands/runtime_input_cmd.py

@@ -0,0 +1,86 @@
+"""观察、统一 JSON 计划与操作生命周期；快捷键只生成同一协议。"""
+import json
+from pathlib import Path
+import click
+from .runtime_ui_cmd import UICommand, session_option
+from ..command_context import project_dir
+from ..input_plan import INPUT_ACTIONS, input_key_plan, normalize_input_plan
+
+
+def perform(session, action, **parameters):
+    from ..mcstudio.unified_input import execute
+    return execute(project_dir(), session, action, {k: v for k, v in parameters.items() if v is not None})
+
+
+@click.group(name='input', epilog='动作由同一注册表定义：'+', '.join(INPUT_ACTIONS))
+def input_cmd():
+    """观察当前状态 → run 提交统一计划 → status/cancel 查询或停止；默认游戏内执行。"""
+
+
+@input_cmd.command(cls=UICommand, name='capabilities')
+@session_option
+def capabilities_cmd(session):
+    """只读查询动作参数、时钟、后端和限制，不自动安装。"""
+    return perform(session, 'capabilities')
+
+
+@input_cmd.command(cls=UICommand, name='observe')
+@session_option
+@click.option('--view', type=click.Choice(['auto', 'player', 'ui']), default='auto')
+@click.option('--query', help='UI 观察按名称或路径筛选')
+@click.option('--limit', type=click.IntRange(1, 160), default=80)
+@click.option('--offset', type=click.IntRange(0), default=0)
+@click.option('--details', is_flag=True)
+def observe_cmd(session, **parameters):
+    """按当前画面返回快照、目标和可执行动作；页面改变后重新观察。"""
+    return perform(session, 'observe', **parameters)
+
+
+@input_cmd.command(cls=UICommand, name='run')
+@session_option
+@click.option('--file', 'filename', required=True, type=click.Path(exists=True, dir_okay=False))
+@click.option('--request-id', help='32 位小写十六进制幂等 ID；未知结果查原 ID')
+def run_cmd(session, filename, request_id):
+    """一次提交 JSON steps；自动/显式排时共用协议，不选择 sequence/timeline。"""
+    raw = Path(filename).read_bytes()
+    if len(raw) > 65536:
+        raise click.UsageError('输入文件超过 64 KiB；规范化计划上限为 16 KiB')
+    try:
+        plan = normalize_input_plan(json.loads(raw.decode('utf-8-sig')))
+    except (ValueError, UnicodeError) as error:
+        raise click.UsageError(str(error)) from None
+    return perform(session, 'run', plan=plan, request_id=request_id)
+
+
+@input_cmd.command(cls=UICommand, name='key')
+@session_option
+@click.argument('keys')
+@click.option('--duration-ms', type=click.IntRange(20, 10000), default=80)
+@click.option('--request-id')
+def key_cmd(session, keys, duration_ms, request_id):
+    """人工快捷命令，按声明顺序生成 key 计划，再调用同一个 run。"""
+    return perform(session, 'run', plan=input_key_plan(keys, duration_ms), request_id=request_id)
+
+
+@input_cmd.command(cls=UICommand, name='status')
+@session_option
+@click.option('--operation')
+@click.option('--details', is_flag=True)
+def status_cmd(session, operation, details):
+    """查询 operation_id；details 返回规范化计划和实际/清理日志。"""
+    return perform(session, 'status', operation=operation, details=details)
+
+
+@input_cmd.command(cls=UICommand, name='cancel')
+@session_option
+@click.option('--operation', required=True)
+def cancel_cmd(session, operation):
+    """取消原操作并释放其输入；不能以重跑计划代替清理。"""
+    return perform(session, 'cancel', operation=operation)
+
+
+@input_cmd.command(cls=UICommand, name='stop')
+@session_option
+def stop_cmd(session):
+    """停止本控制层输入，不退出游戏。"""
+    return perform(session, 'stop')

{mcpywrap-0.4.1 → mcpywrap-0.4.2}/mcpywrap/commands/runtime_player_cmd.py

@@ -24,7 +24,7 @@ def player_cmd():
 @player_cmd.command(cls=UICommand, name='install')
 @session_option
 def install_cmd(session):
-    """一次注入 mcpy.ui、mcpy.player、mcpy.api。"""
+    """注入统一 mcpy.input 及兼容的 UI、玩家和客户端 API。"""
     return perform(session, 'install')
 
 
@@ -155,6 +155,19 @@ def sequence_cmd(session, request_id, steps, filename):
     return perform(session,'sequence',steps=plan,request_id=request_id)
 
 
+@player_cmd.command(cls=UICommand, name='timeline')
+@action_options
+@click.option('--file', 'filename', required=True, type=click.Path(exists=True, dir_okay=False),
+              help='调用端 UTF-8 JSON 按键边沿计划；同一时刻严格按列表顺序')
+def timeline_cmd(session, filename, request_id):
+    """一次提交后台按键时间线；迟到默认继续并记录，不提供 tick 对齐。"""
+    try:
+        plan = json.loads(Path(filename).read_text(encoding='utf-8-sig'))
+    except ValueError:
+        raise click.UsageError('--file 必须是合法的 UTF-8 JSON 计划') from None
+    return perform(session, 'timeline', plan=plan, request_id=request_id)
+
+
 @player_cmd.command(cls=UICommand, name='status')
 @session_option
 @click.option('--operation')

mcpywrap-0.4.2/mcpywrap/input_executor.py

@@ -0,0 +1,246 @@
+# coding: utf-8
+"""统一计划状态机；后端负责时钟、调度和提交，状态机不直接依赖引擎。"""
+from __future__ import unicode_literals
+import json
+import threading
+import uuid
+
+try:
+    normalize_input_plan
+except NameError:
+    from .input_plan import (normalize_input_plan, input_signature, input_require, InputPlanError,
+                             INPUT_LIMITS, INPUT_ACTIONS, input_key_plan)
+
+
+class InputExecutor(object):
+    def __init__(self, adapter):
+        self.adapter = adapter
+        self.active = None
+        self.operations, self.order = {}, []
+        self.lock = threading.RLock()
+
+    def _view(self, op, details=False):
+        if op is None: return None
+        value = {k: v for k, v in op.items() if not k.startswith('_')}
+        if not details:
+            for key in ('plan', 'steps', 'events', 'cleanup_events'): value.pop(key, None)
+        return json.loads(json.dumps(value, ensure_ascii=True, allow_nan=False))
+
+    def _error(self, op, error):
+        try: message = unicode(error)
+        except NameError: message = str(error)
+        if len(message) > 512: op['logs_truncated'] = True
+        return message[:512]
+
+    def _log(self, op, family, row):
+        size = len(input_signature(row))
+        op[family].append(row); op['_log_bytes'] += size
+        while op['_log_bytes'] > INPUT_LIMITS['log_bytes']:
+            target = next(key for key in ('cleanup_events', 'events', 'steps') if op[key])
+            old = op[target].pop(0)
+            op['_log_bytes'] -= len(input_signature(old))
+            op[target+'_dropped'] += 1
+            op['logs_truncated'] = True
+
+    def run(self, plan, request_id=None):
+        normalized = normalize_input_plan(plan)
+        request_id = request_id or uuid.uuid4().hex
+        input_require(isinstance(request_id, str) or isinstance(request_id, type(u'')), 'invalid_request_id', 'request_id 必须是字符串')
+        input_require(len(request_id) == 32 and all(c in '0123456789abcdef' for c in request_id),
+                      'invalid_request_id', 'request_id 必须是 32 位小写十六进制')
+        signature = input_signature(normalized)
+        with self.lock:
+            previous = self.operations.get(request_id)
+            if previous is not None:
+                input_require(previous['_signature'] == signature, 'request_conflict', 'request_id 已用于不同计划')
+                return self._view(previous, True)
+            input_require(self.active is None, 'busy', '当前输入未结束或释放未确认，查询 status 或 stop')
+            self.adapter.ready()
+            bindings = self.adapter.validate(normalized)
+            op = {'ok': True, 'operation_id': request_id, 'request_id': request_id, 'state': 'pending',
+                  'backend': normalized['backend'], 'clock': 'monotonic_ms', 'clock_source': self.adapter.clock_source,
+                  'effect_verified': False, 'released': False, 'started': False, 'index': 0, 'count': len(normalized['steps']),
+                  'plan': normalized, 'steps': [], 'events': [], 'cleanup_events': [], 'held_keys': [],
+                  'unconfirmed_release_keys': [], 'logs_truncated': False,
+                  'steps_dropped': 0, 'events_dropped': 0, 'cleanup_events_dropped': 0,
+                  '_signature': signature, '_bindings': bindings, '_held': [], '_stage': None,
+                  '_started': None, '_deadline': self.adapter.clock()+INPUT_LIMITS['execution_ms']/1000.,
+                  '_log_bytes': 0, '_finishing': False}
+            self.operations[request_id] = op; self.order.append(request_id)
+            while len(self.order) > INPUT_LIMITS['history']:
+                self.operations.pop(self.order.pop(0), None)
+            self.active = op
+            self._schedule(op, 0.)
+            return self._view(op, True)
+
+    def key(self, keys, duration_ms=80, request_id=None):
+        return self.run(input_key_plan(keys, duration_ms), request_id)
+
+    def status(self, operation=None, details=False):
+        with self.lock:
+            if operation is None:
+                return {'ok': True, 'active': self._view(self.active, details),
+                        'last_operation': self._view(self.operations.get(self.order[-1]) if self.order else None, details)}
+            input_require(operation in self.operations, 'operation_not_found', '记录不存在或已淘汰，不代表从未执行')
+            return self._view(self.operations[operation], details)
+
+    def cancel(self, operation):
+        with self.lock:
+            input_require(operation in self.operations, 'operation_not_found', '操作记录不存在')
+            op = self.operations[operation]
+            if self.active is op: self._finish(op, 'cancelled', 'requested_cancel')
+            return self._view(op)
+
+    def stop(self):
+        with self.lock:
+            if self.active is not None: self._finish(self.active, 'cancelled', 'requested_stop')
+            return dict(self.status(), ok=self.active is None)
+
+    def relative_ms(self, op):
+        return None if op['_started'] is None else (self.adapter.clock()-op['_started'])*1000.
+
+    def _schedule(self, op, seconds):
+        try:
+            self.adapter.schedule(seconds, lambda: self._tick(op))
+        except Exception as error:
+            self._fail(op, error)
+
+    def _fail(self, op, error):
+        op['error'] = self._error(op, error)
+        stage = op.get('_stage')
+        if stage is not None and not stage.get('failure_logged'):
+            self._log(op, 'steps', dict(index=op['index'], action=stage['step']['action'],
+                at_ms=stage['step']['at_ms'], started_ms=stage['started_ms'], finished_ms=self.relative_ms(op),
+                result={'state': 'failed', 'code': getattr(error, 'code', 'input_error'), 'error': op['error']},
+                input_path=stage.get('input_path', self.adapter.input_path)))
+            stage['failure_logged'] = True
+        self._finish(op, 'failed', getattr(error, 'code', 'input_error'))
+
+    def _guard(self, op):
+        input_require(self.adapter.clock() < op['_deadline'], 'input_timeout', '输入超过 125 秒执行上限')
+        self.adapter.guard(op)
+
+    def _tick(self, op):
+        with self.lock:
+            if self.active is not op or op['state'] != 'pending': return
+            try:
+                if not op['started']:
+                    self.adapter.prepare(op)
+                    self._guard(op)
+                    op['_started'] = self.adapter.clock()
+                    op.update(started=True, started_at=op['_started'])
+                while self.active is op and op['state'] == 'pending':
+                    self._guard(op)
+                    if op['_stage'] is not None:
+                        stage = op['_stage']
+                        if not self._poll(op, stage):
+                            self._schedule(op, .01)
+                            return
+                        op['_stage'] = None
+                        if self.active is not op or op['state'] != 'pending': return
+                        self._log(op, 'steps', dict(index=op['index'], action=stage['step']['action'],
+                            at_ms=stage['step']['at_ms'], started_ms=stage['started_ms'],
+                            finished_ms=self.relative_ms(op), result=stage.get('result', {}),
+                            input_path=stage.get('input_path', self.adapter.input_path)))
+                        op['index'] += 1
+                    if op['index'] >= op['count']:
+                        self._finish(op, 'completed')
+                        return
+                    step = op['plan']['steps'][op['index']]
+                    actual = self.relative_ms(op)
+                    if actual < step['at_ms']:
+                        self._schedule(op, max(.001, min(.05, (step['at_ms']-actual)/1000.)))
+                        return
+                    maximum = op['plan']['max_lateness_ms']
+                    input_require(maximum is None or actual-step['at_ms'] <= maximum,
+                                  'deadline_missed', '步骤迟到超过 max_lateness_ms')
+                    stage = {'step': step, 'started_ms': actual, 'started_at': self.adapter.clock(), 'kind': 'instant'}
+                    op['_stage'] = stage
+                    self._begin(op, stage)
+            except Exception as error:
+                self._fail(op, error)
+
+    def _begin(self, op, stage):
+        step = stage['step']; name = step['action']
+        if name == 'wait':
+            stage.update(kind='duration', until=stage['started_at']+step['duration_ms']/1000., input_path='scheduler')
+        elif name == 'key':
+            stage['kind'] = 'key'
+            stage['keys'] = list(step['keys'])
+            for key in step['keys']:
+                self.edge(op, 'key', key, True)
+                if self.active is not op or op['state'] != 'pending': return
+            stage['until'] = stage['started_at']+step['duration_ms']/1000.
+        elif name in ('key_down', 'key_up'):
+            self.edge(op, 'key', step['key'], name == 'key_down')
+        elif name in ('pointer.down', 'pointer.up'):
+            self.edge(op, 'pointer', step['button'], name == 'pointer.down')
+        else:
+            self.adapter.begin(op, stage)
+
+    def _poll(self, op, stage):
+        if stage['kind'] in ('duration', 'key'):
+            if self.adapter.clock() < stage['until']: return False
+            if stage['kind'] == 'key':
+                for key in reversed(stage['keys']): self.edge(op, 'key', key, False)
+            return True
+        if stage['kind'] == 'instant': return True
+        return self.adapter.poll(op, stage)
+
+    def edge(self, op, kind, key, down, cleanup=False):
+        binding = self.adapter.binding(op, kind, key)
+        identity = self.adapter.identity(kind, binding)
+        owned = next((row for row in op['_held'] if row['identity'] == identity), None)
+        input_require(owned is None if down else owned is not None, 'input_conflict', '输入边沿与本计划持有状态冲突')
+        if down:
+            owned = {'kind': kind, 'key': key, 'binding': binding, 'identity': identity, 'index': op['index']}
+            op['_held'].append(owned)
+            self._held(op)
+        row = {'index': op['index'], 'action': kind+('_down' if down else '_up'), 'key': key,
+               'started_ms': self.relative_ms(op), 'accepted': None, 'input_path': self.adapter.input_path}
+        if cleanup: row['release_of_index'] = owned['index']
+        else:
+            row['at_ms'] = op['plan']['steps'][op['index']]['at_ms']
+            row['lateness_ms'] = max(0., row['started_ms']-row['at_ms'])
+        try:
+            accepted = self.adapter.send(kind, binding, down)
+            row['accepted'] = accepted
+            row.update(getattr(self.adapter, 'last_send', {}))
+            input_require(accepted is True, 'release_failed' if not down else 'input_rejected', '输入接口未确认提交')
+            if not down and owned in op['_held']:
+                op['_held'].remove(owned)
+                self._held(op)
+        except Exception as error:
+            row['error'] = self._error(op, error)
+            raise
+        finally:
+            row.update(finished_ms=self.relative_ms(op), held_keys=list(op['held_keys']))
+            self._log(op, 'cleanup_events' if cleanup else 'events', row)
+
+    @staticmethod
+    def _held(op):
+        op['held_keys'] = [row['key'] if row['kind'] == 'key' else 'pointer:'+row['key'] for row in op['_held']]
+
+    def _finish(self, op, state, code=None):
+        if op['_finishing']: return
+        op['_finishing'] = True
+        if op['state'] == 'pending':
+            op['_terminal'] = state
+            if code: op['code'] = code
+        op['state'] = op.get('_terminal', state)
+        failures = []
+        try:
+            self.adapter.cleanup(op)
+        except Exception as error:
+            failures.append('action')
+            op['cleanup_error'] = self._error(op, error)
+        for row in reversed(list(op['_held'])):
+            try: self.edge(op, row['kind'], row['key'], False, cleanup=True)
+            except Exception as error:
+                op['cleanup_error'] = self._error(op, error)
+        op['unconfirmed_release_keys'] = list(op['held_keys'])+failures
+        op['released'] = not op['unconfirmed_release_keys']
+        op.update(ok=op['_terminal'] in ('completed', 'cancelled') and op['released'],
+                  state=op['_terminal'] if op['released'] else 'unknown', finished_ms=self.relative_ms(op), _finishing=False)
+        if op['released'] and self.active is op: self.active = None
+        self.adapter.finished(op)