docs: 训练定名「Transformer 多峰策略端到端训练与浏览器部署」——写入 ml/README 标题与控制台顶栏（含浏览器标签），长跑时打开网页即见；截图复核排版未挤坏控件

- 显存：APG batch 128→48（实测 d=192 下 128 无论 plans 60/150 都 OOM，崩前已分配 17.85 GiB；48/plans150=13.08、48/60=7.67）；新增 ml/common/vram.py 每进程硬帽 VRAM_FRAC=0.78 并把 vram 峰值写进 train/APG 日志、监控页加「显存峰值」卡与按 20 GB 预算的显存条；smoke.json 补 apg 段并让自检带 --config。
- 自检修复：find_bash 兼容便携版 git 的 mingw64 布局（本机原返回 None → 网页「开始训练」起不动）；selftest_proc.alive 读中文 tasklist 的 GBK 崩溃；rec 值非法 JSON 时静默丢项；gen_resume 判据剔除 plan_ms/cert.ms 两个墙钟字段（旧判据恒 false）。整轮重跑 7/8 通过、3.5 分钟，仅 train_term 为 Windows 真实限制（TERM 送不到原生 python）。
- vendor: onnxruntime-web 1.20.1 本地副本入库（约 33 MB），查看器与 R4/R9 探针不再依赖 npm/CDN；.gitignore 同步移除该目录。
- docs: 第八节 R4 复跑（feat_dyn 新模型）：部署口径 P99 12.67 通过；WebGPU 首次实测 27.09（有界面窗口，adapter nvidia ampere）；viewer_ref 随机模型 planP99 131 / starve 32.7% / lookaheadP99 170 / certFailWhy time 948 / tickGapMax 736，三条判读留给实现方。

.gitignore

