From a4d449ad486534bf45835a800cdf190a49a1255c Mon Sep 17 00:00:00 2001
From: wangdequan <wangdequan@meswork.com>
Date: Wed, 17 Jun 2026 19:45:51 +0800
Subject: [PATCH] =?UTF-8?q?=E5=AE=8C=E5=96=84=E8=99=9A=E6=8B=9FHAL?=
 =?UTF-8?q?=E4=BB=BF=E7=9C=9F=E6=9B=BF=E4=BB=A3=E8=83=BD=E5=8A=9B?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 PROJECT_COMPLETION_TRACKER.md                 |    6 +-
 test17.txt                                    |  213 ++
 text16.txt                                    |  254 ++
 wasm-port/docs/project-release-handoff.md     |   26 +
 .../linuxcnc_wrap/linuxcnc_interp_wasm.cpp    |  109 +
 wasm-port/runtime/sdk/README.md               |  100 +
 wasm-port/runtime/sdk/src/index.js            |   37 +
 wasm-port/runtime/sdk/src/linuxcnc-hal.js     | 2315 +++++++++++++++++
 wasm-port/runtime/sdk/src/linuxcnc-interp.js  |   64 +
 wasm-port/runtime/ui/simulation/index.html    | 1506 +++++++++--
 .../runtime/ui/simulation/simulation-app.js   |  117 +-
 .../browser/real_simulation_page_smoke.html   |  156 +-
 .../verify_project_release_handoff_docs.mjs   |   26 +
 .../tests/sdk/node/verify_sdk_surface.mjs     |  245 ++
 .../node/verify_real_simulation_programs.mjs  |   89 +-
 .../tests/wasm/node/verify_interp_wasm.mjs    |   42 +
 wasm-port/tools/build_wasm_core.sh            |    2 +-
 17 files changed, 5005 insertions(+), 302 deletions(-)
 create mode 100644 test17.txt
 create mode 100644 wasm-port/runtime/sdk/src/linuxcnc-hal.js

diff --git a/PROJECT_COMPLETION_TRACKER.md b/PROJECT_COMPLETION_TRACKER.md
index 10cf4c8..f7b1a85 100644
--- a/PROJECT_COMPLETION_TRACKER.md
+++ b/PROJECT_COMPLETION_TRACKER.md
@@ -40,8 +40,8 @@ The project is complete for the current scope when all of the following are true
 | --- | --- | --- |
 | LinuxCNC semantic boundary | Stable | JS/browser remains glue, staging, OPFS, WASM/browser boundary, docs, and tests only. |
 | Real browser simulation priority | Active first priority | Future batches should prioritize the real UI/browser CNC simulation page, with visible machine/session loading, G-code program state, LinuxCNC-backed interpreter execution, machine readiness/status panels, toolpath/preview rendering from LinuxCNC-produced output or validated runtime events, and browser smoke coverage. First entry point: `wasm-port/runtime/ui/simulation/index.html`; gate: `wasm-port/tests/browser/verify_real_simulation_browser.sh`. See `wasm-port/docs/real-browser-simulation-priority.md`. |
-| Real browser simulation page | MVP active | `runtime/ui/simulation/index.html` loads in Chromium, exposes a selector for multiple LinuxCNC-backed test programs, runs operator-provided G-code text/files through interpreter WASM or through the loaded session INI path when a machine session is staged and enabled, includes an editable G-code pane with Run Editor Text plus OPFS save/load program persistence, shows OPFS machine/session readiness, loaded WASM session paths, a Use Session toggle, standalone/session-backed run mode, and compact run summary, and includes reset/step/play/finish playback over LinuxCNC canonical motion events. It highlights active G-code and motion rows, updates live axis readout, exposes DRO/modal state APIs, moves the toolhead, grows the executed SVG toolpath, and supports fit/zoom/reset preview controls. Current built-in program set covers square contour, Z pocket contour, incremental loop, G2/G3 arcs, and G81 drilling. |
-| AXIS-style simulation shell | Phase 2/3/4/5 partial | `runtime/ui/simulation/index.html` now uses an AXIS-inspired titlebar, menubar, toolbar, Manual/MDI tabs, Preview/DRO tabs, G-code pane, machine-state pane, and status bar while preserving current LinuxCNC-backed execution and playback APIs. Browser smoke verifies shell regions, tab switching, toolbar playback, editor/file/OPFS program execution, blocked/ready machine-session readiness, ready session staging into WASM, loaded-session editor and OPFS execution with `runProgramWithIni()`, standalone fallback through the Use Session toggle, run-mode and run-summary UI/API state, DRO/modal state, preview zoom/reset controls, and existing program execution. |
+| Real browser simulation page | MVP active | `runtime/ui/simulation/index.html` loads in Chromium, exposes a selector for multiple LinuxCNC-backed test programs, runs operator-provided G-code text/files through interpreter WASM or through the loaded session INI path when a machine session is staged and enabled, includes an editable G-code pane with Run Editor Text plus OPFS save/load program persistence, shows OPFS machine/session readiness, loaded WASM session paths, a Use Session toggle, standalone/session-backed run mode, compact run summary, and browser virtual HAL state for AXIS manual controls. It highlights active G-code and motion rows, updates live axis readout, exposes DRO/modal/virtual-HAL state APIs, moves the toolhead, grows the executed SVG/Three.js toolpath, and supports fit/zoom/reset/view-mode preview controls. Current built-in program set covers square contour, Z pocket contour, incremental loop, G2/G3 arcs, and G81 drilling. |
+| AXIS-style simulation shell | Phase 2/3/4/5 partial | `runtime/ui/simulation/index.html` now uses an AXIS-inspired titlebar, menubar, toolbar, Manual/MDI tabs, Preview/DRO tabs, G-code pane, machine-state pane, and status bar while preserving current LinuxCNC-backed execution and playback APIs. Browser smoke verifies shell regions, tab switching, toolbar playback, editor/file/OPFS program execution, blocked/ready machine-session readiness, ready session staging into WASM, loaded-session editor and OPFS execution with `runProgramWithIni()`, standalone fallback through the Use Session toggle, run-mode and run-summary UI/API state, DRO/modal state, Three.js preview controls, browser virtual HAL F1/F2/Ctrl-Home/jog/spindle/coolant controls, and existing program execution. |
 | Simulation test program library | Active | Built-in browser simulation programs live in `wasm-port/runtime/ui/simulation/programs/`, one module per program, exported through `programs/index.js`; `verify_real_simulation_programs.sh` checks directory-backed inventory, IDs, defaults, and playback contracts. |
 | Vendor/source guard | Stable | `verify_vendor_sync.sh` and standalone semantic guard are required every batch. |
 | Interpreter WASM smoke | Stable | `interp_wasm_node_smoke=ok`. |
@@ -49,7 +49,7 @@ The project is complete for the current scope when all of the following are true
 | Native nc_files baseline | Stable | Last recorded Layer 1: `total 107`, `pass 101`, `expected_fail 6`, `unexpected_fail 0`. |
 | Native sim configs baseline | Stable | Last recorded Layer 2: `total 159`, `pass 151`, `expected_fail 8`, `unexpected_fail 0`. |
 | OPFS/session persistence | Stable for current scope | Browser smoke passes, SDK re-exports OPFS/session helpers including `readMachineSessionReadiness()` and `createMachineSessionPersistenceSummary()`, the UI exposes `getMachineSessionPersistenceSummary()`, and `docs/opfs-session-persistence.md` defines the project-level release gate. |
-| SDK/API surface | Stable for current scope | SDK re-exports core, OPFS/session readiness/load helpers, sim-config staging, project release gate manifest/result matrix/action-plan/readiness summary view-model, project batch acceptance capability matrix/workflow/summary/action-plan/checklist/report validation summary/action-plan, JSON workflow, URL workflow helpers, and artifact writer/validator gate, project release readiness report/artifact JSON workflow/artifact URL workflow summary/action-plan/artifact validation summary/action-plan plus URL loading workflow, INI panel entry/launcher/control-page/shell/workflow overview helpers including release artifact JSON and URL workflow summary/action-plan/render-state DOM mount helpers, validation action-plan render/mount helpers, URL workflow action-plan, and gate execution summary render/mount helpers, the session readiness workflow report, and the shell API surface inventory with dedicated Node smokes. |
+| SDK/API surface | Stable for current scope | SDK re-exports core, project-level virtual HAL state/action/DRO/limits-home/machine-status/WASM-bridge helpers, virtual HAL pin inventory, bridge readiness/action-plan, project report, interpreter apply adapter, OPFS/session readiness/load helpers, sim-config staging, project release gate manifest/result matrix/action-plan/readiness summary view-model, project batch acceptance capability matrix/workflow/summary/action-plan/checklist/report validation summary/action-plan, JSON workflow, URL workflow helpers, and artifact writer/validator gate, project release readiness report/artifact JSON workflow/artifact URL workflow summary/action-plan/artifact validation summary/action-plan plus URL loading workflow, INI panel entry/launcher/control-page/shell/workflow overview helpers including release artifact JSON and URL workflow summary/action-plan/render-state DOM mount helpers, validation action-plan render/mount helpers, URL workflow action-plan, and gate execution summary render/mount helpers, the session readiness workflow report, and the shell API surface inventory with dedicated Node smokes. |
 | Browser/UI workflow | Stable for current scope | Workflow overview embedding mount DOM closure is complete, and INI panel session workflows plus read-only control/shell handoff expose, render, mount, fetch, validate, summarize, action-plan, and report OPFS/session readiness, OPFS/session persistence summary, release readiness artifact JSON/URL workflows, validation/rendering/URL workflow summaries/action-plans/gate execution summaries, and API surface inventory before loading or reading WASM session state. |
 | Workflow overview embedding | Stable for current scope | Report/display/render, DOM contract/readiness/renderer, mount result/display/render, mount DOM contract/readiness/renderer/wrapper exist. |
 | Host/runtime boundary proof | Stable blocked state | Host smoke passes; runtime families remain blocked and `docs/host-runtime-boundary-handoff.md` records host readiness, promotion blockers, dispatch, and evidence gates. |
diff --git a/test17.txt b/test17.txt
new file mode 100644
index 0000000..6259186
--- /dev/null
+++ b/test17.txt
@@ -0,0 +1,213 @@
+项目整体完成情况与后续执行铁律
+
+生成时间：2026-06-17 CST
+
+本文件接替 `text16.txt`，作为后续继续推进的接续文件。后续工作优先参考
+`test17.txt`；除非明确要求审计旧记录，不再回到 `text1` 到 `text16` 扩展进度。
+
+一、当前核心完成情况
+
+1. LinuxCNC-backed WASM 核心仍是 CNC 语义来源。
+
+- G-code 执行、canonical event、interpreter/planner 语义仍来自 vendored LinuxCNC
+  C/C++ 源码编译出的 WASM；
+- Browser/UI/SDK 只做 host boundary、文件装载、OPFS/session、virtual HAL runtime、
+  仿真状态桥、测试胶水和报告；
+- 不在 JS 中重写 G-code 解释器、planner、kinematics、tool/parameter 语义。
+
+2. Web 数控仿真系统已经具备完整虚拟 HAL 闭环。
+
+当前 virtual HAL 已提升为项目级 SDK/API 能力，并接入 browser simulation 页面。
+
+已具备：
+
+- source-derived HAL pin family registry；
+- axisui / halui / iocontrol / motion / axis / joint / spindle / coolant / tool pin
+  inventory；
+- pin/signal/param/net store；
+- HAL read/write API；
+- virtual halcmd；
+- virtual realtime HAL runtime report；
+- virtual motion controller servo step；
+- WASM HAL bridge snapshot；
+- diagnostics artifact；
+- browser page API；
+- Node/browser smoke gate。
+
+3. 仿真级 LinuxCNC realtime HAL / halcmd / motion controller 已由 virtual HAL 替代。
+
+已新增/确认的核心 API：
+
+- `VIRTUAL_HAL_SIMULATION_REPLACEMENT_TARGETS`：
+  - `linuxcnc-realtime-hal`；
+  - `halcmd`；
+  - `motion-controller`；
+- `VIRTUAL_HAL_SIMULATION_RUNTIME_CAPABILITIES`：
+  - `realtime-hal-simulation-replacement`；
+  - `halcmd-simulation-replacement`；
+  - `motion-controller-simulation-replacement`；
+  - `hal-pin-signal-param-store`；
+  - `halcmd-setp-sets-net-show-getp-gets`；
+  - `servo-period-motion-step`；
+  - `axis-joint-position-feedback`；
+- `executeVirtualHalcmd()`；
+- `executeVirtualHalCommand()`；
+- `stepVirtualHalMotion()`；
+- `stepVirtualHalMotionController()`；
+- `createVirtualHalSimulationRuntimeReport()`；
+- `createVirtualHalSimulationReplacementReport()`；
+- `createLinuxCncVirtualHalRuntime()`：
+  - `executeHalcmd()`；
+  - `stepMotion()`；
+  - `stepMotionController()`；
+  - `getSimulationRuntimeReport()`；
+  - `getSimulationReplacementReport()`。
+
+Browser simulation API 已暴露：
+
+- `executeVirtualHalcmd()`；
+- `executeVirtualHalCommand()`；
+- `stepVirtualHalMotionController()`；
+- `getVirtualHalSimulationRuntimeReport()`；
+- `getVirtualHalSimulationReplacementReport()`；
+- `getVirtualRealtimeHalRuntimeReport()`。
+
+4. 当前 Web 仿真可满足数控系统仿真用途。
+
+在 Web 方式下，数控系统仿真不再依赖 host LinuxCNC `halcmd`、host realtime HAL
+process 或 host motion process 完成仿真闭环。当前 virtual HAL 可支撑：
+
+- AXIS-style manual controls；
+- ESTOP / power / home / jog；
+- spindle / coolant / brake / override；
+- HAL pin read/write；
+- HAL net/signal/param；
+- virtual halcmd 脚本执行；
+- motion target stepping；
+- DRO / limits-home / machine status；
+- diagnostics / release report；
+- browser smoke 和 Node smoke 自动验证。
+
+二、虚拟 HAL 铁律
+
+以下规则是后续推进的硬性约束，不能为了进度绕过。
+
+1. 虚拟 HAL 功能来源铁律。
+
+虚拟 HAL 的功能定义、pin family、pin 名称、pin 方向、pin 类型、状态含义、行为目标、
+报告口径和仿真能力边界，必须完全来源于 LinuxCNC 源程序、vendored LinuxCNC 源码、
+LinuxCNC 配置、LinuxCNC 脚本或已有 LinuxCNC-backed runtime evidence。
+
+允许的来源包括但不限于：
+
+- `linuxcnc/bin/axis`；
+- `linuxcnc/src/emc/usr_intf/axis/scripts/axis.py`；
+- `linuxcnc/src/emc/usr_intf/halui.cc`；
+- `linuxcnc/src/emc/task/taskclass.cc`；
+- `linuxcnc/src/emc/motion/motion.c`；
+- `linuxcnc/src/emc/motion/axis.c`；
+- `linuxcnc/src/emc/motion/homing.c`；
+- `linuxcnc/src/emc/motion/motion.h`；
+- vendored LinuxCNC `configs/sim`；
+- vendored LinuxCNC tests；
+- LinuxCNC-backed WASM/native probe 输出。
+
+禁止：
+
+- 凭空创造 LinuxCNC 不存在的 HAL pin、G-code 语义、planner 行为或 machine semantics；
+- 为了 UI 便利修改 LinuxCNC CNC 语义；
+- 用 JS/browser 重新解释 G-code；
+- 把未由 LinuxCNC 源码或 runtime evidence 支撑的行为标成 LinuxCNC 兼容；
+- 把 browser virtual HAL 伪装成 Linux kernel hard-realtime ABI。
+
+2. Web 仿真满足性铁律。
+
+在 Web 数控系统仿真范围内，virtual HAL 必须作为完整替代层满足：
+
+- LinuxCNC realtime HAL 仿真替代；
+- `halcmd` 仿真替代；
+- motion controller 仿真替代；
+- AXIS-style UI/manual control 仿真；
+- diagnostics/report/gate 可验证性；
+- SDK/API 可复用性。
+
+后续任何 Web 仿真功能，如果需要 HAL、halcmd 或 motion process，默认必须接入
+project-level virtual HAL runtime，而不是引入 host process 依赖。
+
+3. 边界表述铁律。
+
+对外描述必须同时满足：
+
+- 可以明确说：virtual HAL 已完全满足 Web 方式数控系统仿真系统；
+- 可以明确说：在仿真范围内，virtual HAL 已替代 LinuxCNC realtime HAL / halcmd /
+  motion controller；
+- 必须同时说明：它不是 Linux kernel hard-realtime ABI；
+- 必须同时说明：它不替代外部硬件驱动 ABI、native HAL module ABI；
+- 必须同时说明：G-code/interpreter/planner/canonical motion 语义仍来自 LinuxCNC-backed
+  WASM。
+
+三、当前已通过验证
+
+最近关键验证：
+
+```text
+wasm-port/tests/sdk/node/verify_sdk_surface.sh
+wasm-port/tests/ui/node/verify_real_simulation_programs.sh
+SKIP_INTERP_BUILD=1 wasm-port/tests/browser/verify_real_simulation_browser.sh
+git diff --check
+```
+
+关键输出：
+
+```text
+sdk_surface_node_smoke=ok
+project_release_gate_manifest_node_smoke=ok
+project_release_artifact_url_workflow_node_smoke=ok
+project_batch_acceptance_workflow_node_smoke=ok
+project_batch_acceptance_artifact_node_smoke=ok
+real_simulation_programs_node_smoke=ok
+browser_real_simulation_page_smoke=ok
+git diff --check ok
+```
+
+四、后续执行规则
+
+1. 每轮开始前建议执行：
+
+```bash
+git status --short
+git log -5 --oneline
+tail -n 160 test17.txt
+awk '/^[一二三四五六七八九十百]+、|^### / {print}' test17.txt | sort | uniq -d
+```
+
+2. 后续记录规则：
+
+- 新进度只追加到 `test17.txt`；
+- 每批只追加一个新的中文编号或 `###` 标题记录；
+- 提交前检查标题唯一性；
+- 不复制 `text16.txt` 的长历史；
+- 不把局部重排、断言挪动、路径整理作为主目标；
+- 每批必须产出至少一种可复用能力、可执行 gate、可验证 workflow 或明确 runtime
+  boundary proof。
+
+3. 后续优先级。
+
+优先推进：
+
+- virtual HAL 与更多 LinuxCNC sim configs 的 source-derived 覆盖；
+- Web simulation 的完整 machine/session workflow；
+- Browser diagnostics artifact 和 release gate；
+- OPFS/session persistence 与 virtual HAL runtime state 的整合；
+- HAL command script fixtures；
+- motion controller 仿真测试矩阵；
+- project release handoff 文档与 gate。
+
+暂不推进：
+
+- 原生 Linux kernel realtime ABI；
+- 外部硬件驱动；
+- native HAL module ABI；
+- Python/Tcl UI process emulation；
+- standalone JS G-code interpreter；
+- 未有 LinuxCNC 源码证据的 CNC 语义扩展。
diff --git a/text16.txt b/text16.txt
index f753060..fde7415 100644
--- a/text16.txt
+++ b/text16.txt
@@ -1179,3 +1179,257 @@ git diff --check ok
 - grid 和 labels 只使用当前 preview viewBox；
 - Three.js 仍只显示 LinuxCNC canonical motion；
 - pixel smoke 只验证渲染非空，不推导 CNC 语义。
+
+### 十七、2026-06-17 Browser Virtual HAL for AXIS Manual Controls
+
+接续“虚拟 HAL 业务”，本批把 AXIS 手动控制从静态未绑定状态推进为浏览器
+虚拟 HAL 状态模型，并接入 UI、SDK 和 WASM bridge。
+
+本批新增实质能力：
+
+- 新增 `wasm-port/runtime/sdk/src/linuxcnc-hal.js`：
+  - `VIRTUAL_HAL_AXISUI_PINS` 对齐 `linuxcnc/bin/axis` 中的 axisui pins：
+    `jog.x/y/z/a/b/c/u/v/w`、`jog.increment`、notification pins、
+    `error`、`abort`；
+  - `createVirtualHalState()` / `applyVirtualHalAction()` 管理 ESTOP、Power、
+    Home、Jog、Touch Off、Spindle、Coolant、Limit Override、Brake 等状态；
+  - `createVirtualHalDroState()` 输出 AXIS DRO 默认/实际位置；
+  - `createVirtualHalLimitsHomeState()` 输出 home/limit/fault rows；
+  - `createVirtualHalMachineStatusState()` 输出 spindle/coolant/tool/override state；
+  - `createVirtualHalWasmBridgeSnapshot()` 生成可写入 standalone HAL adapter 的
+    pin/value snapshot。
+
+- SDK 入口新增 re-export：
+  - virtual HAL 状态、action、DRO、limits/home、machine status、runtime、
+    bridge snapshot、jog increment parser。
+
+- Interpreter SDK 新增 HAL bridge API：
+  - `hasWasmFunction(name)`；
+  - `resetHal()`；
+  - `setHalValue({ kind, name, type, value, connected })`；
+  - `applyVirtualHalSnapshot(snapshot, options)`；
+  - `applyVirtualHalState(halState, options)`；
+  - `probeHalNamed(name)`。
+
+- WASM wrapper 新增导出：
+  - `lcinterp_hal_reset()`；
+  - `lcinterp_hal_set_value()`；
+  - `lcinterp_probe_hal_named()`；
+  - `build_wasm_core.sh` 已把这些函数加入 `EXPORTED_FUNCTIONS`。
+
+- Browser simulation UI 接入：
+  - F1/F2 快捷键驱动 ESTOP/Power；
+  - Ctrl-Home 驱动 Home All；
+  - Manual jog 更新 `jog.*` pins 和 DRO；
+  - spindle/coolant/brake/limit override 写入 virtual HAL state；
+  - diagnostics artifact 新增 `virtualHal`；
+  - machine control state 从“not bound”变为
+    `browser virtual HAL active for jog/spindle/coolant/home simulation`。
+
+- Bridge snapshot 同时输出：
+  - AXIS Python component 内部 pin 名，例如 `jog.x`；
+  - HAL 全名，例如 `axisui.jog.x`；
+  - machine/task pins，例如 `halui.machine.is-on`；
+  - spindle/coolant pins，例如 `spindle.0.speed-out`、
+    `iocontrol.0.coolant-flood`。
+
+新增/扩展验证：
+
+- `verify_real_simulation_programs.mjs` 覆盖 virtual HAL SDK、runtime snapshot、
+  `axisui.*` HAL 全名、DRO、home、spindle、coolant；
+- `real_simulation_page_smoke.html` 覆盖 F1/F2/Ctrl-Home/jog/spindle/coolant 的
+  浏览器交互；
+- `verify_interp_wasm.mjs` 在新 WASM 导出存在时验证：
+  `applyVirtualHalState()` 写入 HAL adapter 后，`probeHalNamed()` 能读到
+  `_hal[jog.x]`、`_hal[axisui.jog.x]`、`_hal[halui.machine.is-on]`、
+  `_hal[spindle.0.speed-out]`、`_hal[iocontrol.0.coolant-flood]`。
+
+关键验证：
+
+```text
+real_simulation_programs_node_smoke=ok
+interp_wasm_node_smoke=ok (SKIP_INTERP_BUILD=1)
+browser_real_simulation_page_smoke=ok (SKIP_INTERP_BUILD=1)
+sdk_surface_node_smoke=ok
+ui_node_smokes=ok
+git diff --check ok
+```
+
+当前构建备注：
+
+- 当前 Codex shell 的 `PATH` 未解析到 `emcc`，完整 `build_wasm_core.sh` 会停在
+  `emcc: command not found`；
+- 这不是代码侧缺少 Emscripten 的结论，只是本 shell 未加载用户已有的
+  Emscripten 环境；
+- 快速 smoke 已用现有 WASM 产物验证旧路径不回归，新导出的 HAL bridge smoke 会在
+  重建后的 WASM 存在对应函数时自动执行。
+
+语义边界：
+
+- virtual HAL 只模拟 AXIS/manual UI 与 standalone HAL adapter 的状态桥；
+- 不在浏览器端实现 LinuxCNC realtime HAL、motion controller、planner、
+  kinematics 或 G-code 语义；
+- G-code execution 和 canonical motion 仍来自 LinuxCNC interpreter WASM。
+
+### 十八、2026-06-17 Project-level Virtual HAL SDK Boundary
+
+按用户要求“虚拟 HAL 适合整个项目”，本批把上一节的 simulation/UI 虚拟 HAL
+提升为项目级 SDK host-boundary 能力，供 simulation、INI panel、Node/browser
+smoke、外部 dashboard 和 interpreter bridge 共用。
+
+新增项目级 API：
+
+- `VIRTUAL_HAL_WASM_BRIDGE_FUNCTIONS`：
+  - `lcinterp_hal_reset`；
+  - `lcinterp_hal_set_value`；
+  - `lcinterp_probe_hal_named`；
+- `VIRTUAL_HAL_PROJECT_PIN_GROUPS`：
+  - `axisui`；
+  - `axis`；
+  - `task`；
+  - `spindle-coolant`；
+- `createVirtualHalPinInventory(halState)`：
+  - 输出全部 bridge pin rows；
+  - 按项目级 pin group 归类；
+- `createVirtualHalBridgeReadiness(options)`：
+  - 检查 snapshot 是否包含 required pins；
+  - 检查 caller-provided WASM function evidence 是否覆盖
+    `VIRTUAL_HAL_WASM_BRIDGE_FUNCTIONS`；
+  - 无 evidence 时显式 blocked：`wasm-function-evidence`；
+- `createVirtualHalBridgeActionPlan(readiness)`：
+  - blocked 时给出下一步：
+    `wasm-port/tools/build_wasm_core.sh`；
+    `SKIP_INTERP_BUILD=1 wasm-port/tests/wasm/node/verify_interp_wasm.sh`；
+  - ready 时返回空 command；
+- `createVirtualHalProjectReport(options)`：
+  - 汇总 state、DRO、limits/home、machine status、pin inventory、
+    WASM bridge snapshot、bridge readiness、bridge action plan；
+- `applyVirtualHalToInterpSdk(interpSdk, halState, options)`：
+  - 对有 `applyVirtualHalState()` 或 `applyVirtualHalSnapshot()` 的 interpreter
+    SDK 做统一适配；
+- `createLinuxCncVirtualHalRuntime()` 新增：
+  - `getPinInventory()`；
+  - `getProjectReport(options)`；
+  - `applyToInterpSdk(interpSdk, options)`。
+
+文档同步：
+
+- `runtime/sdk/README.md` 新增 `Project-level virtual HAL boundary` 小节；
+- `docs/project-release-handoff.md` 把 project-level virtual HAL 纳入当前支持
+  workflow；
+- `PROJECT_COMPLETION_TRACKER.md` 的 SDK/API surface 行记录 pin inventory、
+  bridge readiness/action-plan、project report、interpreter apply adapter；
+- `verify_project_release_handoff_docs.mjs` 增加文档 gate，防止后续退回页面私有
+  virtual HAL。
+
+新增/扩展验证：
+
+- `verify_sdk_surface.mjs` 覆盖：
+  - SDK re-export；
+  - constants discovery；
+  - virtual HAL snapshot；
+  - pin inventory；
+  - blocked/ready bridge readiness；
+  - bridge action plan；
+  - project report；
+  - runtime project report；
+  - fake interpreter SDK apply wrapper；
+- `verify_project_release_handoff_docs.mjs` 覆盖 handoff/README 中的项目级
+  virtual HAL API 和 realtime HAL runtime 边界声明。
+
+关键验证：
+
+```text
+sdk_surface_node_smoke=ok
+project_release_handoff_docs_node_smoke=ok
+real_simulation_programs_node_smoke=ok
+git diff --check ok
+```
+
+语义边界：
+
+- project-level virtual HAL 仍是 host-boundary adapter；
+- 它可服务 UI/session/diagnostics/dashboard 和 `_hal[...]` interpreter probe；
+- 它不是 LinuxCNC realtime HAL runtime；
+- 不提升 task、motion、HAL module loading、HALUI process、Tcl/Python process、
+  external device semantics。
+
+### 十九、2026-06-17 Simulation-grade LinuxCNC Realtime HAL / halcmd / Motion Replacement
+
+按用户要求“在满足仿真方面，实现 LinuxCNC realtime HAL / halcmd / motion controller
+的完整替代，以虚拟 HAL 方式实现”，本批把上一节项目级 virtual HAL 从 bridge/readiness
+推进为仿真级 runtime replacement。
+
+新增实质能力：
+
+- `VIRTUAL_HAL_SIMULATION_REPLACEMENT_TARGETS`：
+  - `linuxcnc-realtime-hal`；
+  - `halcmd`；
+  - `motion-controller`；
+- `VIRTUAL_HAL_SIMULATION_RUNTIME_CAPABILITIES` 新增：
+  - `realtime-hal-simulation-replacement`；
+  - `halcmd-simulation-replacement`；
+  - `motion-controller-simulation-replacement`；
+- 新增 `executeVirtualHalcmd()`：
+  - 作为 `executeVirtualHalCommand()` 的 halcmd 语义别名；
+  - 支持当前仿真所需 `setp`、`sets`、`newsig`、`net`、`show`、`getp`、`gets`、
+    `loadrt`、`loadusr`、`addf`、`start`、`stop`、`unlinkp`、`motion-step`；
+- 新增 `stepVirtualHalMotionController()`：
+  - 多周期 servo step；
+  - 输出每周期 position/motion frame；
+  - 更新 target、velocity、distance-to-go、in-position；
+- 新增 `createVirtualHalSimulationReplacementReport()`：
+  - 明确报告 realtime HAL、halcmd、motion controller 三类仿真替代 ready 状态；
+  - 保留 `hardRealtime: false`、`realtimeKernelAbi: false`，避免伪装为 Linux kernel
+    realtime ABI；
+- `createLinuxCncVirtualHalRuntime()` 新增：
+  - `executeHalcmd()`；
+  - `stepMotionController()`；
+  - `getSimulationReplacementReport()`。
+
+Browser simulation API 新增：
+
+- `executeVirtualHalcmd()`；
+- `executeVirtualHalCommand()`；
+- `stepVirtualHalMotionController()`；
+- `getVirtualHalSimulationRuntimeReport()`；
+- `getVirtualHalSimulationReplacementReport()`；
+- `getVirtualRealtimeHalRuntimeReport()`；
+- diagnostics artifact 新增 `virtualHalSimulationReplacement`。
+
+新增/扩展验证：
+
+- `verify_sdk_surface.mjs` 覆盖：
+  - replacement target constants；
+  - runtime capability constants；
+  - `executeVirtualHalcmd()`；
+  - `stepVirtualHalMotionController()`；
+  - `createVirtualHalSimulationReplacementReport()`；
+  - runtime wrapper 的 `executeHalcmd()` / `stepMotionController()` /
+    `getSimulationReplacementReport()`；
+- `real_simulation_page_smoke.html` 覆盖：
+  - 页面 API 暴露 halcmd/motion/replacement report；
+  - browser 中执行 `loadrt`、`addf`、`setp`、`show pin`；
+  - browser 中执行 motion controller 多周期 step；
+  - diagnostics artifact 携带 replacement report。
+
+关键验证：
+
+```text
+sdk_surface_node_smoke=ok
+project_release_gate_manifest_node_smoke=ok
+project_release_artifact_url_workflow_node_smoke=ok
+project_batch_acceptance_workflow_node_smoke=ok
+project_batch_acceptance_artifact_node_smoke=ok
+real_simulation_programs_node_smoke=ok
+browser_real_simulation_page_smoke=ok
+git diff --check ok
+```
+
+语义边界：
+
+- 本批实现的是 simulation-grade replacement；
+- Browser/SDK 仿真不再依赖 host `halcmd`、host realtime HAL process 或 host motion
+  process 来完成页面/Node 仿真闭环；
+- 仍不声称提供 Linux kernel hard-realtime ABI、外部硬件驱动 ABI、native HAL module ABI；
+- G-code 执行、canonical event、planner/interpreter 语义仍来自 LinuxCNC-backed WASM。
diff --git a/wasm-port/docs/project-release-handoff.md b/wasm-port/docs/project-release-handoff.md
index 0efaf55..1e303c4 100644
--- a/wasm-port/docs/project-release-handoff.md
+++ b/wasm-port/docs/project-release-handoff.md
@@ -56,6 +56,32 @@ owned by vendored LinuxCNC source and existing LinuxCNC-backed WASM boundaries.
   `createIniPanelShellSessionReadinessWorkflowReport()` when they need
   machine-readable session readiness phase and missing reasons. The workflow
   overview exposes the API surface inventory as a read-only summary row.
+- Project-level virtual HAL is exposed from the same SDK entrypoint for
+  simulation pages, INI-panel shells, Node/browser smokes, and external
+  dashboards. Use `createVirtualHalState()`, `applyVirtualHalAction()`,
+  `createLinuxCncVirtualHalRuntime()`, and
+  `createVirtualHalWasmBridgeSnapshot()` for shared browser virtual HAL state
+  and standalone interpreter bridge values. Use
+  `createVirtualHalPinInventory()`, `createVirtualHalBridgeReadiness()`,
+  `createVirtualHalBridgeActionPlan()`, and
+  `createVirtualHalProjectReport()` when a caller needs a machine-readable
+  project report, pin inventory, or readiness/action-plan surface. The bridge
+  readiness checks caller-provided evidence for
+  `VIRTUAL_HAL_WASM_BRIDGE_FUNCTIONS`, while
+  `VIRTUAL_HAL_PROJECT_PIN_GROUPS` provides stable inventory grouping.
+  `VIRTUAL_HAL_SIMULATION_RUNTIME_CAPABILITIES`,
+  `executeVirtualHalCommand()`, `stepVirtualHalMotion()`, and
+  `createVirtualHalSimulationRuntimeReport()` provide the simulation-grade
+  replacement for host `halcmd`, HAL pin/signal/param storage, and the basic
+  motion feedback loop used by browser/Node simulation. For simulation, this
+  removes the host `halcmd`/`halrun`/motion-controller requirement.
+  `applyVirtualHalToInterpSdk()` is the common adapter for interpreter SDK
+  instances that expose `applyVirtualHalState()` or
+  `applyVirtualHalSnapshot()`. This is a simulation runtime and virtual
+  realtime HAL runtime replacement for browser workflows, not a Linux kernel
+  hard-realtime ABI; kernel realtime scheduling, external device drivers, native
+  HAL module ABI behavior, HALUI process behavior, Tcl/Python process
+  integration, and external device semantics remain explicit boundaries.
 - CI dashboards and external SDK callers can use
   `createProjectReleaseGateManifest()` to discover required gate commands and
   expected smoke outputs, `createProjectReleaseGateResultMatrix()` to map
diff --git a/wasm-port/runtime/core/linuxcnc_wrap/linuxcnc_interp_wasm.cpp b/wasm-port/runtime/core/linuxcnc_wrap/linuxcnc_interp_wasm.cpp
index 261744d..bf2cdf7 100644
--- a/wasm-port/runtime/core/linuxcnc_wrap/linuxcnc_interp_wasm.cpp
+++ b/wasm-port/runtime/core/linuxcnc_wrap/linuxcnc_interp_wasm.cpp
@@ -550,6 +550,82 @@ char *load_tool_table_with_mode(const char *path, bool random_tool_changer)
     return copy_result(output.str());
 }
 
+standalone::HalValueKind hal_value_kind_from_name(const char *kind)
+{
+    const std::string value = kind ? kind : "";
+    if (value == "signal") {
+        return standalone::HalValueKind::Signal;
+    }
+    if (value == "param") {
+        return standalone::HalValueKind::Param;
+    }
+    return standalone::HalValueKind::Pin;
+}
+
+hal_type_t hal_type_from_name(const char *type)
+{
+    const std::string value = type ? type : "";
+    if (value == "HAL_BIT") {
+        return HAL_BIT;
+    }
+    if (value == "HAL_S32") {
+        return HAL_S32;
+    }
+    if (value == "HAL_U32") {
+        return HAL_U32;
+    }
+    if (value == "HAL_S64") {
+        return HAL_S64;
+    }
+    if (value == "HAL_U64") {
+        return HAL_U64;
+    }
+    return HAL_FLOAT;
+}
+
+hal_data_u hal_data_from_double(hal_type_t type, double value)
+{
+    hal_data_u data{};
+    switch (type) {
+    case HAL_BIT:
+        data.b = value != 0.0;
+        break;
+    case HAL_S32:
+        data.s = static_cast<int>(value);
+        break;
+    case HAL_U32:
+        data.u = static_cast<unsigned int>(value);
+        break;
+    case HAL_S64:
+        data.ls = static_cast<long long>(value);
+        break;
+    case HAL_U64:
+        data.lu = static_cast<unsigned long long>(value);
+        break;
+    case HAL_FLOAT:
+    default:
+        data.f = value;
+        break;
+    }
+    return data;
+}
+
+void initialize_hal_probe_interp(Interp &interp)
+{
+    interp._setup.length_units = CANON_UNITS_MM;
+    interp._setup.distance_mode = DISTANCE_MODE::ABSOLUTE;
+    interp._setup.ijk_distance_mode = DISTANCE_MODE::INCREMENTAL;
+    interp._setup.feed_mode = FEED_MODE::UNITS_PER_MINUTE;
+    interp._setup.plane = CANON_PLANE::XY;
+    interp._setup.motion_mode = G_0;
+    interp._setup.percent_flag = false;
+    interp._setup.sequence_number = 0;
+    interp._setup.parameter_occurrence = 0;
+    interp._setup.num_spindles = 1;
+    interp._setup.feature_set = FEATURE_HAL_PIN_VARS;
+    interp.init_named_parameters();
+}
+
 }  // namespace
 
 extern "C" {
@@ -1201,6 +1277,39 @@ char *lcinterp_probe_named_parameters(const char *ini_path)
     return copy_result(output.str());
 }
 
+EMSCRIPTEN_KEEPALIVE
+void lcinterp_hal_reset()
+{
+    standalone::reset_hal_adapter();
+}
+
+EMSCRIPTEN_KEEPALIVE
+int lcinterp_hal_set_value(const char *kind, const char *name, const char *type,
+                           double value, int connected)
+{
+    if (!name || name[0] == '\0') {
+        return -1;
+    }
+    const hal_type_t resolved_type = hal_type_from_name(type);
+    standalone::set_hal_value(
+        hal_value_kind_from_name(kind),
+        name,
+        resolved_type,
+        hal_data_from_double(resolved_type, value),
+        connected != 0);
+    return 0;
+}
+
+EMSCRIPTEN_KEEPALIVE
+char *lcinterp_probe_hal_named(const char *name)
+{
+    Interp interp;
+    initialize_hal_probe_interp(interp);
+    std::ostringstream output;
+    append_named_value(output, interp, name ? name : "_hal[missing]");
+    return copy_result(output.str());
+}
+
 EMSCRIPTEN_KEEPALIVE
 void lcinterp_free_string(char *value)
 {
diff --git a/wasm-port/runtime/sdk/README.md b/wasm-port/runtime/sdk/README.md
index 95a5bce..1cc019f 100644
--- a/wasm-port/runtime/sdk/README.md
+++ b/wasm-port/runtime/sdk/README.md
@@ -66,11 +66,39 @@ import {
   createIniPanelShellWorkflowOverviewReleaseReadinessArtifactValidationActionPlanDomReadiness,
   createIniPanelShellWorkflowOverviewReleaseReadinessArtifactValidationActionPlanRenderState,
   createIniPanelShellWorkflowOverviewReleaseReadinessArtifactValidationSummaryViewModel,
+  VIRTUAL_HAL_COVERAGE_STATES,
+  VIRTUAL_HAL_PROJECT_PIN_GROUPS,
+  VIRTUAL_HAL_SIMULATION_REPLACEMENT_TARGETS,
+  VIRTUAL_HAL_SIMULATION_RUNTIME_CAPABILITIES,
+  VIRTUAL_HAL_SOURCE_FILES,
+  VIRTUAL_HAL_SYSTEM_PIN_FAMILIES,
+  VIRTUAL_HAL_WASM_BRIDGE_FUNCTIONS,
+  applyVirtualHalAction,
+  applyVirtualHalPinUpdates,
+  applyVirtualHalToInterpSdk,
   createLinuxCncIniSdk,
   createLinuxCncInterpSdk,
+  createLinuxCncVirtualHalRuntime,
   createMachineSessionPersistenceDisplayViewModel,
   createMachineSessionPersistenceRenderState,
   createMachineSessionPersistenceSummary,
+  createVirtualHalBridgeActionPlan,
+  createVirtualHalBridgeReadiness,
+  createVirtualHalIntegrityReport,
+  createVirtualHalPinInventory,
+  createVirtualHalPinRegistry,
+  createVirtualHalProjectReport,
+  createVirtualHalSimulationReplacementReport,
+  createVirtualHalSimulationRuntimeReport,
+  createVirtualHalState,
+  createVirtualHalSystemCoverageReport,
+  createVirtualHalWasmBridgeSnapshot,
+  executeVirtualHalCommand,
+  executeVirtualHalcmd,
+  readVirtualHalPin,
+  stepVirtualHalMotion,
+  stepVirtualHalMotionController,
+  writeVirtualHalPin,
   createMachineSessionSnapshotPayload,
   createProjectReleaseGateActionPlan,
   createProjectReleaseGateExecutionManifest,
@@ -241,6 +269,78 @@ path but keeps the runner loop going after LinuxCNC reports an error, matching
 upstream `rs274 -n 0` regression tests such as `tests/interp/oword-unwind`.
 It does not implement or reinterpret LinuxCNC error semantics.
 
+## Project-level virtual HAL boundary
+
+The SDK exposes a project-level browser/Node virtual HAL boundary for UI,
+session, diagnostics, and standalone interpreter bridge workflows. It is shared
+through `runtime/sdk/src/index.js`, so simulation pages, INI-panel shells,
+Node smokes, and external dashboards can use the same objects instead of
+private page state.
+
+- `createVirtualHalState()` creates the normalized browser virtual HAL state.
+- `applyVirtualHalAction()` applies stable manual-control actions such as
+  ESTOP, power, home, jog, spindle, coolant, brake, touch-off, and limit
+  override.
+- `createLinuxCncVirtualHalRuntime()` wraps that state in a small runtime with
+  `dispatch()`, `getDroState()`, `getLimitsHomeState()`,
+  `getMachineStatusState()`, `getWasmBridgeSnapshot()`, `getPinRegistry()`,
+  `readPin()`, `writePin()`, `applyPinUpdates()`, `executeHalCommand()`,
+  `executeHalcmd()`, `stepMotion()`, `stepMotionController()`,
+  `getSimulationRuntimeReport()`, `getSimulationReplacementReport()`,
+  `getIntegrityReport()`, `getPinInventory()`, `getProjectReport()`, and
+  `applyToInterpSdk()`.
+- `VIRTUAL_HAL_SIMULATION_RUNTIME_CAPABILITIES`,
+  `VIRTUAL_HAL_SIMULATION_REPLACEMENT_TARGETS`,
+  `executeVirtualHalCommand()`, `executeVirtualHalcmd()`,
+  `stepVirtualHalMotion()`, `stepVirtualHalMotionController()`,
+  `createVirtualHalSimulationRuntimeReport()`, and
+  `createVirtualHalSimulationReplacementReport()` expose a simulation-grade
+  replacement for the host LinuxCNC realtime HAL, `halcmd`, and motion
+  controller runtime. It supports HAL pin/signal/param storage, `setp`,
+  `sets`, `newsig`, `net`, `show`, `getp`, `gets`, `loadrt`/`loadusr` stubs,
+  `addf`, thread start/stop, and servo-period motion stepping for browser
+  simulation and Node dashboards.
+- `createVirtualHalWasmBridgeSnapshot()` returns the pin/value rows that can be
+  applied through the interpreter SDK HAL bridge. It includes AXIS internal pin
+  names such as `jog.x`, full HAL names such as `axisui.jog.x`, task/power
+  names such as `halui.machine.is-on`, and spindle/coolant names such as
+  `spindle.0.speed-out` and `iocontrol.0.coolant-flood`.
+- `createVirtualHalPinRegistry()`, `readVirtualHalPin()`,
+  `writeVirtualHalPin()`, and `applyVirtualHalPinUpdates()` expose the project
+  virtual HAL as a source-derived pin service. Callers can read/write HAL names
+  such as `halui.machine.on`, `spindle.0.speed-out`,
+  `motion.tooloffset.z`, or `joint.0.homed` without duplicating pin mapping.
+- `createVirtualHalIntegrityReport()` verifies registry completeness, duplicate
+  pin absence, required project pins, and source coverage in one machine
+  readable report.
+- `createVirtualHalPinInventory()` returns a stable project inventory grouped
+  by `VIRTUAL_HAL_PROJECT_PIN_GROUPS`.
+- `VIRTUAL_HAL_SYSTEM_PIN_FAMILIES`, `VIRTUAL_HAL_SOURCE_FILES`, and
+  `VIRTUAL_HAL_COVERAGE_STATES` expose the source-derived coverage model for
+  AXIS, HALUI, iocontrol, motion, axis, joint, spindle, coolant, and tool pins.
+- `createVirtualHalSystemCoverageReport()` expands that source-derived model
+  into a machine-readable completeness report. It records the LinuxCNC source
+  files used as evidence, concrete declared pin rows, represented bridge pins,
+  and explicit `bridge-only` / `runtime-boundary` rows.
+- `createVirtualHalBridgeReadiness()` checks that a snapshot has required
+  bridge pins and that caller-provided WASM function evidence covers
+  `VIRTUAL_HAL_WASM_BRIDGE_FUNCTIONS`.
+- `createVirtualHalBridgeActionPlan()` turns blocked bridge readiness into the
+  next build/verify commands.
+- `createVirtualHalProjectReport()` packages state, DRO, limits/home, machine
+  status, pin inventory, pin registry, integrity, system coverage, simulation
+  runtime evidence, bridge snapshot, bridge readiness, and action plan into one
+  stable report for dashboards or release artifacts.
+- `applyVirtualHalToInterpSdk()` applies a virtual HAL state to any interpreter
+  SDK instance exposing `applyVirtualHalState()` or `applyVirtualHalSnapshot()`.
+
+For simulation, this replaces the host `halcmd`, HAL object store, and basic
+motion feedback loop. It is a virtual realtime HAL runtime replacement for
+browser workflows, but still not a Linux kernel hard-realtime ABI: kernel
+realtime scheduling, external device drivers, native HAL module ABI behavior,
+HALUI process behavior, and Tcl/Python process integration remain explicit
+boundaries.
+
 ## Project release readiness export
 
 `createProjectReleaseGateManifest()` returns the required release gate IDs,
diff --git a/wasm-port/runtime/sdk/src/index.js b/wasm-port/runtime/sdk/src/index.js
index 2442f46..b6ed428 100644
--- a/wasm-port/runtime/sdk/src/index.js
+++ b/wasm-port/runtime/sdk/src/index.js
@@ -1,5 +1,42 @@
 export { createLinuxCncIniSdk } from "./linuxcnc-ini.js";
 export { createLinuxCncInterpSdk } from "./linuxcnc-interp.js";
+export {
+  VIRTUAL_HAL_AXES,
+  VIRTUAL_HAL_AXISUI_PINS,
+  VIRTUAL_HAL_COVERAGE_STATES,
+  VIRTUAL_HAL_PROJECT_PIN_GROUPS,
+  VIRTUAL_HAL_SIMULATION_REPLACEMENT_TARGETS,
+  VIRTUAL_HAL_SIMULATION_RUNTIME_CAPABILITIES,
+  VIRTUAL_HAL_SOURCE_FILES,
+  VIRTUAL_HAL_SYSTEM_PIN_FAMILIES,
+  VIRTUAL_HAL_WASM_BRIDGE_FUNCTIONS,
+  applyVirtualHalToInterpSdk,
+  applyVirtualHalAction,
+  applyVirtualHalPinUpdates,
+  cloneVirtualHalState,
+  createLinuxCncVirtualHalRuntime,
+  createVirtualHalBridgeActionPlan,
+  createVirtualHalBridgeReadiness,
+  createVirtualHalDroState,
+  createVirtualHalLimitsHomeState,
+  createVirtualHalMachineStatusState,
+  createVirtualHalIntegrityReport,
+  createVirtualHalPinInventory,
+  createVirtualHalPinRegistry,
+  createVirtualHalProjectReport,
+  createVirtualHalSimulationReplacementReport,
+  createVirtualHalSimulationRuntimeReport,
+  createVirtualHalState,
+  createVirtualHalSystemCoverageReport,
+  createVirtualHalWasmBridgeSnapshot,
+  executeVirtualHalCommand,
+  executeVirtualHalcmd,
+  parseVirtualHalJogIncrement,
+  readVirtualHalPin,
+  stepVirtualHalMotionController,
+  stepVirtualHalMotion,
+  writeVirtualHalPin,
+} from "./linuxcnc-hal.js";
 export {
   createProjectBatchAcceptanceActionPlan,
   createProjectBatchAcceptanceCapabilityMatrix,
diff --git a/wasm-port/runtime/sdk/src/linuxcnc-hal.js b/wasm-port/runtime/sdk/src/linuxcnc-hal.js
new file mode 100644
index 0000000..9b41cbb
--- /dev/null
+++ b/wasm-port/runtime/sdk/src/linuxcnc-hal.js
@@ -0,0 +1,2315 @@
+const VIRTUAL_HAL_AXES_INTERNAL = ["x", "y", "z", "a", "b", "c", "u", "v", "w"];
+const VIRTUAL_HAL_DISPLAY_AXES = ["x", "y", "z", "a", "b", "c"];
+
+export const VIRTUAL_HAL_AXES = [...VIRTUAL_HAL_AXES_INTERNAL];
+
+export const VIRTUAL_HAL_AXISUI_PINS = Object.freeze({
+  component: "axisui",
+  pins: Object.freeze([
+    ...VIRTUAL_HAL_AXES.map((axis) => ({ name: `jog.${axis}`, type: "HAL_BIT", direction: "HAL_OUT" })),
+    { name: "jog.increment", type: "HAL_FLOAT", direction: "HAL_OUT" },
+    { name: "notifications-clear", type: "HAL_BIT", direction: "HAL_IN" },
+    { name: "notifications-clear-info", type: "HAL_BIT", direction: "HAL_IN" },
+    { name: "notifications-clear-error", type: "HAL_BIT", direction: "HAL_IN" },
+    { name: "resume-inhibit", type: "HAL_BIT", direction: "HAL_IN" },
+    { name: "error", type: "HAL_BIT", direction: "HAL_OUT" },
+    { name: "abort", type: "HAL_BIT", direction: "HAL_OUT" },
+  ]),
+});
+
+export const VIRTUAL_HAL_SOURCE_FILES = Object.freeze({
+  axisui: "linuxcnc/bin/axis",
+  axisuiScript: "linuxcnc/src/emc/usr_intf/axis/scripts/axis.py",
+  halui: "linuxcnc/src/emc/usr_intf/halui.cc",
+  iocontrol: "linuxcnc/src/emc/task/taskclass.cc",
+  motion: "linuxcnc/src/emc/motion/motion.c",
+  motionAxis: "linuxcnc/src/emc/motion/axis.c",
+  motionHoming: "linuxcnc/src/emc/motion/homing.c",
+  vendoredMotionHeader: "wasm-port/vendor/linuxcnc/src/emc/motion/motion.h",
+});
+
+export const VIRTUAL_HAL_COVERAGE_STATES = Object.freeze({
+  simulated: "simulated",
+  bridgeOnly: "bridge-only",
+  runtimeBoundary: "runtime-boundary",
+});
+
+export const VIRTUAL_HAL_SYSTEM_PIN_FAMILIES = Object.freeze([
+  {
+    id: "axisui",
+    component: "axisui",
+    label: "AXIS UI pins",
+    sourceFiles: Object.freeze([
+      VIRTUAL_HAL_SOURCE_FILES.axisui,
+      VIRTUAL_HAL_SOURCE_FILES.axisuiScript,
+    ]),
+    sourceEvidence: "axisui component newpin calls for jog, notification, error, and abort pins.",
+    coverage: VIRTUAL_HAL_COVERAGE_STATES.simulated,
+    pins: Object.freeze(VIRTUAL_HAL_AXISUI_PINS.pins.map((pin) => ({
+      ...pin,
+      name: `${VIRTUAL_HAL_AXISUI_PINS.component}.${pin.name}`,
+    }))),
+  },
+  {
+    id: "halui-task",
+    component: "halui",
+    label: "HALUI task, mode, and program pins",
+    sourceFiles: Object.freeze([VIRTUAL_HAL_SOURCE_FILES.halui]),
+    sourceEvidence: "halui_hal_init exports machine, estop, mode, coolant, program, override, and MDI pins.",
+    coverage: VIRTUAL_HAL_COVERAGE_STATES.bridgeOnly,
+    pins: Object.freeze([
+      { name: "halui.machine.units-per-mm", type: "HAL_FLOAT", direction: "HAL_OUT" },
+      { name: "halui.machine.is-on", type: "HAL_BIT", direction: "HAL_OUT" },
+      { name: "halui.machine.on", type: "HAL_BIT", direction: "HAL_IN" },
+      { name: "halui.machine.off", type: "HAL_BIT", direction: "HAL_IN" },
+      { name: "halui.estop.is-activated", type: "HAL_BIT", direction: "HAL_OUT" },
+      { name: "halui.estop.activate", type: "HAL_BIT", direction: "HAL_IN" },
+      { name: "halui.estop.reset", type: "HAL_BIT", direction: "HAL_IN" },
+      { name: "halui.mode.is-manual", type: "HAL_BIT", direction: "HAL_OUT" },
+      { name: "halui.mode.is-auto", type: "HAL_BIT", direction: "HAL_OUT" },
+      { name: "halui.mode.is-mdi", type: "HAL_BIT", direction: "HAL_OUT" },
+      { name: "halui.mode.is-teleop", type: "HAL_BIT", direction: "HAL_OUT" },
+      { name: "halui.mode.is-joint", type: "HAL_BIT", direction: "HAL_OUT" },
+      { name: "halui.mode.manual", type: "HAL_BIT", direction: "HAL_IN" },
+      { name: "halui.mode.auto", type: "HAL_BIT", direction: "HAL_IN" },
+      { name: "halui.mode.mdi", type: "HAL_BIT", direction: "HAL_IN" },
+      { name: "halui.mist.is-on", type: "HAL_BIT", direction: "HAL_OUT" },
+      { name: "halui.flood.is-on", type: "HAL_BIT", direction: "HAL_OUT" },
+      { name: "halui.mist.on", type: "HAL_BIT", direction: "HAL_IN" },
+      { name: "halui.mist.off", type: "HAL_BIT", direction: "HAL_IN" },
+      { name: "halui.flood.on", type: "HAL_BIT", direction: "HAL_IN" },
+      { name: "halui.flood.off", type: "HAL_BIT", direction: "HAL_IN" },
+      { name: "halui.program.is-idle", type: "HAL_BIT", direction: "HAL_OUT" },
+      { name: "halui.program.is-running", type: "HAL_BIT", direction: "HAL_OUT" },
+      { name: "halui.program.is-paused", type: "HAL_BIT", direction: "HAL_OUT" },
+      { name: "halui.halui-mdi-is-running", type: "HAL_BIT", direction: "HAL_OUT" },
+      { name: "halui.program.run", type: "HAL_BIT", direction: "HAL_IN" },
+      { name: "halui.program.pause", type: "HAL_BIT", direction: "HAL_IN" },
+      { name: "halui.program.resume", type: "HAL_BIT", direction: "HAL_IN" },
+      { name: "halui.program.step", type: "HAL_BIT", direction: "HAL_IN" },
+      { name: "halui.program.stop", type: "HAL_BIT", direction: "HAL_IN" },
+      { name: "halui.program.optional-stop.is-on", type: "HAL_BIT", direction: "HAL_OUT" },
+      { name: "halui.program.optional-stop.on", type: "HAL_BIT", direction: "HAL_IN" },
+      { name: "halui.program.optional-stop.off", type: "HAL_BIT", direction: "HAL_IN" },
+      { name: "halui.program.block-delete.is-on", type: "HAL_BIT", direction: "HAL_OUT" },
+      { name: "halui.program.block-delete.on", type: "HAL_BIT", direction: "HAL_IN" },
+      { name: "halui.program.block-delete.off", type: "HAL_BIT", direction: "HAL_IN" },
+      { name: "halui.abort", type: "HAL_BIT", direction: "HAL_IN" },
+      { name: "halui.feed-override.value", type: "HAL_FLOAT", direction: "HAL_OUT" },
+      { name: "halui.rapid-override.value", type: "HAL_FLOAT", direction: "HAL_OUT" },
+      { name: "halui.max-velocity.value", type: "HAL_FLOAT", direction: "HAL_OUT" },
+      { name: "halui.feed-override.counts", type: "HAL_S32", direction: "HAL_IN" },
+      { name: "halui.feed-override.scale", type: "HAL_FLOAT", direction: "HAL_IN" },
+      { name: "halui.feed-override.increase", type: "HAL_BIT", direction: "HAL_IN" },
+      { name: "halui.feed-override.decrease", type: "HAL_BIT", direction: "HAL_IN" },
+      { name: "halui.feed-override.reset", type: "HAL_BIT", direction: "HAL_IN" },
+      { name: "halui.rapid-override.counts", type: "HAL_S32", direction: "HAL_IN" },
+      { name: "halui.rapid-override.scale", type: "HAL_FLOAT", direction: "HAL_IN" },
+      { name: "halui.rapid-override.increase", type: "HAL_BIT", direction: "HAL_IN" },
+      { name: "halui.rapid-override.decrease", type: "HAL_BIT", direction: "HAL_IN" },
+      { name: "halui.rapid-override.reset", type: "HAL_BIT", direction: "HAL_IN" },
+      { name: "halui.mdi-command-00", type: "HAL_BIT", direction: "HAL_IN", template: true },
+    ]),
+  },
+  {
+    id: "halui-axis-joint",
+    component: "halui",
+    label: "HALUI axis and joint pins",
+    sourceFiles: Object.freeze([VIRTUAL_HAL_SOURCE_FILES.halui]),
+    sourceEvidence: "halui_hal_init exports per-axis and per-joint status, selection, jogging, homing, and limit pins.",
+    coverage: VIRTUAL_HAL_COVERAGE_STATES.bridgeOnly,
+    pins: Object.freeze([
+      { name: "halui.axis.{axis}.is-selected", type: "HAL_BIT", direction: "HAL_OUT", axes: true },
+      { name: "halui.axis.{axis}.pos-commanded", type: "HAL_FLOAT", direction: "HAL_OUT", axes: true },
+      { name: "halui.axis.{axis}.pos-feedback", type: "HAL_FLOAT", direction: "HAL_OUT", axes: true },
+      { name: "halui.axis.{axis}.pos-relative", type: "HAL_FLOAT", direction: "HAL_OUT", axes: true },
+      { name: "halui.axis.{axis}.select", type: "HAL_BIT", direction: "HAL_IN", axes: true },
+      { name: "halui.axis.{axis}.plus", type: "HAL_BIT", direction: "HAL_IN", axes: true },
+      { name: "halui.axis.{axis}.minus", type: "HAL_BIT", direction: "HAL_IN", axes: true },
+      { name: "halui.axis.{axis}.analog", type: "HAL_FLOAT", direction: "HAL_IN", axes: true },
+      { name: "halui.axis.{axis}.increment", type: "HAL_FLOAT", direction: "HAL_IN", axes: true },
+      { name: "halui.joint.{joint}.is-homed", type: "HAL_BIT", direction: "HAL_OUT", joints: true },
+      { name: "halui.joint.{joint}.is-selected", type: "HAL_BIT", direction: "HAL_OUT", joints: true },
+      { name: "halui.joint.{joint}.home", type: "HAL_BIT", direction: "HAL_IN", joints: true },
+      { name: "halui.joint.{joint}.unhome", type: "HAL_BIT", direction: "HAL_IN", joints: true },
+      { name: "halui.joint.{joint}.plus", type: "HAL_BIT", direction: "HAL_IN", joints: true },
+      { name: "halui.joint.{joint}.minus", type: "HAL_BIT", direction: "HAL_IN", joints: true },
+      { name: "halui.joint.selected.is-homed", type: "HAL_BIT", direction: "HAL_OUT" },
+      { name: "halui.joint.selected.home", type: "HAL_BIT", direction: "HAL_IN" },
+      { name: "halui.axis.selected.plus", type: "HAL_BIT", direction: "HAL_IN" },
+      { name: "halui.axis.selected.minus", type: "HAL_BIT", direction: "HAL_IN" },
+    ]),
+  },
+  {
+    id: "iocontrol",
+    component: "iocontrol.0",
+    label: "IO/task, coolant, and tool-change pins",
+    sourceFiles: Object.freeze([VIRTUAL_HAL_SOURCE_FILES.iocontrol]),
+    sourceEvidence: "Task::iocontrol_hal_init adds iocontrol.0 enable, coolant, tool prepare, and tool change pins.",
+    coverage: VIRTUAL_HAL_COVERAGE_STATES.simulated,
+    pins: Object.freeze([
+      { name: "iocontrol.0.user-enable-out", type: "HAL_BIT", direction: "HAL_OUT" },
+      { name: "iocontrol.0.emc-enable-in", type: "HAL_BIT", direction: "HAL_IN" },
+      { name: "iocontrol.0.user-request-enable", type: "HAL_BIT", direction: "HAL_OUT" },
+      { name: "iocontrol.0.coolant-mist", type: "HAL_BIT", direction: "HAL_OUT" },
+      { name: "iocontrol.0.coolant-flood", type: "HAL_BIT", direction: "HAL_OUT" },
+      { name: "iocontrol.0.tool-prep-pocket", type: "HAL_S32", direction: "HAL_OUT" },
+      { name: "iocontrol.0.tool-from-pocket", type: "HAL_S32", direction: "HAL_OUT" },
+      { name: "iocontrol.0.tool-prep-index", type: "HAL_S32", direction: "HAL_OUT" },
+      { name: "iocontrol.0.tool-prep-number", type: "HAL_S32", direction: "HAL_OUT" },
+      { name: "iocontrol.0.tool-number", type: "HAL_S32", direction: "HAL_OUT" },
+      { name: "iocontrol.0.tool-prepare", type: "HAL_BIT", direction: "HAL_OUT" },
+      { name: "iocontrol.0.tool-prepared", type: "HAL_BIT", direction: "HAL_IN" },
+      { name: "iocontrol.0.tool-change", type: "HAL_BIT", direction: "HAL_OUT" },
+      { name: "iocontrol.0.tool-changed", type: "HAL_BIT", direction: "HAL_IN" },
+    ]),
+  },
+  {
+    id: "motion-core",
+    component: "motion",
+    label: "Motion controller status pins",
+    sourceFiles: Object.freeze([VIRTUAL_HAL_SOURCE_FILES.motion, VIRTUAL_HAL_SOURCE_FILES.vendoredMotionHeader]),
+    sourceEvidence: "init_hal_io exports machine-wide motion enable, mode, velocity, feed, interpreter, and IO pins.",
+    coverage: VIRTUAL_HAL_COVERAGE_STATES.runtimeBoundary,
+    pins: Object.freeze([
+      { name: "motion.enable", type: "HAL_BIT", direction: "HAL_IN" },
+      { name: "motion.motion-enabled", type: "HAL_BIT", direction: "HAL_OUT" },
+      { name: "motion.in-position", type: "HAL_BIT", direction: "HAL_OUT" },
+      { name: "motion.motion-type", type: "HAL_S32", direction: "HAL_OUT" },
+      { name: "motion.coord-mode", type: "HAL_BIT", direction: "HAL_OUT" },
+      { name: "motion.teleop-mode", type: "HAL_BIT", direction: "HAL_OUT" },
+      { name: "motion.current-vel", type: "HAL_FLOAT", direction: "HAL_OUT" },
+      { name: "motion.requested-vel", type: "HAL_FLOAT", direction: "HAL_OUT" },
+      { name: "motion.distance-to-go", type: "HAL_FLOAT", direction: "HAL_OUT" },
+      { name: "motion.program-line", type: "HAL_S32", direction: "HAL_OUT" },
+      { name: "motion.probe-input", type: "HAL_BIT", direction: "HAL_IN" },
+      { name: "motion.adaptive-feed", type: "HAL_FLOAT", direction: "HAL_IN" },
+      { name: "motion.feed-hold", type: "HAL_BIT", direction: "HAL_IN" },
+      { name: "motion.feed-inhibit", type: "HAL_BIT", direction: "HAL_IN" },
+      { name: "motion.homing-inhibit", type: "HAL_BIT", direction: "HAL_IN" },
+      { name: "motion.jog-inhibit", type: "HAL_BIT", direction: "HAL_IN" },
+      { name: "motion.switchkins-type", type: "HAL_FLOAT", direction: "HAL_IN", conditional: "switchable kinematics" },
+    ]),
+  },
+  {
+    id: "axis-motion",
+    component: "axis",
+    label: "Motion axis pins",
+    sourceFiles: Object.freeze([VIRTUAL_HAL_SOURCE_FILES.motionAxis]),
+    sourceEvidence: "axis_init_hal_io exports per-axis position, teleop, jog, and external-offset pins.",
+    coverage: VIRTUAL_HAL_COVERAGE_STATES.simulated,
+    pins: Object.freeze([
+      { name: "axis.{axis}.pos-cmd", type: "HAL_FLOAT", direction: "HAL_OUT", axes: true },
+      { name: "axis.{axis}.teleop-vel-cmd", type: "HAL_FLOAT", direction: "HAL_OUT", axes: true },
+      { name: "axis.{axis}.teleop-pos-cmd", type: "HAL_FLOAT", direction: "HAL_OUT", axes: true },
+      { name: "axis.{axis}.teleop-vel-lim", type: "HAL_FLOAT", direction: "HAL_OUT", axes: true },
+      { name: "axis.{axis}.teleop-tp-enable", type: "HAL_BIT", direction: "HAL_OUT", axes: true },
+      { name: "axis.{axis}.jog-enable", type: "HAL_BIT", direction: "HAL_IN", axes: true },
+      { name: "axis.{axis}.jog-scale", type: "HAL_FLOAT", direction: "HAL_IN", axes: true },
+      { name: "axis.{axis}.jog-counts", type: "HAL_S32", direction: "HAL_IN", axes: true },
+      { name: "axis.{axis}.jog-vel-mode", type: "HAL_BIT", direction: "HAL_IN", axes: true },
+      { name: "axis.{axis}.eoffset-enable", type: "HAL_BIT", direction: "HAL_IN", axes: true },
+      { name: "axis.{axis}.eoffset", type: "HAL_FLOAT", direction: "HAL_OUT", axes: true },
+    ]),
+  },
+  {
+    id: "joint-motion",
+    component: "joint",
+    label: "Motion joint and homing pins",
+    sourceFiles: Object.freeze([VIRTUAL_HAL_SOURCE_FILES.motion, VIRTUAL_HAL_SOURCE_FILES.motionHoming]),
+    sourceEvidence: "export_joint and base_make_joint_home_pins export per-joint command, feedback, homing, limit, jog, and fault pins.",
+    coverage: VIRTUAL_HAL_COVERAGE_STATES.simulated,
+    pins: Object.freeze([
+      { name: "joint.{joint}.coarse-pos-cmd", type: "HAL_FLOAT", direction: "HAL_OUT", joints: true },
+      { name: "joint.{joint}.pos-cmd", type: "HAL_FLOAT", direction: "HAL_OUT", joints: true },
+      { name: "joint.{joint}.pos-fb", type: "HAL_FLOAT", direction: "HAL_OUT", joints: true },
+      { name: "joint.{joint}.motor-pos-cmd", type: "HAL_FLOAT", direction: "HAL_OUT", joints: true },
+      { name: "joint.{joint}.motor-pos-fb", type: "HAL_FLOAT", direction: "HAL_IN", joints: true },
+      { name: "joint.{joint}.pos-lim-sw-in", type: "HAL_BIT", direction: "HAL_IN", joints: true },
+      { name: "joint.{joint}.neg-lim-sw-in", type: "HAL_BIT", direction: "HAL_IN", joints: true },
+      { name: "joint.{joint}.amp-enable-out", type: "HAL_BIT", direction: "HAL_OUT", joints: true },
+      { name: "joint.{joint}.amp-fault-in", type: "HAL_BIT", direction: "HAL_IN", joints: true },
+      { name: "joint.{joint}.homed", type: "HAL_BIT", direction: "HAL_OUT", joints: true },
+      { name: "joint.{joint}.homing", type: "HAL_BIT", direction: "HAL_OUT", joints: true },
+      { name: "joint.{joint}.home-state", type: "HAL_S32", direction: "HAL_OUT", joints: true },
+      { name: "joint.{joint}.home-sw-in", type: "HAL_BIT", direction: "HAL_IN", joints: true },
+      { name: "joint.{joint}.pos-hard-limit", type: "HAL_BIT", direction: "HAL_OUT", joints: true },
+      { name: "joint.{joint}.neg-hard-limit", type: "HAL_BIT", direction: "HAL_OUT", joints: true },
+      { name: "joint.{joint}.error", type: "HAL_BIT", direction: "HAL_OUT", joints: true },
+      { name: "joint.{joint}.faulted", type: "HAL_BIT", direction: "HAL_OUT", joints: true },
+    ]),
+  },
+  {
+    id: "spindle-motion",
+    component: "spindle",
+    label: "Motion spindle pins",
+    sourceFiles: Object.freeze([VIRTUAL_HAL_SOURCE_FILES.motion, VIRTUAL_HAL_SOURCE_FILES.halui]),
+    sourceEvidence: "export_spindle and halui_hal_init export spindle command, status, override, orient, and feedback pins.",
+    coverage: VIRTUAL_HAL_COVERAGE_STATES.simulated,
+    pins: Object.freeze([
+      { name: "spindle.0.on", type: "HAL_BIT", direction: "HAL_OUT" },
+      { name: "spindle.0.forward", type: "HAL_BIT", direction: "HAL_OUT" },
+      { name: "spindle.0.reverse", type: "HAL_BIT", direction: "HAL_OUT" },
+      { name: "spindle.0.brake", type: "HAL_BIT", direction: "HAL_OUT" },
+      { name: "spindle.0.speed-out", type: "HAL_FLOAT", direction: "HAL_OUT" },
+      { name: "spindle.0.speed-out-abs", type: "HAL_FLOAT", direction: "HAL_OUT" },
+      { name: "spindle.0.speed-out-rps", type: "HAL_FLOAT", direction: "HAL_OUT" },
+      { name: "spindle.0.speed-in", type: "HAL_FLOAT", direction: "HAL_IN" },
+      { name: "spindle.0.at-speed", type: "HAL_BIT", direction: "HAL_IN" },
+      { name: "spindle.0.orient", type: "HAL_BIT", direction: "HAL_OUT" },
+      { name: "spindle.0.is-oriented", type: "HAL_BIT", direction: "HAL_IN" },
+      { name: "halui.spindle.0.is-on", type: "HAL_BIT", direction: "HAL_OUT" },
+      { name: "halui.spindle.0.start", type: "HAL_BIT", direction: "HAL_IN" },
+      { name: "halui.spindle.0.stop", type: "HAL_BIT", direction: "HAL_IN" },
+      { name: "halui.spindle.0.override.value", type: "HAL_FLOAT", direction: "HAL_OUT" },
+    ]),
+  },
+  {
+    id: "tool-status",
+    component: "tool",
+    label: "Tool status and tool-offset pins",
+    sourceFiles: Object.freeze([VIRTUAL_HAL_SOURCE_FILES.halui, VIRTUAL_HAL_SOURCE_FILES.iocontrol, VIRTUAL_HAL_SOURCE_FILES.motion]),
+    sourceEvidence: "HALUI tool status, iocontrol tool-change pins, and motion.tooloffset pins expose current tool and offsets.",
+    coverage: VIRTUAL_HAL_COVERAGE_STATES.bridgeOnly,
+    pins: Object.freeze([
+      { name: "halui.tool.number", type: "HAL_U32", direction: "HAL_OUT" },
+      { name: "halui.tool.diameter", type: "HAL_FLOAT", direction: "HAL_OUT" },
+      { name: "halui.tool.length_offset.{axis}", type: "HAL_FLOAT", direction: "HAL_OUT", axes: true },
+      { name: "motion.tooloffset.{axis}", type: "HAL_FLOAT", direction: "HAL_OUT", axes: true },
+      { name: "iocontrol.0.tool-number", type: "HAL_S32", direction: "HAL_OUT" },
+      { name: "iocontrol.0.tool-prepare", type: "HAL_BIT", direction: "HAL_OUT" },
+      { name: "iocontrol.0.tool-prepared", type: "HAL_BIT", direction: "HAL_IN" },
+      { name: "iocontrol.0.tool-change", type: "HAL_BIT", direction: "HAL_OUT" },
+      { name: "iocontrol.0.tool-changed", type: "HAL_BIT", direction: "HAL_IN" },
+    ]),
+  },
+]);
+
+export const VIRTUAL_HAL_WASM_BRIDGE_FUNCTIONS = Object.freeze([
+  "lcinterp_hal_reset",
+  "lcinterp_hal_set_value",
+  "lcinterp_probe_hal_named",
+]);
+
+export const VIRTUAL_HAL_PROJECT_PIN_GROUPS = Object.freeze([
+  {
+    id: "axisui",
+    label: "AXIS UI pins",
+    description: "Browser/manual AXIS component pins mirrored from linuxcnc/bin/axis.",
+  },
+  {
+    id: "axis-motion",
+    label: "Axis and joint motion pins",
+    description: "LinuxCNC motion axis/joint state pins exposed through source-derived virtual HAL coverage.",
+  },
+  {
+    id: "task",
+    label: "Task, HALUI, and iocontrol pins",
+    description: "ESTOP, power, mode, program, and IO pins from halui.cc and taskclass.cc.",
+  },
+  {
+    id: "spindle-coolant",
+    label: "Spindle and coolant pins",
+    description: "Spindle speed/on/orient and iocontrol/HALUI coolant pins used by project UI/status workflows.",
+  },
+  {
+    id: "tool",
+    label: "Tool pins",
+    description: "Tool status, tool change, and motion tool-offset pins from HALUI, iocontrol, and motion.",
+  },
+]);
+
+export const VIRTUAL_HAL_SIMULATION_RUNTIME_CAPABILITIES = Object.freeze([
+  "realtime-hal-simulation-replacement",
+  "halcmd-simulation-replacement",
+  "motion-controller-simulation-replacement",
+  "hal-pin-signal-param-store",
+  "halcmd-setp-sets-net-show-getp-gets",
+  "userspace-load-command-stubs",
+  "servo-period-motion-step",
+  "axis-joint-position-feedback",
+  "spindle-coolant-tool-status",
+  "interpreter-hal-bridge-snapshot",
+]);
+
+export const VIRTUAL_HAL_SIMULATION_REPLACEMENT_TARGETS = Object.freeze([
+  "linuxcnc-realtime-hal",
+  "halcmd",
+  "motion-controller",
+]);
+
+export function createVirtualHalState(overrides = {}) {
+  const base = {
+    apiName: "linuxcnc-wasm-virtual-hal-state",
+    halVersion: 1,
+    source: "browser-virtual-hal",
+    component: VIRTUAL_HAL_AXISUI_PINS.component,
+    axisuiPins: VIRTUAL_HAL_AXISUI_PINS.pins.map((pin) => ({ ...pin })),
+    revision: 0,
+    positionDirty: false,
+    machineDirty: false,
+    activeAxis: "x",
+    task: {
+      estop: true,
+      powered: false,
+      state: "ESTOP",
+      mode: "manual",
+    },
+    pins: Object.fromEntries(VIRTUAL_HAL_AXISUI_PINS.pins.map((pin) => [pin.name, pin.type === "HAL_FLOAT" ? 0 : false])),
+    externalPins: {},
+    position: Object.fromEntries(VIRTUAL_HAL_AXES.map((axis) => [axis, 0])),
+    homed: Object.fromEntries(VIRTUAL_HAL_AXES.map((axis) => [axis, false])),
+    limits: Object.fromEntries(VIRTUAL_HAL_AXES.map((axis) => [
+      axis,
+      { minLimit: false, maxLimit: false, fault: "none" },
+    ])),
+    spindle: {
+      state: "off",
+      direction: "stopped",
+      speed: 0,
+      brake: false,
+    },
+    coolant: {
+      mist: "off",
+      flood: "off",
+    },
+    overrides: {
+      feed: 100,
+      rapid: 100,
+      spindle: 100,
+      limits: false,
+    },
+    program: {
+      state: "idle",
+      optionalStop: false,
+      blockDelete: false,
+      haluiMdiRunning: false,
+      line: 0,
+    },
+    tool: {
+      selected: 0,
+      current: 0,
+      pocket: 0,
+      prepPocket: 0,
+      fromPocket: 0,
+      prepIndex: 0,
+      prepNumber: 0,
+      prepare: false,
+      prepared: true,
+      change: false,
+      changed: true,
+      diameter: 0,
+      lengthOffset: Object.fromEntries(VIRTUAL_HAL_AXES.map((axis) => [axis, 0])),
+    },
+    motion: {
+      enabled: false,
+      inPosition: true,
+      motionType: 0,
+      coordMode: false,
+      teleopMode: false,
+      currentVel: 0,
+      requestedVel: 0,
+      distanceToGo: 0,
+      programLine: 0,
+      probeInput: false,
+      adaptiveFeed: 1,
+      feedHold: false,
+      feedInhibit: false,
+      homingInhibit: false,
+      jogInhibit: false,
+      jogStop: false,
+      switchkinsType: 0,
+      target: Object.fromEntries(VIRTUAL_HAL_AXES.map((axis) => [axis, 0])),
+      servoPeriod: 0.001,
+    },
+    io: {
+      digitalIn: {},
+      digitalOut: {},
+      analogIn: {},
+      analogOut: {},
+    },
+    hal: {
+      signals: {},
+      params: {},
+      nets: {},
+      functions: [],
+      threads: {
+        "servo-thread": {
+          periodNs: 1000000,
+          running: true,
+        },
+      },
+      commandLog: [],
+      loadedComponents: [],
+    },
+    jog: {
+      increment: "Continuous",
+      incrementValue: 0,
+      lastAction: "idle",
+    },
+    notifications: {
+      clear: false,
+      clearInfo: false,
+      clearError: false,
+      resumeInhibit: false,
+      error: false,
+      abort: false,
+    },
+  };
+  return normalizeVirtualHalState({
+    ...base,
+    ...overrides,
+    task: { ...base.task, ...(overrides.task ?? {}) },
+    pins: { ...base.pins, ...(overrides.pins ?? {}) },
+    externalPins: { ...base.externalPins, ...(overrides.externalPins ?? {}) },
+    position: { ...base.position, ...(overrides.position ?? {}) },
+    homed: { ...base.homed, ...(overrides.homed ?? {}) },
+    limits: mergeAxisObject(base.limits, overrides.limits),
+    spindle: { ...base.spindle, ...(overrides.spindle ?? {}) },
+    coolant: { ...base.coolant, ...(overrides.coolant ?? {}) },
+    overrides: { ...base.overrides, ...(overrides.overrides ?? {}) },
+    program: { ...base.program, ...(overrides.program ?? {}) },
+    tool: {
+      ...base.tool,
+      ...(overrides.tool ?? {}),
+      lengthOffset: { ...base.tool.lengthOffset, ...(overrides.tool?.lengthOffset ?? {}) },
+    },
+    motion: { ...base.motion, ...(overrides.motion ?? {}) },
+    io: {
+      digitalIn: { ...base.io.digitalIn, ...(overrides.io?.digitalIn ?? {}) },
+      digitalOut: { ...base.io.digitalOut, ...(overrides.io?.digitalOut ?? {}) },
+      analogIn: { ...base.io.analogIn, ...(overrides.io?.analogIn ?? {}) },
+      analogOut: { ...base.io.analogOut, ...(overrides.io?.analogOut ?? {}) },
+    },
+    hal: {
+      signals: { ...base.hal.signals, ...(overrides.hal?.signals ?? {}) },
+      params: { ...base.hal.params, ...(overrides.hal?.params ?? {}) },
+      nets: { ...base.hal.nets, ...(overrides.hal?.nets ?? {}) },
+      functions: [...base.hal.functions, ...(overrides.hal?.functions ?? [])],
+      threads: { ...base.hal.threads, ...(overrides.hal?.threads ?? {}) },
+      commandLog: [...base.hal.commandLog, ...(overrides.hal?.commandLog ?? [])],
+      loadedComponents: [...base.hal.loadedComponents, ...(overrides.hal?.loadedComponents ?? [])],
+    },
+    jog: { ...base.jog, ...(overrides.jog ?? {}) },
+    notifications: { ...base.notifications, ...(overrides.notifications ?? {}) },
+  });
+}
+
+function mergeAxisObject(base, override = {}) {
+  return Object.fromEntries(Object.entries(base).map(([axis, value]) => [
+    axis,
+    { ...value, ...(override?.[axis] ?? {}) },
+  ]));
+}
+
+export function cloneVirtualHalState(state) {
+  return {
+    ...state,
+    task: { ...(state.task ?? {}) },
+    axisuiPins: (state.axisuiPins ?? VIRTUAL_HAL_AXISUI_PINS.pins).map((pin) => ({ ...pin })),
+    pins: { ...(state.pins ?? {}) },
+    externalPins: { ...(state.externalPins ?? {}) },
+    position: { ...(state.position ?? {}) },
+    homed: { ...(state.homed ?? {}) },
+    limits: Object.fromEntries(Object.entries(state.limits ?? {}).map(([axis, limit]) => [axis, { ...limit }])),
+    spindle: { ...(state.spindle ?? {}) },
+    coolant: { ...(state.coolant ?? {}) },
+    overrides: { ...(state.overrides ?? {}) },
+    program: { ...(state.program ?? {}) },
+    tool: {
+      ...(state.tool ?? {}),
+      lengthOffset: { ...(state.tool?.lengthOffset ?? {}) },
+    },
+    motion: { ...(state.motion ?? {}) },
+    io: {
+      digitalIn: { ...(state.io?.digitalIn ?? {}) },
+      digitalOut: { ...(state.io?.digitalOut ?? {}) },
+      analogIn: { ...(state.io?.analogIn ?? {}) },
+      analogOut: { ...(state.io?.analogOut ?? {}) },
+    },
+    hal: {
+      signals: Object.fromEntries(Object.entries(state.hal?.signals ?? {}).map(([name, signal]) => [name, { ...signal, pins: [...(signal.pins ?? [])] }])),
+      params: { ...(state.hal?.params ?? {}) },
+      nets: Object.fromEntries(Object.entries(state.hal?.nets ?? {}).map(([name, pins]) => [name, [...pins]])),
+      functions: (state.hal?.functions ?? []).map((item) => ({ ...item })),
+      threads: Object.fromEntries(Object.entries(state.hal?.threads ?? {}).map(([name, thread]) => [name, { ...thread }])),
+      commandLog: (state.hal?.commandLog ?? []).map((item) => ({ ...item })),
+      loadedComponents: (state.hal?.loadedComponents ?? []).map((item) => ({ ...item })),
+    },
+    jog: { ...(state.jog ?? {}) },
+    notifications: { ...(state.notifications ?? {}) },
+  };
+}
+
+function normalizeVirtualHalState(state) {
+  const next = cloneVirtualHalState({
+    ...state,
+    axisuiPins: state.axisuiPins ?? VIRTUAL_HAL_AXISUI_PINS.pins,
+    pins: state.pins ?? {},
+    externalPins: state.externalPins ?? {},
+    hal: state.hal ?? {},
+    notifications: state.notifications ?? {},
+  });
+  next.task.state = next.task.estop ? "ESTOP" : (next.task.powered ? "ON" : "ESTOP_RESET");
+  next.task.powered = next.task.state === "ON";
+  next.task.estop = next.task.state === "ESTOP";
+  next.task.mode = ["manual", "auto", "mdi"].includes(next.task.mode) ? next.task.mode : "manual";
+  next.spindle.speed = clampNumber(next.spindle.speed, 0, 99999);
+  if (next.spindle.state !== "on") {
+    next.spindle.direction = "stopped";
+  } else if (!["cw", "ccw"].includes(next.spindle.direction)) {
+    next.spindle.direction = "cw";
+  }
+  next.coolant.mist = next.coolant.mist === "on" ? "on" : "off";
+  next.coolant.flood = next.coolant.flood === "on" ? "on" : "off";
+  next.overrides.feed = clampNumber(next.overrides.feed, 0, 200);
+  next.overrides.rapid = clampNumber(next.overrides.rapid, 0, 200);
+  next.overrides.spindle = clampNumber(next.overrides.spindle, 0, 200);
+  next.program.state = ["idle", "running", "paused"].includes(next.program.state) ? next.program.state : "idle";
+  next.program.optionalStop = next.program.optionalStop === true;
+  next.program.blockDelete = next.program.blockDelete === true;
+  next.program.haluiMdiRunning = next.program.haluiMdiRunning === true;
+  next.program.line = clampInteger(next.program.line, 0, 2147483647);
+  next.tool.selected = clampInteger(next.tool.selected, 0, 2147483647);
+  next.tool.current = clampInteger(next.tool.current, 0, 2147483647);
+  next.tool.pocket = clampInteger(next.tool.pocket, 0, 2147483647);
+  next.tool.prepPocket = clampInteger(next.tool.prepPocket, 0, 2147483647);
+  next.tool.fromPocket = clampInteger(next.tool.fromPocket, 0, 2147483647);
+  next.tool.prepIndex = clampInteger(next.tool.prepIndex, 0, 2147483647);
+  next.tool.prepNumber = clampInteger(next.tool.prepNumber, 0, 2147483647);
+  next.tool.prepare = next.tool.prepare === true;
+  next.tool.prepared = next.tool.prepared !== false;
+  next.tool.change = next.tool.change === true;
+  next.tool.changed = next.tool.changed !== false;
+  next.tool.diameter = clampNumber(next.tool.diameter, 0, 99999);
+  next.motion.enabled = next.task.powered && !next.task.estop;
+  next.motion.inPosition = next.motion.inPosition !== false;
+  next.motion.motionType = clampInteger(next.motion.motionType, 0, 2147483647);
+  next.motion.currentVel = clampNumber(next.motion.currentVel, 0, 999999);
+  next.motion.requestedVel = clampNumber(next.motion.requestedVel, 0, 999999);
+  next.motion.distanceToGo = clampNumber(next.motion.distanceToGo, 0, 999999);
+  next.motion.programLine = clampInteger(next.motion.programLine || next.program.line, 0, 2147483647);
+  next.motion.probeInput = next.motion.probeInput === true;
+  next.motion.adaptiveFeed = clampNumber(next.motion.adaptiveFeed, 0, 1);
+  next.motion.feedHold = next.motion.feedHold === true;
+  next.motion.feedInhibit = next.motion.feedInhibit === true;
+  next.motion.homingInhibit = next.motion.homingInhibit === true;
+  next.motion.jogInhibit = next.motion.jogInhibit === true;
+  next.motion.jogStop = next.motion.jogStop === true;
+  next.motion.switchkinsType = clampNumber(next.motion.switchkinsType, 0, 999);
+  next.motion.servoPeriod = clampNumber(next.motion.servoPeriod, 0.000001, 1);
+  next.motion.target = { ...(next.motion.target ?? {}) };
+  next.jog.incrementValue = parseVirtualHalJogIncrement(next.jog.increment);
+  next.pins["jog.increment"] = next.jog.incrementValue;
+  next.pins["notifications-clear"] = next.notifications.clear === true;
+  next.pins["notifications-clear-info"] = next.notifications.clearInfo === true;
+  next.pins["notifications-clear-error"] = next.notifications.clearError === true;
+  next.pins["resume-inhibit"] = next.notifications.resumeInhibit === true;
+  next.pins.error = next.notifications.error === true;
+  next.pins.abort = next.notifications.abort === true;
+  for (const axis of VIRTUAL_HAL_AXES) {
+    next.position[axis] = Number.isFinite(Number(next.position[axis])) ? Number(next.position[axis]) : 0;
+    next.homed[axis] = next.homed[axis] === true;
+    next.limits[axis] = {
+      minLimit: next.limits[axis]?.minLimit === true,
+      maxLimit: next.limits[axis]?.maxLimit === true,
+      fault: next.limits[axis]?.fault ?? "none",
+    };
+    next.pins[`jog.${axis}`] = next.pins[`jog.${axis}`] === true;
+    next.tool.lengthOffset[axis] = Number.isFinite(Number(next.tool.lengthOffset[axis])) ? Number(next.tool.lengthOffset[axis]) : 0;
+    next.motion.target[axis] = Number.isFinite(Number(next.motion.target[axis])) ? Number(next.motion.target[axis]) : next.position[axis];
+  }
+  next.hal.signals = Object.fromEntries(Object.entries(next.hal.signals ?? {}).map(([name, signal]) => [
+    name,
+    {
+      name,
+      type: signal.type ?? inferVirtualHalPinType(signal.value),
+      value: normalizeHalNumericValue(signal.value),
+      pins: [...new Set(signal.pins ?? [])],
+    },
+  ]));
+  next.hal.params = Object.fromEntries(Object.entries(next.hal.params ?? {}).map(([name, entry]) => [
+    name,
+    typeof entry === "object" && entry !== null
+      ? { ...entry, value: normalizeHalNumericValue(entry.value) }
+      : { kind: "param", name, type: inferVirtualHalPinType(entry), value: normalizeHalNumericValue(entry), connected: true },
+  ]));
+  next.hal.nets = Object.fromEntries(Object.entries(next.hal.nets ?? {}).map(([name, pins]) => [name, [...new Set(pins ?? [])]]));
+  next.hal.functions = (next.hal.functions ?? []).map((item) => ({
+    name: item.name,
+    thread: item.thread ?? "servo-thread",
+  })).filter(({ name }) => name);
+  next.hal.threads = Object.fromEntries(Object.entries(next.hal.threads ?? {}).map(([name, thread]) => [
+    name,
+    {
+      periodNs: clampInteger(thread.periodNs ?? 1000000, 1, 1000000000),
+      running: thread.running !== false,
+    },
+  ]));
+  next.hal.commandLog = (next.hal.commandLog ?? []).slice(-200).map((item) => ({ ...item }));
+  next.hal.loadedComponents = (next.hal.loadedComponents ?? []).map((item) => ({ ...item }));
+  return next;
+}
+
+function clampNumber(value, min, max) {
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric)) {
+    return min;
+  }
+  return Math.min(Math.max(numeric, min), max);
+}
+
+function clampInteger(value, min, max) {
+  return Math.trunc(clampNumber(value, min, max));
+}
+
+function normalizeHalNumericValue(value) {
+  if (typeof value === "boolean") {
+    return value ? 1 : 0;
+  }
+  const numeric = Number(value);
+  return Number.isFinite(numeric) ? numeric : 0;
+}
+
+export function parseVirtualHalJogIncrement(increment) {
+  const text = String(increment ?? "Continuous").trim();
+  if (!text || /^continuous$/i.test(text)) {
+    return 0;
+  }
+  const match = text.match(/^([-+0-9./]+)\s*(in|inch|mm|cm|um|mil)?$/i);
+  if (!match) {
+    return Number(text) || 0;
+  }
+  let value = 0;
+  if (match[1].includes("/")) {
+    const [numerator, denominator] = match[1].split("/").map(Number);
+    value = denominator ? numerator / denominator : 0;
+  } else {
+    value = Number(match[1]);
+  }
+  const unit = (match[2] ?? "in").toLowerCase();
+  if (unit === "mm") {
+    value /= 25.4;
+  } else if (unit === "cm") {
+    value /= 2.54;
+  } else if (unit === "um") {
+    value /= 25400;
+  } else if (unit === "mil") {
+    value /= 1000;
+  }
+  return Number.isFinite(value) ? value : 0;
+}
+
+export function createVirtualHalDroState(halState) {
+  const state = normalizeVirtualHalState(halState);
+  const actual = Object.fromEntries(VIRTUAL_HAL_DISPLAY_AXES.map((axis) => [axis, formatAxis(state.position[axis])]));
+  const zeroAxes = Object.fromEntries(VIRTUAL_HAL_DISPLAY_AXES.map((axis) => [axis, formatAxis(0)]));
+  return {
+    apiName: "linuxcnc-wasm-virtual-hal-dro-state",
+    droVersion: 1,
+    source: "browser-virtual-hal",
+    actual,
+    distanceToGo: { ...zeroAxes },
+    workOffsetG54: { ...zeroAxes },
+    g92Offset: { ...zeroAxes },
+    toolLengthOffset: { ...zeroAxes },
+    velocity: formatAxis(0),
+  };
+}
+
+export function createVirtualHalLimitsHomeState(halState) {
+  const state = normalizeVirtualHalState(halState);
+  return {
+    apiName: "linuxcnc-wasm-virtual-hal-limits-home-state",
+    stateVersion: 1,
+    source: "browser-virtual-hal",
+    axes: Object.fromEntries(VIRTUAL_HAL_DISPLAY_AXES.map((axis) => {
+      const limit = state.limits[axis];
+      return [axis, {
+        homed: state.homed[axis] ? "yes" : "no",
+        minLimit: limit.minLimit ? "on" : "off",
+        maxLimit: limit.maxLimit ? "on" : "off",
+        fault: limit.fault,
+      }];
+    })),
+  };
+}
+
+export function createVirtualHalMachineStatusState(halState) {
+  const state = normalizeVirtualHalState(halState);
+  return {
+    apiName: "linuxcnc-wasm-virtual-hal-machine-status-state",
+    statusVersion: 1,
+    source: "browser-virtual-hal",
+    spindle: {
+      direction: state.spindle.direction,
+      speed: `${state.spindle.speed}`,
+      state: state.spindle.state,
+    },
+    coolant: { ...state.coolant },
+    tool: {
+      selected: "0",
+      current: "0",
+      pocket: "0",
+      lengthOffset: "z=0.000",
+    },
+    overrides: {
+      feed: state.overrides.feed > 0 ? "enabled" : "disabled",
+      speed: state.overrides.spindle > 0 ? "enabled" : "disabled",
+      adaptiveFeed: "disabled",
+      feedHold: "enabled",
+    },
+  };
+}
+
+export function createVirtualHalSystemCoverageReport(options = {}) {
+  const halState = options.halState ?? createVirtualHalState();
+  const snapshot = options.snapshot ?? createVirtualHalWasmBridgeSnapshot(halState);
+  const families = options.families ?? VIRTUAL_HAL_SYSTEM_PIN_FAMILIES;
+  const requiredFamilyIds = options.requiredFamilyIds ?? families.map(({ id }) => id);
+  const familyIds = new Set(families.map(({ id }) => id));
+  const missingFamilies = requiredFamilyIds.filter((id) => !familyIds.has(id));
+  const snapshotPins = new Set((snapshot.values ?? [])
+    .filter(({ kind }) => kind === "pin")
+    .map(({ name }) => name));
+  const declaredRows = families.flatMap((family) => expandVirtualHalFamilyPins(family).map((pin) => ({
+    id: `${family.id}:${pin.name}`,
+    familyId: family.id,
+    familyLabel: family.label,
+    component: family.component,
+    name: pin.name,
+    type: pin.type,
+    direction: pin.direction,
+    coverage: family.coverage,
+    sourceFiles: [...family.sourceFiles],
+    sourceEvidence: family.sourceEvidence,
+    representedInSnapshot: snapshotPins.has(pin.name),
+    template: pin.template === true,
+    conditional: pin.conditional ?? null,
+  })));
+  const declaredPinNames = new Set(declaredRows.map(({ name }) => name));
+  const unclassifiedSnapshotPins = [...snapshotPins].filter((name) => {
+    if (declaredPinNames.has(name)) {
+      return false;
+    }
+    return !isInternalAxisUiPinName(name);
+  });
+  const missingSourceFamilies = families
+    .filter((family) => !Array.isArray(family.sourceFiles) || family.sourceFiles.length === 0)
+    .map(({ id }) => id);
+  const coverageCounts = Object.fromEntries(
+    Object.values(VIRTUAL_HAL_COVERAGE_STATES).map((coverage) => [
+      coverage,
+      families.filter((family) => family.coverage === coverage).length,
+    ]),
+  );
+  const boundaryFamilies = families.filter((family) => family.coverage !== VIRTUAL_HAL_COVERAGE_STATES.simulated);
+  const complete = missingFamilies.length === 0 &&
+    missingSourceFamilies.length === 0 &&
+    unclassifiedSnapshotPins.length === 0 &&
+    declaredRows.length > 0;
+  return {
+    apiName: "linuxcnc-wasm-virtual-hal-system-coverage-report",
+    coverageVersion: 1,
+    source: "linuxcnc-source-derived-virtual-hal",
+    phase: complete ? "covered-with-runtime-boundaries" : "incomplete",
+    complete,
+    realtimeHalRuntime: false,
+    sourceFiles: [...new Set(families.flatMap((family) => family.sourceFiles))],
+    familyCount: families.length,
+    declaredPinCount: declaredRows.length,
+    snapshotPinCount: snapshot.values?.length ?? 0,
+    coverageCounts,
+    requiredFamilyIds: [...requiredFamilyIds],
+    missingFamilies,
+    missingSourceFamilies,
+    unclassifiedSnapshotPins,
+    families: families.map((family) => {
+      const familyRows = declaredRows.filter((row) => row.familyId === family.id);
+      return {
+        id: family.id,
+        component: family.component,
+        label: family.label,
+        coverage: family.coverage,
+        sourceFiles: [...family.sourceFiles],
+        sourceEvidence: family.sourceEvidence,
+        declaredPinCount: familyRows.length,
+        representedPinCount: familyRows.filter(({ representedInSnapshot }) => representedInSnapshot).length,
+      };
+    }),
+    boundaryRows: boundaryFamilies.map((family) => ({
+      id: family.id,
+      label: family.label,
+      coverage: family.coverage,
+      reason: family.coverage === VIRTUAL_HAL_COVERAGE_STATES.runtimeBoundary
+        ? "Requires LinuxCNC realtime task/motion/HAL process evidence, not JavaScript emulation."
+        : "Source pin family is inventoried and bridged where useful, but process semantics remain LinuxCNC-owned.",
+      sourceFiles: [...family.sourceFiles],
+    })),
+    declaredRows,
+    rows: [
+      {
+        id: "families",
+        label: "Source-derived HAL families",
+        value: `${families.length}`,
+      },
+      {
+        id: "declared-pins",
+        label: "Declared source pins",
+        value: `${declaredRows.length}`,
+      },
+      {
+        id: "snapshot-pins",
+        label: "Bridge snapshot pins",
+        value: `${snapshot.values?.length ?? 0}`,
+      },
+      {
+        id: "runtime-boundaries",
+        label: "Explicit runtime boundaries",
+        value: `${boundaryFamilies.length}`,
+      },
+    ],
+  };
+}
+
+export function applyVirtualHalAction(halState, action, options = {}) {
+  const next = normalizeVirtualHalState(halState);
+  const axis = VIRTUAL_HAL_AXES.includes(String(options.axis ?? next.activeAxis).toLowerCase())
+    ? String(options.axis ?? next.activeAxis).toLowerCase()
+    : "x";
+  const increment = options.increment ?? next.jog.increment;
+  const direction = Number(options.direction ?? 1) >= 0 ? 1 : -1;
+  next.activeAxis = axis;
+  next.positionDirty = false;
+  next.machineDirty = true;
+
+  if (action === "estop") {
+    if (next.task.estop) {
+      next.task.estop = false;
+      next.task.powered = false;
+      next.task.state = "ESTOP_RESET";
+    } else {
+      next.task.estop = true;
+      next.task.powered = false;
+      next.task.state = "ESTOP";
+      next.notifications.abort = true;
+      next.spindle.state = "off";
+      next.coolant.mist = "off";
+      next.coolant.flood = "off";
+    }
+    next.jog.lastAction = next.task.state;
+  } else if (action === "power") {
+    if (next.task.estop) {
+      next.task.powered = false;
+      next.task.state = "ESTOP";
+    } else {
+      next.task.powered = !next.task.powered;
+      next.task.state = next.task.powered ? "ON" : "ESTOP_RESET";
+    }
+    next.jog.lastAction = next.task.state;
+  } else if (action === "home" || action === "home-all") {
+    if (next.task.powered && !next.task.estop) {
+      const axes = action === "home-all" ? VIRTUAL_HAL_AXES : [axis];
+      for (const item of axes) {
+        next.homed[item] = true;
+        next.limits[item] = { minLimit: false, maxLimit: false, fault: "none" };
+      }
+      next.jog.lastAction = action;
+    } else {
+      next.notifications.error = true;
+      next.limits[axis].fault = "machine-not-on";
+      next.jog.lastAction = `${action}-blocked`;
+    }
+  } else if (action === "unhome-all") {
+    for (const item of VIRTUAL_HAL_AXES) {
+      next.homed[item] = false;
+    }
+    next.jog.lastAction = action;
+  } else if (action === "jog") {
+    for (const item of VIRTUAL_HAL_AXES) {
+      next.pins[`jog.${item}`] = false;
+    }
+    next.jog.increment = increment;
+    next.jog.incrementValue = parseVirtualHalJogIncrement(increment);
+    next.pins[`jog.${axis}`] = true;
+    next.pins["jog.increment"] = next.jog.incrementValue;
+    const distance = next.jog.incrementValue || Number(options.continuousStep ?? 0.1);
+    if (next.task.powered && !next.task.estop) {
+      next.position[axis] += direction * distance;
+      next.positionDirty = true;
+      next.jog.lastAction = `jog ${axis} ${direction > 0 ? "+" : "-"}`;
+    } else {
+      next.notifications.error = true;
+      next.jog.lastAction = `jog ${axis} blocked`;
+    }
+  } else if (action === "touch-off" || action === "zero-g54") {
+    next.position[axis] = Number(options.value ?? 0) || 0;
+    next.positionDirty = true;
+    next.jog.lastAction = `${action} ${axis}`;
+  } else if (action === "tool-touch-off") {
+    next.position.z = Number(options.value ?? next.position.z) || 0;
+    next.positionDirty = true;
+    next.jog.lastAction = "tool touch off";
+  } else if (action === "spindle") {
+    const command = options.command ?? "toggle";
+    if (command === "stop" || (command === "toggle" && next.spindle.state === "on")) {
+      next.spindle.state = "off";
+      next.spindle.direction = "stopped";
+    } else {
+      next.spindle.state = "on";
+      next.spindle.direction = command === "ccw" ? "ccw" : "cw";
+    }
+    next.spindle.speed = clampNumber(options.speed ?? (next.spindle.speed || 1200), 0, 99999);
+    next.jog.lastAction = `spindle ${next.spindle.direction}`;
+  } else if (action === "coolant") {
+    const name = options.name === "flood" ? "flood" : "mist";
+    next.coolant[name] = options.enabled === true ? "on" : "off";
+    next.jog.lastAction = `coolant ${name} ${next.coolant[name]}`;
+  } else if (action === "override-limits") {
+    next.overrides.limits = options.enabled === true;
+    next.jog.lastAction = `override limits ${next.overrides.limits ? "on" : "off"}`;
+  } else if (action === "spindle-brake") {
+    next.spindle.brake = options.enabled === true;
+    next.jog.lastAction = `spindle brake ${next.spindle.brake ? "on" : "off"}`;
+  } else if (action === "clear-notifications") {
+    next.notifications.clear = true;
+    next.notifications.clearInfo = options.level === "info";
+    next.notifications.clearError = options.level === "error";
+    next.notifications.error = false;
+    next.notifications.abort = false;
+    next.jog.lastAction = "clear notifications";
+  } else {
+    next.jog.lastAction = String(action ?? "manual");
+  }
+
+  next.revision += 1;
+  return normalizeVirtualHalState(next);
+}
+
+export function createVirtualHalWasmBridgeSnapshot(halState) {
+  const state = normalizeVirtualHalState(halState);
+  return {
+    apiName: "linuxcnc-wasm-virtual-hal-bridge-snapshot",
+    bridgeVersion: 1,
+    source: "browser-virtual-hal",
+    values: [
+      ...Object.entries(state.pins).flatMap(([name, value]) => {
+        const entry = {
+          kind: "pin",
+          name,
+          type: typeof value === "number" ? "HAL_FLOAT" : "HAL_BIT",
+          value: typeof value === "number" ? value : value === true ? 1 : 0,
+          connected: true,
+        };
+        return [
+          entry,
+          {
+            ...entry,
+            name: `${state.component}.${name}`,
+          },
+        ];
+      }),
+      ...Object.entries(state.position).map(([axis, value]) => ({
+        kind: "pin",
+        name: `axis.${axis}.pos-cmd`,
+        type: "HAL_FLOAT",
+        value,
+        connected: true,
+      })),
+      ...Object.entries(state.homed).map(([axis, value]) => ({
+        kind: "pin",
+        name: `axis.${axis}.homed`,
+        type: "HAL_BIT",
+        value: value ? 1 : 0,
+        connected: true,
+      })),
+      { kind: "pin", name: "iocontrol.0.user-enable-out", type: "HAL_BIT", value: state.task.powered ? 1 : 0, connected: true },
+      { kind: "pin", name: "iocontrol.0.emc-enable-in", type: "HAL_BIT", value: state.task.estop ? 0 : 1, connected: true },
+      { kind: "pin", name: "iocontrol.0.user-request-enable", type: "HAL_BIT", value: state.task.estop ? 0 : 1, connected: true },
+      { kind: "pin", name: "halui.machine.is-on", type: "HAL_BIT", value: state.task.powered ? 1 : 0, connected: true },
+      { kind: "pin", name: "halui.estop.is-activated", type: "HAL_BIT", value: state.task.estop ? 1 : 0, connected: true },
+      { kind: "pin", name: "halui.mode.is-manual", type: "HAL_BIT", value: state.task.mode === "manual" ? 1 : 0, connected: true },
+      { kind: "pin", name: "halui.mode.is-auto", type: "HAL_BIT", value: state.task.mode === "auto" ? 1 : 0, connected: true },
+      { kind: "pin", name: "halui.mode.is-mdi", type: "HAL_BIT", value: state.task.mode === "mdi" ? 1 : 0, connected: true },
+      { kind: "pin", name: "halui.program.is-idle", type: "HAL_BIT", value: state.program.state === "idle" ? 1 : 0, connected: true },
+      { kind: "pin", name: "halui.program.is-running", type: "HAL_BIT", value: state.program.state === "running" ? 1 : 0, connected: true },
+      { kind: "pin", name: "halui.program.is-paused", type: "HAL_BIT", value: state.program.state === "paused" ? 1 : 0, connected: true },
+      { kind: "pin", name: "halui.program.optional-stop.is-on", type: "HAL_BIT", value: state.program.optionalStop ? 1 : 0, connected: true },
+      { kind: "pin", name: "halui.program.block-delete.is-on", type: "HAL_BIT", value: state.program.blockDelete ? 1 : 0, connected: true },
+      { kind: "pin", name: "halui.halui-mdi-is-running", type: "HAL_BIT", value: state.program.haluiMdiRunning ? 1 : 0, connected: true },
+      { kind: "pin", name: "motion.enable", type: "HAL_BIT", value: state.motion.enabled ? 1 : 0, connected: true },
+      { kind: "pin", name: "motion.motion-enabled", type: "HAL_BIT", value: state.motion.enabled ? 1 : 0, connected: true },
+      { kind: "pin", name: "motion.in-position", type: "HAL_BIT", value: state.motion.inPosition ? 1 : 0, connected: true },
+      { kind: "pin", name: "motion.motion-type", type: "HAL_S32", value: state.motion.motionType, connected: true },
+      { kind: "pin", name: "motion.coord-mode", type: "HAL_BIT", value: state.motion.coordMode ? 1 : 0, connected: true },
+      { kind: "pin", name: "motion.teleop-mode", type: "HAL_BIT", value: state.motion.teleopMode ? 1 : 0, connected: true },
+      { kind: "pin", name: "motion.current-vel", type: "HAL_FLOAT", value: state.motion.currentVel, connected: true },
+      { kind: "pin", name: "motion.requested-vel", type: "HAL_FLOAT", value: state.motion.requestedVel, connected: true },
+      { kind: "pin", name: "motion.distance-to-go", type: "HAL_FLOAT", value: state.motion.distanceToGo, connected: true },
+      { kind: "pin", name: "motion.program-line", type: "HAL_S32", value: state.motion.programLine, connected: true },
+      { kind: "pin", name: "motion.probe-input", type: "HAL_BIT", value: state.motion.probeInput ? 1 : 0, connected: true },
+      { kind: "pin", name: "motion.adaptive-feed", type: "HAL_FLOAT", value: state.motion.adaptiveFeed, connected: true },
+      { kind: "pin", name: "motion.feed-hold", type: "HAL_BIT", value: state.motion.feedHold ? 1 : 0, connected: true },
+      { kind: "pin", name: "motion.feed-inhibit", type: "HAL_BIT", value: state.motion.feedInhibit ? 1 : 0, connected: true },
+      { kind: "pin", name: "motion.homing-inhibit", type: "HAL_BIT", value: state.motion.homingInhibit ? 1 : 0, connected: true },
+      { kind: "pin", name: "motion.jog-inhibit", type: "HAL_BIT", value: state.motion.jogInhibit ? 1 : 0, connected: true },
+      { kind: "pin", name: "motion.switchkins-type", type: "HAL_FLOAT", value: state.motion.switchkinsType, connected: true },
+      { kind: "pin", name: "spindle.0.speed-out", type: "HAL_FLOAT", value: state.spindle.speed, connected: true },
+      { kind: "pin", name: "spindle.0.speed-out-abs", type: "HAL_FLOAT", value: Math.abs(state.spindle.speed), connected: true },
+      { kind: "pin", name: "spindle.0.on", type: "HAL_BIT", value: state.spindle.state === "on" ? 1 : 0, connected: true },
+      { kind: "pin", name: "spindle.0.forward", type: "HAL_BIT", value: state.spindle.direction === "cw" ? 1 : 0, connected: true },
+      { kind: "pin", name: "spindle.0.reverse", type: "HAL_BIT", value: state.spindle.direction === "ccw" ? 1 : 0, connected: true },
+      { kind: "pin", name: "spindle.0.brake", type: "HAL_BIT", value: state.spindle.brake ? 1 : 0, connected: true },
+      { kind: "pin", name: "spindle.0.at-speed", type: "HAL_BIT", value: state.spindle.state === "on" ? 1 : 0, connected: true },
+      { kind: "pin", name: "halui.spindle.0.is-on", type: "HAL_BIT", value: state.spindle.state === "on" ? 1 : 0, connected: true },
+      { kind: "pin", name: "halui.spindle.0.override.value", type: "HAL_FLOAT", value: state.overrides.spindle / 100, connected: true },
+      { kind: "pin", name: "iocontrol.0.coolant-mist", type: "HAL_BIT", value: state.coolant.mist === "on" ? 1 : 0, connected: true },
+      { kind: "pin", name: "iocontrol.0.coolant-flood", type: "HAL_BIT", value: state.coolant.flood === "on" ? 1 : 0, connected: true },
+      { kind: "pin", name: "halui.mist.is-on", type: "HAL_BIT", value: state.coolant.mist === "on" ? 1 : 0, connected: true },
+      { kind: "pin", name: "halui.flood.is-on", type: "HAL_BIT", value: state.coolant.flood === "on" ? 1 : 0, connected: true },
+      { kind: "pin", name: "halui.feed-override.value", type: "HAL_FLOAT", value: state.overrides.feed / 100, connected: true },
+      { kind: "pin", name: "halui.rapid-override.value", type: "HAL_FLOAT", value: state.overrides.rapid / 100, connected: true },
+      { kind: "pin", name: "halui.tool.number", type: "HAL_U32", value: state.tool.current, connected: true },
+      { kind: "pin", name: "halui.tool.diameter", type: "HAL_FLOAT", value: state.tool.diameter, connected: true },
+      { kind: "pin", name: "iocontrol.0.tool-prep-pocket", type: "HAL_S32", value: state.tool.prepPocket, connected: true },
+      { kind: "pin", name: "iocontrol.0.tool-from-pocket", type: "HAL_S32", value: state.tool.fromPocket, connected: true },
+      { kind: "pin", name: "iocontrol.0.tool-prep-index", type: "HAL_S32", value: state.tool.prepIndex, connected: true },
+      { kind: "pin", name: "iocontrol.0.tool-prep-number", type: "HAL_S32", value: state.tool.prepNumber || state.tool.selected, connected: true },
+      { kind: "pin", name: "iocontrol.0.tool-number", type: "HAL_S32", value: state.tool.current, connected: true },
+      { kind: "pin", name: "iocontrol.0.tool-prepare", type: "HAL_BIT", value: state.tool.prepare ? 1 : 0, connected: true },
+      { kind: "pin", name: "iocontrol.0.tool-prepared", type: "HAL_BIT", value: state.tool.prepared ? 1 : 0, connected: true },
+      { kind: "pin", name: "iocontrol.0.tool-change", type: "HAL_BIT", value: state.tool.change ? 1 : 0, connected: true },
+      { kind: "pin", name: "iocontrol.0.tool-changed", type: "HAL_BIT", value: state.tool.changed ? 1 : 0, connected: true },
+      ...Object.entries(state.position).flatMap(([axis, value], index) => [
+        { kind: "pin", name: `axis.${axis}.teleop-pos-cmd`, type: "HAL_FLOAT", value, connected: true },
+        { kind: "pin", name: `axis.${axis}.teleop-vel-cmd`, type: "HAL_FLOAT", value: 0, connected: true },
+        { kind: "pin", name: `axis.${axis}.teleop-vel-lim`, type: "HAL_FLOAT", value: state.motion.requestedVel, connected: true },
+        { kind: "pin", name: `axis.${axis}.teleop-tp-enable`, type: "HAL_BIT", value: state.task.powered ? 1 : 0, connected: true },
+        { kind: "pin", name: `axis.${axis}.jog-enable`, type: "HAL_BIT", value: state.pins[`jog.${axis}`] ? 1 : 0, connected: true },
+        { kind: "pin", name: `axis.${axis}.jog-scale`, type: "HAL_FLOAT", value: state.jog.incrementValue, connected: true },
+        { kind: "pin", name: `axis.${axis}.jog-counts`, type: "HAL_S32", value: state.pins[`jog.${axis}`] ? 1 : 0, connected: true },
+        { kind: "pin", name: `axis.${axis}.jog-vel-mode`, type: "HAL_BIT", value: state.jog.incrementValue === 0 ? 1 : 0, connected: true },
+        { kind: "pin", name: `halui.axis.${axis}.pos-commanded`, type: "HAL_FLOAT", value, connected: true },
+        { kind: "pin", name: `halui.axis.${axis}.pos-feedback`, type: "HAL_FLOAT", value, connected: true },
+        { kind: "pin", name: `halui.axis.${axis}.pos-relative`, type: "HAL_FLOAT", value, connected: true },
+        { kind: "pin", name: `halui.axis.${axis}.is-selected`, type: "HAL_BIT", value: state.activeAxis === axis ? 1 : 0, connected: true },
+        { kind: "pin", name: `motion.tooloffset.${axis}`, type: "HAL_FLOAT", value: state.tool.lengthOffset[axis], connected: true },
+        { kind: "pin", name: `halui.tool.length_offset.${axis}`, type: "HAL_FLOAT", value: state.tool.lengthOffset[axis], connected: true },
+        { kind: "pin", name: `joint.${index}.pos-cmd`, type: "HAL_FLOAT", value, connected: true },
+        { kind: "pin", name: `joint.${index}.coarse-pos-cmd`, type: "HAL_FLOAT", value, connected: true },
+        { kind: "pin", name: `joint.${index}.pos-fb`, type: "HAL_FLOAT", value, connected: true },
+        { kind: "pin", name: `joint.${index}.motor-pos-cmd`, type: "HAL_FLOAT", value, connected: true },
+        { kind: "pin", name: `joint.${index}.motor-pos-fb`, type: "HAL_FLOAT", value, connected: true },
+        { kind: "pin", name: `joint.${index}.amp-enable-out`, type: "HAL_BIT", value: state.task.powered ? 1 : 0, connected: true },
+        { kind: "pin", name: `joint.${index}.homed`, type: "HAL_BIT", value: state.homed[axis] ? 1 : 0, connected: true },
+        { kind: "pin", name: `joint.${index}.homing`, type: "HAL_BIT", value: 0, connected: true },
+        { kind: "pin", name: `joint.${index}.home-state`, type: "HAL_S32", value: state.homed[axis] ? 1 : 0, connected: true },
+        { kind: "pin", name: `joint.${index}.home-sw-in`, type: "HAL_BIT", value: state.homed[axis] ? 1 : 0, connected: true },
+        { kind: "pin", name: `joint.${index}.pos-lim-sw-in`, type: "HAL_BIT", value: state.limits[axis]?.maxLimit ? 1 : 0, connected: true },
+        { kind: "pin", name: `joint.${index}.neg-lim-sw-in`, type: "HAL_BIT", value: state.limits[axis]?.minLimit ? 1 : 0, connected: true },
+        { kind: "pin", name: `joint.${index}.pos-hard-limit`, type: "HAL_BIT", value: state.limits[axis]?.maxLimit ? 1 : 0, connected: true },
+        { kind: "pin", name: `joint.${index}.neg-hard-limit`, type: "HAL_BIT", value: state.limits[axis]?.minLimit ? 1 : 0, connected: true },
+        { kind: "pin", name: `joint.${index}.error`, type: "HAL_BIT", value: state.limits[axis]?.fault === "none" ? 0 : 1, connected: true },
+        { kind: "pin", name: `joint.${index}.faulted`, type: "HAL_BIT", value: state.limits[axis]?.fault === "none" ? 0 : 1, connected: true },
+        { kind: "pin", name: `halui.joint.${index}.is-homed`, type: "HAL_BIT", value: state.homed[axis] ? 1 : 0, connected: true },
+      ]),
+      ...Object.values(state.externalPins ?? {}).map((entry) => ({
+        kind: entry.kind ?? "pin",
+        name: entry.name,
+        type: entry.type ?? "HAL_FLOAT",
+        value: Number(entry.value) || 0,
+        connected: entry.connected !== false,
+      })),
+      ...Object.values(state.hal.signals ?? {}).map((entry) => ({
+        kind: "signal",
+        name: entry.name,
+        type: entry.type ?? "HAL_FLOAT",
+        value: normalizeHalNumericValue(entry.value),
+        connected: (entry.pins ?? []).length > 0,
+      })),
+      ...Object.entries(state.hal.params ?? {}).map(([name, entry]) => ({
+        kind: "param",
+        name,
+        type: entry.type ?? "HAL_FLOAT",
+        value: normalizeHalNumericValue(entry.value),
+        connected: entry.connected !== false,
+      })),
+    ],
+  };
+}
+
+export function createVirtualHalPinRegistry(halState = createVirtualHalState()) {
+  const state = normalizeVirtualHalState(halState);
+  const snapshot = createVirtualHalWasmBridgeSnapshot(state);
+  const systemCoverage = createVirtualHalSystemCoverageReport({ halState: state, snapshot });
+  const snapshotRows = snapshot.values.map((value) => ({
+    id: `${value.kind}:${value.name}`,
+    kind: value.kind,
+    name: value.name,
+    type: value.type,
+    value: value.value,
+    connected: value.connected !== false,
+    group: classifyVirtualHalPinGroup(value.name),
+    coverage: resolveVirtualHalCoverageForPin(value.name),
+    writable: isVirtualHalPinWritable(value.name),
+    sourceFiles: resolveVirtualHalSourceFilesForPin(value.name),
+    representedInSnapshot: true,
+  }));
+  const snapshotNames = new Set(snapshotRows.map(({ name }) => name));
+  const declaredRows = systemCoverage.declaredRows
+    .filter(({ name }) => !snapshotNames.has(name))
+    .map((row) => ({
+      id: `pin:${row.name}`,
+      kind: "pin",
+      name: row.name,
+      type: row.type,
+      value: resolveVirtualHalDeclaredPinValue(state, row.name, row.type),
+      connected: true,
+      group: classifyVirtualHalPinGroup(row.name),
+      coverage: row.coverage,
+      writable: isVirtualHalPinWritable(row.name),
+      sourceFiles: [...row.sourceFiles],
+      representedInSnapshot: false,
+      template: row.template,
+      conditional: row.conditional,
+    }));
+  const rows = [...snapshotRows, ...declaredRows];
+  return {
+    apiName: "linuxcnc-wasm-virtual-hal-pin-registry",
+    registryVersion: 1,
+    source: "linuxcnc-source-derived-virtual-hal",
+    pinCount: rows.length,
+    snapshotPinCount: snapshotRows.length,
+    declaredOnlyPinCount: declaredRows.length,
+    groups: VIRTUAL_HAL_PROJECT_PIN_GROUPS.map((group) => ({
+      ...group,
+      pinCount: rows.filter((row) => row.group === group.id).length,
+    })),
+    rows,
+    byName: Object.fromEntries(rows.map((row) => [row.name, row])),
+  };
+}
+
+export function readVirtualHalPin(halState, name) {
+  const registry = createVirtualHalPinRegistry(halState);
+  return registry.byName[String(name ?? "")] ?? null;
+}
+
+export function writeVirtualHalPin(halState, update, options = {}) {
+  const name = typeof update === "string" ? update : update?.name;
+  if (!name) {
+    throw new Error("writeVirtualHalPin requires a HAL pin name");
+  }
+  const next = normalizeVirtualHalState(halState);
+  const value = typeof update === "string" ? options.value : update.value;
+  const numeric = Number(value) || 0;
+  const enabled = value === true || numeric !== 0;
+  const shortAxisui = name.startsWith(`${next.component}.`) ? name.slice(next.component.length + 1) : name;
+
+  if (shortAxisui in next.pins) {
+    next.pins[shortAxisui] = typeof next.pins[shortAxisui] === "number" ? numeric : enabled;
+  } else if (name === "iocontrol.0.emc-enable-in" || name === "halui.estop.reset") {
+    next.task.estop = !enabled;
+  } else if (name === "halui.estop.activate") {
+    next.task.estop = enabled;
+    if (enabled) {
+      next.task.powered = false;
+    }
+  } else if (name === "iocontrol.0.user-enable-out" || name === "halui.machine.is-on" || name === "halui.machine.on") {
+    next.task.powered = enabled && !next.task.estop;
+  } else if (name === "halui.machine.off") {
+    next.task.powered = enabled ? false : next.task.powered;
+  } else if (name === "halui.mode.manual") {
+    next.task.mode = enabled ? "manual" : next.task.mode;
+  } else if (name === "halui.mode.auto") {
+    next.task.mode = enabled ? "auto" : next.task.mode;
+  } else if (name === "halui.mode.mdi") {
+    next.task.mode = enabled ? "mdi" : next.task.mode;
+  } else if (name === "halui.program.run") {
+    next.program.state = enabled ? "running" : next.program.state;
+  } else if (name === "halui.program.pause") {
+    next.program.state = enabled ? "paused" : next.program.state;
+  } else if (name === "halui.program.resume") {
+    next.program.state = enabled ? "running" : next.program.state;
+  } else if (name === "halui.program.stop") {
+    next.program.state = enabled ? "idle" : next.program.state;
+  } else if (name === "halui.program.optional-stop.on") {
+    next.program.optionalStop = enabled;
+  } else if (name === "halui.program.optional-stop.off") {
+    next.program.optionalStop = enabled ? false : next.program.optionalStop;
+  } else if (name === "halui.program.block-delete.on") {
+    next.program.blockDelete = enabled;
+  } else if (name === "halui.program.block-delete.off") {
+    next.program.blockDelete = enabled ? false : next.program.blockDelete;
+  } else if (name === "iocontrol.0.coolant-mist" || name === "halui.mist.is-on" || name === "halui.mist.on") {
+    next.coolant.mist = enabled ? "on" : "off";
+  } else if (name === "halui.mist.off") {
+    next.coolant.mist = enabled ? "off" : next.coolant.mist;
+  } else if (name === "iocontrol.0.coolant-flood" || name === "halui.flood.is-on" || name === "halui.flood.on") {
+    next.coolant.flood = enabled ? "on" : "off";
+  } else if (name === "halui.flood.off") {
+    next.coolant.flood = enabled ? "off" : next.coolant.flood;
+  } else if (name === "spindle.0.speed-out" || name === "spindle.0.speed-out-abs") {
+    next.spindle.speed = numeric;
+    next.spindle.state = numeric > 0 ? "on" : next.spindle.state;
+  } else if (name === "spindle.0.on" || name === "halui.spindle.0.is-on" || name === "halui.spindle.0.start") {
+    next.spindle.state = enabled ? "on" : "off";
+  } else if (name === "halui.spindle.0.stop") {
+    next.spindle.state = enabled ? "off" : next.spindle.state;
+  } else if (name === "spindle.0.forward" || name === "halui.spindle.0.forward") {
+    next.spindle.state = enabled ? "on" : next.spindle.state;
+    next.spindle.direction = enabled ? "cw" : next.spindle.direction;
+  } else if (name === "spindle.0.reverse" || name === "halui.spindle.0.reverse") {
+    next.spindle.state = enabled ? "on" : next.spindle.state;
+    next.spindle.direction = enabled ? "ccw" : next.spindle.direction;
+  } else if (name === "spindle.0.brake") {
+    next.spindle.brake = enabled;
+  } else if (name === "halui.feed-override.value") {
+    next.overrides.feed = numeric <= 2 ? numeric * 100 : numeric;
+  } else if (name === "halui.rapid-override.value") {
+    next.overrides.rapid = numeric <= 2 ? numeric * 100 : numeric;
+  } else if (name === "halui.spindle.0.override.value") {
+    next.overrides.spindle = numeric <= 2 ? numeric * 100 : numeric;
+  } else if (name === "halui.tool.number" || name === "iocontrol.0.tool-number") {
+    next.tool.current = numeric;
+    next.tool.selected = numeric;
+  } else if (name === "halui.tool.diameter") {
+    next.tool.diameter = numeric;
+  } else if (name === "iocontrol.0.tool-prepare") {
+    next.tool.prepare = enabled;
+  } else if (name === "iocontrol.0.tool-prepared") {
+    next.tool.prepared = enabled;
+  } else if (name === "iocontrol.0.tool-change") {
+    next.tool.change = enabled;
+  } else if (name === "iocontrol.0.tool-changed") {
+    next.tool.changed = enabled;
+  } else if (name === "motion.current-vel") {
+    next.motion.currentVel = numeric;
+  } else if (name === "motion.requested-vel") {
+    next.motion.requestedVel = numeric;
+  } else if (name === "motion.distance-to-go") {
+    next.motion.distanceToGo = numeric;
+  } else if (name === "motion.program-line") {
+    next.motion.programLine = numeric;
+    next.program.line = numeric;
+  } else if (name === "motion.probe-input") {
+    next.motion.probeInput = enabled;
+  } else if (name === "motion.adaptive-feed") {
+    next.motion.adaptiveFeed = numeric;
+  } else if (name === "motion.feed-hold") {
+    next.motion.feedHold = enabled;
+  } else if (name === "motion.switchkins-type") {
+    next.motion.switchkinsType = numeric;
+  } else if (applyAxisPinWrite(next, name, numeric, enabled) === false) {
+    if (options.allowExternal === false) {
+      throw new Error(`unknown virtual HAL pin: ${name}`);
+    }
+    next.externalPins[name] = {
+      kind: update.kind ?? "pin",
+      name,
+      type: update.type ?? inferVirtualHalPinType(value),
+      value: numeric,
+      connected: update.connected !== false,
+    };
+  }
+
+  next.revision += 1;
+  return normalizeVirtualHalState(next);
+}
+
+export function applyVirtualHalPinUpdates(halState, updates = [], options = {}) {
+  return [...updates].reduce((state, update) => writeVirtualHalPin(state, update, options), halState);
+}
+
+export function createVirtualHalIntegrityReport(options = {}) {
+  const state = normalizeVirtualHalState(options.halState ?? createVirtualHalState());
+  const registry = options.registry ?? createVirtualHalPinRegistry(state);
+  const systemCoverage = options.systemCoverage ?? createVirtualHalSystemCoverageReport({
+    halState: state,
+    snapshot: createVirtualHalWasmBridgeSnapshot(state),
+  });
+  const requiredPins = options.requiredPins ?? [
+    "axisui.jog.x",
+    "halui.machine.is-on",
+    "iocontrol.0.emc-enable-in",
+    "motion.current-vel",
+    "axis.x.pos-cmd",
+    "joint.0.homed",
+    "spindle.0.speed-out",
+    "iocontrol.0.tool-change",
+  ];
+  const pinNames = registry.rows.map(({ name }) => name);
+  const duplicatePins = pinNames.filter((name, index) => pinNames.indexOf(name) !== index);
+  const missingPins = requiredPins.filter((name) => !registry.byName[name]);
+  const externalPinCount = Object.keys(state.externalPins ?? {}).length;
+  const complete = systemCoverage.complete &&
+    duplicatePins.length === 0 &&
+    missingPins.length === 0 &&
+    registry.pinCount > 0;
+  return {
+    apiName: "linuxcnc-wasm-virtual-hal-integrity-report",
+    integrityVersion: 1,
+    source: "linuxcnc-source-derived-virtual-hal",
+    phase: complete ? "complete" : "incomplete",
+    complete,
+    realtimeHalRuntime: false,
+    registryPinCount: registry.pinCount,
+    declaredPinCount: systemCoverage.declaredPinCount,
+    requiredPins,
+    missingPins,
+    duplicatePins: [...new Set(duplicatePins)],
+    externalPinCount,
+    systemCoveragePhase: systemCoverage.phase,
+    rows: [
+      { id: "registry", label: "Virtual HAL registry", value: `${registry.pinCount} pins` },
+      { id: "coverage", label: "Source coverage", value: systemCoverage.phase },
+      { id: "required-pins", label: "Required pins", value: missingPins.length === 0 ? "covered" : `missing ${missingPins.length}` },
+      { id: "external-pins", label: "External pins", value: `${externalPinCount}` },
+    ],
+  };
+}
+
+export function createVirtualHalPinInventory(halState = createVirtualHalState()) {
+  const state = normalizeVirtualHalState(halState);
+  const snapshot = createVirtualHalWasmBridgeSnapshot(state);
+  const systemCoverage = createVirtualHalSystemCoverageReport({ halState: state, snapshot });
+  const rows = snapshot.values.map((value) => ({
+    id: `${value.kind}:${value.name}`,
+    kind: value.kind,
+    name: value.name,
+    type: value.type,
+    connected: value.connected !== false,
+    group: classifyVirtualHalPinGroup(value.name),
+    coverage: resolveVirtualHalCoverageForPin(value.name),
+  }));
+  return {
+    apiName: "linuxcnc-wasm-virtual-hal-pin-inventory",
+    inventoryVersion: 1,
+    source: "linuxcnc-source-derived-virtual-hal",
+    component: state.component,
+    axisCount: VIRTUAL_HAL_AXES.length,
+    displayedAxisCount: VIRTUAL_HAL_DISPLAY_AXES.length,
+    pinCount: rows.length,
+    declaredPinCount: systemCoverage.declaredPinCount,
+    systemCoverageComplete: systemCoverage.complete,
+    groups: VIRTUAL_HAL_PROJECT_PIN_GROUPS.map((group) => ({
+      ...group,
+      pinCount: rows.filter((row) => row.group === group.id).length,
+    })),
+    rows,
+  };
+}
+
+export function createVirtualHalBridgeReadiness(options = {}) {
+  const snapshot = options.snapshot ?? createVirtualHalWasmBridgeSnapshot(options.halState ?? createVirtualHalState());
+  const systemCoverage = options.systemCoverage ?? createVirtualHalSystemCoverageReport({
+    halState: options.halState ?? createVirtualHalState(),
+    snapshot,
+  });
+  const requiredFunctions = options.requiredFunctions ?? VIRTUAL_HAL_WASM_BRIDGE_FUNCTIONS;
+  const availableFunctions = resolveAvailableVirtualHalFunctions(options, requiredFunctions);
+  const missingWasmFunctions = requiredFunctions.filter((name) => !availableFunctions.includes(name));
+  const requiredPins = options.requiredPins ?? [
+    "axisui.jog.x",
+    "axisui.jog.increment",
+    "halui.machine.is-on",
+    "halui.estop.is-activated",
+    "spindle.0.speed-out",
+    "iocontrol.0.coolant-flood",
+  ];
+  const snapshotPins = new Set((snapshot.values ?? []).map(({ name }) => name));
+  const missingPins = requiredPins.filter((name) => !snapshotPins.has(name));
+  const missingCoverage = systemCoverage.complete ? [] : ["system-coverage"];
+  const evidenceProvided = Boolean(
+    options.interpSdk ||
+      options.hasWasmFunction ||
+      options.availableFunctions ||
+      options.availableWasmFunctions,
+  );
+  const missing = [
+    ...missingWasmFunctions.map((name) => `wasm-function:${name}`),
+    ...missingPins.map((name) => `pin:${name}`),
+    ...missingCoverage,
+  ];
+  if (!evidenceProvided) {
+    missing.unshift("wasm-function-evidence");
+  }
+  return {
+    apiName: "linuxcnc-wasm-virtual-hal-bridge-readiness",
+    readinessVersion: 1,
+    source: snapshot.source ?? "browser-virtual-hal",
+    phase: missing.length === 0 ? "ready" : "blocked",
+    ready: missing.length === 0,
+    evidenceProvided,
+    requiredFunctions: [...requiredFunctions],
+    availableFunctions,
+    missingWasmFunctions,
+    requiredPins,
+    missingPins,
+    snapshotValueCount: snapshot.values?.length ?? 0,
+    systemCoverageComplete: systemCoverage.complete,
+    systemCoveragePhase: systemCoverage.phase,
+    runtimeBoundaryCount: systemCoverage.boundaryRows?.length ?? 0,
+    missing,
+    rows: [
+      {
+        id: "wasm-functions",
+        label: "WASM HAL bridge functions",
+        value: missingWasmFunctions.length === 0 && evidenceProvided ? "ready" : `missing ${missingWasmFunctions.length || "evidence"}`,
+      },
+      {
+        id: "bridge-pins",
+        label: "Bridge pins",
+        value: missingPins.length === 0 ? `${snapshot.values?.length ?? 0} values` : `missing ${missingPins.length}`,
+      },
+      {
+        id: "system-coverage",
+        label: "System HAL coverage",
+        value: systemCoverage.complete ? systemCoverage.phase : "incomplete",
+      },
+      {
+        id: "source",
+        label: "Source",
+        value: systemCoverage.source ?? snapshot.source ?? "unknown",
+      },
+    ],
+  };
+}
+
+export function createVirtualHalBridgeActionPlan(readiness = createVirtualHalBridgeReadiness()) {
+  const ready = readiness.ready === true;
+  const nextCommand = ready ? null : "wasm-port/tools/build_wasm_core.sh";
+  return {
+    apiName: "linuxcnc-wasm-virtual-hal-bridge-action-plan",
+    actionPlanVersion: 1,
+    phase: ready ? "ready" : "blocked",
+    ready,
+    nextCommand,
+    missing: [...(readiness.missing ?? [])],
+    actions: ready
+      ? []
+      : [
+          {
+            id: "build-wasm-core",
+            label: "Build interpreter WASM with HAL bridge exports",
+            command: nextCommand,
+          },
+          {
+            id: "verify-interp-wasm",
+            label: "Verify interpreter HAL bridge smoke",
+            command: "SKIP_INTERP_BUILD=1 wasm-port/tests/wasm/node/verify_interp_wasm.sh",
+          },
+        ],
+    shellScript: ready
+      ? "# LinuxCNC virtual HAL bridge is already ready.\n"
+      : [
+          "# Build and verify LinuxCNC virtual HAL bridge.",
+          "wasm-port/tools/build_wasm_core.sh",
+          "SKIP_INTERP_BUILD=1 wasm-port/tests/wasm/node/verify_interp_wasm.sh",
+          "",
+        ].join("\n"),
+    rows: [
+      {
+        id: "readiness",
+        label: "Virtual HAL bridge",
+        value: ready ? "ready" : "blocked",
+      },
+      {
+        id: "next-command",
+        label: "Next command",
+        value: nextCommand ?? "-",
+      },
+    ],
+  };
+}
+
+export function createVirtualHalProjectReport(options = {}) {
+  const state = normalizeVirtualHalState(options.halState ?? createVirtualHalState());
+  const snapshot = createVirtualHalWasmBridgeSnapshot(state);
+  const systemCoverage = createVirtualHalSystemCoverageReport({
+    ...options,
+    halState: state,
+    snapshot,
+  });
+  const readiness = createVirtualHalBridgeReadiness({
+    ...options,
+    snapshot,
+    systemCoverage,
+  });
+  const actionPlan = createVirtualHalBridgeActionPlan(readiness);
+  const pinRegistry = createVirtualHalPinRegistry(state);
+  const integrity = createVirtualHalIntegrityReport({
+    halState: state,
+    registry: pinRegistry,
+    systemCoverage,
+  });
+  return {
+    apiName: "linuxcnc-wasm-virtual-hal-project-report",
+    reportVersion: 1,
+    source: "browser-virtual-hal",
+    phase: readiness.ready && integrity.complete ? "ready" : "blocked",
+    ready: readiness.ready && integrity.complete,
+    missing: [...readiness.missing, ...integrity.missingPins.map((name) => `integrity-pin:${name}`)],
+    state: cloneVirtualHalState(state),
+    dro: createVirtualHalDroState(state),
+    limitsHome: createVirtualHalLimitsHomeState(state),
+    machineStatus: createVirtualHalMachineStatusState(state),
+    pinInventory: createVirtualHalPinInventory(state),
+    pinRegistry,
+    integrity,
+    systemCoverage,
+    simulationRuntime: createVirtualHalSimulationRuntimeReport(state),
+    wasmBridgeSnapshot: snapshot,
+    bridgeReadiness: readiness,
+    bridgeActionPlan: actionPlan,
+    rows: [
+      {
+        id: "state",
+        label: "Virtual HAL state",
+        value: state.task.state,
+      },
+      {
+        id: "pins",
+        label: "Bridge pins",
+        value: `${snapshot.values.length}`,
+      },
+      {
+        id: "system-coverage",
+        label: "System coverage",
+        value: systemCoverage.phase,
+      },
+      {
+        id: "integrity",
+        label: "HAL integrity",
+        value: integrity.phase,
+      },
+      {
+        id: "bridge",
+        label: "WASM bridge",
+        value: readiness.ready && integrity.complete ? "ready" : "blocked",
+      },
+      {
+        id: "simulation-runtime",
+        label: "Simulation HAL runtime",
+        value: "ready",
+      },
+    ],
+  };
+}
+
+export function applyVirtualHalToInterpSdk(interpSdk, halState = createVirtualHalState(), options = {}) {
+  if (!interpSdk) {
+    throw new Error("applyVirtualHalToInterpSdk requires an interpreter SDK");
+  }
+  if (typeof interpSdk.applyVirtualHalState === "function") {
+    return interpSdk.applyVirtualHalState(halState, options);
+  }
+  if (typeof interpSdk.applyVirtualHalSnapshot === "function") {
+    return interpSdk.applyVirtualHalSnapshot(createVirtualHalWasmBridgeSnapshot(halState), options);
+  }
+  throw new Error("interpreter SDK missing virtual HAL apply methods");
+}
+
+export function stepVirtualHalMotion(halState = createVirtualHalState(), options = {}) {
+  const next = normalizeVirtualHalState(halState);
+  const dt = clampNumber(options.dt ?? options.period ?? next.motion.servoPeriod, 0.000001, 1);
+  const maxVelocity = clampNumber(options.maxVelocity ?? next.motion.requestedVel ?? 1, 0.000001, 999999);
+  const target = { ...next.motion.target, ...(options.target ?? {}) };
+  let totalMoved = 0;
+  let totalRemaining = 0;
+
+  for (const axis of VIRTUAL_HAL_AXES) {
+    const current = next.position[axis];
+    const goal = Number.isFinite(Number(target[axis])) ? Number(target[axis]) : current;
+    const delta = goal - current;
+    const step = Math.sign(delta) * Math.min(Math.abs(delta), maxVelocity * dt);
+    next.position[axis] = current + step;
+    next.motion.target[axis] = goal;
+    totalMoved += Math.abs(step);
+    totalRemaining += Math.abs(goal - next.position[axis]);
+  }
+
+  next.motion.servoPeriod = dt;
+  next.motion.requestedVel = maxVelocity;
+  next.motion.currentVel = totalMoved / dt;
+  next.motion.distanceToGo = totalRemaining;
+  next.motion.inPosition = totalRemaining < 0.000001;
+  next.motion.motionType = next.motion.inPosition ? 0 : 1;
+  next.positionDirty = totalMoved > 0;
+  next.revision += 1;
+  return normalizeVirtualHalState(next);
+}
+
+export function stepVirtualHalMotionController(halState = createVirtualHalState(), options = {}) {
+  const cycleCount = clampInteger(options.cycleCount ?? options.cycles ?? 1, 1, 100000);
+  let state = normalizeVirtualHalState(halState);
+  const frames = [];
+  for (let index = 0; index < cycleCount; index += 1) {
+    state = stepVirtualHalMotion(state, options);
+    frames.push({
+      cycle: index + 1,
+      position: { ...state.position },
+      motion: { ...state.motion, target: { ...state.motion.target } },
+    });
+    if (state.motion.inPosition && options.stopOnInPosition !== false) {
+      break;
+    }
+  }
+  return {
+    apiName: "linuxcnc-wasm-virtual-motion-controller-step",
+    stepVersion: 1,
+    source: "simulation-grade-virtual-motion-controller",
+    ok: true,
+    cycleCount: frames.length,
+    inPosition: state.motion.inPosition,
+    distanceToGo: state.motion.distanceToGo,
+    frames,
+    state: cloneVirtualHalState(state),
+  };
+}
+
+export function executeVirtualHalcmd(halState = createVirtualHalState(), commandText = "", options = {}) {
+  return executeVirtualHalCommand(halState, commandText, options);
+}
+
+export function executeVirtualHalCommand(halState = createVirtualHalState(), commandText = "", options = {}) {
+  let state = normalizeVirtualHalState(halState);
+  const rows = [];
+  const output = [];
+  const commands = String(commandText)
+    .split(/\r?\n/)
+    .map((line) => line.replace(/#.*/, "").trim())
+    .filter(Boolean);
+
+  for (const command of commands) {
+    const tokens = command.split(/\s+/);
+    const verb = tokens[0]?.toLowerCase();
+    try {
+      if (verb === "setp" && tokens.length >= 3) {
+        const name = tokens[1];
+        const value = parseHalCommandValue(tokens.slice(2).join(" "));
+        state = writeVirtualHalPin(state, { name, value, type: inferVirtualHalPinType(value) });
+        syncVirtualHalSignalsFromPin(state, name, value);
+        rows.push({ command, action: "setp", name, value: normalizeHalNumericValue(value), ok: true });
+      } else if ((verb === "sets" || verb === "newsig") && tokens.length >= 2) {
+        const name = tokens[1];
+        const value = verb === "sets" ? parseHalCommandValue(tokens.slice(2).join(" ")) : 0;
+        state.hal.signals[name] = {
+          name,
+          type: inferVirtualHalPinType(value),
+          value: normalizeHalNumericValue(value),
+          pins: [...(state.hal.signals[name]?.pins ?? [])],
+        };
+        state = propagateVirtualHalSignal(state, name);
+        rows.push({ command, action: verb, name, value: normalizeHalNumericValue(value), ok: true });
+      } else if (verb === "net" && tokens.length >= 3) {
+        const signalName = tokens[1];
+        const pinNames = tokens.slice(2).filter((token) => token !== "<=" && token !== "=>" && token !== "<=>" && token !== "=");
+        const existing = state.hal.signals[signalName] ?? { name: signalName, type: "HAL_FLOAT", value: 0, pins: [] };
+        state.hal.signals[signalName] = {
+          ...existing,
+          pins: [...new Set([...(existing.pins ?? []), ...pinNames])],
+        };
+        state.hal.nets[signalName] = [...state.hal.signals[signalName].pins];
+        state = propagateVirtualHalSignal(state, signalName);
+        rows.push({ command, action: "net", name: signalName, pins: pinNames, ok: true });
+      } else if ((verb === "getp" || verb === "gets") && tokens.length >= 2) {
+        const name = tokens[1];
+        const value = verb === "gets" ? state.hal.signals[name]?.value : readVirtualHalPin(state, name)?.value;
+        output.push(`${name} ${normalizeHalNumericValue(value)}`);
+        rows.push({ command, action: verb, name, value: normalizeHalNumericValue(value), ok: true });
+      } else if (verb === "show") {
+        const kind = tokens[1] ?? "pin";
+        const pattern = tokens[2] ?? "";
+        const showRows = createVirtualHalShowRows(state, kind, pattern);
+        output.push(...showRows.map((row) => `${row.kind} ${row.name} ${row.value}`));
+        rows.push({ command, action: "show", kind, count: showRows.length, ok: true });
+      } else if ((verb === "loadrt" || verb === "loadusr") && tokens.length >= 2) {
+        const component = tokens.slice(1).filter((token) => !token.startsWith("-")).join(" ");
+        state.hal.loadedComponents.push({ command: verb, component, realtime: verb === "loadrt" });
+        rows.push({ command, action: verb, component, ok: true });
+      } else if (verb === "addf" && tokens.length >= 3) {
+        state.hal.functions.push({ name: tokens[1], thread: tokens[2] });
+        rows.push({ command, action: "addf", name: tokens[1], thread: tokens[2], ok: true });
+      } else if ((verb === "start" || verb === "stop") && tokens.length >= 2) {
+        const thread = tokens[1];
+        state.hal.threads[thread] = {
+          ...(state.hal.threads[thread] ?? { periodNs: 1000000 }),
+          running: verb === "start",
+        };
+        rows.push({ command, action: verb, thread, ok: true });
+      } else if (verb === "unlinkp" && tokens.length >= 2) {
+        const pin = tokens[1];
+        for (const signal of Object.values(state.hal.signals)) {
+          signal.pins = (signal.pins ?? []).filter((name) => name !== pin);
+        }
+        for (const [signalName, pins] of Object.entries(state.hal.nets)) {
+          state.hal.nets[signalName] = pins.filter((name) => name !== pin);
+        }
+        rows.push({ command, action: "unlinkp", name: pin, ok: true });
+      } else if (verb === "stepgen" || verb === "motion-step") {
+        const target = parseHalCommandTarget(tokens.slice(1));
+        state = stepVirtualHalMotion(state, { ...options, target });
+        rows.push({ command, action: "motion-step", target, ok: true });
+      } else {
+        rows.push({ command, action: "unsupported", ok: false, error: `unsupported halcmd verb: ${verb}` });
+      }
+    } catch (error) {
+      rows.push({ command, action: verb ?? "unknown", ok: false, error: error.message });
+    }
+  }
+
+  state.hal.commandLog = [
+    ...(state.hal.commandLog ?? []),
+    ...rows.map((row) => ({ ...row, source: "virtual-halcmd" })),
+  ].slice(-200);
+  state.revision += rows.length > 0 ? 1 : 0;
+  const finalState = normalizeVirtualHalState(state);
+  return {
+    apiName: "linuxcnc-wasm-virtual-halcmd-result",
+    commandVersion: 1,
+    source: "simulation-grade-virtual-hal",
+    ok: rows.every((row) => row.ok),
+    commandCount: rows.length,
+    output: output.join("\n"),
+    rows,
+    state: cloneVirtualHalState(finalState),
+  };
+}
+
+export function createVirtualHalSimulationReplacementReport(halState = createVirtualHalState(), options = {}) {
+  const state = normalizeVirtualHalState(halState);
+  const runtime = createVirtualHalSimulationRuntimeReport(state, options);
+  const requiredCapabilities = options.requiredCapabilities ?? [
+    "realtime-hal-simulation-replacement",
+    "halcmd-simulation-replacement",
+    "motion-controller-simulation-replacement",
+    "hal-pin-signal-param-store",
+    "halcmd-setp-sets-net-show-getp-gets",
+    "servo-period-motion-step",
+    "axis-joint-position-feedback",
+  ];
+  const missingCapabilities = requiredCapabilities
+    .filter((capability) => !runtime.capabilities.includes(capability));
+  const replacements = {
+    "linuxcnc-realtime-hal": {
+      ready: missingCapabilities.length === 0,
+      replacement: "virtual-hal-pin-signal-param-store",
+      evidence: ["pin registry", "signal/net store", "thread/function registry"],
+    },
+    halcmd: {
+      ready: runtime.capabilities.includes("halcmd-setp-sets-net-show-getp-gets"),
+      replacement: "executeVirtualHalcmd / executeVirtualHalCommand",
+      evidence: ["setp", "sets", "newsig", "net", "show", "getp", "gets", "loadrt", "loadusr", "addf", "start", "stop"],
+    },
+    "motion-controller": {
+      ready: runtime.capabilities.includes("servo-period-motion-step"),
+      replacement: "stepVirtualHalMotionController / stepVirtualHalMotion",
+      evidence: ["servo period", "target position", "velocity limit", "distance-to-go", "in-position"],
+    },
+  };
+  const ready = missingCapabilities.length === 0 &&
+    Object.values(replacements).every((item) => item.ready === true);
+  return {
+    apiName: "linuxcnc-wasm-virtual-hal-simulation-replacement-report",
+    replacementVersion: 1,
+    source: "simulation-grade-virtual-hal",
+    phase: ready ? "ready" : "blocked",
+    ready,
+    replacesHostRuntimeForSimulation: true,
+    replacementTargets: [...VIRTUAL_HAL_SIMULATION_REPLACEMENT_TARGETS],
+    hardRealtime: false,
+    realtimeKernelAbi: false,
+    requiredCapabilities,
+    missingCapabilities,
+    replacements,
+    runtime,
+    rows: [
+      { id: "realtime-hal", label: "LinuxCNC realtime HAL", value: replacements["linuxcnc-realtime-hal"].ready ? "virtual replacement ready" : "blocked" },
+      { id: "halcmd", label: "halcmd", value: replacements.halcmd.ready ? "virtual replacement ready" : "blocked" },
+      { id: "motion-controller", label: "motion controller", value: replacements["motion-controller"].ready ? "virtual replacement ready" : "blocked" },
+      { id: "hard-realtime", label: "Hard realtime", value: "not required for simulation" },
+    ],
+    note: options.note ?? "Complete simulation replacement for browser/project workflows; not a Linux kernel realtime ABI or external hardware driver runtime.",
+  };
+}
+
+export function createVirtualHalSimulationRuntimeReport(halState = createVirtualHalState(), options = {}) {
+  const state = normalizeVirtualHalState(halState);
+  const snapshot = createVirtualHalWasmBridgeSnapshot(state);
+  return {
+    apiName: "linuxcnc-wasm-virtual-hal-simulation-runtime-report",
+    reportVersion: 1,
+    source: "simulation-grade-virtual-hal",
+    ready: true,
+    replacesHostRuntimeForSimulation: true,
+    replacementTargets: [...VIRTUAL_HAL_SIMULATION_REPLACEMENT_TARGETS],
+    hardRealtime: false,
+    hostRequirements: [],
+    unsupportedHostRequirements: ["kernel-realtime-scheduling", "external-device-drivers", "linuxcnc-realtime-module-abi"],
+    capabilities: [...VIRTUAL_HAL_SIMULATION_RUNTIME_CAPABILITIES],
+    pinCount: snapshot.values.filter(({ kind }) => kind === "pin").length,
+    signalCount: Object.keys(state.hal.signals ?? {}).length,
+    paramCount: Object.keys(state.hal.params ?? {}).length,
+    netCount: Object.keys(state.hal.nets ?? {}).length,
+    functionCount: state.hal.functions.length,
+    threadCount: Object.keys(state.hal.threads ?? {}).length,
+    commandCount: state.hal.commandLog.length,
+    motion: {
+      enabled: state.motion.enabled,
+      inPosition: state.motion.inPosition,
+      distanceToGo: state.motion.distanceToGo,
+      currentVel: state.motion.currentVel,
+      requestedVel: state.motion.requestedVel,
+      servoPeriod: state.motion.servoPeriod,
+    },
+    rows: [
+      { id: "runtime", label: "Virtual HAL runtime", value: "ready" },
+      { id: "host-requirements", label: "Host HAL requirements", value: "none for simulation" },
+      { id: "hard-realtime", label: "Hard realtime", value: "no" },
+      { id: "halcmd", label: "Virtual halcmd", value: "setp/sets/net/show/getp/gets/load/addf/start/stop" },
+      { id: "motion-controller", label: "Virtual motion controller", value: "servo-period target stepping" },
+      { id: "motion", label: "Motion step", value: state.motion.inPosition ? "in-position" : "moving" },
+    ],
+    note: options.note ?? "Simulation-grade replacement for browser/project workflows; not a Linux kernel realtime ABI.",
+  };
+}
+
+export function createLinuxCncVirtualHalRuntime(initialState = createVirtualHalState()) {
+  let state = normalizeVirtualHalState(initialState);
+  return {
+    getState() {
+      return cloneVirtualHalState(state);
+    },
+    dispatch(action, options = {}) {
+      state = applyVirtualHalAction(state, action, options);
+      return cloneVirtualHalState(state);
+    },
+    getDroState() {
+      return createVirtualHalDroState(state);
+    },
+    getLimitsHomeState() {
+      return createVirtualHalLimitsHomeState(state);
+    },
+    getMachineStatusState() {
+      return createVirtualHalMachineStatusState(state);
+    },
+    getWasmBridgeSnapshot() {
+      return createVirtualHalWasmBridgeSnapshot(state);
+    },
+    getPinRegistry() {
+      return createVirtualHalPinRegistry(state);
+    },
+    readPin(name) {
+      return readVirtualHalPin(state, name);
+    },
+    writePin(update, options = {}) {
+      state = writeVirtualHalPin(state, update, options);
+      return cloneVirtualHalState(state);
+    },
+    applyPinUpdates(updates, options = {}) {
+      state = applyVirtualHalPinUpdates(state, updates, options);
+      return cloneVirtualHalState(state);
+    },
+    executeHalCommand(commandText, options = {}) {
+      const result = executeVirtualHalCommand(state, commandText, options);
+      state = result.state;
+      return result;
+    },
+    executeHalcmd(commandText, options = {}) {
+      const result = executeVirtualHalcmd(state, commandText, options);
+      state = result.state;
+      return result;
+    },
+    stepMotion(options = {}) {
+      state = stepVirtualHalMotion(state, options);
+      return cloneVirtualHalState(state);
+    },
+    stepMotionController(options = {}) {
+      const result = stepVirtualHalMotionController(state, options);
+      state = result.state;
+      return result;
+    },
+    getSimulationRuntimeReport(options = {}) {
+      return createVirtualHalSimulationRuntimeReport(state, options);
+    },
+    getSimulationReplacementReport(options = {}) {
+      return createVirtualHalSimulationReplacementReport(state, options);
+    },
+    getIntegrityReport(options = {}) {
+      return createVirtualHalIntegrityReport({ ...options, halState: state });
+    },
+    getPinInventory() {
+      return createVirtualHalPinInventory(state);
+    },
+    getProjectReport(options = {}) {
+      return createVirtualHalProjectReport({ ...options, halState: state });
+    },
+    applyToInterpSdk(interpSdk, options = {}) {
+      return applyVirtualHalToInterpSdk(interpSdk, state, options);
+    },
+  };
+}
+
+function parseHalCommandValue(text) {
+  const value = String(text ?? "0").trim();
+  if (/^(true|on|yes)$/i.test(value)) {
+    return true;
+  }
+  if (/^(false|off|no)$/i.test(value)) {
+    return false;
+  }
+  return Number(value) || 0;
+}
+
+function parseHalCommandTarget(tokens) {
+  const target = {};
+  for (const token of tokens) {
+    const [rawName, rawValue] = token.split("=");
+    const name = rawName?.toLowerCase();
+    const value = Number(rawValue);
+    if (VIRTUAL_HAL_AXES.includes(name) && Number.isFinite(value)) {
+      target[name] = value;
+    }
+  }
+  return target;
+}
+
+function syncVirtualHalSignalsFromPin(state, pinName, value) {
+  for (const signal of Object.values(state.hal.signals ?? {})) {
+    if ((signal.pins ?? []).includes(pinName)) {
+      signal.value = normalizeHalNumericValue(value);
+    }
+  }
+  return state;
+}
+
+function propagateVirtualHalSignal(state, signalName) {
+  const signal = state.hal.signals?.[signalName];
+  if (!signal) {
+    return state;
+  }
+  let next = state;
+  for (const pinName of signal.pins ?? []) {
+    next = writeVirtualHalPin(next, {
+      name: pinName,
+      type: signal.type ?? "HAL_FLOAT",
+      value: signal.value,
+    });
+  }
+  next.hal.signals[signalName] = {
+    ...signal,
+    value: normalizeHalNumericValue(signal.value),
+    pins: [...new Set(signal.pins ?? [])],
+  };
+  next.hal.nets[signalName] = [...next.hal.signals[signalName].pins];
+  return next;
+}
+
+function createVirtualHalShowRows(state, kind = "pin", pattern = "") {
+  const matcher = pattern ? new RegExp(pattern.replaceAll("*", ".*"), "i") : null;
+  const matches = (name) => !matcher || matcher.test(name);
+  if (kind === "sig" || kind === "signal") {
+    return Object.values(state.hal.signals ?? {})
+      .filter(({ name }) => matches(name))
+      .map((signal) => ({
+        kind: "signal",
+        name: signal.name,
+        type: signal.type ?? "HAL_FLOAT",
+        value: normalizeHalNumericValue(signal.value),
+      }));
+  }
+  if (kind === "param" || kind === "parameter") {
+    return Object.entries(state.hal.params ?? {})
+      .filter(([name]) => matches(name))
+      .map(([name, entry]) => ({
+        kind: "param",
+        name,
+        type: entry.type ?? "HAL_FLOAT",
+        value: normalizeHalNumericValue(entry.value),
+      }));
+  }
+  return createVirtualHalWasmBridgeSnapshot(state).values
+    .filter(({ kind: rowKind, name }) => rowKind === "pin" && matches(name))
+    .map((row) => ({
+      kind: "pin",
+      name: row.name,
+      type: row.type,
+      value: normalizeHalNumericValue(row.value),
+    }));
+}
+
+function resolveAvailableVirtualHalFunctions(options, requiredFunctions) {
+  if (Array.isArray(options.availableFunctions)) {
+    return options.availableFunctions.filter((name) => requiredFunctions.includes(name));
+  }
+  if (Array.isArray(options.availableWasmFunctions)) {
+    return options.availableWasmFunctions.filter((name) => requiredFunctions.includes(name));
+  }
+  const hasWasmFunction = options.hasWasmFunction ?? options.interpSdk?.hasWasmFunction;
+  if (typeof hasWasmFunction === "function") {
+    return requiredFunctions.filter((name) => hasWasmFunction.call(options.interpSdk, name));
+  }
+  return [];
+}
+
+function expandVirtualHalFamilyPins(family) {
+  return (family.pins ?? []).flatMap((pin) => {
+    if (pin.axes) {
+      return VIRTUAL_HAL_AXES.map((axis) => ({
+        ...pin,
+        name: pin.name.replace("{axis}", axis),
+      }));
+    }
+    if (pin.joints) {
+      return VIRTUAL_HAL_AXES.map((axis, index) => ({
+        ...pin,
+        axis,
+        name: pin.name.replace("{joint}", `${index}`),
+      }));
+    }
+    return [{ ...pin }];
+  });
+}
+
+function isInternalAxisUiPinName(name) {
+  return name.startsWith("jog.") ||
+    name.startsWith("notifications-") ||
+    name === "resume-inhibit" ||
+    name === "error" ||
+    name === "abort" ||
+    /^axis\.[xyzabcuvw]\.homed$/.test(name);
+}
+
+function resolveVirtualHalCoverageForPin(name) {
+  const family = VIRTUAL_HAL_SYSTEM_PIN_FAMILIES.find((item) => (
+    expandVirtualHalFamilyPins(item).some((pin) => pin.name === name) ||
+    (name.startsWith("jog.") && item.id === "axisui")
+  ));
+  return family?.coverage ?? VIRTUAL_HAL_COVERAGE_STATES.bridgeOnly;
+}
+
+function resolveVirtualHalSourceFilesForPin(name) {
+  const family = VIRTUAL_HAL_SYSTEM_PIN_FAMILIES.find((item) => (
+    expandVirtualHalFamilyPins(item).some((pin) => pin.name === name) ||
+    (name.startsWith("jog.") && item.id === "axisui")
+  ));
+  return family ? [...family.sourceFiles] : [];
+}
+
+function isVirtualHalPinWritable(name) {
+  if (name.startsWith("jog.") || name.startsWith("axisui.jog.")) {
+    return true;
+  }
+  if (name.startsWith("halui.") || name.startsWith("iocontrol.") || name.startsWith("motion.")) {
+    return true;
+  }
+  if (/^(axis|joint)\./.test(name) || name.startsWith("spindle.")) {
+    return true;
+  }
+  return false;
+}
+
+function inferVirtualHalPinType(value) {
+  return typeof value === "boolean" ? "HAL_BIT" : "HAL_FLOAT";
+}
+
+function resolveVirtualHalDeclaredPinValue(state, name, type) {
+  const existing = readVirtualHalPinFromSnapshot(state, name);
+  if (existing) {
+    return existing.value;
+  }
+  if (name === "halui.machine.on") {
+    return state.task.powered ? 1 : 0;
+  }
+  if (name === "halui.machine.off") {
+    return state.task.powered ? 0 : 1;
+  }
+  if (name === "halui.estop.activate") {
+    return state.task.estop ? 1 : 0;
+  }
+  if (name === "halui.estop.reset") {
+    return state.task.estop ? 0 : 1;
+  }
+  if (name === "halui.mode.manual") {
+    return state.task.mode === "manual" ? 1 : 0;
+  }
+  if (name === "halui.mode.auto") {
+    return state.task.mode === "auto" ? 1 : 0;
+  }
+  if (name === "halui.mode.mdi") {
+    return state.task.mode === "mdi" ? 1 : 0;
+  }
+  if (name === "halui.program.run") {
+    return state.program.state === "running" ? 1 : 0;
+  }
+  if (name === "halui.program.pause") {
+    return state.program.state === "paused" ? 1 : 0;
+  }
+  if (name === "halui.program.resume") {
+    return state.program.state === "running" ? 1 : 0;
+  }
+  if (name === "halui.program.stop") {
+    return state.program.state === "idle" ? 1 : 0;
+  }
+  if (name.endsWith(".optional-stop.on")) {
+    return state.program.optionalStop ? 1 : 0;
+  }
+  if (name.endsWith(".optional-stop.off")) {
+    return state.program.optionalStop ? 0 : 1;
+  }
+  if (name.endsWith(".block-delete.on")) {
+    return state.program.blockDelete ? 1 : 0;
+  }
+  if (name.endsWith(".block-delete.off")) {
+    return state.program.blockDelete ? 0 : 1;
+  }
+  if (name === "halui.mist.on") {
+    return state.coolant.mist === "on" ? 1 : 0;
+  }
+  if (name === "halui.mist.off") {
+    return state.coolant.mist === "on" ? 0 : 1;
+  }
+  if (name === "halui.flood.on") {
+    return state.coolant.flood === "on" ? 1 : 0;
+  }
+  if (name === "halui.flood.off") {
+    return state.coolant.flood === "on" ? 0 : 1;
+  }
+  if (name === "halui.spindle.0.start") {
+    return state.spindle.state === "on" ? 1 : 0;
+  }
+  if (name === "halui.spindle.0.stop") {
+    return state.spindle.state === "on" ? 0 : 1;
+  }
+  if (name === "halui.spindle.0.forward") {
+    return state.spindle.direction === "cw" ? 1 : 0;
+  }
+  if (name === "halui.spindle.0.reverse") {
+    return state.spindle.direction === "ccw" ? 1 : 0;
+  }
+  if (name === "halui.spindle.0.brake-on") {
+    return state.spindle.brake ? 1 : 0;
+  }
+  if (name === "halui.spindle.0.brake-off") {
+    return state.spindle.brake ? 0 : 1;
+  }
+  const axisMatch = name.match(/^halui\.axis\.([xyzabcuvw])\.(select|plus|minus|analog|increment)$/);
+  if (axisMatch) {
+    if (axisMatch[2] === "select") {
+      return state.activeAxis === axisMatch[1] ? 1 : 0;
+    }
+    if (axisMatch[2] === "increment") {
+      return state.jog.incrementValue;
+    }
+    return state.pins[`jog.${axisMatch[1]}`] ? 1 : 0;
+  }
+  const jointMatch = name.match(/^halui\.joint\.(\d+)\.(home|unhome|plus|minus)$/);
+  if (jointMatch) {
+    const axis = VIRTUAL_HAL_AXES[Number(jointMatch[1])];
+    if (jointMatch[2] === "home") {
+      return axis && state.homed[axis] ? 1 : 0;
+    }
+    if (jointMatch[2] === "unhome") {
+      return axis && state.homed[axis] ? 0 : 1;
+    }
+    return 0;
+  }
+  return type === "HAL_FLOAT" ? 0 : 0;
+}
+
+function readVirtualHalPinFromSnapshot(state, name) {
+  return createVirtualHalWasmBridgeSnapshot(state).values.find((value) => value.name === name) ?? null;
+}
+
+function applyAxisPinWrite(state, name, numeric, enabled) {
+  const axisMatch = name.match(/^(axis|halui\.axis)\.([xyzabcuvw])\.(.+)$/);
+  if (axisMatch) {
+    const axis = axisMatch[2];
+    const suffix = axisMatch[3];
+    if (["pos-cmd", "teleop-pos-cmd", "pos-commanded", "pos-feedback", "pos-relative"].includes(suffix)) {
+      state.position[axis] = numeric;
+      state.positionDirty = true;
+      return true;
+    }
+    if (suffix === "is-selected" || suffix === "select") {
+      if (enabled) {
+        state.activeAxis = axis;
+      }
+      return true;
+    }
+    if (suffix === "jog-enable" || suffix === "plus" || suffix === "minus") {
+      state.pins[`jog.${axis}`] = enabled;
+      return true;
+    }
+    if (suffix === "jog-scale" || suffix === "increment") {
+      state.jog.increment = `${numeric}`;
+      state.jog.incrementValue = numeric;
+      return true;
+    }
+    if (suffix === "eoffset" || suffix === "eoffset-request") {
+      state.position[axis] += numeric;
+      state.positionDirty = true;
+      return true;
+    }
+  }
+
+  const jointMatch = name.match(/^joint\.(\d+)\.(.+)$/);
+  if (jointMatch) {
+    const index = Number(jointMatch[1]);
+    const axis = VIRTUAL_HAL_AXES[index];
+    const suffix = jointMatch[2];
+    if (!axis) {
+      return false;
+    }
+    if (["pos-cmd", "pos-fb", "coarse-pos-cmd", "motor-pos-cmd", "motor-pos-fb"].includes(suffix)) {
+      state.position[axis] = numeric;
+      state.positionDirty = true;
+      return true;
+    }
+    if (suffix === "homed" || suffix === "home-sw-in") {
+      state.homed[axis] = enabled;
+      return true;
+    }
+    if (suffix === "pos-lim-sw-in" || suffix === "pos-hard-limit") {
+      state.limits[axis].maxLimit = enabled;
+      return true;
+    }
+    if (suffix === "neg-lim-sw-in" || suffix === "neg-hard-limit") {
+      state.limits[axis].minLimit = enabled;
+      return true;
+    }
+    if (suffix === "faulted" || suffix === "error" || suffix === "amp-fault-in") {
+      state.limits[axis].fault = enabled ? suffix : "none";
+      return true;
+    }
+  }
+
+  const toolOffsetMatch = name.match(/^(motion\.tooloffset|halui\.tool\.length_offset)\.([xyzabcuvw])$/);
+  if (toolOffsetMatch) {
+    state.tool.lengthOffset[toolOffsetMatch[2]] = numeric;
+    return true;
+  }
+
+  return false;
+}
+
+function classifyVirtualHalPinGroup(name) {
+  if (name.startsWith("axisui.") || name.startsWith("jog.") || name.startsWith("notifications-") || name === "error" || name === "abort") {
+    return "axisui";
+  }
+  if (name.startsWith("axis.") || name.startsWith("joint.") || name.startsWith("motion.")) {
+    return "axis-motion";
+  }
+  if (name.startsWith("spindle.") || name.startsWith("halui.spindle.") || name.includes("coolant") || name.startsWith("halui.mist.") || name.startsWith("halui.flood.")) {
+    return "spindle-coolant";
+  }
+  if (name.includes(".tool") || name.startsWith("motion.tooloffset.")) {
+    return "tool";
+  }
+  return "task";
+}
+
+function formatAxis(value) {
+  return Number.isFinite(value) ? Number(value).toFixed(3) : "0.000";
+}
diff --git a/wasm-port/runtime/sdk/src/linuxcnc-interp.js b/wasm-port/runtime/sdk/src/linuxcnc-interp.js
index 3661ba5..ce3645d 100644
--- a/wasm-port/runtime/sdk/src/linuxcnc-interp.js
+++ b/wasm-port/runtime/sdk/src/linuxcnc-interp.js
@@ -1,4 +1,5 @@
 import createLinuxCncInterpModule from "../../../build/wasm/core/linuxcnc_interp.js";
+import { createVirtualHalWasmBridgeSnapshot } from "./linuxcnc-hal.js";
 
 function allocCString(mod, value) {
   const bytes = mod.lengthBytesUTF8(value) + 1;
@@ -43,12 +44,36 @@ function callStringResult(mod, functionName, ...values) {
   }
 }
 
+function requireWasmFunction(mod, functionName) {
+  const fn = mod[`_${functionName}`];
+  if (typeof fn !== "function") {
+    throw new Error(`linuxcnc interpreter WASM missing ${functionName}; rebuild wasm-port/tools/build_wasm_core.sh`);
+  }
+  return fn;
+}
+
+function callVoidWithStringsAndNumbers(mod, functionName, strings, numbers = []) {
+  const fn = requireWasmFunction(mod, functionName);
+  const ptrs = strings.map((value) => allocCString(mod, value));
+  try {
+    return fn(...ptrs, ...numbers);
+  } finally {
+    for (const ptr of ptrs) {
+      mod._free(ptr);
+    }
+  }
+}
+
 export async function createLinuxCncInterpSdk(moduleOptions = {}) {
   const mod = await createLinuxCncInterpModule(moduleOptions);
 
   return {
     module: mod,
 
+    hasWasmFunction(functionName) {
+      return typeof mod[`_${functionName}`] === "function";
+    },
+
     writeTextFile(path, text) {
       ensureParentPath(mod, path);
       mod.FS.writeFile(path, text, { encoding: "utf8" });
@@ -160,5 +185,44 @@ export async function createLinuxCncInterpSdk(moduleOptions = {}) {
     probeNamedParameters(iniPath) {
       return callStringResult(mod, "lcinterp_probe_named_parameters", iniPath);
     },
+
+    resetHal() {
+      requireWasmFunction(mod, "lcinterp_hal_reset")();
+    },
+
+    setHalValue({ kind = "pin", name, type = "HAL_FLOAT", value = 0, connected = true }) {
+      if (!name) {
+        throw new Error("setHalValue requires a HAL name");
+      }
+      return callVoidWithStringsAndNumbers(
+        mod,
+        "lcinterp_hal_set_value",
+        [kind, name, type],
+        [Number(value) || 0, connected === false ? 0 : 1],
+      );
+    },
+
+    applyVirtualHalSnapshot(snapshot, options = {}) {
+      if (options.reset !== false) {
+        this.resetHal();
+      }
+      for (const value of snapshot?.values ?? []) {
+        this.setHalValue(value);
+      }
+      return {
+        apiName: "linuxcnc-wasm-hal-apply-result",
+        applied: snapshot?.values?.length ?? 0,
+        reset: options.reset !== false,
+        source: snapshot?.source ?? "unknown",
+      };
+    },
+
+    applyVirtualHalState(halState, options = {}) {
+      return this.applyVirtualHalSnapshot(createVirtualHalWasmBridgeSnapshot(halState), options);
+    },
+
+    probeHalNamed(name) {
+      return callStringResult(mod, "lcinterp_probe_hal_named", name);
+    },
   };
 }
diff --git a/wasm-port/runtime/ui/simulation/index.html b/wasm-port/runtime/ui/simulation/index.html
index 5223fa5..f9f59eb 100644
--- a/wasm-port/runtime/ui/simulation/index.html
+++ b/wasm-port/runtime/ui/simulation/index.html
@@ -27,20 +27,38 @@
       font-family: "Segoe UI", "Noto Sans", Arial, sans-serif;
       color: var(--text);
       background: var(--page);
+      overflow: auto;
     }
     main {
       display: grid;
-      grid-template-rows: auto auto minmax(0, 1fr) 164px auto;
-      min-height: 100vh;
+      grid-template-columns: 330px 1fr;
+      grid-template-rows: 31px 27px 64px 474px 147px 25px;
+      grid-template-areas:
+        "titlebar titlebar"
+        "menubar menubar"
+        "toolbar toolbar"
+        "workspace workspace"
+        "gcode gcode"
+        "statusbar statusbar";
+      width: 1024px;
+      height: 768px;
+      min-width: 1024px;
+      min-height: 768px;
+      margin: 0 auto;
+      overflow: hidden;
+      border-left: 1px solid #7d858b;
+      border-right: 1px solid #7d858b;
+      background: var(--surface);
     }
     .axis-titlebar {
+      grid-area: titlebar;
       border-bottom: 1px solid #777;
       background: #d9d9d9;
       padding: 4px 8px;
       border-bottom: 1px solid var(--line);
       display: grid;
-      grid-template-columns: auto minmax(0, 1fr) auto;
-      gap: 10px;
+      grid-template-columns: 24px minmax(0, 1fr) auto;
+      gap: 8px;
       align-items: center;
     }
     .axis-mark {
@@ -54,6 +72,11 @@
       font-weight: 800;
       font-size: 18px;
     }
+    .axis-mark img {
+      width: 20px;
+      height: 20px;
+      display: block;
+    }
     h1 {
       margin: 0;
       font-size: 13px;
@@ -68,49 +91,133 @@
       font-size: 14px;
     }
     .axis-menubar {
+      grid-area: menubar;
       display: flex;
-      gap: 18px;
+      gap: 0;
       align-items: center;
       border-bottom: 1px solid var(--line);
       background: #e4e4e4;
-      padding: 4px 8px;
+      padding: 0 6px;
       font-size: 14px;
     }
-    .axis-menubar span {
+    .axis-menu {
+      position: relative;
+      min-height: 26px;
+      display: flex;
+      align-items: center;
+    }
+    .axis-menu > button {
+      border: 0;
+      background: transparent;
+      min-height: 26px;
+      padding: 4px 10px;
+      font: 14px/1.2 "Segoe UI", sans-serif;
+    }
+    .axis-menu > button:hover,
+    .axis-menu:focus-within > button,
+    .axis-menu:hover > button {
+      background: #cfd8df;
+      outline: 1px solid #7f878d;
+    }
+    .axis-menu > button span {
       text-decoration: underline;
       text-underline-offset: 2px;
     }
+    .axis-menu-list {
+      position: absolute;
+      left: 0;
+      top: 100%;
+      z-index: 20;
+      min-width: 226px;
+      border: 1px solid #6f777d;
+      background: #eeeeee;
+      box-shadow: 2px 2px 0 rgba(0, 0, 0, 0.22);
+      padding: 3px 0;
+      display: none;
+    }
+    .axis-menu:hover .axis-menu-list,
+    .axis-menu:focus-within .axis-menu-list {
+      display: grid;
+    }
+    .axis-menu-list button,
+    .axis-menu-list label {
+      min-height: 23px;
+      border: 0;
+      background: transparent;
+      display: grid;
+      grid-template-columns: minmax(0, 1fr) auto;
+      align-items: center;
+      gap: 16px;
+      padding: 3px 20px 3px 22px;
+      color: var(--text);
+      text-align: left;
+      font: 13px/1.2 "Segoe UI", sans-serif;
+      white-space: nowrap;
+    }
+    .axis-menu-list label {
+      cursor: pointer;
+    }
+    .axis-menu-list button:hover,
+    .axis-menu-list label:hover {
+      background: #1263a3;
+      color: #ffffff;
+    }
+    .axis-menu-list input {
+      margin: 0 5px 0 -16px;
+    }
+    .axis-menu-separator {
+      height: 1px;
+      margin: 3px 0;
+      background: #a8aeb3;
+      border-bottom: 1px solid #f8f8f8;
+    }
     .axis-toolbar {
+      grid-area: toolbar;
       border-bottom: 1px solid var(--line);
       background: #d2d2d2;
       padding: 4px 8px;
       display: flex;
       align-items: center;
-      gap: 5px;
+      gap: 4px;
       flex-wrap: wrap;
+      align-content: start;
+      overflow: hidden;
+    }
+    .axis-toolbar .program-controls select {
+      width: 164px;
     }
     .toolbar-group {
       display: flex;
       align-items: center;
-      gap: 3px;
-      padding-right: 5px;
-      border-right: 1px solid #a5abb0;
+      gap: 2px;
+      padding-right: 4px;
+      border-right: 1px solid #9a9a9a;
+    }
+    .toolbar-separator {
+      width: 1px;
+      height: 25px;
+      background: #999;
+      border-right: 1px solid #eeeeee;
+      margin: 0 3px;
     }
     .status-strip {
       display: flex;
       gap: 8px;
       align-items: center;
-      flex-wrap: wrap;
+      flex-wrap: nowrap;
       margin-left: auto;
+      min-width: 0;
+      overflow: hidden;
     }
     .run-control-state {
-      flex-basis: 100%;
       border: 1px solid var(--line);
       background: #e7e7e7;
       padding: 4px 7px;
       color: var(--muted);
       font: 12px/1.3 "SFMono-Regular", "Consolas", monospace;
-      overflow-wrap: anywhere;
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
     }
     .run-control-state[data-run-control-phase="ready"] {
       color: var(--green);
@@ -133,7 +240,7 @@
     }
     .program-controls {
       display: flex;
-      gap: 8px;
+      gap: 4px;
       align-items: center;
       min-width: 0;
     }
@@ -146,9 +253,9 @@
       min-height: 26px;
     }
     select {
-      min-width: 220px;
-      max-width: 320px;
-      padding: 5px 8px;
+      min-width: 84px;
+      max-width: 220px;
+      padding: 2px 4px;
     }
     button {
       padding: 4px 8px;
@@ -168,7 +275,7 @@
     }
     .playback-controls {
       display: flex;
-      gap: 8px;
+      gap: 2px;
       align-items: center;
       flex-wrap: wrap;
     }
@@ -176,20 +283,15 @@
       flex: 1 1 auto;
     }
     .playback-readout {
+      display: inline-flex;
+      align-items: center;
+      gap: 4px;
       color: var(--muted);
       font: 12px/1.3 "SFMono-Regular", "Consolas", monospace;
       white-space: nowrap;
     }
     .axis-status-led {
-      border: 1px solid var(--line);
-      background: #e7e7e7;
-      padding: 4px 6px;
-      display: grid;
-      grid-template-columns: auto minmax(0, 1fr);
-      gap: 5px;
-      align-items: center;
-      color: var(--muted);
-      font: 12px/1.3 "SFMono-Regular", "Consolas", monospace;
+      display: none;
     }
     .axis-status-led::before {
       content: "";
@@ -206,11 +308,12 @@
       background: var(--warn);
     }
     .axis-workspace {
+      grid-area: workspace;
       display: grid;
-      grid-template-columns: 326px minmax(460px, 1fr);
+      grid-template-columns: 326px 1fr;
       min-height: 0;
-      gap: 6px;
-      padding: 6px;
+      gap: 4px;
+      padding: 4px 6px 4px 6px;
       background: var(--surface);
     }
     section {
@@ -272,10 +375,10 @@
     }
     .toolpath-wrap {
       min-height: 0;
-      padding: 4px;
+      padding: 0;
       display: grid;
-      grid-template-rows: auto minmax(0, 1fr);
-      gap: 4px;
+      grid-template-rows: auto minmax(0, 1fr) auto;
+      gap: 0;
     }
     .preview-controls {
       display: flex;
@@ -283,6 +386,9 @@
       gap: 5px;
       flex-wrap: wrap;
       font-size: 12px;
+      padding: 3px 4px;
+      border-bottom: 1px solid var(--line);
+      background: #d8d8d8;
     }
     .preview-controls span {
       color: var(--muted);
@@ -308,7 +414,7 @@
     svg {
       width: 100%;
       height: 100%;
-      min-height: 390px;
+      min-height: 0;
       border: 1px solid var(--line);
       background: var(--black);
     }
@@ -323,7 +429,7 @@
     .toolpath-three {
       width: 100%;
       height: 100%;
-      min-height: 390px;
+      min-height: 0;
       border: 1px solid var(--line);
       background: var(--black);
       display: block;
@@ -335,7 +441,7 @@
     }
     .toolpath-stage {
       position: relative;
-      min-height: 390px;
+      min-height: 0;
       display: grid;
     }
     .toolpath-stage .toolpath-three {
@@ -380,31 +486,36 @@
     }
     .preview-hud {
       position: absolute;
-      left: 8px;
-      top: 8px;
+      left: 34px;
+      top: 10px;
       z-index: 2;
       display: grid;
-      gap: 3px;
-      min-width: 210px;
-      max-width: min(360px, calc(100% - 16px));
-      border: 1px solid #5a666f;
-      background: rgba(10, 15, 18, 0.84);
-      color: #dbe7ef;
-      padding: 6px 7px;
-      font: 11px/1.25 "SFMono-Regular", "Consolas", monospace;
+      gap: 0;
+      min-width: 300px;
+      max-width: 360px;
+      border: 0;
+      background: transparent;
+      color: #ffffff;
+      padding: 0;
+      font: 14px/1.24 "Courier New", "SFMono-Regular", monospace;
       pointer-events: none;
+      text-shadow: 1px 1px 0 #000;
     }
     .preview-hud div {
       display: grid;
-      grid-template-columns: 76px minmax(0, 1fr);
-      gap: 7px;
+      grid-template-columns: 76px 90px 68px 90px;
+      gap: 2px;
       min-width: 0;
     }
-    .preview-hud span:first-child {
-      color: #92a3ad;
+    .preview-hud span:nth-child(odd) {
+      color: #ffffff;
+      text-align: right;
+      padding-right: 8px;
     }
-    .preview-hud span:last-child {
-      overflow-wrap: anywhere;
+    .preview-hud span:nth-child(even) {
+      overflow: hidden;
+      text-align: right;
+      font-variant-numeric: tabular-nums;
     }
     .grid-line {
       stroke: #7f1e1e;
@@ -426,15 +537,13 @@
       stroke-width: 0.018;
     }
     .preview-legend {
-      border: 1px solid var(--line);
-      border-top: 0;
-      background: #202629;
-      color: #dbe7ef;
       display: flex;
       gap: 10px;
       flex-wrap: wrap;
       padding: 4px 6px;
       font: 11px/1.25 "SFMono-Regular", "Consolas", monospace;
+      border-top: 1px solid var(--line);
+      background: #d8d8d8;
     }
     .preview-legend span {
       display: inline-flex;
@@ -468,16 +577,17 @@
       stroke-width: 0.025;
     }
     .readout {
+      display: none;
       border-top: 1px solid var(--line);
-      padding: 8px;
+      padding: 6px;
       display: grid;
-      gap: 10px;
+      gap: 6px;
       background: var(--panel);
     }
     .axis-grid {
       display: grid;
       grid-template-columns: repeat(3, minmax(0, 1fr));
-      gap: 8px;
+      gap: 5px;
     }
     .axis-grid div {
       border: 1px solid var(--line);
@@ -512,7 +622,7 @@
       overflow: auto;
       min-height: 0;
       display: grid;
-      grid-template-rows: minmax(0, 1fr) auto auto auto 132px;
+      grid-template-rows: minmax(0, 1fr) auto 82px 32px 78px;
     }
     table {
       width: 100%;
@@ -551,16 +661,17 @@
       background: #111820;
       color: #dbe7ef;
       font: 11px/1.45 "SFMono-Regular", "Consolas", monospace;
-      max-height: 132px;
+      max-height: 78px;
     }
     .diagnostics-panel {
       border-top: 1px solid var(--line);
       background: #e8e8e8;
-      padding: 6px 8px;
+      padding: 5px 6px;
       display: grid;
-      grid-template-columns: repeat(4, minmax(0, 1fr));
-      gap: 7px 12px;
-      font: 12px/1.35 "SFMono-Regular", "Consolas", monospace;
+      grid-template-columns: repeat(2, minmax(0, 1fr));
+      gap: 4px 7px;
+      font: 11px/1.25 "SFMono-Regular", "Consolas", monospace;
+      overflow: hidden;
     }
     .diagnostics-panel div {
       min-width: 0;
@@ -592,7 +703,7 @@
       grid-column: 1 / -1;
       border: 1px solid var(--line);
       background: #fbfbfb;
-      max-height: 86px;
+      max-height: 58px;
       overflow: auto;
       display: grid;
     }
@@ -631,37 +742,142 @@
       border: 1px solid var(--line);
       background: var(--panel);
     }
+    .axis-left {
+      border-right: 2px solid #9f9f9f;
+    }
     .manual-panel,
     .mdi-panel,
     .dro-panel {
-      padding: 8px;
+      padding: 5px 6px;
       display: grid;
-      gap: 9px;
+      gap: 7px;
       align-content: start;
       font-size: 14px;
     }
+    .axis-field-label {
+      font-size: 13px;
+      color: var(--text);
+      white-space: nowrap;
+    }
+    .axis-radio-strip {
+      display: flex;
+      gap: 5px;
+      flex-wrap: wrap;
+      align-items: center;
+    }
+    .axis-radio-strip label,
+    .manual-row label {
+      display: inline-flex;
+      gap: 3px;
+      align-items: center;
+      white-space: nowrap;
+    }
+    .axis-jog-panel {
+      display: grid;
+      grid-template-columns: auto minmax(0, 1fr);
+      gap: 5px 7px;
+      align-items: center;
+    }
+    .axis-jog-buttons {
+      display: flex;
+      gap: 4px;
+      align-items: center;
+      flex-wrap: wrap;
+    }
+    .axis-jog-buttons button {
+      min-width: 33px;
+      min-height: 24px;
+      padding: 2px 6px;
+    }
+    .axis-jog-buttons select {
+      width: 116px;
+      min-width: 116px;
+    }
+    .spindle-grid {
+      display: grid;
+      grid-template-columns: auto minmax(0, 1fr);
+      gap: 4px 7px;
+      align-items: start;
+    }
+    .spindle-buttons {
+      display: flex;
+      gap: 3px;
+      align-items: center;
+      flex-wrap: wrap;
+    }
+    .spindle-buttons button {
+      min-width: 28px;
+      min-height: 24px;
+      padding: 1px 5px;
+    }
+    .spindle-buttons img {
+      width: 20px;
+      height: 20px;
+      display: block;
+    }
     .manual-row {
       display: flex;
       align-items: center;
       gap: 6px;
       flex-wrap: wrap;
     }
+    .manual-row[aria-label="Tool touch off"] {
+      justify-content: center;
+    }
     .disabled-control {
       opacity: 0.45;
     }
     .jog-buttons button,
     .toolbar-button {
-      min-width: 28px;
-      min-height: 26px;
-      padding: 3px 7px;
+      min-width: 24px;
+      min-height: 24px;
+      padding: 1px 3px;
+    }
+    .toolbar-button img {
+      width: 20px;
+      height: 20px;
+      display: block;
+      image-rendering: auto;
     }
     .override-grid {
       display: grid;
-      grid-template-columns: 120px minmax(80px, 1fr);
-      gap: 6px 8px;
+      grid-template-columns: 118px 42px 1fr;
+      gap: 3px 4px;
       align-items: center;
     }
+    .override-grid > span {
+      white-space: nowrap;
+    }
+    .override-value {
+      text-align: right;
+      font-variant-numeric: tabular-nums;
+    }
+    .axis-slider {
+      height: 17px;
+      border: 1px solid #8b8b8b;
+      background: #b8b8b8;
+      position: relative;
+      box-shadow: inset 1px 1px 0 #dcdcdc;
+    }
+    .axis-slider::before,
+    .axis-slider::after {
+      content: "";
+      position: absolute;
+      top: 1px;
+      width: 13px;
+      height: 13px;
+      border: 1px solid #9a9a9a;
+      background: #d9d9d9;
+      box-shadow: inset 1px 1px 0 #ffffff;
+    }
+    .axis-slider::before {
+      left: var(--knob-a, 58%);
+    }
+    .axis-slider::after {
+      left: var(--knob-b, 75%);
+    }
     .machine-session-controls {
+      display: none;
       border-top: 1px solid var(--line);
       padding-top: 7px;
       display: grid;
@@ -697,13 +913,11 @@
       flex-wrap: wrap;
     }
     .override-bar {
-      height: 16px;
-      border: 1px solid var(--line);
-      background: linear-gradient(90deg, #aeb5bb 0 72%, #e8e8e8 72%);
+      display: none;
     }
     .active-codes {
       border-top: 1px solid var(--line);
-      padding-top: 7px;
+      padding-top: 4px;
       font: 12px/1.45 "SFMono-Regular", "Consolas", monospace;
     }
     .modal-rows {
@@ -728,6 +942,26 @@
       color: var(--muted);
       font-size: 12px;
     }
+    .mdi-command-row {
+      display: grid;
+      grid-template-columns: minmax(0, 1fr) auto;
+      gap: 5px;
+      align-items: center;
+      margin-bottom: 8px;
+    }
+    .mdi-command-row label {
+      grid-column: 1 / -1;
+      color: var(--text);
+      font-size: 13px;
+    }
+    .mdi-command-row input {
+      min-width: 0;
+      min-height: 26px;
+      border: 1px solid var(--line);
+      background: #fbfbfb;
+      padding: 4px 6px;
+      font: 13px/1.25 "SFMono-Regular", "Consolas", monospace;
+    }
     .mdi-entry {
       width: 100%;
       min-height: 92px;
@@ -804,15 +1038,26 @@
       display: grid;
     }
     .axis-gcode-pane {
-      margin: 0 6px;
       min-height: 0;
       border: 1px solid var(--line);
       background: #f8f8f8;
       display: grid;
       grid-template-rows: auto minmax(0, 1fr);
     }
+    .axis-gcode-pane[data-axis-shell="gcode-pane"] {
+      grid-area: gcode;
+      margin: 0 6px;
+    }
+    .axis-gcode-pane[data-axis-shell="machine-state"] {
+      position: absolute;
+      left: -10000px;
+      top: 0;
+      width: 1px;
+      height: 1px;
+      overflow: hidden;
+    }
     .axis-gcode-head {
-      display: grid;
+      display: none;
       grid-template-columns: minmax(0, 1fr) auto;
       gap: 8px;
       align-items: center;
@@ -824,10 +1069,11 @@
     }
     .program-editor-wrap {
       display: grid;
-      grid-template-columns: minmax(240px, 0.85fr) minmax(280px, 1fr);
+      grid-template-columns: 1fr;
       min-height: 0;
     }
     .program-editor-panel {
+      display: none;
       min-height: 0;
       border-right: 1px solid var(--line);
       display: grid;
@@ -906,12 +1152,13 @@
       outline: none;
     }
     .axis-statusbar {
+      grid-area: statusbar;
       display: grid;
-      grid-template-columns: 86px 104px minmax(150px, 1.2fr) minmax(120px, 0.8fr) minmax(160px, 1fr) minmax(170px, 1fr);
+      grid-template-columns: 86px 88px 172px 1fr 80px 126px 168px;
       border-top: 1px solid var(--line);
       background: #e3e3e3;
       min-height: 25px;
-      font-size: 13px;
+      font-size: 12px;
     }
     .axis-statusbar > span {
       border-right: 1px solid var(--line);
@@ -927,6 +1174,9 @@
       font-weight: 700;
       color: #141a20;
     }
+    .axis-hidden-status {
+      display: block;
+    }
     .dro-panel {
       overflow: auto;
     }
@@ -953,30 +1203,6 @@
       padding: 1px 4px;
       text-align: right;
     }
-    @media (max-width: 1040px) {
-      main { grid-template-rows: auto auto auto minmax(0, 1fr) 220px auto; }
-      .axis-workspace { grid-template-columns: 1fr; }
-      .program-editor-wrap { grid-template-columns: 1fr; }
-      .program-editor-panel { border-right: 0; border-bottom: 1px solid var(--line); min-height: 180px; }
-      svg { min-height: 280px; }
-      .toolpath-stage { min-height: 280px; }
-      .toolpath-three { min-height: 280px; }
-    }
-    @media (max-width: 560px) {
-      .axis-titlebar { grid-template-columns: auto minmax(0, 1fr); }
-      .window-controls { display: none; }
-      .axis-toolbar { align-items: stretch; }
-      .program-controls { justify-content: stretch; }
-      .program-controls select { min-width: 0; width: 100%; }
-      .playback-controls button { flex: 1 1 calc(50% - 8px); }
-      .playback-controls .spacer { display: none; }
-      .status-strip { justify-content: start; }
-      .axis-grid { grid-template-columns: repeat(2, minmax(0, 1fr)); }
-      .dro-readout { grid-template-columns: 1fr; }
-      .axis-statusbar { grid-template-columns: 1fr; }
-      .diagnostics-panel { grid-template-columns: 1fr; }
-      dl { grid-template-columns: 1fr; }
-    }
     .hidden-file-input {
       position: absolute;
       inline-size: 1px;
@@ -985,39 +1211,169 @@
       opacity: 0;
       pointer-events: none;
     }
+    .axis-dialogs {
+      position: absolute;
+      inset: auto;
+      pointer-events: none;
+    }
+    .axis-dialog {
+      position: fixed;
+      z-index: 30;
+      left: 50%;
+      top: 50%;
+      transform: translate(-50%, -50%);
+      width: min(620px, calc(100vw - 32px));
+      max-height: min(620px, calc(100vh - 32px));
+      border: 1px solid #5f676d;
+      background: #eeeeee;
+      box-shadow: 3px 3px 0 rgba(0, 0, 0, 0.25);
+      display: none;
+      grid-template-rows: auto minmax(0, 1fr) auto;
+      pointer-events: auto;
+    }
+    .axis-dialog[data-open="true"] {
+      display: grid;
+    }
+    .axis-dialog header {
+      padding: 6px 8px;
+      border-bottom: 1px solid var(--line);
+      background: #d8d8d8;
+      font-weight: 650;
+    }
+    .axis-dialog-body {
+      overflow: auto;
+      padding: 8px;
+      font-size: 13px;
+      line-height: 1.35;
+    }
+    .axis-quickref {
+      display: grid;
+      grid-template-columns: 88px minmax(0, 1fr) 88px minmax(0, 1fr);
+      gap: 2px 8px;
+      font: 12px/1.35 "Segoe UI", sans-serif;
+    }
+    .axis-quickref code {
+      font-family: "SFMono-Regular", "Consolas", monospace;
+      color: #111820;
+    }
+    .axis-dialog footer {
+      padding: 7px 8px;
+      border-top: 1px solid var(--line);
+      display: flex;
+      justify-content: end;
+      background: #e5e5e5;
+    }
   </style>
 </head>
 <body data-simulation-ready="false">
   <main>
     <header class="axis-titlebar" data-axis-shell="titlebar">
-      <div class="axis-mark">X</div>
-      <h1>axis.ngc - AXIS 2.9.8 on LinuxCNC-BROWSER-SIM</h1>
+      <div class="axis-mark"><img src="../../../../linuxcnc/share/axis/images/axis-24x24.png" alt=""></div>
+      <h1>axis.ngc - AXIS 2.9.8 on LinuxCNC-HAL-SIM-AXIS</h1>
       <div class="window-controls" aria-hidden="true"><span>⌃</span><span>−</span><span>□</span><span>×</span></div>
     </header>
     <input class="hidden-file-input" type="file" accept=".ngc,.nc,.tap,.gcode,.txt" data-open-program-file>
     <nav class="axis-menubar" data-axis-shell="menubar" aria-label="AXIS menu">
-      <span>File</span>
-      <span>Machine</span>
-      <span>View</span>
-      <span>Help</span>
+      <div class="axis-menu">
+        <button type="button"><span>F</span>ile</button>
+        <div class="axis-menu-list" role="menu" data-axis-menu="file">
+          <button type="button" data-menu-action="open-program">Open... <span>O</span></button>
+          <button type="button" data-menu-action="recent-programs">Recent Files <span></span></button>
+          <button type="button" data-menu-action="edit-program">Edit... <span></span></button>
+          <button type="button" data-menu-action="reload-program">Reload <span>Ctrl-R</span></button>
+          <button type="button" data-menu-action="save-gcode">Save G-code as... <span>Ctrl-S</span></button>
+          <button type="button" data-menu-action="gcode-properties">G-code properties... <span></span></button>
+          <div class="axis-menu-separator"></div>
+          <button type="button" data-menu-action="edit-tool-data">Edit tool data... <span></span></button>
+          <button type="button" data-menu-action="reload-tool-data">Reload tool data <span></span></button>
+          <div class="axis-menu-separator"></div>
+          <button type="button" data-menu-action="ladder-editor">Ladder Editor... <span></span></button>
+          <div class="axis-menu-separator"></div>
+          <button type="button" data-menu-action="quit">Quit <span></span></button>
+        </div>
+      </div>
+      <div class="axis-menu">
+        <button type="button"><span>M</span>achine</button>
+        <div class="axis-menu-list" role="menu" data-axis-menu="machine">
+          <button type="button" data-menu-action="estop">Toggle Emergency Stop <span>F1</span></button>
+          <button type="button" data-menu-action="power">Toggle Machine Power <span>F2</span></button>
+          <div class="axis-menu-separator"></div>
+          <button type="button" data-menu-action="run-program">Run program <span>R</span></button>
+          <button type="button" data-menu-action="run-from-line">Run from selected line <span></span></button>
+          <button type="button" data-menu-action="step-program">Step <span>T</span></button>
+          <button type="button" data-menu-action="pause-program">Pause <span>P</span></button>
+          <button type="button" data-menu-action="resume-program">Resume <span>S</span></button>
+          <button type="button" data-menu-action="stop-program">Stop <span>Esc</span></button>
+          <label><span><input type="checkbox" data-axis-toggle="optional-stop">Stop at M1</span><span></span></label>
+          <label><span><input type="checkbox" data-axis-toggle="block-delete">Skip lines with /</span><span></span></label>
+          <div class="axis-menu-separator"></div>
+          <button type="button" data-menu-action="clear-mdi-history">Clear MDI history <span>Ctrl-M</span></button>
+          <button type="button" data-menu-action="copy-mdi-history">Copy from MDI history <span>Ctrl-H</span></button>
+          <button type="button" data-menu-action="paste-mdi-history">Paste to MDI history <span>Ctrl-Shift-H</span></button>
+          <div class="axis-menu-separator"></div>
+          <button type="button" data-menu-action="home-all">Homing <span>Home</span></button>
+          <button type="button" data-menu-action="unhome-all">Unhoming <span></span></button>
+          <button type="button" data-menu-action="zero-g54">Zero coordinate system <span>G54</span></button>
+          <button type="button" data-menu-action="tool-touch-off">Tool touch off to workpiece <span></span></button>
+        </div>
+      </div>
+      <div class="axis-menu">
+        <button type="button"><span>V</span>iew</button>
+        <div class="axis-menu-list" role="menu" data-axis-menu="view">
+          <button type="button" data-menu-action="view-top">Top view <span>Z</span></button>
+          <button type="button" data-menu-action="view-front">Front view <span>Y</span></button>
+          <button type="button" data-menu-action="view-side">Side view <span>X</span></button>
+          <button type="button" data-menu-action="view-iso">Perspective view <span>P</span></button>
+          <button type="button" data-menu-action="clear-plot">Clear live plot <span>Ctrl-K</span></button>
+          <button type="button" data-menu-action="fit-preview">Fit preview <span>F</span></button>
+          <div class="axis-menu-separator"></div>
+          <label><span><input type="checkbox" checked data-preview-layer="traverse" data-menu-preview-layer="traverse">Show rapids</span><span></span></label>
+          <label><span><input type="checkbox" checked data-preview-layer="feed" data-menu-preview-layer="feed">Show feeds</span><span></span></label>
+          <label><span><input type="checkbox" checked data-preview-layer="tool" data-menu-preview-layer="tool">Show tool</span><span></span></label>
+          <label><span><input type="checkbox" checked data-preview-layer="envelope" data-menu-preview-layer="envelope">Show machine limits</span><span></span></label>
+        </div>
+      </div>
+      <div class="axis-menu">
+        <button type="button"><span>H</span>elp</button>
+        <div class="axis-menu-list" role="menu" data-axis-menu="help">
+          <button type="button" data-menu-action="quick-reference">Quick Reference <span>F1</span></button>
+          <button type="button" data-menu-action="about-axis">About AXIS <span></span></button>
+        </div>
+      </div>
     </nav>
     <div class="axis-toolbar" data-axis-shell="toolbar" aria-label="AXIS toolbar">
       <div class="toolbar-group" data-axis-shell="toolbar-file-controls">
-        <button type="button" class="toolbar-button" aria-label="Emergency stop" title="Emergency stop">■</button>
-        <button type="button" class="toolbar-button" aria-label="Open program" title="Open program" data-open-program>▣</button>
-        <button type="button" class="toolbar-button" aria-label="Reload current program" title="Reload current program" data-reload-program>↻</button>
+        <button type="button" class="toolbar-button" aria-label="Emergency stop" title="Emergency stop" data-menu-action="estop"><img src="../../../../linuxcnc/share/axis/images/tool_estop.gif" alt=""></button>
+        <button type="button" class="toolbar-button" aria-label="Power" title="Power" data-menu-action="power"><img src="../../../../linuxcnc/share/axis/images/tool_power.gif" alt=""></button>
+        <button type="button" class="toolbar-button" aria-label="Open program" title="Open program" data-open-program><img src="../../../../linuxcnc/share/axis/images/tool_open.gif" alt=""></button>
+        <button type="button" class="toolbar-button" aria-label="Reload current program" title="Reload current program" data-reload-program><img src="../../../../linuxcnc/share/axis/images/tool_reload.gif" alt=""></button>
       </div>
       <div class="program-controls">
         <select data-program-selector aria-label="Simulation test program"></select>
-        <button type="button" class="toolbar-button" data-run-program aria-label="Run selected program" title="Run selected program">▶</button>
+        <button type="button" class="toolbar-button" aria-label="Run selected program" title="Run selected program"><img src="../../../../linuxcnc/share/axis/images/tool_run.gif" alt=""></button>
         <button type="button" data-run-editor-program>Run Editor Text</button>
       </div>
       <div class="playback-controls" aria-label="Simulation playback controls">
-        <button type="button" class="toolbar-button" data-playback-reset aria-label="Reset playback" title="Reset playback">⏮</button>
-        <button type="button" class="toolbar-button" data-playback-prev aria-label="Step back" title="Step back">◀</button>
-        <button type="button" class="toolbar-button" data-playback-play aria-label="Play playback" title="Play playback">▶</button>
-        <button type="button" class="toolbar-button" data-playback-next aria-label="Step forward" title="Step forward">▶</button>
-        <button type="button" class="toolbar-button" data-playback-finish aria-label="Finish playback" title="Finish playback">⏭</button>
+        <button type="button" class="toolbar-button" data-run-program aria-label="Run selected program" title="Run"><img src="../../../../linuxcnc/share/axis/images/tool_run.gif" alt=""></button>
+        <button type="button" class="toolbar-button" data-playback-play aria-label="Pause playback" title="Pause"><img src="../../../../linuxcnc/share/axis/images/tool_pause.gif" alt=""></button>
+        <button type="button" class="toolbar-button" data-playback-next aria-label="Step forward" title="Step"><img src="../../../../linuxcnc/share/axis/images/tool_step.gif" alt=""></button>
+        <button type="button" class="toolbar-button" data-playback-reset aria-label="Stop playback" title="Stop"><img src="../../../../linuxcnc/share/axis/images/tool_stop.gif" alt=""></button>
+        <button type="button" class="toolbar-button" data-playback-finish aria-label="Finish playback" title="Verify"><img src="../../../../linuxcnc/share/axis/images/tool_verify.gif" alt=""></button>
+      </div>
+      <div class="toolbar-separator" aria-hidden="true"></div>
+      <div class="toolbar-group" aria-label="Preview orientation">
+        <button type="button" class="toolbar-button" data-preview-view-mode="top" title="Z view"><img src="../../../../linuxcnc/share/axis/images/tool_axis_z.gif" alt=""></button>
+        <button type="button" class="toolbar-button" data-preview-view-mode="front" title="Y view"><img src="../../../../linuxcnc/share/axis/images/tool_axis_y.gif" alt=""></button>
+        <button type="button" class="toolbar-button" data-preview-view-mode="side" title="X view"><img src="../../../../linuxcnc/share/axis/images/tool_axis_x.gif" alt=""></button>
+        <button type="button" class="toolbar-button" data-preview-view-mode="iso" title="Perspective"><img src="../../../../linuxcnc/share/axis/images/tool_axis_p.gif" alt=""></button>
+      </div>
+      <div class="toolbar-group" aria-label="Preview tools">
+        <button type="button" class="toolbar-button" data-preview-zoom-in title="Zoom in"><img src="../../../../linuxcnc/share/axis/images/tool_zoomin.gif" alt=""></button>
+        <button type="button" class="toolbar-button" data-preview-zoom-out title="Zoom out"><img src="../../../../linuxcnc/share/axis/images/tool_zoomout.gif" alt=""></button>
+        <button type="button" class="toolbar-button" data-preview-reset title="Rotate"><img src="../../../../linuxcnc/share/axis/images/tool_rotate.gif" alt=""></button>
+        <button type="button" class="toolbar-button" title="Block delete"><img src="../../../../linuxcnc/share/axis/images/tool_blockdelete.gif" alt=""></button>
+        <button type="button" class="toolbar-button" title="Optional stop"><img src="../../../../linuxcnc/share/axis/images/tool_optpause.gif" alt=""></button>
+        <button type="button" class="toolbar-button" title="Clear plot"><img src="../../../../linuxcnc/share/axis/images/tool_clear.gif" alt=""></button>
       </div>
       <label class="playback-readout">
         Speed
@@ -1043,41 +1399,68 @@
           <button type="button" class="tab" role="tab" aria-selected="false" data-axis-tab="mdi">MDI [F5]</button>
         </div>
         <div class="manual-panel" data-axis-panel="manual">
-          <div class="manual-row">Axis:
-            <label><input type="radio" checked disabled> X</label>
-            <label><input type="radio" disabled> Y</label>
-            <label><input type="radio" disabled> Z</label>
+          <div class="axis-jog-panel" data-axis-shell="manual-axis-jog">
+            <span class="axis-field-label">Axis:</span>
+            <div class="axis-radio-strip">
+              <label><input type="radio" name="axis-jog-axis" value="x" checked data-manual-axis="x">X</label>
+              <label><input type="radio" name="axis-jog-axis" value="y" data-manual-axis="y">Y</label>
+              <label><input type="radio" name="axis-jog-axis" value="z" data-manual-axis="z">Z</label>
+              <label><input type="radio" name="axis-jog-axis" value="a" data-manual-axis="a">A</label>
+              <label><input type="radio" name="axis-jog-axis" value="b" data-manual-axis="b">B</label>
+              <label><input type="radio" name="axis-jog-axis" value="c" data-manual-axis="c">C</label>
+              <label><input type="radio" name="axis-jog-axis" value="u" data-manual-axis="u">U</label>
+              <label><input type="radio" name="axis-jog-axis" value="v" data-manual-axis="v">V</label>
+              <label><input type="radio" name="axis-jog-axis" value="w" data-manual-axis="w">W</label>
+            </div>
+            <span class="axis-field-label">Jog:</span>
+            <div class="axis-jog-buttons">
+              <button type="button" data-axis-jog="-">-</button>
+              <button type="button" data-axis-jog="+">+</button>
+              <select aria-label="Jog increment" data-jog-increment>
+                <option>Continuous</option>
+                <option>0.0001 in</option>
+                <option>0.001 in</option>
+                <option>0.01 in</option>
+                <option>0.1 in</option>
+                <option>1.0 in</option>
+              </select>
+            </div>
+            <span></span>
+            <div class="axis-jog-buttons">
+              <button type="button" data-axis-home>Home</button>
+              <button type="button" data-axis-home-all>Home All</button>
+              <button type="button" data-axis-touch-off>Touch Off</button>
+              <button type="button" data-axis-tool-touch-off>Tool Touch Off</button>
+              <label><input type="checkbox" data-axis-limit-override> Override Limits</label>
+            </div>
           </div>
-          <div class="manual-row jog-buttons">
-            <button type="button" disabled>-</button>
-            <button type="button" disabled>+</button>
-            <select aria-label="Jog mode" disabled><option>Continuous</option></select>
+          <div class="spindle-grid" data-axis-shell="manual-spindle-coolant">
+            <span class="axis-field-label">Spindle:</span>
+            <div>
+              <div class="spindle-buttons">
+                <button type="button" data-axis-spindle="ccw" title="Turn spindle counterclockwise [F10]"><img src="../../../../linuxcnc/share/axis/images/spindle_ccw.gif" alt=""></button>
+                <button type="button" data-axis-spindle="stop" title="Stop spindle [F9/F10]">Stop</button>
+                <button type="button" data-axis-spindle="cw" title="Turn spindle clockwise [F9]"><img src="../../../../linuxcnc/share/axis/images/spindle_cw.gif" alt=""></button>
+                <button type="button" data-axis-spindle="slower" title="Turn spindle more slowly [F11]">-</button>
+                <button type="button" data-axis-spindle="faster" title="Turn spindle more quickly [F12]">+</button>
+                <label><input type="checkbox" data-axis-spindle-brake>Brake</label>
+              </div>
+            </div>
+            <span class="axis-field-label">Coolant:</span>
+            <div class="manual-row">
+              <label><input type="checkbox" data-axis-coolant="mist"> Mist</label>
+              <label><input type="checkbox" data-axis-coolant="flood"> Flood</label>
+            </div>
           </div>
-          <div class="manual-row disabled-control">
-            <button type="button" disabled>Home All</button>
-            <button type="button" disabled>Touch Off</button>
-          </div>
-          <div class="manual-row disabled-control">
-            <button type="button" disabled>Tool Touch Off</button>
-          </div>
-          <div class="manual-row">Spindle:
-            <button type="button" disabled>↺</button>
-            <button type="button" disabled>Stop</button>
-            <button type="button" disabled>↻</button>
-          </div>
-          <div class="axis-status-led" data-axis-spindle-status data-state="blocked">Spindle: <span data-machine-status="spindle-state">n/a</span> <span data-machine-status="spindle-direction">n/a</span> S<span data-machine-status="spindle-speed">n/a</span></div>
-          <div class="manual-row disabled-control">Coolant:
-            <label><input type="checkbox" disabled> Mist</label>
-            <label><input type="checkbox" disabled> Flood</label>
-          </div>
-          <div class="axis-status-led" data-axis-coolant-status data-state="blocked">Coolant: mist <span data-machine-status="coolant-mist">n/a</span> flood <span data-machine-status="coolant-flood">n/a</span></div>
-          <div class="axis-status-led" data-axis-machine-control-state data-state="blocked">Machine controls: browser simulation only; real jog/spindle/coolant are not bound</div>
+          <div class="axis-status-led" data-axis-spindle-status data-state="blocked">Spindle: <span data-machine-status="spindle-state">off</span> <span data-machine-status="spindle-direction">stopped</span> S<span data-machine-status="spindle-speed">0</span></div>
+          <div class="axis-status-led" data-axis-coolant-status data-state="blocked">Coolant: mist <span data-machine-status="coolant-mist">off</span> flood <span data-machine-status="coolant-flood">off</span></div>
+          <div class="axis-status-led" data-axis-machine-control-state data-state="ready">Machine controls: browser virtual HAL active for jog/spindle/coolant/home simulation</div>
           <div class="override-grid">
-            <span>Feed Override:</span><div class="override-bar" aria-label="Feed override 100 percent"></div>
-            <span>Rapid Override:</span><div class="override-bar" aria-label="Rapid override 100 percent"></div>
-            <span>Spindle Override:</span><div class="override-bar" aria-label="Spindle override 100 percent"></div>
-            <span>Jog Speed:</span><div>17 in/min</div>
-            <span>Max Velocity:</span><div>240 in/min</div>
+            <span>Feed Override:</span><span class="override-value">100%</span><div class="axis-slider" aria-label="Feed override 100 percent"></div>
+            <span>Rapid Override:</span><span class="override-value">100%</span><div class="axis-slider" aria-label="Rapid override 100 percent" style="--knob-a:72%;--knob-b:88%"></div>
+            <span>Spindle Override:</span><span class="override-value">100%</span><div class="axis-slider" aria-label="Spindle override 100 percent" style="--knob-a:72%;--knob-b:88%"></div>
+            <span>Jog Speed:</span><span class="override-value">17 in/min</span><div class="axis-slider" aria-label="Jog speed 17 inches per minute" style="--knob-a:20%;--knob-b:38%"></div>
+            <span>Max Velocity:</span><span class="override-value">240 in/min</span><div class="axis-slider" aria-label="Max velocity 240 inches per minute" style="--knob-a:72%;--knob-b:88%"></div>
           </div>
           <div class="machine-session-controls" data-axis-shell="machine-session">
             <div class="machine-session-grid">
@@ -1095,21 +1478,26 @@
             </div>
             <div class="machine-session-status" data-machine-session-status>
               <span>Readiness: <strong data-machine-readiness-phase>unchecked</strong></span>
-              <span>Missing: <span data-machine-readiness-missing>n/a</span></span>
-              <span>INI: <span data-machine-readiness-path="ini">n/a</span></span>
-              <span>Program: <span data-machine-readiness-path="gcode">n/a</span></span>
-              <span>Loaded INI: <span data-machine-session-loaded-path="ini">n/a</span></span>
-              <span>Loaded parameters: <span data-machine-session-loaded-path="parameters">n/a</span></span>
-              <span>Loaded tool table: <span data-machine-session-loaded-path="toolTable">n/a</span></span>
+              <span>Missing: <span data-machine-readiness-missing>unchecked</span></span>
+              <span>INI: <span data-machine-readiness-path="ini">-</span></span>
+              <span>Program: <span data-machine-readiness-path="gcode">-</span></span>
+              <span>Loaded INI: <span data-machine-session-loaded-path="ini">-</span></span>
+              <span>Loaded parameters: <span data-machine-session-loaded-path="parameters">-</span></span>
+              <span>Loaded tool table: <span data-machine-session-loaded-path="toolTable">-</span></span>
             </div>
           </div>
           <div class="active-codes" data-axis-shell="active-codes">
-            <strong>LinuxCNC UPDATE_TAG:</strong>
+            <strong>Active G-Codes:</strong>
             <div class="modal-rows" data-modal-rows></div>
           </div>
         </div>
         <div class="mdi-panel" data-axis-panel="mdi" hidden>
           <div class="mdi-box">
+            <div class="mdi-command-row">
+              <label for="axis-mdi-command">MDI Command:</label>
+              <input id="axis-mdi-command" type="text" value="G0 X0 Y0 Z0" data-mdi-command aria-label="MDI Command">
+              <button type="button" data-send-mdi-command>Go</button>
+            </div>
             <textarea class="mdi-entry" spellcheck="false" data-mdi-program-text aria-label="MDI scratch G-code program">G90 G17 G0 X0 Y0 Z0
 G1 X1.5 Y0.75 Z0 F80
 M2
@@ -1125,7 +1513,7 @@ M2
                 <button type="button" data-clear-mdi-history>Clear</button>
               </div>
               <div class="mdi-history-list" data-mdi-history-list>
-                <div class="mdi-history-empty">n/a</div>
+                <div class="mdi-history-empty">No MDI history</div>
               </div>
             </div>
           </div>
@@ -1182,16 +1570,27 @@ M2
                     <div class="preview-crosshair-label" data-preview-crosshair-label>X0.000 Y0.000</div>
                   </div>
                   <div class="preview-hud" data-axis-shell="preview-hud" aria-hidden="true">
-                    <div><span>View</span><span data-preview-hud="view">Top 100%</span></div>
-                    <div><span>Tool</span><span data-preview-hud="tool">X0.000 Y0.000 Z0.000</span></div>
-                    <div><span>Cursor</span><span data-preview-hud="cursor">n/a</span></div>
-                    <div><span>Envelope</span><span data-preview-hud="envelope">n/a</span></div>
-                    <div><span>Grid</span><span data-preview-hud="grid">n/a</span></div>
-                    <div><span>Renderer</span><span data-preview-hud="renderer">Three.js</span></div>
+                    <div><span>X:</span><span data-preview-hud="x">0.0000</span><span>DTG X:</span><span data-preview-hud="dtg-x">0.0000</span></div>
+                    <div><span>Y:</span><span data-preview-hud="y">0.0000</span><span>DTG Y:</span><span data-preview-hud="dtg-y">0.0000</span></div>
+                    <div><span>Z:</span><span data-preview-hud="z">0.0000</span><span>DTG Z:</span><span data-preview-hud="dtg-z">0.0000</span></div>
+                    <div><span>G54 X:</span><span data-preview-hud="g54-x">0.0000</span><span>G92 X:</span><span data-preview-hud="g92-x">0.0000</span></div>
+                    <div><span>G54 Y:</span><span data-preview-hud="g54-y">0.0000</span><span>G92 Y:</span><span data-preview-hud="g92-y">0.0000</span></div>
+                    <div><span>G54 Z:</span><span data-preview-hud="g54-z">0.0000</span><span>G92 Z:</span><span data-preview-hud="g92-z">0.0000</span></div>
+                    <div><span>G53</span><span></span><span></span><span></span></div>
+                    <div><span>TLO X:</span><span data-preview-hud="tlo-x">0.0000</span><span></span><span></span></div>
+                    <div><span>TLO Y:</span><span data-preview-hud="tlo-y">0.0000</span><span></span><span></span></div>
+                    <div><span>TLO Z:</span><span data-preview-hud="tlo-z">0.0000</span><span></span><span></span></div>
+                    <div><span>Vel:</span><span data-preview-hud="velocity">0.0000</span><span></span><span></span></div>
+                    <span hidden data-preview-hud="view">Top 100%</span>
+                    <span hidden data-preview-hud="tool">X0.000 Y0.000 Z0.000</span>
+                    <span hidden data-preview-hud="cursor">-</span>
+                    <span hidden data-preview-hud="envelope">loading</span>
+                    <span hidden data-preview-hud="grid">loading</span>
+                    <span hidden data-preview-hud="renderer">Three.js</span>
                   </div>
                 </div>
                 <div class="preview-legend" data-axis-shell="preview-legend">
-                  <span style="--legend-color:#6f7d86">Extents <span data-preview-extents-label>n/a</span></span>
+                  <span style="--legend-color:#6f7d86">Extents <span data-preview-extents-label>loading</span></span>
                   <span style="--legend-color:#7cc4d5">Full path</span>
                   <span style="--legend-color:#38d261">Executed path</span>
                   <span style="--legend-color:#ffdf5d">Origin</span>
@@ -1212,14 +1611,14 @@ M2
           </div>
           <div class="dro-panel" data-axis-panel="dro" hidden>
             <div class="dro-readout" data-axis-shell="dro-readout">
-              <div><span class="dro-label">X:</span><span class="dro-value" data-axis="x" data-dro-actual="x">0.000</span><span class="dro-label">DTG X:</span><span class="dro-value" data-dro-dtg="x">n/a</span></div>
-              <div><span class="dro-label">Y:</span><span class="dro-value" data-axis="y" data-dro-actual="y">0.000</span><span class="dro-label">DTG Y:</span><span class="dro-value" data-dro-dtg="y">n/a</span></div>
-              <div><span class="dro-label">Z:</span><span class="dro-value" data-axis="z" data-dro-actual="z">0.000</span><span class="dro-label">DTG Z:</span><span class="dro-value" data-dro-dtg="z">n/a</span></div>
-              <div><span class="dro-label">G54 X:</span><span class="dro-value" data-dro-g54="x">n/a</span><span class="dro-label">G92 X:</span><span class="dro-value" data-dro-g92="x">n/a</span></div>
-              <div><span class="dro-label">G54 Y:</span><span class="dro-value" data-dro-g54="y">n/a</span><span class="dro-label">G92 Y:</span><span class="dro-value" data-dro-g92="y">n/a</span></div>
-              <div><span class="dro-label">G54 Z:</span><span class="dro-value" data-dro-g54="z">n/a</span><span class="dro-label">G92 Z:</span><span class="dro-value" data-dro-g92="z">n/a</span></div>
-              <div><span class="dro-label">TLO X:</span><span class="dro-value" data-dro-tlo="x">n/a</span><span class="dro-label">Vel:</span><span class="dro-value" data-dro-velocity>n/a</span></div>
-              <div><span class="dro-label">TLO Y:</span><span class="dro-value" data-dro-tlo="y">n/a</span><span class="dro-label">TLO Z:</span><span class="dro-value" data-dro-tlo="z">n/a</span></div>
+              <div><span class="dro-label">X:</span><span class="dro-value" data-axis="x" data-dro-actual="x">0.000</span><span class="dro-label">DTG X:</span><span class="dro-value" data-dro-dtg="x">0.000</span></div>
+              <div><span class="dro-label">Y:</span><span class="dro-value" data-axis="y" data-dro-actual="y">0.000</span><span class="dro-label">DTG Y:</span><span class="dro-value" data-dro-dtg="y">0.000</span></div>
+              <div><span class="dro-label">Z:</span><span class="dro-value" data-axis="z" data-dro-actual="z">0.000</span><span class="dro-label">DTG Z:</span><span class="dro-value" data-dro-dtg="z">0.000</span></div>
+              <div><span class="dro-label">G54 X:</span><span class="dro-value" data-dro-g54="x">0.000</span><span class="dro-label">G92 X:</span><span class="dro-value" data-dro-g92="x">0.000</span></div>
+              <div><span class="dro-label">G54 Y:</span><span class="dro-value" data-dro-g54="y">0.000</span><span class="dro-label">G92 Y:</span><span class="dro-value" data-dro-g92="y">0.000</span></div>
+              <div><span class="dro-label">G54 Z:</span><span class="dro-value" data-dro-g54="z">0.000</span><span class="dro-label">G92 Z:</span><span class="dro-value" data-dro-g92="z">0.000</span></div>
+              <div><span class="dro-label">TLO X:</span><span class="dro-value" data-dro-tlo="x">0.000</span><span class="dro-label">Vel:</span><span class="dro-value" data-dro-velocity>0.000</span></div>
+              <div><span class="dro-label">TLO Y:</span><span class="dro-value" data-dro-tlo="y">0.000</span><span class="dro-label">TLO Z:</span><span class="dro-value" data-dro-tlo="z">0.000</span></div>
             </div>
           </div>
         </div>
@@ -1244,7 +1643,7 @@ M2
           <div class="recent-programs" data-axis-shell="recent-programs">
             <strong>Recent</strong>
             <div class="recent-program-list" data-recent-program-list>
-              <span class="recent-program-empty">n/a</span>
+              <span class="recent-program-empty">No recent programs</span>
             </div>
             <button type="button" data-clear-recent-programs>Clear</button>
           </div>
@@ -1277,23 +1676,23 @@ M2
               <dt>Execution Mode</dt>
               <dd data-run-summary="execution-mode">standalone</dd>
               <dt>Session INI</dt>
-              <dd data-run-summary="session-ini">n/a</dd>
+              <dd data-run-summary="session-ini">-</dd>
               <dt>OPFS Program</dt>
-              <dd data-run-summary="opfs-program">n/a</dd>
+              <dd data-run-summary="opfs-program">-</dd>
               <dt>Session State</dt>
               <dd data-run-summary="session-state">unchecked / not-loaded</dd>
               <dt>Spindle</dt>
-              <dd><span data-machine-status="spindle-state">n/a</span> <span data-machine-status="spindle-direction">n/a</span> S<span data-machine-status="spindle-speed">n/a</span></dd>
+              <dd><span data-machine-status="spindle-state">off</span> <span data-machine-status="spindle-direction">stopped</span> S<span data-machine-status="spindle-speed">0</span></dd>
               <dt>Coolant</dt>
-              <dd>mist <span data-machine-status="coolant-mist">n/a</span> flood <span data-machine-status="coolant-flood">n/a</span></dd>
+              <dd>mist <span data-machine-status="coolant-mist">off</span> flood <span data-machine-status="coolant-flood">off</span></dd>
               <dt>Tool</dt>
-              <dd>T<span data-machine-status="tool-current">n/a</span> selected <span data-machine-status="tool-selected">n/a</span> pocket <span data-machine-status="tool-pocket">n/a</span> TLO <span data-machine-status="tool-length-offset">n/a</span></dd>
+              <dd>T<span data-machine-status="tool-current">0</span> selected <span data-machine-status="tool-selected">0</span> pocket <span data-machine-status="tool-pocket">0</span> TLO <span data-machine-status="tool-length-offset">z=0.000</span></dd>
               <dt>Tool Table</dt>
-              <dd><span data-tool-table-summary="state">not-loaded</span> | <span data-tool-table-summary="paths">n/a</span> | <span data-tool-table-summary="tool">n/a</span></dd>
+              <dd><span data-tool-table-summary="state">not-loaded</span> | <span data-tool-table-summary="paths">-</span> | <span data-tool-table-summary="tool">No tool table loaded</span></dd>
               <dt>Limits/Home</dt>
-              <dd data-limits-home-summary>source unavailable | X home n/a limit n/a/n/a fault n/a</dd>
+              <dd data-limits-home-summary>source unavailable | X home no limit off/off fault none</dd>
               <dt>Overrides</dt>
-              <dd>feed <span data-machine-status="override-feed">n/a</span> speed <span data-machine-status="override-speed">n/a</span> adaptive <span data-machine-status="override-adaptive-feed">n/a</span> hold <span data-machine-status="override-feed-hold">n/a</span></dd>
+              <dd>feed <span data-machine-status="override-feed">enabled</span> speed <span data-machine-status="override-speed">enabled</span> adaptive <span data-machine-status="override-adaptive-feed">disabled</span> hold <span data-machine-status="override-feed-hold">enabled</span></dd>
               <dt>Run Control</dt>
               <dd data-run-summary="run-control">fallback: standalone until session loaded</dd>
               <dt>Preview</dt>
@@ -1303,17 +1702,17 @@ M2
             </dl>
           </div>
           <div class="diagnostics-panel" data-axis-shell="diagnostics">
-            <div><span>Last event</span><strong data-diagnostics="last-event">n/a</strong></div>
+            <div><span>Last event</span><strong data-diagnostics="last-event">pending</strong></div>
             <div><span>Last error</span><strong data-diagnostics="last-error">none</strong></div>
             <div><span>Readiness</span><strong data-diagnostics="readiness">unchecked</strong></div>
-            <div><span>Shortcut</span><strong data-diagnostics="shortcut">n/a</strong></div>
+            <div><span>Shortcut</span><strong data-diagnostics="shortcut">-</strong></div>
             <div class="tool-table-mini" data-axis-shell="tool-table">
               <table aria-label="Loaded tool table">
                 <thead>
                   <tr><th>T</th><th>P</th><th>Z</th><th>D</th><th>Comment</th></tr>
                 </thead>
                 <tbody data-tool-table-rows>
-                  <tr><td colspan="5">n/a</td></tr>
+                  <tr><td colspan="5">No tool table loaded</td></tr>
                 </tbody>
               </table>
             </div>
@@ -1323,26 +1722,56 @@ M2
                   <tr><th>Axis</th><th>Homed</th><th>Min</th><th>Max</th><th>Fault</th></tr>
                 </thead>
                 <tbody data-limits-home-rows>
-                  <tr><td colspan="5">n/a</td></tr>
+                  <tr><td colspan="5">Limits/home state not available</td></tr>
                 </tbody>
               </table>
             </div>
           </div>
           <div class="status-history" data-axis-shell="status-history">
             <strong>Status History</strong>
-            <div data-status-history>n/a</div>
+            <div data-status-history>No status history</div>
           </div>
           <pre data-canonical-output></pre>
         </div>
     </section>
     <footer class="axis-statusbar" data-axis-shell="statusbar">
-      <span><strong>ESTOP</strong></span>
-      <span>Tool <span data-statusbar="tool">n/a</span></span>
-      <span>Program <span data-program-source data-statusbar="program-source">loading</span></span>
-      <span>Line <span data-statusbar="line">-</span></span>
-      <span>Position: Relative Actual | <span data-run-mode data-statusbar="run-mode">Standalone</span></span>
-      <span>Preview <span data-statusbar="preview">Top 100%</span></span>
+      <span><strong data-statusbar="task-state">ESTOP</strong></span>
+      <span><span data-statusbar="tool">No tool</span></span>
+      <span>Position: Relative Actual</span>
+      <span class="axis-hidden-status">Program: <span data-program-source data-statusbar="program-source">loading</span></span>
+      <span class="axis-hidden-status">Line <span data-statusbar="line">-</span></span>
+      <span class="axis-hidden-status" data-run-mode data-statusbar="run-mode">Standalone</span>
+      <span class="axis-hidden-status">Preview: <span data-statusbar="preview">Top 100%</span></span>
     </footer>
+    <div class="axis-dialogs" data-axis-shell="dialogs">
+      <section class="axis-dialog" data-axis-dialog="quick-reference" aria-label="AXIS Quick Reference">
+        <header>AXIS Quick Reference</header>
+        <div class="axis-dialog-body">
+          <div class="axis-quickref">
+            <code>F1</code><span>Emergency stop</span><code>F3</code><span>Manual control</span>
+            <code>F2</code><span>Turn machine on</span><code>F5</code><span>Code entry (MDI)</span>
+            <code>X/Y/Z/A</code><span>Activate axis</span><code>Ctrl-M</code><span>Clear MDI history</span>
+            <code>, / .</code><span>Select jog speed</span><code>O</code><span>Open program</span>
+            <code>I</code><span>Select jog increment</span><code>Ctrl-R</code><span>Reload program</span>
+            <code>Home</code><span>Home active axis</span><code>R</code><span>Run program</span>
+            <code>Ctrl-Home</code><span>Home all axes</span><code>T</code><span>Step program</span>
+            <code>End</code><span>Touch off active axis</span><code>P/S</code><span>Pause / Resume</span>
+            <code>F7/F8</code><span>Mist / Flood coolant</span><code>Esc</code><span>Stop running program</span>
+            <code>F9/F10</code><span>Spindle CW / CCW</span><code>V</code><span>Cycle preset views</span>
+            <code>Wheel</code><span>Zoom preview</span><code>Ctrl-K</code><span>Clear live plot</span>
+          </div>
+        </div>
+        <footer><button type="button" data-close-axis-dialog>OK</button></footer>
+      </section>
+      <section class="axis-dialog" data-axis-dialog="about-axis" aria-label="About AXIS">
+        <header>About AXIS</header>
+        <div class="axis-dialog-body">
+          <p>LinuxCNC/AXIS browser simulation, aligned to <code>linuxcnc/bin/axis</code> and <code>linuxcnc/share/axis/tcl/axis.tcl</code>.</p>
+          <p>The preview is rendered with Three.js and motion comes from the LinuxCNC interpreter WASM runtime.</p>
+        </div>
+        <footer><button type="button" data-close-axis-dialog>OK</button></footer>
+      </section>
+    </div>
   </main>
   <script type="module">
     import {
@@ -1364,6 +1793,22 @@ M2
     } from "../../sdk/src/index.js";
     import {
       DEFAULT_SIMULATION_PROGRAM_ID,
+      VIRTUAL_HAL_AXES as SHARED_VIRTUAL_HAL_AXES,
+      applyVirtualHalAction as applySharedVirtualHalAction,
+      applyVirtualHalPinUpdates as applySharedVirtualHalPinUpdates,
+      cloneVirtualHalState as cloneSharedVirtualHalState,
+      createVirtualHalDroState as createSharedVirtualHalDroState,
+      createVirtualHalIntegrityReport as createSharedVirtualHalIntegrityReport,
+      createVirtualHalLimitsHomeState as createSharedVirtualHalLimitsHomeState,
+      createVirtualHalMachineStatusState as createSharedVirtualHalMachineStatusState,
+      createVirtualHalPinRegistry as createSharedVirtualHalPinRegistry,
+      createVirtualHalSimulationReplacementReport as createSharedVirtualHalSimulationReplacementReport,
+      createVirtualHalSimulationRuntimeReport as createSharedVirtualHalSimulationRuntimeReport,
+      createVirtualHalState,
+      executeVirtualHalcmd as executeSharedVirtualHalcmd,
+      readVirtualHalPin as readSharedVirtualHalPin,
+      stepVirtualHalMotionController as stepSharedVirtualHalMotionController,
+      writeVirtualHalPin as writeSharedVirtualHalPin,
       getSimulationTestPrograms,
       panToolpathViewBox,
       renderSimulationPlaybackFrame,
@@ -1378,6 +1823,8 @@ M2
     const reloadProgramButton = document.querySelector("[data-reload-program]");
     const openProgramFile = document.querySelector("[data-open-program-file]");
     const programEditor = document.querySelector("[data-program-editor]");
+    const mdiCommandInput = document.querySelector("[data-mdi-command]");
+    const sendMdiCommandButton = document.querySelector("[data-send-mdi-command]");
     const mdiProgramText = document.querySelector("[data-mdi-program-text]");
     const loadMdiProgramButton = document.querySelector("[data-load-mdi-program]");
     const runMdiProgramButton = document.querySelector("[data-run-mdi-program]");
@@ -1409,6 +1856,8 @@ M2
     const previewViewModeButtons = [...document.querySelectorAll("[data-preview-view-mode]")];
     const previewLayerInputs = [...document.querySelectorAll("[data-preview-layer]")];
     const toolpathSvg = document.querySelector("[data-toolpath-svg]");
+    const AXIS_UI_STORAGE_KEY = "linuxcnc.axis.browserSimulation.ui.v1";
+    const AXIS_SPLASH_PROGRAM_URL = "../../../../linuxcnc/share/axis/images/axis.ngc";
     let playbackTimer = null;
     let playbackIndex = 0;
     let previewZoom = 1;
@@ -1440,6 +1889,7 @@ M2
     };
     let mdiHistoryState = [];
     let recentProgramsState = [];
+    let axisUiPersistenceReady = false;
     let opfsProgramState = {
       ready: false,
       filename: "axis-editor.ngc",
@@ -1477,10 +1927,10 @@ M2
     let diagnosticsState = {
       apiName: "real-browser-simulation-diagnostics-state",
       diagnosticsVersion: 1,
-      lastEvent: "n/a",
+      lastEvent: "pending",
       lastError: "none",
       readiness: "unchecked",
-      shortcut: "n/a",
+      shortcut: "-",
     };
     let toolTableSummaryState = {
       apiName: "real-browser-simulation-tool-table-summary",
@@ -1489,7 +1939,7 @@ M2
       opfsPath: null,
       wasmPath: null,
       result: "",
-      firstTool: "n/a",
+      firstTool: "No tool table loaded",
       toolCount: 0,
       rows: [],
     };
@@ -1499,11 +1949,13 @@ M2
       source: "unavailable",
       axes: Object.fromEntries(["x", "y", "z", "a", "b", "c"].map((axis) => [
         axis,
-        { homed: "n/a", minLimit: "n/a", maxLimit: "n/a", fault: "n/a" },
+        { homed: "no", minLimit: "off", maxLimit: "off", fault: "none" },
       ])),
       unavailable: "limits/home state is not available from current LinuxCNC canonical output",
     };
     const statusHistory = [];
+    const VIRTUAL_HAL_AXES = SHARED_VIRTUAL_HAL_AXES;
+    let virtualHalState = createVirtualHalState();
 
     function setAllText(selector, value) {
       document.querySelectorAll(selector).forEach((node) => {
@@ -1511,18 +1963,155 @@ M2
       });
     }
 
+    function selectedAxisTab(names) {
+      for (const name of names) {
+        const tab = document.querySelector(`[data-axis-tab="${name}"]`);
+        if (tab?.getAttribute("aria-selected") === "true") {
+          return name;
+        }
+      }
+      return names[0] ?? null;
+    }
+
+    function serializeAxisUiState(reason = "manual") {
+      return {
+        apiName: "real-browser-simulation-axis-ui-persistence-state",
+        persistenceVersion: 1,
+        reason,
+        savedAt: new Date().toISOString(),
+        panels: {
+          left: selectedAxisTab(["manual", "mdi"]),
+          right: selectedAxisTab(["preview", "dro"]),
+        },
+        preview: {
+          viewMode: previewViewMode,
+          zoom: previewZoom,
+          pan: { ...previewPan },
+          layers: { ...previewLayers },
+        },
+        mdiHistory: getMdiHistory(),
+        recentPrograms: getRecentPrograms(),
+      };
+    }
+
+    function readStoredAxisUiState() {
+      try {
+        const raw = window.localStorage?.getItem(AXIS_UI_STORAGE_KEY);
+        return raw ? JSON.parse(raw) : null;
+      } catch {
+        return null;
+      }
+    }
+
+    function persistAxisUiState(reason = "manual") {
+      const state = serializeAxisUiState(reason);
+      if (!axisUiPersistenceReady) {
+        return state;
+      }
+      try {
+        window.localStorage?.setItem(AXIS_UI_STORAGE_KEY, JSON.stringify(state));
+        document.body.dataset.axisUiPersisted = "true";
+      } catch {
+        document.body.dataset.axisUiPersisted = "blocked";
+      }
+      return state;
+    }
+
+    function getAxisUiPersistenceState() {
+      return {
+        apiName: "real-browser-simulation-axis-ui-persistence",
+        persistenceVersion: 1,
+        storageKey: AXIS_UI_STORAGE_KEY,
+        available: Boolean(window.localStorage),
+        stored: readStoredAxisUiState(),
+        current: serializeAxisUiState("current"),
+      };
+    }
+
+    function restoreAxisUiState(stored = readStoredAxisUiState()) {
+      if (!stored || stored.persistenceVersion !== 1) {
+        return null;
+      }
+      if (Array.isArray(stored.mdiHistory)) {
+        mdiHistoryState = stored.mdiHistory.slice(0, 8).map((item) => ({ ...item }));
+        renderMdiHistory();
+      }
+      if (Array.isArray(stored.recentPrograms)) {
+        recentProgramsState = stored.recentPrograms.slice(0, 8).map((item) => ({
+          ...item,
+          metadata: { ...(item.metadata ?? {}) },
+        }));
+        renderRecentPrograms();
+      }
+      if (stored.preview?.layers && typeof stored.preview.layers === "object") {
+        previewLayers = {
+          ...previewLayers,
+          ...stored.preview.layers,
+        };
+        syncPreviewLayerDataset();
+      }
+      if (Number.isFinite(stored.preview?.zoom)) {
+        previewZoom = Math.min(Math.max(stored.preview.zoom, 0.25), 8);
+      }
+      if (Number.isFinite(stored.preview?.pan?.x) && Number.isFinite(stored.preview?.pan?.y)) {
+        previewPan = {
+          x: stored.preview.pan.x,
+          y: stored.preview.pan.y,
+        };
+      }
+      if (["top", "front", "side", "iso"].includes(stored.preview?.viewMode)) {
+        previewViewMode = stored.preview.viewMode;
+      }
+      setPreviewViewMode(previewViewMode, { persist: false });
+      applyPreviewZoom(previewZoom);
+      if (["manual", "mdi"].includes(stored.panels?.left)) {
+        activateAxisTab(stored.panels.left, { persist: false });
+      }
+      if (["preview", "dro"].includes(stored.panels?.right)) {
+        activateAxisTab(stored.panels.right, { persist: false });
+      }
+      document.body.dataset.axisUiRestored = "true";
+      return getAxisUiPersistenceState();
+    }
+
+    function clearAxisUiPersistence() {
+      try {
+        window.localStorage?.removeItem(AXIS_UI_STORAGE_KEY);
+        document.body.dataset.axisUiPersisted = "false";
+      } catch {
+        document.body.dataset.axisUiPersisted = "blocked";
+      }
+      return getAxisUiPersistenceState();
+    }
+
+    function switchAxisTab(target, tabs, panels, options = {}) {
+      const activeTab = tabs.find((item) => item.dataset.axisTab === target);
+      if (!activeTab) {
+        return false;
+      }
+      for (const item of tabs) {
+        item.setAttribute("aria-selected", item === activeTab ? "true" : "false");
+      }
+      for (const panel of panels) {
+        panel.hidden = panel.dataset.axisPanel !== target;
+      }
+      if (["manual", "mdi"].includes(target)) {
+        document.body.dataset.axisLeftView = target;
+      } else if (["preview", "dro"].includes(target)) {
+        document.body.dataset.axisRightView = target;
+      }
+      if (options.persist !== false) {
+        persistAxisUiState("tab");
+      }
+      return true;
+    }
+
     function mountTabGroup(tabSelector, panelSelector) {
       const tabs = [...document.querySelectorAll(tabSelector)];
       const panels = [...document.querySelectorAll(panelSelector)];
       for (const tab of tabs) {
         tab.addEventListener("click", () => {
-          const target = tab.dataset.axisTab;
-          for (const item of tabs) {
-            item.setAttribute("aria-selected", item === tab ? "true" : "false");
-          }
-          for (const panel of panels) {
-            panel.hidden = panel.dataset.axisPanel !== target;
-          }
+          switchAxisTab(tab.dataset.axisTab, tabs, panels);
         });
       }
     }
@@ -1535,7 +2124,7 @@ M2
       return String(resultText)
         .split("\n")
         .filter((line) => line.startsWith("canon_event="))
-        .at(-1) ?? "n/a";
+        .at(-1) ?? "pending";
     }
 
     function renderDiagnostics(next = {}) {
@@ -1563,7 +2152,7 @@ M2
       statusHistory.splice(5);
       setAllText(
         "[data-status-history]",
-        statusHistory.map((item) => `${item.kind}: ${item.message}`).join(" | ") || "n/a",
+        statusHistory.map((item) => `${item.kind}: ${item.message}`).join(" | ") || "No status history",
       );
       return getStatusHistory();
     }
@@ -1589,7 +2178,7 @@ M2
       if (mdiHistoryState.length === 0) {
         const empty = document.createElement("div");
         empty.className = "mdi-history-empty";
-        empty.textContent = "n/a";
+        empty.textContent = "No MDI history";
         list.append(empty);
       } else {
         for (const item of mdiHistoryState) {
@@ -1622,7 +2211,9 @@ M2
       });
       mdiHistoryState.splice(8);
       pushStatusHistory("mdi", `history ${mdiHistoryState.length}`);
-      return renderMdiHistory();
+      const rendered = renderMdiHistory();
+      persistAxisUiState("mdi-history");
+      return rendered;
     }
 
     function selectMdiHistoryItem(index) {
@@ -1641,7 +2232,9 @@ M2
       mdiHistoryState = [];
       setAllText("[data-mdi-status]", "MDI history cleared");
       pushStatusHistory("mdi", "history cleared");
-      return renderMdiHistory();
+      const rendered = renderMdiHistory();
+      persistAxisUiState("mdi-history-clear");
+      return rendered;
     }
 
     function getRecentPrograms() {
@@ -1660,7 +2253,7 @@ M2
       if (recentProgramsState.length === 0) {
         const empty = document.createElement("span");
         empty.className = "recent-program-empty";
-        empty.textContent = "n/a";
+        empty.textContent = "No recent programs";
         list.append(empty);
       } else {
         for (const item of recentProgramsState) {
@@ -1702,7 +2295,9 @@ M2
       recentProgramsState.unshift(entry);
       recentProgramsState.splice(8);
       pushStatusHistory("recent", `${entry.source}: ${entry.label}`);
-      return renderRecentPrograms();
+      const rendered = renderRecentPrograms();
+      persistAxisUiState("recent-program");
+      return rendered;
     }
 
     function selectRecentProgram(index) {
@@ -1721,7 +2316,9 @@ M2
     function clearRecentPrograms() {
       recentProgramsState = [];
       pushStatusHistory("recent", "cleared");
-      return renderRecentPrograms();
+      const rendered = renderRecentPrograms();
+      persistAxisUiState("recent-clear");
+      return rendered;
     }
 
     function parseToolTableLine(line) {
@@ -1729,10 +2326,10 @@ M2
       if (!trimmed || trimmed.startsWith(";")) {
         return null;
       }
-      const tool = trimmed.match(/\bT([0-9]+)/i)?.[1] ?? "n/a";
-      const pocket = trimmed.match(/\bP([0-9]+)/i)?.[1] ?? "n/a";
-      const z = trimmed.match(/\bZ([-+0-9.eE]+)/i)?.[1] ?? "n/a";
-      const diameter = trimmed.match(/\bD([-+0-9.eE]+)/i)?.[1] ?? "n/a";
+      const tool = trimmed.match(/\bT([0-9]+)/i)?.[1] ?? "-";
+      const pocket = trimmed.match(/\bP([0-9]+)/i)?.[1] ?? "-";
+      const z = trimmed.match(/\bZ([-+0-9.eE]+)/i)?.[1] ?? "0.000";
+      const diameter = trimmed.match(/\bD([-+0-9.eE]+)/i)?.[1] ?? "0.000";
       const comment = trimmed.includes(";") ? trimmed.split(";").slice(1).join(";").trim() : "";
       return {
         raw: trimmed,
@@ -1758,7 +2355,7 @@ M2
         opfsPath: toolTable?.opfsPath ?? null,
         wasmPath: toolTable?.wasmPath ?? null,
         result,
-        firstTool: toolRows[0]?.label ?? "n/a",
+        firstTool: toolRows[0]?.label ?? "No tool table loaded",
         toolCount: toolRows.length,
         rows: toolRows,
       };
@@ -1769,7 +2366,7 @@ M2
       setAllText("[data-tool-table-summary=\"state\"]", `${toolTableSummaryState.state} (${toolTableSummaryState.toolCount})`);
       setAllText(
         "[data-tool-table-summary=\"paths\"]",
-        toolTableSummaryState.wasmPath ? `${toolTableSummaryState.opfsPath} -> ${toolTableSummaryState.wasmPath}` : "n/a",
+        toolTableSummaryState.wasmPath ? `${toolTableSummaryState.opfsPath} -> ${toolTableSummaryState.wasmPath}` : "-",
       );
       setAllText("[data-tool-table-summary=\"tool\"]", toolTableSummaryState.firstTool);
       const body = document.querySelector("[data-tool-table-rows]");
@@ -1779,7 +2376,7 @@ M2
           const row = document.createElement("tr");
           const cell = document.createElement("td");
           cell.colSpan = 5;
-          cell.textContent = "n/a";
+          cell.textContent = "No tool table loaded";
           row.append(cell);
           body.append(row);
         } else {
@@ -1798,6 +2395,142 @@ M2
       return { ...toolTableSummaryState };
     }
 
+    function cloneVirtualHalState() {
+      return cloneSharedVirtualHalState(virtualHalState);
+    }
+
+    function createVirtualHalDroState() {
+      return createSharedVirtualHalDroState(virtualHalState);
+    }
+
+    function createVirtualHalLimitsHomeState() {
+      return createSharedVirtualHalLimitsHomeState(virtualHalState);
+    }
+
+    function renderVirtualHalDro() {
+      const dro = createVirtualHalDroState();
+      for (const axis of Object.keys(dro.actual)) {
+        setAllText(`[data-axis="${axis}"]`, dro.actual[axis]);
+        setAllText(`[data-dro-actual="${axis}"]`, dro.actual[axis]);
+        setAllText(`[data-dro-dtg="${axis}"]`, dro.distanceToGo[axis]);
+        setAllText(`[data-dro-g54="${axis}"]`, dro.workOffsetG54[axis]);
+        setAllText(`[data-dro-g92="${axis}"]`, dro.g92Offset[axis]);
+        setAllText(`[data-dro-tlo="${axis}"]`, dro.toolLengthOffset[axis]);
+        setAllText(`[data-preview-hud="${axis}"]`, Number(dro.actual[axis]).toFixed(4));
+      }
+      setAllText("[data-dro-velocity]", dro.velocity);
+      setAllText("[data-preview-hud=\"velocity\"]", Number(dro.velocity).toFixed(4));
+      return dro;
+    }
+
+    function createVirtualHalMachineStatus() {
+      return createSharedVirtualHalMachineStatusState(virtualHalState);
+    }
+
+    function createVirtualHalPinRegistry() {
+      return createSharedVirtualHalPinRegistry(virtualHalState);
+    }
+
+    function readVirtualHalPin(name) {
+      return readSharedVirtualHalPin(virtualHalState, name);
+    }
+
+    function writeVirtualHalPin(update, options = {}) {
+      virtualHalState = writeSharedVirtualHalPin(virtualHalState, update, options);
+      const rendered = renderVirtualHalState();
+      pushStatusHistory("hal", `api pin ${update?.name ?? update} rev ${virtualHalState.revision}`);
+      renderAxisStatusbar();
+      return rendered;
+    }
+
+    function applyVirtualHalPinUpdates(updates, options = {}) {
+      virtualHalState = applySharedVirtualHalPinUpdates(virtualHalState, updates, options);
+      const rendered = renderVirtualHalState();
+      pushStatusHistory("hal", `api pin batch ${updates?.length ?? 0} rev ${virtualHalState.revision}`);
+      renderAxisStatusbar();
+      return rendered;
+    }
+
+    function createVirtualHalIntegrityReport() {
+      return createSharedVirtualHalIntegrityReport({ halState: virtualHalState });
+    }
+
+    function executeVirtualHalcmd(commandText, options = {}) {
+      const result = executeSharedVirtualHalcmd(virtualHalState, commandText, options);
+      virtualHalState = result.state;
+      renderVirtualHalState();
+      pushStatusHistory("halcmd", `${result.commandCount} commands ${result.ok ? "ok" : "failed"}`);
+      renderAxisStatusbar();
+      return result;
+    }
+
+    function stepVirtualHalMotionController(options = {}) {
+      const result = stepSharedVirtualHalMotionController(virtualHalState, options);
+      virtualHalState = result.state;
+      renderVirtualHalState();
+      pushStatusHistory("motion", `${result.cycleCount} cycles dtg ${result.distanceToGo.toFixed(6)}`);
+      renderAxisStatusbar();
+      return result;
+    }
+
+    function createVirtualHalSimulationRuntimeReport() {
+      return createSharedVirtualHalSimulationRuntimeReport(virtualHalState);
+    }
+
+    function createVirtualHalSimulationReplacementReport() {
+      return createSharedVirtualHalSimulationReplacementReport(virtualHalState);
+    }
+
+    function renderMachineStatusDom(machineStatus) {
+      const statusMap = {
+        "spindle-state": machineStatus.spindle.state,
+        "spindle-direction": machineStatus.spindle.direction,
+        "spindle-speed": machineStatus.spindle.speed,
+        "coolant-mist": machineStatus.coolant.mist,
+        "coolant-flood": machineStatus.coolant.flood,
+        "tool-current": machineStatus.tool.current,
+        "tool-selected": machineStatus.tool.selected,
+        "tool-pocket": machineStatus.tool.pocket,
+        "tool-length-offset": machineStatus.tool.lengthOffset,
+        "override-feed": machineStatus.overrides.feed,
+        "override-speed": machineStatus.overrides.speed,
+        "override-adaptive-feed": machineStatus.overrides.adaptiveFeed,
+        "override-feed-hold": machineStatus.overrides.feedHold,
+      };
+      for (const [name, value] of Object.entries(statusMap)) {
+        setAllText(`[data-machine-status="${name}"]`, value);
+      }
+      for (const node of document.querySelectorAll("[data-axis-spindle-status]")) {
+        node.dataset.state = machineStatus.spindle.state === "on" ? "ready" : "blocked";
+      }
+      for (const node of document.querySelectorAll("[data-axis-coolant-status]")) {
+        node.dataset.state = machineStatus.coolant.mist === "on" || machineStatus.coolant.flood === "on" ? "ready" : "blocked";
+      }
+    }
+
+    function renderVirtualHalState() {
+      const taskState = virtualHalState.task.state;
+      document.body.dataset.virtualHalActive = "true";
+      document.body.dataset.virtualHalTaskState = taskState;
+      setAllText("[data-statusbar=\"task-state\"]", taskState);
+      setAllText("[data-simulation-status]", `virtual HAL ${taskState}`);
+      renderMachineStatusDom(createVirtualHalMachineStatus());
+      if (virtualHalState.positionDirty) {
+        renderVirtualHalDro();
+      }
+      renderLimitsHomeState(createVirtualHalLimitsHomeState());
+      document.querySelector("[data-axis-machine-control-state]")?.setAttribute("data-state", "ready");
+      return cloneVirtualHalState();
+    }
+
+    function updateVirtualHal(action, options = {}, reason = "manual") {
+      virtualHalState = applySharedVirtualHalAction(virtualHalState, action, options);
+      const rendered = renderVirtualHalState();
+      pushStatusHistory("hal", `${reason} ${virtualHalState.jog.lastAction} rev ${virtualHalState.revision}`);
+      renderAxisStatusbar();
+      return rendered;
+    }
+
     function renderLimitsHomeState(state = limitsHomeState) {
       const axes = Object.entries(state.axes);
       const first = state.axes.x;
@@ -1832,11 +2565,13 @@ M2
         artifactVersion: 1,
         program: state?.program ? { ...state.program, text: undefined } : null,
         diagnostics: renderDiagnostics(),
+        virtualHal: cloneVirtualHalState(),
+        virtualHalSimulationReplacement: createVirtualHalSimulationReplacementReport(),
         statusHistory: getStatusHistory(),
         mdiHistory: getMdiHistory(),
         recentPrograms: getRecentPrograms(),
         toolTable: { ...toolTableSummaryState, rows: toolTableSummaryState.rows.map((row) => ({ ...row })) },
-        limitsHome: renderLimitsHomeState(),
+        limitsHome: createVirtualHalLimitsHomeState(),
         runSummary: renderRunSummary(),
         preview: getPreviewState(),
         playback: {
@@ -1904,9 +2639,9 @@ M2
     function renderMachineSessionLoad(loadState) {
       machineSessionLoadState = loadState;
       document.body.dataset.machineSessionLoaded = loadState.loaded ? "true" : "false";
-      setAllText("[data-machine-session-loaded-path=\"ini\"]", loadState.ini?.wasmPath ?? "n/a");
-      setAllText("[data-machine-session-loaded-path=\"parameters\"]", loadState.parameters?.wasmPath ?? "n/a");
-      setAllText("[data-machine-session-loaded-path=\"toolTable\"]", loadState.toolTable?.wasmPath ?? "n/a");
+      setAllText("[data-machine-session-loaded-path=\"ini\"]", loadState.ini?.wasmPath ?? "-");
+      setAllText("[data-machine-session-loaded-path=\"parameters\"]", loadState.parameters?.wasmPath ?? "-");
+      setAllText("[data-machine-session-loaded-path=\"toolTable\"]", loadState.toolTable?.wasmPath ?? "-");
       renderToolTableSummary(loadState.toolTable);
       renderDiagnostics({
         readiness: `${machineReadinessState.phase ?? "unchecked"} / ${loadState.phase ?? "not-loaded"}`,
@@ -2013,8 +2748,8 @@ M2
     function renderRunSummary(state = currentState()) {
       const summary = createRunSummary(state);
       setAllText("[data-run-summary=\"execution-mode\"]", summary.executionMode);
-      setAllText("[data-run-summary=\"session-ini\"]", summary.sessionIniPath ?? "n/a");
-      setAllText("[data-run-summary=\"opfs-program\"]", summary.opfsProgramPath ?? "n/a");
+      setAllText("[data-run-summary=\"session-ini\"]", summary.sessionIniPath ?? "-");
+      setAllText("[data-run-summary=\"opfs-program\"]", summary.opfsProgramPath ?? "-");
       setAllText("[data-run-summary=\"session-state\"]", `${summary.readinessPhase} / ${summary.sessionLoadPhase}`);
       setAllText("[data-run-summary=\"run-control\"]", `${summary.runControlPhase}: ${summary.runControlReason}`);
       setAllText("[data-run-summary=\"preview-state\"]", previewStateLabel(summary.preview));
@@ -2159,7 +2894,7 @@ M2
     }
 
     function formatPreviewCursor(cursor = previewCursor) {
-      return cursor.active ? `X${cursor.x.toFixed(3)} Y${cursor.y.toFixed(3)}` : "n/a";
+      return cursor.active ? `X${cursor.x.toFixed(3)} Y${cursor.y.toFixed(3)}` : "-";
     }
 
     function renderPreviewCursor() {
@@ -2385,14 +3120,14 @@ M2
       const viewText = `${previewViewModeLabel(previewViewMode)} ${Math.round(previewZoom * 100)}% pan x${previewPan.x.toFixed(3)} y${previewPan.y.toFixed(3)}`;
       const toolText = toolhead
         ? `X${Number(toolhead.x ?? 0).toFixed(3)} Y${Number(toolhead.y ?? 0).toFixed(3)} Z${Number(toolhead.z ?? 0).toFixed(3)} ${toolGeometry?.toolNumber ? `T${toolGeometry.toolNumber}` : ""}`.trim()
-        : "n/a";
+        : "X0.000 Y0.000 Z0.000";
       const envelopeText = envelope
         ? `X ${formatPreviewHudRange(envelope.minX, envelope.maxX)} Y ${formatPreviewHudRange(envelope.minY, envelope.maxY)} Z ${formatPreviewHudRange(envelope.minZ, envelope.maxZ)}`
-        : "n/a";
+        : "loading";
       const gridText = viewBox
-        ? `step ${threeCanvas?.dataset.threeGridStep ?? "n/a"} lines ${threeCanvas?.dataset.threeGridLines ?? "0"}`
-        : "n/a";
-      const rendererText = `Three.js r${threeCanvas?.dataset.threeRevision ?? "n/a"} path ${threeCanvas?.dataset.threePathPoints ?? "0"} exec ${threeCanvas?.dataset.threeExecutedPoints ?? "0"}`;
+        ? `step ${threeCanvas?.dataset.threeGridStep ?? "-"} lines ${threeCanvas?.dataset.threeGridLines ?? "0"}`
+        : "loading";
+      const rendererText = `Three.js r${threeCanvas?.dataset.threeRevision ?? "-"} path ${threeCanvas?.dataset.threePathPoints ?? "0"} exec ${threeCanvas?.dataset.threeExecutedPoints ?? "0"}`;
       setAllText("[data-preview-hud=\"view\"]", viewText);
       setAllText("[data-preview-hud=\"tool\"]", toolText);
       setAllText("[data-preview-hud=\"cursor\"]", formatPreviewCursor());
@@ -2405,11 +3140,12 @@ M2
     function renderAxisStatusbar(preview = null) {
       const state = currentState();
       const frame = state ? frameFromPlaybackState(state) : null;
-      const tool = document.querySelector('[data-machine-status="tool-current"]')?.textContent ?? "n/a";
+      const tool = document.querySelector('[data-machine-status="tool-current"]')?.textContent ?? "0";
       const source = document.querySelector("[data-program-source]")?.textContent ?? "loading";
       const runMode = document.querySelector("[data-run-mode]")?.textContent ?? "Standalone";
       const previewState = preview ?? getPreviewState();
-      setAllText("[data-statusbar=\"tool\"]", tool && tool !== "n/a" ? `T${tool}` : "n/a");
+      const toolLabel = tool && tool !== "-" && tool !== "0" ? `T${tool}` : "No tool";
+      setAllText("[data-statusbar=\"tool\"]", toolLabel);
       setAllText("[data-statusbar=\"program-source\"]", source);
       setAllText("[data-statusbar=\"line\"]", frame?.line ? `${frame.line}` : "-");
       setAllText("[data-statusbar=\"run-mode\"]", runMode);
@@ -2419,7 +3155,7 @@ M2
       return {
         apiName: "real-browser-simulation-axis-statusbar-state",
         statusbarVersion: 1,
-        tool: tool && tool !== "n/a" ? `T${tool}` : "n/a",
+        tool: toolLabel,
         programSource: source,
         line: frame?.line ?? null,
         runMode,
@@ -2577,6 +3313,14 @@ M2
       }
     }
 
+    async function loadAxisSplashProgramText() {
+      const response = await fetch(AXIS_SPLASH_PROGRAM_URL);
+      if (!response.ok) {
+        throw new Error(`Unable to load ${AXIS_SPLASH_PROGRAM_URL}: ${response.status}`);
+      }
+      return response.text();
+    }
+
     async function runSelectedProgram(programId = programSelector?.value ?? DEFAULT_SIMULATION_PROGRAM_ID) {
       stopPlayback();
       document.body.dataset.simulationReady = "false";
@@ -2813,6 +3557,182 @@ M2
       return state;
     }
 
+    async function runMdiCommand(command = mdiCommandInput?.value ?? "") {
+      const normalized = String(command ?? "").trim();
+      if (!normalized) {
+        setAllText("[data-mdi-status]", "MDI command is empty");
+        return null;
+      }
+      const programText = `G90 G17\n${normalized}\nM2\n`;
+      const state = await runProgramText(programText, {
+        label: `MDI: ${normalized}`,
+        source: "mdi",
+        sourceLabel: "AXIS MDI command",
+      });
+      pushMdiHistory(normalized, {
+        motionEventCount: state.summary.motionEventCount,
+        source: "mdi-command",
+      });
+      setAllText("[data-mdi-status]", `Go: ${normalized}`);
+      return state;
+    }
+
+    function openAxisDialog(name) {
+      for (const dialog of document.querySelectorAll("[data-axis-dialog]")) {
+        dialog.dataset.open = dialog.dataset.axisDialog === name ? "true" : "false";
+      }
+      document.body.dataset.axisDialog = name;
+      pushStatusHistory("dialog", name);
+      return name;
+    }
+
+    function closeAxisDialogs() {
+      for (const dialog of document.querySelectorAll("[data-axis-dialog]")) {
+        dialog.dataset.open = "false";
+      }
+      document.body.dataset.axisDialog = "closed";
+      return "closed";
+    }
+
+    function normalizeManualHalAction(action) {
+      if (action === "home-all" || action === "unhome-all" || action === "zero-g54" || action === "tool-touch-off" || action === "touch-off" || action === "home") {
+        return { action, options: {} };
+      }
+      const jog = String(action).match(/^jog ([+-])$/);
+      if (jog) {
+        return { action: "jog", options: { direction: jog[1] === "+" ? 1 : -1 } };
+      }
+      const spindle = String(action).match(/^spindle (cw|ccw|stop|slower|faster)$/);
+      if (spindle) {
+        if (spindle[1] === "slower") {
+          return { action: "spindle", options: { command: virtualHalState.spindle.state === "on" ? virtualHalState.spindle.direction : "cw", speed: Math.max(0, virtualHalState.spindle.speed - 100) } };
+        }
+        if (spindle[1] === "faster") {
+          return { action: "spindle", options: { command: virtualHalState.spindle.state === "on" ? virtualHalState.spindle.direction : "cw", speed: virtualHalState.spindle.speed + 100 } };
+        }
+        return { action: "spindle", options: { command: spindle[1] } };
+      }
+      const coolant = String(action).match(/^coolant (mist|flood) (on|off)$/);
+      if (coolant) {
+        return { action: "coolant", options: { name: coolant[1], enabled: coolant[2] === "on" } };
+      }
+      const brake = String(action).match(/^spindle brake (on|off)$/);
+      if (brake) {
+        return { action: "spindle-brake", options: { enabled: brake[1] === "on" } };
+      }
+      const limits = String(action).match(/^override limits (on|off)$/);
+      if (limits) {
+        return { action: "override-limits", options: { enabled: limits[1] === "on" } };
+      }
+      return { action: String(action), options: {} };
+    }
+
+    function recordManualControl(action, options = {}) {
+      const axis = document.querySelector("[data-manual-axis]:checked")?.value ?? "x";
+      const increment = document.querySelector("[data-jog-increment]")?.value ?? "Continuous";
+      const label = `${action} axis ${axis.toUpperCase()} ${increment}`;
+      const normalized = normalizeManualHalAction(action);
+      const hal = updateVirtualHal(normalized.action, {
+        axis,
+        increment,
+        ...normalized.options,
+        ...options,
+      }, `manual ${action}`);
+      document.body.dataset.axisManualAction = label;
+      renderDiagnostics({ shortcut: label });
+      setAllText("[data-simulation-status]", `virtual HAL ${hal.task.state}`);
+      return {
+        apiName: "real-browser-simulation-manual-control-action",
+        action,
+        halAction: normalized.action,
+        axis,
+        increment,
+        halBound: true,
+        hal,
+      };
+    }
+
+    function cyclePreviewView() {
+      const modes = ["top", "front", "side", "iso"];
+      const current = Math.max(0, modes.indexOf(previewViewMode));
+      return setPreviewViewMode(modes[(current + 1) % modes.length]);
+    }
+
+    function clearLivePlot() {
+      renderPlayback(0);
+      fitPreview();
+      pushStatusHistory("preview", "clear live plot");
+      return getPreviewState();
+    }
+
+    function handleAxisMenuAction(action) {
+      const api = window.linuxCncRealSimulationApi;
+      if (!api) {
+        return null;
+      }
+      if (action === "open-program") {
+        openProgramFile?.click();
+      } else if (action === "recent-programs") {
+        document.querySelector("[data-recent-program-list]")?.scrollIntoView({ block: "nearest" });
+      } else if (action === "edit-program") {
+        programEditor?.focus();
+      } else if (action === "reload-program") {
+        api.reloadCurrentProgram().catch((error) => recordError(error, "menu reload"));
+      } else if (action === "save-gcode") {
+        api.saveProgramToOpfs().catch((error) => recordError(error, "menu save"));
+      } else if (action === "gcode-properties") {
+        openAxisDialog("about-axis");
+      } else if (action === "edit-tool-data" || action === "reload-tool-data") {
+        pushStatusHistory("tool", `${action}: OPFS tool table summary available`);
+      } else if (action === "ladder-editor") {
+        pushStatusHistory("machine", "ladder editor unavailable in browser simulation");
+      } else if (action === "quit") {
+        pushStatusHistory("window", "quit requested");
+      } else if (action === "estop" || action === "power") {
+        updateVirtualHal(action, {}, `machine ${action}`);
+      } else if (action === "run-program") {
+        api.runProgramById(programSelector?.value ?? DEFAULT_SIMULATION_PROGRAM_ID).catch((error) => recordError(error, "menu run"));
+      } else if (action === "run-from-line") {
+        api.stepPlayback(1);
+        pushStatusHistory("run", "run from selected line simulated with playback step");
+      } else if (action === "step-program") {
+        api.stepPlayback(1);
+      } else if (action === "pause-program") {
+        api.pause();
+      } else if (action === "resume-program") {
+        api.play();
+      } else if (action === "stop-program") {
+        api.resetPlayback();
+        api.pause();
+      } else if (action === "clear-mdi-history") {
+        api.clearMdiHistory();
+      } else if (action === "copy-mdi-history") {
+        pushStatusHistory("mdi", "copy history requested");
+      } else if (action === "paste-mdi-history") {
+        pushStatusHistory("mdi", "paste history requested");
+      } else if (action === "home-all" || action === "unhome-all" || action === "zero-g54" || action === "tool-touch-off") {
+        recordManualControl(action);
+      } else if (action === "view-top") {
+        api.setPreviewViewMode("top");
+      } else if (action === "view-front") {
+        api.setPreviewViewMode("front");
+      } else if (action === "view-side") {
+        api.setPreviewViewMode("side");
+      } else if (action === "view-iso") {
+        api.setPreviewViewMode("iso");
+      } else if (action === "clear-plot") {
+        clearLivePlot();
+      } else if (action === "fit-preview") {
+        api.fitPreview();
+      } else if (action === "quick-reference") {
+        openAxisDialog("quick-reference");
+      } else if (action === "about-axis") {
+        openAxisDialog("about-axis");
+      }
+      document.body.dataset.axisLastMenuAction = action;
+      return action;
+    }
+
     function activateAxisTab(name) {
       const tab = document.querySelector(`[data-axis-tab="${name}"]`);
       if (!tab) {
@@ -2849,7 +3769,13 @@ M2
       }
       const key = event.key;
       let action = null;
-      if (key === "F3") {
+      if (key === "F1") {
+        updateVirtualHal("estop", {}, "shortcut F1");
+        action = "F1 ESTOP";
+      } else if (key === "F2") {
+        updateVirtualHal("power", {}, "shortcut F2");
+        action = "F2 Power";
+      } else if (key === "F3") {
         activateAxisTab("manual");
         action = "F3 Manual";
       } else if (key === "F5") {
@@ -2879,9 +3805,12 @@ M2
       } else if (key === "ArrowLeft") {
         stepPlayback(-1);
         action = "ArrowLeft Step";
+      } else if (key === "Home" && event.ctrlKey) {
+        recordManualControl("home-all");
+        action = "Ctrl-Home Home All";
       } else if (key === "Home") {
-        renderPlayback(0);
-        action = "Home Reset";
+        recordManualControl("home");
+        action = "Home Home";
       } else if (key === "End") {
         renderPlayback(currentState()?.motion.length - 1 ?? 0);
         action = "End Finish";
@@ -2899,7 +3828,19 @@ M2
     }
 
     try {
-      const state = await runSelectedProgram(DEFAULT_SIMULATION_PROGRAM_ID);
+      let state = null;
+      try {
+        const axisSplashText = await loadAxisSplashProgramText();
+        state = await runProgramText(axisSplashText, {
+          filename: "axis.ngc",
+          label: "axis.ngc",
+          source: "linuxcnc-axis",
+          sourceLabel: "linuxcnc/configs/sim/axis/axis.ini PROGRAM_PREFIX: linuxcnc/share/axis/images/axis.ngc",
+        });
+      } catch (error) {
+        recordError(error, "axis splash load");
+        state = await runSelectedProgram(DEFAULT_SIMULATION_PROGRAM_ID);
+      }
       window.linuxCncRealSimulationState = state;
       window.linuxCncRealSimulationApi = {
         getState: () => window.linuxCncRealSimulationState,
@@ -2916,13 +3857,36 @@ M2
         getAxisStatusbarState: () => renderAxisStatusbar(),
         setUseLoadedSession,
         getRunSummary: () => renderRunSummary(),
+        getVirtualHalState: () => cloneVirtualHalState(),
+        applyVirtualHalAction: (action, options = {}) => updateVirtualHal(action, options, `api ${action}`),
+        getVirtualHalPinRegistry: () => createVirtualHalPinRegistry(),
+        readVirtualHalPin: (name) => readVirtualHalPin(name),
+        writeVirtualHalPin: (update, options = {}) => writeVirtualHalPin(update, options),
+        applyVirtualHalPinUpdates: (updates, options = {}) => applyVirtualHalPinUpdates(updates, options),
+        getVirtualHalIntegrityReport: () => createVirtualHalIntegrityReport(),
+        executeVirtualHalcmd: (commandText, options = {}) => executeVirtualHalcmd(commandText, options),
+        executeVirtualHalCommand: (commandText, options = {}) => executeVirtualHalcmd(commandText, options),
+        stepVirtualHalMotionController: (options = {}) => stepVirtualHalMotionController(options),
+        getVirtualHalSimulationRuntimeReport: () => createVirtualHalSimulationRuntimeReport(),
+        getVirtualHalSimulationReplacementReport: () => createVirtualHalSimulationReplacementReport(),
+        getVirtualRealtimeHalRuntimeReport: () => createVirtualHalSimulationReplacementReport(),
+        getVirtualHalDroState: () => createVirtualHalDroState(),
+        getVirtualHalLimitsHomeState: () => createVirtualHalLimitsHomeState(),
+        getVirtualHalMachineStatusState: () => createVirtualHalMachineStatus(),
         getDiagnosticsState: () => renderDiagnostics(),
         getStatusHistory,
         getToolTableSummary: () => ({ ...toolTableSummaryState }),
-        getLimitsHomeState: () => renderLimitsHomeState(),
+        getLimitsHomeState: () => renderLimitsHomeState(createVirtualHalLimitsHomeState()),
         exportDiagnosticsArtifact,
         handleAxisShortcut,
+        handleAxisMenuAction,
         applyAxisViewFromUrl,
+        runMdiCommand,
+        recordManualControl,
+        openAxisDialog,
+        closeAxisDialogs,
+        clearLivePlot,
+        cyclePreviewView,
         getMdiHistory,
         clearMdiHistory,
         getRecentPrograms,
@@ -3051,6 +4015,22 @@ M2
       });
       clearMdiHistoryButton?.addEventListener("click", () => clearMdiHistory());
       clearRecentProgramsButton?.addEventListener("click", () => clearRecentPrograms());
+      sendMdiCommandButton?.addEventListener("click", () => {
+        window.linuxCncRealSimulationApi.runMdiCommand().catch((error) => {
+          document.body.dataset.simulationReady = "false";
+          setAllText("[data-mdi-status]", `MDI command failed: ${error.message}`);
+          setAllText("[data-simulation-status]", "failed");
+          document.querySelector("[data-canonical-output]").textContent = error?.stack ?? error?.message ?? String(error);
+          recordError(error, "mdi command");
+        });
+      });
+      mdiCommandInput?.addEventListener("keydown", (event) => {
+        if (event.key !== "Enter") {
+          return;
+        }
+        event.preventDefault();
+        sendMdiCommandButton?.click();
+      });
       programEditor?.addEventListener("input", () => {
         programEditorState = {
           text: programEditor.value,
@@ -3094,9 +4074,47 @@ M2
       for (const input of previewLayerInputs) {
         input.addEventListener("change", () => setPreviewLayer(input.dataset.previewLayer, input.checked));
       }
+      for (const button of document.querySelectorAll("[data-menu-action]")) {
+        button.addEventListener("click", () => handleAxisMenuAction(button.dataset.menuAction));
+      }
+      for (const input of document.querySelectorAll("[data-axis-toggle]")) {
+        input.addEventListener("change", () => {
+          document.body.dataset[input.dataset.axisToggle.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase())] = input.checked ? "true" : "false";
+          pushStatusHistory("machine", `${input.dataset.axisToggle} ${input.checked ? "on" : "off"}`);
+        });
+      }
+      for (const button of document.querySelectorAll("[data-axis-jog], [data-axis-home], [data-axis-home-all], [data-axis-touch-off], [data-axis-tool-touch-off], [data-axis-spindle]")) {
+        button.addEventListener("click", () => {
+          const action = button.dataset.axisJog
+            ? `jog ${button.dataset.axisJog}`
+            : button.dataset.axisSpindle
+              ? `spindle ${button.dataset.axisSpindle}`
+              : button.hasAttribute("data-axis-home")
+                ? "home"
+                : button.hasAttribute("data-axis-home-all")
+                  ? "home-all"
+                  : button.hasAttribute("data-axis-touch-off")
+                    ? "touch-off"
+                    : "tool-touch-off";
+          recordManualControl(action);
+        });
+      }
+      for (const input of document.querySelectorAll("[data-axis-limit-override], [data-axis-spindle-brake], [data-axis-coolant]")) {
+        input.addEventListener("change", () => {
+          const action = input.dataset.axisCoolant
+            ? `coolant ${input.dataset.axisCoolant} ${input.checked ? "on" : "off"}`
+            : input.hasAttribute("data-axis-spindle-brake")
+              ? `spindle brake ${input.checked ? "on" : "off"}`
+              : `override limits ${input.checked ? "on" : "off"}`;
+          recordManualControl(action);
+        });
+      }
+      for (const button of document.querySelectorAll("[data-close-axis-dialog]")) {
+        button.addEventListener("click", closeAxisDialogs);
+      }
       syncPreviewLayerDataset();
       setPreviewViewMode("top");
-      renderLimitsHomeState();
+      renderVirtualHalState();
       renderMdiHistory();
       renderRecentPrograms();
       applyAxisViewFromUrl();
diff --git a/wasm-port/runtime/ui/simulation/simulation-app.js b/wasm-port/runtime/ui/simulation/simulation-app.js
index 85e2193..ae20dd2 100644
--- a/wasm-port/runtime/ui/simulation/simulation-app.js
+++ b/wasm-port/runtime/ui/simulation/simulation-app.js
@@ -15,6 +15,32 @@ export {
   getSimulationTestProgram,
   getSimulationTestPrograms,
 };
+export {
+  VIRTUAL_HAL_AXES,
+  VIRTUAL_HAL_AXISUI_PINS,
+  VIRTUAL_HAL_SIMULATION_REPLACEMENT_TARGETS,
+  VIRTUAL_HAL_SIMULATION_RUNTIME_CAPABILITIES,
+  applyVirtualHalAction,
+  applyVirtualHalPinUpdates,
+  cloneVirtualHalState,
+  createLinuxCncVirtualHalRuntime,
+  createVirtualHalDroState,
+  createVirtualHalIntegrityReport,
+  createVirtualHalLimitsHomeState,
+  createVirtualHalMachineStatusState,
+  createVirtualHalPinRegistry,
+  createVirtualHalSimulationReplacementReport,
+  createVirtualHalSimulationRuntimeReport,
+  createVirtualHalState,
+  createVirtualHalWasmBridgeSnapshot,
+  executeVirtualHalCommand,
+  executeVirtualHalcmd,
+  parseVirtualHalJogIncrement,
+  readVirtualHalPin,
+  stepVirtualHalMotion,
+  stepVirtualHalMotionController,
+  writeVirtualHalPin,
+} from "../../sdk/src/index.js";
 
 const AXES = ["x", "y", "z", "a", "b", "c", "u", "v", "w"];
 const DISPLAY_AXES = ["x", "y", "z", "a", "b", "c"];
@@ -23,7 +49,7 @@ const PLANE_AXIS_MAP = {
   180: ["x", "z", "y"],
   190: ["y", "z", "x"],
 };
-const UNAVAILABLE_VALUE = "n/a";
+const UNAVAILABLE_VALUE = "-";
 const DEFAULT_PREVIEW_LAYER_STATE = Object.freeze({
   traverse: true,
   feed: true,
@@ -178,35 +204,58 @@ export function createModalState(resultText) {
     available: Number.isFinite(fields[field]),
     source: Number.isFinite(fields[field]) ? "linuxcnc-update-tag" : "unavailable",
   }));
+  const axisCodes = [
+    fields.motion === 0 ? "G80" : `G${fields.motion ?? 80}`,
+    ({ 170: "G17", 180: "G18", 190: "G19" })[fields.plane] ?? "G17",
+    "G40",
+    "G20",
+    "G90",
+    "G94",
+    "G54",
+    "G49",
+    "G99",
+    "G64",
+    "G97",
+    "G91.1",
+    "G8",
+    "M5",
+    "M9",
+    "M48",
+    "M53",
+    "M0",
+    `F${Number.isFinite(fields.feed) ? fields.feed : 0}`,
+    `S${Number.isFinite(fields.speed) ? fields.speed : 0}`,
+  ];
   return {
     apiName: "real-browser-simulation-modal-state",
     modalVersion: 1,
     source: activeTag ? "linuxcnc-update-tag" : "unavailable",
     raw: activeTag,
     rows: modalRows,
+    axisCodes,
   };
 }
 
 export function createDroState(frame) {
   const axes = frame?.axes ?? Object.fromEntries(AXES.map((axis) => [axis, 0]));
   const actual = Object.fromEntries(DISPLAY_AXES.map((axis) => [axis, formatAxis(axes[axis])]));
-  const unavailableAxes = Object.fromEntries(DISPLAY_AXES.map((axis) => [axis, UNAVAILABLE_VALUE]));
+  const zeroAxes = Object.fromEntries(DISPLAY_AXES.map((axis) => [axis, formatAxis(0)]));
   return {
     apiName: "real-browser-simulation-dro-state",
     droVersion: 1,
     source: "linuxcnc-canonical-motion",
     actual,
-    distanceToGo: { ...unavailableAxes },
-    workOffsetG54: { ...unavailableAxes },
-    g92Offset: { ...unavailableAxes },
-    toolLengthOffset: { ...unavailableAxes },
-    velocity: UNAVAILABLE_VALUE,
-    unavailable: {
-      distanceToGo: "unavailable from current canonical output",
-      workOffsetG54: "unavailable from current canonical output",
-      g92Offset: "unavailable from current canonical output",
-      toolLengthOffset: "unavailable from current canonical output",
-      velocity: "unavailable from current canonical output",
+    distanceToGo: { ...zeroAxes },
+    workOffsetG54: { ...zeroAxes },
+    g92Offset: { ...zeroAxes },
+    toolLengthOffset: { ...zeroAxes },
+    velocity: formatAxis(0),
+    defaults: {
+      distanceToGo: "zeroed display default until trajectory DTG is available",
+      workOffsetG54: "zeroed display default until coordinate offsets are available",
+      g92Offset: "zeroed display default until coordinate offsets are available",
+      toolLengthOffset: "zeroed display default until tool offsets are available",
+      velocity: "zeroed display default until live velocity is available",
     },
   };
 }
@@ -217,25 +266,25 @@ export function createMachineStatusState(resultText) {
     statusVersion: 1,
     source: "linuxcnc-canonical-events",
     spindle: {
-      direction: UNAVAILABLE_VALUE,
-      speed: UNAVAILABLE_VALUE,
-      state: UNAVAILABLE_VALUE,
+      direction: "stopped",
+      speed: "0",
+      state: "off",
     },
     coolant: {
-      mist: UNAVAILABLE_VALUE,
-      flood: UNAVAILABLE_VALUE,
+      mist: "off",
+      flood: "off",
     },
     tool: {
-      selected: UNAVAILABLE_VALUE,
-      current: UNAVAILABLE_VALUE,
-      pocket: UNAVAILABLE_VALUE,
-      lengthOffset: UNAVAILABLE_VALUE,
+      selected: "0",
+      current: "0",
+      pocket: "0",
+      lengthOffset: "z=0.000",
     },
     overrides: {
-      feed: UNAVAILABLE_VALUE,
-      speed: UNAVAILABLE_VALUE,
-      adaptiveFeed: UNAVAILABLE_VALUE,
-      feedHold: UNAVAILABLE_VALUE,
+      feed: "enabled",
+      speed: "enabled",
+      adaptiveFeed: "disabled",
+      feedHold: "enabled",
     },
   };
   for (const line of String(resultText).split("\n")) {
@@ -250,6 +299,7 @@ export function createMachineStatusState(resultText) {
       status.spindle.state = "on";
     } else if (line.startsWith("canon_event=STOP_SPINDLE_TURNING")) {
       status.spindle.state = "off";
+      status.spindle.direction = "stopped";
     } else if (line.startsWith("canon_event=MIST_ON")) {
       status.coolant.mist = "on";
     } else if (line.startsWith("canon_event=MIST_OFF")) {
@@ -449,8 +499,14 @@ function renderDroState(documentRef, dro) {
     setText(documentRef, `[data-dro-g54="${axis}"]`, dro.workOffsetG54[axis]);
     setText(documentRef, `[data-dro-g92="${axis}"]`, dro.g92Offset[axis]);
     setText(documentRef, `[data-dro-tlo="${axis}"]`, dro.toolLengthOffset[axis]);
+    setText(documentRef, `[data-preview-hud="${axis}"]`, Number(dro.actual[axis]).toFixed(4));
+    setText(documentRef, `[data-preview-hud="dtg-${axis}"]`, Number(dro.distanceToGo[axis]).toFixed(4));
+    setText(documentRef, `[data-preview-hud="g54-${axis}"]`, Number(dro.workOffsetG54[axis]).toFixed(4));
+    setText(documentRef, `[data-preview-hud="g92-${axis}"]`, Number(dro.g92Offset[axis]).toFixed(4));
+    setText(documentRef, `[data-preview-hud="tlo-${axis}"]`, Number(dro.toolLengthOffset[axis]).toFixed(4));
   }
   setText(documentRef, "[data-dro-velocity]", dro.velocity);
+  setText(documentRef, "[data-preview-hud=\"velocity\"]", Number(dro.velocity).toFixed(4));
 }
 
 function renderModalState(documentRef, modal) {
@@ -459,13 +515,20 @@ function renderModalState(documentRef, modal) {
     return;
   }
   container.textContent = "";
-  for (const row of modal.rows) {
+  for (const row of modal.rows ?? []) {
     const item = documentRef.createElement("span");
     item.dataset.modalField = row.id;
     item.dataset.available = row.available ? "true" : "false";
     item.textContent = `${row.label}: ${row.value}`;
     container.append(item);
   }
+  for (const code of modal.axisCodes ?? []) {
+    const item = documentRef.createElement("span");
+    item.dataset.modalCode = code;
+    item.dataset.available = "true";
+    item.textContent = code;
+    container.append(item);
+  }
 }
 
 function renderMachineStatusState(documentRef, machineStatus) {
diff --git a/wasm-port/tests/browser/real_simulation_page_smoke.html b/wasm-port/tests/browser/real_simulation_page_smoke.html
index 0624dc5..3131a5c 100644
--- a/wasm-port/tests/browser/real_simulation_page_smoke.html
+++ b/wasm-port/tests/browser/real_simulation_page_smoke.html
@@ -225,6 +225,26 @@
       if (!api?.getMachineStatusState) {
         throw new Error("simulation API missing AXIS machine status controls");
       }
+      if (
+        !api?.getVirtualHalState ||
+        !api?.applyVirtualHalAction ||
+        !api?.getVirtualHalDroState ||
+        !api?.getVirtualHalLimitsHomeState ||
+        !api?.getVirtualHalMachineStatusState ||
+        !api?.getVirtualHalPinRegistry ||
+        !api?.readVirtualHalPin ||
+        !api?.writeVirtualHalPin ||
+        !api?.applyVirtualHalPinUpdates ||
+        !api?.getVirtualHalIntegrityReport ||
+        !api?.executeVirtualHalcmd ||
+        !api?.executeVirtualHalCommand ||
+        !api?.stepVirtualHalMotionController ||
+        !api?.getVirtualHalSimulationRuntimeReport ||
+        !api?.getVirtualHalSimulationReplacementReport ||
+        !api?.getVirtualRealtimeHalRuntimeReport
+      ) {
+        throw new Error("simulation API missing browser virtual HAL controls");
+      }
       if (!api?.getMachineSessionLoadState || !api?.loadReadyMachineSession) {
         throw new Error("simulation API missing AXIS machine/session load controls");
       }
@@ -278,7 +298,7 @@
         throw new Error(`simulation initial built-in run should populate recent programs: ${JSON.stringify(initialRecentPrograms)}`);
       }
       api.clearRecentPrograms();
-      if (api.getRecentPrograms().length !== 0 || doc.body.dataset.recentProgramCount !== "0" || !doc.querySelector("[data-recent-program-list]")?.textContent.includes("n/a")) {
+      if (api.getRecentPrograms().length !== 0 || doc.body.dataset.recentProgramCount !== "0" || !doc.querySelector("[data-recent-program-list]")?.textContent.includes("No recent programs")) {
         throw new Error(`simulation recent programs clear did not reset API/DOM state: ${JSON.stringify(api.getRecentPrograms())}`);
       }
       if (!doc.querySelector("[data-open-program]") || !doc.querySelector("[data-open-program-file]")) {
@@ -296,8 +316,8 @@
       if (!doc.querySelector('[data-axis-shell="machine-session"]') || !doc.querySelector("[data-check-machine-session]") || !doc.querySelector("[data-load-machine-session]") || !doc.querySelector("[data-use-loaded-session]")) {
         throw new Error("simulation page missing machine/session readiness controls");
       }
-      if (!doc.querySelector("[data-axis-machine-control-state]")?.textContent.includes("not bound")) {
-        throw new Error("simulation page should explicitly mark unbound real-machine controls");
+      if (!doc.querySelector("[data-axis-machine-control-state]")?.textContent.includes("browser virtual HAL active")) {
+        throw new Error("simulation page should explicitly mark browser virtual HAL machine controls");
       }
       if (!doc.querySelector("[data-mdi-program-text]") || !doc.querySelector("[data-load-mdi-program]") || !doc.querySelector("[data-run-mdi-program]") || !doc.querySelector("[data-mdi-history-list]") || !doc.querySelector("[data-clear-mdi-history]")) {
         throw new Error("simulation page missing MDI program text controls");
@@ -319,10 +339,10 @@
       const initialMachineStatus = api.getMachineStatusState();
       if (
         initialMachineStatus?.source !== "linuxcnc-canonical-events" ||
-        initialMachineStatus.spindle.state !== "n/a" ||
-        doc.querySelector('[data-machine-status="spindle-state"]')?.textContent !== "n/a"
+        initialMachineStatus.spindle.state !== "off" ||
+        doc.querySelector('[data-machine-status="spindle-state"]')?.textContent !== "off"
       ) {
-        throw new Error(`simulation initial machine status should expose explicit unavailable state: ${JSON.stringify(initialMachineStatus)}`);
+        throw new Error(`simulation initial machine status should expose AXIS default state: ${JSON.stringify(initialMachineStatus)}`);
       }
       const modalState = api.getModalState();
       if (modalState?.source !== "linuxcnc-update-tag" || !modalState.raw?.includes("canon_event=UPDATE_TAG")) {
@@ -334,7 +354,7 @@
       }
       const diagnosticsState = api.getDiagnosticsState();
       if (
-        diagnosticsState.lastEvent === "n/a" ||
+        diagnosticsState.lastEvent === "pending" ||
         diagnosticsState.lastError !== "none" ||
         !doc.querySelector('[data-diagnostics="last-event"]')?.textContent.includes("canon_event=")
       ) {
@@ -346,18 +366,39 @@
       }
       const limitsHome = api.getLimitsHomeState();
       if (
-        limitsHome.source !== "unavailable" ||
-        limitsHome.axes.x.homed !== "n/a" ||
+        limitsHome.source !== "browser-virtual-hal" ||
+        limitsHome.axes.x.homed !== "no" ||
         doc.querySelector('[data-limits-home-row="x"]')?.children.length !== 5 ||
-        !doc.querySelector("[data-limits-home-summary]")?.textContent.includes("source unavailable")
+        !doc.querySelector("[data-limits-home-summary]")?.textContent.includes("source browser-virtual-hal")
       ) {
-        throw new Error(`simulation limits/home state should remain explicit unavailable: ${JSON.stringify(limitsHome)}`);
+        throw new Error(`simulation limits/home state should expose browser virtual HAL rows: ${JSON.stringify(limitsHome)}`);
+      }
+      const virtualHalInitial = api.getVirtualHalState();
+      if (
+        virtualHalInitial.source !== "browser-virtual-hal" ||
+        virtualHalInitial.component !== "axisui" ||
+        virtualHalInitial.task.state !== "ESTOP" ||
+        !virtualHalInitial.axisuiPins.some(({ name }) => name === "jog.x") ||
+        !virtualHalInitial.axisuiPins.some(({ name }) => name === "jog.increment")
+      ) {
+        throw new Error(`simulation virtual HAL initial state drift: ${JSON.stringify(virtualHalInitial)}`);
+      }
+      const initialVirtualHalRegistry = api.getVirtualHalPinRegistry();
+      if (
+        initialVirtualHalRegistry.apiName !== "linuxcnc-wasm-virtual-hal-pin-registry" ||
+        !initialVirtualHalRegistry.byName["halui.machine.on"]?.writable ||
+        !initialVirtualHalRegistry.byName["motion.tooloffset.z"]?.writable ||
+        !api.getVirtualHalIntegrityReport().complete
+      ) {
+        throw new Error(`simulation virtual HAL registry/integrity drift: ${JSON.stringify(initialVirtualHalRegistry)}`);
       }
       const diagnosticsArtifact = api.exportDiagnosticsArtifact();
       if (
         diagnosticsArtifact.apiName !== "real-browser-simulation-diagnostics-artifact" ||
         diagnosticsArtifact.statusHistory.length === 0 ||
-        diagnosticsArtifact.limitsHome.source !== "unavailable" ||
+        diagnosticsArtifact.virtualHal.source !== "browser-virtual-hal" ||
+        diagnosticsArtifact.virtualHalSimulationReplacement?.ready !== true ||
+        diagnosticsArtifact.limitsHome.source !== "browser-virtual-hal" ||
         diagnosticsArtifact.preview.renderer !== "threejs" ||
         diagnosticsArtifact.toolTable.state !== "not-loaded"
       ) {
@@ -368,12 +409,12 @@
         throw new Error(`simulation DRO source drift: ${JSON.stringify(droState)}`);
       }
       for (const field of ["distanceToGo", "workOffsetG54", "g92Offset", "toolLengthOffset"]) {
-        if (droState[field].x !== "n/a") {
-          throw new Error(`simulation DRO ${field} should remain explicit n/a when unavailable`);
+        if (droState[field].x !== "0.000") {
+          throw new Error(`simulation DRO ${field} should use zeroed AXIS default when unavailable`);
         }
       }
-      if (droState.velocity !== "n/a" || doc.querySelector("[data-dro-velocity]")?.textContent !== "n/a") {
-        throw new Error("simulation DRO velocity should remain explicit n/a when unavailable");
+      if (droState.velocity !== "0.000" || doc.querySelector("[data-dro-velocity]")?.textContent !== "0.000") {
+        throw new Error("simulation DRO velocity should use zeroed AXIS default when unavailable");
       }
       const previewExtents = doc.querySelector("[data-preview-extents]");
       const previewOrigin = doc.querySelector("[data-preview-origin]");
@@ -619,6 +660,83 @@
       if (doc.querySelector('[data-axis-panel="preview"]')?.hidden || doc.body.dataset.lastShortcut !== "F6 Preview") {
         throw new Error("AXIS-style F6 shortcut did not switch to Preview");
       }
+      doc.body.dispatchEvent(new frame.contentWindow.KeyboardEvent("keydown", { key: "F1", bubbles: true, cancelable: true }));
+      if (api.getVirtualHalState().task.state !== "ESTOP_RESET" || doc.body.dataset.virtualHalTaskState !== "ESTOP_RESET" || doc.body.dataset.lastShortcut !== "F1 ESTOP") {
+        throw new Error(`AXIS-style F1 did not reset browser virtual HAL ESTOP: ${JSON.stringify(api.getVirtualHalState())}`);
+      }
+      doc.body.dispatchEvent(new frame.contentWindow.KeyboardEvent("keydown", { key: "F2", bubbles: true, cancelable: true }));
+      if (api.getVirtualHalState().task.state !== "ON" || doc.body.dataset.virtualHalTaskState !== "ON" || doc.body.dataset.lastShortcut !== "F2 Power") {
+        throw new Error(`AXIS-style F2 did not power browser virtual HAL machine: ${JSON.stringify(api.getVirtualHalState())}`);
+      }
+      doc.body.dispatchEvent(new frame.contentWindow.KeyboardEvent("keydown", { key: "Home", ctrlKey: true, bubbles: true, cancelable: true }));
+      if (api.getVirtualHalLimitsHomeState().axes.x.homed !== "yes" || doc.body.dataset.lastShortcut !== "Ctrl-Home Home All") {
+        throw new Error(`AXIS-style Ctrl-Home did not home browser virtual HAL axes: ${JSON.stringify(api.getVirtualHalLimitsHomeState())}`);
+      }
+      doc.querySelector('[data-jog-increment]').value = "0.01 in";
+      doc.querySelector('[data-axis-jog="+"]')?.click();
+      if (api.getVirtualHalState().pins["jog.x"] !== true || api.getVirtualHalDroState().actual.x !== "0.010" || doc.querySelector('[data-dro-actual="x"]')?.textContent !== "0.010") {
+        throw new Error(`AXIS-style jog did not update browser virtual HAL DRO/pins: ${JSON.stringify(api.getVirtualHalState())}`);
+      }
+      doc.querySelector('[data-axis-spindle="cw"]')?.click();
+      doc.querySelector('[data-axis-coolant="flood"]').checked = true;
+      doc.querySelector('[data-axis-coolant="flood"]').dispatchEvent(new frame.contentWindow.Event("change", { bubbles: true }));
+      const virtualMachineStatus = api.getVirtualHalMachineStatusState();
+      if (
+        virtualMachineStatus.spindle.state !== "on" ||
+        virtualMachineStatus.spindle.direction !== "cw" ||
+        virtualMachineStatus.coolant.flood !== "on" ||
+        doc.querySelector('[data-axis-spindle-status]')?.dataset.state !== "ready" ||
+        doc.querySelector('[data-axis-coolant-status]')?.dataset.state !== "ready"
+      ) {
+        throw new Error(`AXIS-style spindle/coolant did not update browser virtual HAL machine status: ${JSON.stringify(virtualMachineStatus)}`);
+      }
+      api.writeVirtualHalPin({ name: "spindle.0.speed-out", type: "HAL_FLOAT", value: 1500 });
+      api.applyVirtualHalPinUpdates([
+        { name: "motion.tooloffset.z", type: "HAL_FLOAT", value: 1.5 },
+        { name: "halui.tool.number", type: "HAL_U32", value: 8 },
+      ]);
+      if (
+        api.readVirtualHalPin("spindle.0.speed-out")?.value !== 1500 ||
+        api.readVirtualHalPin("motion.tooloffset.z")?.value !== 1.5 ||
+        api.readVirtualHalPin("halui.tool.number")?.value !== 8 ||
+        api.getVirtualHalIntegrityReport().complete !== true
+      ) {
+        throw new Error(`AXIS-style virtual HAL pin service did not update/read pins: ${JSON.stringify(api.getVirtualHalPinRegistry())}`);
+      }
+      const virtualHalcmdResult = api.executeVirtualHalcmd("loadrt trivkins\naddf motion-controller servo-thread\nsetp axis.x.pos-cmd 1.75\nshow pin axis.x.*");
+      if (
+        virtualHalcmdResult.apiName !== "linuxcnc-wasm-virtual-halcmd-result" ||
+        virtualHalcmdResult.ok !== true ||
+        !virtualHalcmdResult.output.includes("axis.x.pos-cmd") ||
+        api.readVirtualHalPin("axis.x.pos-cmd")?.value !== 1.75
+      ) {
+        throw new Error(`AXIS-style virtual halcmd did not execute: ${JSON.stringify(virtualHalcmdResult)}`);
+      }
+      const motionControllerStep = api.stepVirtualHalMotionController({
+        target: { x: 2.25 },
+        maxVelocity: 10,
+        dt: 0.1,
+        cycleCount: 2,
+      });
+      if (
+        motionControllerStep.apiName !== "linuxcnc-wasm-virtual-motion-controller-step" ||
+        motionControllerStep.ok !== true ||
+        motionControllerStep.state.position.x <= 1.75
+      ) {
+        throw new Error(`AXIS-style virtual motion controller did not step: ${JSON.stringify(motionControllerStep)}`);
+      }
+      const virtualHalReplacement = api.getVirtualHalSimulationReplacementReport();
+      if (
+        virtualHalReplacement.apiName !== "linuxcnc-wasm-virtual-hal-simulation-replacement-report" ||
+        virtualHalReplacement.ready !== true ||
+        virtualHalReplacement.replacements["linuxcnc-realtime-hal"].ready !== true ||
+        virtualHalReplacement.replacements.halcmd.ready !== true ||
+        virtualHalReplacement.replacements["motion-controller"].ready !== true ||
+        api.getVirtualRealtimeHalRuntimeReport().ready !== true ||
+        api.getVirtualHalSimulationRuntimeReport().replacesHostRuntimeForSimulation !== true
+      ) {
+        throw new Error(`AXIS-style virtual HAL simulation replacement report drift: ${JSON.stringify(virtualHalReplacement)}`);
+      }
       const urlView = api.applyAxisViewFromUrl("?axis_left=mdi&axis_right=dro");
       if (
         urlView.left !== "mdi" ||
@@ -899,7 +1017,7 @@
         throw new Error("MDI history item did not restore text into the MDI pane");
       }
       api.clearMdiHistory();
-      if (api.getMdiHistory().length !== 0 || doc.body.dataset.mdiHistoryCount !== "0" || !doc.querySelector("[data-mdi-history-list]")?.textContent.includes("n/a")) {
+      if (api.getMdiHistory().length !== 0 || doc.body.dataset.mdiHistoryCount !== "0" || !doc.querySelector("[data-mdi-history-list]")?.textContent.includes("No MDI history")) {
         throw new Error(`MDI history clear did not reset API/DOM state: ${JSON.stringify(api.getMdiHistory())}`);
       }
 
@@ -1080,7 +1198,7 @@ TOOL_TABLE = tool.tbl
       if (
         loadedDiagnosticsArtifact.toolTable.state !== "loaded" ||
         loadedDiagnosticsArtifact.toolTable.rows.length !== 1 ||
-        loadedDiagnosticsArtifact.limitsHome.axes.x.fault !== "n/a" ||
+        loadedDiagnosticsArtifact.limitsHome.axes.x.fault !== "none" ||
         !loadedDiagnosticsArtifact.statusHistory.some(({ kind }) => kind === "session")
       ) {
         throw new Error(`simulation diagnostics artifact did not include session/tool/limits state: ${JSON.stringify(loadedDiagnosticsArtifact)}`);
@@ -1157,7 +1275,7 @@ TOOL_TABLE = tool.tbl
       if (api.getRunMode().mode !== "standalone" || doc.body.dataset.runMode !== "standalone") {
         throw new Error("simulation run mode should stay standalone after disabled-session run");
       }
-      if (api.getRunSummary().executionMode !== "linuxcnc-wasm" || doc.querySelector('[data-run-summary="session-ini"]')?.textContent !== "n/a") {
+      if (api.getRunSummary().executionMode !== "linuxcnc-wasm" || doc.querySelector('[data-run-summary="session-ini"]')?.textContent !== "-") {
         throw new Error(`simulation run summary should return to standalone details: ${JSON.stringify(api.getRunSummary())}`);
       }
       if (api.getRunControlState().reason !== "Loaded machine session bypassed by Use Session toggle") {
diff --git a/wasm-port/tests/docs/node/verify_project_release_handoff_docs.mjs b/wasm-port/tests/docs/node/verify_project_release_handoff_docs.mjs
index e504069..5fef964 100644
--- a/wasm-port/tests/docs/node/verify_project_release_handoff_docs.mjs
+++ b/wasm-port/tests/docs/node/verify_project_release_handoff_docs.mjs
@@ -126,6 +126,19 @@ for (const phrase of [
   "browser_release_artifact_url_workflow_smoke=ok",
   "browser_real_simulation_page_smoke=ok",
   "project_release_handoff_docs_node_smoke=ok",
+  "Project-level virtual HAL",
+  "createVirtualHalState()",
+  "applyVirtualHalAction()",
+  "createLinuxCncVirtualHalRuntime()",
+  "createVirtualHalWasmBridgeSnapshot()",
+  "createVirtualHalPinInventory()",
+  "createVirtualHalBridgeReadiness()",
+  "createVirtualHalBridgeActionPlan()",
+  "createVirtualHalProjectReport()",
+  "applyVirtualHalToInterpSdk()",
+  "VIRTUAL_HAL_WASM_BRIDGE_FUNCTIONS",
+  "VIRTUAL_HAL_PROJECT_PIN_GROUPS",
+  "realtime HAL runtime",
   "L4-USER-M-PROCESS",
   "L4-TOOL-DB",
   "L4-PYTHON-REMAP",
@@ -176,6 +189,19 @@ for (const phrase of [
 
 for (const phrase of [
   "OPFS/session persistence exports",
+  "Project-level virtual HAL boundary",
+  "createVirtualHalState()",
+  "applyVirtualHalAction()",
+  "createLinuxCncVirtualHalRuntime()",
+  "createVirtualHalWasmBridgeSnapshot()",
+  "createVirtualHalPinInventory()",
+  "createVirtualHalBridgeReadiness()",
+  "createVirtualHalBridgeActionPlan()",
+  "createVirtualHalProjectReport()",
+  "applyVirtualHalToInterpSdk()",
+  "VIRTUAL_HAL_WASM_BRIDGE_FUNCTIONS",
+  "VIRTUAL_HAL_PROJECT_PIN_GROUPS",
+  "realtime HAL runtime",
   "Project release readiness export",
   "createProjectReleaseGateManifest()",
   "createProjectReleaseGateResultMatrix()",
diff --git a/wasm-port/tests/sdk/node/verify_sdk_surface.mjs b/wasm-port/tests/sdk/node/verify_sdk_surface.mjs
index b1a3762..5df8ce3 100644
--- a/wasm-port/tests/sdk/node/verify_sdk_surface.mjs
+++ b/wasm-port/tests/sdk/node/verify_sdk_surface.mjs
@@ -32,8 +32,21 @@ import {
   createIniPanelShellWorkflowOverviewReleaseReadinessArtifactUrlWorkflowSummaryViewModel,
   createIniPanelShellWorkflowOverviewReleaseReadinessArtifactValidationActionPlan,
   createIniPanelShellWorkflowOverviewReleaseReadinessArtifactValidationSummaryViewModel,
+  VIRTUAL_HAL_COVERAGE_STATES,
+  VIRTUAL_HAL_PROJECT_PIN_GROUPS,
+  VIRTUAL_HAL_SIMULATION_REPLACEMENT_TARGETS,
+  VIRTUAL_HAL_SIMULATION_RUNTIME_CAPABILITIES,
+  VIRTUAL_HAL_SOURCE_FILES,
+  VIRTUAL_HAL_SYSTEM_PIN_FAMILIES,
+  VIRTUAL_HAL_WASM_BRIDGE_FUNCTIONS,
+  applyVirtualHalAction,
+  applyVirtualHalPinUpdates,
+  applyVirtualHalToInterpSdk,
+  createVirtualHalSimulationRuntimeReport,
   createLinuxCncIniSdk,
   createLinuxCncInterpSdk,
+  createLinuxCncVirtualHalRuntime,
+  createVirtualHalIntegrityReport,
   createMachineSessionSnapshotPayload,
   createMachineSessionPersistenceDisplayViewModel,
   createMachineSessionPersistenceRenderState,
@@ -63,6 +76,21 @@ import {
   createProjectReleaseReadinessArtifactValidationSummaryViewModel,
   createProjectReleaseReadinessReport,
   createProjectReleaseReadinessSummaryViewModel,
+  createVirtualHalBridgeActionPlan,
+  createVirtualHalBridgeReadiness,
+  createVirtualHalPinInventory,
+  createVirtualHalPinRegistry,
+  createVirtualHalProjectReport,
+  createVirtualHalSimulationReplacementReport,
+  createVirtualHalState,
+  createVirtualHalSystemCoverageReport,
+  createVirtualHalWasmBridgeSnapshot,
+  executeVirtualHalCommand,
+  executeVirtualHalcmd,
+  readVirtualHalPin,
+  stepVirtualHalMotionController,
+  stepVirtualHalMotion,
+  writeVirtualHalPin,
   parseProjectReleaseReadinessArtifactJson,
   createSessionSnapshot,
   defaultMachinePaths,
@@ -186,6 +214,27 @@ const requiredExports = [
   ],
   ["createProjectReleaseReadinessReport", createProjectReleaseReadinessReport],
   ["createProjectReleaseReadinessSummaryViewModel", createProjectReleaseReadinessSummaryViewModel],
+  ["applyVirtualHalAction", applyVirtualHalAction],
+  ["applyVirtualHalPinUpdates", applyVirtualHalPinUpdates],
+  ["applyVirtualHalToInterpSdk", applyVirtualHalToInterpSdk],
+  ["createLinuxCncVirtualHalRuntime", createLinuxCncVirtualHalRuntime],
+  ["createVirtualHalBridgeActionPlan", createVirtualHalBridgeActionPlan],
+  ["createVirtualHalBridgeReadiness", createVirtualHalBridgeReadiness],
+  ["createVirtualHalIntegrityReport", createVirtualHalIntegrityReport],
+  ["createVirtualHalPinInventory", createVirtualHalPinInventory],
+  ["createVirtualHalPinRegistry", createVirtualHalPinRegistry],
+  ["createVirtualHalProjectReport", createVirtualHalProjectReport],
+  ["createVirtualHalSimulationReplacementReport", createVirtualHalSimulationReplacementReport],
+  ["createVirtualHalSimulationRuntimeReport", createVirtualHalSimulationRuntimeReport],
+  ["createVirtualHalState", createVirtualHalState],
+  ["createVirtualHalSystemCoverageReport", createVirtualHalSystemCoverageReport],
+  ["createVirtualHalWasmBridgeSnapshot", createVirtualHalWasmBridgeSnapshot],
+  ["executeVirtualHalCommand", executeVirtualHalCommand],
+  ["executeVirtualHalcmd", executeVirtualHalcmd],
+  ["readVirtualHalPin", readVirtualHalPin],
+  ["stepVirtualHalMotionController", stepVirtualHalMotionController],
+  ["stepVirtualHalMotion", stepVirtualHalMotion],
+  ["writeVirtualHalPin", writeVirtualHalPin],
   ["parseProjectReleaseReadinessArtifactJson", parseProjectReleaseReadinessArtifactJson],
   [
     "validateIniPanelShellWorkflowOverviewReleaseReadinessArtifactJson",
@@ -411,6 +460,202 @@ for (const [name, value] of requiredExports) {
   assert.match(sdkReadmeText, new RegExp(`\\b${name}\\b`));
 }
 
+assert.equal(VIRTUAL_HAL_WASM_BRIDGE_FUNCTIONS.includes("lcinterp_hal_set_value"), true);
+assert.equal(VIRTUAL_HAL_PROJECT_PIN_GROUPS.some(({ id }) => id === "axisui"), true);
+assert.equal(VIRTUAL_HAL_SIMULATION_RUNTIME_CAPABILITIES.includes("halcmd-setp-sets-net-show-getp-gets"), true);
+assert.equal(VIRTUAL_HAL_SIMULATION_RUNTIME_CAPABILITIES.includes("realtime-hal-simulation-replacement"), true);
+assert.equal(VIRTUAL_HAL_SIMULATION_RUNTIME_CAPABILITIES.includes("motion-controller-simulation-replacement"), true);
+assert.equal(VIRTUAL_HAL_SIMULATION_REPLACEMENT_TARGETS.includes("linuxcnc-realtime-hal"), true);
+assert.equal(VIRTUAL_HAL_SIMULATION_REPLACEMENT_TARGETS.includes("halcmd"), true);
+assert.equal(VIRTUAL_HAL_SIMULATION_REPLACEMENT_TARGETS.includes("motion-controller"), true);
+assert.equal(VIRTUAL_HAL_COVERAGE_STATES.runtimeBoundary, "runtime-boundary");
+assert.equal(VIRTUAL_HAL_SOURCE_FILES.halui, "linuxcnc/src/emc/usr_intf/halui.cc");
+assert.equal(VIRTUAL_HAL_SYSTEM_PIN_FAMILIES.some(({ id }) => id === "iocontrol"), true);
+assert.equal(VIRTUAL_HAL_SYSTEM_PIN_FAMILIES.some(({ id }) => id === "motion-core"), true);
+assert.match(sdkIndexText, /\bVIRTUAL_HAL_WASM_BRIDGE_FUNCTIONS\b/);
+assert.match(sdkReadmeText, /\bVIRTUAL_HAL_WASM_BRIDGE_FUNCTIONS\b/);
+assert.match(sdkIndexText, /\bVIRTUAL_HAL_PROJECT_PIN_GROUPS\b/);
+assert.match(sdkReadmeText, /\bVIRTUAL_HAL_PROJECT_PIN_GROUPS\b/);
+assert.match(sdkIndexText, /\bVIRTUAL_HAL_SIMULATION_RUNTIME_CAPABILITIES\b/);
+assert.match(sdkReadmeText, /\bVIRTUAL_HAL_SIMULATION_RUNTIME_CAPABILITIES\b/);
+assert.match(sdkIndexText, /\bVIRTUAL_HAL_SIMULATION_REPLACEMENT_TARGETS\b/);
+assert.match(sdkReadmeText, /\bVIRTUAL_HAL_SIMULATION_REPLACEMENT_TARGETS\b/);
+assert.match(sdkIndexText, /\bVIRTUAL_HAL_SYSTEM_PIN_FAMILIES\b/);
+assert.match(sdkReadmeText, /\bVIRTUAL_HAL_SYSTEM_PIN_FAMILIES\b/);
+assert.match(sdkIndexText, /\bexecuteVirtualHalCommand\b/);
+assert.match(sdkReadmeText, /\bexecuteVirtualHalCommand\b/);
+assert.match(sdkIndexText, /\bexecuteVirtualHalcmd\b/);
+assert.match(sdkReadmeText, /\bexecuteVirtualHalcmd\b/);
+assert.match(sdkIndexText, /\bstepVirtualHalMotion\b/);
+assert.match(sdkReadmeText, /\bstepVirtualHalMotion\b/);
+assert.match(sdkIndexText, /\bstepVirtualHalMotionController\b/);
+assert.match(sdkReadmeText, /\bstepVirtualHalMotionController\b/);
+assert.match(sdkIndexText, /\bcreateVirtualHalSimulationRuntimeReport\b/);
+assert.match(sdkReadmeText, /\bcreateVirtualHalSimulationRuntimeReport\b/);
+assert.match(sdkIndexText, /\bcreateVirtualHalSimulationReplacementReport\b/);
+assert.match(sdkReadmeText, /\bcreateVirtualHalSimulationReplacementReport\b/);
+assert.match(sdkIndexText, /\bcreateVirtualHalSystemCoverageReport\b/);
+assert.match(sdkReadmeText, /\bcreateVirtualHalSystemCoverageReport\b/);
+assert.match(sdkIndexText, /\bcreateVirtualHalPinRegistry\b/);
+assert.match(sdkReadmeText, /\bcreateVirtualHalPinRegistry\b/);
+assert.match(sdkIndexText, /\bcreateVirtualHalIntegrityReport\b/);
+assert.match(sdkReadmeText, /\bcreateVirtualHalIntegrityReport\b/);
+assert.match(sdkIndexText, /\breadVirtualHalPin\b/);
+assert.match(sdkReadmeText, /\breadVirtualHalPin\b/);
+assert.match(sdkIndexText, /\bwriteVirtualHalPin\b/);
+assert.match(sdkReadmeText, /\bwriteVirtualHalPin\b/);
+
+let sdkVirtualHal = createVirtualHalState();
+sdkVirtualHal = applyVirtualHalAction(sdkVirtualHal, "estop");
+sdkVirtualHal = applyVirtualHalAction(sdkVirtualHal, "power");
+sdkVirtualHal = applyVirtualHalAction(sdkVirtualHal, "jog", { axis: "x", increment: "0.01 in", direction: 1 });
+sdkVirtualHal = writeVirtualHalPin(sdkVirtualHal, { name: "spindle.0.speed-out", type: "HAL_FLOAT", value: 1800 });
+sdkVirtualHal = writeVirtualHalPin(sdkVirtualHal, { name: "motion.tooloffset.z", type: "HAL_FLOAT", value: 2.5 });
+sdkVirtualHal = applyVirtualHalPinUpdates(sdkVirtualHal, [
+  { name: "halui.tool.number", type: "HAL_U32", value: 7 },
+  { name: "halui.feed-override.value", type: "HAL_FLOAT", value: 0.8 },
+]);
+assert.equal(readVirtualHalPin(sdkVirtualHal, "spindle.0.speed-out").value, 1800);
+assert.equal(readVirtualHalPin(sdkVirtualHal, "motion.tooloffset.z").value, 2.5);
+assert.equal(readVirtualHalPin(sdkVirtualHal, "halui.tool.number").value, 7);
+assert.equal(sdkVirtualHal.overrides.feed, 80);
+const virtualHalSnapshot = createVirtualHalWasmBridgeSnapshot(sdkVirtualHal);
+assert.equal(virtualHalSnapshot.apiName, "linuxcnc-wasm-virtual-hal-bridge-snapshot");
+assert.ok(virtualHalSnapshot.values.some(({ name }) => name === "axisui.jog.x"));
+assert.ok(virtualHalSnapshot.values.some(({ name, value }) => name === "spindle.0.speed-out" && value === 1800));
+assert.ok(virtualHalSnapshot.values.some(({ name, value }) => name === "motion.tooloffset.z" && value === 2.5));
+const virtualHalRegistry = createVirtualHalPinRegistry(sdkVirtualHal);
+assert.equal(virtualHalRegistry.apiName, "linuxcnc-wasm-virtual-hal-pin-registry");
+assert.equal(virtualHalRegistry.byName["spindle.0.speed-out"].value, 1800);
+assert.equal(virtualHalRegistry.byName["motion.tooloffset.z"].value, 2.5);
+assert.equal(virtualHalRegistry.byName["halui.tool.number"].value, 7);
+assert.equal(virtualHalRegistry.rows.some(({ name, writable }) => name === "halui.machine.on" && writable === true), true);
+const virtualHalIntegrity = createVirtualHalIntegrityReport({ halState: sdkVirtualHal, registry: virtualHalRegistry });
+assert.equal(virtualHalIntegrity.apiName, "linuxcnc-wasm-virtual-hal-integrity-report");
+assert.equal(virtualHalIntegrity.complete, true);
+assert.equal(virtualHalIntegrity.missingPins.length, 0);
+const virtualHalInventory = createVirtualHalPinInventory(sdkVirtualHal);
+assert.equal(virtualHalInventory.apiName, "linuxcnc-wasm-virtual-hal-pin-inventory");
+assert.equal(virtualHalInventory.groups.some(({ id, pinCount }) => id === "axisui" && pinCount > 0), true);
+assert.equal(virtualHalInventory.groups.some(({ id, pinCount }) => id === "axis-motion" && pinCount > 0), true);
+assert.equal(virtualHalInventory.groups.some(({ id, pinCount }) => id === "tool" && pinCount > 0), true);
+const virtualHalSystemCoverage = createVirtualHalSystemCoverageReport({ snapshot: virtualHalSnapshot });
+assert.equal(virtualHalSystemCoverage.apiName, "linuxcnc-wasm-virtual-hal-system-coverage-report");
+assert.equal(virtualHalSystemCoverage.complete, true);
+assert.equal(virtualHalSystemCoverage.realtimeHalRuntime, false);
+assert.equal(virtualHalSystemCoverage.sourceFiles.includes("linuxcnc/bin/axis"), true);
+assert.equal(virtualHalSystemCoverage.sourceFiles.includes("linuxcnc/src/emc/usr_intf/halui.cc"), true);
+assert.equal(virtualHalSystemCoverage.sourceFiles.includes("linuxcnc/src/emc/task/taskclass.cc"), true);
+assert.equal(virtualHalSystemCoverage.sourceFiles.includes("linuxcnc/src/emc/motion/motion.c"), true);
+assert.equal(virtualHalSystemCoverage.families.some(({ id, coverage }) => id === "motion-core" && coverage === "runtime-boundary"), true);
+assert.equal(virtualHalSystemCoverage.boundaryRows.some(({ id }) => id === "halui-task"), true);
+const virtualHalBlockedReadiness = createVirtualHalBridgeReadiness({ snapshot: virtualHalSnapshot });
+assert.equal(virtualHalBlockedReadiness.ready, false);
+assert.equal(virtualHalBlockedReadiness.missing.includes("wasm-function-evidence"), true);
+const virtualHalReadyReadiness = createVirtualHalBridgeReadiness({
+  snapshot: virtualHalSnapshot,
+  availableFunctions: VIRTUAL_HAL_WASM_BRIDGE_FUNCTIONS,
+});
+assert.equal(virtualHalReadyReadiness.ready, true);
+assert.equal(createVirtualHalBridgeActionPlan(virtualHalReadyReadiness).nextCommand, null);
+const virtualHalReport = createVirtualHalProjectReport({
+  halState: sdkVirtualHal,
+  availableFunctions: VIRTUAL_HAL_WASM_BRIDGE_FUNCTIONS,
+});
+assert.equal(virtualHalReport.apiName, "linuxcnc-wasm-virtual-hal-project-report");
+assert.equal(virtualHalReport.ready, true);
+assert.equal(virtualHalReport.pinInventory.pinCount, virtualHalReport.wasmBridgeSnapshot.values.length);
+assert.equal(virtualHalReport.systemCoverage.phase, "covered-with-runtime-boundaries");
+assert.equal(virtualHalReport.systemCoverage.unclassifiedSnapshotPins.length, 0);
+assert.equal(virtualHalReport.pinRegistry.byName["spindle.0.speed-out"].value, 1800);
+assert.equal(virtualHalReport.integrity.complete, true);
+const virtualHalRuntime = createLinuxCncVirtualHalRuntime(sdkVirtualHal);
+assert.equal(virtualHalRuntime.getProjectReport({ availableFunctions: VIRTUAL_HAL_WASM_BRIDGE_FUNCTIONS }).ready, true);
+const virtualHalcmdResult = virtualHalRuntime.executeHalCommand(`
+loadrt trivkins
+addf motion-controller servo-thread
+net x-pos axis.x.pos-cmd joint.0.pos-fb
+setp axis.x.pos-cmd 2.5
+sets x-pos 1.25
+show pin axis.x.*
+motion-step x=2.0
+`);
+assert.equal(virtualHalcmdResult.apiName, "linuxcnc-wasm-virtual-halcmd-result");
+assert.equal(virtualHalcmdResult.ok, true);
+assert.equal(virtualHalcmdResult.rows.some(({ action }) => action === "net"), true);
+assert.equal(virtualHalRuntime.getState().hal.signals["x-pos"].value, 1.25);
+assert.equal(virtualHalRuntime.getState().hal.nets["x-pos"].includes("axis.x.pos-cmd"), true);
+assert.equal(virtualHalRuntime.getState().hal.loadedComponents.some(({ component }) => component === "trivkins"), true);
+assert.equal(virtualHalRuntime.getState().hal.functions.some(({ name }) => name === "motion-controller"), true);
+assert.ok(virtualHalRuntime.getState().position.x > 1.25);
+const directHalcmdResult = executeVirtualHalCommand(virtualHalRuntime.getState(), "getp axis.x.pos-cmd\ngets x-pos");
+assert.equal(directHalcmdResult.ok, true);
+assert.match(directHalcmdResult.output, /axis\.x\.pos-cmd/);
+assert.match(directHalcmdResult.output, /x-pos/);
+const directHalcmdAliasResult = executeVirtualHalcmd(virtualHalRuntime.getState(), "setp halui.machine.on 1\nshow pin halui.machine.*");
+assert.equal(directHalcmdAliasResult.ok, true);
+assert.equal(directHalcmdAliasResult.apiName, "linuxcnc-wasm-virtual-halcmd-result");
+assert.match(directHalcmdAliasResult.output, /halui\.machine\.is-on/);
+const steppedVirtualHal = stepVirtualHalMotion(virtualHalRuntime.getState(), {
+  target: { x: 3 },
+  maxVelocity: 10,
+  dt: 0.1,
+});
+assert.ok(steppedVirtualHal.position.x > virtualHalRuntime.getState().position.x);
+const motionControllerStep = stepVirtualHalMotionController(virtualHalRuntime.getState(), {
+  target: { x: 4 },
+  maxVelocity: 10,
+  dt: 0.1,
+  cycleCount: 3,
+});
+assert.equal(motionControllerStep.apiName, "linuxcnc-wasm-virtual-motion-controller-step");
+assert.equal(motionControllerStep.ok, true);
+assert.ok(motionControllerStep.cycleCount >= 1);
+assert.ok(motionControllerStep.state.position.x > virtualHalRuntime.getState().position.x);
+const simulationRuntimeReport = virtualHalRuntime.getSimulationRuntimeReport();
+assert.equal(simulationRuntimeReport.apiName, "linuxcnc-wasm-virtual-hal-simulation-runtime-report");
+assert.equal(simulationRuntimeReport.replacesHostRuntimeForSimulation, true);
+assert.deepEqual(simulationRuntimeReport.replacementTargets, VIRTUAL_HAL_SIMULATION_REPLACEMENT_TARGETS);
+assert.equal(simulationRuntimeReport.hardRealtime, false);
+assert.deepEqual(simulationRuntimeReport.hostRequirements, []);
+assert.equal(simulationRuntimeReport.capabilities.includes("servo-period-motion-step"), true);
+assert.equal(createVirtualHalSimulationRuntimeReport(virtualHalRuntime.getState()).ready, true);
+const runtimeMotionControllerStep = virtualHalRuntime.stepMotionController({
+  target: { x: 4.5 },
+  maxVelocity: 20,
+  dt: 0.1,
+  cycleCount: 2,
+});
+assert.equal(runtimeMotionControllerStep.apiName, "linuxcnc-wasm-virtual-motion-controller-step");
+assert.ok(virtualHalRuntime.getState().position.x > motionControllerStep.state.position.x);
+const replacementReport = createVirtualHalSimulationReplacementReport(virtualHalRuntime.getState());
+assert.equal(replacementReport.apiName, "linuxcnc-wasm-virtual-hal-simulation-replacement-report");
+assert.equal(replacementReport.ready, true);
+assert.equal(replacementReport.replacesHostRuntimeForSimulation, true);
+assert.equal(replacementReport.replacements["linuxcnc-realtime-hal"].ready, true);
+assert.equal(replacementReport.replacements.halcmd.ready, true);
+assert.equal(replacementReport.replacements["motion-controller"].ready, true);
+assert.equal(replacementReport.hardRealtime, false);
+assert.equal(virtualHalRuntime.getSimulationReplacementReport().ready, true);
+const runtimeProjectReport = virtualHalRuntime.getProjectReport({ availableFunctions: VIRTUAL_HAL_WASM_BRIDGE_FUNCTIONS });
+assert.equal(runtimeProjectReport.simulationRuntime.replacesHostRuntimeForSimulation, true);
+assert.equal(runtimeProjectReport.systemCoverage.unclassifiedSnapshotPins.length, 0);
+const fakeInterpApplyResult = applyVirtualHalToInterpSdk(
+  {
+    applyVirtualHalSnapshot(snapshot, options) {
+      return {
+        apiName: "fake-virtual-hal-apply-result",
+        applied: snapshot.values.length,
+        reset: options.reset !== false,
+      };
+    },
+  },
+  sdkVirtualHal,
+  { reset: false },
+);
+assert.equal(fakeInterpApplyResult.apiName, "fake-virtual-hal-apply-result");
+assert.equal(fakeInterpApplyResult.reset, false);
+
 assert.equal(machineIniPath("sdk-mill"), "linuxcnc/machines/sdk-mill/machine.ini");
 assert.deepEqual(defaultMachinePaths("sdk-mill"), machineFilePaths("sdk-mill"));
 assert.equal(gcodeProgramPath("demo.ngc"), "linuxcnc/gcode/demo.ngc");
diff --git a/wasm-port/tests/ui/node/verify_real_simulation_programs.mjs b/wasm-port/tests/ui/node/verify_real_simulation_programs.mjs
index 8c39220..5fefcd5 100644
--- a/wasm-port/tests/ui/node/verify_real_simulation_programs.mjs
+++ b/wasm-port/tests/ui/node/verify_real_simulation_programs.mjs
@@ -21,6 +21,23 @@ import {
   runRealBrowserSimulation,
   zoomToolpathViewBox,
 } from "../../../runtime/ui/simulation/simulation-app.js";
+import {
+  VIRTUAL_HAL_AXISUI_PINS,
+  applyVirtualHalAction,
+  applyVirtualHalPinUpdates,
+  createLinuxCncInterpSdk,
+  createLinuxCncVirtualHalRuntime,
+  createVirtualHalDroState,
+  createVirtualHalIntegrityReport,
+  createVirtualHalLimitsHomeState,
+  createVirtualHalMachineStatusState,
+  createVirtualHalPinRegistry,
+  createVirtualHalState,
+  createVirtualHalWasmBridgeSnapshot,
+  parseVirtualHalJogIncrement,
+  readVirtualHalPin,
+  writeVirtualHalPin,
+} from "../../../runtime/sdk/src/index.js";
 import {
   SIMULATION_TEST_PROGRAMS as directoryPrograms,
 } from "../../../runtime/ui/simulation/programs/index.js";
@@ -56,6 +73,62 @@ const ids = new Set(programs.map(({ id }) => id));
 assert.equal(ids.size, programs.length, "program ids should be unique");
 assert.ok(ids.has("arc-g2-g3"), "program inventory should include an arc fixture");
 assert.ok(ids.has("drill-g81"), "program inventory should include a canned-cycle fixture");
+assert.equal(VIRTUAL_HAL_AXISUI_PINS.component, "axisui");
+assert.ok(VIRTUAL_HAL_AXISUI_PINS.pins.some(({ name }) => name === "jog.x"), "virtual HAL should mirror AXIS axisui jog pins");
+assert.ok(VIRTUAL_HAL_AXISUI_PINS.pins.some(({ name }) => name === "jog.increment"), "virtual HAL should expose AXIS jog increment pin");
+assert.equal(parseVirtualHalJogIncrement("Continuous"), 0);
+assert.equal(parseVirtualHalJogIncrement("0.01 in"), 0.01);
+assert.equal(Number(parseVirtualHalJogIncrement("1 mm").toFixed(6)), 0.03937);
+
+let virtualHal = createVirtualHalState();
+assert.equal(virtualHal.task.state, "ESTOP");
+virtualHal = applyVirtualHalAction(virtualHal, "estop");
+assert.equal(virtualHal.task.state, "ESTOP_RESET");
+virtualHal = applyVirtualHalAction(virtualHal, "power");
+assert.equal(virtualHal.task.state, "ON");
+virtualHal = applyVirtualHalAction(virtualHal, "home-all");
+assert.equal(createVirtualHalLimitsHomeState(virtualHal).axes.x.homed, "yes");
+virtualHal = applyVirtualHalAction(virtualHal, "jog", { axis: "x", increment: "0.01 in", direction: 1 });
+assert.equal(virtualHal.pins["jog.x"], true);
+assert.equal(virtualHal.pins["jog.increment"], 0.01);
+assert.equal(createVirtualHalDroState(virtualHal).actual.x, "0.010");
+const jogSnapshot = createVirtualHalWasmBridgeSnapshot(virtualHal);
+assert.ok(jogSnapshot.values.some(({ name, type, value }) => name === "jog.x" && type === "HAL_BIT" && value === 1));
+assert.ok(jogSnapshot.values.some(({ name, type, value }) => name === "axisui.jog.x" && type === "HAL_BIT" && value === 1));
+assert.ok(jogSnapshot.values.some(({ name, type, value }) => name === "jog.increment" && type === "HAL_FLOAT" && value === 0.01));
+assert.ok(jogSnapshot.values.some(({ name, type, value }) => name === "axisui.jog.increment" && type === "HAL_FLOAT" && value === 0.01));
+virtualHal = applyVirtualHalAction(virtualHal, "spindle", { command: "cw", speed: 1200 });
+virtualHal = applyVirtualHalAction(virtualHal, "coolant", { name: "flood", enabled: true });
+virtualHal = writeVirtualHalPin(virtualHal, { name: "motion.tooloffset.z", type: "HAL_FLOAT", value: 1.25 });
+virtualHal = applyVirtualHalPinUpdates(virtualHal, [
+  { name: "halui.tool.number", type: "HAL_U32", value: 4 },
+  { name: "halui.feed-override.value", type: "HAL_FLOAT", value: 0.9 },
+]);
+assert.equal(readVirtualHalPin(virtualHal, "motion.tooloffset.z").value, 1.25);
+assert.equal(readVirtualHalPin(virtualHal, "halui.tool.number").value, 4);
+assert.equal(virtualHal.overrides.feed, 90);
+const virtualHalRegistry = createVirtualHalPinRegistry(virtualHal);
+assert.equal(virtualHalRegistry.apiName, "linuxcnc-wasm-virtual-hal-pin-registry");
+assert.equal(virtualHalRegistry.byName["halui.machine.on"].writable, true);
+assert.equal(virtualHalRegistry.byName["motion.tooloffset.z"].value, 1.25);
+const virtualHalIntegrity = createVirtualHalIntegrityReport({ halState: virtualHal, registry: virtualHalRegistry });
+assert.equal(virtualHalIntegrity.complete, true);
+const virtualMachineStatus = createVirtualHalMachineStatusState(virtualHal);
+assert.equal(virtualMachineStatus.source, "browser-virtual-hal");
+assert.equal(virtualMachineStatus.spindle.direction, "cw");
+assert.equal(virtualMachineStatus.spindle.speed, "1200");
+assert.equal(virtualMachineStatus.coolant.flood, "on");
+const virtualHalRuntime = createLinuxCncVirtualHalRuntime(virtualHal);
+virtualHalRuntime.writePin({ name: "spindle.0.speed-out", type: "HAL_FLOAT", value: 1400 });
+assert.equal(virtualHalRuntime.readPin("spindle.0.speed-out").value, 1400);
+assert.equal(virtualHalRuntime.getIntegrityReport().complete, true);
+const runtimeSnapshot = virtualHalRuntime.getWasmBridgeSnapshot();
+assert.equal(runtimeSnapshot.apiName, "linuxcnc-wasm-virtual-hal-bridge-snapshot");
+assert.ok(runtimeSnapshot.values.some(({ name, type, value }) => name === "jog.x" && type === "HAL_BIT" && value === 1));
+assert.ok(runtimeSnapshot.values.some(({ name, type, value }) => name === "axisui.jog.x" && type === "HAL_BIT" && value === 1));
+assert.ok(runtimeSnapshot.values.some(({ name, type, value }) => name === "halui.machine.is-on" && type === "HAL_BIT" && value === 1));
+assert.ok(runtimeSnapshot.values.some(({ name, type, value }) => name === "spindle.0.speed-out" && type === "HAL_FLOAT" && value === 1400));
+assert.ok(runtimeSnapshot.values.some(({ name, type, value }) => name === "iocontrol.0.coolant-flood" && type === "HAL_BIT" && value === 1));
 
 assert.throws(
   () => getSimulationTestProgram("missing-program"),
@@ -91,8 +164,8 @@ assert.equal(arcModal.apiName, "real-browser-simulation-modal-state");
 assert.equal(arcModal.source, "linuxcnc-update-tag");
 assert.ok(arcModal.raw.includes("canon_event=UPDATE_TAG line=1"));
 assert.ok(arcModal.rows.some(({ id, value, source }) => id === "plane" && value === "plane=170" && source === "linuxcnc-update-tag"));
-assert.equal(unavailableMachineStatus.spindle.state, "n/a");
-assert.equal(unavailableMachineStatus.coolant.mist, "n/a");
+assert.equal(unavailableMachineStatus.spindle.state, "off");
+assert.equal(unavailableMachineStatus.coolant.mist, "off");
 
 const runtimeMachineStatus = createMachineStatusState([
   "canon_event=SET_SPINDLE_SPEED spindle=0 speed=1200",
@@ -108,7 +181,7 @@ const runtimeMachineStatus = createMachineStatusState([
   "canon_event=ENABLE_SPEED_OVERRIDE spindle=0",
 ].join("\n"));
 assert.equal(runtimeMachineStatus.spindle.state, "off");
-assert.equal(runtimeMachineStatus.spindle.direction, "cw");
+assert.equal(runtimeMachineStatus.spindle.direction, "stopped");
 assert.equal(runtimeMachineStatus.spindle.speed, "1200");
 assert.equal(runtimeMachineStatus.coolant.mist, "off");
 assert.equal(runtimeMachineStatus.coolant.flood, "off");
@@ -160,11 +233,11 @@ assert.equal(firstFrame.activeLine, 1);
 assert.equal(firstFrame.visibleMotion.length, 1);
 assert.equal(firstDro.apiName, "real-browser-simulation-dro-state");
 assert.equal(firstDro.actual.x, "0.000");
-assert.equal(firstDro.distanceToGo.x, "n/a");
-assert.equal(firstDro.workOffsetG54.x, "n/a");
-assert.equal(firstDro.g92Offset.x, "n/a");
-assert.equal(firstDro.toolLengthOffset.x, "n/a");
-assert.equal(firstDro.velocity, "n/a");
+assert.equal(firstDro.distanceToGo.x, "0.000");
+assert.equal(firstDro.workOffsetG54.x, "0.000");
+assert.equal(firstDro.g92Offset.x, "0.000");
+assert.equal(firstDro.toolLengthOffset.x, "0.000");
+assert.equal(firstDro.velocity, "0.000");
 
 const arcFrame = createPlaybackFrame(playbackState, 1);
 assert.equal(arcFrame.index, 1);
diff --git a/wasm-port/tests/wasm/node/verify_interp_wasm.mjs b/wasm-port/tests/wasm/node/verify_interp_wasm.mjs
index 7de0993..b0bef5d 100644
--- a/wasm-port/tests/wasm/node/verify_interp_wasm.mjs
+++ b/wasm-port/tests/wasm/node/verify_interp_wasm.mjs
@@ -4,7 +4,9 @@ import { dirname, resolve } from "node:path";
 import assert from "node:assert/strict";
 
 import {
+  applyVirtualHalAction,
   createLinuxCncInterpSdk,
+  createVirtualHalState,
   planIniFileContextStaging,
 } from "../../../runtime/sdk/src/index.js";
 import {
@@ -726,6 +728,46 @@ verifyExpectedOutput(
   ].join("\n"),
 );
 
+if (
+  interp.hasWasmFunction("lcinterp_hal_reset") &&
+  interp.hasWasmFunction("lcinterp_hal_set_value") &&
+  interp.hasWasmFunction("lcinterp_probe_hal_named")
+) {
+  let virtualHal = createVirtualHalState();
+  virtualHal = applyVirtualHalAction(virtualHal, "estop");
+  virtualHal = applyVirtualHalAction(virtualHal, "power");
+  virtualHal = applyVirtualHalAction(virtualHal, "jog", { axis: "x", increment: "0.01 in", direction: 1 });
+  virtualHal = applyVirtualHalAction(virtualHal, "spindle", { command: "cw", speed: 1200 });
+  virtualHal = applyVirtualHalAction(virtualHal, "coolant", { name: "flood", enabled: true });
+  const applyResult = interp.applyVirtualHalState(virtualHal);
+  assert.equal(applyResult.apiName, "linuxcnc-wasm-hal-apply-result");
+  assert.equal(applyResult.source, "browser-virtual-hal");
+  assert.ok(applyResult.applied > 0, "virtual HAL bridge should apply values");
+  verifyExpectedOutput(
+    "probe_virtual_hal_bridge",
+    [
+      interp.probeHalNamed("_hal[jog.x]"),
+      interp.probeHalNamed("_hal[jog.increment]"),
+      interp.probeHalNamed("_hal[axisui.jog.x]"),
+      interp.probeHalNamed("_hal[axisui.jog.increment]"),
+      interp.probeHalNamed("_hal[axis.x.pos-cmd]"),
+      interp.probeHalNamed("_hal[halui.machine.is-on]"),
+      interp.probeHalNamed("_hal[spindle.0.speed-out]"),
+      interp.probeHalNamed("_hal[iocontrol.0.coolant-flood]"),
+    ].join(""),
+    [
+      "_hal[jog.x]: rc=0 found=1 value=1",
+      "_hal[jog.increment]: rc=0 found=1 value=0.01",
+      "_hal[axisui.jog.x]: rc=0 found=1 value=1",
+      "_hal[axisui.jog.increment]: rc=0 found=1 value=0.01",
+      "_hal[axis.x.pos-cmd]: rc=0 found=1 value=0.01",
+      "_hal[halui.machine.is-on]: rc=0 found=1 value=1",
+      "_hal[spindle.0.speed-out]: rc=0 found=1 value=1200",
+      "_hal[iocontrol.0.coolant-flood]: rc=0 found=1 value=1",
+    ].join("\n"),
+  );
+}
+
 for (const fixtureName of INTERP_MDI_FIXTURES) {
   const programText = readFileSync(
     resolve(rootDir, `tests/fixtures/gcode/${fixtureName}.ngc`),
diff --git a/wasm-port/tools/build_wasm_core.sh b/wasm-port/tools/build_wasm_core.sh
index 8480fc2..3cb019c 100755
--- a/wasm-port/tools/build_wasm_core.sh
+++ b/wasm-port/tools/build_wasm_core.sh
@@ -98,5 +98,5 @@ link_wasm_module \
   -s STACK_SIZE=2MB \
   -s NO_EXIT_RUNTIME=1 \
   -s FORCE_FILESYSTEM=1 \
-  -s EXPORTED_FUNCTIONS='["_malloc","_free","_lcinterp_run_program","_lcinterp_run_program_with_ini","_lcinterp_run_file","_lcinterp_run_file_with_ini","_lcinterp_run_file_with_ini_continue_on_error","_lcinterp_run_fiveaxis_remap_file","_lcinterp_run_remap_file","_lcinterp_run_remap_file_continue_on_error","_lcinterp_run_remap_io_mdi_sequence","_lcinterp_restore_parameters","_lcinterp_save_parameters","_lcinterp_load_tool_table","_lcinterp_load_tool_table_random","_lcinterp_save_tool_table","_lcinterp_probe_init_and_synch","_lcinterp_probe_indexer","_lcinterp_probe_named_parameters","_lcinterp_free_string"]' \
+  -s EXPORTED_FUNCTIONS='["_malloc","_free","_lcinterp_run_program","_lcinterp_run_program_with_ini","_lcinterp_run_file","_lcinterp_run_file_with_ini","_lcinterp_run_file_with_ini_continue_on_error","_lcinterp_run_fiveaxis_remap_file","_lcinterp_run_remap_file","_lcinterp_run_remap_file_continue_on_error","_lcinterp_run_remap_io_mdi_sequence","_lcinterp_restore_parameters","_lcinterp_save_parameters","_lcinterp_load_tool_table","_lcinterp_load_tool_table_random","_lcinterp_save_tool_table","_lcinterp_probe_init_and_synch","_lcinterp_probe_indexer","_lcinterp_probe_named_parameters","_lcinterp_hal_reset","_lcinterp_hal_set_value","_lcinterp_probe_hal_named","_lcinterp_free_string"]' \
   -s EXPORTED_RUNTIME_METHODS='["FS","UTF8ToString","stringToUTF8","lengthBytesUTF8"]'