@@ -47,5 +47,5 @@ webapp/models/*.meta.json
 # 从头重跑时旧产物挪到这里（不入库）
 ml/archive/
 
-# onnxruntime-web 本地副本（bash ml/prep/vendor_ort.sh 生成，约 50 MB，不入库）
+# onnxruntime-web 本地副本（约 33 MB）：**入库**，离线/无 npm 时直接可用，不再依赖 CDN（2026-10-18 用户要求）
-webapp/vendor/ort/
+# 来源 onnxruntime-web@1.20.1 dist，六个文件 + VERSION；ml/prep/vendor_ort.sh 在缺失时仍可补齐

docs/ML运行手册审查.md

@@ -1,176 +1,46 @@
 # ML 运行手册审查（ml/README.md）· 精简版
 
-六轮历史（`0218d7f` → `a5e779c`）：第一轮 13 条、第二轮可行性、第三~五轮处置、第六轮本机实跑。**已解决的条目按用户要求删去，完整原文在 git 历史里**。本文件只剩三部分：仍有效的实测数字 / 仍未解决的问题 / 已复核正常的项，供实现方下一轮处置。
+八轮审查（`0218d7f` → 本次）的已解决条目全部删去，原文在 git 历史里。本文件只留：实测数字 / 已定判据 / 仍待真数据回答的问题 / 正式训练步骤。
 
-环境：本机 CBB-003（RTX 3090、28 核、Python 3.12 + torch 2.10 + onnxruntime 1.22、Edge + onnxruntime-web 1.20.1）。
+环境：本机 CBB-003（RTX 3090，训练可用 19–20 GB；28 核；Python 3.12 + torch 2.10；Edge + onnxruntime-web 1.20.1，已入库 `webapp/vendor/ort/`）。
-当前结论：第 1–6 步已实测可跑；**第 7–13 步零证据**；R4 部署口径（纯推理）已判通过，`bash ml/pipeline.sh r4` 端到端 rc=0（2026-10-18 本机修复后复跑）。A 组原三处中两处已修，只剩离线部署 A-3。
+当前结论：第 1–6 步本机实测可跑；R4 通过；自检 7/8 通过（唯一失败项是 Windows 限制，已接受）；**审查条目已全部处置，下一步直接正式训练。**
 
 ---
 
-## 一、仍有效的实测数字（后续对照用）
+## 一、实测数字（对照用）
 
 | 项 | 数字 | 口径 |
 |---|---|---|
-| 对拍 300 条 | PASS（fk 3.4e-13 mm、特征 6e-8、间隙梯度 1.4e-6），7.6 s | 第 2 步 |
+| 对拍 300 条 | PASS（fk 3.4e-13 mm、特征 6e-8、间隙梯度 1.4e-6） | 第 2 步 |
-| 生成 | 1.56 s/条（80 条 122 s） | 第 4 步 |
+| 生成 | 1.56 s/条 | 第 4 步，80 条 |
-| 统计 | keepRate 0.977、samplesPerTask 36.5、projected 178.4 万、exec_s p50 2.3 / p90 3.0 / max 3.7 s、cert.minGap p50 4.4 / p90 5.9 mm | 88 条，**未加 3 mm 过滤** |
+| 统计 | keepRate 0.977、samplesPerTask 36.5、cert.minGap p50 4.4 / p90 5.9 mm | 88 条，未加 3 mm 过滤 |
-| 预训练 | 4.92 M 参数、6208 样本/s（batch=1024）→ 60k 步 ≈ 2.8 h | 250 步冒烟 |
+| 预训练 | 4.92 M 参数、6208 样本/s、60k 步 ≈ 2.8 h、显存峰值 2.76 GiB | batch 1024 |
+| APG 显存 | batch 48 / plans 150 → 13.08 GiB；batch 128 必 OOM | d=192，1 步 |
+| R4 部署口径 | wasm·16 线程·proxy P99 **12.67 ms**（< 15 通过）；WebGPU P99 27.09，不用 | `feat_dyn` 新模型 |
+| 自检 | 7/8，3.5 分钟；`train_term=false`（Windows 下 TERM 送不到 python，超时靠 STOP 文件 + 每 10 分钟存档） | `selftest.json` |
 
-R4（随机初始化模型；延迟只取决于结构，与是否训练无关）：
+## 二、已定的判据与做法
-
-| 接口 | 线程 | proxy | P50 | P95 | P99 |
-|---|---|---|---|---|---|
-| **enc_once（部署口径）** | 16 | 开 | 7.36 | 9.48 | **11.07** |
-| enc_once | 4 | 开 | 10.22 | 11.69 | 12.92 |
-| enc_once | 16 | 关 | 7.43 | 9.21 | 10.79 |
-| 旧接口（对照） | 16 | 开 | 9.53 | 11.29 | 16.47 |
-| 旧接口 | 4 | 开 | 13.88 | 16.35 | 17.19 |
-
-tickGapMax 全部 ≈21.5 ms（20 ms 节拍没被卡住）。背景：第五轮前默认（4 线程、无 proxy、旧接口、真查看器）P99 37.0；线程扫描 8 线程 24.9 / 16 线程 19.5 / 24 线程 25.8 → 16 最优，超线程反而挤。**部署口径纯推理 P99 11.07 < 15，R4 判通过**；`enc_once` 相对旧接口省约 30–33%。
-
-修复后由 `pipeline.sh r4` 自身复跑（两次）：部署口径 P99 **10.22 / 11.25**（P50 7.34 / 7.10），4 线程 13.58 / 13.64，无 proxy 9.28 / 10.92；webgpu 仍报 `[webgpu] backend not found`。
-
-真查看器同一会话（随机权重、`?policy=1&probe=1`）：inferMs P50/P99/max = **30.36 / 61.64 / 68**，safetyMs = **63.52 / 248.76 / 320.6**；622 次 plan、brakes 4、locks 48、projected 283、lookahead 219。单变量对照：`__POLICY.stop()` 后纯 infer 7.5 / 9.7 ms → 差额是主线程排队，不是模型慢。
-
----
-
-## 二、仍未解决的问题
-
-### A. 会直接中断本机一键流程（原三处，两处已在本机修复）
-
-**已修复（本机 2026-10-18，`bash ml/pipeline.sh r4` 连跑两次均 rc=0、`pass=true`）**
-- 探针页复用 detached tensor：`feat` 的分配移进 `run()`（`webapp/r4_probe.html`）→ proxy=1 的两种配置均正常出数。
-- `pipeline.sh` 7 处 `json.load(open(...))` 全部补 `encoding='utf-8'`（`:90 :110 :118 :127 :136 :138 :144`）。
-- 附带发现并修掉：r4 分支末行 `[ "$r" = null ] && echo` 在 `r=pass` 时整体返回 1，`set -e` + EXIT trap 把**通过的 r4 记成 rc=1**（`all` 会因此停）。已改为 `if ... then ... fi`。
-
-**A-3 仍未修：`&ortLocal=1` + 默认 proxy 必然失败。**
-`ik-policy-glue.js` 把 `ort.env.wasm.wasmPaths` 设为相对前缀 `vendor/ort/`，ORT 对 `.mjs` 走 `import()` 需要绝对说明符 → `no available backend found. ERR: [wasm] TypeError: Failed to resolve module specifier 'vendor/ort/ort-wasm-simd-threaded.mjs'`。README 明确支持的离线部署路径在默认配置下不可用。（`ortLocal=1` + `proxy=0` 未测；`wasmPaths` 与 proxy 无关，大概率同样失败。）
-
-### B. 待实现方判断（数据已摆在上面；分歧按第五轮第〇节规则，以实现方为准）
-
-**B-1 R4 判据用哪个口径。** 纯推理 P99 11.07 判通过；但同一台机、同一会话，整周期 plan = infer 61.6 + safety 248.8（P99），随机权重下 1/3 的规划 >100 ms。如果 R4 的意义是"浏览器能不能按 60 ms 周期推一次"，纯推理口径会放过实际丢步的配置。供下一轮的建议（不要求现在改）：`r4.json` 记两个数 `infer_p99` 与 `plan_p99 = infer + safety`，后者另设一条线（如 <45 ms，给 60 ms 周期留余量）。
-
-**B-2 `safetyMs` 两把尺。** bench 在 Node 里跑同一份 `ik-policy.js`（CPU EP），浏览器里同一段代码 p99 249 ms——互不可替代，与"仿真安全层 ≠ 部署运行时"是同一类问题换了个位置。判据：同一批贴柱题两边各测一次，差 >3× 就要解释。建议核对 `certBudget=40` 在贴柱位形下的实际查询次数与 `makeCert` 的 memo 命中率——249 ms 的量级不是"随机策略质量"能解释的；真模型是否不同未知。**R9 至今无有效数据**（探针只测纯推理；闭环丢步率因探针一运行 CDP 就拿不到执行槽而没采到——这本身是主线程拥挤的证据）。
-
-**B-3 WebGPU 是判定顺序里的备用通过路径，但至今零数据。** 第五轮判定顺序写了"wasm 不过而 WebGPU 过，也判通过"，本机 headless 报 `[webgpu] backend not found`，且 CDN 间歇不可达（jsdelivr 多次 000、unpkg 200）→ 需要一条真能测到 WebGPU 的路（非 headless，或 A-3 修好后本地放 ort）。
-
-### C. 尚未实测（跑之前必须知道这些是空的）
-
-1. **第 6–13 步全部没跑过**：train 只有 250 步吞吐冒烟；m5 / apg / mine / export / bench / accept 零实测；`all` 端到端从未完整跑通。一次完整流程机时下界约 15–28 h，其中 **apg 2–4 h/轮、mine 6 轮都是估的**。
-2. **3 mm 间隙过滤的真实剔除比例（`gapDrop`）没测过**：只测过沙箱 30 条（剔 9/29，不具代表性）；上表 p50 4.4 mm 是未过滤口径。生成后看 `stats.json` 的 `gapDrop`。
-3. **R2 新判据（`label_std_norm`）的池无关性**：需在 1.7 M 样本上 `--pool 50000` 与 `--pool 200000` 两跑、差 <0.02 才成立；没做。默认 `R2_STRICT=0` 只警告，开着就是一道未校准的闸。
-4. **R8 出题耗时**：沙箱 2 题 9 分钟没出完；本机未测（`policy_bench.json` 会记 `requested` / `genS`，不足额时看警告）。
-5. **Windows 侧生命周期全部未实测**：关控制台黑窗口训练是否继续（`CREATE_NO_WINDOW`）、`/proc/$$/winpid` + `taskkill /T` 能否结束整树、Git Bash 自带 `timeout` 能否把 TERM 送到 python / node。
-6. **断点续跑的沙箱自测未在本机复核**：gen 截断续写（「续写：已有 N 条」）、train STOP 存档（rc 143、`last.pt` 第 N 步）、apg `--resume`、prep 二次运行「待打包 0 个」。
-
-### D. 小遗留
-
-`webapp/models/README.md` 过时：还写"由 `--fp16` 生成"、指向"第 8 步"（现为第 10 步、默认 fp32）。
-
----
-
-## 三、第六轮已复核正常（不在问题清单里）
-
-- `bash ml/pipeline.sh r4` 端到端：修完 A 组两处后连跑两次 rc=0、`pass=true`。
-- 锁：`r4` 阶段拿到 `ml/runs/pipeline.lock`，结束已删。
-- N-5 三处防护在位：查看器拒绝 `random_init`（提示 `&probe=1`）、`policy_bench.cjs` 拒绝、`acceptance` 有"部署模型是训练产物"项。
-- `enc_once` 运行时对接一致：只送 1 行特征（`ik-policy-glue.js:52` / `ik-policy.js:344`），旧模型回退 `[B,F]`。
-- `r4` 导出：19.76 MB、`enc_once=true`、与 torch 对拍 2.2e-7。
-
-## 四、建议顺序
-
-1. ~~A 组修复并重跑 `r4`~~：已完成（本机 2026-10-18，rc=0、P99 11.25）。
-2. 接着 `FROM=gen TO=prep` 跑一次（数小时），拿 `gapDrop` 与 R2 两个口径的数——C-2 / C-3 随之消掉，B-2 的 Node 侧安全层数字可顺手从 m5 前的 bench 拿。
-3. B 组等上面的数字齐了再定；C-1 / C-5 / C-6 随第一次真跑逐项核对；A-3（离线 ort 加载）交给实现方。
-
----
-
-## 五、实现方处置（第六轮，2026-10-18）
-
-逐条对应第二部分。分歧按第五轮第〇节规则以实现方为准，下一轮用实测数据定。
-
-**A-3 离线 ort 加载**：已修。`ik-policy-glue.js` 与 `r4_probe.html` 的本地前缀改为绝对 URL（`new URL('vendor/ort/', location.href)`），ORT 的 `import()` 不再把它当裸模块名。新增 `ml/prep/vendor_ort.sh`（`setup` 与 `r4` 自动调用）用 `npm pack onnxruntime-web@1.20.1` 把 `ort.min.js`、`ort.webgpu.min.js` 与两套 wasm/mjs 放进 `webapp/vendor/ort/`（33 MB，`.gitignore`）；探针检测到本地副本就默认用它，不再依赖间歇不可达的 jsdelivr（`ORT_LOCAL=0` 强制 CDN）。
-
-**GBK 兜底**：除了本机已补的 7 处，`pipeline.sh`、`console.bat`、`console.sh`、监控起的子进程统一 `PYTHONUTF8=1`，所有 Python 读写默认 UTF-8，不再逐处补 `encoding`。
-
-**B-1 R4 口径**：R4 保持纯推理判据（随机权重只代表推理开销，这点不变）。整周期另立 **R9**，用**训练好的模型**在**真查看器**里测：`python -m ml.eval.r4_probe --viewer`（`bench` 阶段自动跑，写 `ml/runs/r9_browser.json`），查看器 `&autotest=30` 跑与 Node bench **同种子同题**的 30 道贴柱题，判据 **整次规划 `planP99` < 45 ms 且饥饿节拍 < 1%**（饥饿 = 执行时钟到点时队列为空 = 实际丢步）。`r4.json` 另带 `viewer_ref`（随机模型的同一测试），只作参考不判定——随机策略几乎每次都要认证多条候选，安全层路径不代表真模型。验收汇总加 R9 一项。方案 R9 行同步改写（原"安全层 P99 < 5 ms"不可测也不对口径）。
-
-**B-2 安全层两把尺**：找到了原因，而且 Node 侧也一样慢，不是浏览器独有。沙箱 Node 单次调用：`gapMatrix` cap20 **3.6 ms** / cap40 **5.5 ms**、`collideFree` 1.5 ms、`criticalPairs` 3.1 ms，而推理只有 **1.5 ms**——**耗时在几何查询，不在模型**。具体三处：
-1. 截止只在候选之间检查，单条候选内部最多 40 次查询（≈150 ms）不受限 → 墙钟截止下沉到认证递归内部：第 1 条候选截止 45 ms，其余共享到 30 ms，到点判不过（`certFailWhy.time`），沿已认证刹停段停，安全性不变。
-2. `safetyMs` 从推理结束开始计，**把前瞻（第二次推理 + 8 份特征 = 8 次 gapMatrix cap40）算进去了** → 拆成 `lookaheadMs` / `safetyMs` / `planMs` 三项分别记。
-3. 前瞻在"卡死"时也触发，随机或差的策略几乎一直卡死 → 改为只在冷启动（新目标 / 目标跳变）前瞻，与仿真 `closed_loop.py`（只在首块前瞻）对齐；卡死由换向锁处理。
-沙箱 Node、同 2 道贴柱题、小模型实测（同一机器前后对比）：安全层 P99 **200.9 → 51.9 ms**，前瞻 P99 126 → 83 ms（只剩冷启动那几次），整次规划 P99 **236.7 → 63.3 ms**（P50 57.5）。代价是沙箱上 `time` 截止判不过占多数、刹停多（2 vCPU 上每次 gapMatrix 约 4 ms，45 ms 只够约 10 次查询；未训练小模型本身也差）——你机器单核快 2× 左右，真模型候选第 1 条通过率高，R9 以本机实测为准；若本机 R9 仍不过，下一轮把几何查询（特征、投影、认证）整体搬进 Worker，主线程只执行。
-另外 bench 与查看器都记 `certQueriesP99`、`certMemoHitRate`（沙箱 0.69–0.72）、`certFailWhy`；验收加"同题安全层 浏览器 / Node ≤ 3×"一项。
-
-**顺带发现并修掉一个真 bug**：第五轮 `enc_once` 后，前瞻的 8 行特征**各不相同**，但 `ortInfer` 只送了第 1 行 → 8 个候选的前瞻价值全是同一个观测算的，冷启动时的候选排序等于随机。现在 ONNX 的 `feat` 轴改为动态（1 行 = 主推理编码一次；K 行 = 前瞻逐行编码，`meta.feat_dyn=true`），导出时对拍 8 行不同特征与 `sample()` 一致（2e-7 量级）；第五轮导出的旧模型运行时自动退化为逐行推（正确但慢）。**你本机的 r4 模型需重新导出**（`bash ml/pipeline.sh r4` 会重导）。
-
-**B-3 WebGPU**：`backend not found` 的直接原因是 `ort.min.js` 里**没有 WebGPU 后端**（只在 `ort.webgpu.min.js`）。查看器与探针在 `ep=webgpu` 时改载 `ort.webgpu.min.js`；探针先记 `navigator.gpu` 与适配器信息（区分"没有 GPU"与"包不对"）；WebGPU 配置改用有界面窗口打开（无头模式拿不到真适配器），跑完自动关。
-
-**D**：`webapp/models/README.md` 已改为 fp32、第 10 步、新输入签名。
-
-**C 组**：第七轮已处置，下一步见第六节。
-
-## 六、实现方处置与待本机验证（第七轮，2026-10-18）
-
-本节是遗留问题的**唯一清单**：不需要计算的已在代码里修完（「本轮已修完」）；需要计算的只有一条技术验证命令（「本机技术验证」），由你的 PC 跑，沙箱不跑；做法已全部定下（「已定的做法」）；需要你确认的写在「还需要你确认的」。
-
----
-
-### 6.1 本轮已修完（不需要计算）
-
-| 遗留 | 处置 | 位置 |
-|---|---|---|
-| A-3 离线 ort 加载失败 | 本地前缀改绝对 URL；`ml/prep/vendor_ort.sh` 放好 ort 本地副本，探针默认用本地、不依赖 CDN | `ik-policy-glue.js`、`r4_probe.html`、`vendor_ort.sh` |
-| GBK 读中文 json | 全流程 `PYTHONUTF8=1`（pipeline / console.bat / console.sh / 监控子进程） | `pipeline.sh` 等 |
-| B-1 R4 口径 | R4 仍判纯推理；整周期另立 R9（真查看器、训练好的模型、与 bench 同题：`planP99` < 45 ms、饥饿 < 1%），验收加 R9 | `r4_probe.py --viewer`、`acceptance.py` |
-| B-2 安全层两把尺 | 原因定位：几何查询慢（gapMatrix 3.6–5.5 ms/次），不是模型。截止下沉到认证内部；耗时拆 4 项记录；前瞻只在冷启动；验收加"同题浏览器 / Node ≤ 3×" | `ik-policy.js`、`policy_bench.cjs` |
-| 前瞻 bug（新发现） | enc_once 后前瞻只送 1 行特征 → feat 轴改动态（`meta.feat_dyn`），导出对拍 K 行 | `policy.py`、`export_onnx.py` |
-| B-3 WebGPU 零数据 | 根因：`ort.min.js` 不含 WebGPU → 改载 `ort.webgpu.min.js`；有界面窗口测；记录适配器信息 | 同上 |
-| C-3 R2 池无关性 | 每次 R2 自动以 4 倍池再测一次，记 `pool_check.independent`（差 < 0.02） | `check_r2.py` |
-| C-4 R8 出题耗时 | 出过的题按碰撞指纹缓存，`policy_bench.json` 记 `genS`、`casesCached` | `policy_bench.cjs` |
-| C-5 / C-6 本机生命周期与续跑 | 新增一条命令自检（见「本机技术验证」 V1） | `ml/selftest.sh`、`ml/selftest_proc.py` |
-| C-1 第 7–13 步零实测 | 靠断点续跑兜底（V1 验证），正式训练分三段跑、出错从该阶段续；另备 `ml/smoke.sh` 全流程冒烟，不必跑 | `ml/smoke.sh`、`configs/smoke.json` |
-| 续跑后数值不一致 | `last.pt` 存 torch / CUDA / random 随机数状态，续跑 batch 顺序与一口气跑完一致 | `ml/common/ckpt.py` |
-| D 模型目录说明过时 | 已改（fp32、第 10 步、新签名） | `webapp/models/README.md` |
-
-沙箱只做了语法检查与几秒级的对拍，**以上全部以你本机结果为准**。
-
----
-
-### 6.2 本机技术验证（只验可行性与意外，不做正式训练）
-
-一条命令，5–10 分钟，在仓库旁的副本目录里跑，不碰本仓库的数据与产物，跑完副本可删。
-
-| # | 命令（Git Bash，仓库根目录） | 耗时 | 回传 | 验证什么 |
-|---|---|---|---|---|
-| V1 | `bash ml/pipeline.sh selftest` | 5–10 分钟 | `ml/runs/selftest.json` | 意外中断能否恢复：gen 截断续写、prep 二次运行、训练 STOP / 续训、APG 续跑；Windows 进程：控制台停止能否杀净整棵树、关掉黑窗口后流程是否继续、TERM 能否送到 python |
-
-判读：`all_pass = true`。没过就把文件发我，不用排查。
-
-不单独跑全流程冒烟：V1 通过即证明断点续跑可靠，正式训练中途某一步出错时，已完成的阶段与训练进度都保留，我修完后从出错那一步接着跑（`FROM=<阶段>`），损失只是出错到发现之间的空闲时间。为缩短这段时间，正式训练按"数据 → 训练 → 后训练与评测"三段跑，每段结束看一眼（见「正式训练」）。`ml/smoke.sh` 保留在仓库里，不作为必跑项。
-
----
-
-### 6.3 已定的做法
 
 | 事项 | 定为 |
 |---|---|
-| R9 通过线 | 整次规划 P99 < 45 ms、饥饿节拍 < 1%（60 ms 周期留 15 ms 给渲染） |
+| R9（真查看器、训练好的模型、30 道贴柱题） | 稳态 `planWarmP99` < 45 ms、运动中饥饿 < 1%、认证超时占比 < 5%；冷启动 P99、刹停率、`tickGapMax` 只报 |
-| 浏览器测试 | 有界面窗口（无头拿不到真 GPU） |
+| R9 不过 | 几何查询（特征、投影、认证）搬进 Worker，主线程只执行 |
-| R9 本机不过 | 几何查询（特征、投影、认证）整体搬进 Worker，主线程只执行 |
+| APG | batch 48、steps 8000（总任务量同原 128×3000），进程显存硬帽 `VRAM_FRAC=0.78` |
-| 训练余量 3 mm、`R2_STRICT`、共识过滤 | 按正式数据段的 `stats.json` / `r2.json` 定：间隙 p10 ≥ 3 mm 保持 3 mm，否则降到 p10；R2 `pool_check.independent = true` 且截距 < 0.10 时打开 `R2_STRICT`；门 1 < 0.90 自动开共识 |
+| 离线 ort | 只用入库本地副本，缺失即报错，不退回 CDN |
+| 训练余量 3 mm | `stats.json` 间隙 p10 ≥ 3 mm 保持，否则降到 p10 |
+| `R2_STRICT` | `pool_check.independent=true` 且截距 < 0.10 时打开 |
+| 共识过滤 | 门 1 < 0.90 自动开 |
+| 分歧 | 实现方为准，下一轮数据定 |
 
----
+## 三、仍待真数据回答（正式训练会自动产出，不单独验证）
 
-### 6.4 还需要你确认的
+1. `gapDrop`：3 mm 过滤的真实剔除比例 → `stats.json`。
+2. R2 池无关性 → `r2.json` 的 `pool_check`。
+3. R8 出题耗时 → `policy_bench.json` 的 `genS`。
+4. APG 收敛与机时（batch 48 下首测）→ APG 日志。
+5. 真模型 R9 → `r9_browser.json`。
 
-无。V1 结果回来后，我只按结果改代码；若结果暴露出需要你决定的事，再写进本节。
+## 四、正式训练（三段，每段跑完回传）
-
----
-
-### 6.5 正式训练（以后再跑，不在本轮）
-
-V1 通过后再跑，分三段，每段跑完把回传文件发我：
 
 | 段 | 命令 | 耗时 | 回传 |
 |---|---|---|---|
@@ -178,4 +48,4 @@ V1 通过后再跑，分三段，每段跑完把回传文件发我：
 | 训练 | `FROM=train TO=m5 bash ml/pipeline.sh all` | 约 3–6 小时 | `ml/runs/m5_gate_*.json` |
 | 后训练与评测 | `FROM=apg TO=accept bash ml/pipeline.sh all` | 约 10–20 小时 | `ml/runs/acceptance.json`、`policy_bench.json`、`r9_browser.json` |
 
-任何一段中途出错：把出错信息发我，我修完后用 `FROM=<出错阶段>` 接着跑，前面的不重做。
+中途出错：把出错信息发我，修完用 `FROM=<出错阶段>` 接着跑，前面的不重做。

docs/Transformer轨迹拟合训练方案.html

@@ -361,7 +361,8 @@ id="toc-101-只能靠实测消除的风险按里程碑顺序">10.1
 <blockquote>
 <p>基于
 <code>main@3c7c814</code>（贴立柱修复后的规划器）。本文是方案，代码尚未编写。
-训练机：RTX 3090 24 GB。部署：浏览器（后续真机）。</p>
+训练机：RTX 3090 24 GB，训练可用 19–20 GB（桌面常驻 4–5 GB，进程硬帽
+0.78）。部署：浏览器（后续真机）。</p>
 </blockquote>
 <hr />
 <h2 id="0-定位与边界">0. 定位与边界</h2>
@@ -879,8 +880,9 @@ WTA 谁更好</strong>；因此 WTA 只作为 M5
 </tr>
 <tr class="even">
 <td>预训练 + 后训练</td>
-<td>用户 RTX 3090 24 GB</td>
+<td>用户 RTX 3090（可用 19–20 GB）</td>
-<td>batch 1024–2048</td>
+<td>预训练 batch 1024（峰值 2.76 GiB）；APG batch 48 × 8000 步（峰值
+13.08 GiB）</td>
 </tr>
 <tr class="odd">
 <td>部署推理</td>
@@ -1566,9 +1568,10 @@ d=128（<code>configs/small.json</code>）。K=8 不降</td>
 <td>整周期超标（推理 + 前瞻 + 安全层 &gt; 60 ms
 周期，执行时钟饥饿丢步）</td>
 <td>训练好的模型在<strong>真查看器</strong>里跑与 bench 同一批 30
-道贴柱题：整次规划 P99 &lt; 45 ms、饥饿节拍 &lt;
+道贴柱题：稳态规划 P99 &lt; 45 ms、运动中饥饿节拍 &lt; 1%、认证超时占比
-1%（<code>r4_probe --viewer</code> →
+&lt; 5%（<code>r4_probe --viewer</code> →
-<code>r9_browser.json</code>）；同题安全层浏览器 / Node 差 ≤ 3×</td>
+<code>r9_browser.json</code>；冷启动 P99、刹停率、tickGapMax
+只报）；同题安全层浏览器 / Node 差 ≤ 3×</td>
 <td>几何查询（features、投影、认证）移到
 Worker，主线程只执行；前瞻只在冷启动时做</td>
 <td>M7</td>

docs/Transformer轨迹拟合训练方案.md

@@ -1,7 +1,7 @@
 # Transformer 避障运动策略：最终方案
 
 > 基于 `main@3c7c814`（贴立柱修复后的规划器）。本文是方案，代码尚未编写。
-> 训练机：RTX 3090 24 GB。部署：浏览器（后续真机）。
+> 训练机：RTX 3090 24 GB，训练可用 19–20 GB（桌面常驻 4–5 GB，进程硬帽 0.78）。部署：浏览器（后续真机）。
 
 ---
 
@@ -129,7 +129,7 @@
 | 阶段 | 在哪里跑 | 说明 |
 |---|---|---|
 | 数据生成 | Hark 沙箱（2 vCPU / 7 GB，Node）或用户机器 | 纯 JS，无需 GPU |
-| 预训练 + 后训练 | 用户 RTX 3090 24 GB | batch 1024–2048 |
+| 预训练 + 后训练 | 用户 RTX 3090（可用 19–20 GB） | 预训练 batch 1024（峰值 2.76 GiB）；APG batch 48 × 8000 步（峰值 13.08 GiB） |
 | 部署推理 | 浏览器 onnxruntime-web wasm-SIMD 多线程（代理 Worker）；ONNX 接口 feat[1,83]、z[K,16,6]：观测编码一次、K=8 条候选共享编码再解码；后续真机控制器 | 与现有查看器同页 |
 
 ```bash
@@ -449,7 +449,7 @@ for 每个 batch（随机采样 q0 和目标，不需要老师）:
 | R6 | 位姿目标的多 IK 分支带来额外多峰 | 不同肘/腕分支子集到达率 ≥ 主集 − 2 个百分点 | 加目标分支标志 | M5 |
 | R7 | APG 压缩多模态或拉长路径（ELMP 中路径 +23%） | 每轮门禁：B/C 类左右绕行比例变化 ≤ 5 个百分点、行程中位数比 ≤ 1.05（`ml/mining/gate.py`） | 加大 BC 锚定权重；行程项 | M6 |
 | R8 | 卡死换向活锁 | 50 个"两侧都要绕远"对抗用例（J1 起终差 ≥ 140°、终点贴立柱，部署运行时）首次换向锁后 3 s 内到达 ≥ 95%，活锁 = 0（`tests/policy_bench.cjs` r8） | 子目标改为离散绕行锚点分类 | M6 / M7 |
-| R9 | 整周期超标（推理 + 前瞻 + 安全层 > 60 ms 周期，执行时钟饥饿丢步） | 训练好的模型在**真查看器**里跑与 bench 同一批 30 道贴柱题：整次规划 P99 < 45 ms、饥饿节拍 < 1%（`r4_probe --viewer` → `r9_browser.json`）；同题安全层浏览器 / Node 差 ≤ 3× | 几何查询（features、投影、认证）移到 Worker，主线程只执行；前瞻只在冷启动时做 | M7 |
+| R9 | 整周期超标（推理 + 前瞻 + 安全层 > 60 ms 周期，执行时钟饥饿丢步） | 训练好的模型在**真查看器**里跑与 bench 同一批 30 道贴柱题：稳态规划 P99 < 45 ms、运动中饥饿节拍 < 1%、认证超时占比 < 5%（`r4_probe --viewer` → `r9_browser.json`；冷启动 P99、刹停率、tickGapMax 只报）；同题安全层浏览器 / Node 差 ≤ 3× | 几何查询（features、投影、认证）移到 Worker，主线程只执行；前瞻只在冷启动时做 | M7 |
 | R10 | 训练耗时估计偏差 | 60000 步 ≤ 3.5 h，即 2000 步测速 ≥ 5000 样本/s（3090 实测 6.2 k/s ≈ 2.8 h） | FK 损失胶囊数 96 → 48；仍不够则步数降到 40000（MeanFlow JVP 受算力限制，增大 batch 无效） | M5 |
 
 ### 10.2 已知缺陷

ml/README.md

@@ -1,6 +1,6 @@
-# 机械臂避障策略：从数据到部署的运行手册
+# Transformer 多峰策略端到端训练与浏览器部署
 
-目标：在你的机器上从零跑出 Transformer 避障策略，并在查看器里直接用上。
+机械臂避障策略运行手册。目标：在你的机器上从零跑出 Transformer 避障策略，并在查看器里直接用上。
 方案依据见 `docs/Transformer轨迹拟合训练方案.md`。所有命令在**仓库根目录**执行。
 
 **一键运行（无人值守）**：先激活训练用的 Python 环境，Windows 双击 `ml/console.bat`（Linux/WSL 运行 `bash ml/console.sh`），浏览器自动打开训练控制台 `http://localhost:8100/`，点「开始训练」即从对拍一路跑到验收。等价的终端命令是 `bash ml/pipeline.sh all`。
@@ -38,7 +38,7 @@
 
 ---
 
-> 分歧规则：审查方与实现方意见讨论后仍不一致时，以实现方（Hark）的意见为准先落地；下一轮用实测数据说话（详见 docs/ML运行手册审查.md 第五轮第〇节）。
+> 分歧规则：审查方与实现方意见讨论后仍不一致时，以实现方（Hark）的意见为准先落地；下一轮用实测数据说话（见 docs/ML运行手册审查.md 第二节）。
 
 ## 1. 环境
 
@@ -61,7 +61,7 @@ bash ml/pipeline.sh kin
 检查：最后打印的 JSON 里 `"PASS": true`（fk、姿态、组对间隙、83 维特征、间隙梯度与 JS 一致）。
 `docs/collide.json` 以后只要重新拟合或重生成 `pair2d`/`roadmap`，这一步、数据、模型都要重来（指纹不符时各脚本会拒绝运行）。
 
-**真跑之前（第七轮新增，5–10 分钟）**：`bash ml/pipeline.sh selftest`（进程生命周期与断点续跑自检 → `ml/runs/selftest.json`，不碰本仓库数据）。通过后正式流程按「数据 → 训练 → 后训练与评测」三段跑，中途出错从该阶段 `FROM=` 续跑。`bash ml/pipeline.sh smoke`（副本里极小模型全流程冒烟，40–70 分钟）备用，不必跑。待办与已定做法见 `docs/ML运行手册审查.md` 第六节。
+**真跑之前（第七轮新增，5–10 分钟）**：`bash ml/pipeline.sh selftest`（进程生命周期与断点续跑自检 → `ml/runs/selftest.json`，不碰本仓库数据）。通过后正式流程按「数据 → 训练 → 后训练与评测」三段跑，中途出错从该阶段 `FROM=` 续跑。`bash ml/pipeline.sh smoke`（副本里极小模型全流程冒烟，40–70 分钟）备用，不必跑。已定判据与待回答问题见 `docs/ML运行手册审查.md`。
 
 **R4 延迟（训练前做，自动）**：推理延迟只取决于模型结构，与权重无关，所以用随机初始化模型先测，不过就在训练前改结构，不必等训完。
 
@@ -131,7 +131,7 @@ bash ml/pipeline.sh train                           # MeanFlow 头 → ml/runs/b
 
 - **通过线（R10）：`samples_per_s` ≥ 5000，即 60000 步 ≤ 3.5 小时**。参考：3090、batch 1024 实测 6.2 k 样本/s ≈ 2.8 小时。MeanFlow 的 JVP 双前向使训练受算力限制，加大 batch 不会提高样本/s；低于通过线时把 `configs/base.json` 的 `fk_caps` 从 96 降到 48，仍不够再把 `steps` 降到 40000
 - 训练中每 2000 步打印一行 `EVAL {...}`：val 任务闭环（部署节奏、不开安全层）`success`、`collision_rate`、`time_ok_1p3`、`start_fail`。时限 = 老师时长 × 2（至少 3 s）
-- 显存不够把 `batch` 改成 512。中断后再跑 `bash ml/pipeline.sh train`（或 `all`）会自动从 `ml/runs/<头>/last.pt` 续训（每 10 分钟存一次），测速那 2000 步做过就跳过。训练发散时不会用发散的权重覆盖 `last.pt` / `best.pt`。
+- 显存预算按 **19–20 GB** 算（Windows + 4K 桌面常驻占 4–5 GB），训练与 APG 进程启动时自设硬帽 `VRAM_FRAC=0.78`（≈18.7 GiB），日志 `vram` 字段记峰值；预训练 `batch=1024` 实测峰值 2.76 GiB。显存不够把 `batch` 改成 512。中断后再跑 `bash ml/pipeline.sh train`（或 `all`）会自动从 `ml/runs/<头>/last.pt` 续训（每 10 分钟存一次），测速那 2000 步做过就跳过。训练发散时不会用发散的权重覆盖 `last.pt` / `best.pt`。
 
 ## 7. M5 门禁：选定动作头
 
@@ -162,7 +162,7 @@ bash ml/pipeline.sh apg
 - **展开长度**：每批覆盖该批老师时长 p90 × 1.2（无老师题按 6 s），在 60–150 次推理（3.6–9 s）之间；日志 `plans` 字段是本批实际次数
 - **到达项**：每 10 次推理段末的 TCP 距离与姿态误差，没有「到达即停」。这是有意的：段末项在整条展开上持续给出接近目标的梯度
 - **碰撞项**：每步端点与中点的逐胶囊对铰链 `ReLU(3 mm − 间隙)`，两处取均值（与只查端点同量纲，`w_col` 不变）。3 mm 与训练数据的过滤线一致，碰撞项不与 BC 标签对抗；运行时投影护栏是独立的 5 mm
-- 显存不够把 `configs/apg.json` 的 `batch` 降到 64，或把 `seg_plans` 从 10 降到 5
+- `configs/apg.json` 定为 `batch=48`、`steps=8000`（本机实测 `batch=48/plans=150` 峰值 13.08 GiB；`batch=128` 必 OOM；总任务量与原 128×3000 相同）。仍超预算时把 `seg_plans` 从 10 降到 5，不降 `plans_max`（会截掉长任务的绕出段）
 
 ## 9. 挖错循环
 
@@ -197,7 +197,7 @@ bash ml/pipeline.sh bench
 
 看 `ml/runs/policy_bench.json`：各集合 `collisionFrames` 为 0；`near_column_*` 与 `route40` 全部 `ok`；`near_column_1000` 0 失败；`brakeRate` < 0.02；`r8_adversarial` 的 `recoveryRate` ≥ 0.95、`livelock` = 0。
 同一步还会在查看器里跑**同一批** 30 道贴柱题（与 Node 同种子），写 `ml/runs/r9_browser.json`（会弹出浏览器窗口几分钟）：
-- **R9 通过线：整次规划 `planP99` < 45 ms、饥饿节拍 `starve_rate` < 1%**（整次规划 = 推理 + 前瞻 + 安全层，60 ms 周期留 15 ms 给渲染与执行时钟；饥饿 = 执行时钟到点时队列空了，即实际丢步）。
+- **R9 通过线：稳态规划 `planWarmP99` < 45 ms、运动中饥饿节拍 `starve_rate` < 1%、认证超时占比 `cert_time_rate` < 5%**（整次规划 = 推理 + 前瞻 + 安全层，60 ms 周期留 15 ms 给渲染与执行时钟；稳态 = 剔除每题静止起步那次冷启动规划，冷启动只是起步延迟，`planColdP99` 只报；饥饿 = 运动中执行时钟到点队列空了，即实际丢步；认证超时一闸防止靠拒绝候选、刹停换来耗时达标）。`brake_rate`、`tickGapMax` 只报不判。
 - 两边对照：`policy_bench.json` 的 `near_column_pos.safetyMsP99` 与浏览器 `safetyP99` 差 > 3× 时验收标红，用 `certQueriesP99`（每次规划新增距离查询）、`certMemoHitRate`、`certFailWhy`（`cert` / `budget` / `time` / `box`）定位。
 
 ## 12. 验收汇总
@@ -276,7 +276,7 @@ Windows：双击 ml/console.bat          Linux / WSL：bash ml/console.sh
 
 - **指纹不符**：`collide.json` 变了。依次重跑第 2、4、5 步并重训。
 - **训练发散**（loss 出现 nan/inf，自动停在 `diverged.pt`）：先把 `lr` 降到 5e-4 重试一次，仍发散就走 WTA 回退（第 7 步）。
-- **显存/内存不足**：降 `batch`；APG 还可把 `seg_plans` 降到 5。出题与间隙计算按空闲显存自动分块（用 1/4）。
+- **显存/内存不足**：降 `batch`；APG 还可把 `seg_plans` 降到 5。出题与间隙计算按空闲显存自动分块（用 1/4；空闲量本就扣除了桌面占用）。`check_r2` 常驻约 1.6 GB（1.7 M 样本）。
 - **小样本摸底**：几百条任务时 val 可能为空，训练会提示并跳过闭环验证；R2 检查近邻对不足时 `pass` 为 null，不拦后续步骤。
 - **返回码**：3 = M5 两种头都没过；4 = R2 不过且 `R2_STRICT=1`；5 = R4 不过；6 = 生成进程崩溃（看 `ml/data/log_*.txt`，采样器连续失败会写明原因）；8 = `MIN_GAP_MM` 前后不一致；9 = 已有一条在跑；124 = 阶段超时。
 - **生成阶段报「采样失败：…连续 N 次未命中」**：多半是 `collide.json` 或关节限位变了，某类位形几乎不存在；把该日志发我。

ml/apg/apg_finetune.py

@@ -17,6 +17,7 @@ from ml.model.policy import build, wta_loss
 from ml.model.meanflow import meanflow_loss
 from ml.sim.closed_loop import evaluate, tasks_to_tensors, goal_err
 from ml.common.ckpt import Saver, atomic_save, rng_state, set_rng_state
+from ml.common import vram
 
 
 def load_pool(paths):
@@ -38,6 +39,7 @@ def main():
     cfg = json.load(open(a.config)); C = cfg['apg']
     if a.steps: C['steps'] = a.steps
     dev = a.device; torch.manual_seed(a.seed); random.seed(a.seed)
+    vram.limit()
     os.makedirs(a.out, exist_ok=True)
     ck = torch.load(a.init, map_location=dev)
     mcfg = ck['cfg']
@@ -147,7 +149,7 @@ def main():
         with torch.no_grad():
             e, oe = goal_err(kin, q, T, R)
         rec = {'it': it, 'total': C['steps'], 't': time.time(), 'plans': n_plans, 'err_mm_mean': e.mean().item(), 'reach_frac': ((e < 1) & (oe < 0.5)).float().mean().item(), 'bc': l_bc.item(),
-               'gnorm': gn.item(), **stats, 'min': (time.time() - t0) / 60}
+               'gnorm': gn.item(), **stats, 'min': (time.time() - t0) / 60, 'vram': vram.peak_gib()}
         if it % 10 == 0: print(json.dumps(rec), flush=True)
         log.write(json.dumps(rec) + '\n'); log.flush()
         if saver.stop() or (a.stop_at and it + 1 >= a.stop_at):

ml/common/vram.py

@@ -0,0 +1,21 @@
+"""显存预算（2026-10-18 本机实测后加）。
+用户定的预算：这台 3090 只有 19–20 GB 能给训练用——Windows + 4K 桌面常驻就占掉 4–5 GB（空载 nvidia-smi 4.4 GB）。
+  limit()     给本进程设硬帽（VRAM_FRAC，默认 0.78 ≈ 18.7 GiB）。超限时在自己的反向里早失败，
+              而不是把桌面挤到没有显存（整机卡顿、别的应用崩），这也是 APG batch=128 原先 OOM 时把显存顶到 23.6 GB 的原因。
+  peak_gib()  记进日志的 vram 字段：网页指标卡与 ml/selftest.sh 都按它核对预算，不用再去猜。
+实测参考（d=192 同结构、1 步即到位）：预训练 batch=1024 → 2.76；APG batch=48/plans=150 → 13.08、batch=128 → OOM。"""
+import os
+import torch
+
+
+def limit():
+    if not torch.cuda.is_available(): return False
+    f = float(os.environ.get('VRAM_FRAC', '0.78'))
+    tot = torch.cuda.get_device_properties(0).total_memory / 2**30
+    torch.cuda.set_per_process_memory_fraction(f)
+    print('显存上限：本进程 %.1f GiB（整卡 %.1f GiB × %.2f，其余留给桌面）' % (f * tot, tot, f), flush=True)
+    return True
+
+
+def peak_gib():
+    return round(torch.cuda.max_memory_allocated() / 2**30, 2) if torch.cuda.is_available() else None

ml/configs/apg.json

@@ -1,7 +1,9 @@
 {
   "apg": {
-    "batch": 128, "lr": 1e-4, "steps": 3000, "grad_clip": 1.0, "amp": "bf16",
+    "batch": 48, "lr": 1e-4, "steps": 8000, "grad_clip": 1.0, "amp": "bf16",
     "plans": 60, "plans_max": 150, "seg_plans": 10,
+    "_vram": "batch 由 128 降到 48：2026-10-18 本机实测（d=192 同结构、每进程 19.2 GB 硬帽）batch=128 无论 plans 取 60 还是 150 都 OOM（崩前已分配 17.85 GiB）；batch=48/plans=150 峰值 13.08 GiB、plans=60 为 7.67 GiB，加 Windows+4K 桌面常驻 4.4 GB 仍在 19–20 GB 预算内。batch=64/plans=150 要 17.66 GiB（不取）。展开长度 plans 没动——降 plans 会把长任务的绕出段截掉。",
+    "_steps": "2026-10-18 第八轮：batch 128→48 后 steps 3000→8000，保持总任务量（3000×128 ≈ 8000×48）不变；每步展开代价按 batch 线性降，总机时与原估同量级（约 4 h），学习率不动。",
     "margin_train_mm": 3.0,
     "w_tgt": 1.0, "w_rot": 0.3, "w_col": 2.0, "w_smooth": 0.02, "w_len": 0.001, "w_bc": 0.5,
     "cat_weights": {"A": 0.4, "B": 1.0, "C": 1.6, "D": 0.6, "Dr": 0.6},

ml/configs/smoke.json

@@ -31,5 +31,13 @@
   "log_every": 10,
   "patience_evals": 5
  },
- "_note": "冒烟专用（bash ml/smoke.sh）：只验证流程能跑通，数值无意义"
+ "apg": {
+  "batch": 8, "lr": 0.0001, "steps": 10, "grad_clip": 1.0, "amp": "bf16",
+  "plans": 20, "plans_max": 30, "seg_plans": 5,
+  "margin_train_mm": 3.0,
+  "w_tgt": 1.0, "w_rot": 0.3, "w_col": 2.0, "w_smooth": 0.02, "w_len": 0.001, "w_bc": 0.5,
+  "cat_weights": {"A": 0.4, "B": 1.0, "C": 1.6, "D": 0.6, "Dr": 0.6},
+  "ckpt_min": 10, "eval_every": 1000, "eval_tasks": 4
+ },
+ "_note": "冒烟与自检专用（bash ml/pipeline.sh selftest / smoke）：只验证流程能跑通，数值无意义。apg 段必须有：selftest.sh 第 6 项原先不带 --config，走的是正式 apg.json 的 batch=128，本机实测第一次反向就 OOM；改成正式值 48 也要约 13 GiB，自检不必吃这么多。"
 }

ml/eval/acceptance.py

@@ -62,8 +62,8 @@ def main():
     r4 = jload('ml/runs/r4.json')
     add('R4 浏览器推理 batch=8 P99（ms）', (r4 or {}).get('deploy', {}).get('p99') if r4 else 'missing', bool(r4 and r4.get('pass')), '< 15（随机初始化同结构模型实测）')
     r9 = jload('ml/runs/r9_browser.json'); rr = (r9 or {}).get('result') or {}
-    add('R9 查看器整次规划 P99（ms）/ 饥饿节拍占比', [rr.get('planP99'), rr.get('starve_rate')] if r9 else 'missing', bool(r9 and r9.get('pass')),
+    add('R9 查看器稳态规划 P99（ms）/ 运动中饥饿占比 / 认证超时占比', [rr.get('planWarmP99'), rr.get('starve_rate'), rr.get('cert_time_rate')] if r9 else 'missing', bool(r9 and r9.get('pass')),
-        '< 45 ms 且 < 1%（训练好的模型、30 道贴柱题，ml.eval.r4_probe --viewer）')
+        '< 45 ms、< 1%、< 5%（训练好的模型、30 道贴柱题，ml.eval.r4_probe --viewer；冷启动 P99 / 刹停率 / tickGapMax 见 r9_browser.json）')
     pb = jload('ml/runs/policy_bench.json')
     if pb is None:
         add('部署形态评测', 'missing', False, '先跑 bash ml/pipeline.sh bench')

ml/eval/check_r2.py

@@ -7,7 +7,7 @@
   改为按"近邻距离 → 标签差"做线性回归，取距离 → 0 的截距 label_std_norm 作判据（与池大小无关：池大只是近邻更近、点更多，
   截距估计的是"同一输入下的固有标签分歧"）；旧口径 label_std_mean 保留作参考。pipeline 默认只警告，R2_STRICT=1 才拦。
   自检（第七轮起每次自动做）：--pool 50000 与 4 倍池 200000 各测一次，label_std_norm 差 < 0.02 记 pool_check.independent=true。
-2026-10-18 新增（审查：R2 无执行点）。默认 5000 查询 × 50000 池，分块 256：GPU 峰值 < 0.5 GB，连同 4 倍池自检 CPU 约 5–10 分钟、GPU 约 1 分钟；近邻对为空时输出 pass=null 而不报错。"""
+2026-10-18 新增（审查：R2 无执行点）。默认 5000 查询 × 50000 池，分块 256：GPU 常驻约 1.6 GB（每样本 776 B × 1.7 M + 分块，第八轮按本机实测改），连同 4 倍池自检 CPU 约 5–10 分钟、GPU 约 1 分钟；近邻对为空时输出 pass=null 而不报错。"""
 import argparse, json, math
 import torch
 

ml/eval/r4_probe.py

@@ -21,12 +21,19 @@ import argparse, http.server, json, os, shutil, socket, subprocess, sys, tempfil
 ROOT = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 LIMIT_MS = 15.0
 PLAN_LIMIT_MS = 45.0      # R9：整次规划 P99（60 ms 周期留 15 ms 给渲染与 tick）
-STARVE_LIMIT = 0.01       # R9：饥饿节拍占比上限
+STARVE_LIMIT = 0.01       # R9：饥饿节拍占比上限（只计运动中，冷启动不计）
+TIME_LIMIT = 0.05         # R9：认证因墙钟截止判不过的占比上限——防止靠拒绝候选、刹停换来 planP99 达标（第八轮，viewer_ref 随机模型 time 占失败 70%）
+# 2026-10-18 第八轮：R9 判稳态 planWarmP99（剔除每题首次冷启动规划）。冷启动发生在静止起步，只是起步延迟，单独报 planColdP99 不设闸；
+# 否则 30 题 = 30 次冷启动，planP99 测的是题数而不是稳态。
 
 
 def ort_local():
-    if os.environ.get('ORT_LOCAL') in ('0', '1'): return os.environ['ORT_LOCAL'] == '1'
+    # 2026-10-18 第八轮：ort 已入库（webapp/vendor/ort），默认只用本地；本地缺失直接报错，不再静默退回 CDN
-    return os.path.exists(os.path.join(ROOT, 'webapp', 'vendor', 'ort', 'ort.min.js'))
+    # （第七轮本机：npm pack 失败 → 退回 CDN → jsDelivr 不通 → 四种配置全是「加载 ort 失败」却显示跑完）。确要用 CDN 设 ORT_LOCAL=0。
+    if os.environ.get('ORT_LOCAL') == '0': return False
+    if not os.path.exists(os.path.join(ROOT, 'webapp', 'vendor', 'ort', 'ort.min.js')):
+        sys.exit('webapp/vendor/ort/ort.min.js 不存在：git pull 拿入库的 ort，或 bash ml/prep/vendor_ort.sh；确要用 CDN 设 ORT_LOCAL=0')
+    return True
 
 
 def find_browser():
@@ -105,7 +112,10 @@ def viewer(srv, browser, model_url, n, probe):
     if r.get('planP99') is not None:
         sr = (r.get('starve') or 0) / max(1, r.get('ticks') or 1)
         r['starve_rate'] = round(sr, 4)
-        r['r9_pass'] = r['planP99'] < PLAN_LIMIT_MS and sr < STARVE_LIMIT
+        pl = max(1, r.get('plans') or 1); why = r.get('certFailWhy') or {}
+        r['cert_time_rate'] = round((why.get('time') or 0) / pl, 4); r['brake_rate'] = round((r.get('brakes') or 0) / pl, 4)
+        w = r.get('planWarmP99') if r.get('planWarmP99') is not None else r['planP99']
+        r['r9_pass'] = w < PLAN_LIMIT_MS and sr < STARVE_LIMIT and r['cert_time_rate'] < TIME_LIMIT
     print('viewer', json.dumps({k: v for k, v in r.items() if k != 'per'}, ensure_ascii=False), flush=True)
     return r
 
@@ -152,7 +162,7 @@ def main():
 
 def main_viewer(a):
     meta = json.load(open(a.model.replace('.onnx', '.meta.json'), encoding='utf-8'))
-    out = {'rule': f'R9：查看器整次规划 planMs P99 < {PLAN_LIMIT_MS:g} ms 且饥饿节拍 < {STARVE_LIMIT:.0%}', 'model': a.model, 'pass': None}
+    out = {'rule': f'R9：查看器稳态规划 planWarmP99 < {PLAN_LIMIT_MS:g} ms、运动中饥饿节拍 < {STARVE_LIMIT:.0%}、认证超时占比 < {TIME_LIMIT:.0%}（planColdP99 / brake_rate / tickGapMax 只报不判）', 'model': a.model, 'pass': None}
     br = find_browser()
     if not br: out['note'] = '没找到 Edge / Chrome（可设 R4_BROWSER=浏览器路径）'
     else:
@@ -164,7 +174,7 @@ def main_viewer(a):
     os.makedirs(os.path.dirname(a.out) or '.', exist_ok=True)
     json.dump(out, open(a.out, 'w', encoding='utf-8'), indent=1, ensure_ascii=False)
     r = out.get('result') or {}
-    print(f"R9：{ {True: '通过', False: '未通过', None: '未判定'}[out['pass']] }  planMs P99 {r.get('planP99')} ms（推理 {r.get('inferP99')} / 安全层 {r.get('safetyP99')}），饥饿 {r.get('starve_rate')}")
+    print(f"R9：{ {True: '通过', False: '未通过', None: '未判定'}[out['pass']] }  稳态 planMs P99 {r.get('planWarmP99')} ms（冷启动 {r.get('planColdP99')}；推理 {r.get('inferP99')} / 安全层 {r.get('safetyP99')}），饥饿 {r.get('starve_rate')}，认证超时 {r.get('cert_time_rate')}，刹停 {r.get('brake_rate')}，tickGapMax {r.get('tickGapMax')}")
 
 
 if __name__ == '__main__':

ml/monitor.html

@@ -3,7 +3,7 @@
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1">
-<title>训练监控 · 机械臂避障策略</title>
+<title>Transformer 多峰策略端到端训练与浏览器部署 · 训练监控</title>
 <style>
   :root {
     --bg: #0b0f17; --bg2: #0f1521; --panel: #131a27; --panel2: #18212f; --line: #222c3c; --line2: #2c3850;
@@ -153,7 +153,7 @@
 <header>
   <div class="brand">
     <div class="logo"><svg viewBox="0 0 24 24" fill="none" stroke="#fff" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M4 20h6"/><path d="M7 20v-5l5-6"/><path d="M12 9l5 2"/><circle cx="12" cy="9" r="1.6"/><path d="M17 11l2-3"/></svg></div>
-    <div><h1>训练监控</h1><div class="sub">机械臂避障策略 · Transformer</div></div>
+    <div><h1>Transformer 多峰策略端到端训练与浏览器部署</h1><div class="sub">机械臂避障策略 · 训练监控</div></div>
   </div>
   <select id="run" title="选择运行（ml/runs/*）"></select>
   <select id="scenario" title="示例场景" style="display:none"><option value="train">示例：预训练进行中</option><option value="gen">示例：生成数据中</option><option value="late">示例：挖错第 3 轮</option><option value="idle">示例：还没开始</option></select>
@@ -436,6 +436,7 @@ function renderKpis() {
     tile('展开内到达比例', pct(r.reach_frac), '误差 < 1 mm 且姿态 < 0.5°', '', last('reach_frac'), COLORS[2]);
     tile('闭环到达率', pct(e.success) + dlt('success'), `最好 ${pct(best)}`, '', evs('success'), COLORS[2]);
     tile('碰撞率', pct(e.collision_rate, 2) + dlt('collision_rate', -1), '关安全层', e.collision_rate > 0.03 ? 'warn' : '', evs('collision_rate'), COLORS[3]);
+    tile('显存峰值', isNum(r.vram) ? `${r.vram.toFixed(2)}<small>GiB</small>` : '—', '预算 19–20 GB（整卡 24，桌面占 4–5）', r.vram > 17 ? 'bad' : r.vram > 14 ? 'warn' : '', last('vram'), COLORS[1]);
   } else {
     const sps = r.samples_per_s;
     tile('总损失', fmt(r.loss, 4), `MF ${fmt(r.mf)} · FK ${fmt(r.fk_cm)} cm`, '', ema(last('loss'), 0.9), COLORS[0]);
@@ -443,6 +444,7 @@ function renderKpis() {
     tile('闭环到达率', pct(e.success) + dlt('success'), evals.length ? `最好 ${pct(best)} · @${e.x.toLocaleString()} 步` : '尚未评估', '', evs('success'), COLORS[2]);
     tile('碰撞率', pct(e.collision_rate, 2) + dlt('collision_rate', -1), '关安全层，部署另有护栏', e.collision_rate > 0.03 ? 'warn' : '', evs('collision_rate'), COLORS[3]);
     tile('梯度范数', fmt(r.gnorm), '裁剪阈值 1.0', r.gnorm > 5 ? 'warn' : '', ema(last('gnorm'), 0.9), COLORS[4]);
+    tile('显存峰值', isNum(r.vram) ? `${r.vram.toFixed(2)}<small>GiB</small>` : '—', '预算 19–20 GB（整卡 24，桌面占 4–5）', r.vram > 17 ? 'bad' : r.vram > 14 ? 'warn' : '', last('vram'), COLORS[1]);
   }
   $('kpis').innerHTML = tiles.map(t => t.html).join('');
   [...$('kpis').querySelectorAll('canvas')].forEach((cv, i) => spark(cv, tiles[i].sp, tiles[i].color));
@@ -477,7 +479,7 @@ async function poll() {
       render();
     }
     const P = lastStatus.pipeline, busy = (job && job.running) || (P && P.current);
-    if (DEMO) { setPill('demo', '示例数据'); if (!$('demobar')) $('pipe').insertAdjacentHTML('beforebegin', `<div class="demobar" id="demobar">这是示例数据，不是你的训练。${location.protocol === 'file:' ? '直接双击 monitor.html 只能看示例；' : ''}看真实训练请双击 ml/console.bat（或 python -m ml.monitor --open）。</div>`); }
+    if (DEMO) { setPill('demo', '示例数据'); if (!$('demobar')) $('pipe').closest('.hero').insertAdjacentHTML('beforebegin', `<div class="demobar" id="demobar">这是示例数据，不是你的训练。${location.protocol === 'file:' ? '直接双击 monitor.html 只能看示例；' : ''}看真实训练请双击 ml/console.bat（或 python -m ml.monitor --open）。</div>`); }
     else if (busy) setPill('live', `运行中 · ${P && P.current ? SM[P.current]?.n || P.current : '启动中'}`);
     else if (cur && Date.now() / 1000 - lastMtime < 120) setPill('live', `运行中 · ${ago(lastMtime)}更新`);
     else setPill('', '空闲');
@@ -531,15 +533,16 @@ function renderStatus(s) {
 
   // GPU
   const G = s.gpu || [];
+  const BUD = (s.vram_budget_gb || 24) * 1024;      // 显存预算（MB）：桌面常驻占 4–5 GB，不能按整卡 24 GB 看
   $('gputime').textContent = G.length ? '实时' : '';
   $('gpu').innerHTML = G.length ? G.map(g => {
     const u = g.util ?? 0, C = 2 * Math.PI * 50, col = u > 85 ? css('--ok') : u > 50 ? css('--accent') : css('--warn');
-    const memP = 100 * g.mem_used / g.mem_total, tc = g.temp > 83 ? css('--bad') : g.temp > 75 ? css('--warn') : css('--c6');
+    const memP = 100 * g.mem_used / BUD, tc = g.temp > 83 ? css('--bad') : g.temp > 75 ? css('--warn') : css('--c6');
     const row = (k, v, p, c) => `<div class="gr"><div class="l"><span>${k}</span><b>${v}</b></div><div class="mini"><div style="width:${Math.min(100, p)}%;background:${c}"></div></div></div>`;
     return `<div class="gpuwrap"><div class="ring"><svg width="116" height="116"><circle cx="58" cy="58" r="50" stroke="#1b2433" stroke-width="10" fill="none"/>
       <circle cx="58" cy="58" r="50" stroke="${col}" stroke-width="10" fill="none" stroke-linecap="round" stroke-dasharray="${C}" stroke-dashoffset="${C * (1 - u / 100)}" style="transition:stroke-dashoffset .6s"/></svg>
       <div class="c"><div><b>${u}%</b><span>利用率</span></div></div></div>
-      <div class="gpurows">${row('显存', `${(g.mem_used / 1024).toFixed(1)} / ${(g.mem_total / 1024).toFixed(0)} GB`, memP, css('--accent2'))}
+      <div class="gpurows">${row('显存', `${(g.mem_used / 1024).toFixed(1)} / ${(BUD / 1024).toFixed(0)} GB 预算（整卡 ${(g.mem_total / 1024).toFixed(0)}）`, memP, memP > 100 ? css('--bad') : memP > 85 ? css('--warn') : css('--accent2'))}
       ${row('温度', `${g.temp} °C`, g.temp, tc)}${row('功耗', g.power != null ? `${Math.round(g.power)} W` : '—', g.power ? g.power / 3.5 : 0, css('--c7'))}</div></div>
       <div class="gname">${g.name}</div>`;
   }).join('<hr style="border:none;border-top:1px solid var(--line);margin:14px 0">') : empty('未检测到 nvidia-smi');

ml/monitor.py

@@ -192,7 +192,9 @@ def status():
     pb = jload(P(RUNS, 'policy_bench.json'))
     if pb: pb = {k: {kk: v.get(kk) for kk in ('n', 'ok', 'reached', 'collisionFrames', 'brakeRate', 'recoveryRate', 'livelock', 'inferMsP99', 'safetyMsP99')}
                  for k, v in pb.items() if isinstance(v, dict) and 'n' in v}
-    return {'now': time.time(), 'gpu': gpu(), 'pipeline': pl, 'check': CHECK.get(), 'lock': lock_info(),
+    return {'now': time.time(), 'gpu': gpu(),
+            'vram_budget_gb': float(os.environ.get('VRAM_BUDGET_GB', 20)),      # 本机桌面常驻占 4–5 GB，给训练的预算 19–20 GB
+            'pipeline': pl, 'check': CHECK.get(), 'lock': lock_info(),   # 2026-10-18 第八轮修：上一版这三项被行尾注释吞掉，网页步骤条/锁状态拿不到
             'stage_meta': [{'id': k, 'name': n, 'est_h': h, 'timeout_h': pstate.TIMEOUT_H[k]} for k, n, h in pstate.STAGES],
             'r4': jload(P(RUNS, 'r4.json')),
             'data': {'consistency': (jload(P(DATA, 'consistency.json')) or {}).get('consistentByGateRule'),
@@ -218,8 +220,13 @@ def find_bash():
             if p and os.path.exists(p): return p
         g = shutil.which('git')
         if g:
-            p = os.path.join(os.path.dirname(os.path.dirname(g)), 'bin', 'bash.exe')
+            root = os.path.dirname(os.path.dirname(g))       # 便携版 git 常放在 <根>\mingw64\bin\git.exe，要再上一层才找到 bash
+            for base in dict.fromkeys([root, os.path.dirname(root)]):
+                for sub in ('bin', os.path.join('usr', 'bin')):
+                    p = os.path.join(base, sub, 'bash.exe')
                     if os.path.exists(p): return p
+        b = shutil.which('bash')
+        if b and 'windows\\system32' not in b.lower(): return b
         return None
     return shutil.which('bash')
 

ml/pipeline.sh

@@ -110,7 +110,7 @@ case $stage in
   kin)    run node ml/prep/export_kin.cjs; run node ml/eval/dump_parity.cjs 2000; run $PY -m ml.eval.check_parity ;;
   r4)     # 浏览器推理延迟（方案 R4）：随机初始化模型导出到独立文件（不碰 webapp/models，审查 N-5），无头浏览器自动测
           mkdir -p ml/runs/r4
-          bash ml/prep/vendor_ort.sh || echo "本地 ort 没放好（npm 不通？），探针改用 CDN"
+          [ -f webapp/vendor/ort/ort.min.js ] || [ "${ORT_LOCAL:-1}" = 0 ] || { echo "webapp/vendor/ort 缺失（ort 已入库，先 git pull）；确要用 CDN 设 ORT_LOCAL=0"; exit 3; }   # 第八轮：不再静默退回 CDN
           run $PY -m ml.export_onnx --random $CFG --out ml/runs/r4/traj_policy_r4.onnx
           run $PY -m ml.eval.r4_probe --model ml/runs/r4/traj_policy_r4.onnx --out ml/runs/r4.json ${R4_ARGS:-}
           r=$($PY -c "import json;p=json.load(open('ml/runs/r4.json', encoding='utf-8')).get('pass');print({True:'pass',False:'fail'}.get(p,'null'))")

ml/selftest.sh

@@ -13,18 +13,26 @@ cd "$(dirname "$0")/.."
 SRC=$(pwd); PY=${PYTHON:-python}; export PYTHONUTF8=1
 D=${SELFTEST_DIR:-$(dirname "$SRC")/$(basename "$SRC")_selftest}
 rm -rf "$D"; mkdir -p "$D"
-git ls-files -z | tar --null -T - -cf - | (cd "$D" && tar xf -)
+# 第八轮：连同未跟踪的新文件一起复制（本机实测：新加 vram.py 未 add 时三项假失败）
+git ls-files -z -co --exclude-standard | tar --null -T - -cf - | (cd "$D" && tar xf -)
 [ -d ml/node_modules ] && cp -r ml/node_modules "$D/ml/node_modules"
 cd "$D"; mkdir -p ml/runs ml/data
 R=ml/runs/selftest_items.jsonl; : > $R
-rec() { $PY -c "import json,sys;print(json.dumps({'item':sys.argv[1],'pass':json.loads(sys.argv[2]),'detail':sys.argv[3]},ensure_ascii=False))" "$1" "$2" "$3" >> $R; echo "[selftest] $1 → $2  $3"; }
+rec() { $PY -c "import json,sys
+try: v=json.loads(sys.argv[2])
+except Exception: v=False      # 值不是合法 JSON 时记 false，不能让整项静默消失（第七轮实测：'none' 抛异常 → 两项没进结果）
+print(json.dumps({'item':sys.argv[1],'pass':v,'detail':sys.argv[3]},ensure_ascii=False))" "$1" "$2" "$3" >> $R; echo "[selftest] $1 → $2  $3"; }
 CFGS=ml/configs/smoke.json
 # 1 生成续写
 node ml/gen/gen_dataset.cjs --n 6 --seed 11 --out ml/data/a.jsonl 2>/dev/null
 node ml/gen/gen_dataset.cjs --n 3 --seed 11 --out ml/data/shard_0011.jsonl.part 2>/dev/null
 sz=$(wc -c < ml/data/shard_0011.jsonl.part); head -c $((sz - 40)) ml/data/shard_0011.jsonl.part > t && mv t ml/data/shard_0011.jsonl.part
 node ml/gen/gen_dataset.cjs --n 6 --seed 11 --out ml/data/shard_0011.jsonl.part 2>ml/runs/st_gen.log; mv ml/data/shard_0011.jsonl.part ml/data/shard_0011.jsonl
-cmp -s ml/data/a.jsonl ml/data/shard_0011.jsonl && rec gen_resume true "$(grep -o '续写[^,]*' ml/runs/st_gen.log | head -1)" || rec gen_resume false "续写结果与一口气生成不同"
+gd=$($PY -c "import json,sys
+f=lambda p:[json.dumps({**r,'plan_ms':0,'cert':{**r.get('cert',{}),'ms':0}},sort_keys=True) for r in (json.loads(l) for l in open(p,encoding='utf-8') if l.strip())]
+a,b=f(sys.argv[1]),f(sys.argv[2]);print('OK' if a==b else '不同 %d/%d 条'%(sum(x!=y for x,y in zip(a,b))+abs(len(a)-len(b)),max(len(a),len(b))))" ml/data/a.jsonl ml/data/shard_0011.jsonl)
+if [ "$gd" = OK ]; then rec gen_resume true "$(grep -o '续写[^,]*' ml/runs/st_gen.log | head -1)（逐条一致；不含 plan_ms/cert.ms 两个墙钟字段，第七轮实测 cmp -s 恒不等）"
+else rec gen_resume false "续写与一口气生成不同：$gd"; fi
 rm -f ml/data/a.jsonl
 node ml/gen/gen_dataset.cjs --n 40 --seed 12 --out ml/data/shard_0012.jsonl 2>/dev/null   # 训练自检用的小数据
 # 2 打包二次运行
@@ -49,13 +57,16 @@ if command -v timeout >/dev/null; then
   grep -q "收到停止请求" ml/runs/st_c.log && rec train_term true "rc=$rc，TERM 送达并存档" || rec train_term false "rc=$rc，TERM 没送到 python（Windows 原生进程常见）→ 阶段超时只能硬杀，进度靠每 10 分钟存档"
 else rec train_term false "没有 timeout 命令"; fi
 # 6 APG 续跑
-$PY -m ml.apg.apg_finetune --init ml/runs/st_a/last.pt --samples ml/data/samples --out ml/runs/st_apg --steps 10 --stop-at 5 > ml/runs/st_apg.log 2>&1; rc=$?
+$PY -m ml.apg.apg_finetune --config $CFGS --init ml/runs/st_a/last.pt --samples ml/data/samples --out ml/runs/st_apg --steps 10 --stop-at 5 > ml/runs/st_apg.log 2>&1; rc=$?
-$PY -m ml.apg.apg_finetune --init ml/runs/st_a/last.pt --samples ml/data/samples --out ml/runs/st_apg --steps 10 --resume ml/runs/st_apg/last.pt >> ml/runs/st_apg.log 2>&1; rc2=$?
+$PY -m ml.apg.apg_finetune --config $CFGS --init ml/runs/st_a/last.pt --samples ml/data/samples --out ml/runs/st_apg --steps 10 --resume ml/runs/st_apg/last.pt >> ml/runs/st_apg.log 2>&1; rc2=$?
 [ $rc = 143 ] && [ $rc2 = 0 ] && rec apg_resume true "" || rec apg_resume false "rc=$rc 续跑rc=$rc2（日志 $D/ml/runs/st_apg.log）"
 # 7 进程树 / 关窗口
 pj=$($PY ml/selftest_proc.py 2>ml/runs/st_proc.err | tail -1)
 echo "$pj" > ml/runs/st_proc.json
-k=$($PY -c "import json,sys;d=json.loads(sys.argv[1]);print(str(d.get('tree_killed')).lower(), str(d.get('survive_parent_exit')).lower())" "$pj" 2>/dev/null || echo "null null")
+k=$($PY -c "import json,sys
+try: d=json.loads(sys.argv[1])
+except Exception: d={}
+print(json.dumps(d.get('tree_killed')), json.dumps(d.get('survive_parent_exit')))" "$pj" 2>/dev/null || echo "null null")
 rec tree_killed ${k% *} "$pj" ; rec survive_parent_exit ${k#* } ""
 mkdir -p "$SRC/ml/runs"
 $PY - "$R" "$SRC/ml/runs/selftest.json" "$D" <<'PY'

ml/selftest_proc.py

@@ -14,8 +14,9 @@ FLAGS = {'creationflags': subprocess.CREATE_NEW_PROCESS_GROUP | 0x08000000} if o
 
 def alive(pid):
     if os.name == 'nt':
-        r = subprocess.run(['tasklist', '/FI', f'PID eq {pid}', '/NH'], capture_output=True, text=True)
+        # 中文 Windows 的 tasklist 表头是 GBK，text=True 会让读线程解码崩掉（stdout 变 None）→ 按字节读再容错解码
-        return str(pid) in r.stdout
+        r = subprocess.run(['tasklist', '/FI', f'PID eq {pid}', '/NH'], capture_output=True, text=True, errors='replace')
+        return str(pid) in (r.stdout or '')
     try: os.kill(pid, 0); return True
     except OSError: return False
 
@@ -26,11 +27,14 @@ def tree_cmd(d):
             f'node -e "require(\'fs\').writeFileSync(\'{dd}/n.pid\',String(process.pid));setInterval(()=>{{}},1000)" & wait')
 
 
+WAITERR = ['']
+
+
 def wait_pids(d, t=20):
     for _ in range(t * 4):
         try: return int(open(os.path.join(d, 'p.pid')).read()), int(open(os.path.join(d, 'n.pid')).read())
-        except Exception: time.sleep(0.25)
+        except Exception as e: WAITERR[0] = type(e).__name__ + ': ' + str(e)[:90]; time.sleep(0.25)
-    return None, None
+    return None, None      # 起不来时把最后一次异常带进结果，别让 tree_started=false 变成没有原因的失败
 
 
 def main():

ml/train.py

@@ -9,6 +9,7 @@ import torch
 from ml.common.kin_torch import Kin
 from ml.common.features import STEP, D2R
 from ml.common.ckpt import Saver, atomic_save, rng_state, set_rng_state
+from ml.common import vram
 from ml.data import Samples, load_tasks
 from ml.model.policy import build, wta_loss
 from ml.model.meanflow import meanflow_loss, one_step
@@ -40,6 +41,7 @@ def main():
     os.makedirs(a.out, exist_ok=True)
     torch.manual_seed(a.seed)
     dev = a.device
+    vram.limit()
     kin = Kin(device=dev)
     data = Samples(a.samples, device=dev, split='train')
     val_tasks = [t for t in load_tasks(a.samples) if t['split'] == 'val'][:tc['eval_tasks']]
@@ -111,7 +113,7 @@ def main():
             el = time.time() - t0
             rec = {'step': step, 'total': total, 't': time.time(), 'loss': loss.item(), 'mf': mf_raw.item(), 'fk_cm': l_fk.item(), 'smooth': l_sm.item(),
                    'value': l_val.item(), 'sub': l_sub.item(), 'gnorm': gn.item(), 'lr': lr_at(step), 'samples_per_s': seen / max(el, 1e-6),
-                   'eta_h': (total - step - 1) * tc['batch'] / max(seen / max(el, 1e-6), 1e-6) / 3600}
+                   'eta_h': (total - step - 1) * tc['batch'] / max(seen / max(el, 1e-6), 1e-6) / 3600, 'vram': vram.peak_gib()}
             print(json.dumps(rec), flush=True); log.write(json.dumps(rec) + '\n'); log.flush()
         if not a.no_eval and (step + 1) % tc['eval_every'] == 0:
             model.eval()

tests/policy_bench.cjs

@@ -67,7 +67,7 @@ const pct = (a, p) => { if (!a.length) return null; const s = a.slice().sort((x,
   const out = { model: MODEL, meta: { fp: meta.fp, eval: meta.eval } };
   const runSet = async (name, cases, mode) => {
     let ok = 0, reached = 0, colTasks = 0, colFrames = 0, uncert = 0, brakes = 0, locks = 0, plans = 0, recovered = 0, lockTasks = 0, livelock = 0;
-    const inf = [], saf = [], look = [], planT = [], cq = [], times = [], fails = []; let hits = 0; const why = {};
+    const inf = [], saf = [], look = [], planT = [], planW = [], cq = [], times = [], fails = []; let hits = 0; const why = {};
     for (let ci = 0; ci < cases.length; ci++) {
       const c = cases[ci];
       const R = mode === 'pose' ? c.R : null;
@@ -86,7 +86,7 @@ const pct = (a, p) => { if (!a.length) return null; const s = a.slice().sort((x,
       const { e, oe } = r.err(r.q);
       const rc = r.done && e < 1 && oe < 0.5;
       if (rc) reached++; if (cf) { colTasks++; colFrames += cf; } if (rc && !cf) { ok++; times.push(r.t); } else fails.push({ ci, err: +e.toFixed(1), oerr: +oe.toFixed(1), colFrames: cf, brakes: r.stats.brakes });
-      inf.push(...r.stats.inferMs); saf.push(...r.stats.safetyMs); look.push(...r.stats.lookaheadMs); planT.push(...r.stats.planMs); cq.push(...r.stats.certQ); hits += r.stats.certHit;
+      inf.push(...r.stats.inferMs); saf.push(...r.stats.safetyMs); look.push(...r.stats.lookaheadMs); planT.push(...r.stats.planMs); planW.push(...r.stats.planWarmMs); cq.push(...r.stats.certQ); hits += r.stats.certHit;
       for (const k in r.stats.certWhy) why[k] = (why[k] || 0) + r.stats.certWhy[k]; brakes += r.stats.brakes; locks += r.stats.locks; plans += r.stats.plans;
       if (tLock != null) { lockTasks++; if (rc && !cf && r.t - tLock <= 3.0) recovered++; } else if (rc && !cf) recovered++;
       if (!rc && r.stats.locks >= 2) livelock++;
@@ -96,7 +96,7 @@ const pct = (a, p) => { if (!a.length) return null; const s = a.slice().sort((x,
       plans, brakeRate: plans ? +(brakes / plans).toFixed(4) : null, lockTasks, recovered3s: recovered, recoveryRate: cases.length ? +(recovered / cases.length).toFixed(4) : null, livelock,
       timeP50: pct(times, 0.5), inferMsP50: pct(inf, 0.5), inferMsP99: pct(inf, 0.99), safetyMsP50: pct(saf, 0.5), safetyMsP99: pct(saf, 0.99),
       // 2026-10-18 第六轮（审查 B-1/B-2）：前瞻、整次规划耗时，每次规划的距离查询数与记忆命中率，认证失败原因——与查看器 autotest 同口径对照
-      lookaheadMsP99: pct(look, 0.99), planMsP50: pct(planT, 0.5), planMsP99: pct(planT, 0.99), certQueriesP50: pct(cq, 0.5), certQueriesP99: pct(cq, 0.99),
+      lookaheadMsP99: pct(look, 0.99), planMsP50: pct(planT, 0.5), planMsP99: pct(planT, 0.99), planWarmMsP99: pct(planW, 0.99), certQueriesP50: pct(cq, 0.5), certQueriesP99: pct(cq, 0.99),
       certMemoHitRate: (() => { const q = cq.reduce((a, b) => a + b, 0); return q + hits ? +(hits / (q + hits)).toFixed(3) : null; })(), certFailWhy: why, fails: fails.slice(0, 15) };
     console.error(name, JSON.stringify({ ok, n: cases.length, collisionFrames: colFrames }));
   };

webapp/js/ik-policy-glue.js

@@ -72,7 +72,7 @@ async function boot() {
       latency: () => { const p = (a, x) => { const s = a.slice().sort((u, v) => u - v); return s.length ? s[Math.min(s.length - 1, Math.floor(s.length * x))] : null; };
         const st = runner.stats;
         return { inferP50: p(st.inferMs, .5), inferP99: p(st.inferMs, .99), safetyP50: p(st.safetyMs, .5), safetyP99: p(st.safetyMs, .99),
-          lookaheadP99: p(st.lookaheadMs, .99), planP50: p(st.planMs, .5), planP99: p(st.planMs, .99), certQP99: p(st.certQ, .99),
+          lookaheadP99: p(st.lookaheadMs, .99), planP50: p(st.planMs, .5), planP99: p(st.planMs, .99), planWarmP99: p(st.planWarmMs, .99), planColdP99: p(st.planColdMs, .99), coldPlans: st.planColdMs.length, certQP99: p(st.certQ, .99),
           tickGapP99: p(TICKS.gaps, .99), tickGapMax: TICKS.gaps.length ? Math.max(...TICKS.gaps) : null, starve: TICKS.starve, ticks: TICKS.n,
           threads: ort.env.wasm.numThreads, ep: ep[0], proxy, encOnce: !!meta.enc_once, featDyn: !!meta.feat_dyn, probe }; }
     };
@@ -118,7 +118,8 @@ function onTick() {
   if (!running) return;
   const tn = performance.now(); if (TICKS.last) TICKS.gaps.push(tn - TICKS.last); TICKS.last = tn; TICKS.n++;
   if (TICKS.gaps.length > 20000) TICKS.gaps.splice(0, 10000);
-  if (!runner.queue.length && !runner.done && runner.goal) TICKS.starve++;
+  /* 第八轮：冷启动（静止起步、首次规划含前瞻）时队列本就为空、机械臂没在动，不算丢步；只统计运动中断粮 */
+  if (!runner.queue.length && !runner.done && runner.goal && !runner.cold) TICKS.starve++;
   if (runner.needPlan()) runner.plan().catch(e => { console.error(e); stop(); say('策略推理出错：' + e.message, 'badb'); });
   const q = runner.tick();
   if (q) window.IK.setJoints(q, false);

webapp/js/ik-policy.js

@@ -184,7 +184,7 @@ class Runner {
     this.rng = makeRng(this.o.seed);
     /* 2026-10-18 第六轮（审查 B-1/B-2）：耗时拆开记——inferMs 主推理、lookaheadMs 前瞻（第二次推理 + 8 份特征）、safetyMs 只含认证、
        planMs 整次规划（R9 口径：必须 < 60 ms 周期）；certQ 每次规划新增的距离查询数，certHit 记忆命中数，certWhy 认证失败原因计数 */
-    this.stats = { plans: 0, inferMs: [], lookaheadMs: [], safetyMs: [], planMs: [], certQ: [], certHit: 0, certWhy: {}, brakes: 0, refine: 0, lookahead: 0, locks: 0, projected: 0 };
+    this.stats = { plans: 0, inferMs: [], lookaheadMs: [], safetyMs: [], planMs: [], planWarmMs: [], planColdMs: [], certQ: [], certHit: 0, certWhy: {}, brakes: 0, refine: 0, lookahead: 0, locks: 0, projected: 0 };
     this.reset(null);
   }
   reset(q0) {
@@ -238,11 +238,11 @@ class Runner {
   async plan() {
     if (!this.needPlan()) return;
     this.planning = true;
-    const t = now(), c0 = this.cert.counters();
+    const t = now(), c0 = this.cert.counters(), wasCold = this.cold;   // 第八轮：冷启动（含前瞻）与稳态分开记，R9 判稳态
     try { await this._plan(); } finally {
       this.planning = false; this._until = undefined;
       const c1 = this.cert.counters();
-      this.stats.planMs.push(now() - t); this.stats.certQ.push(c1.queries - c0.queries); this.stats.certHit += c1.hits - c0.hits;
+      const dt = now() - t; this.stats.planMs.push(dt); (wasCold ? this.stats.planColdMs : this.stats.planWarmMs).push(dt); this.stats.certQ.push(c1.queries - c0.queries); this.stats.certHit += c1.hits - c0.hits;
     }
   }
   async _plan() {

webapp/vendor/ort/VERSION

@@ -0,0 +1 @@
+1.20.1

webapp/vendor/ort/ort-wasm-simd-threaded.jsep.mjs

@@ -0,0 +1,130 @@
+
+var ortWasmThreaded = (() => {
+  var _scriptName = import.meta.url;
+  
+  return (
+async function(moduleArg = {}) {
+  var moduleRtn;
+
+function e(){l.buffer!=q.buffer&&t();return q}function w(){l.buffer!=q.buffer&&t();return ba}function ca(){l.buffer!=q.buffer&&t();return da}function ea(){l.buffer!=q.buffer&&t();return fa}function z(){l.buffer!=q.buffer&&t();return ha}function A(){l.buffer!=q.buffer&&t();return ia}function ja(){l.buffer!=q.buffer&&t();return ka}function la(){l.buffer!=q.buffer&&t();return ma}
+var B=Object.assign({},moduleArg),na,oa,pa=new Promise((a,b)=>{na=a;oa=b}),qa="object"==typeof window,C="function"==typeof importScripts,D="object"==typeof process&&"object"==typeof process.versions&&"string"==typeof process.versions.node,E=C&&"em-pthread"==self.name;if(D){const {createRequire:a}=await import("module");var require=a(import.meta.url),ra=require("worker_threads");global.Worker=ra.Worker;E=(C=!ra.pc)&&"em-pthread"==ra.workerData}"use strict";
+B.mountExternalData=(a,b)=>{a.startsWith("./")&&(a=a.substring(2));(B.Fb||(B.Fb=new Map)).set(a,b)};B.unmountExternalData=()=>{delete B.Fb};var SharedArrayBuffer=globalThis.SharedArrayBuffer??(new WebAssembly.Memory({initial:0,maximum:0,shared:!0})).buffer.constructor;"use strict";
+let ta=()=>{const a=(c,d,f)=>(...g)=>{const k=F,m=d?.();g=c(...g);const p=d?.();m!==p&&(c=p,f(m),d=f=null);return F!=k?sa():g},b=c=>async(...d)=>{try{if(B.Eb)throw Error("Session already started");const f=B.Eb={fc:d[0],errors:[]},g=await c(...d);if(B.Eb!==f)throw Error("Session mismatch");B.Gb?.flush();const k=f.errors;if(0<k.length){let m=await Promise.all(k);m=m.filter(p=>p);if(0<m.length)throw Error(m.join("\n"));}return g}finally{B.Eb=null}};B._OrtCreateSession=a(B._OrtCreateSession,()=>B._OrtCreateSession,
+c=>B._OrtCreateSession=c);B._OrtRun=b(a(B._OrtRun,()=>B._OrtRun,c=>B._OrtRun=c));B._OrtRunWithBinding=b(a(B._OrtRunWithBinding,()=>B._OrtRunWithBinding,c=>B._OrtRunWithBinding=c));B._OrtBindInput=a(B._OrtBindInput,()=>B._OrtBindInput,c=>B._OrtBindInput=c);ta=void 0};
+B.jsepInit=(a,b)=>{ta?.();if("webgpu"===a){[B.Gb,B.Ub,B.Yb,B.Nb,B.Xb,B.jb,B.Zb,B.bc,B.Vb,B.Wb,B.$b]=b;const c=B.Gb;B.jsepRegisterBuffer=(d,f,g,k)=>c.registerBuffer(d,f,g,k);B.jsepGetBuffer=d=>c.getBuffer(d);B.jsepCreateDownloader=(d,f,g)=>c.createDownloader(d,f,g);B.jsepOnReleaseSession=d=>{c.onReleaseSession(d)};B.jsepOnRunStart=d=>c.onRunStart(d);B.cc=(d,f)=>{c.upload(d,f)}}else if("webnn"===a){[B.Gb,B.ac,B.Ob,B.jsepEnsureTensor,B.dc,B.jsepDownloadTensor]=b;B.jsepReleaseTensorId=B.Ob;const c=B.Gb;
+B.jsepOnRunStart=d=>c.onRunStart(d);B.jsepRegisterMLContext=(d,f)=>{c.registerMLContext(d,f)};B.jsepOnReleaseSession=d=>{c.onReleaseSession(d)};B.jsepCreateMLTensorDownloader=(d,f)=>c.createMLTensorDownloader(d,f);B.jsepRegisterMLTensor=(d,f,g)=>c.registerMLTensor(d,f,g)}};var ua=Object.assign({},B),va="./this.program",wa=(a,b)=>{throw b;},G="",xa,ya,za;
+if(D){var fs=require("fs"),Aa=require("path");G=require("url").fileURLToPath(new URL("./",import.meta.url));xa=(a,b)=>{a=Ba(a)?new URL(a):Aa.normalize(a);return fs.readFileSync(a,b?void 0:"utf8")};za=a=>{a=xa(a,!0);a.buffer||(a=new Uint8Array(a));return a};ya=(a,b,c,d=!0)=>{a=Ba(a)?new URL(a):Aa.normalize(a);fs.readFile(a,d?void 0:"utf8",(f,g)=>{f?c(f):b(d?g.buffer:g)})};!B.thisProgram&&1<process.argv.length&&(va=process.argv[1].replace(/\\/g,"/"));process.argv.slice(2);wa=(a,b)=>{process.exitCode=
+a;throw b;}}else if(qa||C)C?G=self.location.href:"undefined"!=typeof document&&document.currentScript&&(G=document.currentScript.src),_scriptName&&(G=_scriptName),G.startsWith("blob:")?G="":G=G.substr(0,G.replace(/[?#].*/,"").lastIndexOf("/")+1),D||(xa=a=>{var b=new XMLHttpRequest;b.open("GET",a,!1);b.send(null);return b.responseText},C&&(za=a=>{var b=new XMLHttpRequest;b.open("GET",a,!1);b.responseType="arraybuffer";b.send(null);return new Uint8Array(b.response)}),ya=(a,b,c)=>{var d=new XMLHttpRequest;
+d.open("GET",a,!0);d.responseType="arraybuffer";d.onload=()=>{200==d.status||0==d.status&&d.response?b(d.response):c()};d.onerror=c;d.send(null)});D&&"undefined"==typeof performance&&(global.performance=require("perf_hooks").performance);var Ca=console.log.bind(console),Da=console.error.bind(console);D&&(Ca=(...a)=>fs.writeSync(1,a.join(" ")+"\n"),Da=(...a)=>fs.writeSync(2,a.join(" ")+"\n"));var Ea=Ca,H=Da;Object.assign(B,ua);ua=null;
+if(E){var Fa;if(D){var Ga=ra.parentPort;Ga.on("message",b=>onmessage({data:b}));Object.assign(globalThis,{self:global,importScripts:()=>{},postMessage:b=>Ga.postMessage(b),performance:global.performance||{now:Date.now}})}var Ha=!1;H=function(...b){b=b.join(" ");D?fs.writeSync(2,b+"\n"):console.error(b)};self.alert=function(...b){postMessage({Mb:"alert",text:b.join(" "),qc:Ia()})};B.instantiateWasm=(b,c)=>new Promise(d=>{Fa=f=>{f=new WebAssembly.Instance(f,Ja());c(f);d()}});self.onunhandledrejection=
+b=>{throw b.reason||b;};function a(b){try{var c=b.data,d=c.cmd;if("load"===d){let f=[];self.onmessage=g=>f.push(g);self.startWorker=()=>{postMessage({cmd:"loaded"});for(let g of f)a(g);self.onmessage=a};for(const g of c.handlers)if(!B[g]||B[g].proxy)B[g]=(...k)=>{postMessage({Mb:"callHandler",oc:g,args:k})},"print"==g&&(Ea=B[g]),"printErr"==g&&(H=B[g]);l=c.wasmMemory;t();Fa(c.wasmModule)}else if("run"===d){Ka(c.pthread_ptr,0,0,1,0,0);La(c.pthread_ptr);Ma();Na();Ha||(Oa(),Ha=!0);try{Pa(c.start_routine,
+c.arg)}catch(f){if("unwind"!=f)throw f;}}else"cancel"===d?Ia()&&Qa(-1):"setimmediate"!==c.target&&("checkMailbox"===d?Ha&&Ra():d&&(H(`worker: received unknown command ${d}`),H(c)))}catch(f){throw Sa(),f;}}self.onmessage=a}var Ta;B.wasmBinary&&(Ta=B.wasmBinary);var l,Ua,I=!1,Va,q,ba,da,fa,ha,ia,ka,J,Wa,ma;
+function t(){var a=l.buffer;B.HEAP8=q=new Int8Array(a);B.HEAP16=da=new Int16Array(a);B.HEAPU8=ba=new Uint8Array(a);B.HEAPU16=fa=new Uint16Array(a);B.HEAP32=ha=new Int32Array(a);B.HEAPU32=ia=new Uint32Array(a);B.HEAPF32=ka=new Float32Array(a);B.HEAPF64=ma=new Float64Array(a);B.HEAP64=J=new BigInt64Array(a);B.HEAPU64=Wa=new BigUint64Array(a)}
+if(!E){l=new WebAssembly.Memory({initial:256,maximum:65536,shared:!0});if(!(l.buffer instanceof SharedArrayBuffer))throw H("requested a shared WebAssembly.Memory but the returned buffer is not a SharedArrayBuffer, indicating that while the browser has SharedArrayBuffer it does not have WebAssembly threads support - you may need to set a flag"),D&&H("(on node you may need: --experimental-wasm-threads --experimental-wasm-bulk-memory and/or recent version)"),Error("bad memory");t()}
+var Xa=[],Ya=[],Za=[],$a=0,ab=null,bb=null;function cb(){$a--;if(0==$a&&(null!==ab&&(clearInterval(ab),ab=null),bb)){var a=bb;bb=null;a()}}function db(a){a="Aborted("+a+")";H(a);I=!0;Va=1;a=new WebAssembly.RuntimeError(a+". Build with -sASSERTIONS for more info.");oa(a);throw a;}var eb=a=>a.startsWith("data:application/octet-stream;base64,"),Ba=a=>a.startsWith("file://"),fb;
+function gb(a){if(a==fb&&Ta)return new Uint8Array(Ta);if(za)return za(a);throw"both async and sync fetching of the wasm failed";}function hb(a){if(!Ta&&(qa||C)){if("function"==typeof fetch&&!Ba(a))return fetch(a,{credentials:"same-origin"}).then(b=>{if(!b.ok)throw`failed to load wasm binary file at '${a}'`;return b.arrayBuffer()}).catch(()=>gb(a));if(ya)return new Promise((b,c)=>{ya(a,d=>b(new Uint8Array(d)),c)})}return Promise.resolve().then(()=>gb(a))}
+function ib(a,b,c){return hb(a).then(d=>WebAssembly.instantiate(d,b)).then(c,d=>{H(`failed to asynchronously prepare wasm: ${d}`);db(d)})}function jb(a,b){var c=fb;return Ta||"function"!=typeof WebAssembly.instantiateStreaming||eb(c)||Ba(c)||D||"function"!=typeof fetch?ib(c,a,b):fetch(c,{credentials:"same-origin"}).then(d=>WebAssembly.instantiateStreaming(d,a).then(b,function(f){H(`wasm streaming compile failed: ${f}`);H("falling back to ArrayBuffer instantiation");return ib(c,a,b)}))}
+function Ja(){kb={O:lb,Aa:mb,b:nb,aa:ob,B:pb,qa:qb,Y:rb,_:sb,ra:tb,oa:ub,ha:vb,na:wb,L:xb,Z:yb,W:zb,pa:Ab,X:Bb,wa:Cb,F:Db,Q:Eb,P:Fb,E:Gb,u:Hb,q:Ib,G:Jb,A:Kb,R:Lb,ua:Mb,ka:Nb,U:Ob,ba:Pb,H:Qb,ja:La,ta:Rb,t:Sb,x:Tb,o:Ub,l:Vb,c:Wb,n:Xb,j:Yb,w:Zb,p:$b,g:ac,s:bc,m:cc,e:dc,k:ec,i:fc,h:gc,d:hc,ea:ic,fa:jc,ga:kc,ca:lc,da:mc,T:nc,f:oc,D:pc,I:qc,M:rc,y:sc,sa:tc,V:uc,v:vc,z:wc,N:xc,S:yc,za:zc,ya:Ac,la:Bc,ma:Cc,$:Dc,C:Ec,K:Fc,ia:Gc,J:Hc,a:l,xa:Ic,va:Jc,r:Kc};return{a:kb}}
+var Lc={868340:(a,b,c,d,f)=>{if("undefined"==typeof B||!B.Fb)return 1;a=K(a>>>0);a.startsWith("./")&&(a=a.substring(2));a=B.Fb.get(a);if(!a)return 2;b>>>=0;c>>>=0;d>>>=0;if(b+c>a.byteLength)return 3;try{const g=a.subarray(b,b+c);switch(f){case 0:w().set(g,d>>>0);break;case 1:B.cc(d,g);break;default:return 4}return 0}catch{return 4}},869023:(a,b,c)=>{B.dc(a,w().subarray(b>>>0,b+c>>>0))},869086:()=>B.ac(),869127:a=>{B.Ob(a)},869163:()=>{B.Vb()},869194:()=>{B.Wb()},869223:()=>{B.$b()},869248:a=>B.Ub(a),
+869281:a=>B.Yb(a),869313:(a,b,c)=>{B.Nb(a,b,c,!0)},869352:(a,b,c)=>{B.Nb(a,b,c)},869385:()=>"undefined"!==typeof wasmOffsetConverter,869442:a=>{B.jb("Abs",a,void 0)},869493:a=>{B.jb("Neg",a,void 0)},869544:a=>{B.jb("Floor",a,void 0)},869597:a=>{B.jb("Ceil",a,void 0)},869649:a=>{B.jb("Reciprocal",a,void 0)},869707:a=>{B.jb("Sqrt",a,void 0)},869759:a=>{B.jb("Exp",a,void 0)},869810:a=>{B.jb("Erf",a,void 0)},869861:a=>{B.jb("Sigmoid",a,void 0)},869916:(a,b,c)=>{B.jb("HardSigmoid",a,{alpha:b,beta:c})},
+869995:a=>{B.jb("Log",a,void 0)},870046:a=>{B.jb("Sin",a,void 0)},870097:a=>{B.jb("Cos",a,void 0)},870148:a=>{B.jb("Tan",a,void 0)},870199:a=>{B.jb("Asin",a,void 0)},870251:a=>{B.jb("Acos",a,void 0)},870303:a=>{B.jb("Atan",a,void 0)},870355:a=>{B.jb("Sinh",a,void 0)},870407:a=>{B.jb("Cosh",a,void 0)},870459:a=>{B.jb("Asinh",a,void 0)},870512:a=>{B.jb("Acosh",a,void 0)},870565:a=>{B.jb("Atanh",a,void 0)},870618:a=>{B.jb("Tanh",a,void 0)},870670:a=>{B.jb("Not",a,void 0)},870721:(a,b,c)=>{B.jb("Clip",
+a,{min:b,max:c})},870790:a=>{B.jb("Clip",a,void 0)},870842:(a,b)=>{B.jb("Elu",a,{alpha:b})},870900:a=>{B.jb("Gelu",a,void 0)},870952:a=>{B.jb("Relu",a,void 0)},871004:(a,b)=>{B.jb("LeakyRelu",a,{alpha:b})},871068:(a,b)=>{B.jb("ThresholdedRelu",a,{alpha:b})},871138:(a,b)=>{B.jb("Cast",a,{to:b})},871196:a=>{B.jb("Add",a,void 0)},871247:a=>{B.jb("Sub",a,void 0)},871298:a=>{B.jb("Mul",a,void 0)},871349:a=>{B.jb("Div",a,void 0)},871400:a=>{B.jb("Pow",a,void 0)},871451:a=>{B.jb("Equal",a,void 0)},871504:a=>
+{B.jb("Greater",a,void 0)},871559:a=>{B.jb("GreaterOrEqual",a,void 0)},871621:a=>{B.jb("Less",a,void 0)},871673:a=>{B.jb("LessOrEqual",a,void 0)},871732:(a,b,c,d,f)=>{B.jb("ReduceMean",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(z().subarray(d>>>0,f>>>0)):[]})},871891:(a,b,c,d,f)=>{B.jb("ReduceMax",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(z().subarray(d>>>0,f>>>0)):[]})},872049:(a,b,c,d,f)=>{B.jb("ReduceMin",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(z().subarray(d>>>
+0,f>>>0)):[]})},872207:(a,b,c,d,f)=>{B.jb("ReduceProd",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(z().subarray(d>>>0,f>>>0)):[]})},872366:(a,b,c,d,f)=>{B.jb("ReduceSum",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(z().subarray(d>>>0,f>>>0)):[]})},872524:(a,b,c,d,f)=>{B.jb("ReduceL1",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(z().subarray(d>>>0,f>>>0)):[]})},872681:(a,b,c,d,f)=>{B.jb("ReduceL2",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(z().subarray(d>>>
+0,f>>>0)):[]})},872838:(a,b,c,d,f)=>{B.jb("ReduceLogSum",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(z().subarray(d>>>0,f>>>0)):[]})},872999:(a,b,c,d,f)=>{B.jb("ReduceSumSquare",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(z().subarray(d>>>0,f>>>0)):[]})},873163:(a,b,c,d,f)=>{B.jb("ReduceLogSumExp",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(z().subarray(d>>>0,f>>>0)):[]})},873327:a=>{B.jb("Where",a,void 0)},873380:(a,b,c)=>{B.jb("Transpose",a,{perm:b?Array.from(z().subarray(b>>>
+0,c>>>0)):[]})},873488:(a,b,c,d)=>{B.jb("DepthToSpace",a,{blocksize:b,mode:K(c),format:d?"NHWC":"NCHW"})},873621:(a,b,c,d)=>{B.jb("DepthToSpace",a,{blocksize:b,mode:K(c),format:d?"NHWC":"NCHW"})},873754:(a,b,c,d,f,g,k,m,p,n,r,v,x,h,u)=>{B.jb("ConvTranspose",a,{format:p?"NHWC":"NCHW",autoPad:b,dilations:[c],group:d,kernelShape:[f],pads:[g,k],strides:[m],wIsConst:()=>!!e()[n>>>0],outputPadding:r?Array.from(z().subarray(r>>>0,v>>>0)):[],outputShape:x?Array.from(z().subarray(x>>>0,h>>>0)):[],activation:K(u)})},
+874155:(a,b,c,d,f,g,k,m,p,n,r,v,x,h)=>{B.jb("ConvTranspose",a,{format:m?"NHWC":"NCHW",autoPad:b,dilations:Array.from(z().subarray(c>>>0,(c>>>0)+2>>>0)),group:d,kernelShape:Array.from(z().subarray(f>>>0,(f>>>0)+2>>>0)),pads:Array.from(z().subarray(g>>>0,(g>>>0)+4>>>0)),strides:Array.from(z().subarray(k>>>0,(k>>>0)+2>>>0)),wIsConst:()=>!!e()[p>>>0],outputPadding:n?Array.from(z().subarray(n>>>0,r>>>0)):[],outputShape:v?Array.from(z().subarray(v>>>0,x>>>0)):[],activation:K(h)})},874720:(a,b,c,d,f,g,k,
+m,p,n,r,v,x,h,u)=>{B.jb("ConvTranspose",a,{format:p?"NHWC":"NCHW",autoPad:b,dilations:[c],group:d,kernelShape:[f],pads:[g,k],strides:[m],wIsConst:()=>!!e()[n>>>0],outputPadding:r?Array.from(z().subarray(r>>>0,v>>>0)):[],outputShape:x?Array.from(z().subarray(x>>>0,h>>>0)):[],activation:K(u)})},875121:(a,b,c,d,f,g,k,m,p,n,r,v,x,h)=>{B.jb("ConvTranspose",a,{format:m?"NHWC":"NCHW",autoPad:b,dilations:Array.from(z().subarray(c>>>0,(c>>>0)+2>>>0)),group:d,kernelShape:Array.from(z().subarray(f>>>0,(f>>>
+0)+2>>>0)),pads:Array.from(z().subarray(g>>>0,(g>>>0)+4>>>0)),strides:Array.from(z().subarray(k>>>0,(k>>>0)+2>>>0)),wIsConst:()=>!!e()[p>>>0],outputPadding:n?Array.from(z().subarray(n>>>0,r>>>0)):[],outputShape:v?Array.from(z().subarray(v>>>0,x>>>0)):[],activation:K(h)})},875686:(a,b)=>{B.jb("GlobalAveragePool",a,{format:b?"NHWC":"NCHW"})},875777:(a,b,c,d,f,g,k,m,p,n,r,v,x,h)=>{B.jb("AveragePool",a,{format:h?"NHWC":"NCHW",auto_pad:b,ceil_mode:c,count_include_pad:d,storage_order:f,dilations:g?Array.from(z().subarray(g>>>
+0,k>>>0)):[],kernel_shape:m?Array.from(z().subarray(m>>>0,p>>>0)):[],pads:n?Array.from(z().subarray(n>>>0,r>>>0)):[],strides:v?Array.from(z().subarray(v>>>0,x>>>0)):[]})},876192:(a,b)=>{B.jb("GlobalAveragePool",a,{format:b?"NHWC":"NCHW"})},876283:(a,b,c,d,f,g,k,m,p,n,r,v,x,h)=>{B.jb("AveragePool",a,{format:h?"NHWC":"NCHW",auto_pad:b,ceil_mode:c,count_include_pad:d,storage_order:f,dilations:g?Array.from(z().subarray(g>>>0,k>>>0)):[],kernel_shape:m?Array.from(z().subarray(m>>>0,p>>>0)):[],pads:n?Array.from(z().subarray(n>>>
+0,r>>>0)):[],strides:v?Array.from(z().subarray(v>>>0,x>>>0)):[]})},876698:(a,b)=>{B.jb("GlobalMaxPool",a,{format:b?"NHWC":"NCHW"})},876785:(a,b,c,d,f,g,k,m,p,n,r,v,x,h)=>{B.jb("MaxPool",a,{format:h?"NHWC":"NCHW",auto_pad:b,ceil_mode:c,count_include_pad:d,storage_order:f,dilations:g?Array.from(z().subarray(g>>>0,k>>>0)):[],kernel_shape:m?Array.from(z().subarray(m>>>0,p>>>0)):[],pads:n?Array.from(z().subarray(n>>>0,r>>>0)):[],strides:v?Array.from(z().subarray(v>>>0,x>>>0)):[]})},877196:(a,b)=>{B.jb("GlobalMaxPool",
+a,{format:b?"NHWC":"NCHW"})},877283:(a,b,c,d,f,g,k,m,p,n,r,v,x,h)=>{B.jb("MaxPool",a,{format:h?"NHWC":"NCHW",auto_pad:b,ceil_mode:c,count_include_pad:d,storage_order:f,dilations:g?Array.from(z().subarray(g>>>0,k>>>0)):[],kernel_shape:m?Array.from(z().subarray(m>>>0,p>>>0)):[],pads:n?Array.from(z().subarray(n>>>0,r>>>0)):[],strides:v?Array.from(z().subarray(v>>>0,x>>>0)):[]})},877694:(a,b,c,d,f)=>{B.jb("Gemm",a,{alpha:b,beta:c,transA:d,transB:f})},877798:a=>{B.jb("MatMul",a,void 0)},877852:(a,b,c,
+d)=>{B.jb("ArgMax",a,{keepDims:!!b,selectLastIndex:!!c,axis:d})},877960:(a,b,c,d)=>{B.jb("ArgMin",a,{keepDims:!!b,selectLastIndex:!!c,axis:d})},878068:(a,b)=>{B.jb("Softmax",a,{axis:b})},878131:(a,b)=>{B.jb("Concat",a,{axis:b})},878191:(a,b,c,d,f)=>{B.jb("Split",a,{axis:b,numOutputs:c,splitSizes:d?Array.from(z().subarray(d>>>0,f>>>0)):[]})},878331:a=>{B.jb("Expand",a,void 0)},878385:(a,b)=>{B.jb("Gather",a,{axis:Number(b)})},878456:(a,b)=>{B.jb("GatherElements",a,{axis:Number(b)})},878535:(a,b,c,
+d,f,g,k,m,p,n,r)=>{B.jb("Resize",a,{antialias:b,axes:c?Array.from(z().subarray(c>>>0,d>>>0)):[],coordinateTransformMode:K(f),cubicCoeffA:g,excludeOutside:k,extrapolationValue:m,keepAspectRatioPolicy:K(p),mode:K(n),nearestMode:K(r)})},878881:(a,b,c,d,f,g,k)=>{B.jb("Slice",a,{starts:b?Array.from(z().subarray(b>>>0,c>>>0)):[],ends:d?Array.from(z().subarray(d>>>0,f>>>0)):[],axes:g?Array.from(z().subarray(g>>>0,k>>>0)):[]})},879097:a=>{B.jb("Tile",a,void 0)},879149:(a,b,c)=>{B.jb("InstanceNormalization",
+a,{epsilon:b,format:c?"NHWC":"NCHW"})},879263:(a,b,c)=>{B.jb("InstanceNormalization",a,{epsilon:b,format:c?"NHWC":"NCHW"})},879377:a=>{B.jb("Range",a,void 0)},879430:(a,b)=>{B.jb("Einsum",a,{equation:K(b)})},879511:(a,b,c,d,f)=>{B.jb("Pad",a,{mode:b,value:c,pads:d?Array.from(z().subarray(d>>>0,f>>>0)):[]})},879638:(a,b,c,d,f,g)=>{B.jb("BatchNormalization",a,{epsilon:b,momentum:c,spatial:!!f,trainingMode:!!d,format:g?"NHWC":"NCHW"})},879807:(a,b,c,d,f,g)=>{B.jb("BatchNormalization",a,{epsilon:b,momentum:c,
+spatial:!!f,trainingMode:!!d,format:g?"NHWC":"NCHW"})},879976:(a,b,c)=>{B.jb("CumSum",a,{exclusive:Number(b),reverse:Number(c)})},880073:(a,b,c)=>{B.jb("DequantizeLinear",a,{axis:b,blockSize:c})},880163:(a,b,c,d,f,g,k,m,p)=>{B.jb("Attention",a,{numHeads:b,isUnidirectional:c,maskFilterValue:d,scale:f,doRotary:g,qkvHiddenSizes:k?Array.from(z().subarray(Number(m)>>>0,Number(m)+k>>>0)):[],pastPresentShareBuffer:!!p})},880435:a=>{B.jb("BiasAdd",a,void 0)},880490:a=>{B.jb("BiasSplitGelu",a,void 0)},880551:a=>
+{B.jb("FastGelu",a,void 0)},880607:(a,b,c,d,f,g,k,m,p,n,r,v,x,h,u,y)=>{B.jb("Conv",a,{format:v?"NHWC":"NCHW",auto_pad:b,dilations:c?Array.from(z().subarray(c>>>0,d>>>0)):[],group:f,kernel_shape:g?Array.from(z().subarray(g>>>0,k>>>0)):[],pads:m?Array.from(z().subarray(m>>>0,p>>>0)):[],strides:n?Array.from(z().subarray(n>>>0,r>>>0)):[],w_is_const:()=>!!e()[x>>>0],activation:K(h),activation_params:u?Array.from(ja().subarray(u>>>0,y>>>0)):[]})},881103:a=>{B.jb("Gelu",a,void 0)},881155:(a,b,c,d)=>{B.jb("GroupQueryAttention",
+a,{numHeads:b,kvNumHeads:c,scale:d})},881268:(a,b,c,d)=>{B.jb("LayerNormalization",a,{axis:b,epsilon:c,simplified:!!d})},881379:(a,b,c,d)=>{B.jb("LayerNormalization",a,{axis:b,epsilon:c,simplified:!!d})},881490:(a,b,c,d,f,g)=>{B.jb("MatMulNBits",a,{k:b,n:c,accuracyLevel:d,bits:f,blockSize:g})},881617:(a,b,c,d,f,g)=>{B.jb("MultiHeadAttention",a,{numHeads:b,isUnidirectional:c,maskFilterValue:d,scale:f,doRotary:g})},881776:(a,b)=>{B.jb("QuickGelu",a,{alpha:b})},881840:(a,b,c,d,f)=>{B.jb("RotaryEmbedding",
+a,{interleaved:!!b,numHeads:c,rotaryEmbeddingDim:d,scale:f})},881979:(a,b,c)=>{B.jb("SkipLayerNormalization",a,{epsilon:b,simplified:!!c})},882081:(a,b,c)=>{B.jb("SkipLayerNormalization",a,{epsilon:b,simplified:!!c})},882183:(a,b,c,d)=>{B.jb("GatherBlockQuantized",a,{gatherAxis:b,quantizeAxis:c,blockSize:d})},882304:a=>{B.Zb(a)},882338:(a,b)=>B.bc(a,b,B.Eb.fc,B.Eb.errors)};function mb(a,b,c){return Mc(async()=>{await B.Xb(a,b,c)})}function lb(){return"undefined"!==typeof wasmOffsetConverter}
+function Nc(a){this.name="ExitStatus";this.message=`Program terminated with exit(${a})`;this.status=a}
+var Oc=a=>{a.terminate();a.onmessage=()=>{}},Rc=a=>{0==L.length&&(Pc(),Qc(L[0]));var b=L.pop();if(!b)return 6;M.push(b);N[a.Ab]=b;b.Ab=a.Ab;var c={cmd:"run",start_routine:a.hc,arg:a.Qb,pthread_ptr:a.Ab};D&&b.unref();b.postMessage(c,a.mc);return 0},O=0,P=(a,b,...c)=>{for(var d=2*c.length,f=Sc(),g=Tc(8*d),k=g>>>3,m=0;m<c.length;m++){var p=c[m];"bigint"==typeof p?(J[k+2*m]=1n,J[k+2*m+1]=p):(J[k+2*m]=0n,la()[k+2*m+1>>>0]=p)}a=Vc(a,0,d,g,b);Wc(f);return a};
+function Ic(a){if(E)return P(0,1,a);Va=a;if(!(0<O)){for(var b of M)Oc(b);for(b of L)Oc(b);L=[];M=[];N=[];I=!0}wa(a,new Nc(a))}function Xc(a){if(E)return P(1,0,a);Dc(a)}var Dc=a=>{Va=a;if(E)throw Xc(a),"unwind";Ic(a)},L=[],M=[],Yc=[],N={};function Zc(){for(var a=B.numThreads-1;a--;)Pc();Xa.unshift(()=>{$a++;$c(()=>cb())})}var bd=a=>{var b=a.Ab;delete N[b];L.push(a);M.splice(M.indexOf(a),1);a.Ab=0;ad(b)};function Na(){Yc.forEach(a=>a())}
+var Qc=a=>new Promise(b=>{a.onmessage=g=>{g=g.data;var k=g.cmd;if(g.targetThread&&g.targetThread!=Ia()){var m=N[g.targetThread];m?m.postMessage(g,g.transferList):H(`Internal error! Worker sent a message "${k}" to target pthread ${g.targetThread}, but that thread no longer exists!`)}else if("checkMailbox"===k)Ra();else if("spawnThread"===k)Rc(g);else if("cleanupThread"===k)bd(N[g.thread]);else if("killThread"===k)g=g.thread,k=N[g],delete N[g],Oc(k),ad(g),M.splice(M.indexOf(k),1),k.Ab=0;else if("cancelThread"===
+k)N[g.thread].postMessage({cmd:"cancel"});else if("loaded"===k)a.loaded=!0,D&&!a.Ab&&a.unref(),b(a);else if("alert"===k)alert(`Thread ${g.threadId}: ${g.text}`);else if("setimmediate"===g.target)a.postMessage(g);else if("callHandler"===k)B[g.handler](...g.args);else k&&H(`worker sent an unknown command ${k}`)};a.onerror=g=>{H(`${"worker sent an error!"} ${g.filename}:${g.lineno}: ${g.message}`);throw g;};D&&(a.on("message",g=>a.onmessage({data:g})),a.on("error",g=>a.onerror(g)));var c=[],d=[],f;for(f of d)B.hasOwnProperty(f)&&
+c.push(f);a.postMessage({cmd:"load",handlers:c,wasmMemory:l,wasmModule:Ua})});function $c(a){E?a():Promise.all(L.map(Qc)).then(a)}function Pc(){var a=new Worker(new URL(import.meta.url),{type:"module",workerData:"em-pthread",name:"em-pthread"});L.push(a)}var cd=a=>{for(;0<a.length;)a.shift()(B)},Ma=()=>{var a=Ia(),b=A()[a+52>>>2>>>0];a=A()[a+56>>>2>>>0];dd(b,b-a);Wc(b)},Pa=(a,b)=>{O=0;a=ed(a,b);0<O?Va=a:Qa(a)};class fd{constructor(a){this.Jb=a-24}}var gd=0,hd=0;
+function nb(a,b,c){a>>>=0;var d=new fd(a);b>>>=0;c>>>=0;A()[d.Jb+16>>>2>>>0]=0;A()[d.Jb+4>>>2>>>0]=b;A()[d.Jb+8>>>2>>>0]=c;gd=a;hd++;throw gd;}function jd(a,b,c,d){return E?P(2,1,a,b,c,d):ob(a,b,c,d)}
+function ob(a,b,c,d){a>>>=0;b>>>=0;c>>>=0;d>>>=0;if("undefined"==typeof SharedArrayBuffer)return H("Current environment does not support SharedArrayBuffer, pthreads are not available!"),6;var f=[];if(E&&0===f.length)return jd(a,b,c,d);a={hc:c,Ab:a,Qb:d,mc:f};return E?(a.Mb="spawnThread",postMessage(a,f),0):Rc(a)}
+var kd="undefined"!=typeof TextDecoder?new TextDecoder("utf8"):void 0,ld=(a,b,c)=>{b>>>=0;var d=b+c;for(c=b;a[c]&&!(c>=d);)++c;if(16<c-b&&a.buffer&&kd)return kd.decode(a.buffer instanceof SharedArrayBuffer?a.slice(b,c):a.subarray(b,c));for(d="";b<c;){var f=a[b++];if(f&128){var g=a[b++]&63;if(192==(f&224))d+=String.fromCharCode((f&31)<<6|g);else{var k=a[b++]&63;f=224==(f&240)?(f&15)<<12|g<<6|k:(f&7)<<18|g<<12|k<<6|a[b++]&63;65536>f?d+=String.fromCharCode(f):(f-=65536,d+=String.fromCharCode(55296|f>>
+10,56320|f&1023))}}else d+=String.fromCharCode(f)}return d},K=(a,b)=>(a>>>=0)?ld(w(),a,b):"";function pb(a,b,c){return E?P(3,1,a,b,c):0}function qb(a,b){if(E)return P(4,1,a,b)}
+var md=a=>{for(var b=0,c=0;c<a.length;++c){var d=a.charCodeAt(c);127>=d?b++:2047>=d?b+=2:55296<=d&&57343>=d?(b+=4,++c):b+=3}return b},nd=(a,b,c,d)=>{c>>>=0;if(!(0<d))return 0;var f=c;d=c+d-1;for(var g=0;g<a.length;++g){var k=a.charCodeAt(g);if(55296<=k&&57343>=k){var m=a.charCodeAt(++g);k=65536+((k&1023)<<10)|m&1023}if(127>=k){if(c>=d)break;b[c++>>>0]=k}else{if(2047>=k){if(c+1>=d)break;b[c++>>>0]=192|k>>6}else{if(65535>=k){if(c+2>=d)break;b[c++>>>0]=224|k>>12}else{if(c+3>=d)break;b[c++>>>0]=240|k>>
+18;b[c++>>>0]=128|k>>12&63}b[c++>>>0]=128|k>>6&63}b[c++>>>0]=128|k&63}}b[c>>>0]=0;return c-f},od=(a,b,c)=>nd(a,w(),b,c);function rb(a,b){if(E)return P(5,1,a,b)}function sb(a,b,c){if(E)return P(6,1,a,b,c)}function tb(a,b,c){return E?P(7,1,a,b,c):0}function ub(a,b){if(E)return P(8,1,a,b)}function vb(a,b,c){if(E)return P(9,1,a,b,c)}function wb(a,b,c,d){if(E)return P(10,1,a,b,c,d)}function xb(a,b,c,d){if(E)return P(11,1,a,b,c,d)}function yb(a,b,c,d){if(E)return P(12,1,a,b,c,d)}
+function zb(a){if(E)return P(13,1,a)}function Ab(a,b){if(E)return P(14,1,a,b)}function Bb(a,b,c){if(E)return P(15,1,a,b,c)}var Cb=()=>{db("")},pd,Q=a=>{for(var b="";w()[a>>>0];)b+=pd[w()[a++>>>0]];return b},qd={},rd={},sd={},R;
+function td(a,b,c={}){var d=b.name;if(!a)throw new R(`type "${d}" must have a positive integer typeid pointer`);if(rd.hasOwnProperty(a)){if(c.Sb)return;throw new R(`Cannot register type '${d}' twice`);}rd[a]=b;delete sd[a];qd.hasOwnProperty(a)&&(b=qd[a],delete qd[a],b.forEach(f=>f()))}function S(a,b,c={}){if(!("argPackAdvance"in b))throw new TypeError("registerType registeredInstance requires argPackAdvance");return td(a,b,c)}
+var ud=(a,b,c)=>{switch(b){case 1:return c?d=>e()[d>>>0]:d=>w()[d>>>0];case 2:return c?d=>ca()[d>>>1>>>0]:d=>ea()[d>>>1>>>0];case 4:return c?d=>z()[d>>>2>>>0]:d=>A()[d>>>2>>>0];case 8:return c?d=>J[d>>>3]:d=>Wa[d>>>3];default:throw new TypeError(`invalid integer width (${b}): ${a}`);}};
+function Db(a,b,c){a>>>=0;c>>>=0;b=Q(b>>>0);S(a,{name:b,fromWireType:d=>d,toWireType:function(d,f){if("bigint"!=typeof f&&"number"!=typeof f)throw null===f?f="null":(d=typeof f,f="object"===d||"array"===d||"function"===d?f.toString():""+f),new TypeError(`Cannot convert "${f}" to ${this.name}`);"number"==typeof f&&(f=BigInt(f));return f},argPackAdvance:T,readValueFromPointer:ud(b,c,-1==b.indexOf("u")),Db:null})}var T=8;
+function Eb(a,b,c,d){a>>>=0;b=Q(b>>>0);S(a,{name:b,fromWireType:function(f){return!!f},toWireType:function(f,g){return g?c:d},argPackAdvance:T,readValueFromPointer:function(f){return this.fromWireType(w()[f>>>0])},Db:null})}var vd=[],U=[];function Wb(a){a>>>=0;9<a&&0===--U[a+1]&&(U[a]=void 0,vd.push(a))}
+var V=a=>{if(!a)throw new R("Cannot use deleted val. handle = "+a);return U[a]},W=a=>{switch(a){case void 0:return 2;case null:return 4;case !0:return 6;case !1:return 8;default:const b=vd.pop()||U.length;U[b]=a;U[b+1]=1;return b}};function wd(a){return this.fromWireType(A()[a>>>2>>>0])}var xd={name:"emscripten::val",fromWireType:a=>{var b=V(a);Wb(a);return b},toWireType:(a,b)=>W(b),argPackAdvance:T,readValueFromPointer:wd,Db:null};function Fb(a){return S(a>>>0,xd)}
+var yd=(a,b)=>{switch(b){case 4:return function(c){return this.fromWireType(ja()[c>>>2>>>0])};case 8:return function(c){return this.fromWireType(la()[c>>>3>>>0])};default:throw new TypeError(`invalid float width (${b}): ${a}`);}};function Gb(a,b,c){a>>>=0;c>>>=0;b=Q(b>>>0);S(a,{name:b,fromWireType:d=>d,toWireType:(d,f)=>f,argPackAdvance:T,readValueFromPointer:yd(b,c),Db:null})}
+function Hb(a,b,c,d,f){a>>>=0;c>>>=0;b=Q(b>>>0);-1===f&&(f=4294967295);f=m=>m;if(0===d){var g=32-8*c;f=m=>m<<g>>>g}var k=b.includes("unsigned")?function(m,p){return p>>>0}:function(m,p){return p};S(a,{name:b,fromWireType:f,toWireType:k,argPackAdvance:T,readValueFromPointer:ud(b,c,0!==d),Db:null})}
+function Ib(a,b,c){function d(g){var k=A()[g>>>2>>>0];g=A()[g+4>>>2>>>0];return new f(e().buffer,g,k)}a>>>=0;var f=[Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,BigInt64Array,BigUint64Array][b];c=Q(c>>>0);S(a,{name:c,fromWireType:d,argPackAdvance:T,readValueFromPointer:d},{Sb:!0})}
+function Jb(a,b){a>>>=0;b=Q(b>>>0);var c="std::string"===b;S(a,{name:b,fromWireType:function(d){var f=A()[d>>>2>>>0],g=d+4;if(c)for(var k=g,m=0;m<=f;++m){var p=g+m;if(m==f||0==w()[p>>>0]){k=K(k,p-k);if(void 0===n)var n=k;else n+=String.fromCharCode(0),n+=k;k=p+1}}else{n=Array(f);for(m=0;m<f;++m)n[m]=String.fromCharCode(w()[g+m>>>0]);n=n.join("")}X(d);return n},toWireType:function(d,f){f instanceof ArrayBuffer&&(f=new Uint8Array(f));var g="string"==typeof f;if(!(g||f instanceof Uint8Array||f instanceof
+Uint8ClampedArray||f instanceof Int8Array))throw new R("Cannot pass non-string to std::string");var k=c&&g?md(f):f.length;var m=zd(4+k+1),p=m+4;A()[m>>>2>>>0]=k;if(c&&g)od(f,p,k+1);else if(g)for(g=0;g<k;++g){var n=f.charCodeAt(g);if(255<n)throw X(p),new R("String has UTF-16 code units that do not fit in 8 bits");w()[p+g>>>0]=n}else for(g=0;g<k;++g)w()[p+g>>>0]=f[g];null!==d&&d.push(X,m);return m},argPackAdvance:T,readValueFromPointer:wd,Db(d){X(d)}})}
+var Ad="undefined"!=typeof TextDecoder?new TextDecoder("utf-16le"):void 0,Bd=(a,b)=>{var c=a>>1;for(var d=c+b/2;!(c>=d)&&ea()[c>>>0];)++c;c<<=1;if(32<c-a&&Ad)return Ad.decode(w().slice(a,c));c="";for(d=0;!(d>=b/2);++d){var f=ca()[a+2*d>>>1>>>0];if(0==f)break;c+=String.fromCharCode(f)}return c},Cd=(a,b,c)=>{c??=2147483647;if(2>c)return 0;c-=2;var d=b;c=c<2*a.length?c/2:a.length;for(var f=0;f<c;++f){var g=a.charCodeAt(f);ca()[b>>>1>>>0]=g;b+=2}ca()[b>>>1>>>0]=0;return b-d},Dd=a=>2*a.length,Ed=(a,b)=>
+{for(var c=0,d="";!(c>=b/4);){var f=z()[a+4*c>>>2>>>0];if(0==f)break;++c;65536<=f?(f-=65536,d+=String.fromCharCode(55296|f>>10,56320|f&1023)):d+=String.fromCharCode(f)}return d},Fd=(a,b,c)=>{b>>>=0;c??=2147483647;if(4>c)return 0;var d=b;c=d+c-4;for(var f=0;f<a.length;++f){var g=a.charCodeAt(f);if(55296<=g&&57343>=g){var k=a.charCodeAt(++f);g=65536+((g&1023)<<10)|k&1023}z()[b>>>2>>>0]=g;b+=4;if(b+4>c)break}z()[b>>>2>>>0]=0;return b-d},Gd=a=>{for(var b=0,c=0;c<a.length;++c){var d=a.charCodeAt(c);55296<=
+d&&57343>=d&&++c;b+=4}return b};
+function Kb(a,b,c){a>>>=0;b>>>=0;c>>>=0;c=Q(c);if(2===b){var d=Bd;var f=Cd;var g=Dd;var k=m=>ea()[m>>>1>>>0]}else 4===b&&(d=Ed,f=Fd,g=Gd,k=m=>A()[m>>>2>>>0]);S(a,{name:c,fromWireType:m=>{for(var p=A()[m>>>2>>>0],n,r=m+4,v=0;v<=p;++v){var x=m+4+v*b;if(v==p||0==k(x))r=d(r,x-r),void 0===n?n=r:(n+=String.fromCharCode(0),n+=r),r=x+b}X(m);return n},toWireType:(m,p)=>{if("string"!=typeof p)throw new R(`Cannot pass non-string to C++ string type ${c}`);var n=g(p),r=zd(4+n+b);A()[r>>>2>>>0]=n/b;f(p,r+4,n+b);
+null!==m&&m.push(X,r);return r},argPackAdvance:T,readValueFromPointer:wd,Db(m){X(m)}})}function Lb(a,b){a>>>=0;b=Q(b>>>0);S(a,{Tb:!0,name:b,argPackAdvance:0,fromWireType:()=>{},toWireType:()=>{}})}var Mb=()=>1;function Nb(a){Ka(a>>>0,!C,1,!qa,131072,!1);Na()}var Hd=a=>{if(!I)try{if(a(),!(0<O))try{E?Qa(Va):Dc(Va)}catch(b){b instanceof Nc||"unwind"==b||wa(1,b)}}catch(b){b instanceof Nc||"unwind"==b||wa(1,b)}};
+function La(a){a>>>=0;"function"===typeof Atomics.nc&&(Atomics.nc(z(),a>>>2,a).value.then(Ra),a+=128,Atomics.store(z(),a>>>2,1))}var Ra=()=>{var a=Ia();a&&(La(a),Hd(Id))};function Ob(a,b){a>>>=0;a==b>>>0?setTimeout(Ra):E?postMessage({targetThread:a,cmd:"checkMailbox"}):(a=N[a])&&a.postMessage({cmd:"checkMailbox"})}var Jd=[];function Pb(a,b,c,d,f){b>>>=0;d/=2;Jd.length=d;c=f>>>0>>>3;for(f=0;f<d;f++)Jd[f]=J[c+2*f]?J[c+2*f+1]:la()[c+2*f+1>>>0];return(b?Lc[b]:Kd[a])(...Jd)}
+function Qb(a){a>>>=0;E?postMessage({cmd:"cleanupThread",thread:a}):bd(N[a])}function Rb(a){D&&N[a>>>0].ref()}var Md=(a,b)=>{var c=rd[a];if(void 0===c)throw a=Ld(a),c=Q(a),X(a),new R(`${b} has unknown type ${c}`);return c},Nd=(a,b,c)=>{var d=[];a=a.toWireType(d,c);d.length&&(A()[b>>>2>>>0]=W(d));return a};function Sb(a,b,c){b>>>=0;c>>>=0;a=V(a>>>0);b=Md(b,"emval::as");return Nd(b,c,a)}var Od=a=>{try{a()}catch(b){db(b)}};
+function Pd(){var a=Y,b={};for(let [c,d]of Object.entries(a))b[c]="function"==typeof d?(...f)=>{Qd.push(c);try{return d(...f)}finally{I||(Qd.pop(),F&&1===Z&&0===Qd.length&&(Z=0,O+=1,Od(Rd),"undefined"!=typeof Fibers&&Fibers.sc()))}}:d;return b}var Z=0,F=null,Sd=0,Qd=[],Td={},Ud={},Vd=0,Wd=null,Xd=[];function sa(){return new Promise((a,b)=>{Wd={resolve:a,reject:b}})}
+function Yd(){var a=zd(65548),b=a+12;A()[a>>>2>>>0]=b;A()[a+4>>>2>>>0]=b+65536;b=Qd[0];var c=Td[b];void 0===c&&(c=Vd++,Td[b]=c,Ud[c]=b);b=c;z()[a+8>>>2>>>0]=b;return a}function Zd(){var a=z()[F+8>>>2>>>0];a=Y[Ud[a]];--O;return a()}
+function $d(a){if(!I){if(0===Z){var b=!1,c=!1;a((d=0)=>{if(!I&&(Sd=d,b=!0,c)){Z=2;Od(()=>ae(F));"undefined"!=typeof Browser&&Browser.Kb.Rb&&Browser.Kb.resume();d=!1;try{var f=Zd()}catch(m){f=m,d=!0}var g=!1;if(!F){var k=Wd;k&&(Wd=null,(d?k.reject:k.resolve)(f),g=!0)}if(d&&!g)throw f;}});c=!0;b||(Z=1,F=Yd(),"undefined"!=typeof Browser&&Browser.Kb.Rb&&Browser.Kb.pause(),Od(()=>be(F)))}else 2===Z?(Z=0,Od(ce),X(F),F=null,Xd.forEach(Hd)):db(`invalid state: ${Z}`);return Sd}}
+function Mc(a){return $d(b=>{a().then(b)})}function Tb(a){a>>>=0;return Mc(()=>{a=V(a);return a.then(W)})}var de=[];function Ub(a,b,c,d){c>>>=0;d>>>=0;a=de[a>>>0];b=V(b>>>0);return a(null,b,c,d)}var ee={},fe=a=>{var b=ee[a];return void 0===b?Q(a):b};function Vb(a,b,c,d,f){c>>>=0;d>>>=0;f>>>=0;a=de[a>>>0];b=V(b>>>0);c=fe(c);return a(b,b[c],d,f)}var ge=()=>"object"==typeof globalThis?globalThis:Function("return this")();function Xb(a){a>>>=0;if(0===a)return W(ge());a=fe(a);return W(ge()[a])}
+var he=a=>{var b=de.length;de.push(a);return b},ie=(a,b)=>{for(var c=Array(a),d=0;d<a;++d)c[d]=Md(A()[b+4*d>>>2>>>0],"parameter "+d);return c},je=(a,b)=>Object.defineProperty(b,"name",{value:a});function ke(a){var b=Function;if(!(b instanceof Function))throw new TypeError(`new_ called with constructor type ${typeof b} which is not a function`);var c=je(b.name||"unknownFunctionName",function(){});c.prototype=b.prototype;c=new c;a=b.apply(c,a);return a instanceof Object?a:c}
+function Yb(a,b,c){b=ie(a,b>>>0);var d=b.shift();a--;var f="return function (obj, func, destructorsRef, args) {\n",g=0,k=[];0===c&&k.push("obj");for(var m=["retType"],p=[d],n=0;n<a;++n)k.push("arg"+n),m.push("argType"+n),p.push(b[n]),f+=`  var arg${n} = argType${n}.readValueFromPointer(args${g?"+"+g:""});\n`,g+=b[n].argPackAdvance;f+=`  var rv = ${1===c?"new func":"func.call"}(${k.join(", ")});\n`;d.Tb||(m.push("emval_returnValue"),p.push(Nd),f+="  return emval_returnValue(retType, destructorsRef, rv);\n");
+m.push(f+"};\n");a=ke(m)(...p);c=`methodCaller<(${b.map(r=>r.name).join(", ")}) => ${d.name}>`;return he(je(c,a))}function Zb(a){a=fe(a>>>0);return W(B[a])}function $b(a,b){b>>>=0;a=V(a>>>0);b=V(b);return W(a[b])}function ac(a){a>>>=0;9<a&&(U[a+1]+=1)}function bc(){return W([])}function cc(a){a=V(a>>>0);for(var b=Array(a.length),c=0;c<a.length;c++)b[c]=a[c];return W(b)}function dc(a){return W(fe(a>>>0))}function ec(){return W({})}
+function fc(a){a>>>=0;for(var b=V(a);b.length;){var c=b.pop();b.pop()(c)}Wb(a)}function gc(a,b,c){b>>>=0;c>>>=0;a=V(a>>>0);b=V(b);c=V(c);a[b]=c}function hc(a,b){b>>>=0;a=Md(a>>>0,"_emval_take_value");a=a.readValueFromPointer(b);return W(a)}
+function ic(a,b){a=-9007199254740992>a||9007199254740992<a?NaN:Number(a);b>>>=0;a=new Date(1E3*a);z()[b>>>2>>>0]=a.getUTCSeconds();z()[b+4>>>2>>>0]=a.getUTCMinutes();z()[b+8>>>2>>>0]=a.getUTCHours();z()[b+12>>>2>>>0]=a.getUTCDate();z()[b+16>>>2>>>0]=a.getUTCMonth();z()[b+20>>>2>>>0]=a.getUTCFullYear()-1900;z()[b+24>>>2>>>0]=a.getUTCDay();a=(a.getTime()-Date.UTC(a.getUTCFullYear(),0,1,0,0,0,0))/864E5|0;z()[b+28>>>2>>>0]=a}
+var le=a=>0===a%4&&(0!==a%100||0===a%400),me=[0,31,60,91,121,152,182,213,244,274,305,335],ne=[0,31,59,90,120,151,181,212,243,273,304,334];
+function jc(a,b){a=-9007199254740992>a||9007199254740992<a?NaN:Number(a);b>>>=0;a=new Date(1E3*a);z()[b>>>2>>>0]=a.getSeconds();z()[b+4>>>2>>>0]=a.getMinutes();z()[b+8>>>2>>>0]=a.getHours();z()[b+12>>>2>>>0]=a.getDate();z()[b+16>>>2>>>0]=a.getMonth();z()[b+20>>>2>>>0]=a.getFullYear()-1900;z()[b+24>>>2>>>0]=a.getDay();var c=(le(a.getFullYear())?me:ne)[a.getMonth()]+a.getDate()-1|0;z()[b+28>>>2>>>0]=c;z()[b+36>>>2>>>0]=-(60*a.getTimezoneOffset());c=(new Date(a.getFullYear(),6,1)).getTimezoneOffset();
+var d=(new Date(a.getFullYear(),0,1)).getTimezoneOffset();a=(c!=d&&a.getTimezoneOffset()==Math.min(d,c))|0;z()[b+32>>>2>>>0]=a}
+function kc(a){a>>>=0;var b=new Date(z()[a+20>>>2>>>0]+1900,z()[a+16>>>2>>>0],z()[a+12>>>2>>>0],z()[a+8>>>2>>>0],z()[a+4>>>2>>>0],z()[a>>>2>>>0],0),c=z()[a+32>>>2>>>0],d=b.getTimezoneOffset(),f=(new Date(b.getFullYear(),6,1)).getTimezoneOffset(),g=(new Date(b.getFullYear(),0,1)).getTimezoneOffset(),k=Math.min(g,f);0>c?z()[a+32>>>2>>>0]=Number(f!=g&&k==d):0<c!=(k==d)&&(f=Math.max(g,f),b.setTime(b.getTime()+6E4*((0<c?k:f)-d)));z()[a+24>>>2>>>0]=b.getDay();c=(le(b.getFullYear())?me:ne)[b.getMonth()]+
+b.getDate()-1|0;z()[a+28>>>2>>>0]=c;z()[a>>>2>>>0]=b.getSeconds();z()[a+4>>>2>>>0]=b.getMinutes();z()[a+8>>>2>>>0]=b.getHours();z()[a+12>>>2>>>0]=b.getDate();z()[a+16>>>2>>>0]=b.getMonth();z()[a+20>>>2>>>0]=b.getYear();a=b.getTime();return BigInt(isNaN(a)?-1:a/1E3)}function lc(a,b,c,d,f,g,k){return E?P(16,1,a,b,c,d,f,g,k):-52}function mc(a,b,c,d,f,g){if(E)return P(17,1,a,b,c,d,f,g)}
+function nc(a,b,c,d){a>>>=0;b>>>=0;c>>>=0;d>>>=0;var f=(new Date).getFullYear(),g=new Date(f,0,1),k=new Date(f,6,1);f=g.getTimezoneOffset();var m=k.getTimezoneOffset(),p=Math.max(f,m);A()[a>>>2>>>0]=60*p;z()[b>>>2>>>0]=Number(f!=m);a=n=>n.toLocaleTimeString(void 0,{hour12:!1,timeZoneName:"short"}).split(" ")[1];g=a(g);k=a(k);m<f?(od(g,c,17),od(k,d,17)):(od(g,d,17),od(k,c,17))}
+var oe=[],pe=(a,b)=>{oe.length=0;for(var c;c=w()[a++>>>0];){var d=105!=c;d&=112!=c;b+=d&&b%8?4:0;oe.push(112==c?A()[b>>>2>>>0]:106==c?J[b>>>3]:105==c?z()[b>>>2>>>0]:la()[b>>>3>>>0]);b+=d?8:4}return oe};function oc(a,b,c){a>>>=0;b=pe(b>>>0,c>>>0);return Lc[a](...b)}function pc(a,b,c){a>>>=0;b=pe(b>>>0,c>>>0);return Lc[a](...b)}var qc=()=>{},rc=()=>Date.now();function sc(a,b){return H(K(a>>>0,b>>>0))}var tc=()=>{O+=1;throw"unwind";};function uc(){return 4294901760}var vc;
+vc=()=>performance.timeOrigin+performance.now();var wc=()=>D?require("os").cpus().length:navigator.hardwareConcurrency;function xc(){db("Cannot use emscripten_pc_get_function without -sUSE_OFFSET_CONVERTER");return 0}
+function yc(a){a>>>=0;var b=w().length;if(a<=b||4294901760<a)return!1;for(var c=1;4>=c;c*=2){var d=b*(1+.2/c);d=Math.min(d,a+100663296);var f=Math;d=Math.max(a,d);a:{f=(f.min.call(f,4294901760,d+(65536-d%65536)%65536)-l.buffer.byteLength+65535)/65536;try{l.grow(f);t();var g=1;break a}catch(k){}g=void 0}if(g)return!0}return!1}var qe=()=>{db("Cannot use convertFrameToPC (needed by __builtin_return_address) without -sUSE_OFFSET_CONVERTER");return 0},re={},se=a=>{a.forEach(b=>{var c=qe();c&&(re[c]=b)})};
+function zc(){var a=Error().stack.toString().split("\n");"Error"==a[0]&&a.shift();se(a);re.Pb=qe();re.ec=a;return re.Pb}function Ac(a,b,c){a>>>=0;b>>>=0;if(re.Pb==a)var d=re.ec;else d=Error().stack.toString().split("\n"),"Error"==d[0]&&d.shift(),se(d);for(var f=3;d[f]&&qe()!=a;)++f;for(a=0;a<c&&d[a+f];++a)z()[b+4*a>>>2>>>0]=qe();return a}
+var te={},ve=()=>{if(!ue){var a={USER:"web_user",LOGNAME:"web_user",PATH:"/",PWD:"/",HOME:"/home/web_user",LANG:("object"==typeof navigator&&navigator.languages&&navigator.languages[0]||"C").replace("-","_")+".UTF-8",_:va||"./this.program"},b;for(b in te)void 0===te[b]?delete a[b]:a[b]=te[b];var c=[];for(b in a)c.push(`${b}=${a[b]}`);ue=c}return ue},ue;
+function Bc(a,b){if(E)return P(18,1,a,b);a>>>=0;b>>>=0;var c=0;ve().forEach((d,f)=>{var g=b+c;f=A()[a+4*f>>>2>>>0]=g;for(g=0;g<d.length;++g)e()[f++>>>0]=d.charCodeAt(g);e()[f>>>0]=0;c+=d.length+1});return 0}function Cc(a,b){if(E)return P(19,1,a,b);a>>>=0;b>>>=0;var c=ve();A()[a>>>2>>>0]=c.length;var d=0;c.forEach(f=>d+=f.length+1);A()[b>>>2>>>0]=d;return 0}function Ec(a){return E?P(20,1,a):52}function Fc(a,b,c,d){return E?P(21,1,a,b,c,d):52}function Gc(a,b,c,d){return E?P(22,1,a,b,c,d):70}
+var we=[null,[],[]];function Hc(a,b,c,d){if(E)return P(23,1,a,b,c,d);b>>>=0;c>>>=0;d>>>=0;for(var f=0,g=0;g<c;g++){var k=A()[b>>>2>>>0],m=A()[b+4>>>2>>>0];b+=8;for(var p=0;p<m;p++){var n=w()[k+p>>>0],r=we[a];0===n||10===n?((1===a?Ea:H)(ld(r,0)),r.length=0):r.push(n)}f+=m}A()[d>>>2>>>0]=f;return 0}var xe=[31,29,31,30,31,30,31,31,30,31,30,31],ye=[31,28,31,30,31,30,31,31,30,31,30,31];function ze(a){var b=Array(md(a)+1);nd(a,b,0,b.length);return b}var Ae=(a,b)=>{e().set(a,b>>>0)};
+function Jc(a,b,c,d){function f(h,u,y){for(h="number"==typeof h?h.toString():h||"";h.length<u;)h=y[0]+h;return h}function g(h,u){return f(h,u,"0")}function k(h,u){function y(Uc){return 0>Uc?-1:0<Uc?1:0}var aa;0===(aa=y(h.getFullYear()-u.getFullYear()))&&0===(aa=y(h.getMonth()-u.getMonth()))&&(aa=y(h.getDate()-u.getDate()));return aa}function m(h){switch(h.getDay()){case 0:return new Date(h.getFullYear()-1,11,29);case 1:return h;case 2:return new Date(h.getFullYear(),0,3);case 3:return new Date(h.getFullYear(),
+0,2);case 4:return new Date(h.getFullYear(),0,1);case 5:return new Date(h.getFullYear()-1,11,31);case 6:return new Date(h.getFullYear()-1,11,30)}}function p(h){var u=h.Bb;for(h=new Date((new Date(h.Cb+1900,0,1)).getTime());0<u;){var y=h.getMonth(),aa=(le(h.getFullYear())?xe:ye)[y];if(u>aa-h.getDate())u-=aa-h.getDate()+1,h.setDate(1),11>y?h.setMonth(y+1):(h.setMonth(0),h.setFullYear(h.getFullYear()+1));else{h.setDate(h.getDate()+u);break}}y=new Date(h.getFullYear()+1,0,4);u=m(new Date(h.getFullYear(),
+0,4));y=m(y);return 0>=k(u,h)?0>=k(y,h)?h.getFullYear()+1:h.getFullYear():h.getFullYear()-1}a>>>=0;b>>>=0;c>>>=0;d>>>=0;var n=A()[d+40>>>2>>>0];d={kc:z()[d>>>2>>>0],jc:z()[d+4>>>2>>>0],Hb:z()[d+8>>>2>>>0],Lb:z()[d+12>>>2>>>0],Ib:z()[d+16>>>2>>>0],Cb:z()[d+20>>>2>>>0],ub:z()[d+24>>>2>>>0],Bb:z()[d+28>>>2>>>0],rc:z()[d+32>>>2>>>0],ic:z()[d+36>>>2>>>0],lc:n?K(n):""};c=K(c);n={"%c":"%a %b %d %H:%M:%S %Y","%D":"%m/%d/%y","%F":"%Y-%m-%d","%h":"%b","%r":"%I:%M:%S %p","%R":"%H:%M","%T":"%H:%M:%S","%x":"%m/%d/%y",
+"%X":"%H:%M:%S","%Ec":"%c","%EC":"%C","%Ex":"%m/%d/%y","%EX":"%H:%M:%S","%Ey":"%y","%EY":"%Y","%Od":"%d","%Oe":"%e","%OH":"%H","%OI":"%I","%Om":"%m","%OM":"%M","%OS":"%S","%Ou":"%u","%OU":"%U","%OV":"%V","%Ow":"%w","%OW":"%W","%Oy":"%y"};for(var r in n)c=c.replace(new RegExp(r,"g"),n[r]);var v="Sunday Monday Tuesday Wednesday Thursday Friday Saturday".split(" "),x="January February March April May June July August September October November December".split(" ");n={"%a":h=>v[h.ub].substring(0,3),"%A":h=>
+v[h.ub],"%b":h=>x[h.Ib].substring(0,3),"%B":h=>x[h.Ib],"%C":h=>g((h.Cb+1900)/100|0,2),"%d":h=>g(h.Lb,2),"%e":h=>f(h.Lb,2," "),"%g":h=>p(h).toString().substring(2),"%G":p,"%H":h=>g(h.Hb,2),"%I":h=>{h=h.Hb;0==h?h=12:12<h&&(h-=12);return g(h,2)},"%j":h=>{for(var u=0,y=0;y<=h.Ib-1;u+=(le(h.Cb+1900)?xe:ye)[y++]);return g(h.Lb+u,3)},"%m":h=>g(h.Ib+1,2),"%M":h=>g(h.jc,2),"%n":()=>"\n","%p":h=>0<=h.Hb&&12>h.Hb?"AM":"PM","%S":h=>g(h.kc,2),"%t":()=>"\t","%u":h=>h.ub||7,"%U":h=>g(Math.floor((h.Bb+7-h.ub)/7),
+2),"%V":h=>{var u=Math.floor((h.Bb+7-(h.ub+6)%7)/7);2>=(h.ub+371-h.Bb-2)%7&&u++;if(u)53==u&&(y=(h.ub+371-h.Bb)%7,4==y||3==y&&le(h.Cb)||(u=1));else{u=52;var y=(h.ub+7-h.Bb-1)%7;(4==y||5==y&&le(h.Cb%400-1))&&u++}return g(u,2)},"%w":h=>h.ub,"%W":h=>g(Math.floor((h.Bb+7-(h.ub+6)%7)/7),2),"%y":h=>(h.Cb+1900).toString().substring(2),"%Y":h=>h.Cb+1900,"%z":h=>{h=h.ic;var u=0<=h;h=Math.abs(h)/60;return(u?"+":"-")+String("0000"+(h/60*100+h%60)).slice(-4)},"%Z":h=>h.lc,"%%":()=>"%"};c=c.replace(/%%/g,"\x00\x00");
+for(r in n)c.includes(r)&&(c=c.replace(new RegExp(r,"g"),n[r](d)));c=c.replace(/\0\0/g,"%");r=ze(c);if(r.length>b)return 0;Ae(r,a);return r.length-1}function Kc(a,b,c,d){return Jc(a>>>0,b>>>0,c>>>0,d>>>0)}E||Zc();for(var Be=Array(256),Ce=0;256>Ce;++Ce)Be[Ce]=String.fromCharCode(Ce);pd=Be;R=B.BindingError=class extends Error{constructor(a){super(a);this.name="BindingError"}};B.InternalError=class extends Error{constructor(a){super(a);this.name="InternalError"}};U.push(0,1,void 0,1,null,1,!0,1,!1,1);
+B.count_emval_handles=()=>U.length/2-5-vd.length;
+var Kd=[Ic,Xc,jd,pb,qb,rb,sb,tb,ub,vb,wb,xb,yb,zb,Ab,Bb,lc,mc,Bc,Cc,Ec,Fc,Gc,Hc],kb,Y=function(){function a(c,d){Y=c.exports;Y=Pd();Y=De();Yc.push(Y.ib);Ya.unshift(Y.Ba);Ua=d;cb();return Y}var b=Ja();$a++;if(B.instantiateWasm)try{return B.instantiateWasm(b,a)}catch(c){H(`Module.instantiateWasm callback failed with error: ${c}`),oa(c)}fb||=B.locateFile?eb("ort-wasm-simd-threaded.jsep.wasm")?"ort-wasm-simd-threaded.jsep.wasm":B.locateFile?B.locateFile("ort-wasm-simd-threaded.jsep.wasm",G):G+"ort-wasm-simd-threaded.jsep.wasm":
+(new URL("ort-wasm-simd-threaded.jsep.wasm",import.meta.url)).href;jb(b,function(c){a(c.instance,c.module)}).catch(oa);return{}}(),Ld=a=>(Ld=Y.Ca)(a),Oa=()=>(Oa=Y.Da)();B._OrtInit=(a,b)=>(B._OrtInit=Y.Ea)(a,b);B._OrtGetLastError=(a,b)=>(B._OrtGetLastError=Y.Fa)(a,b);B._OrtCreateSessionOptions=(a,b,c,d,f,g,k,m,p,n)=>(B._OrtCreateSessionOptions=Y.Ga)(a,b,c,d,f,g,k,m,p,n);B._OrtAppendExecutionProvider=(a,b)=>(B._OrtAppendExecutionProvider=Y.Ha)(a,b);
+B._OrtAddFreeDimensionOverride=(a,b,c)=>(B._OrtAddFreeDimensionOverride=Y.Ia)(a,b,c);B._OrtAddSessionConfigEntry=(a,b,c)=>(B._OrtAddSessionConfigEntry=Y.Ja)(a,b,c);B._OrtReleaseSessionOptions=a=>(B._OrtReleaseSessionOptions=Y.Ka)(a);B._OrtCreateSession=(a,b,c)=>(B._OrtCreateSession=Y.La)(a,b,c);B._OrtReleaseSession=a=>(B._OrtReleaseSession=Y.Ma)(a);B._OrtGetInputOutputCount=(a,b,c)=>(B._OrtGetInputOutputCount=Y.Na)(a,b,c);B._OrtGetInputName=(a,b)=>(B._OrtGetInputName=Y.Oa)(a,b);
+B._OrtGetOutputName=(a,b)=>(B._OrtGetOutputName=Y.Pa)(a,b);B._OrtFree=a=>(B._OrtFree=Y.Qa)(a);B._OrtCreateTensor=(a,b,c,d,f,g)=>(B._OrtCreateTensor=Y.Ra)(a,b,c,d,f,g);B._OrtGetTensorData=(a,b,c,d,f)=>(B._OrtGetTensorData=Y.Sa)(a,b,c,d,f);B._OrtReleaseTensor=a=>(B._OrtReleaseTensor=Y.Ta)(a);B._OrtCreateRunOptions=(a,b,c,d)=>(B._OrtCreateRunOptions=Y.Ua)(a,b,c,d);B._OrtAddRunConfigEntry=(a,b,c)=>(B._OrtAddRunConfigEntry=Y.Va)(a,b,c);B._OrtReleaseRunOptions=a=>(B._OrtReleaseRunOptions=Y.Wa)(a);
+B._OrtCreateBinding=a=>(B._OrtCreateBinding=Y.Xa)(a);B._OrtBindInput=(a,b,c)=>(B._OrtBindInput=Y.Ya)(a,b,c);B._OrtBindOutput=(a,b,c,d)=>(B._OrtBindOutput=Y.Za)(a,b,c,d);B._OrtClearBoundOutputs=a=>(B._OrtClearBoundOutputs=Y._a)(a);B._OrtReleaseBinding=a=>(B._OrtReleaseBinding=Y.$a)(a);B._OrtRunWithBinding=(a,b,c,d,f)=>(B._OrtRunWithBinding=Y.ab)(a,b,c,d,f);B._OrtRun=(a,b,c,d,f,g,k,m)=>(B._OrtRun=Y.bb)(a,b,c,d,f,g,k,m);B._OrtEndProfiling=a=>(B._OrtEndProfiling=Y.cb)(a);
+B._JsepOutput=(a,b,c)=>(B._JsepOutput=Y.db)(a,b,c);B._JsepGetNodeName=a=>(B._JsepGetNodeName=Y.eb)(a);
+var Ia=()=>(Ia=Y.fb)(),zd=B._malloc=a=>(zd=B._malloc=Y.gb)(a),X=B._free=a=>(X=B._free=Y.hb)(a),Ka=(a,b,c,d,f,g)=>(Ka=Y.kb)(a,b,c,d,f,g),Sa=()=>(Sa=Y.lb)(),Vc=(a,b,c,d,f)=>(Vc=Y.mb)(a,b,c,d,f),ad=a=>(ad=Y.nb)(a),Qa=a=>(Qa=Y.ob)(a),Id=()=>(Id=Y.pb)(),dd=(a,b)=>(dd=Y.qb)(a,b),Wc=a=>(Wc=Y.rb)(a),Tc=a=>(Tc=Y.sb)(a),Sc=()=>(Sc=Y.tb)(),ed=B.dynCall_ii=(a,b)=>(ed=B.dynCall_ii=Y.vb)(a,b),be=a=>(be=Y.wb)(a),Rd=()=>(Rd=Y.xb)(),ae=a=>(ae=Y.yb)(a),ce=()=>(ce=Y.zb)();B.___start_em_js=882450;B.___stop_em_js=882672;
+function De(){var a=Y;a=Object.assign({},a);var b=d=>f=>d(f)>>>0,c=d=>()=>d()>>>0;a.Ca=b(a.Ca);a.fb=c(a.fb);a.gb=b(a.gb);a.emscripten_main_runtime_thread_id=c(a.emscripten_main_runtime_thread_id);a.sb=b(a.sb);a.tb=c(a.tb);return a}B.stackSave=()=>Sc();B.stackRestore=a=>Wc(a);B.stackAlloc=a=>Tc(a);B.UTF8ToString=K;B.stringToUTF8=od;B.lengthBytesUTF8=md;var Ee;bb=function Fe(){Ee||Ge();Ee||(bb=Fe)};
+function Ge(){0<$a||(E?(na(B),E||cd(Ya),startWorker(B)):(cd(Xa),0<$a||Ee||(Ee=!0,B.calledRun=!0,I||(E||cd(Ya),na(B),E||cd(Za)))))}Ge();moduleRtn=pa;
+
+
+  return moduleRtn;
+}
+);
+})();
+export default ortWasmThreaded;
+var isPthread = globalThis.self?.name === 'em-pthread';
+var isNode = typeof globalThis.process?.versions?.node == 'string';
+if (isNode) isPthread = (await import('worker_threads')).workerData === 'em-pthread';
+
+// When running as a pthread, construct a new instance on startup
+isPthread && ortWasmThreaded();

webapp/vendor/ort/ort-wasm-simd-threaded.mjs

@@ -0,0 +1,81 @@
+
+var ortWasmThreaded = (() => {
+  var _scriptName = import.meta.url;
+  
+  return (
+async function(moduleArg = {}) {
+  var moduleRtn;
+
+function aa(){g.buffer!=l.buffer&&m();return l}function n(){g.buffer!=l.buffer&&m();return ba}function r(){g.buffer!=l.buffer&&m();return ca}function u(){g.buffer!=l.buffer&&m();return da}function ea(){g.buffer!=l.buffer&&m();return fa}var w=Object.assign({},moduleArg),ha,x,ia=new Promise((a,b)=>{ha=a;x=b}),ja="object"==typeof window,A="function"==typeof importScripts,B="object"==typeof process&&"object"==typeof process.versions&&"string"==typeof process.versions.node,C=A&&"em-pthread"==self.name;
+if(B){const {createRequire:a}=await import("module");var require=a(import.meta.url),D=require("worker_threads");global.Worker=D.Worker;C=(A=!D.lb)&&"em-pthread"==D.workerData}"use strict";w.mountExternalData=(a,b)=>{a.startsWith("./")&&(a=a.substring(2));(w.Ua||(w.Ua=new Map)).set(a,b)};w.unmountExternalData=()=>{delete w.Ua};
+var SharedArrayBuffer=globalThis.SharedArrayBuffer??(new WebAssembly.Memory({initial:0,maximum:0,shared:!0})).buffer.constructor,ka=Object.assign({},w),la="./this.program",E=(a,b)=>{throw b;},F="",ma,G,H;
+if(B){var fs=require("fs"),na=require("path");F=require("url").fileURLToPath(new URL("./",import.meta.url));ma=(a,b)=>{a=oa(a)?new URL(a):na.normalize(a);return fs.readFileSync(a,b?void 0:"utf8")};H=a=>{a=ma(a,!0);a.buffer||(a=new Uint8Array(a));return a};G=(a,b,c,d=!0)=>{a=oa(a)?new URL(a):na.normalize(a);fs.readFile(a,d?void 0:"utf8",(f,h)=>{f?c(f):b(d?h.buffer:h)})};!w.thisProgram&&1<process.argv.length&&(la=process.argv[1].replace(/\\/g,"/"));process.argv.slice(2);E=(a,b)=>{process.exitCode=
+a;throw b;}}else if(ja||A)A?F=self.location.href:"undefined"!=typeof document&&document.currentScript&&(F=document.currentScript.src),_scriptName&&(F=_scriptName),F.startsWith("blob:")?F="":F=F.substr(0,F.replace(/[?#].*/,"").lastIndexOf("/")+1),B||(ma=a=>{var b=new XMLHttpRequest;b.open("GET",a,!1);b.send(null);return b.responseText},A&&(H=a=>{var b=new XMLHttpRequest;b.open("GET",a,!1);b.responseType="arraybuffer";b.send(null);return new Uint8Array(b.response)}),G=(a,b,c)=>{var d=new XMLHttpRequest;
+d.open("GET",a,!0);d.responseType="arraybuffer";d.onload=()=>{200==d.status||0==d.status&&d.response?b(d.response):c()};d.onerror=c;d.send(null)});B&&"undefined"==typeof performance&&(global.performance=require("perf_hooks").performance);var pa=console.log.bind(console),qa=console.error.bind(console);B&&(pa=(...a)=>fs.writeSync(1,a.join(" ")+"\n"),qa=(...a)=>fs.writeSync(2,a.join(" ")+"\n"));var ra=pa,I=qa;Object.assign(w,ka);ka=null;
+if(C){var sa;if(B){var ta=D.parentPort;ta.on("message",b=>onmessage({data:b}));Object.assign(globalThis,{self:global,importScripts:()=>{},postMessage:b=>ta.postMessage(b),performance:global.performance||{now:Date.now}})}var ua=!1;I=function(...b){b=b.join(" ");B?fs.writeSync(2,b+"\n"):console.error(b)};self.alert=function(...b){postMessage({Za:"alert",text:b.join(" "),nb:K()})};w.instantiateWasm=(b,c)=>new Promise(d=>{sa=f=>{f=new WebAssembly.Instance(f,va());c(f);d()}});self.onunhandledrejection=
+b=>{throw b.reason||b;};function a(b){try{var c=b.data,d=c.cmd;if("load"===d){let f=[];self.onmessage=h=>f.push(h);self.startWorker=()=>{postMessage({cmd:"loaded"});for(let h of f)a(h);self.onmessage=a};for(const h of c.handlers)if(!w[h]||w[h].proxy)w[h]=(...k)=>{postMessage({Za:"callHandler",kb:h,args:k})},"print"==h&&(ra=w[h]),"printErr"==h&&(I=w[h]);g=c.wasmMemory;m();sa(c.wasmModule)}else if("run"===d){wa(c.pthread_ptr,0,0,1,0,0);xa(c.pthread_ptr);ya();za();ua||=!0;try{Aa(c.start_routine,c.arg)}catch(f){if("unwind"!=
+f)throw f;}}else"cancel"===d?K()&&Ba(-1):"setimmediate"!==c.target&&("checkMailbox"===d?ua&&Ca():d&&(I(`worker: received unknown command ${d}`),I(c)))}catch(f){throw Da(),f;}}self.onmessage=a}var L;w.wasmBinary&&(L=w.wasmBinary);var g,Ea,Fa=!1,M,l,ba,ca,da,N,fa;
+function m(){var a=g.buffer;w.HEAP8=l=new Int8Array(a);w.HEAP16=new Int16Array(a);w.HEAPU8=ba=new Uint8Array(a);w.HEAPU16=new Uint16Array(a);w.HEAP32=ca=new Int32Array(a);w.HEAPU32=da=new Uint32Array(a);w.HEAPF32=new Float32Array(a);w.HEAPF64=fa=new Float64Array(a);w.HEAP64=N=new BigInt64Array(a);w.HEAPU64=new BigUint64Array(a)}
+if(!C){g=new WebAssembly.Memory({initial:256,maximum:65536,shared:!0});if(!(g.buffer instanceof SharedArrayBuffer))throw I("requested a shared WebAssembly.Memory but the returned buffer is not a SharedArrayBuffer, indicating that while the browser has SharedArrayBuffer it does not have WebAssembly threads support - you may need to set a flag"),B&&I("(on node you may need: --experimental-wasm-threads --experimental-wasm-bulk-memory and/or recent version)"),Error("bad memory");m()}
+var Ga=[],Ha=[],Ia=[],O=0,Ja=null,P=null;function Ka(){O--;if(0==O&&(null!==Ja&&(clearInterval(Ja),Ja=null),P)){var a=P;P=null;a()}}function La(a){a="Aborted("+a+")";I(a);Fa=!0;M=1;a=new WebAssembly.RuntimeError(a+". Build with -sASSERTIONS for more info.");x(a);throw a;}var Ma=a=>a.startsWith("data:application/octet-stream;base64,"),oa=a=>a.startsWith("file://"),Na;function Oa(a){if(a==Na&&L)return new Uint8Array(L);if(H)return H(a);throw"both async and sync fetching of the wasm failed";}
+function Pa(a){if(!L&&(ja||A)){if("function"==typeof fetch&&!oa(a))return fetch(a,{credentials:"same-origin"}).then(b=>{if(!b.ok)throw`failed to load wasm binary file at '${a}'`;return b.arrayBuffer()}).catch(()=>Oa(a));if(G)return new Promise((b,c)=>{G(a,d=>b(new Uint8Array(d)),c)})}return Promise.resolve().then(()=>Oa(a))}function Qa(a,b,c){return Pa(a).then(d=>WebAssembly.instantiate(d,b)).then(c,d=>{I(`failed to asynchronously prepare wasm: ${d}`);La(d)})}
+function Ra(a,b){var c=Na;return L||"function"!=typeof WebAssembly.instantiateStreaming||Ma(c)||oa(c)||B||"function"!=typeof fetch?Qa(c,a,b):fetch(c,{credentials:"same-origin"}).then(d=>WebAssembly.instantiateStreaming(d,a).then(b,function(f){I(`wasm streaming compile failed: ${f}`);I("falling back to ArrayBuffer instantiation");return Qa(c,a,b)}))}
+function va(){Sa={j:Ta,b:Ua,E:Va,g:Wa,V:Xa,A:Ya,C:Za,W:$a,T:ab,L:bb,S:cb,o:db,B:eb,y:fb,U:gb,z:hb,_:ib,Z:jb,P:kb,w:lb,F:mb,k:nb,O:xa,Y:ob,I:pb,J:qb,K:rb,G:sb,H:tb,v:ub,q:vb,l:wb,p:xb,e:yb,X:zb,x:Ab,d:Bb,f:Cb,i:Db,u:Eb,t:Fb,s:Gb,Q:Hb,R:Ib,D:Jb,h:Kb,n:Lb,M:Mb,m:Nb,a:g,r:Ob,N:Pb,c:Qb};return{a:Sa}}
+var Rb={837620:(a,b,c,d,f)=>{if("undefined"==typeof w||!w.Ua)return 1;a=Q(a>>>0);a.startsWith("./")&&(a=a.substring(2));a=w.Ua.get(a);if(!a)return 2;b>>>=0;c>>>=0;d>>>=0;if(b+c>a.byteLength)return 3;try{const h=a.subarray(b,b+c);switch(f){case 0:n().set(h,d>>>0);break;case 1:w.mb(d,h);break;default:return 4}return 0}catch{return 4}},838303:()=>"undefined"!==typeof wasmOffsetConverter};function Ta(){return"undefined"!==typeof wasmOffsetConverter}
+function Sb(a){this.name="ExitStatus";this.message=`Program terminated with exit(${a})`;this.status=a}
+var Tb=a=>{a.terminate();a.onmessage=()=>{}},Wb=a=>{0==R.length&&(Ub(),Vb(R[0]));var b=R.pop();if(!b)return 6;S.push(b);T[a.Ra]=b;b.Ra=a.Ra;var c={cmd:"run",start_routine:a.cb,arg:a.ab,pthread_ptr:a.Ra};B&&b.unref();b.postMessage(c,a.ib);return 0},U=0,V=(a,b,...c)=>{for(var d=2*c.length,f=$b(),h=ac(8*d),k=h>>>3,q=0;q<c.length;q++){var y=c[q];"bigint"==typeof y?(N[k+2*q]=1n,N[k+2*q+1]=y):(N[k+2*q]=0n,ea()[k+2*q+1>>>0]=y)}a=bc(a,0,d,h,b);cc(f);return a};
+function Ob(a){if(C)return V(0,1,a);M=a;if(!(0<U)){for(var b of S)Tb(b);for(b of R)Tb(b);R=[];S=[];T=[];Fa=!0}E(a,new Sb(a))}function dc(a){if(C)return V(1,0,a);Jb(a)}var Jb=a=>{M=a;if(C)throw dc(a),"unwind";Ob(a)},R=[],S=[],ec=[],T={};function fc(){for(var a=w.numThreads-1;a--;)Ub();Ga.unshift(()=>{O++;gc(()=>Ka())})}var ic=a=>{var b=a.Ra;delete T[b];R.push(a);S.splice(S.indexOf(a),1);a.Ra=0;hc(b)};function za(){ec.forEach(a=>a())}
+var Vb=a=>new Promise(b=>{a.onmessage=h=>{h=h.data;var k=h.cmd;if(h.targetThread&&h.targetThread!=K()){var q=T[h.targetThread];q?q.postMessage(h,h.transferList):I(`Internal error! Worker sent a message "${k}" to target pthread ${h.targetThread}, but that thread no longer exists!`)}else if("checkMailbox"===k)Ca();else if("spawnThread"===k)Wb(h);else if("cleanupThread"===k)ic(T[h.thread]);else if("killThread"===k)h=h.thread,k=T[h],delete T[h],Tb(k),hc(h),S.splice(S.indexOf(k),1),k.Ra=0;else if("cancelThread"===
+k)T[h.thread].postMessage({cmd:"cancel"});else if("loaded"===k)a.loaded=!0,B&&!a.Ra&&a.unref(),b(a);else if("alert"===k)alert(`Thread ${h.threadId}: ${h.text}`);else if("setimmediate"===h.target)a.postMessage(h);else if("callHandler"===k)w[h.handler](...h.args);else k&&I(`worker sent an unknown command ${k}`)};a.onerror=h=>{I(`${"worker sent an error!"} ${h.filename}:${h.lineno}: ${h.message}`);throw h;};B&&(a.on("message",h=>a.onmessage({data:h})),a.on("error",h=>a.onerror(h)));var c=[],d=[],f;for(f of d)w.hasOwnProperty(f)&&
+c.push(f);a.postMessage({cmd:"load",handlers:c,wasmMemory:g,wasmModule:Ea})});function gc(a){C?a():Promise.all(R.map(Vb)).then(a)}function Ub(){var a=new Worker(new URL(import.meta.url),{type:"module",workerData:"em-pthread",name:"em-pthread"});R.push(a)}var jc=a=>{for(;0<a.length;)a.shift()(w)},ya=()=>{var a=K(),b=u()[a+52>>>2>>>0];a=u()[a+56>>>2>>>0];kc(b,b-a);cc(b)},lc=[],mc,Aa=(a,b)=>{U=0;var c=lc[a];c||(a>=lc.length&&(lc.length=a+1),lc[a]=c=mc.get(a));a=c(b);0<U?M=a:Ba(a)};
+class nc{constructor(a){this.Xa=a-24}}var oc=0,pc=0;function Ua(a,b,c){a>>>=0;var d=new nc(a);b>>>=0;c>>>=0;u()[d.Xa+16>>>2>>>0]=0;u()[d.Xa+4>>>2>>>0]=b;u()[d.Xa+8>>>2>>>0]=c;oc=a;pc++;throw oc;}function qc(a,b,c,d){return C?V(2,1,a,b,c,d):Va(a,b,c,d)}
+function Va(a,b,c,d){a>>>=0;b>>>=0;c>>>=0;d>>>=0;if("undefined"==typeof SharedArrayBuffer)return I("Current environment does not support SharedArrayBuffer, pthreads are not available!"),6;var f=[];if(C&&0===f.length)return qc(a,b,c,d);a={cb:c,Ra:a,ab:d,ib:f};return C?(a.Za="spawnThread",postMessage(a,f),0):Wb(a)}
+var rc="undefined"!=typeof TextDecoder?new TextDecoder("utf8"):void 0,sc=(a,b,c)=>{b>>>=0;var d=b+c;for(c=b;a[c]&&!(c>=d);)++c;if(16<c-b&&a.buffer&&rc)return rc.decode(a.buffer instanceof SharedArrayBuffer?a.slice(b,c):a.subarray(b,c));for(d="";b<c;){var f=a[b++];if(f&128){var h=a[b++]&63;if(192==(f&224))d+=String.fromCharCode((f&31)<<6|h);else{var k=a[b++]&63;f=224==(f&240)?(f&15)<<12|h<<6|k:(f&7)<<18|h<<12|k<<6|a[b++]&63;65536>f?d+=String.fromCharCode(f):(f-=65536,d+=String.fromCharCode(55296|f>>
+10,56320|f&1023))}}else d+=String.fromCharCode(f)}return d},Q=(a,b)=>(a>>>=0)?sc(n(),a,b):"";function Wa(a,b,c){return C?V(3,1,a,b,c):0}function Xa(a,b){if(C)return V(4,1,a,b)}
+var tc=a=>{for(var b=0,c=0;c<a.length;++c){var d=a.charCodeAt(c);127>=d?b++:2047>=d?b+=2:55296<=d&&57343>=d?(b+=4,++c):b+=3}return b},uc=(a,b,c,d)=>{c>>>=0;if(!(0<d))return 0;var f=c;d=c+d-1;for(var h=0;h<a.length;++h){var k=a.charCodeAt(h);if(55296<=k&&57343>=k){var q=a.charCodeAt(++h);k=65536+((k&1023)<<10)|q&1023}if(127>=k){if(c>=d)break;b[c++>>>0]=k}else{if(2047>=k){if(c+1>=d)break;b[c++>>>0]=192|k>>6}else{if(65535>=k){if(c+2>=d)break;b[c++>>>0]=224|k>>12}else{if(c+3>=d)break;b[c++>>>0]=240|k>>
+18;b[c++>>>0]=128|k>>12&63}b[c++>>>0]=128|k>>6&63}b[c++>>>0]=128|k&63}}b[c>>>0]=0;return c-f},W=(a,b,c)=>uc(a,n(),b,c);function Ya(a,b){if(C)return V(5,1,a,b)}function Za(a,b,c){if(C)return V(6,1,a,b,c)}function $a(a,b,c){return C?V(7,1,a,b,c):0}function ab(a,b){if(C)return V(8,1,a,b)}function bb(a,b,c){if(C)return V(9,1,a,b,c)}function cb(a,b,c,d){if(C)return V(10,1,a,b,c,d)}function db(a,b,c,d){if(C)return V(11,1,a,b,c,d)}function eb(a,b,c,d){if(C)return V(12,1,a,b,c,d)}
+function fb(a){if(C)return V(13,1,a)}function gb(a,b){if(C)return V(14,1,a,b)}function hb(a,b,c){if(C)return V(15,1,a,b,c)}var ib=()=>{La("")},jb=()=>1;function kb(a){wa(a>>>0,!A,1,!ja,131072,!1);za()}function xa(a){a>>>=0;"function"===typeof Atomics.jb&&(Atomics.jb(r(),a>>>2,a).value.then(Ca),a+=128,Atomics.store(r(),a>>>2,1))}
+var Ca=()=>{var a=K();if(a&&(xa(a),a=vc,!Fa))try{if(a(),!(0<U))try{C?Ba(M):Jb(M)}catch(b){b instanceof Sb||"unwind"==b||E(1,b)}}catch(b){b instanceof Sb||"unwind"==b||E(1,b)}};function lb(a,b){a>>>=0;a==b>>>0?setTimeout(Ca):C?postMessage({targetThread:a,cmd:"checkMailbox"}):(a=T[a])&&a.postMessage({cmd:"checkMailbox"})}var wc=[];function mb(a,b,c,d,f){b>>>=0;d/=2;wc.length=d;c=f>>>0>>>3;for(f=0;f<d;f++)wc[f]=N[c+2*f]?N[c+2*f+1]:ea()[c+2*f+1>>>0];return(b?Rb[b]:xc[a])(...wc)}
+function nb(a){a>>>=0;C?postMessage({cmd:"cleanupThread",thread:a}):ic(T[a])}function ob(a){B&&T[a>>>0].ref()}
+function pb(a,b){a=-9007199254740992>a||9007199254740992<a?NaN:Number(a);b>>>=0;a=new Date(1E3*a);r()[b>>>2>>>0]=a.getUTCSeconds();r()[b+4>>>2>>>0]=a.getUTCMinutes();r()[b+8>>>2>>>0]=a.getUTCHours();r()[b+12>>>2>>>0]=a.getUTCDate();r()[b+16>>>2>>>0]=a.getUTCMonth();r()[b+20>>>2>>>0]=a.getUTCFullYear()-1900;r()[b+24>>>2>>>0]=a.getUTCDay();a=(a.getTime()-Date.UTC(a.getUTCFullYear(),0,1,0,0,0,0))/864E5|0;r()[b+28>>>2>>>0]=a}
+var X=a=>0===a%4&&(0!==a%100||0===a%400),yc=[0,31,60,91,121,152,182,213,244,274,305,335],zc=[0,31,59,90,120,151,181,212,243,273,304,334];
+function qb(a,b){a=-9007199254740992>a||9007199254740992<a?NaN:Number(a);b>>>=0;a=new Date(1E3*a);r()[b>>>2>>>0]=a.getSeconds();r()[b+4>>>2>>>0]=a.getMinutes();r()[b+8>>>2>>>0]=a.getHours();r()[b+12>>>2>>>0]=a.getDate();r()[b+16>>>2>>>0]=a.getMonth();r()[b+20>>>2>>>0]=a.getFullYear()-1900;r()[b+24>>>2>>>0]=a.getDay();var c=(X(a.getFullYear())?yc:zc)[a.getMonth()]+a.getDate()-1|0;r()[b+28>>>2>>>0]=c;r()[b+36>>>2>>>0]=-(60*a.getTimezoneOffset());c=(new Date(a.getFullYear(),6,1)).getTimezoneOffset();
+var d=(new Date(a.getFullYear(),0,1)).getTimezoneOffset();a=(c!=d&&a.getTimezoneOffset()==Math.min(d,c))|0;r()[b+32>>>2>>>0]=a}
+function rb(a){a>>>=0;var b=new Date(r()[a+20>>>2>>>0]+1900,r()[a+16>>>2>>>0],r()[a+12>>>2>>>0],r()[a+8>>>2>>>0],r()[a+4>>>2>>>0],r()[a>>>2>>>0],0),c=r()[a+32>>>2>>>0],d=b.getTimezoneOffset(),f=(new Date(b.getFullYear(),6,1)).getTimezoneOffset(),h=(new Date(b.getFullYear(),0,1)).getTimezoneOffset(),k=Math.min(h,f);0>c?r()[a+32>>>2>>>0]=Number(f!=h&&k==d):0<c!=(k==d)&&(f=Math.max(h,f),b.setTime(b.getTime()+6E4*((0<c?k:f)-d)));r()[a+24>>>2>>>0]=b.getDay();c=(X(b.getFullYear())?yc:zc)[b.getMonth()]+
+b.getDate()-1|0;r()[a+28>>>2>>>0]=c;r()[a>>>2>>>0]=b.getSeconds();r()[a+4>>>2>>>0]=b.getMinutes();r()[a+8>>>2>>>0]=b.getHours();r()[a+12>>>2>>>0]=b.getDate();r()[a+16>>>2>>>0]=b.getMonth();r()[a+20>>>2>>>0]=b.getYear();a=b.getTime();return BigInt(isNaN(a)?-1:a/1E3)}function sb(a,b,c,d,f,h,k){return C?V(16,1,a,b,c,d,f,h,k):-52}function tb(a,b,c,d,f,h){if(C)return V(17,1,a,b,c,d,f,h)}
+function ub(a,b,c,d){a>>>=0;b>>>=0;c>>>=0;d>>>=0;var f=(new Date).getFullYear(),h=new Date(f,0,1),k=new Date(f,6,1);f=h.getTimezoneOffset();var q=k.getTimezoneOffset(),y=Math.max(f,q);u()[a>>>2>>>0]=60*y;r()[b>>>2>>>0]=Number(f!=q);a=v=>v.toLocaleTimeString(void 0,{hour12:!1,timeZoneName:"short"}).split(" ")[1];h=a(h);k=a(k);q<f?(W(h,c,17),W(k,d,17)):(W(h,d,17),W(k,c,17))}var Ac=[];
+function vb(a,b,c){a>>>=0;b>>>=0;c>>>=0;Ac.length=0;for(var d;d=n()[b++>>>0];){var f=105!=d;f&=112!=d;c+=f&&c%8?4:0;Ac.push(112==d?u()[c>>>2>>>0]:106==d?N[c>>>3]:105==d?r()[c>>>2>>>0]:ea()[c>>>3>>>0]);c+=f?8:4}return Rb[a](...Ac)}var wb=()=>{},xb=()=>Date.now();function yb(a,b){return I(Q(a>>>0,b>>>0))}var zb=()=>{U+=1;throw"unwind";};function Ab(){return 4294901760}var Bb;Bb=()=>performance.timeOrigin+performance.now();var Cb=()=>B?require("os").cpus().length:navigator.hardwareConcurrency;
+function Db(){La("Cannot use emscripten_pc_get_function without -sUSE_OFFSET_CONVERTER");return 0}function Eb(a){a>>>=0;var b=n().length;if(a<=b||4294901760<a)return!1;for(var c=1;4>=c;c*=2){var d=b*(1+.2/c);d=Math.min(d,a+100663296);var f=Math;d=Math.max(a,d);a:{f=(f.min.call(f,4294901760,d+(65536-d%65536)%65536)-g.buffer.byteLength+65535)/65536;try{g.grow(f);m();var h=1;break a}catch(k){}h=void 0}if(h)return!0}return!1}
+var Bc=()=>{La("Cannot use convertFrameToPC (needed by __builtin_return_address) without -sUSE_OFFSET_CONVERTER");return 0},Y={},Cc=a=>{a.forEach(b=>{var c=Bc();c&&(Y[c]=b)})};function Fb(){var a=Error().stack.toString().split("\n");"Error"==a[0]&&a.shift();Cc(a);Y.$a=Bc();Y.bb=a;return Y.$a}
+function Gb(a,b,c){a>>>=0;b>>>=0;if(Y.$a==a)var d=Y.bb;else d=Error().stack.toString().split("\n"),"Error"==d[0]&&d.shift(),Cc(d);for(var f=3;d[f]&&Bc()!=a;)++f;for(a=0;a<c&&d[a+f];++a)r()[b+4*a>>>2>>>0]=Bc();return a}
+var Dc={},Fc=()=>{if(!Ec){var a={USER:"web_user",LOGNAME:"web_user",PATH:"/",PWD:"/",HOME:"/home/web_user",LANG:("object"==typeof navigator&&navigator.languages&&navigator.languages[0]||"C").replace("-","_")+".UTF-8",_:la||"./this.program"},b;for(b in Dc)void 0===Dc[b]?delete a[b]:a[b]=Dc[b];var c=[];for(b in a)c.push(`${b}=${a[b]}`);Ec=c}return Ec},Ec;
+function Hb(a,b){if(C)return V(18,1,a,b);a>>>=0;b>>>=0;var c=0;Fc().forEach((d,f)=>{var h=b+c;f=u()[a+4*f>>>2>>>0]=h;for(h=0;h<d.length;++h)aa()[f++>>>0]=d.charCodeAt(h);aa()[f>>>0]=0;c+=d.length+1});return 0}function Ib(a,b){if(C)return V(19,1,a,b);a>>>=0;b>>>=0;var c=Fc();u()[a>>>2>>>0]=c.length;var d=0;c.forEach(f=>d+=f.length+1);u()[b>>>2>>>0]=d;return 0}function Kb(a){return C?V(20,1,a):52}function Lb(a,b,c,d){return C?V(21,1,a,b,c,d):52}function Mb(a,b,c,d){return C?V(22,1,a,b,c,d):70}
+var Gc=[null,[],[]];function Nb(a,b,c,d){if(C)return V(23,1,a,b,c,d);b>>>=0;c>>>=0;d>>>=0;for(var f=0,h=0;h<c;h++){var k=u()[b>>>2>>>0],q=u()[b+4>>>2>>>0];b+=8;for(var y=0;y<q;y++){var v=n()[k+y>>>0],z=Gc[a];0===v||10===v?((1===a?ra:I)(sc(z,0)),z.length=0):z.push(v)}f+=q}u()[d>>>2>>>0]=f;return 0}var Hc=[31,29,31,30,31,30,31,31,30,31,30,31],Ic=[31,28,31,30,31,30,31,31,30,31,30,31];function Jc(a){var b=Array(tc(a)+1);uc(a,b,0,b.length);return b}var Kc=(a,b)=>{aa().set(a,b>>>0)};
+function Pb(a,b,c,d){function f(e,p,t){for(e="number"==typeof e?e.toString():e||"";e.length<p;)e=t[0]+e;return e}function h(e,p){return f(e,p,"0")}function k(e,p){function t(Xb){return 0>Xb?-1:0<Xb?1:0}var J;0===(J=t(e.getFullYear()-p.getFullYear()))&&0===(J=t(e.getMonth()-p.getMonth()))&&(J=t(e.getDate()-p.getDate()));return J}function q(e){switch(e.getDay()){case 0:return new Date(e.getFullYear()-1,11,29);case 1:return e;case 2:return new Date(e.getFullYear(),0,3);case 3:return new Date(e.getFullYear(),
+0,2);case 4:return new Date(e.getFullYear(),0,1);case 5:return new Date(e.getFullYear()-1,11,31);case 6:return new Date(e.getFullYear()-1,11,30)}}function y(e){var p=e.Sa;for(e=new Date((new Date(e.Ta+1900,0,1)).getTime());0<p;){var t=e.getMonth(),J=(X(e.getFullYear())?Hc:Ic)[t];if(p>J-e.getDate())p-=J-e.getDate()+1,e.setDate(1),11>t?e.setMonth(t+1):(e.setMonth(0),e.setFullYear(e.getFullYear()+1));else{e.setDate(e.getDate()+p);break}}t=new Date(e.getFullYear()+1,0,4);p=q(new Date(e.getFullYear(),
+0,4));t=q(t);return 0>=k(p,e)?0>=k(t,e)?e.getFullYear()+1:e.getFullYear():e.getFullYear()-1}a>>>=0;b>>>=0;c>>>=0;d>>>=0;var v=u()[d+40>>>2>>>0];d={gb:r()[d>>>2>>>0],fb:r()[d+4>>>2>>>0],Va:r()[d+8>>>2>>>0],Ya:r()[d+12>>>2>>>0],Wa:r()[d+16>>>2>>>0],Ta:r()[d+20>>>2>>>0],Qa:r()[d+24>>>2>>>0],Sa:r()[d+28>>>2>>>0],ob:r()[d+32>>>2>>>0],eb:r()[d+36>>>2>>>0],hb:v?Q(v):""};c=Q(c);v={"%c":"%a %b %d %H:%M:%S %Y","%D":"%m/%d/%y","%F":"%Y-%m-%d","%h":"%b","%r":"%I:%M:%S %p","%R":"%H:%M","%T":"%H:%M:%S","%x":"%m/%d/%y",
+"%X":"%H:%M:%S","%Ec":"%c","%EC":"%C","%Ex":"%m/%d/%y","%EX":"%H:%M:%S","%Ey":"%y","%EY":"%Y","%Od":"%d","%Oe":"%e","%OH":"%H","%OI":"%I","%Om":"%m","%OM":"%M","%OS":"%S","%Ou":"%u","%OU":"%U","%OV":"%V","%Ow":"%w","%OW":"%W","%Oy":"%y"};for(var z in v)c=c.replace(new RegExp(z,"g"),v[z]);var Yb="Sunday Monday Tuesday Wednesday Thursday Friday Saturday".split(" "),Zb="January February March April May June July August September October November December".split(" ");v={"%a":e=>Yb[e.Qa].substring(0,3),
+"%A":e=>Yb[e.Qa],"%b":e=>Zb[e.Wa].substring(0,3),"%B":e=>Zb[e.Wa],"%C":e=>h((e.Ta+1900)/100|0,2),"%d":e=>h(e.Ya,2),"%e":e=>f(e.Ya,2," "),"%g":e=>y(e).toString().substring(2),"%G":y,"%H":e=>h(e.Va,2),"%I":e=>{e=e.Va;0==e?e=12:12<e&&(e-=12);return h(e,2)},"%j":e=>{for(var p=0,t=0;t<=e.Wa-1;p+=(X(e.Ta+1900)?Hc:Ic)[t++]);return h(e.Ya+p,3)},"%m":e=>h(e.Wa+1,2),"%M":e=>h(e.fb,2),"%n":()=>"\n","%p":e=>0<=e.Va&&12>e.Va?"AM":"PM","%S":e=>h(e.gb,2),"%t":()=>"\t","%u":e=>e.Qa||7,"%U":e=>h(Math.floor((e.Sa+
+7-e.Qa)/7),2),"%V":e=>{var p=Math.floor((e.Sa+7-(e.Qa+6)%7)/7);2>=(e.Qa+371-e.Sa-2)%7&&p++;if(p)53==p&&(t=(e.Qa+371-e.Sa)%7,4==t||3==t&&X(e.Ta)||(p=1));else{p=52;var t=(e.Qa+7-e.Sa-1)%7;(4==t||5==t&&X(e.Ta%400-1))&&p++}return h(p,2)},"%w":e=>e.Qa,"%W":e=>h(Math.floor((e.Sa+7-(e.Qa+6)%7)/7),2),"%y":e=>(e.Ta+1900).toString().substring(2),"%Y":e=>e.Ta+1900,"%z":e=>{e=e.eb;var p=0<=e;e=Math.abs(e)/60;return(p?"+":"-")+String("0000"+(e/60*100+e%60)).slice(-4)},"%Z":e=>e.hb,"%%":()=>"%"};c=c.replace(/%%/g,
+"\x00\x00");for(z in v)c.includes(z)&&(c=c.replace(new RegExp(z,"g"),v[z](d)));c=c.replace(/\0\0/g,"%");z=Jc(c);if(z.length>b)return 0;Kc(z,a);return z.length-1}function Qb(a,b,c,d){return Pb(a>>>0,b>>>0,c>>>0,d>>>0)}C||fc();
+var xc=[Ob,dc,qc,Wa,Xa,Ya,Za,$a,ab,bb,cb,db,eb,fb,gb,hb,sb,tb,Hb,Ib,Kb,Lb,Mb,Nb],Sa,Z=function(){function a(c,d){Z=c.exports;Z=Lc();ec.push(Z.Ea);mc=Z.Fa;Ha.unshift(Z.$);Ea=d;Ka();return Z}var b=va();O++;if(w.instantiateWasm)try{return w.instantiateWasm(b,a)}catch(c){I(`Module.instantiateWasm callback failed with error: ${c}`),x(c)}Na||=w.locateFile?Ma("ort-wasm-simd-threaded.wasm")?"ort-wasm-simd-threaded.wasm":w.locateFile?w.locateFile("ort-wasm-simd-threaded.wasm",F):F+"ort-wasm-simd-threaded.wasm":
+(new URL("ort-wasm-simd-threaded.wasm",import.meta.url)).href;Ra(b,function(c){a(c.instance,c.module)}).catch(x);return{}}();w._OrtInit=(a,b)=>(w._OrtInit=Z.aa)(a,b);w._OrtGetLastError=(a,b)=>(w._OrtGetLastError=Z.ba)(a,b);w._OrtCreateSessionOptions=(a,b,c,d,f,h,k,q,y,v)=>(w._OrtCreateSessionOptions=Z.ca)(a,b,c,d,f,h,k,q,y,v);w._OrtAppendExecutionProvider=(a,b)=>(w._OrtAppendExecutionProvider=Z.da)(a,b);w._OrtAddFreeDimensionOverride=(a,b,c)=>(w._OrtAddFreeDimensionOverride=Z.ea)(a,b,c);
+w._OrtAddSessionConfigEntry=(a,b,c)=>(w._OrtAddSessionConfigEntry=Z.fa)(a,b,c);w._OrtReleaseSessionOptions=a=>(w._OrtReleaseSessionOptions=Z.ga)(a);w._OrtCreateSession=(a,b,c)=>(w._OrtCreateSession=Z.ha)(a,b,c);w._OrtReleaseSession=a=>(w._OrtReleaseSession=Z.ia)(a);w._OrtGetInputOutputCount=(a,b,c)=>(w._OrtGetInputOutputCount=Z.ja)(a,b,c);w._OrtGetInputName=(a,b)=>(w._OrtGetInputName=Z.ka)(a,b);w._OrtGetOutputName=(a,b)=>(w._OrtGetOutputName=Z.la)(a,b);w._OrtFree=a=>(w._OrtFree=Z.ma)(a);
+w._OrtCreateTensor=(a,b,c,d,f,h)=>(w._OrtCreateTensor=Z.na)(a,b,c,d,f,h);w._OrtGetTensorData=(a,b,c,d,f)=>(w._OrtGetTensorData=Z.oa)(a,b,c,d,f);w._OrtReleaseTensor=a=>(w._OrtReleaseTensor=Z.pa)(a);w._OrtCreateRunOptions=(a,b,c,d)=>(w._OrtCreateRunOptions=Z.qa)(a,b,c,d);w._OrtAddRunConfigEntry=(a,b,c)=>(w._OrtAddRunConfigEntry=Z.ra)(a,b,c);w._OrtReleaseRunOptions=a=>(w._OrtReleaseRunOptions=Z.sa)(a);w._OrtCreateBinding=a=>(w._OrtCreateBinding=Z.ta)(a);
+w._OrtBindInput=(a,b,c)=>(w._OrtBindInput=Z.ua)(a,b,c);w._OrtBindOutput=(a,b,c,d)=>(w._OrtBindOutput=Z.va)(a,b,c,d);w._OrtClearBoundOutputs=a=>(w._OrtClearBoundOutputs=Z.wa)(a);w._OrtReleaseBinding=a=>(w._OrtReleaseBinding=Z.xa)(a);w._OrtRunWithBinding=(a,b,c,d,f)=>(w._OrtRunWithBinding=Z.ya)(a,b,c,d,f);w._OrtRun=(a,b,c,d,f,h,k,q)=>(w._OrtRun=Z.za)(a,b,c,d,f,h,k,q);w._OrtEndProfiling=a=>(w._OrtEndProfiling=Z.Aa)(a);var K=()=>(K=Z.Ba)();w._malloc=a=>(w._malloc=Z.Ca)(a);w._free=a=>(w._free=Z.Da)(a);
+var wa=(a,b,c,d,f,h)=>(wa=Z.Ga)(a,b,c,d,f,h),Da=()=>(Da=Z.Ha)(),bc=(a,b,c,d,f)=>(bc=Z.Ia)(a,b,c,d,f),hc=a=>(hc=Z.Ja)(a),Ba=a=>(Ba=Z.Ka)(a),vc=()=>(vc=Z.La)(),kc=(a,b)=>(kc=Z.Ma)(a,b),cc=a=>(cc=Z.Na)(a),ac=a=>(ac=Z.Oa)(a),$b=()=>($b=Z.Pa)();w.___start_em_js=838360;w.___stop_em_js=838421;
+function Lc(){var a=Z;a=Object.assign({},a);var b=d=>()=>d()>>>0,c=d=>f=>d(f)>>>0;a.Ba=b(a.Ba);a.Ca=c(a.Ca);a.emscripten_main_runtime_thread_id=b(a.emscripten_main_runtime_thread_id);a.Oa=c(a.Oa);a.Pa=b(a.Pa);return a}w.stackSave=()=>$b();w.stackRestore=a=>cc(a);w.stackAlloc=a=>ac(a);w.UTF8ToString=Q;w.stringToUTF8=W;w.lengthBytesUTF8=tc;var Mc;P=function Nc(){Mc||Oc();Mc||(P=Nc)};
+function Oc(){0<O||(C?(ha(w),C||jc(Ha),startWorker(w)):(jc(Ga),0<O||Mc||(Mc=!0,w.calledRun=!0,Fa||(C||jc(Ha),ha(w),C||jc(Ia)))))}Oc();moduleRtn=ia;
+
+
+  return moduleRtn;
+}
+);
+})();
+export default ortWasmThreaded;
+var isPthread = globalThis.self?.name === 'em-pthread';
+var isNode = typeof globalThis.process?.versions?.node == 'string';
+if (isNode) isPthread = (await import('worker_threads')).workerData === 'em-pthread';
+
+// When running as a pthread, construct a new instance on startup
+isPthread && ortWasmThreaded();