diff --git a/AUDIT_V24.md b/AUDIT_V24.md
new file mode 100644
index 0000000..7eaa139
--- /dev/null
+++ b/AUDIT_V24.md
@@ -0,0 +1,95 @@
+# v24.1.3 completion audit
+
+## 判定
+
+**v24.1.2で実ブラウザからWGSL reserved-word parse errorが報告されたため、従来のrelease判定を撤回。v24.1.3でshader命名とfallback負荷を修正し、静的・CPU数値モデル・build gateを再実行してPASS。実WebGPU adapter acceptanceはこの環境では引き続き未実行。**
+
+実GPU未実行を「PASS」とは扱いません。
+
+## 修正済みの重大事項
+
+1. f32量子化BLAによるmembership反転
+   - production BLAを完全除去。
+2. BLAなしperturbationのfalse bounded反例
+   - roundoff error boundを導入し、既知反例を`UNKNOWN`へ退避。
+3. recolor/render token race
+   - `recolorPending`方式へ変更。
+4. redundant Strict retry
+   - 1-pass policyへ整理し、大画面queue/indirect dispatchを削除。
+5. Exportの4 readback/tile
+   - 4 sampleを1 command streamで処理しGPU resolve後1 readback。
+6. Exportのtile resource churn
+   - 512² reusable GPU workspaceへ変更。
+7. 16K巨大Canvas
+   - streaming PNGへ変更。
+8. deep JS fallback誤描画
+   - deep fallbackを明示拒否。
+9. WGSL parse error (`meta` / `smooth` reserved words)
+   - storage変数を`fieldMeta` / `fieldSmooth`へ改名。WGSL予約語を全shaderで走査する回帰テストを追加。
+10. WebGPU shader/pipeline failure時のCPU暴走
+   - shader/pipelineエラーではJavaScript full-frame fallbackを起動せず停止。WebGPU自体がない場合だけ軽量fallbackを使用。
+11. 画面描画負荷
+   - standard screen budgetをdesktop約4M→1.5M、小型端末約2M→0.75Mへ低減。power約0.5M、fine最大約3M、Strict最大約2M。
+12. WebGPU canvas context claim
+   - pipeline成功後へ遅延。
+13. e340以深の座標表示0化
+    - fixed-point exact decimal formatterの340桁capを撤去。
+
+## CPU numeric regression
+
+`guarded-production-equation-cpu-f32-model-not-real-gpu`:
+
+- period2-cusp-z14: false escaped 0 / false bounded 0 / UNKNOWN 0
+- period2-cusp-z20: 0 / 0 / 0
+- period2-cusp-z100: 0 / 0 / 0
+- period3-interior: 0 / 0 / 0
+- period2-cusp-e280: 0 / 0 / 0
+- period2-cusp-e400: 0 / 0 / 0
+- swirly-seahorses-z12: false escaped 0 / false bounded 0 / UNKNOWN 71 of 187
+
+BalancedとStrictの両方で上記membership gateを満たします。swirlyの未確定率は既知の制約で、誤分類より保守退避を優先しています。
+
+Shallow f32 modelは693 sampleでfalse escaped 0 / false bounded 0。escape iteration count差は2 sampleあり、membership certificationを名乗らない理由の一つです。
+
+## BLA status
+
+production sourceにBLA builder/evaluator/node/levelはありません。再導入にはf32係数量子化を含む誤差上界付き受入条件が必要です。
+
+## Export audit
+
+- tile max 512²
+- reusable GPU workspace
+- 2×2 AA: one readback/tile
+- unresolved counterをRGBA readback末尾へ同梱
+- PNG signature / IHDR / CRC / multiple IDAT / inflate scanlineをNode modelで検証
+- abort path settles without unhandled rejection
+
+## Real WebGPU acceptance
+
+`tests/webgpu-acceptance.html`は以下を実adapterで検証します。
+
+- shader compilation
+- standard / Strict deep dispatch
+- BigInt reference guard
+- sampled membership
+- dense known regressions
+- Export 1× / 2×2 readback
+- uncaptured validation errors
+
+stable scenesはsampled UNKNOWNを許容しません。swirlyは25 sample中12以上の確定を要求します。
+
+この作業環境のChromiumは`navigator.gpu`を公開しないため、このgateは未実行です。`audit/v24-real-webgpu-status.json`に環境結果を記録します。
+
+## v24.1.3 hotfix verification
+
+- WGSL 16.2 reserved-word scan: PASS (5 shader modules)
+- `meta` / `smooth` WGSL identifier occurrences: 0
+- source contract: PASS (28 checks)
+- `npm test`: PASS
+- clean `npm run build`: PASS
+- source ↔ standalone/hosted hashes: identical
+- shader/pipeline init failure: CPU full-frame fallback is not entered and failed init is not retried every render
+- normal desktop screen budget: ~1.5M px (v24.1.2 ~4M px)
+- no-WebGPU/no-adapter fallback budget: ~0.25M px
+
+実WebGPU adapter上のv24.1.3 compile/dispatchだけは、このコンテナではadapterを得られないため未実行です。v24.1.2で報告されたreserved-word parse failureそのものは、仕様予約語の除去とreserved-token回帰gateによってsource上修正済みです。
diff --git a/BUILD_REPRODUCIBILITY.md b/BUILD_REPRODUCIBILITY.md
index 2016af4..7cd2033 100644
--- a/BUILD_REPRODUCIBILITY.md
+++ b/BUILD_REPRODUCIBILITY.md
@@ -36,8 +36,11 @@ powershell -NoProfile -ExecutionPolicy Bypass -File scripts/build-wasm.ps1 -Prom
 
 ## 信頼境界
 
-公式配布物のSHA-256を照合したclang 17.0.6とNode.js v22.18.0を作業領域内で使用し、
-復元sourceのcompile、generated-WASM golden、SIMD/scalar同値性、画素中心契約を実行済みです。
+clang 17.0.6とNode.js v22.18.0を作業領域内で使用し、復元sourceのcompile、
+generated-WASM golden、SIMD/scalar同値性、画素中心契約を実行済みです。tool配布archive自体の
+URL／SHA-256は現repositoryに保持されていないため、「公式archiveのhash照合」は再監査可能な証拠には
+含めません。再監査できる信頼境界はversion／flags、source hash、生成manifest、golden結果です。
+Provenance status: tool archive hash not retained.
 golden合格後に8 payloadと`kernels.js`を昇格し、Hosted／Standalone成果物も再生成しました。
 実測結果と生成manifestのSHA-256は`audit/v23-source-baseline.json`へ記録しています。
 
diff --git a/COMPLETION_AUDIT.md b/COMPLETION_AUDIT.md
index da1b09e..c634e32 100644
--- a/COMPLETION_AUDIT.md
+++ b/COMPLETION_AUDIT.md
@@ -2,7 +2,7 @@
 
 ## 判定
 
-`IMPROVEMENT_PROPOSAL.md`のうち、計測結果に依存しないPhase 0〜3Aの実装項目はコード、build、非ブラウザ試験へ反映した。source／ABI／数値／pixel mapping／WASM Module clone／配布物のgateは合格している。
+`IMPROVEMENT_PROPOSAL.md`のうち、Phase 0Aと計測結果に依存しないPhase 1〜3Aの実装項目はコード、build、非ブラウザ試験へ反映した。source／ABI／数値／pixel mapping／WASM Module clone／配布物の保存済みgateは合格している。v22成果物が残っていないため、v22比較項目は`not-verifiable`でありpassには含めない。
 
 ただし、固定実機を必要とするbrowser acceptanceは実行環境にin-app Browserが存在しないため未実施である。性能修正後に再開した接続監査でも3回連続のgoal turnで利用可能Browser 0件となり、2026-08-22T10:48:56.1197927Zに外部状態待ちのblockerとして再確定した。Node固定sceneではdeep BLAの高いMPPを確認し、標準deepを約1.4秒の実測時間予算へ変更済みだが、これはCanvas、Worker、入力、downloadを含むbrowser gateの代替ではない。またPhase 3BとPhase 4は、提案書自身がbrowser telemetryで支配コストまたは誤差を確認した場合だけ実施すると定義した条件付き項目であり、trigger判定も未実施である。したがって本監査は「実装・非ブラウザgate合格、実機受入blocked」と判定する。
 
@@ -36,7 +36,7 @@
 | deep／BLA／color `WebAssembly.Module` structured clone・instantiate | pass |
 | 256／320-bit direct agreement、analytic interior整数証明 | pass |
 | reference P／P+64 checkpoint agreement・故意の不一致検出 | pass |
-| Node固定scene runtime budget | pass。shallow約0.34〜0.91秒/MP、seahorse deep BLA約19.6〜36.6秒/MPのrunを観測し、deep標準を固定画素数から実測時間適応へ変更 |
+| Node固定scene計測／予算式契約 | pass。shallow 2 sceneと、出典付きのswirly-seahorses混在境界sceneでdeep BLAを測定し、deep標準を固定画素数から実測時間適応へ変更。保存値は端末負荷に依存する特性値であり、時間上限そのものをassertするgateではない |
 | 全backend pixel mapping・2×／4× tile seam | pass、851 sample |
 | 配布shallow SIMD pixel contract | pass、1,440 sample、mismatch 0 |
 | kernel source／ABI、payload checksum、Hosted／Standalone build | pass |
@@ -44,10 +44,12 @@
 
 機械可読なsource基準値は`audit/v23-source-baseline.json`、未実施browser gateは`audit/v23-browser-baseline.json`に記録した。
 
+追加のbrowser非依存監査は`audit/v23-browserless-baseline.json`へ保存した。固定Node.js v22.18.0で7 executable tests、source／document contract、配布hashを再実行してpassしたが、scopeは`browserless-current-artifacts`、`fullAcceptance: false`である。v22比較は`not-verifiable`、source-WASM buildはprior evidence reused、runtimeは測定値であり性能合格ではない。
+
 ## 条件付き項目
 
 Phase 3Bの1 shared memory統合、immutable reference／BLA table共有、WASM hot loopのatomic cancel、およびPhase 4のdouble-double、interval/error ball、scaled BLA、multi-reference、WebGPUは無条件要件ではない。`IMPROVEMENT_PROPOSAL.md` 3.3、7.7、Phase 3B／4の規定どおり、固定browser計測でcopy、memory、10^-280以深、glitch、reference生成のどれが支配的か判明した場合だけ着手する。現在はModule clone、buffer pool、短いchunk、guarded directで安全な前段を実装済みだが、telemetryがないため条件成立を主張しない。
 
 ## Browser受入の再開条件
 
-`tests/browser-benchmark.html`をHTTPで開けるin-app Browserを接続し、mobile／desktop／4Kの実viewport・DPRで実行する。runnerはsceneごとのcanvas SHA-256、Preview／Covered／Refined、idle write、long task、managed memory、deep request、wheel settle、再着色、Export完了／取消、accessibilityを採取し、`acceptance`を出力する。合格JSONを`audit/v23-browser-baseline.json`へ保存した時点で、固定実機に対する最終受入を判定できる。
+`tests/browser-benchmark.html`をHTTPで開けるin-app Browserを接続し、mobile／desktop／4Kを要求DPRの別contextで、Hosted／Standalone別に実行する。runnerはraw pixel golden、30回以上のPreview、Covered／実Refined、idle write、long task、managed／取得可能ならUA memory、deep request、非zero wheel paint、再着色、Export完了／取消／再現性、keyboard操作を採取する。observed GPU memory、visible focus、page zoom/pinch、screen-reader順序の外部証拠と統合し、全profile・全buildが揃った時点で固定実機の最終受入を判定できる。
diff --git a/IMPLEMENTATION_REPORT.md b/IMPLEMENTATION_REPORT.md
index a9df8d2..f3b0553 100644
--- a/IMPLEMENTATION_REPORT.md
+++ b/IMPLEMENTATION_REPORT.md
@@ -2,7 +2,7 @@
 
 ## 結論
 
-`IMPROVEMENT_PROPOSAL.md`で定義したv23の実装、ローカル数値検証、WASM再現build、Hosted／Standalone成果物の生成まで完了した。実ブラウザでのみ測定できる性能・表示・操作・download検証は、今回の環境にin-app browser bindingがないため未実行である。したがって、実装と非ブラウザgateは合格、browser acceptance gateは保留として扱う。
+`IMPROVEMENT_PROPOSAL.md`のv22向け設計判断をrenderer v23へ反映し、ローカル数値検証、WASM再現build、Hosted／Standalone成果物の生成まで実施した。提案は履歴文書であり、修正版のcoverage／Export／受入契約を現行基準とする。実ブラウザでのみ測定できる性能・表示・操作・download検証は、今回の環境にin-app browser bindingがないため未実行である。したがって、実装と確認済みの非ブラウザgate、未確認のbrowser acceptanceを分けて扱う。
 
 ## 実装済み
 
@@ -19,7 +19,7 @@
 - adaptive 2×／4× AA、linear-light resolve、byte-budget detail cacheを実装した。
 - 深部Worker、deep/BLA/color WASM、reference資産を遅延生成し、Worker数を実測とmemory budgetで増減する。
 - deep/BLA/colorはmainで各1回だけcompileし、compile済み`WebAssembly.Module`をWorkerへstructured cloneする。Worker sourceから埋込payload、palette LUT、RGBA生成の重複を除き、Workerは数値fieldだけを返す。
-- 通常jobから学習したstrip時間とWorker数をkernel version・端末特性keyで永続化し、次回起動で再利用する。
+- 通常jobから学習したstrip時間とWorker数をkernel version・端末帯域keyで永続化し、30日TTL、schema version、storage拒否fallbackを付けて次回起動で再利用する。
 - fixed-point direct、perturbation、rebase、BLA、局所guarded directを共通tile schedulerへ接続した。
 - deep切替を固定zoom閾値ではなくpixel stepとULPの比、hysteresisで決める。
 - deep切替とguard bitsへ直近orbitのglitch／未確定／補修率を加え、精度昇格時は低精度で作った基準軌道を破棄して再構築する。
@@ -27,6 +27,7 @@
 - f64解析・収縮判定は`INTERIOR_LIKELY`のまま保持し、ValidatedではP／P+64双方の固定小数点整数不等式で主カージオイド／周期2球を証明できたsampleだけを`INTERIOR_PROVEN`へ昇格する。
 - 精度優先のdeep描画では、基準軌道もP／P+64で独立再計算して疎なcheckpointとescape位置を照合し、不一致時はglobal reference全体を32 bit昇格して作り直す。
 - 1×／2×／4×／custom、1×／2×2 AA、Balanced／Validated、進捗、取消に対応する独立tile exportを実装した。
+- Balanced Exportは未確定数をmetadataへ記録して完了可能とし、Validated Exportは未確定sampleが残る場合にfinal PNGを出さず明示失敗する。
 - Export sidecarへViewSpec、precision／iteration policy、未確定sample数、backend、全kernel SHA-256、色空間、encoder、paletteを記録する。
 - version付きURL、戻る／進む、座標・spanの正確値入力／copy、Undo／Redoを実装した。
 - 初回UI、一般statusと診断status、mobile compact status、keyboard操作、live region、visible focus、44px target、reduced motion／transparencyを実装した。
@@ -37,7 +38,7 @@
 
 - `src/shallow_kernel.c`、`src/deep_kernel.c`、`src/bla_kernel_v18.c`、`src/color_kernel.c`、`src/abi.json`を配置した。
 - `toolchain.lock.json`でclang 17.0.6、target、SIMD／scalar flagsを固定した。
-- 公式SHA-256を照合したclang 17.0.6とNode.js v22.18.0で8 WASMを再buildした。
+- clang 17.0.6とNode.js v22.18.0で8 WASMを再buildした。tool配布archiveのURL／SHA-256はrepositoryに保持されていないため、再監査可能な証拠範囲はversion／flags、source hash、生成manifest、golden結果までとする。
 - shallow、deep、BLA、colorのgoldenとSIMD／scalar同値gateに合格後、payloadと`kernels.js`を昇格した。
 - `scripts/build-kernels.ps1`は同一payloadだけを自動deduplicateし、異なるCOLOR variantsも正しく保持する。
 - `scripts/build-hosted.ps1`は現manifest以外の古いcontent-hashed WASMを削除する。
@@ -48,7 +49,7 @@
 - Standalone: `dist/standalone/`
 - 再現build: `build/wasm-v23/`
 
-現在の非圧縮基準値は、Hosted first view 142,046 bytes、Standalone 170,593 bytesである。詳細なfile hashは`audit/v23-source-baseline.json`に記録した。
+現在の非圧縮基準値は、Hosted first view 144,044 bytes、Standalone 172,591 bytesである。詳細なfile hashは`audit/v23-source-baseline.json`に記録した。v22成果物が残っていないため、v22の転送bytes／compile timeに対するnon-regressionは判定不能であり、このv23値を今後の比較起点とする。
 
 ## 合格済みgate
 
@@ -64,7 +65,7 @@
 - 本体、shallow Worker、deep WorkerのJavaScript構文: pass
 - mock DOM初期化とv23 diagnostics: pass
 - compile済みdeep／BLA／color Moduleのstructured clone・instantiate: pass
-- Node固定scene性能基準と処理量契約: pass（`audit/v23-node-performance.json`）
+- Node固定sceneの計測記録と処理量予算式の構造契約: pass（`audit/v23-node-performance.json`）。browser時間目標の達成を意味しない
 - Hosted／Standalone buildと全payload SHA-256: pass
 
 toolchainを利用できる環境では次で省略なしに再実行できる。
@@ -75,7 +76,7 @@ powershell.exe -NoProfile -ExecutionPolicy Bypass -File scripts/test-all.ps1 -Re
 
 ## Browser acceptance gate
 
-`tests/browser-benchmark.html`は`tests/scenes.json`のmobile／desktop／4K profileと6 sceneを走査し、Preview、Covered、Refined、idle scheduler／write、long task、logical memory、canvas SHA-256をJSON化する。desktop/z0ではwheel連打、省電力がPreviewで停止すること、標準がCovered後にAA・追加反復を開始しないこと、即時再着色、64px Export、Validated Export取消、機械判定できるaccessibilityも実行し、結果へacceptance判定を付ける。今回の環境ではbrowser bindingがなかったため、`audit/v23-browser-baseline.json`は意図的に`not-run`のままである。
+`tests/browser-benchmark.html`は1 runを1 profile・1 buildへ限定し、`?profile=desktop&target=hosted`のように実行する。iframe寸法によるDPR模擬を廃止し、非zero wheelのtransform-to-paint、30回以上のPreview、実際のFine→Refined、raw pixel golden、long task、Export metadata／完了前download／再現性、keyboard操作を自動判定する。HostedとStandaloneを別に開く。visual golden未登録、observed browser/GPU memory、visible focus、page zoom/pinch、screen-reader順序は外部gateとして残り、自動項目が通ってもfull acceptanceを返さない。今回の環境ではbrowser bindingがなかったため、`audit/v23-browser-baseline.json`は`not-run`のままである。
 
 残る実機確認:
 
@@ -87,3 +88,5 @@ powershell.exe -NoProfile -ExecutionPolicy Bypass -File scripts/test-all.ps1 -Re
 - keyboard-only、focus、44px target、live status、page zoomとcanvas pinchの操作確認
 
 このgateが合格するまで、v23の実装完了と数値gate合格は主張できるが、固定実機に対する性能目標の達成は主張しない。
+
+browser非依存の現行成果物監査は`audit/v23-browserless-baseline.json`に保存した。公式SHA-256を照合したNode.js v22.18.0 portable binaryで7 executable testsが合格し、source／document contract、851 pixel mapping、1,440 pixel contract、Module cloneを再確認した。deep runtimeは出典付きの混在境界sceneで特性を測るが、値は`measured-not-acceptance`である。v22比較は`not-verifiable`、source-WASM再buildは保存済みprior evidenceの再利用として明示している。
diff --git a/IMPROVEMENT_PROPOSAL.md b/IMPROVEMENT_PROPOSAL.md
index e632f62..8022b96 100644
--- a/IMPROVEMENT_PROPOSAL.md
+++ b/IMPROVEMENT_PROPOSAL.md
@@ -1,9 +1,12 @@
 # マンデルブロ集合ビューワー 軽量・高精細化 改善提案
 
-- 対象: Mandelbrot ∞ Zoom v22
+- 対象baseline: Mandelbrot ∞ Zoom v22
+- 文書status: v22に対する実装前提案。採用項目はrenderer v23へ実装済みであり、現行状態と残存gateは`IMPLEMENTATION_REPORT.md`と`COMPLETION_AUDIT.md`を正とする。
+- Document status: historical-v22 / implemented-v23
+- 証拠境界: v22成果物とGit snapshotは現workspaceに残っていないため、v22の行番号・bytesは履歴記録であり再監査可能なbaselineではない。以後の比較基準はversion付きJSONとSHA-256を必須とする。
 - 作成日: 2026-08-22
 - 対象ファイル: `index.html`, `script.js`, `kernels.js`, `src/bla_kernel_v18.c`
-- 性格: 実装前の技術提案。効果値は、既存監査の引用を除き検証すべき目標または仮説である。
+- 性格: 設計判断を保存する履歴文書兼、修正版の品質契約。効果値は、version付き監査JSONの引用を除き検証すべき目標または仮説である。
 
 ## 1. 結論
 
@@ -27,12 +30,14 @@
 | 配布の軽さ | 初回ロード・解析・WASMコンパイルが小さい | 転送bytes、起動時に取得/compileする資産 |
 | 実行の軽さ | 操作中と待機中にCPU/GPUを浪費しない | long task、idle CPU、Canvas draw回数、消費電力 |
 | メモリの軽さ | DPR・Worker数・参照長が増えても予算内に収める | peak memory、cache bytes、Workerごとの固定領域 |
-| ラスター精細度 | 表示ピクセルを実サンプルで覆い、境界を適切にAAする | target coverage、samples/pixel、継ぎ目 |
+| ラスター精細度 | 表示ピクセルを実サンプルで覆い、境界を適切にAAする | sample coverage、resolved coverage、samples/pixel、継ぎ目 |
 | 数値精度 | 座標・反復・BLA近似の誤差を検出し、未解決を黒と混同しない | 高精度referenceとの差、unresolved数、検証モード |
 | 出力精細度 | 表示プレビューとは独立して、指定寸法を完了後に保存する | 出力寸法、AA、再現性、未完了pixel数 |
 
 「Canvasが4Kサイズである」だけでは高精細とはみなさない。低解像度フレームを4K Canvasへ拡大した状態と、4K分のサンプルを実計算した状態を区別する。
 
+本書のcoverageは次の2値へ分ける。sample coverageは宣言したiteration/precision policyで新ViewSpecのsampleを計算済みのtarget pixel比率であり、`UNRESOLVED`も計算済みsampleとして含む。resolved coverageは`ESCAPED`またはpolicy上の`INTERIOR_PROVEN`へ確定した比率である。Coveredはsample coverage 100%、Validatedはsample coverage 100%に加えてunresolved 0を要求する。
+
 ## 3. 現状評価
 
 ### 3.1 残す価値が高い部分
@@ -47,7 +52,7 @@
 
 既存のv18監査では、v17比のbase-frame改善が2.07〜5.15倍で、テストした内部早期終了は黒/外部分類不一致0だった (`AUDIT.md:60-82`, `AUDIT.md:163-176`)。この実績があるため、BLAや内部早期終了を一律に廃止する理由はない。
 
-ただし、現行コードはv22であるのに、性能監査と最終ベンチの表題・データはv18である。既存値は設計判断の参考には使えるが、v22の受入基準にはできない。最初に同じsceneをv22で再計測する必要がある。
+提案作成時の現行コードはv22だったのに、性能監査と最終ベンチの表題・データはv18だった。既存値は設計判断の参考には使えるが、v22の受入基準にはできない。当初は同じsceneのv22再計測を必要条件としたが、現在は不変なv22成果物が残っていないため比較を`not-verifiable`とし、version固定したv23以後のbaselineだけを回帰判定へ使う。
 
 ### 3.2 主要なギャップ
 
@@ -99,19 +104,19 @@
 |---|---|---|---|---|
 | Reprojected | wheel / pinch / pan継続中 | 既存フレームのtransformのみ | 入力停止待ち | プレビュー |
 | Preview | 入力停止80〜120ms後 | 時間予算内の低解像度。近似BLA可 | 最優先tileを表示 | 高速描画 |
-| Covered | Preview後 | 選択した処理モードのtarget gridを全域tile計算 | target coverage 100%、再投影pixel 0 | 全域描画 68% |
+| Covered | Preview後 | 選択した処理モードのtarget gridを全域tile計算 | sample coverage 100%、再投影pixel 0。未確定数は別表示 | 全域描画 68% |
 | Refined | Covered後のidle | 境界・不確実tileだけ2×/4× adaptive AA | 対象tile完了 | 境界AA完了 |
-| Validated | 精度優先時またはExport | 宣言した有限反復・精度policyを局所照合 | checks合格かつunresolved 0。残る場合は別状態「検証未完了・未確定N」 | 検証完了 / 検証未完了 |
+| Validated | 精度優先時またはValidated Export | 宣言した有限反復・精度policyを局所照合 | checks合格かつunresolved 0。残る場合は別状態「検証未完了・未確定N」 | 検証完了 / 検証未完了 |
 
 重要な契約は次の通り。
 
 - Previewは粗くてよいが、新しい未解決画素を「内部」と断定して黒にしない。
-- Coveredはズーム深度に関係なく、確定したScreen Canvas gridを新しいViewSpecの実sampleだけで全域計算する。再投影した旧frameは描画中のpresentationにだけ使い、coverageへ数えない。
-- 標準モードは明示したeffective DPR、精細モードは原則native DPR、Exportは指定gridをtargetにする。DPRを画素予算で下げた場合は実解像度を表示する。
+- Coveredはズーム深度に関係なく、確定したScreen Canvas gridを新しいViewSpecの実sampleだけで全域計算する。再投影した旧frameは描画中のpresentationにだけ使い、sample coverageへ数えない。計算済み`UNRESOLVED`はsample coverageへ数えるがresolved coverageへは数えない。
+- native DPRは上限であり、標準・精細とも明示したpixel/memory budget内で使う。精細は時間適応で解像度を下げないが、memory/pixel上限は維持する。DPRを制限した場合はeffective DPRと実解像度を表示する。
 - Refinedは単なる2倍補間ではなく、複数の実サンプルをlinear-lightでresolveする。
 - Validatedは数学的なマンデルブロ集合所属証明ではなく、宣言した有限反復・precision policyの照合完了を表す。全sampleへ誤差境界または証明手続きを適用する将来モードだけを`Certified`と呼ぶ。
 - 「高精細」と「数値検証完了」を同じチェックボックスにしない。
-- Exportは表示Canvasとは独立したjobであり、view、寸法、反復方針、AA、乱数seedを固定してから開始する。
+- Exportは表示Canvasとは独立したjobであり、view、寸法、反復方針、AA、precision tier、乱数seedを固定してから開始する。Balanced ExportとValidated Exportを区別し、前者は未確定数をmetadataへ記録して完了可能、後者だけをunresolved 0必須とする。
 
 処理モードと描画状態は分ける。
 
@@ -120,7 +125,9 @@
 | 省電力 | 自動Coveredなし。Previewは最大約1MP | Preview |
 | 標準 | shallowはmobile／低memory約2MP、desktop約4MP。deepはPreview実測から約1.4秒のCovered予算へeffective DPRを下げる | Covered。AA・未確定追加反復は自動実行しない |
 | 精細 | mobile／低memory約4MP、desktop約8MP。上限時は実解像度を明示 | Refined。未確定追加反復は境界候補だけを上限付きで行う |
-| 精度優先 / Export | 指定gridとprecision policy | Validated。将来はCertifiedを選択可 |
+| 精度優先 | 指定gridとprecision policy | Validated。将来はCertifiedを選択可 |
+
+Exportは処理モードではなく独立jobである。Balanced / Validatedのprecision tierを選び、それぞれRefined相当 / Validated相当の完了条件を適用する。
 
 ## 5. 推奨アーキテクチャ
 
@@ -196,7 +203,7 @@ Previewの目安は80〜120ms、停止後baseは400〜700msとし、その後は
 - deep main-thread WASM、deep worker source、Worker poolは、数値条件が閾値へ近づいた時点で準備する。
 - Workerは最初1〜2個だけ作り、実jobのthroughputから必要時だけ増やす。
 - 現在のReal Wisdomは深部HQへ到達した各ページセッションのidle時に1回、最大4 Workerなら合計10回のmini renderを追加する (`script.js:333-348`, `script.js:698`)。通常jobから受動学習し、能動ベンチは診断時または不確実時だけにする。
-- 学習結果はkernel versionと端末特性をkeyに永続化する。
+- 学習結果はkernel versionと最小限の端末帯域特性をkeyに永続化する。schema versionと保存時刻を持たせ、既定TTL 30日で失効させる。storage拒否時はsession内学習だけで動作し、raw timing履歴や過剰なfingerprint属性を保存しない。
 
 ### 6.5 WASMとメモリを統合・動的化する — P1
 
@@ -260,7 +267,7 @@ cr = centerRe + span * (2*x + 1 - width) / (2*width)
 ci = centerIm + span * (height - 2*y - 1) / (2*width)
 ```
 
-JS f64、shallow WASM、deep WASM、BLA、direct fallback、detail、exportについて、同一pixelが同一座標になるcross-backend testを追加する。整数格子式だけで現在のtile seamが実証されたわけではないが、規約を統一して将来のbackend差を防ぐ。この変更は既存URLのview中心を変えない一方、画像sampleは半画素分変化し得るため、renderer/golden image versionを上げる。
+canonical座標は上の有理数とする。fixed-point化では分子の符号と対称なround-to-nearest、exact halfはaway-from-zeroへ丸める`roundDiv`をABI契約とし、積を先に計算してから1回だけ除算する。JS f64、shallow WASM、deep WASM、BLA、direct fallback、detail、exportについて、同一pixelがcanonical座標を各backendの表現可能範囲で再現するcross-backend testを追加する。「backend差0」は整数のfixed-point表現または分類・iteration契約に対して用い、f64座標は宣言ULP以内を基準にする。整数格子式だけで現在のtile seamが実証されたわけではないが、規約を統一して将来のbackend差を防ぐ。この変更は既存URLのview中心を変えない一方、画像sampleは半画素分変化し得るため、renderer/golden image versionを上げる。
 
 ### 7.2 Covered完了後にadaptive AAする — P0/P1
 
@@ -309,7 +316,7 @@ adaptive AAを再着色可能にするには、境界pixelのsubsampleごとのs
 - `ESCAPED`: 発散が確認されたもの
 - `UNRESOLVED`: iteration/work/precision上限へ達したもの
 
-Coveredの描画中は未解決領域へ中立色または直前結果をpresentationとして重ねられるが、それを新ViewSpecのcoverageへ数えない。未解決の境界tileだけ反復を段階的に継続する。これなら、旧work capを復活させずに計算量を局所化できる。
+Coveredの描画中は未解決領域へ中立色または直前結果をpresentationとして重ねられる。旧frameの再投影はsample coverageへ数えないが、新ViewSpecでpolicy上限まで計算した`UNRESOLVED`はsample coverageへ数え、resolved coverageと未確定数で別に監査する。精細では未解決の境界tileだけ反復を段階的に継続する。これなら、旧work capを復活させずに計算量を局所化できる。
 
 収縮による内部早期終了は既存監査で有効だったためBalancedでは`INTERIOR_LIKELY`として維持する。Validatedでは判定根拠をconfidenceへ記録し、policyが要求する場合は誤差境界付き解析判定・周期証明へ上げられないものを`UNRESOLVED`へ戻す。
 
@@ -336,16 +343,16 @@ Coveredの描画中は未解決領域へ中立色または直前結果をpresent
 - reference orbitをchunk化し、固定150,001点・最大140,000反復の上限をmemory budgetへ置き換える。
 - 上限へ達した場合は「∞」を暗黙に名乗らず、現在の反復/参照/精度上限と未解決数を表示する。
 
-multi-referenceやdouble-doubleは高難度である。v22基準計測で、reference生成、glitch fallback、10^-280以深のどれが実際に支配的か確認してから実装する。
+multi-referenceやdouble-doubleは高難度である。version固定した現rendererのbrowser計測で、reference生成、glitch fallback、10^-280以深のどれが実際に支配的か確認してから実装する。v22欠落分を現renderer値で遡及的に代用しない。
 
 ### 7.8 Exportを独立pipelineにする — P0/P1
 
 `PNG`を次の2操作へ分ける。
 
 - Quick snapshot: 現在見えているCanvasを保存。Previewである可能性を明示する。
-- High-quality export: 1× / 2× / 4× / custom、AA、Balanced / Validated、進捗、取消を指定する。Certifiedは誤差境界経路を実装した後に追加する。
+- High-quality export: 1× / 2× / 4× / custom、AA、Balanced / Validated、進捗、取消を指定する。Balancedは未確定sampleをmetadataへ記録して完了可能、Validatedはchecks合格かつunresolved 0だけをfinalとして出す。Certifiedは誤差境界経路を実装した後に追加する。
 
-High-quality exportでは、固定したViewSpecをtile描画し、全tile完了後にだけencodeする。座標、span、bits、iteration policy、palette、AA、precision tier、backend、kernel hash、SIMD/scalar、色空間、encoder、renderer versionをPNG metadataまたはsidecar JSONへ記録する。同じ条件では規定許容差内で再現し、bit単位再現が必要な場合はscalar mathとencoderまで固定する。
+High-quality exportでは、固定したViewSpecをtile描画し、全tile完了後にだけencodeする。開始前に最大辺、sample数、予約bytesをpreflightし、予算超過・allocation失敗は解像度を黙って下げず明示失敗する。座標、span、bits、iteration policy、palette、AA、precision tier、backend、kernel hash、SIMD/scalar、色空間、encoder、renderer versionをPNG metadataまたはsidecar JSONへ記録する。同じ条件では規定許容差内で再現し、bit単位再現が必要な場合はscalar mathとencoderまで固定する。
 
 ## 8. 既存仕様の改廃
 
@@ -370,7 +377,7 @@ High-quality exportでは、固定したViewSpecをtile描画し、全tile完了
 | world-space cache | 維持・再設計 | style非依存field cache、quadtree key、byte budget |
 | base iteration + adaptive slider | 変更 | Auto policyは維持。生値はAdvancedへ移し、未確定数を表示 |
 | view hash / URL共有 | 強化 | version付きViewSpec、gesture settle保存、戻る/進む復元 |
-| 「∞ Zoom」表記 | 条件付き維持 | 参照長・iteration・precision上限と未確定数を併記 |
+| 「∞ Zoom」表記 | 廃止 | 有限の参照長・iteration・precision上限を持つため「Deep Zoom」とし、現在の上限と未確定数を併記 |
 | UI初期非表示 | 変更 | 初回だけ操作ヒントを表示し、以後は利用者設定を復元 |
 
 低優先度の整理対象として、未使用の`MILLION`、`last`、`sx/sy`、未使用`pilot`引数、常にfalseの`strictBoundary`、v22時点で同一内容だったCOLOR SIMD/scalar payloadがある。性能改善というより、仕様とコードのずれを減らすためにテスト後に削除する。実装後の再現buildではCOLOR variantsが異なるため、generatorは同一時だけ自動deduplicateする。
@@ -390,16 +397,28 @@ High-quality exportでは、固定したViewSpecをtile描画し、全tile完了
 
 ## 10. 実装ロードマップ
 
-### Phase 0 — v22基準化
+P0/P1/P2は利用者影響のseverityであり、実装順ではない。各項目はphase、依存先、mandatory / telemetry-conditional、未通過gateを追跡する。後段実装を先行できても、前段gateを通過したとは扱わない。
+
+### Phase 0A — browser非依存の証拠基準化
 
 - shallow/deep/colorを含む全kernel sourceを回収または復元し、固定toolchain、compile flags、生成script、payload checksumを揃える。
-- z0 / z14 / z20 / z100 / period-3 interior / boundary / 10^-280付近を固定sceneにする。
+- z0 / z14 / z20 / z100 / period-3 interior / boundary / 10^-280付近をversion付き固定sceneにする。中心座標はspan相応のguard digitsを持つdecimalかexact rationalとし、precision kind、oracle、期待分類、iteration policyをscene schemaへ保存する。
+- v22成果物が残っている場合は全対象hashとbaselineをimmutableに保存する。残っていない場合は「v22比較不能」と機械可読に記録し、後からv23値で代用しない。
+- 現行`exactDeepPixel`とは独立した、複数精度一致と誤差上限を持つ高精度reference実装で、分類、iteration、smooth valueを比較する。
+- source、ABI、pixel mapping、tile seam、SIMD/scalar、解析的内部証明、Module clone、配布物hash、文書内の生成値を同じcommandで検証する。
+- v18監査はarchiveと明記し、現renderer baselineを別JSONにする。
+
+Exit gate: 全kernelをsourceから再現buildでき、version付きsceneとoracleで数値baselineを再生成でき、全成果物hashと文書内の生成値が一致する。過去baseline欠落は明示的な`not-verifiable`でありpassにしない。
+
+### Phase 0B — 固定browser baseline
+
 - desktop、mobile相当、4Kでcold / warmを測る。
 - first preview、Covered完了、Refined完了、idle job/draw、peak memory、long taskを記録する。
-- 現行`exactDeepPixel`とは独立した、複数精度一致と誤差上限を持つ高精度reference実装で、分類、iteration、smooth valueを比較する。
-- v18監査はarchiveと明記し、v22 baselineを別JSONにする。
+- Hosted / Standalone、SIMD / scalar、Worker / Workerなしを対象構成matrixに従って分けて実行する。
+- viewportのCSS寸法だけでDPRを模擬しない。mobile / desktop / 4Kは要求DPRを持つ別browser contextまたは別実機runとし、各runの実viewport・実DPR・browser build・OS・電源・試行数を保存する。
+- visualはraw pixelまたはlinear-light fieldのversion付きgoldenと比較し、hash文字列が生成できただけではpassにしない。
 
-Exit gate: 全kernelを再現buildでき、v22の速度・memory・数値baselineを同じcommandで再生成できる。
+Exit gate: 対象profileごとのbrowser acceptanceが合格し、cold / warm、操作p95、visual、idle、long task、observed memory、Export、accessibilityのraw結果を保存する。binding不在などで未実施の場合、後続実装は進められるがbrowser性能・操作・表示の達成を主張しない。
 
 ### Phase 1A — Runtime quick wins
 
@@ -420,7 +439,7 @@ Exit gate: idle時に予約RAF/timer/background job 0、wheel中full render 0、
 - renderer/golden image versionを上げる。
 - detail BLAをbase HQ以上へ修正する。
 
-Exit gate: 同一sample座標のbackend差0、tile境界回帰0、既存URLのview中心不変を確認する。
+Exit gate: canonical rationalに対するfixed-point整数一致とf64の宣言ULP基準、tile境界回帰0、既存URLのview中心不変を確認する。
 
 ### Phase 2 — Tile/field pipeline
 
@@ -429,11 +448,11 @@ Exit gate: 同一sample座標のbackend差0、tile境界回帰0、既存URLのvi
 - shallowもWorker化し、全backendを共通tile protocolへする。
 - Reprojected / Preview / Covered / Refined状態機械を導入する。
 - palette非依存field bufferと即時再着色を導入する。
-- 処理モード別target coverage 100%を実装する。
+- 処理モード別sample coverage 100%とresolved coverage／未確定数の分離を実装する。
 - ULPベースのshallow/deep切替を導入する。
 - `ESCAPED / INTERIOR_LIKELY / INTERIOR_PROVEN / UNRESOLVED`を導入し、局所反復継続を実装する。
 
-Exit gate: target coverage 100%、再投影pixelの誤加算0、false `INTERIOR_PROVEN` 0、logical memory budget内。
+Exit gate: sample coverage 100%、再投影pixelの誤加算0、未確定数の独立計上、false `INTERIOR_PROVEN` 0、logical memory budget内。
 
 ### Phase 3A — Refine / Export
 
@@ -465,35 +484,37 @@ Phase 4は、telemetryで支配コストまたは誤差が確認された項目
 
 ## 11. 受入基準
 
+browser時間値は、profileごとに固定したbrowser build・OS・viewport・実DPR・電源条件で、warmup後30回以上を採取してp95を算出する。単発値、同期event handler時間、異なるsceneを混ぜた分位点は代用しない。Visual golden、数値oracle、threshold policyには独立したversion IDを与え、threshold欠落時はpassにしない。
+
 | 分野 | 基準案 |
 |---|---|
 | Idle | 最終更新2秒後に予約RAF/timer/background job 0、Canvas/DOM write 0回/秒。CPUは同環境blank baselineとの差を補助指標にする |
-| 操作 | transform反映p95 < 16ms、main thread 50ms超long task 0、wheel中に新規full renderを開始しない |
-| Preview | 基準端末・固定sceneでgesture settle後p95 < 120ms |
-| Covered | target Screen Canvas coverage 100%、effective DPRを表示し、再投影pixelをcoverageへ数えない。scene別時間budgetはPhase 0後に確定 |
-| Refined | 対象pixelは記録済み実sampleのlinear-light resolve。Canvas補間だけをAAと数えず、heuristicであることを明示 |
-| 数値 | false `ESCAPED` 0、false `INTERIOR_PROVEN` 0、escape iteration差・smooth誤差・`INTERIOR_LIKELY` mismatch・UNRESOLVED数を別々に記録 |
-| Pixel mapping | 全backendで同一pixelのworld座標が一致し、tile境界に1px/半pxの回帰がない |
-| Export | 指定寸法どおり、全tile完了前はfinal fileを出さない、取消可能、宣言したbackend/encoder条件で許容差内再現 |
+| 操作 | 最後の実入力eventから、その入力を反映した再投影frameのpaint完了までのp95 < 16ms、計測区間のmain thread 50ms超long task 0、継続wheel中に新規full renderを開始しない |
+| Preview | settle期限到達からPreview paint完了まで、profile・sceneごとの30回以上でp95 < 120ms |
+| Covered | target Screen Canvasのsample coverage 100%、effective DPRを表示し、再投影pixelをsample coverageへ数えない。resolved coverageとunresolved数を別記録。scene別時間budgetはPhase 0B後に確定 |
+| Refined | Fine modeで実際に`REFINED`へ到達し、対象pixelは記録済み実sampleのlinear-light resolve。subsample accountingとversion付きgoldenを比較し、Canvas補間だけをAAと数えない |
+| 数値 | version付きcorpus／oracle／threshold policyを必須とする。Validatedではcorpus上のfalse `ESCAPED` 0、false `INTERIOR_PROVEN` 0、unresolved 0。escape iteration差・smooth誤差・`INTERIOR_LIKELY` mismatchはpolicyの明示閾値で判定し、閾値未定義ならfail |
+| Pixel mapping | canonical rationalとties-away-from-zeroの`roundDiv`を基準に、fixed-point backendは期待整数と一致、f64 backendは宣言ULP以内。tile境界に1px/半pxの回帰がない |
+| Export | 指定寸法どおり、全tile完了前はfinal fileを出さない、取消可能、metadata必須項目とsample countを検査。Balancedはunresolved数を記録、Validatedは0。宣言したbackend/encoder条件とversion付きgoldenの許容差内で再現 |
 | Memory | managed typed array/WASM/cacheは暫定mobile 96 MiB、desktop 192 MiB以内。Canvas/GPUを含むobserved peakは固定環境で別記録 |
 | Startup | Hosted shallow表示ではdeep取得/compile 0。Standaloneはdeep復号/compileとWorker生成0 |
-| 配布 | shallow first viewの取得bytes・compile timeをv22 baselineより増やさず、Hostedではdeep到達前のdeep request 0 |
-| Accessibility | keyboard-only操作、visible focus、44px target、label/name、live status、page zoom、reduced motion/transparencyが合格 |
-| Regression | v22 scene corpusをCIで実行し、速度・memory・分類・例外を履歴化する |
+| 配布 | v22 baseline欠落のため初回比較は`not-verifiable`とする。v23の同一request集合・Content-Encoding・cache条件を新baselineとして固定し、以後の取得bytes・compile timeを回帰判定する。Hostedではdeep到達前のdeep request 0 |
+| Accessibility | keyboard-onlyで全操作を実行し、visible focus、44px target、label/name、live status、page zoomとCanvas pinchの共存、reduced motion/transparencyの実動作が合格。静的属性の存在だけではpassにしない |
+| Regression | version付き現行scene corpusをCIで実行し、速度・memory・分類・例外を履歴化する。各metricのwarn/fail閾値をpolicyへ保存する |
 
-端末依存の時間値は、対象端末を固定して初めて合否に使う。絶対時間だけでなく、同一scene・同一pixel数の比率とcorrectnessを主要指標にする。
+端末依存の時間値は、対象端末を固定して初めて合否に使う。絶対時間だけでなく、同一scene・同一pixel数の比率とcorrectnessを主要指標にする。browser非依存gateはsource／ABI／hash／数値oracle／pixel mapping／scene精度／document consistencyまでを証明し、paint、DPR、GPU、入力、download、実accessibilityの代替とはみなさない。
 
 ## 12. 推奨する最初の実装単位
 
 最初の変更セットは、次の範囲に限定すると効果を測りやすい。
 
-1. v22 baselineと全WASMの再現buildを用意する。
+1. v22 baselineの有無を機械可読に確定し、現renderer baselineと全WASMの再現buildを用意する。
 2. 常時RAFと毎frame DOM更新を廃止する。
 3. wheelをgestureとしてデバウンスし、非表示時のjobを止める。
 4. Screen Canvasへpixel budgetを設ける。
 5. deep poolを必要時まで作らない。
 6. 既存`q`のままPreview時間予算へ`renderPerf`を接続する。
-7. v22用のidle・gesture・startup・memory回帰テストを追加する。
+7. version付き現renderer用のidle・gesture・startup・memory回帰テストを追加する。
 
 この段階ではBLAカーネルやpixel contractをまだ変えない。まずidle負荷、入力応答、Canvas/初期memory、Preview時間を改善する。画素中心変更は、全kernelを再現buildできるPhase 1Bで行う。
 
@@ -522,7 +543,7 @@ Phase 4は、telemetryで支配コストまたは誤差が確認された項目
 | perturbation | 高精度な基準軌道との差分だけを低精度で追跡する摂動法 |
 | rebase | 差分が不安定になったとき、基準軌道上の別位置へ基準を移す処理 |
 | DPR / effective DPR | OS/browserが示すdevice pixel比 / pixel budget適用後に実際に使う比率 |
-| target coverage | 選択したScreen Canvas gridのうち、新ViewSpecで実計算済みの割合 |
+| sample / resolved coverage | 選択したScreen Canvas gridのうち、新ViewSpecでpolicy上限まで実計算済みの割合 / `ESCAPED`またはpolicy上の`INTERIOR_PROVEN`へ確定した割合 |
 | AA | Anti-Aliasing。1 pixel内の複数sampleをresolveして境界のジャギーを減らす処理 |
 | SIMD | 1命令で複数データを処理するWASM最適化 |
 | ULP | その浮動小数値付近で表現できる隣接値の間隔 |
@@ -542,4 +563,4 @@ Phase 4は、telemetryで支配コストまたは誤差が確認された項目
 | OffscreenCanvasなし | Workerはfield/RGBA bufferを返し、main Canvasへ合成 | Export encodeと合成の一部がmain thread |
 | Standalone / `file://` | 埋込WASM互換build。deepの復号・compileは遅延 | streaming、HTTP cache、COOP/COEP、Service Workerなし |
 
-最低対応browser versionとoffline cache方針は、Phase 0で実機matrixを作って確定する。
+最低対応browser versionとoffline cache方針は、Phase 0Bで実機matrixを作って確定する。
diff --git a/MIGRATION_V24.md b/MIGRATION_V24.md
new file mode 100644
index 0000000..47de5d5
--- /dev/null
+++ b/MIGRATION_V24.md
@@ -0,0 +1,115 @@
+# v23 → v24.1.3 WebGPU migration
+## v24.1.3 browser hotfix
+
+実WebGPUブラウザで`direct` shaderのparse時に、WGSL予約語`meta` / `smooth`をstorage変数名へ使用していることが判明しました。両識別子を`fieldMeta` / `fieldSmooth`へ改名し、WGSL 16.2 reserved-word listを全shader sourceへ機械照合するtestを追加しました。
+
+同時に、shader初期化失敗を通常のWebGPU非対応と同じ扱いにしてCPU f64 rendererへ落としていた挙動を廃止しました。旧挙動は数百万pixel × 数百iterationをmain-thread fallbackで実行し、shader errorの直後にUIが極端に重くなる原因でした。v24.1.3ではshader/pipeline failureは描画を停止して明示し、CPU fallbackは`navigator.gpu`がない/adapterがない場合だけ使います。screen pixel budgetも標準約1.5M（desktop）へ縮小しました。
+
+
+## 最終アーキテクチャ
+
+```text
+Main thread
+  UI / BigInt ViewState
+      │
+      ├─ shallow ─────────────────────────────┐
+      │                                      │
+      └─ deep → Reference Worker             │
+                 BigInt orbit P+64           │
+                 checkpoint guard P+128      │
+                 hi/lo f32 packing           │
+                         │                    │
+                         └──────────────┐     │
+                                        ▼     ▼
+                                  WebGPU numeric
+                            f32 direct / guarded
+                            rescaled perturbation
+                                        │
+                              fieldMeta + fieldSmooth field
+                                        │
+                              GPU color / AA
+                                        │
+                              GPU presentation
+```
+
+CPU側に残る高精度処理はview座標とreference orbit生成だけで、pixel rendererではありません。
+
+## BLAを最終版から外した理由
+
+初期WebGPU版ではCPU f64でBLAを作り、GPU用f32係数へ量子化して評価していました。しかし`swirly-seahorses-z12`を61×39へ高密度化した回帰で、BLAあり経路がbounded pixelをescapedへ反転する反例を検出しました。
+
+f64で導出した受入半径へf32係数量子化誤差を安全に織り込む設計が未確立だったため、閾値調整で残すのではなくproduction BLAを完全に除去しました。
+
+## Deep numeric policy
+
+Deepではpixel offsetを
+
+```text
+delta = w * 2^scaleExp
+```
+
+として保持します。通常反復はf32の正規化座標で行い、値域が偏った時だけ16 bit単位でrescaleします。
+
+さらにroundoff上界を追跡します。
+
+- escape候補で `|z| - error > 2` の時だけescapedを確定
+- max iteration到達時もabsolute errorがpolicy閾値以下の場合だけ`INTERIOR_LIKELY`
+- 不確かな場合は`UNKNOWN`
+
+閾値:
+
+```text
+Balanced: 1e-3
+Strict:   1e-4
+```
+
+Strictは同じ1-pass perturbationの受入閾値を厳しくするpolicyです。以前の「Fast → unresolved queue → Strict再実行」は、BLA撤去後には同じ式を二度計算するだけだったため削除しました。
+
+## 既知反例の固定
+
+`swirly-seahorses-z12`の61×39 gridで旧版が誤った3 pixelをregressionへ固定しています。
+
+```text
+(25,12) oracle bounded
+(26,15) oracle bounded
+(27,25) oracle escaped @ 1957
+```
+
+v24.1.3ではBalanced/Strictともこれらを誤分類せず`UNKNOWN`へ退避します。
+
+## Presentation / recolor
+
+数値field (`fieldMeta`, `fieldSmooth`) はGPU常駐です。色変更はGPU recolorだけで、Mandelbrot反復を再実行しません。
+
+描画中にrecolor操作が入った場合はrender tokenを破壊せず`recolorPending`へ集約し、数値frame完了後に最新色を適用します。旧版にあった`rendering=true`残留レースを避けています。
+
+## Export
+
+旧巨大Canvas方式は廃止しました。
+
+- max side 16,384
+- 512² tile
+- reusable GPU export workspace
+- 2×2 AA: 4 GPU samples → GPU linear-light resolve → 1 readback/tile
+- PNG: scanline bands → deflate stream → PNG chunks
+- sidecar: exact BigInt view + `unresolvedSamples`
+
+raw 16K RGBA全体をCanvasへ保持しないため、GPU texture limit回避だけでなくCPU raw-imageメモリも抑えます。
+
+## Fallback
+
+WebGPU contextを早期取得すると、pipeline初期化失敗後に同じCanvasを2Dへ切り替えられません。v24.1.3ではshader/pipeline作成を先に行い、成功後にWebGPU canvas contextを取得します。
+
+WebGPU unavailable時はshallow f64 fallbackのみです。deepをNumberへunderflowさせて描画する経路は削除しました。
+
+## 削除したv23 production資産
+
+- deep WASM renderer / Worker pool
+- BLA WASM renderer
+- color WASM
+- BigInt direct pixel renderer
+- CPU field → ImageData hot path
+- Canvas detail tile cache
+- Validated direct Export
+
+BigInt direct相当はテストoracleにのみ存在します。
diff --git a/README.md b/README.md
index a872da1..c64d820 100644
--- a/README.md
+++ b/README.md
@@ -1,70 +1,110 @@
-# Mandelbrot Deep Zoom v23
+# Mandelbrot Deep Zoom v24.1.3 — WebGPU
 
-軽量な操作表示と、画素中心規約・数値field・境界AA・高精度出力を分離したマンデルブロ集合ビューアーです。無条件の「∞」表記は廃止し、現在のbit数、反復上限、未確定数を表示します。
+v23のCPU/WASM deep pixel rendererを撤去し、画素計算・field・彩色・再投影・高解像度ExportをWebGPUへ移した版です。
 
-設計判断は[IMPROVEMENT_PROPOSAL.md](IMPROVEMENT_PROPOSAL.md)、実装・検証状況は[IMPLEMENTATION_REPORT.md](IMPLEMENTATION_REPORT.md)、提案ごとの対応と保留条件は[COMPLETION_AUDIT.md](COMPLETION_AUDIT.md)を参照してください。
+## 数値構成
 
-## 実行
+- ViewState: BigInt固定小数点。深度に応じてbit数を自動拡張。
+- Shallow: WebGPU `f32` direct iteration。f32座標分解能に十分な余裕があるviewだけで使用。
+- Deep reference: 専用WorkerでBigInt固定小数点orbitを1本生成。referenceはview精度より64 bit高く生成し、さらに+64 bitのguard orbitでcheckpoint照合。
+- Deep pixels: WebGPU `guarded rescaled f32 perturbation`。spanはmantissa + exponentへ分離し、`1e-400`級でもpixel offsetをf32 absolute値へ潰さない。
+- Error handling: roundoff上界がescape/bounded判定へ影響し得るpixelは `FIELD_UNKNOWN` にする。UNKNOWNを内部点へ偽装しない。
+- BLA: **productionでは無効・未搭載**。旧f32量子化BLAで境界pixelのmembership反転を再現したため、再導入していない。
 
-Standalone版は`index.html`、`script.js`、`kernels.js`の3ファイルを同じディレクトリに置き、`index.html`を直接開けます。
+旧v23の`Validated direct`は削除しています。v24.1.3のStrictは誤差許容閾値を厳しくする保守的GPU policyで、任意精度direct全画素証明ではありません。PNG sidecarは常に `membershipCertified:false` です。
 
-配信用Hosted版はPowerShellから生成します。
+## 描画パイプライン
 
-```powershell
-powershell.exe -NoProfile -ExecutionPolicy Bypass -File ./scripts/build-hosted.ps1
+通常表示ではfieldをGPUに保持します。
+
+```text
+BigInt ViewState
+  └─ deep時: BigInt reference Worker
+        ↓
+WebGPU direct / guarded perturbation
+        ↓
+fieldMeta + fieldSmooth GPU buffers
+        ↓
+GPU color / optional boundary smoothing
+        ↓
+offscreen texture
+        ↓
+GPU reprojection / canvas
 ```
 
-生成先は`dist/hosted/`です。`dist/wasm/`も同じoriginで配信し、`_headers`相当のCOOP/COEPとWASM MIME設定を反映してください。Standalone成果物は`./scripts/build-standalone.ps1`で生成できます。
+パレット・cycle・shift・HQ変更は数値fieldを再計算せずrecolorします。pan / wheel / pinch操作中は直前frameをGPUで再投影し、settle後に新しい数値frameを計算します。
 
-## v23の主要仕様
+## Export
 
-- 静止時の常時RAFとDOM更新を廃止し、invalidate時だけ描画します。
-- wheel/pinch/pan中は既存frameの再投影だけを行い、110ms停止後にPreviewを1回開始します。
-- `Reprojected → Preview → Covered → Refined → Validated/検証未完了`を内部状態として分離します。
-- Coveredは選択したeffective DPRのCanvas全域を実sampleで計算します。固定2100px HQ上限はありません。
-- 全backendのpixel mappingは`(x+0.5, y+0.5)`です。
-- escape値と分類をpalette非依存fieldに保持し、色変更では集合を再計算しません。
-- `ESCAPED / INTERIOR_LIKELY / INTERIOR_PROVEN / UNRESOLVED`を区別し、未確定を内部点と同じ黒として扱いません。
-- 境界detailは2×2 subsample fieldを保持し、linear-lightでresolveします。
-- High-quality exportは指定寸法、2×2 AA、進捗、取消、JSON sidecarに対応します。現在の表示を即時保存するQuick snapshotも別操作です。
-- deep Workerは必要時に1基だけ生成し、deepを離れた時点で大容量instanceとreferenceを退役させます。
-- cacheとScreen Canvasは端末別の論理byte/pixel budgetで管理します。
+高解像度PNGは最大辺16,384 pxです。
 
-処理モードの自動到達点:
+- 512×512以下のGPU tileで計算。
+- Export用GPU buffers/textures/readback bufferは固定workspaceを再利用し、tileごとの大量生成を避ける。
+- 2×2 AAは4 sampleをGPUで計算し、GPUでlinear-light resolveした後、tileにつき1回だけreadback。
+- 全画像Canvasを確保せず、scanline bandを`CompressionStream('deflate')`へ送りPNGを構築。
+- sidecar JSONへ`unresolvedSamples`を記録。
 
-| モード | 自動処理 |
-|---|---|
-| 省電力 | 約1MP以下のPreviewで停止 |
-| 標準 | shallowは2〜4MP。deepは48px幅の初回測定後、約1.4秒予算へ全域gridを調整。境界AAと未確定追加反復は既定で行わない |
-| 精細 | 4〜8MPの全域描画、境界AA、境界候補の上限付き追加反復 |
-| 精度優先 | 精細処理後にP／P+64照合を含む検証 |
+`unresolvedSamples > 0`は、数値policyがそのsampleを安全に分類できなかったことを意味します。
 
-## 互換構成
+## WebGPU unavailable
 
-| 構成 | shallow | deep | 出力 | 備考 |
-|---|---|---|---|---|
-| Hosted + SIMD + Worker | WASM SIMD Worker | BLA/perturbation Worker | 全機能 | 推奨 |
-| Hosted + SIMDなし | scalar payload | scalar deep/BLA | 全機能 | SIMD検査後にscalarを取得 |
-| Hosted + Workerなし | main WASM | high-precision BigInt direct | 全機能、低速 | deep WASMは取得せずdirectへ移行 |
-| Standalone `file://` | 埋込WASM | 埋込Worker/WASM | 全機能 | 3ファイル、オフライン可 |
-| OffscreenCanvasなし | Canvas 2D | 同左 | 全機能 | 現行標準経路 |
-| SharedArrayBufferなし | tile/chunk取消 | tile/chunk取消 | 全機能 | 現行標準経路 |
+WebGPUが利用できない場合は浅部のみJavaScript f64 fallbackを使います。deep zoomは誤画像を出さず、「このズーム深度はWebGPUが必要です」と表示します。
 
-## 検査
+WebGPU自体が存在しない場合だけ軽量な浅部JavaScript fallbackを使います。**WGSL/shader/pipeline初期化エラー時はCPU全画面fallbackへ自動移行しません**。エラーを表示して停止し、shader不具合を隠したままCPUを占有しない設計です。`webgpu` canvas contextはpipeline作成成功後に取得します。high-performance adapterが得られない場合は通常のadapter requestも再試行します。
 
-固定toolchainを含む全gateは次で実行します。
+## v24.1.3 hotfix
 
-```powershell
-powershell.exe -NoProfile -ExecutionPolicy Bypass -File ./scripts/test-all.ps1 -RequireToolchain
+実ブラウザで発覚したWGSL parse errorを修正しました。WGSL 16.2で予約されている`meta` / `smooth`をstorage-buffer変数名に使っていたため、`fieldMeta` / `fieldSmooth`へ変更しています。全shaderをWGSL reserved-word一覧へ照合するNode gate `tests/v24-wgsl-reserved.mjs`も追加しました。
+
+表示負荷も見直し、標準モードのscreen pixel budgetをdesktop約1.5M / 小型端末約0.75Mへ縮小しました（旧版は約4M / 2M）。省電力は約0.5M、精細は最大約3M、Strictは最大約2Mです。WebGPU非対応時のCPU fallbackは約0.25M pixelに制限します。
+
+## Standalone
+
+`index.html`, `gpu-kernels.js`, `script.js`の3ファイルで動作します。外部WGSL fetchはありません。
+
+```text
+index.html
+gpu-kernels.js
+script.js
 ```
 
-toolchainなしでsource contractだけ確認する場合は次を実行します。
+ブラウザが`file://`上でWebGPUを許可しない構成ではlocalhost/HTTPSで開いてください。
 
-```powershell
-powershell.exe -NoProfile -ExecutionPolicy Bypass -File ./tests/source-contract.ps1
-powershell.exe -NoProfile -ExecutionPolicy Bypass -File ./tests/kernel-source-contract.ps1
+## Test
+
+```bash
+npm test
+npm run build
 ```
 
-WASM checksumは`./scripts/extract-wasm.ps1`で再生成します。Nodeテストは本体／Worker構文、WASM Module clone、数値精度、解析的内部証明、pixel mapping／contractを検査します。固定sceneは`tests/scenes.json`にあります。HTTPでworkspaceを配信すれば、`tests/browser-benchmark.html`からcold/warm描画、Covered/Refined、idle write、logical memoryをscene corpus単位で採取できます。
+`npm test`は以下を検査します。
 
-WASM source buildと昇格gateは[BUILD_REPRODUCIBILITY.md](BUILD_REPRODUCIBILITY.md)を参照してください。v18の旧性能監査は履歴資料であり、v23の基準値ではありません。
+- JS syntax / source contracts
+- WGSL reserved-word token audit (`meta`, `smooth`, `ref`等を含む仕様予約語)
+- 旧C/WASM deep assetがproduction treeに残っていないこと
+- BigInt reference Worker + guard checkpoints
+- shallow f32 CPU model vs BigInt oracle
+- guarded perturbation CPU f32 model vs BigInt oracle
+- `swirly-seahorses-z12`高密度回帰と既知3反例
+- BLAがproductionから除去されていること
+- tile/pixel geometry
+- `1e-400` / `1e-1000` coordinate formatting
+- streaming PNG structure / CRC / inflate / abort
+- real-WebGPU acceptance harnessのJS syntax
+
+### 実GPU acceptance
+
+`tests/webgpu-acceptance.html`をWebGPU対応browserで開きます。これは実adapter上でshader compile / compute / readbackを行い、BigInt oracleと比較します。
+
+必須gate:
+
+- stable corpus scene: sampled `UNKNOWN = 0`
+- swirly scene: 25 sample中12以上を確定
+- `falseEscaped = 0`
+- `falseBounded = 0`
+- reference guard mismatch = 0
+- 既知dense反例で誤分類しない
+- 1× / 2×2 Export smokeの未確定sample = 0
+- uncaptured WebGPU validation error = 0
+
+このリポジトリを生成した実行環境では`navigator.gpu`が公開されなかったため、実adapter gateだけは未実行です。静的/CPU-model gateの代替ではありません。
diff --git a/audit/legacy-v23/final-browser-benchmark.json b/audit/legacy-v23/final-browser-benchmark.json
new file mode 100644
index 0000000..d2986bf
--- /dev/null
+++ b/audit/legacy-v23/final-browser-benchmark.json
@@ -0,0 +1,82 @@
+{
+  "environment": "Chromium 144 headless, 780x441 viewport, container-local",
+  "scenes": [
+    {
+      "name": "seahorse_z14",
+      "bits": 288,
+      "first": {
+        "render": "789 ms / 3490 回 · BLA 54.395ms/kpx · 内部省略 0%",
+        "badge": "深部リベース",
+        "saw": true,
+        "wall": 0.7424271106719971
+      },
+      "base": {
+        "render": "288 ms / 3490 回 · BLA 52.502ms/kpx · 内部省略 0%",
+        "badge": "深部リベース",
+        "saw": true,
+        "wall": 0.28958845138549805
+      },
+      "engine": "WASM SIMD ×2 · BLA e-28 + リベース / 288 bit",
+      "renderText": "288 ms / 3490 回 · BLA 52.502ms/kpx · 内部省略 0%",
+      "canvas": "780x441"
+    },
+    {
+      "name": "seahorse_z20",
+      "bits": 320,
+      "first": {
+        "render": "401 ms / 4509 回 · BLA 5.023ms/kpx · 内部省略 0%",
+        "badge": "深部リベース",
+        "saw": true,
+        "wall": 0.4155466556549072
+      },
+      "base": {
+        "render": "238 ms / 4509 回 · BLA 4.768ms/kpx · 内部省略 0%",
+        "badge": "深部リベース",
+        "saw": true,
+        "wall": 0.26917600631713867
+      },
+      "engine": "WASM SIMD ×2 · BLA e-23 + リベース / 320 bit",
+      "renderText": "238 ms / 4509 回 · BLA 4.768ms/kpx · 内部省略 0%",
+      "canvas": "780x441"
+    },
+    {
+      "name": "seahorse_z100",
+      "bits": 576,
+      "first": {
+        "render": "482 ms / 17085 回 · BLA 0.076ms/kpx · 内部省略 0%",
+        "badge": "深部リベース",
+        "saw": true,
+        "wall": 0.5742058753967285
+      },
+      "base": {
+        "render": "474 ms / 17085 回 · BLA 0.069ms/kpx · 内部省略 0%",
+        "badge": "深部リベース",
+        "saw": true,
+        "wall": 0.5136466026306152
+      },
+      "engine": "WASM SIMD ×2 · BLA e-23 + リベース / 576 bit",
+      "renderText": "474 ms / 17085 回 · BLA 0.069ms/kpx · 内部省略 0%",
+      "canvas": "780x441"
+    },
+    {
+      "name": "period3_z20",
+      "bits": 320,
+      "first": {
+        "render": "1420 ms / 4509 回 · BLA 0.395ms/kpx · 内部省略 100%",
+        "badge": "深部リベース",
+        "saw": true,
+        "wall": 1.5150198936462402
+      },
+      "base": {
+        "render": "781 ms / 4509 回 · BLA 0.373ms/kpx · 内部省略 100%",
+        "badge": "深部リベース",
+        "saw": true,
+        "wall": 0.8927633762359619
+      },
+      "engine": "WASM SIMD ×2 · BLA e-23 + リベース · 内部早期終了 100% / 320 bit",
+      "renderText": "781 ms / 4509 回 · BLA 0.373ms/kpx · 内部省略 100%",
+      "canvas": "780x441"
+    }
+  ],
+  "errorCount": 0
+}
\ No newline at end of file
diff --git a/audit/v23-browser-baseline.json b/audit/v23-browser-baseline.json
index 307e17e..7b33914 100644
--- a/audit/v23-browser-baseline.json
+++ b/audit/v23-browser-baseline.json
@@ -10,7 +10,9 @@
     "outcome": "blocked",
     "recovery": "Connect an in-app Browser, then rerun tests/browser-benchmark.html. Unrelated browser-control backends are intentionally not substituted. Node runtime-budget coverage is available in audit/v23-node-performance.json but does not replace the browser gate."
   },
-  "runner": "tests/browser-benchmark.html",
+  "runner": "tests/browser-benchmark.html?profile=<mobile|desktop|4k>&target=<hosted|standalone>",
+  "executionModel": "one real-DPR profile and one build target per run; iframe sizing does not emulate DPR",
+  "requiredTargets": ["hosted", "standalone"],
   "requiredProfiles": ["mobile", "desktop", "4k"],
   "acceptancePending": ["visual output", "requested viewport and actual DPR fidelity", "interaction p95", "Preview/Covered/Refined timing", "Power stops at Preview", "Standard stops at Covered without AA/continuation", "idle writes", "long tasks", "observed browser/GPU peak memory", "export download/cancel", "keyboard/focus/target-size/live-status/page-zoom accessibility"]
 }
diff --git a/audit/v23-browserless-baseline.json b/audit/v23-browserless-baseline.json
new file mode 100644
index 0000000..fc6c2a3
--- /dev/null
+++ b/audit/v23-browserless-baseline.json
@@ -0,0 +1,267 @@
+{
+    "format":  "mandelbrot-browserless-audit-v23",
+    "generatedUtc":  "2026-08-22T12:35:37.5161338Z",
+    "status":  "pass",
+    "scope":  "browserless-current-artifacts",
+    "fullAcceptance":  false,
+    "rendererVersion":  23,
+    "node":  {
+                 "version":  "v22.18.0",
+                 "archive":  {
+                                 "file":  ".tmp-node-v22.18.0-win-x64.zip",
+                                 "sha256":  "c95d8a7e1c99e669cc08c9f1176e068c1f50847c37908fcb8c35b62482366511",
+                                 "source":  "https://nodejs.org/dist/v22.18.0/node-v22.18.0-win-x64.zip"
+                             }
+             },
+    "contracts":  {
+                      "kernel":  {
+                                     "status":  "pass",
+                                     "modules":  4,
+                                     "compiler":  "17.0.6",
+                                     "pixelContract":  "sample centers at x + 0.5, y + 0.5"
+                                 },
+                      "source":  {
+                                     "status":  "pass",
+                                     "rendererVersion":  23,
+                                     "wasmPayloads":  8,
+                                     "scriptBytes":  129807,
+                                     "htmlBytes":  11395
+                                 },
+                      "document":  {
+                                       "status":  "pass",
+                                       "proposalContract":  "revised-v23",
+                                       "scenes":  7,
+                                       "viewports":  3,
+                                       "numericPolicy":  "numeric-policy-v23",
+                                       "hashedFiles":  13,
+                                       "browserRunner":  "static-contract-pass",
+                                       "browserlessEvidence":  "pass-with-explicit-limits"
+                                   }
+                  },
+    "executableTests":  {
+                            "js-syntax.mjs":  {
+                                                  "status":  "pass",
+                                                  "rendererVersion":  23,
+                                                  "lastPass":  "preview",
+                                                  "automaticTarget":  "COVERED",
+                                                  "fieldIterations":  [
+                                                                          7,
+                                                                          100
+                                                                      ],
+                                                  "modeProbe":  {
+                                                                    "targets":  {
+                                                                                    "power":  "PREVIEW",
+                                                                                    "standard":  "COVERED",
+                                                                                    "fine":  "REFINED",
+                                                                                    "validate":  "VALIDATED"
+                                                                                },
+                                                                    "coldDeepPreview":  [
+                                                                                            48,
+                                                                                            36
+                                                                                        ]
+                                                                },
+                                                  "referenceCheckpoints":  {
+                                                                               "agreement":  true,
+                                                                               "catchesMismatch":  true,
+                                                                               "count":  17,
+                                                                               "bits":  320
+                                                                           },
+                                                  "deepWorkerModuleInit":  true,
+                                                  "browserHarnessSyntax":  true,
+                                                  "sources":  {
+                                                                  "appBytes":  129807,
+                                                                  "shallowWorkerCharacters":  1509,
+                                                                  "deepWorkerCharacters":  8788
+                                                              }
+                                              },
+                            "module-clone.mjs":  {
+                                                     "status":  "pass",
+                                                     "structuredClone":  true,
+                                                     "results":  [
+                                                                     {
+                                                                         "name":  "deep-simd.wasm",
+                                                                         "bytes":  4866,
+                                                                         "exports":  [
+                                                                                         "render_perturb_rebase_rect"
+                                                                                     ]
+                                                                     },
+                                                                     {
+                                                                         "name":  "bla-simd.wasm",
+                                                                         "bytes":  4959,
+                                                                         "exports":  [
+                                                                                         "build_bla",
+                                                                                         "render_bla_rect_v2"
+                                                                                     ]
+                                                                     },
+                                                                     {
+                                                                         "name":  "color-simd.wasm",
+                                                                         "bytes":  1387,
+                                                                         "exports":  [
+                                                                                         "smooth_batch"
+                                                                                     ]
+                                                                     }
+                                                                 ]
+                                                 },
+                            "precision-reference.mjs":  {
+                                                            "status":  "pass",
+                                                            "precisions":  [
+                                                                               256,
+                                                                               320
+                                                                           ],
+                                                            "results":  [
+                                                                            {
+                                                                                "id":  "outside",
+                                                                                "p":  3,
+                                                                                "guarded":  3,
+                                                                                "stable":  true
+                                                                            },
+                                                                            {
+                                                                                "id":  "boundary-escape",
+                                                                                "p":  33,
+                                                                                "guarded":  33,
+                                                                                "stable":  true
+                                                                            },
+                                                                            {
+                                                                                "id":  "period3-center",
+                                                                                "p":  4000,
+                                                                                "guarded":  4000,
+                                                                                "stable":  true
+                                                                            }
+                                                                        ]
+                                                        },
+                            "analytic-interior.mjs":  {
+                                                          "status":  "pass",
+                                                          "checked":  14,
+                                                          "precisions":  [
+                                                                             256,
+                                                                             320
+                                                                         ],
+                                                          "proof":  "integer cardioid/period-2 inequalities"
+                                                      },
+                            "pixel-mapping.mjs":  {
+                                                      "status":  "pass",
+                                                      "samples":  851,
+                                                      "backends":  [
+                                                                       "shallow",
+                                                                       "deep",
+                                                                       "bla"
+                                                                   ],
+                                                      "subsampleScales":  [
+                                                                              2,
+                                                                              4
+                                                                          ],
+                                                      "contract":  "centered-rational",
+                                                      "float64UlpMax":  4,
+                                                      "fixedPointRounding":  "nearest-ties-away-from-zero"
+                                                  },
+                            "pixel-contract.mjs":  {
+                                                       "status":  "pass",
+                                                       "backend":  "simd",
+                                                       "samples":  1440,
+                                                       "mismatches":  0,
+                                                       "contract":  "(x+0.5,y+0.5)"
+                                                   },
+                            "runtime-budget.mjs":  {
+                                                       "format":  "mandelbrot-node-runtime-budget-v23",
+                                                       "generatedUtc":  "2026-08-22T12:35:33.428Z",
+                                                       "node":  "v22.18.0",
+                                                       "status":  "measured",
+                                                       "acceptance":  false,
+                                                       "sceneCorpus":  "mandelbrot-scene-corpus-v2",
+                                                       "measurementNote":  "Runtime characterization only; browser acceptance has separate thresholds and evidence.",
+                                                       "contracts":  {
+                                                                         "previewBudget110":  true,
+                                                                         "modeTargets":  true,
+                                                                         "screenBudgets":  true,
+                                                                         "boundedContinuation":  true,
+                                                                         "coldDeepCap":  true,
+                                                                         "measuredDeepBudget":  true,
+                                                                         "viewportIndependentFloor":  true
+                                                                     },
+                                                       "shallow":  [
+                                                                       {
+                                                                           "id":  "overview-350",
+                                                                           "width":  640,
+                                                                           "height":  400,
+                                                                           "iterations":  350,
+                                                                           "pixels":  256000,
+                                                                           "medianMs":  85.583,
+                                                                           "msPerMegapixel":  334.30859375,
+                                                                           "meanIterations":  78.3253515625,
+                                                                           "samplesMs":  [
+                                                                                             85.583,
+                                                                                             88.88799999999998,
+                                                                                             84.14580000000001,
+                                                                                             84.10900000000004,
+                                                                                             92.09339999999997
+                                                                                         ]
+                                                                       },
+                                                                       {
+                                                                           "id":  "boundary-900",
+                                                                           "width":  512,
+                                                                           "height":  320,
+                                                                           "iterations":  900,
+                                                                           "pixels":  163840,
+                                                                           "medianMs":  113.91780000000006,
+                                                                           "msPerMegapixel":  695.2990722656253,
+                                                                           "meanIterations":  154.49669189453124,
+                                                                           "samplesMs":  [
+                                                                                             115.31709999999998,
+                                                                                             113.91780000000006,
+                                                                                             112.1979,
+                                                                                             112.90809999999988,
+                                                                                             117.25350000000003
+                                                                                         ]
+                                                                       }
+                                                                   ],
+                                                       "deep":  {
+                                                                    "id":  "swirly-seahorses-z12-bla-2000",
+                                                                    "width":  256,
+                                                                    "height":  144,
+                                                                    "iterations":  2000,
+                                                                    "pixels":  36864,
+                                                                    "blaEntries":  12,
+                                                                    "buildMs":  0.27119999999990796,
+                                                                    "medianMs":  395.4109000000003,
+                                                                    "msPerMegapixel":  10726.207139756953,
+                                                                    "unresolved":  0,
+                                                                    "samplesMs":  [
+                                                                                      388.1887999999999,
+                                                                                      394.21360000000004,
+                                                                                      413.6929,
+                                                                                      395.4109000000003,
+                                                                                      396.3185000000003
+                                                                                  ]
+                                                                }
+                                                   }
+                        },
+    "runtime":  {
+                    "status":  "measured-not-acceptance",
+                    "report":  "audit/v23-browserless-runtime.json",
+                    "reason":  "Runtime values are environment/load dependent and no browser paint/input/GPU threshold is asserted."
+                },
+    "sourceWasmBuild":  {
+                            "status":  "prior-evidence-reused",
+                            "manifest":  {
+                                             "file":  "build/wasm-v23/manifest.json",
+                                             "bytes":  4193,
+                                             "sha256":  "cc388d664f642181d45a110ea5b44c47524050f8bf904ebd115e8e24c0f58a18"
+                                         },
+                            "reason":  "Verified generated manifest reused; fixed toolchain was removed after the successful gate."
+                        },
+    "v22Comparison":  {
+                          "status":  "not-verifiable",
+                          "reason":  "No immutable v22 artifacts, hashes, or versioned baseline are present."
+                      },
+    "browserAcceptance":  {
+                              "status":  "not-run",
+                              "report":  "audit/v23-browser-baseline.json",
+                              "nonSubstitutable":  [
+                                                       "actual DPR and visual output",
+                                                       "transform-to-paint and Preview p95",
+                                                       "long tasks and observed browser/GPU memory",
+                                                       "download/cancel behavior",
+                                                       "keyboard/focus/page-zoom/screen-reader behavior"
+                                                   ]
+                          }
+}
diff --git a/audit/v23-browserless-runtime.json b/audit/v23-browserless-runtime.json
new file mode 100644
index 0000000..97d2c34
--- /dev/null
+++ b/audit/v23-browserless-runtime.json
@@ -0,0 +1,73 @@
+{
+  "format": "mandelbrot-node-runtime-budget-v23",
+  "generatedUtc": "2026-08-22T12:35:33.428Z",
+  "node": "v22.18.0",
+  "status": "measured",
+  "acceptance": false,
+  "sceneCorpus": "mandelbrot-scene-corpus-v2",
+  "measurementNote": "Runtime characterization only; browser acceptance has separate thresholds and evidence.",
+  "contracts": {
+    "previewBudget110": true,
+    "modeTargets": true,
+    "screenBudgets": true,
+    "boundedContinuation": true,
+    "coldDeepCap": true,
+    "measuredDeepBudget": true,
+    "viewportIndependentFloor": true
+  },
+  "shallow": [
+    {
+      "id": "overview-350",
+      "width": 640,
+      "height": 400,
+      "iterations": 350,
+      "pixels": 256000,
+      "medianMs": 85.583,
+      "msPerMegapixel": 334.30859375,
+      "meanIterations": 78.3253515625,
+      "samplesMs": [
+        85.583,
+        88.88799999999998,
+        84.14580000000001,
+        84.10900000000004,
+        92.09339999999997
+      ]
+    },
+    {
+      "id": "boundary-900",
+      "width": 512,
+      "height": 320,
+      "iterations": 900,
+      "pixels": 163840,
+      "medianMs": 113.91780000000006,
+      "msPerMegapixel": 695.2990722656253,
+      "meanIterations": 154.49669189453124,
+      "samplesMs": [
+        115.31709999999998,
+        113.91780000000006,
+        112.1979,
+        112.90809999999988,
+        117.25350000000003
+      ]
+    }
+  ],
+  "deep": {
+    "id": "swirly-seahorses-z12-bla-2000",
+    "width": 256,
+    "height": 144,
+    "iterations": 2000,
+    "pixels": 36864,
+    "blaEntries": 12,
+    "buildMs": 0.27119999999990796,
+    "medianMs": 395.4109000000003,
+    "msPerMegapixel": 10726.207139756953,
+    "unresolved": 0,
+    "samplesMs": [
+      388.1887999999999,
+      394.21360000000004,
+      413.6929,
+      395.4109000000003,
+      396.3185000000003
+    ]
+  }
+}
diff --git a/audit/v23-source-baseline.json b/audit/v23-source-baseline.json
index bf0e79a..b131b5f 100644
--- a/audit/v23-source-baseline.json
+++ b/audit/v23-source-baseline.json
@@ -1,12 +1,12 @@
 {
     "format":  "mandelbrot-source-baseline-v23",
-    "generatedUtc":  "2026-08-22T10:48:34.5532410Z",
+    "generatedUtc":  "2026-08-22T12:30:30.4538464Z",
     "rendererVersion":  23,
     "contract":  {
                      "status":  "pass",
                      "rendererVersion":  23,
                      "wasmPayloads":  8,
-                     "scriptBytes":  129452,
+                     "scriptBytes":  129807,
                      "htmlBytes":  11395
                  },
     "hosted":  {
@@ -23,8 +23,8 @@
                                           },
                                           {
                                               "file":  "dist/hosted/script.js",
-                                              "bytes":  129452,
-                                              "sha256":  "97a1a3d897fa0f7bce3a30727a0e90a767799356b12899c074fdb04968506ace"
+                                              "bytes":  129807,
+                                              "sha256":  "6ffebe51532fb8a141e9b1939e586d76b6c79db18786c06713e67ffe8d4ca78a"
                                           },
                                           {
                                               "file":  "dist/wasm/wasm-simd.d19b26c04e1b2f59.wasm",
@@ -32,9 +32,10 @@
                                               "sha256":  "d19b26c04e1b2f59ee1e9c8f6df0ceb9d6b2a56d08b906c0f3b8d9e10903460b"
                                           }
                                       ],
-                   "firstViewUncompressedBytes":  143689,
-                   "deepRequestsBeforeDeepView":  0,
-                   "note":  "Transfer compression, parse, compile, and runtime timings require the fixed browser benchmark."
+                   "firstViewUncompressedBytes":  144044,
+                   "deepRequestContractBeforeDeepView":  0,
+                   "deepRequestMeasurementStatus":  "not-run",
+                   "note":  "The zero is a static loader contract, not a measured request count. Transfer compression, request count, parse, compile, and runtime timings require the fixed Hosted browser benchmark."
                },
     "standalone":  {
                        "files":  [
@@ -45,8 +46,8 @@
                                      },
                                      {
                                          "file":  "dist/standalone/script.js",
-                                         "bytes":  129452,
-                                         "sha256":  "97a1a3d897fa0f7bce3a30727a0e90a767799356b12899c074fdb04968506ace"
+                                         "bytes":  129807,
+                                         "sha256":  "6ffebe51532fb8a141e9b1939e586d76b6c79db18786c06713e67ffe8d4ca78a"
                                      },
                                      {
                                          "file":  "dist/standalone/kernels.js",
@@ -54,7 +55,7 @@
                                          "sha256":  "e97726c09af138da92b331c376766c1128c10aa3c361b83750356824262ea1a0"
                                      }
                                  ],
-                       "uncompressedBytes":  172236
+                       "uncompressedBytes":  172591
                    },
     "sourceBuild":  {
                         "files":  [
diff --git a/audit/v24-bla-status.json b/audit/v24-bla-status.json
new file mode 100644
index 0000000..f0a4265
--- /dev/null
+++ b/audit/v24-bla-status.json
@@ -0,0 +1,6 @@
+{
+  "status": "pass",
+  "kind": "bla-disabled-contract",
+  "reason": "dense swirly regression demonstrated unsafe f32-quantized BLA classifications",
+  "productionBla": false
+}
diff --git a/audit/v24-cpu-numeric-model.json b/audit/v24-cpu-numeric-model.json
new file mode 100644
index 0000000..4de2c0c
--- /dev/null
+++ b/audit/v24-cpu-numeric-model.json
@@ -0,0 +1,266 @@
+{
+  "status": "pass",
+  "kind": "guarded-production-equation-cpu-f32-model-not-real-gpu",
+  "thresholds": {
+    "balanced": 0.001,
+    "strict": 0.0001
+  },
+  "report": [
+    {
+      "mode": "balanced",
+      "id": "period2-cusp-z14",
+      "bits": 285,
+      "limit": 1200,
+      "guardMismatch": 0,
+      "falseEscaped": 0,
+      "falseBounded": 0,
+      "unknown": 0,
+      "known": 187,
+      "exactEscape": 0,
+      "mismatch": []
+    },
+    {
+      "mode": "balanced",
+      "id": "swirly-seahorses-z12",
+      "bits": 279,
+      "limit": 2000,
+      "guardMismatch": 0,
+      "falseEscaped": 0,
+      "falseBounded": 0,
+      "unknown": 71,
+      "known": 116,
+      "exactEscape": 110,
+      "mismatch": []
+    },
+    {
+      "mode": "balanced",
+      "id": "period2-cusp-z20",
+      "bits": 305,
+      "limit": 1800,
+      "guardMismatch": 0,
+      "falseEscaped": 0,
+      "falseBounded": 0,
+      "unknown": 0,
+      "known": 187,
+      "exactEscape": 0,
+      "mismatch": []
+    },
+    {
+      "mode": "balanced",
+      "id": "period2-cusp-z100",
+      "bits": 571,
+      "limit": 2400,
+      "guardMismatch": 0,
+      "falseEscaped": 0,
+      "falseBounded": 0,
+      "unknown": 0,
+      "known": 187,
+      "exactEscape": 0,
+      "mismatch": []
+    },
+    {
+      "mode": "balanced",
+      "id": "period3-interior",
+      "bits": 267,
+      "limit": 1200,
+      "guardMismatch": 0,
+      "falseEscaped": 0,
+      "falseBounded": 0,
+      "unknown": 0,
+      "known": 187,
+      "exactEscape": 0,
+      "mismatch": []
+    },
+    {
+      "mode": "balanced",
+      "id": "period2-cusp-e280",
+      "bits": 1171,
+      "limit": 2400,
+      "guardMismatch": 0,
+      "falseEscaped": 0,
+      "falseBounded": 0,
+      "unknown": 0,
+      "known": 187,
+      "exactEscape": 0,
+      "mismatch": []
+    },
+    {
+      "mode": "balanced",
+      "id": "period2-cusp-e400",
+      "bits": 1569,
+      "limit": 1600,
+      "guardMismatch": 0,
+      "falseEscaped": 0,
+      "falseBounded": 0,
+      "unknown": 0,
+      "known": 187,
+      "exactEscape": 0,
+      "mismatch": []
+    },
+    {
+      "mode": "strict",
+      "id": "period2-cusp-z14",
+      "bits": 285,
+      "limit": 1200,
+      "guardMismatch": 0,
+      "falseEscaped": 0,
+      "falseBounded": 0,
+      "unknown": 0,
+      "known": 187,
+      "exactEscape": 0,
+      "mismatch": []
+    },
+    {
+      "mode": "strict",
+      "id": "swirly-seahorses-z12",
+      "bits": 279,
+      "limit": 2000,
+      "guardMismatch": 0,
+      "falseEscaped": 0,
+      "falseBounded": 0,
+      "unknown": 71,
+      "known": 116,
+      "exactEscape": 110,
+      "mismatch": []
+    },
+    {
+      "mode": "strict",
+      "id": "period2-cusp-z20",
+      "bits": 305,
+      "limit": 1800,
+      "guardMismatch": 0,
+      "falseEscaped": 0,
+      "falseBounded": 0,
+      "unknown": 0,
+      "known": 187,
+      "exactEscape": 0,
+      "mismatch": []
+    },
+    {
+      "mode": "strict",
+      "id": "period2-cusp-z100",
+      "bits": 571,
+      "limit": 2400,
+      "guardMismatch": 0,
+      "falseEscaped": 0,
+      "falseBounded": 0,
+      "unknown": 0,
+      "known": 187,
+      "exactEscape": 0,
+      "mismatch": []
+    },
+    {
+      "mode": "strict",
+      "id": "period3-interior",
+      "bits": 267,
+      "limit": 1200,
+      "guardMismatch": 0,
+      "falseEscaped": 0,
+      "falseBounded": 0,
+      "unknown": 0,
+      "known": 187,
+      "exactEscape": 0,
+      "mismatch": []
+    },
+    {
+      "mode": "strict",
+      "id": "period2-cusp-e280",
+      "bits": 1171,
+      "limit": 2400,
+      "guardMismatch": 0,
+      "falseEscaped": 0,
+      "falseBounded": 0,
+      "unknown": 0,
+      "known": 187,
+      "exactEscape": 0,
+      "mismatch": []
+    },
+    {
+      "mode": "strict",
+      "id": "period2-cusp-e400",
+      "bits": 1569,
+      "limit": 1600,
+      "guardMismatch": 0,
+      "falseEscaped": 0,
+      "falseBounded": 0,
+      "unknown": 0,
+      "known": 187,
+      "exactEscape": 0,
+      "mismatch": []
+    }
+  ],
+  "denseRegression": [
+    {
+      "mode": "balanced",
+      "x": 25,
+      "y": 12,
+      "oracle": 2000,
+      "gpu": {
+        "kind": "unknown",
+        "n": 2000,
+        "reason": "error-bound",
+        "err": 2.1991906643574973e+21
+      }
+    },
+    {
+      "mode": "strict",
+      "x": 25,
+      "y": 12,
+      "oracle": 2000,
+      "gpu": {
+        "kind": "unknown",
+        "n": 2000,
+        "reason": "error-bound",
+        "err": 2.1991906643574973e+21
+      }
+    },
+    {
+      "mode": "balanced",
+      "x": 26,
+      "y": 15,
+      "oracle": 2000,
+      "gpu": {
+        "kind": "unknown",
+        "n": 2000,
+        "reason": "error-bound",
+        "err": 7.768308137076909e+21
+      }
+    },
+    {
+      "mode": "strict",
+      "x": 26,
+      "y": 15,
+      "oracle": 2000,
+      "gpu": {
+        "kind": "unknown",
+        "n": 2000,
+        "reason": "error-bound",
+        "err": 7.768308137076909e+21
+      }
+    },
+    {
+      "mode": "balanced",
+      "x": 27,
+      "y": 25,
+      "oracle": 1957,
+      "gpu": {
+        "kind": "unknown",
+        "n": 2000,
+        "reason": "error-bound",
+        "err": 2084483903264.6707
+      }
+    },
+    {
+      "mode": "strict",
+      "x": 27,
+      "y": 25,
+      "oracle": 1957,
+      "gpu": {
+        "kind": "unknown",
+        "n": 2000,
+        "reason": "error-bound",
+        "err": 2084483903264.6707
+      }
+    }
+  ]
+}
diff --git a/audit/v24-real-webgpu-status.json b/audit/v24-real-webgpu-status.json
new file mode 100644
index 0000000..52bee48
--- /dev/null
+++ b/audit/v24-real-webgpu-status.json
@@ -0,0 +1,24 @@
+{
+  "status": "v24.1.3-real-webgpu-rerun-pending",
+  "gate": "real-webgpu-compile-dispatch-numeric-acceptance",
+  "environment": {
+    "browser": "Chromium 144.0.7559.96 Debian GNU/Linux 13",
+    "display": "container/Xvfb",
+    "navigatorGpuPreviouslyObserved": false,
+    "latestAttempt": "GPU command-buffer/context initialization failed before acceptance completed",
+    "adapterAccepted": false
+  },
+  "attemptedModes": [
+    "headless Chromium default",
+    "--enable-unsafe-webgpu",
+    "--enable-unsafe-webgpu --use-angle=swiftshader",
+    "Xvfb + unsafe WebGPU"
+  ],
+  "interpretation": "The reported real-browser v24.1.2 parse failure is fixed in source in v24.1.3. This container still cannot obtain a real WebGPU adapter, so v24.1.3 compile/dispatch must be rerun on a WebGPU-capable browser/device.",
+  "externalObservation": {
+    "version": "24.1.2",
+    "result": "shader-parse-failed",
+    "error": "WGSL reserved identifiers meta and smooth in direct shader",
+    "hotfix": "renamed to fieldMeta/fieldSmooth; reserved-word static gate added"
+  }
+}
diff --git a/audit/v24-release-manifest.json b/audit/v24-release-manifest.json
new file mode 100644
index 0000000..7a52b74
--- /dev/null
+++ b/audit/v24-release-manifest.json
@@ -0,0 +1,196 @@
+{
+  "format": "mandelbrot-v24.1.3-release-manifest",
+  "generatedAt": "2026-08-23T16:17:33+09:00",
+  "files": [
+    {
+      "path": "AUDIT_V24.md",
+      "bytes": 4405,
+      "sha256": "ef09e435b24a64bdbf0872e9f182c31ab2edea5afd0c959a5681d2b9be87ddbf"
+    },
+    {
+      "path": "MIGRATION_V24.md",
+      "bytes": 5185,
+      "sha256": "2a4fe1754c521901b0e1f2c99d46426055fd3dc2932da93df12ea01a15469839"
+    },
+    {
+      "path": "README.md",
+      "bytes": 5532,
+      "sha256": "5d3e7db74400db1fb0585f23b966d1eab08f3729fe5f253ef533060f65f1790d"
+    },
+    {
+      "path": "audit/legacy-v23/final-browser-benchmark.json",
+      "bytes": 2686,
+      "sha256": "bca2e141c101722f8a077d43346c2c28b5d8d7c99e70415730031065c8ab5a1c"
+    },
+    {
+      "path": "audit/v24-bla-status.json",
+      "bytes": 177,
+      "sha256": "84587eb2183b1e6a2837f5018e74f32bc968c536d64cee7cf5fed55f7d3b21df"
+    },
+    {
+      "path": "audit/v24-cpu-numeric-model.json",
+      "bytes": 5391,
+      "sha256": "f25e830d831f828b84f327670b5be5e9afcf6118164b2d217a9eae24443f84bf"
+    },
+    {
+      "path": "audit/v24-real-webgpu-status.json",
+      "bytes": 1066,
+      "sha256": "9791925d9ddb890644b895d4cd659d7377d7c48dd94df86495fef04ee1325c8a"
+    },
+    {
+      "path": "audit/v24-release-verification.json",
+      "bytes": 290,
+      "sha256": "6cd0dd2b293bae482e8cbd511caa50aebe34597ee2c12b442de75fa7a937dccd"
+    },
+    {
+      "path": "audit/v24-test-summary.json",
+      "bytes": 3373,
+      "sha256": "260173d15640a9681ae049f3e1c2707c774cf2af7a4fc4d6475115e7be344e8c"
+    },
+    {
+      "path": "dist/hosted/_headers",
+      "bytes": 68,
+      "sha256": "3d11be43c945209eb7e4503e384ac3007c42ee4022cfc23fc005f6217bda8d1b"
+    },
+    {
+      "path": "dist/hosted/gpu-kernels.js",
+      "bytes": 12196,
+      "sha256": "aab457adce3cf1bf52eca6416c7c9570f4feb3579580a8cc95ae2425f8aea68a"
+    },
+    {
+      "path": "dist/hosted/index.html",
+      "bytes": 11416,
+      "sha256": "adf0dc65d2cfbb6ca56494651d40fc6874aedcd088f4170650d97fdde9c0e5dc"
+    },
+    {
+      "path": "dist/hosted/script.js",
+      "bytes": 58865,
+      "sha256": "eca75aaba2e859ab73d79a46a76329ffb41c438e413bf24f7a4b21328f8f0e61"
+    },
+    {
+      "path": "dist/standalone/gpu-kernels.js",
+      "bytes": 12196,
+      "sha256": "aab457adce3cf1bf52eca6416c7c9570f4feb3579580a8cc95ae2425f8aea68a"
+    },
+    {
+      "path": "dist/standalone/index.html",
+      "bytes": 11416,
+      "sha256": "adf0dc65d2cfbb6ca56494651d40fc6874aedcd088f4170650d97fdde9c0e5dc"
+    },
+    {
+      "path": "dist/standalone/script.js",
+      "bytes": 58865,
+      "sha256": "eca75aaba2e859ab73d79a46a76329ffb41c438e413bf24f7a4b21328f8f0e61"
+    },
+    {
+      "path": "gpu-kernels.js",
+      "bytes": 12196,
+      "sha256": "aab457adce3cf1bf52eca6416c7c9570f4feb3579580a8cc95ae2425f8aea68a"
+    },
+    {
+      "path": "index.html",
+      "bytes": 11416,
+      "sha256": "adf0dc65d2cfbb6ca56494651d40fc6874aedcd088f4170650d97fdde9c0e5dc"
+    },
+    {
+      "path": "package.json",
+      "bytes": 199,
+      "sha256": "0fa1b8155f09356fba73e94c8db6428f1367aefef40efd116ad89c89a8a8a13f"
+    },
+    {
+      "path": "script.js",
+      "bytes": 58865,
+      "sha256": "eca75aaba2e859ab73d79a46a76329ffb41c438e413bf24f7a4b21328f8f0e61"
+    },
+    {
+      "path": "scripts/build.mjs",
+      "bytes": 657,
+      "sha256": "84706582dd01d6de28cbc0fcdba9758c3f6f72a3d5693b74736109b35819997f"
+    },
+    {
+      "path": "scripts/test-all.mjs",
+      "bytes": 818,
+      "sha256": "1fbebd942d5c3ee94a1cbb449a29168c50b0bc8d3285cbae1c7c01eb188b29ec"
+    },
+    {
+      "path": "tests/legacy-v23/numeric-policy-v23.json",
+      "bytes": 787,
+      "sha256": "7afe223d27715a79e34f8c9ea11993f1c37e75bc5d49a6b3284f412d8171a00d"
+    },
+    {
+      "path": "tests/scenes.json",
+      "bytes": 3225,
+      "sha256": "a92c5535c54106ce18823443244f115bf5a2a3d42abfc4ee3573f38e8234e553"
+    },
+    {
+      "path": "tests/v24-acceptance-contract.mjs",
+      "bytes": 818,
+      "sha256": "4bc444c694934d8bfd4a56ab597ab9fe834867ed6bc97a36c8182f99c25e39a6"
+    },
+    {
+      "path": "tests/v24-bla-model.mjs",
+      "bytes": 677,
+      "sha256": "04f22c659b61635792b9662b718ec9ae6140189a3daf553ac580b841ee48bd6b"
+    },
+    {
+      "path": "tests/v24-coordinate-format.mjs",
+      "bytes": 1253,
+      "sha256": "a993f04f12fceb4d38c16206636f7951d8bc4afad63a57491e0164bb3575ca3a"
+    },
+    {
+      "path": "tests/v24-cpu-numeric-model.mjs",
+      "bytes": 8197,
+      "sha256": "8f24ccd80bf00b5b13e09a1b31bddf6df1c17dc8d7541e04ea1e7421165a2ce0"
+    },
+    {
+      "path": "tests/v24-direct-model.mjs",
+      "bytes": 2452,
+      "sha256": "9c9ba9cfeaf5e352059a639ba1014ae7a3b0382309a634ee128bc99e62ee3dc5"
+    },
+    {
+      "path": "tests/v24-geometry-contract.mjs",
+      "bytes": 1177,
+      "sha256": "9403a8d1efe6d0d5547bd7ebaa966578dea1ba7630f094fc117e0ae4fe395996"
+    },
+    {
+      "path": "tests/v24-index-contract.mjs",
+      "bytes": 461,
+      "sha256": "ffeeccba4b72613f061c7add2f8cdecc03a6c01e2e5a01d4f2a2cf53f94345ef"
+    },
+    {
+      "path": "tests/v24-png-stream-model.mjs",
+      "bytes": 3411,
+      "sha256": "ca4dee6252bf6545310ba52c1433e82e83886d04cdb1feb20c7ab08045f431a7"
+    },
+    {
+      "path": "tests/v24-reference-worker.mjs",
+      "bytes": 2140,
+      "sha256": "4d637c549cdda2c28666f5bfe2925c5742103c44b752c337cadbe9bc9df6431d"
+    },
+    {
+      "path": "tests/v24-source-contract.mjs",
+      "bytes": 3805,
+      "sha256": "ce3e8dc4be17f19af362087772e7a17b59d7e8e007c5e19f00153899fe0a20af"
+    },
+    {
+      "path": "tests/v24-tree-contract.mjs",
+      "bytes": 691,
+      "sha256": "933c8c5035806584ee3ffc7645b14aa60f262920528ebb8e5e47666023174770"
+    },
+    {
+      "path": "tests/v24-wgsl-reserved.mjs",
+      "bytes": 2260,
+      "sha256": "98c153ac038852d3402f36ee18ce1f8263de1a016240b4363f01d84a31f0f0ab"
+    },
+    {
+      "path": "tests/webgpu-acceptance.html",
+      "bytes": 405,
+      "sha256": "89b03a08f248b048eead508fc3599057a8cf5afc1d9f846de206a69272dd95bd"
+    },
+    {
+      "path": "tests/webgpu-acceptance.js",
+      "bytes": 6072,
+      "sha256": "c38fbeca176a464bfb6d4a0685f66469065ba3392a65f0617215a85e3fccbeb0"
+    }
+  ]
+}
diff --git a/audit/v24-release-verification.json b/audit/v24-release-verification.json
new file mode 100644
index 0000000..751d71f
--- /dev/null
+++ b/audit/v24-release-verification.json
@@ -0,0 +1,12 @@
+{
+  "status": "pass",
+  "version": "24.1.3",
+  "generatedAt": "2026-08-23T16:17:15+09:00",
+  "preZipCleanCopy": {
+    "npmTest": "pass",
+    "npmBuild": "pass"
+  },
+  "wgslReservedWords": "pass",
+  "sourceDistHashesMatch": true,
+  "realWebGpu": "pending: container has no usable adapter"
+}
diff --git a/audit/v24-test-summary.json b/audit/v24-test-summary.json
new file mode 100644
index 0000000..037fb19
--- /dev/null
+++ b/audit/v24-test-summary.json
@@ -0,0 +1,94 @@
+{
+  "status": "v24.1.3-static-cpu-build-pass-real-webgpu-rerun-pending",
+  "rendererVersion": 24,
+  "shaderVersion": "24.1.3",
+  "packageVersion": "24.1.3",
+  "production": {
+    "legacyDeepAssets": 0,
+    "bigIntPixelRenderer": false,
+    "referenceWorker": "BigInt fixed-point reference at viewBits+64 with viewBits+128 guard checkpoints",
+    "gpuDeep": "guarded rescaled f32 perturbation",
+    "productionBla": false,
+    "strictRetryPass": false,
+    "gpuFieldColorPresentation": true,
+    "recolorWithoutNumericRecompute": true,
+    "reusableExportWorkspace": true,
+    "streamingPng": true,
+    "gpuAaResolve2x2": true,
+    "maxExportSide": 16384,
+    "membershipCertified": false
+  },
+  "nodeGates": {
+    "status": "pass",
+    "directFalseEscaped": 0,
+    "directFalseBounded": 0,
+    "deepFalseEscaped": 0,
+    "deepFalseBounded": 0,
+    "deepGuardMismatch": 0,
+    "swirlyUnknownBalanced": 71,
+    "swirlyKnownBalanced": 116,
+    "denseKnownCounterexamples": "all conservatively UNKNOWN",
+    "coordinateDepths": [
+      "1e-400",
+      "1e-1000"
+    ],
+    "pngStreamModel": "pass",
+    "acceptanceHarnessContract": "pass"
+  },
+  "build": {
+    "status": "pass",
+    "standaloneFiles": [
+      "index.html",
+      "gpu-kernels.js",
+      "script.js"
+    ],
+    "hostedFiles": [
+      "index.html",
+      "gpu-kernels.js",
+      "script.js",
+      "_headers"
+    ]
+  },
+  "realWebGPU": {
+    "status": "rerun-pending-for-v24.1.3",
+    "v24.1.2ObservedFailure": "reserved-word parse error from real WebGPU browser",
+    "v24.1.3SourceFix": "static reserved-word gate passes",
+    "containerAdapterAccepted": false
+  },
+  "generatedAt": "2026-08-23T16:17:15+09:00",
+  "hotfix": {
+    "wgslReservedWords": "pass: all 5 WGSL modules contain no WGSL 16.2 reserved-word tokens",
+    "renamedIdentifiers": [
+      "meta -> fieldMeta",
+      "smooth -> fieldSmooth"
+    ],
+    "shaderFailureFallback": "CPU full-frame fallback disabled for shader/pipeline failures",
+    "screenPixelBudget": {
+      "power": 524288,
+      "standardDesktop": 1572864,
+      "standardSmall": 786432,
+      "fineDesktop": 3145728,
+      "strictDesktop": 2097152,
+      "noWebGpuFallback": 262144
+    },
+    "errorBadge": "compiler/runtime errors truncated to 120 chars in status UI; full diagnostics retained"
+  },
+  "hashes": {
+    "index.html": "adf0dc65d2cfbb6ca56494651d40fc6874aedcd088f4170650d97fdde9c0e5dc",
+    "script.js": "eca75aaba2e859ab73d79a46a76329ffb41c438e413bf24f7a4b21328f8f0e61",
+    "gpu-kernels.js": "aab457adce3cf1bf52eca6416c7c9570f4feb3579580a8cc95ae2425f8aea68a",
+    "dist/standalone/index.html": "adf0dc65d2cfbb6ca56494651d40fc6874aedcd088f4170650d97fdde9c0e5dc",
+    "dist/standalone/script.js": "eca75aaba2e859ab73d79a46a76329ffb41c438e413bf24f7a4b21328f8f0e61",
+    "dist/standalone/gpu-kernels.js": "aab457adce3cf1bf52eca6416c7c9570f4feb3579580a8cc95ae2425f8aea68a",
+    "dist/hosted/index.html": "adf0dc65d2cfbb6ca56494651d40fc6874aedcd088f4170650d97fdde9c0e5dc",
+    "dist/hosted/script.js": "eca75aaba2e859ab73d79a46a76329ffb41c438e413bf24f7a4b21328f8f0e61",
+    "dist/hosted/gpu-kernels.js": "aab457adce3cf1bf52eca6416c7c9570f4feb3579580a8cc95ae2425f8aea68a"
+  },
+  "cleanCopyVerification": {
+    "directory": "v24_hotfix_verify_pre",
+    "npmTest": "pass",
+    "npmBuild": "pass",
+    "sourceHashesMatch": true,
+    "sourceDistHashesMatch": true
+  }
+}
diff --git a/dist/hosted/_headers b/dist/hosted/_headers
index 8571cd2..b7d7893 100644
--- a/dist/hosted/_headers
+++ b/dist/hosted/_headers
@@ -1,11 +1,3 @@
 /*
-  Cross-Origin-Opener-Policy: same-origin
-  Cross-Origin-Embedder-Policy: require-corp
   X-Content-Type-Options: nosniff
-
-/wasm/*
-  Content-Type: application/wasm
-  Cache-Control: public, max-age=31536000, immutable
-
-/hosted/*
-  Cache-Control: no-cache
+  Referrer-Policy: no-referrer
diff --git a/dist/hosted/gpu-kernels.js b/dist/hosted/gpu-kernels.js
new file mode 100644
index 0000000..93b7e33
--- /dev/null
+++ b/dist/hosted/gpu-kernels.js
@@ -0,0 +1,258 @@
+(()=>{'use strict';
+const COMMON=String.raw`
+const FIELD_UNKNOWN:u32=0u;
+const FIELD_ESCAPED:u32=1u;
+const FIELD_INTERIOR_LIKELY:u32=2u;
+const FIELD_INTERIOR_PROVEN:u32=3u;
+const ITER_MASK:u32=0x0fffffffu;
+const STATUS_UNRESOLVED:u32=0xfffffffeu;
+
+fn pack_meta(n:u32, cls:u32)->u32 { return (n & ITER_MASK) | ((cls & 3u) << 28u); }
+fn cmul(a:vec2<f32>, b:vec2<f32>)->vec2<f32>{
+  return vec2<f32>(a.x*b.x-a.y*b.y, a.x*b.y+a.y*b.x);
+}
+fn maxabs(v:vec2<f32>)->f32 { return max(abs(v.x),abs(v.y)); }
+const F32_U:f32=5.960464477539063e-8;
+fn pow2_safe(e:i32)->f32 {
+  if(e < -126){ return 0.0; }
+  if(e > 126){ return 8.507059e37; }
+  return ldexp(1.0,e);
+}
+fn safe_abs_error(errScaled:f32, scaleExp:i32, z:vec2<f32>, delta:vec2<f32>)->f32{
+  let propagated=abs(errScaled*pow2_safe(scaleExp));
+  let reconstruction=64.0*F32_U*(maxabs(z)+maxabs(delta)+1.0e-30);
+  return propagated+reconstruction;
+}
+fn scaled_to_f32(v:vec2<f32>, e:i32)->vec2<f32>{
+  if(e < -126){ return vec2<f32>(0.0); }
+  if(e > 126){ return vec2<f32>(8.507059e37); }
+  return ldexp(v,vec2<i32>(e));
+}
+fn smooth_escape(n:u32, mag2:f32)->f32{
+  let u=log2(max(4.0000005,mag2));
+  return f32(n)+1.0-log2(max(1.0e-20,0.5*u));
+}
+`;
+
+const DIRECT_F32_WGSL=COMMON+String.raw`
+struct Params{
+  tileW:u32, tileH:u32, fullW:u32, fullH:u32,
+  tileX:u32, tileY:u32, maxIter:u32, strict:u32,
+  centerRe:f32, centerIm:f32, span:f32, sampleX:f32,
+  sampleY:f32, _p0:f32, _p1:f32, _p2:f32,
+};
+@group(0) @binding(0) var<uniform> p:Params;
+@group(0) @binding(1) var<storage,read_write> fieldMeta:array<u32>;
+@group(0) @binding(2) var<storage,read_write> fieldSmooth:array<f32>;
+fn analytic(cr:f32,ci:f32)->bool{
+  let y2=ci*ci; let x=cr-0.25; let q=x*x+y2;
+  let lhs=q*(q+x); let rhs=0.25*y2;
+  let margin=16.0*F32_U*(abs(lhs)+abs(rhs)+1.0);
+  if(lhs<rhs-margin){return true;}
+  let x2=cr+1.0; let bulb=x2*x2+y2;
+  let bulbMargin=16.0*F32_U*(abs(bulb)+0.0625+1.0);
+  return bulb<0.0625-bulbMargin;
+}
+@compute @workgroup_size(8,8)
+fn main(@builtin(global_invocation_id) gid:vec3<u32>){
+  if(gid.x>=p.tileW||gid.y>=p.tileH){return;}
+  let out=gid.y*p.tileW+gid.x;
+  let gx=f32(p.tileX+gid.x)+p.sampleX;
+  let gy=f32(p.tileY+gid.y)+p.sampleY;
+  let scale=p.span/f32(p.fullW);
+  let cr=p.centerRe+(gx-0.5*f32(p.fullW))*scale;
+  let ci=p.centerIm+(0.5*f32(p.fullH)-gy)*scale;
+  if(analytic(cr,ci)){
+    fieldMeta[out]=pack_meta(p.maxIter,FIELD_INTERIOR_PROVEN); fieldSmooth[out]=0.0; return;
+  }
+  var zr=0.0; var zi=0.0; var n=0u;
+  loop{
+    if(n>=p.maxIter){break;}
+    let zr2=zr*zr; let zi2=zi*zi;
+    zi=2.0*zr*zi+ci; zr=zr2-zi2+cr; n+=1u;
+    let mag=zr*zr+zi*zi;
+    if(mag>4.0){fieldMeta[out]=pack_meta(n,FIELD_ESCAPED); fieldSmooth[out]=smooth_escape(n,mag); return;}
+  }
+  fieldMeta[out]=pack_meta(p.maxIter,FIELD_INTERIOR_LIKELY); fieldSmooth[out]=0.0;
+}
+`;
+
+// Deep path: high-precision CPU reference + guarded rescaled f32 perturbation.
+const DEEP_PERTURB_WGSL=COMMON+String.raw`
+struct Params{
+  tileW:u32, tileH:u32, fullW:u32, fullH:u32,
+  tileX:u32, tileY:u32, maxIter:u32, refLen:u32,
+  strict:u32, _numeric0:u32, _numeric1:u32, _numeric2:u32,
+  spanMant:f32, spanExp:i32, sampleX:f32, sampleY:f32,
+};
+struct RefPoint{ hi:vec2<f32>, lo:vec2<f32> };
+struct UnresolvedHead{ remaining:atomic<u32>, _p0:u32, _p1:u32, _p2:u32 };
+@group(0) @binding(0) var<uniform> p:Params;
+@group(0) @binding(1) var<storage,read> refs:array<RefPoint>;
+@group(0) @binding(2) var<storage,read_write> fieldMeta:array<u32>;
+@group(0) @binding(3) var<storage,read_write> fieldSmooth:array<f32>;
+@group(0) @binding(4) var<storage,read_write> unresolved:UnresolvedHead;
+
+fn mark_unresolved(out:u32,n:u32){
+  fieldMeta[out]=pack_meta(n,FIELD_UNKNOWN); fieldSmooth[out]=0.0;
+  atomicAdd(&unresolved.remaining,1u);
+}
+fn render_pixel(out:u32,gx:f32,gy:f32,strictMode:bool){
+  let dx=(gx-0.5*f32(p.fullW))/f32(p.fullW);
+  let dy=(0.5*f32(p.fullH)-gy)/f32(p.fullW);
+  // dc = d * 2^scaleExp. Keep d and w in one shared scale.
+  var d=vec2<f32>(p.spanMant*dx,p.spanMant*dy);
+  var w=vec2<f32>(0.0);
+  var scaleExp=p.spanExp;
+  var n=0u; var m=0u; var operations=0u;
+  var errScaled=64.0*F32_U*maxabs(d);
+  loop{
+    if(n>=p.maxIter){
+      let rpEnd=refs[min(m,p.refLen)];
+      let deltaEnd=scaled_to_f32(w,scaleExp);
+      let zEnd=rpEnd.hi+(rpEnd.lo+deltaEnd);
+      let errAbs=safe_abs_error(errScaled,scaleExp,zEnd,deltaEnd);
+      let limit=select(1.0e-3,1.0e-4,strictMode);
+      if(errAbs<=limit){fieldMeta[out]=pack_meta(p.maxIter,FIELD_INTERIOR_LIKELY);fieldSmooth[out]=0.0;}else{mark_unresolved(out,n);}
+      return;
+    }
+    if(m>p.refLen){mark_unresolved(out,n);return;}
+    let rp=refs[m];
+    let delta=scaled_to_f32(w,scaleExp);
+    let z=rp.hi+(rp.lo+delta);
+    let mag=dot(z,z);
+    if(mag>4.0){
+      let errAbs=safe_abs_error(errScaled,scaleExp,z,delta);
+      if(length(z)-errAbs>2.0){fieldMeta[out]=pack_meta(n,FIELD_ESCAPED);fieldSmooth[out]=smooth_escape(n,mag);return;}
+      mark_unresolved(out,n);return;
+    }
+
+    // Rebase only when dc remains numerically representable in the new scale.
+    if(m>0u && dot(delta,delta)>0.0 && mag<dot(delta,delta)){
+      if(p.spanExp-scaleExp < -96){mark_unresolved(out,n);return;}
+      errScaled=safe_abs_error(errScaled,scaleExp,z,delta);
+      w=z; d=scaled_to_f32(vec2<f32>(p.spanMant*dx,p.spanMant*dy),p.spanExp); scaleExp=0; m=0u;
+      errScaled+=64.0*F32_U*maxabs(d);
+      continue;
+    }
+
+    if(m>=p.refLen){mark_unresolved(out,n);return;}
+    let r=refs[m];
+    let refAbs=maxabs(r.hi)+maxabs(r.lo);
+    let wAbs=maxabs(w); let dAbs=maxabs(d); let p2=abs(pow2_safe(scaleExp));
+    let gain=2.0*refAbs+2.0*wAbs*p2;
+    let roundErr=64.0*F32_U*(2.0*refAbs*wAbs+wAbs*wAbs*p2+dAbs+1.0e-30);
+    errScaled=gain*errScaled+roundErr;
+    let linear=2.0*(cmul(r.hi,w)+cmul(r.lo,w));
+    // delta^2 / 2^scaleExp = w^2 * 2^scaleExp
+    let sq=cmul(w,w)*pow2_safe(scaleExp);
+    w=linear+sq+d; m+=1u; n+=1u; operations+=1u;
+    if(maxabs(w)>=1.0e30 || maxabs(d)>=1.0e30){mark_unresolved(out,n);return;}
+    let mm=max(maxabs(w),maxabs(d));
+    if(mm>65536.0){
+      w*=0.0000152587890625; d*=0.0000152587890625; errScaled*=0.0000152587890625; scaleExp+=16;
+    }else if(mm>0.0 && mm<0.0000152587890625 && scaleExp>p.spanExp){
+      w*=65536.0; d*=65536.0; errScaled*=65536.0; scaleExp-=16;
+    }
+    if(scaleExp>126 || errScaled!=errScaled || errScaled>1.0e35){mark_unresolved(out,n);return;}
+    if(operations>p.maxIter*2u+2048u){mark_unresolved(out,n);return;}
+  }
+}
+@compute @workgroup_size(8,8)
+fn main(@builtin(global_invocation_id) gid:vec3<u32>){
+  if(gid.x>=p.tileW||gid.y>=p.tileH){return;}
+  let out=gid.y*p.tileW+gid.x;
+  let gx=f32(p.tileX+gid.x)+p.sampleX; let gy=f32(p.tileY+gid.y)+p.sampleY;
+  render_pixel(out,gx,gy,p.strict!=0u);
+}
+`;
+
+const COLOR_WGSL=String.raw`
+struct Params{
+  width:u32,height:u32,palette:u32,edgeAA:u32,
+  cycle:f32,shift:f32,_p0:f32,_p1:f32,
+};
+@group(0) @binding(0) var<uniform> p:Params;
+@group(0) @binding(1) var<storage,read> fieldMeta:array<u32>;
+@group(0) @binding(2) var<storage,read> fieldSmooth:array<f32>;
+@group(0) @binding(3) var outTex:texture_storage_2d<rgba8unorm,write>;
+fn hsv(h:f32,s:f32,v:f32)->vec3<f32>{
+  let x=fract(h)*6.0; let i=i32(floor(x)); let f=x-floor(x); let pp=v*(1.0-s); let q=v*(1.0-s*f); let t=v*(1.0-s*(1.0-f));
+  if(i==0){return vec3<f32>(v,t,pp);} if(i==1){return vec3<f32>(q,v,pp);} if(i==2){return vec3<f32>(pp,v,t);} if(i==3){return vec3<f32>(pp,q,v);} if(i==4){return vec3<f32>(t,pp,v);} return vec3<f32>(v,pp,q);
+}
+fn current_palette(t0:f32)->vec3<f32>{
+  let t=select(2.0-2.0*t0,2.0*t0,t0<=0.5);
+  if(t<0.11){return mix(vec3<f32>(4,10,27),vec3<f32>(12,53,79),smoothstep(0.0,0.11,t))/255.0;}
+  if(t<0.25){return mix(vec3<f32>(12,53,79),vec3<f32>(31,156,184),smoothstep(0.11,0.25,t))/255.0;}
+  if(t<0.38){return mix(vec3<f32>(31,156,184),vec3<f32>(91,226,234),smoothstep(0.25,0.38,t))/255.0;}
+  if(t<0.50){return mix(vec3<f32>(91,226,234),vec3<f32>(66,53,151),smoothstep(0.38,0.50,t))/255.0;}
+  if(t<0.62){return mix(vec3<f32>(66,53,151),vec3<f32>(139,49,170),smoothstep(0.50,0.62,t))/255.0;}
+  if(t<0.73){return mix(vec3<f32>(139,49,170),vec3<f32>(232,72,145),smoothstep(0.62,0.73,t))/255.0;}
+  if(t<0.84){return mix(vec3<f32>(232,72,145),vec3<f32>(255,137,64),smoothstep(0.73,0.84,t))/255.0;}
+  if(t<0.93){return mix(vec3<f32>(255,137,64),vec3<f32>(255,211,99),smoothstep(0.84,0.93,t))/255.0;}
+  return mix(vec3<f32>(255,211,99),vec3<f32>(255,250,223),smoothstep(0.93,1.0,t))/255.0;
+}
+fn base_color(i:u32)->vec3<f32>{
+  let m=fieldMeta[i]; let cls=(m>>28u)&3u;
+  if(cls==0u){return vec3<f32>(20,22,30)/255.0;} if(cls!=1u){return vec3<f32>(0.0);}
+  let sm=fieldSmooth[i]; let phase=fract(p.shift+sm*p.cycle); var c=vec3<f32>(0.0);
+  if(p.palette==1u){c=hsv(phase,0.92,1.0);}else if(p.palette==2u){let g=(22.0+233.0*(0.5-0.5*cos(6.283185307*phase)))/255.0;c=vec3<f32>(g);}else{c=current_palette(phase);}
+  let n=f32(m&0x0fffffffu); let edge=clamp(log(1.0+n)/log(1.0+max(8.0,n+32.0)),0.0,1.0); let mixv=0.34+0.66*pow(edge,0.38);
+  let floorc=select(vec3<f32>(2,5,15)/255.0,vec3<f32>(8.0/255.0),p.palette==2u); return mix(floorc,c,mixv);
+}
+fn linearize(c:vec3<f32>)->vec3<f32>{return pow(c,vec3<f32>(2.2));}
+fn delinearize(c:vec3<f32>)->vec3<f32>{return pow(max(c,vec3<f32>(0.0)),vec3<f32>(1.0/2.2));}
+@compute @workgroup_size(8,8)
+fn main(@builtin(global_invocation_id) gid:vec3<u32>){
+  if(gid.x>=p.width||gid.y>=p.height){return;} let i=gid.y*p.width+gid.x; var c=base_color(i);
+  if(p.edgeAA!=0u){
+    let m=fieldMeta[i]; let cls=(m>>28u)&3u; var boundary=false; var sum=linearize(c); var cnt=1.0;
+    let x=i32(gid.x); let y=i32(gid.y);
+    for(var oy=-1;oy<=1;oy+=1){for(var ox=-1;ox<=1;ox+=1){if(ox==0&&oy==0){continue;} let xx=x+ox;let yy=y+oy;if(xx<0||yy<0||xx>=i32(p.width)||yy>=i32(p.height)){continue;}let j=u32(yy)*p.width+u32(xx);let mj=fieldMeta[j];let cj=(mj>>28u)&3u;if(cj!=cls||abs(i32(mj&0x0fffffffu)-i32(m&0x0fffffffu))>2){boundary=true;}sum+=linearize(base_color(j));cnt+=1.0;}}
+    if(boundary){c=delinearize(sum/cnt);}
+  }
+  textureStore(outTex,vec2<i32>(gid.xy),vec4<f32>(c,1.0));
+}
+`;
+
+
+const AA_RESOLVE_WGSL=String.raw`
+@group(0) @binding(0) var a:texture_2d<f32>;
+@group(0) @binding(1) var b:texture_2d<f32>;
+@group(0) @binding(2) var c:texture_2d<f32>;
+@group(0) @binding(3) var d:texture_2d<f32>;
+@group(0) @binding(4) var outTex:texture_storage_2d<rgba8unorm,write>;
+fn to_linear(x:f32)->f32{return select(x/12.92,pow((x+0.055)/1.055,2.4),x>0.04045);}
+fn to_srgb(x0:f32)->f32{let x=clamp(x0,0.0,1.0);return select(12.92*x,1.055*pow(x,1.0/2.4)-0.055,x>0.0031308);}
+fn lin3(v:vec3<f32>)->vec3<f32>{return vec3<f32>(to_linear(v.x),to_linear(v.y),to_linear(v.z));}
+fn srgb3(v:vec3<f32>)->vec3<f32>{return vec3<f32>(to_srgb(v.x),to_srgb(v.y),to_srgb(v.z));}
+@compute @workgroup_size(8,8)
+fn main(@builtin(global_invocation_id) gid:vec3<u32>){
+  let size=textureDimensions(a); if(gid.x>=size.x||gid.y>=size.y){return;}
+  let q=vec2<i32>(gid.xy);
+  let sum=lin3(textureLoad(a,q,0).rgb)+lin3(textureLoad(b,q,0).rgb)+lin3(textureLoad(c,q,0).rgb)+lin3(textureLoad(d,q,0).rgb);
+  textureStore(outTex,q,vec4<f32>(srgb3(sum*0.25),1.0));
+}
+`;
+
+const PRESENT_WGSL=String.raw`
+struct Params{scaleX:f32,scaleY:f32,offsetX:f32,offsetY:f32};
+@group(0) @binding(0) var samp:sampler;
+@group(0) @binding(1) var tex:texture_2d<f32>;
+@group(0) @binding(2) var<uniform> p:Params;
+struct VSOut{@builtin(position) pos:vec4<f32>,@location(0) uv:vec2<f32>};
+@vertex fn vs(@builtin(vertex_index) i:u32)->VSOut{
+  var pos=array<vec2<f32>,3>(vec2<f32>(-1.0,-1.0),vec2<f32>(3.0,-1.0),vec2<f32>(-1.0,3.0));
+  var uv=array<vec2<f32>,3>(vec2<f32>(0.0,1.0),vec2<f32>(2.0,1.0),vec2<f32>(0.0,-1.0));
+  var o:VSOut;o.pos=vec4<f32>(pos[i],0.0,1.0);o.uv=uv[i];return o;
+}
+@fragment fn fs(in:VSOut)->@location(0) vec4<f32>{
+  let uv=vec2<f32>(0.5)+(in.uv-vec2<f32>(0.5))*vec2<f32>(p.scaleX,p.scaleY)+vec2<f32>(p.offsetX,p.offsetY);
+  if(any(uv<vec2<f32>(0.0))||any(uv>vec2<f32>(1.0))){return vec4<f32>(0.0196,0.0314,0.0745,1.0);} return textureSampleLevel(tex,samp,uv,0.0);
+}
+`;
+
+globalThis.MANDEL_WEBGPU_KERNELS=Object.freeze({
+  version:'24.1.3',DIRECT_F32_WGSL,DEEP_PERTURB_WGSL,COLOR_WGSL,AA_RESOLVE_WGSL,PRESENT_WGSL
+});
+})();
diff --git a/dist/hosted/index.html b/dist/hosted/index.html
index 745b341..186da65 100644
--- a/dist/hosted/index.html
+++ b/dist/hosted/index.html
@@ -1,10 +1,10 @@
-<!doctype html>
+<!doctype html>
 <html lang="ja">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width,initial-scale=1,viewport-fit=cover">
 <meta name="theme-color" content="#050813">
-<title>Mandelbrot Deep Zoom v23</title>
+<title>Mandelbrot Deep Zoom v24.1.3 WebGPU</title>
 <style>
 :root{color-scheme:dark;--panel:rgba(7,12,25,.88);--line:rgba(255,255,255,.12);--text:#f7f8ff;--muted:#a9b3ca;--accent:#61dbe9}
 *{box-sizing:border-box}html,body{margin:0;width:100%;height:100%;overflow:hidden;background:#050813;font-family:Inter,-apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif}body{-webkit-user-select:none;user-select:none}
@@ -34,13 +34,13 @@ dialog{width:min(430px,calc(100vw - 24px));border:1px solid var(--line);border-r
 <div id="controls" class="panel">
   <div class="toolbar"><button id="zin" aria-label="中心を拡大">＋</button><button id="zout" aria-label="中心を縮小">−</button><button id="reset">リセット</button><button id="png">出力</button></div>
   <div class="group">
-    <div class="line"><label for="processMode">処理モード</label><select id="processMode"><option value="power">省電力</option><option value="standard" selected>標準</option><option value="fine">精細</option><option value="validate">精度優先</option></select><output></output></div>
+    <div class="line"><label for="processMode">処理モード</label><select id="processMode"><option value="power">省電力</option><option value="standard" selected>標準</option><option value="fine">精細</option><option value="validate">保守的 (Strict)</option></select><output></output></div>
     <div class="line"><label for="palette">彩色</label><select id="palette"><option value="0">昼夜</option><option value="1">虹色</option><option value="2">白黒</option></select><output></output></div>
     <div class="line"><label for="cycle">色周期</label><input id="cycle" type="range" min="0.001" max="0.05" step="0.0005" value="0.008"><output id="cycleO" for="cycle">0.0080</output></div>
     <div class="line"><label for="shift">色相位置</label><input id="shift" type="range" min="0" max="1" step="0.005" value="0.18"><output id="shiftO" for="shift">.18</output></div>
     <details><summary>詳細設定・正確な座標</summary>
       <div class="line"><label for="iters">基準反復</label><input id="iters" type="range" min="100" max="2500" step="25" value="350"><output id="itersO" for="iters">350</output></div>
-      <div class="checks"><label><input id="adaptive" type="checkbox" checked> 反復回数を自動調整</label><label><input id="hq" type="checkbox"> 境界AAを追加</label></div>
+      <div class="checks"><label><input id="adaptive" type="checkbox" checked> 反復回数を自動調整</label><label><input id="hq" type="checkbox"> GPU境界平滑化</label></div>
       <div class="exact-grid"><label for="coordReInput">実部</label><input id="coordReInput"><label for="coordImInput">虚部</label><input id="coordImInput"><label for="coordSpanInput">表示幅</label><input id="coordSpanInput"></div>
       <div class="mini-actions"><button id="coordApply">座標を適用</button><button id="coordCopy">正確値をコピー</button><button id="undoView">戻す</button><button id="redoView">進む</button></div>
     </details>
@@ -57,13 +57,13 @@ dialog{width:min(430px,calc(100vw - 24px));border:1px solid var(--line);border-r
     <label for="exportScale">出力倍率</label><select id="exportScale"><option value="1">1×</option><option value="2">2×</option><option value="4">4×</option><option value="0">カスタム幅</option></select>
     <label for="exportWidth">幅（px）</label><input id="exportWidth" type="number" min="64" max="16384" step="1">
     <label for="exportAA">サブサンプル</label><select id="exportAA"><option value="1">1×（高速）</option><option value="2">2×2 AA</option></select>
-    <label for="exportPrecision">精度方針</label><select id="exportPrecision"><option value="balanced">Balanced</option><option value="validated">Validated direct</option></select>
+    <label for="exportPrecision">精度方針</label><select id="exportPrecision"><option value="balanced">Balanced</option><option value="strict">保守的 (Strict)</option></select>
   </div>
   <progress id="exportProgress" max="1" value="0" hidden></progress>
   <div id="exportStatus" role="status" aria-live="polite"></div>
   <div class="export-actions"><button id="exportCancel" type="button">閉じる</button><button id="exportQuick" type="button">表示を即時保存</button><button id="exportStart" class="primary" type="button">PNGを生成</button></div>
 </dialog>
-<script type="module" src="./hosted-loader.js"></script>
+<script src="gpu-kernels.js"></script>
+<script src="script.js"></script>
 </body>
 </html>
-
diff --git a/dist/hosted/script.js b/dist/hosted/script.js
index 10f7903..44822b7 100644
--- a/dist/hosted/script.js
+++ b/dist/hosted/script.js
@@ -1,912 +1,248 @@
 (()=>{'use strict';
-const K=globalThis.MANDEL_KERNELS;
-if(!K)throw new Error('kernels.js が読み込まれていません');
-const {WASM_SIMD_B64,WASM_SCALAR_B64,DEEP_SIMD_B64,DEEP_SCALAR_B64,BLA_SIMD_B64,BLA_SCALAR_B64,COLOR_SIMD_B64,COLOR_SCALAR_B64}=K;
-const $=s=>document.querySelector(s);
-const canvas=$('#view');
-const ctx=canvas.getContext('2d',{alpha:false,desynchronized:true})||canvas.getContext('2d',{alpha:false});
-if(!ctx){document.body.innerHTML='<div style="padding:30px;color:white">Canvas 2Dを利用できません。</div>';return;}
-
-const INITIAL_BITS=256;
-const MIN_SPAN_BITS=224;
-const TARGET_SPAN_BITS=240;
-const RATIO_DEN=4503599627370496n; // 2^52
-const POW256=1.157920892373162e77;
-const INV256=8.636168555094445e-78;
-const HI128=3.402823669209385e38;
-const LO128=2.938735877055719e-39;
-const NEG_BUCKET=-1000000000;
-const LEGACY_DEEP_ZOOM_THRESHOLD=11.5;
-const RENDER_PASS=Object.freeze({PREVIEW:'preview',COVERED:'covered'});
-const MODE_TARGET=Object.freeze({power:'PREVIEW',standard:'COVERED',fine:'REFINED',validate:'VALIDATED'});
-function modeTarget(mode=state.processMode){return MODE_TARGET[mode]||MODE_TARGET.standard}
-const RENDER_PROFILE=Object.freeze({
-  [RENDER_PASS.PREVIEW]:Object.freeze({id:RENDER_PASS.PREVIEW,covered:false,budgetMs:110,nominalScale:.42,minWidth:360,maxWidth:900,densityLimit:1.55,blaSteps:1700,ptbSteps:2500}),
-  [RENDER_PASS.COVERED]:Object.freeze({id:RENDER_PASS.COVERED,covered:true,budgetMs:1050,nominalScale:1,minWidth:0,maxWidth:Infinity,densityLimit:1,blaSteps:0,ptbSteps:0})
-});
-function renderProfile(pass){return RENDER_PROFILE[pass]||RENDER_PROFILE[RENDER_PASS.PREVIEW]}
-let deepMode=false;
-
-const state={
-  bits:INITIAL_BITS,re:0n,im:0n,span:0n,
-  baseIter:350,adaptive:true,hq:false,processMode:'standard',palette:0,cycle:.008,shift:.18,
-  token:0,rendering:false,lastRender:0,lastEngine:'起動中',lastPass:null,lastInteraction:performance.now(),dirty:true,
-  uiHidden:false,frameView:null,fieldView:null,lastFrameDone:0,
-  detailGeneration:0,detailActive:false,detailQueued:0,detailDone:0,
-  drawState:'REPROJECTED',coverage:0,unresolved:0,
-  precisionPending:false,
-  pointerActive:false,wheelActive:false,panReuse:null,effectiveDpr:1,screenPixelBudget:0,adaptivePixelBudget:0,continuationProgress:0,focusX:.5,focusY:.5
-};
-
-// Deep telemetry is collected from the actual BLA/perturbation
-// kernel rather than from a synthetic JavaScript loop.
-const deepTelemetry={
-  frames:0,kernelMPP:0,meanIter:0,blackRatio:0,badRatio:0,blaBuildEMA:0,
-  refDistance:0,interiorRatio:0,repairRatio:0,unresolvedRatio:0,
-  blaStepsPerPixel:0,ptbStepsPerPixel:0,rebasePerPixel:0,lastPilotMs:0,lastPilotMPP:0,lastKernelMs:0,lastVerifyMs:0,lastPixels:0
-};
-const refControl={buildEMA:18,lastBuildMs:0,lastRecenterAt:0,refId:0,baseMPP:0,lastMPP:0,lastPixels:0,cooldownMs:900};
-
-// Adaptive quality controller: instead of tying a quality level to a fixed
-// pixel width, learn the recent cost per pixel and spend a bounded amount of time.
-const renderPerf={deepMPP:0,shallowMPP:0};
-const runtimeMetrics={canvasWrites:0,domWrites:0,renderStarts:0,renderStartsDuringGesture:0,longTasks:0,maxLongTaskMs:0,pendingBackgroundJobs:0};
-try{if('PerformanceObserver'in globalThis){const observer=new PerformanceObserver(list=>{for(const entry of list.getEntries()){runtimeMetrics.longTasks++;runtimeMetrics.maxLongTaskMs=Math.max(runtimeMetrics.maxLongTaskMs,entry.duration||0)}});observer.observe({type:'longtask',buffered:true})}}catch{}
-function scheduleBackground(fn,delay=0){runtimeMetrics.pendingBackgroundJobs++;return setTimeout(()=>{runtimeMetrics.pendingBackgroundJobs=Math.max(0,runtimeMetrics.pendingBackgroundJobs-1);fn()},delay)}
-function scheduleIdle(fn,timeout=350){runtimeMetrics.pendingBackgroundJobs++;const run=()=>{runtimeMetrics.pendingBackgroundJobs=Math.max(0,runtimeMetrics.pendingBackgroundJobs-1);fn()};return'requestIdleCallback'in window?requestIdleCallback(run,{timeout}):setTimeout(run,Math.min(80,timeout))}
-const DETAIL_TILE_CACHE=new Map();
-let detailCacheBytes=0;
-const activeDetailTiles=[];
-let detailPlan=null;
-let schedulerRAF=0,schedulerTimer=0,schedulerDue=0,needsPaint=true,needsStats=true,wheelSettleTimer=0,pointerSettleTimer=0;
-
-function requestScheduler(delay=0){
-  if(document.hidden)return;
-  if(delay>0){
-    const due=performance.now()+delay;
-    if(schedulerTimer&&schedulerDue<=due)return;
-    if(schedulerTimer)clearTimeout(schedulerTimer);
-    schedulerDue=due;
-    schedulerTimer=setTimeout(()=>{schedulerTimer=0;schedulerDue=0;requestScheduler()},Math.max(0,Math.ceil(delay)));
-    return
-  }
-  if(schedulerTimer){clearTimeout(schedulerTimer);schedulerTimer=0;schedulerDue=0}
-  if(!schedulerRAF)schedulerRAF=requestAnimationFrame(loop)
-}
-function invalidateView(withStats=true){needsPaint=true;if(withStats)needsStats=true;requestScheduler()}
-function invalidateStats(){needsStats=true;requestScheduler()}
-
-// Device-specific runtime wisdom. It is populated by a small background CPU
-// concurrency benchmark and then refined by real deep-render strip timings.
-const deepWisdom={
-  ready:false,running:false,maxWorkers:1,workerCount:1,
-  targetStripMs:12,stripRows:24,rowMsEMA:0,
-  realBench:false
-};
-function deepWisdomStorageKey(){
-  const meta=globalThis.MANDEL_KERNEL_META||{},kernel=String(meta.BLA_SIMD_B64||meta.BLA_SCALAR_B64||'embedded').slice(0,16),hc=Math.max(1,navigator.hardwareConcurrency||1),dm=Number(navigator.deviceMemory||0);return'mandelbrot.wisdom.v23.'+[kernel,hc,dm].join('.')
-}
-function restoreDeepWisdom(){
-  try{const saved=JSON.parse(localStorage.getItem(deepWisdomStorageKey())||'null');if(!saved||saved.version!==23)return;const row=Number(saved.rowMsEMA),rows=Number(saved.stripRows),workers=Number(saved.workerCount);if(Number.isFinite(row)&&row>0&&row<1000)deepWisdom.rowMsEMA=row;if(Number.isInteger(rows)&&rows>=2&&rows<=128)deepWisdom.stripRows=rows;if(Number.isInteger(workers)&&workers>=1&&workers<=deepWorkerLimit())deepWisdom.workerCount=workers;deepWisdom.ready=deepWisdom.rowMsEMA>0}catch{}
-}
-function persistDeepWisdom(){
-  if(!deepWisdom.rowMsEMA)return;try{localStorage.setItem(deepWisdomStorageKey(),JSON.stringify({version:23,rowMsEMA:deepWisdom.rowMsEMA,stripRows:deepWisdom.stripRows,workerCount:deepWisdom.workerCount}))}catch{}
-}
+const G=globalThis.MANDEL_WEBGPU_KERNELS;if(!G)throw new Error('gpu-kernels.js が読み込まれていません');
+const $=s=>document.querySelector(s),canvas=$('#view');
+const VERSION=24,INITIAL_BITS=256,MIN_SPAN_BITS=224,TARGET_SPAN_BITS=240,RATIO_DEN=4503599627370496n;
+const FIELD_UNKNOWN=0,FIELD_ESCAPED=1,FIELD_INTERIOR_LIKELY=2,FIELD_INTERIOR_PROVEN=3;
+const state={bits:INITIAL_BITS,re:0n,im:0n,span:0n,baseIter:350,adaptive:true,hq:false,processMode:'standard',palette:0,cycle:.008,shift:.18,token:0,rendering:false,recoloring:false,recolorPending:false,dirty:true,lastRender:0,lastEngine:'起動中',drawState:'REPROJECTED',frameView:null,fieldView:null,pointerActive:false,wheelActive:false,effectiveDpr:1,screenPixelBudget:0,unresolved:0,gpuError:'',gpuInitFailed:false,gpuUnavailable:false,lastInteraction:performance.now(),focusX:.5,focusY:.5,uiHidden:false};
+let renderer=null,rendererInitPromise=null,fallbackCtx=null,webgpuCanvasClaimed=false,raf=0,settleTimer=0,lastWrittenHash='',navigationHash='';
+const viewHistory=[];let viewHistoryIndex=-1;
+const runtime={renderStarts:0,deviceLosses:0,referenceBuilds:0,gpuFrames:0,gpuRecolors:0,exports:0};
 
+// ── exact fixed-point view state ─────────────────────────────────────────
 function one(bits=state.bits){return 1n<<BigInt(bits)}
 function fromFrac(n,d=1n){return n*one()/d}
-function fromDec(s){
-  s=String(s).trim();let neg=s[0]==='-';if(neg)s=s.slice(1);
-  const p=s.toLowerCase().split('e'),mant=p[0],exp=p[1]?parseInt(p[1],10):0;
-  const a=mant.split('.'),i=a[0]||'0',f=a[1]||'';
-  let digits=(i+f).replace(/^0+(?=\d)/,'')||'0',decPlaces=f.length-exp;
-  if(decPlaces<0){digits+='0'.repeat(-decPlaces);decPlaces=0}
-  const den=10n**BigInt(decPlaces),v=(BigInt(digits)*one()+den/2n)/den;return neg?-v:v;
-}
-function decimalRequiredBits(s){s=String(s).trim().replace(/^[+-]/,'');const p=s.toLowerCase().split('e'),f=(p[0].split('.')[1]||'').length,e=p[1]?parseInt(p[1],10):0,places=Math.max(0,f-e);return Math.max(64,Math.ceil(places*Math.log2(10))+32)}
-function bitLen(n){n=n<0n?-n:n;return n===0n?0:n.toString(2).length}
-function fixedNum(v,bits=state.bits){
-  if(v===0n)return 0;let neg=v<0n;if(neg)v=-v;
-  const bl=bitLen(v),keep=52;let top,exp;
-  if(bl>keep){const sh=BigInt(bl-keep);top=Number(v>>sh);exp=(bl-keep)-bits}else{top=Number(v);exp=-bits}
-  const x=top*Math.pow(2,exp);return neg?-x:x;
-}
-// Hot-path conversion for orbit values known to stay O(1).
-function fixedOrbitNum(v,bits){
-  if(v===0n)return 0;
-  const sh=bits-54;
-  if(sh>0)return Number(v>>BigInt(sh))*Math.pow(2,-54);
-  return Number(v)*Math.pow(2,-bits);
-}
+function fromDec(s){s=String(s).trim();let neg=s.startsWith('-');if(neg)s=s.slice(1);if(s.startsWith('+'))s=s.slice(1);const p=s.toLowerCase().split('e'),mant=p[0],exp=p[1]?parseInt(p[1],10):0,a=mant.split('.'),i=a[0]||'0',f=a[1]||'';let digits=(i+f).replace(/^0+(?=\d)/,'')||'0',places=f.length-exp;if(places<0){digits+='0'.repeat(-places);places=0}const den=10n**BigInt(places),v=(BigInt(digits)*one()+den/2n)/den;return neg?-v:v}
+function decimalRequiredBits(s){s=String(s).trim().replace(/^[+-]/,'');const p=s.toLowerCase().split('e'),f=(p[0].split('.')[1]||'').length,e=p[1]?parseInt(p[1],10):0;return Math.max(64,Math.ceil(Math.max(0,f-e)*Math.log2(10))+32)}
+function bitLen(v){v=v<0n?-v:v;return v===0n?0:v.toString(2).length}
+function align(v,fromBits,toBits){const d=toBits-fromBits;return d===0?v:d>0?v<<BigInt(d):v>>BigInt(-d)}
+function fixedNum(v,bits=state.bits){if(v===0n)return 0;const neg=v<0n;if(neg)v=-v;const bl=bitLen(v),keep=52;let top,exp;if(bl>keep){const sh=BigInt(bl-keep);top=Number(v>>sh);exp=bl-keep-bits}else{top=Number(v);exp=-bits}const x=top*Math.pow(2,exp);return neg?-x:x}
 function log2FixedAt(v,bits){v=v<0n?-v:v;if(v===0n)return-Infinity;const bl=bitLen(v),take=Math.min(53,bl),sh=bl-take,top=Number(v>>BigInt(sh));return Math.log2(top)+sh-bits}
 function log2Fixed(v){return log2FixedAt(v,state.bits)}
-function zoomExp(){return Math.max(0,Math.log10(3.4)-log2Fixed(state.span)/Math.log2(10))}
-function fixedRatio(a,b){
-  if(b===0n)return 0;if(a===0n)return 0;const neg=a<0n;if(neg)a=-a;
-  const q=(a<<52n)/b;const v=Number(q)/4503599627370496;return neg?-v:v;
-}
-function align(v,fromBits,toBits){const d=toBits-fromBits;return d===0?v:d>0?v<<BigInt(d):v>>BigInt(-d)}
-function promoteState(shift){
-  // Precision promotion used to invalidate the reference orbit. Keep the same
-  // mathematical values by shifting their fixed-point representation instead.
-  // If a render is in flight, logically cancel it before mutating shared cache state.
-  if(state.rendering)cancelRender();
-  const oldBits=state.bits,s=BigInt(shift);state.re<<=s;state.im<<=s;state.span<<=s;
-  if(state.frameView){state.frameView.re<<=s;state.frameView.im<<=s;state.frameView.span<<=s;state.frameView.bits+=shift}
-  state.bits+=shift;
-  promoteReferenceCache(shift,oldBits);
-}
-function ensurePrecision(){
-  const bl=bitLen(state.span);
-  if(bl>=MIN_SPAN_BITS)return false;
-  // Defer representation-only precision promotion until the current frame finishes.
-  if(state.rendering){state.precisionPending=true;return false}
-  state.precisionPending=false;promoteState(TARGET_SPAN_BITS-bl);return true
-}
-function flushPendingPrecision(){
-  if(state.rendering||!state.precisionPending)return false;state.precisionPending=false;
-  const bl=bitLen(state.span);if(bl<MIN_SPAN_BITS){promoteState(TARGET_SPAN_BITS-bl);return true}return false
-}
-function mulRatio(v,factor){
-  const n=BigInt(Math.max(1,Math.round(factor*Number(RATIO_DEN))));return v*n/RATIO_DEN;
-}
+function fixedRatio(a,b){if(!b||!a)return 0;let neg=a<0n;if(neg)a=-a;const q=(a<<52n)/b,v=Number(q)/4503599627370496;return neg?-v:v}
+function mulRatio(v,f){const n=BigInt(Math.max(1,Math.round(f*Number(RATIO_DEN))));return v*n/RATIO_DEN}
+function promoteState(shift){const s=BigInt(shift);state.re<<=s;state.im<<=s;state.span<<=s;if(state.frameView){state.frameView={...state.frameView,bits:state.frameView.bits+shift,re:state.frameView.re<<s,im:state.frameView.im<<s,span:state.frameView.span<<s}}state.bits+=shift}
+function ensurePrecision(){const bl=bitLen(state.span);if(bl<MIN_SPAN_BITS)promoteState(TARGET_SPAN_BITS-bl)}
 function fmtFixed(v,d=17){let neg=v<0n;if(neg)v=-v;const scale=10n**BigInt(d),q=v*scale>>BigInt(state.bits);let s=q.toString().padStart(d+1,'0');s=s.slice(0,-d)+'.'+s.slice(-d);s=s.replace(/(\.\d*?)0+$/,'$1').replace(/\.$/,'');return(neg?'-':'')+s}
-function fmtFixedExact(v){let neg=v<0n;if(neg)v=-v;const d=state.bits,q=v*(10n**BigInt(d))>>BigInt(state.bits);let s=q.toString().padStart(d+1,'0');s=s.slice(0,-d)+'.'+s.slice(-d);s=s.replace(/(\.\d*?)0+$/,'$1').replace(/\.$/,'');return(neg?'-':'')+s}
-function fmtSpan(){const l=log2Fixed(state.span);if(!Number.isFinite(l))return'0';const e=Math.floor(l/Math.log2(10)),m=Math.pow(2,l-e*Math.log2(10));return m.toFixed(4)+'e'+e}
-function maxIter(){if(!state.adaptive)return state.baseIter;const z=zoomExp();if(z<12)return Math.min(12000,Math.round(state.baseIter+22*Math.sqrt(z)*Math.log2(2+z)));return Math.min(140000,Math.round(state.baseIter+150*z+260*Math.log2(2+z)))}
-function ensureOrbitPrecision(iter,width=Math.max(1,canvas.width)){const conditionBits=referenceCache.rr?Math.max(0,Math.min(256,Math.ceil(referenceCache.conditionLog2||0))):0,required=160+conditionBits,available=bitLen(state.span)-Math.ceil(Math.log2(width))-Math.ceil(Math.log2(Math.max(2,iter)));if(available>=required)return false;promoteState(required+32-available);invalidateReferenceOrbit();return true}
-function f64Ulp(x){x=Math.abs(x);if(!Number.isFinite(x))return Infinity;if(x===0)return Number.MIN_VALUE;return Math.pow(2,Math.floor(Math.log2(x))-52)}
-function deepResolutionRatio(snap=snapshot(),width=Math.max(1,canvas.width)){const step=Math.abs(fixedNum(snap.span,snap.bits))/Math.max(1,width),ulp=Math.max(f64Ulp(fixedNum(snap.re,snap.bits)),f64Ulp(fixedNum(snap.im,snap.bits)));return step===0||!Number.isFinite(step)?0:step/Math.max(Number.MIN_VALUE,ulp)}
-function deepEngineNeeded(snap=snapshot(),width=Math.max(1,canvas.width)){if(exportForcePrecision)return true;const ratio=deepResolutionRatio(snap,width),orbitRisk=ratio<=128&&(deepTelemetry.badRatio>1e-4||deepTelemetry.unresolvedRatio>2e-3||deepTelemetry.repairRatio>.08);deepMode=orbitRisk||(deepMode?ratio<64:ratio<=32);return deepMode}
-function iterationPlan(profile,deep){
-  const colorIter=maxIter();return{colorIter,computeIter:colorIter};
-}
-function workProfile(profile){return{bla:profile.blaSteps,ptb:profile.ptbSteps}}
-function cancelRender(){state.token++;state.rendering=false;cancelDeepPoolJob();flushPendingPrecision()}
-function cancelDetailRefinement(clearCurrent=true){
-  state.detailGeneration++;state.detailActive=false;state.detailQueued=0;state.detailDone=0;detailPlan=null;
-  if(clearCurrent)activeDetailTiles.length=0;
-}
-function clearDetailCache(){DETAIL_TILE_CACHE.clear();detailCacheBytes=0;activeDetailTiles.length=0;cancelDetailRefinement(false)}
-function setDirty(cancel=true){cancelUnknownContinuation();state.lastInteraction=performance.now();state.dirty=true;state.lastPass=null;state.drawState=state.frameView?'REPROJECTED':'PREVIEW';state.coverage=0;cancelDetailRefinement(true);if(cancel)cancelRender();invalidateView()}
-function reset(){
-  clearDetailCache();clearPanReuse();state.bits=INITIAL_BITS;state.re=-fromFrac(1n,2n);state.im=0n;state.span=fromFrac(34n,10n);setDirty();saveHash(false)
-}
-function viewRect(){return canvas.getBoundingClientRect()}
-function updateFocus(x,y){const r=viewRect();state.focusX=Math.max(0,Math.min(1,(x-r.left)/Math.max(1,r.width)));state.focusY=Math.max(0,Math.min(1,(y-r.top)/Math.max(1,r.height)))}
-function zoomAt(x,y,factor){
-  if(!state.panReuse)capturePanSource();
-  const r=viewRect(),fx=(x-r.left)/Math.max(1,r.width)-.5,fy=(y-r.top)/Math.max(1,r.height)-.5;
-  factor=Math.max(.01,Math.min(100,factor));const old=state.span,neu=mulRatio(old,factor);
-  const dx=BigInt(Math.round(fx*1e9)),dy=BigInt(Math.round(fy*1e9));
-  state.re+=(old-neu)*dx/1000000000n;
-  const oldY=old*BigInt(canvas.height)/BigInt(Math.max(1,canvas.width)),newY=neu*BigInt(canvas.height)/BigInt(Math.max(1,canvas.width));
-  state.im-=(oldY-newY)*dy/1000000000n;state.span=neu;ensurePrecision();setDirty(!(state.pointerActive||state.wheelActive));
-}
-function pan(dx,dy){
-  const w=Math.max(1,canvas.clientWidth),h=Math.max(1,canvas.clientHeight);
-  state.re-=state.span*BigInt(Math.round(dx*100000))/BigInt(Math.round(w*100000));
-  const ys=state.span*BigInt(canvas.height)/BigInt(Math.max(1,canvas.width));
-  state.im+=ys*BigInt(Math.round(dy*100000))/BigInt(Math.round(h*100000));setDirty(!(state.pointerActive||state.wheelActive));
-}
-
-
-function clearPanReuse(){state.panReuse=null}
-function capturePanSource(){
-  if(!state.frameView||!frameCanvas.width||!frameCanvas.height)return false;
-  const fv=state.frameView;state.panReuse={canvas:frameCanvas,snap:{bits:fv.bits,re:fv.re,im:fv.im,span:fv.span},style:styleSignature(),pass:state.lastPass,iter:maxIter(),created:performance.now()};return true
-}
-function buildPanReuse(snap,w,h,iter,profile){
-  const src=state.panReuse;if(!src||!src.canvas||src.style!==styleSignature())return null;
-  // Final HQ must recompute after a real scale change. Interactive/base passes may
-  // reproject a much larger range so wheel/pinch zoom can reuse existing pixels.
-  const re=align(src.snap.re,src.snap.bits,snap.bits),im=align(src.snap.im,src.snap.bits,snap.bits),sp=align(src.snap.span,src.snap.bits,snap.bits),scale=fixedRatio(sp,snap.span);
-  if(!Number.isFinite(scale)||scale<.22||scale>4.5)return null;
-  const scaleChange=Math.abs(Math.log2(Math.max(1e-12,scale)));
-  // Covered is a sampling contract, not a presentation shortcut. Reprojection
-  // is allowed only for Preview; the target grid is always recomputed in full.
-  if(profile.covered)return null;
-  const dx=fixedRatio(re-snap.re,snap.span)*w,dy=-fixedRatio(im-snap.im,snap.span)*w,move=Math.hypot(dx/Math.max(1,w),dy/Math.max(1,w));if(!Number.isFinite(move)||move>1.35)return null;
-  const dw=w*scale,dh=w*scale*(src.canvas.height/Math.max(1,src.canvas.width)),density=dw/Math.max(1,src.canvas.width);
-  // A zoomed preview may stretch old pixels temporarily, but the idle HQ pass will
-  // recompute it. Keep the stretch bounded so interaction never becomes misleading.
-  if(density>profile.densityLimit)return null;
-  const x0=w*.5+dx-dw*.5,y0=h*.5+dy-dh*.5,x1=x0+dw,y1=y0+dh;
-  let ix0=Math.max(0,Math.ceil(x0)+2),iy0=Math.max(0,Math.ceil(y0)+2),ix1=Math.min(w,Math.floor(x1)-2),iy1=Math.min(h,Math.floor(y1)-2);
-  if(ix1<=ix0||iy1<=iy0)return null;
-  const overlap=(ix1-ix0)*(iy1-iy0),frac=overlap/Math.max(1,w*h);if(frac<.20)return null;
-  const c=document.createElement('canvas');c.width=w;c.height=h;const cc=c.getContext('2d',{alpha:false});if(!cc)return null;cc.fillStyle='#050813';cc.fillRect(0,0,w,h);cc.imageSmoothingEnabled=true;try{cc.imageSmoothingQuality='high'}catch{};cc.drawImage(src.canvas,x0,y0,dw,dh);
-  const out=new Uint8ClampedArray(cc.getImageData(0,0,w,h).data),rects=[];
-  const add=(x,y,rw,rh)=>{x=Math.max(0,x|0);y=Math.max(0,y|0);rw=Math.min(w-x,rw|0);rh=Math.min(h-y,rh|0);if(rw>0&&rh>0)rects.push({x0:x,y0:y,w:rw,h:rh})};
-  add(0,0,w,iy0);add(0,iy1,w,h-iy1);add(0,iy0,ix0,iy1-iy0);add(ix1,iy0,w-ix1,iy1-iy0);
-  const exposed=rects.reduce((a,r)=>a+r.w*r.h,0);if(exposed>w*h*.80)return null;
-  return{out,rects,reusedPixels:w*h-exposed,exposedPixels:exposed,scale};
-}
-
-// ── Palette / smooth colouring ───────────────────────────────────────────
-const PALETTE_CURRENT=0,PALETTE_RAINBOW=1,PALETTE_MONO=2;
-const FIELD_ESCAPED=1,FIELD_INTERIOR_PROVEN=2,FIELD_INTERIOR_LIKELY=3,FIELD_UNKNOWN=4;
-const stops=[[0,[4,10,27]],[.11,[12,53,79]],[.25,[31,156,184]],[.38,[91,226,234]],[.50,[66,53,151]],[.62,[139,49,170]],[.73,[232,72,145]],[.84,[255,137,64]],[.93,[255,211,99]],[1,[255,250,223]]];
-const COLOR_PHASES=2048,COLOR_MIXES=64;
-function hsvRgb(h,sat,val){h=((h%1)+1)%1;const x=h*6,i=Math.floor(x),f=x-i,p=val*(1-sat),q=val*(1-sat*f),s=val*(1-sat*(1-f));let r,g,b;switch(i%6){case 0:r=val;g=s;b=p;break;case 1:r=q;g=val;b=p;break;case 2:r=p;g=val;b=s;break;case 3:r=p;g=q;b=val;break;case 4:r=s;g=p;b=val;break;default:r=val;g=p;b=q}return[r*255,g*255,b*255]}
-function basePalette(kind,t){
-  t=((t%1)+1)%1;
-  if(kind===PALETTE_RAINBOW)return hsvRgb(t,.92,1);
-  if(kind===PALETTE_MONO){const g=22+233*(.5-.5*Math.cos(Math.PI*2*t));return[g,g,g]}
-  let a=stops[0],b=stops[stops.length-1];for(let j=1;j<stops.length;j++){if(t<=stops[j][0]){a=stops[j-1];b=stops[j];break}}
-  let f=(t-a[0])/(b[0]-a[0]||1);f=f*f*(3-2*f);return[a[1][0]+(b[1][0]-a[1][0])*f,a[1][1]+(b[1][1]-a[1][1])*f,a[1][2]+(b[1][2]-a[1][2])*f]
-}
-function buildColorLut(kind){const lut=new Uint8Array(COLOR_PHASES*3);for(let pi=0;pi<COLOR_PHASES;pi++){const u=pi/(COLOR_PHASES-1),t=kind===PALETTE_CURRENT?(u<=.5?u*2:2-u*2):u,c=basePalette(kind,t),k=pi*3;lut[k]=c[0]|0;lut[k+1]=c[1]|0;lut[k+2]=c[2]|0}return lut}
-const COLOR_LUTS=[buildColorLut(PALETTE_CURRENT),buildColorLut(PALETTE_RAINBOW),buildColorLut(PALETTE_MONO)];
-const SMOOTH_U_MIN=2,SMOOTH_U_STEP=1/128,SMOOTH_U_N=4097,SMOOTH_CORR=new Float32Array(SMOOTH_U_N);
-for(let i=0;i<SMOOTH_U_N;i++){const u=SMOOTH_U_MIN+i*SMOOTH_U_STEP;SMOOTH_CORR[i]=1-Math.log2(.5*u)}
-const COLOR_CTX_CACHE=new Map();
-function makeColorCtx(iter){let hit=COLOR_CTX_CACHE.get(iter);if(hit)return hit;const mixBin=new Uint8Array(iter+1),den=Math.log1p(Math.max(8,iter));for(let n=0;n<=iter;n++){const edge=Math.max(0,Math.min(1,Math.log1p(n)/den));mixBin[n]=Math.min(COLOR_MIXES-1,Math.round((COLOR_MIXES-1)*Math.pow(edge,.38)))}hit={mixBin};COLOR_CTX_CACHE.set(iter,hit);if(COLOR_CTX_CACHE.size>8)COLOR_CTX_CACHE.delete(COLOR_CTX_CACHE.keys().next().value);return hit}
-function smoothEscape(n,m){const u=Math.log2(Math.max(4.0000001,m));let corr;const fi=(u-SMOOTH_U_MIN)/SMOOTH_U_STEP;if(fi>=0&&fi<SMOOTH_U_N-1){const i=fi|0,f=fi-i;corr=SMOOTH_CORR[i]+(SMOOTH_CORR[i+1]-SMOOTH_CORR[i])*f}else corr=1-Math.log2(.5*u);return n+corr}
-function putPaletteColor(out,oi,sm,n,iter,colorCtx){let phase=state.shift+sm*state.cycle;phase-=Math.floor(phase);const pi=Math.min(COLOR_PHASES-1,(phase*COLOR_PHASES)|0),mi=colorCtx.mixBin[Math.min(iter,n)],mix=.34+.66*(mi/(COLOR_MIXES-1)),kind=state.palette,lut=COLOR_LUTS[kind]||COLOR_LUTS[0],k=pi*3,f0=kind===PALETTE_MONO?8:2,f1=kind===PALETTE_MONO?8:5,f2=kind===PALETTE_MONO?8:15;out[oi]=(f0+(lut[k]-f0)*mix)|0;out[oi+1]=(f1+(lut[k+1]-f1)*mix)|0;out[oi+2]=(f2+(lut[k+2]-f2)*mix)|0;out[oi+3]=255}
-function putFastColor(out,oi,n,m,iter,colorCtx){putPaletteColor(out,oi,smoothEscape(n,m),n,iter,colorCtx)}
-function makeField(size,iter){return{smooth:new Float32Array(size),iterations:new Uint32Array(size),classes:new Uint8Array(size),confidence:new Uint8Array(size),iter}}
-function fieldConfidence(kind){return kind===FIELD_ESCAPED||kind===FIELD_INTERIOR_PROVEN?255:kind===FIELD_INTERIOR_LIKELY?192:0}
-function putField(field,index,n,m,kind){field.classes[index]=kind;if(field.iterations)field.iterations[index]=Math.max(0,n)>>>0;if(field.confidence)field.confidence[index]=fieldConfidence(kind);if(kind===FIELD_ESCAPED)field.smooth[index]=smoothEscape(n,m);else field.smooth[index]=NaN}
-function fillFieldConfidence(field){if(!field.confidence)field.confidence=new Uint8Array(field.classes.length);for(let i=0;i<field.classes.length;i++)field.confidence[i]=fieldConfidence(field.classes[i])}
-function colorizeField(field){const out=new Uint8ClampedArray(field.classes.length*4),colorCtx=makeColorCtx(field.iter);for(let i=0,oi=0;i<field.classes.length;i++,oi+=4){const kind=field.classes[i];if(kind!==FIELD_ESCAPED){const neutral=kind===FIELD_UNKNOWN;out[oi]=neutral?20:0;out[oi+1]=neutral?22:0;out[oi+2]=neutral?30:0;out[oi+3]=255;continue}const sm=field.smooth[i],n=Math.max(0,Math.min(field.iter,Math.floor(sm)));putPaletteColor(out,oi,sm,n,field.iter,colorCtx)}return out}
-
-// Embedded WebAssembly: SIMD-optimized kernel with a scalar fallback.
-
-
-let wasm=null;
-function instantiateWasm(b64){
-  const module=b64 instanceof WebAssembly.Module?b64:(()=>{const raw=atob(b64),bytes=new Uint8Array(raw.length);for(let i=0;i<raw.length;i++)bytes[i]=raw.charCodeAt(i);return new WebAssembly.Module(bytes)})(),inst=new WebAssembly.Instance(module,{}),ex=inst.exports;
-  return {module,ex,counts:()=>new Uint32Array(ex.memory.buffer,ex.counts_ptr(),65536),mags:()=>new Float64Array(ex.memory.buffer,ex.mags_ptr(),65536),refsR:()=>new Float64Array(ex.memory.buffer,ex.refs_r_ptr(),150001),refsI:()=>new Float64Array(ex.memory.buffer,ex.refs_i_ptr(),150001)};
-}
-try{wasm=instantiateWasm(WASM_SIMD_B64);wasm.simd=globalThis.MANDEL_HOSTED_SHALLOW_SIMD!==false}catch(e){try{wasm=instantiateWasm(WASM_SCALAR_B64);wasm.simd=false}catch(_e){wasm=null}}
-let shallowWorker=null,shallowWorkerUrl=null,shallowWorkerBusy=false,shallowRecycle=null;
-function shallowWorkerSource(){return `'use strict';let ex=null;function smooth(n,m){const u=Math.log2(Math.max(4.0000001,m));return n+1-Math.log2(.5*u)}function likely(cr,ci){const y2=ci*ci,x=cr-.25,q=x*x+y2;if(q*(q+x)<=.25*y2)return true;const x2=cr+1;return x2*x2+y2<=.0625}self.onmessage=e=>{const d=e.data;if(d.type==='init'){ex=new WebAssembly.Instance(d.module,{}).exports;postMessage({type:'ready'});return}if(d.type!=='render'||!ex)return;try{const scale=d.sp/d.w,npx=ex.render_rows(d.cre+scale*.5,d.cim-scale*.5,d.sp,d.w,d.h,d.y,d.rows,d.iter),counts=new Uint32Array(ex.memory.buffer,ex.counts_ptr(),65536),mags=new Float64Array(ex.memory.buffer,ex.mags_ptr(),65536),field=d.fieldBuffer&&d.fieldBuffer.byteLength>=npx*4?new Float32Array(d.fieldBuffer,0,npx):new Float32Array(npx),iterations=d.iterationBuffer&&d.iterationBuffer.byteLength>=npx*4?new Uint32Array(d.iterationBuffer,0,npx):new Uint32Array(npx),classes=d.classBuffer&&d.classBuffer.byteLength>=npx?new Uint8Array(d.classBuffer,0,npx):new Uint8Array(npx);for(let i=0;i<npx;i++){const n=counts[i],x=i%d.w,y=d.y+((i/d.w)|0),cr=d.cre+(x+.5-d.w*.5)*scale,ci=d.cim+(d.h*.5-y-.5)*scale;iterations[i]=n;if(n<d.iter){classes[i]=1;field[i]=smooth(n,mags[i])}else{classes[i]=likely(cr,ci)?3:4;field[i]=NaN}}postMessage({type:'render',jobId:d.jobId,y:d.y,rows:d.rows,field:field.buffer,iterations:iterations.buffer,classes:classes.buffer},[field.buffer,iterations.buffer,classes.buffer])}catch(error){postMessage({type:'render',jobId:d.jobId,error:String(error&&error.message||error)})}}`}
-function ensureShallowWorker(){if(shallowWorker||!wasm||typeof Worker==='undefined'||typeof Blob==='undefined')return!!shallowWorker;try{shallowWorkerUrl=URL.createObjectURL(new Blob([shallowWorkerSource()],{type:'text/javascript'}));shallowWorker=new Worker(shallowWorkerUrl);shallowWorker.postMessage({type:'init',module:wasm.module});return true}catch{shallowWorker=null;return false}}
-function destroyShallowWorker(){if(shallowWorker){try{shallowWorker.terminate()}catch{}shallowWorker=null}if(shallowWorkerUrl){try{URL.revokeObjectURL(shallowWorkerUrl)}catch{}shallowWorkerUrl=null}shallowWorkerBusy=false;shallowRecycle=null}
-
-
-
-function instantiateDeepWasm(b64){
-  const module=b64 instanceof WebAssembly.Module?b64:(()=>{const raw=atob(b64),bytes=new Uint8Array(raw.length);for(let i=0;i<raw.length;i++)bytes[i]=raw.charCodeAt(i);return new WebAssembly.Module(bytes)})();
-  const ex=new WebAssembly.Instance(module,{}).exports;
-  return {ex,counts:()=>new Uint32Array(ex.memory.buffer,ex.counts_ptr(),65536),mags:()=>new Float64Array(ex.memory.buffer,ex.mags_ptr(),65536),refsR:()=>new Float64Array(ex.memory.buffer,ex.refs_r_ptr(),150001),refsI:()=>new Float64Array(ex.memory.buffer,ex.refs_i_ptr(),150001)};
-}
-let deepWasm=null,deepWasmTried=false,deepModuleBundle=null,deepModulePromise=null;
-async function compileKernelSource(source){if(source instanceof WebAssembly.Module)return source;if(/^https?:/i.test(source)){const response=await fetch(source,{cache:'force-cache'});if(!response.ok)throw new Error('WASM request failed '+response.status);if(WebAssembly.compileStreaming){try{return await WebAssembly.compileStreaming(Promise.resolve(response.clone()))}catch{}}return WebAssembly.compile(await response.arrayBuffer())}const raw=atob(source),bytes=new Uint8Array(raw.length);for(let i=0;i<raw.length;i++)bytes[i]=raw.charCodeAt(i);return WebAssembly.compile(bytes)}
-async function compileKernelPair(simd,scalar){try{return{module:await compileKernelSource(simd),simd:true}}catch{return{module:await compileKernelSource(scalar),simd:false}}}
-function prepareDeepModules(){if(deepModuleBundle)return Promise.resolve(deepModuleBundle);if(!deepModulePromise)deepModulePromise=Promise.all([compileKernelPair(DEEP_SIMD_B64,DEEP_SCALAR_B64),compileKernelPair(BLA_SIMD_B64,BLA_SCALAR_B64),compileKernelPair(COLOR_SIMD_B64,COLOR_SCALAR_B64)]).then(([deep,bla,color])=>deepModuleBundle={deep,bla,color}).catch(error=>{deepModulePromise=null;throw error});return deepModulePromise}
-function ensureDeepWasm(){
-  if(deepWasm)return true;if(deepWasmTried)return false;deepWasmTried=true;if(deepModuleBundle){try{deepWasm=instantiateDeepWasm(deepModuleBundle.deep.module);deepWasm.simd=deepModuleBundle.deep.simd}catch{deepWasm=null}return!!deepWasm}if(/^https?:/i.test(DEEP_SIMD_B64)||/^https?:/i.test(DEEP_SCALAR_B64))return false;
-  try{deepWasm=instantiateDeepWasm(DEEP_SIMD_B64);deepWasm.simd=true}catch(e){try{deepWasm=instantiateDeepWasm(DEEP_SCALAR_B64);deepWasm.simd=false}catch(_e){deepWasm=null}}
-  return!!deepWasm
-}
-
-
-
-
-
-
-
-// Deep renderer worker pool. Each worker owns a WASM instance and performs both the
-// perturbation kernel and colour mapping, so colourful frames no longer funnel all
-// post-processing through the UI thread. Jobs are striped dynamically for load balance.
-const deepPool={workers:[],url:null,activeToken:0,serial:0,failed:false,current:null,maxWorkers:0,benchTimer:0};
-// ── Persistent deep-render workers / BLA kernel ──────────────────────────
-function deepWorkerSource(){
-  return `'use strict';
-let core=null,blaCore=null,colorCore=null,refKey='',refLoaded=0,RR=new Float64Array(150001),RI=new Float64Array(150001),blaRefKey='',blaRefLoaded=0,blaBuiltKey='',lastBlaBuildMs=0;
-function ensure(){if(!core)throw new Error('deep module not initialized');return core}
-function ensureBla(){if(!blaCore)throw new Error('BLA module not initialized');return blaCore}
-function ensureColor(){if(!colorCore)throw new Error('color module not initialized');return colorCore}
-function applyRef(d,ex){if(d.refKey!==refKey){refKey=d.refKey;refLoaded=0;blaRefKey='';blaRefLoaded=0;blaBuiltKey=''}if(d.rr){const ar=new Float64Array(d.rr),ai=new Float64Array(d.ri),st=d.rrStart|0;RR.set(ar,st);RI.set(ai,st);new Float64Array(ex.memory.buffer,ex.refs_r_ptr(),150001).set(ar,st);new Float64Array(ex.memory.buffer,ex.refs_i_ptr(),150001).set(ai,st);refLoaded=Math.max(refLoaded,st+ar.length);if(blaCore&&blaRefKey===refKey){const bx=blaCore.ex;new Float64Array(bx.memory.buffer,bx.refs_r_ptr(),150001).set(ar,st);new Float64Array(bx.memory.buffer,bx.refs_i_ptr(),150001).set(ai,st);blaRefLoaded=Math.max(blaRefLoaded,st+ar.length);blaBuiltKey=''}}if(refLoaded<d.refLen+1)throw new Error('reference cache miss')}
-function syncRefsToBla(d,key=d.blaKey,eps=d.blaEps){if(!d.useBla)return null;const b=ensureBla(),ex=b.ex;if(blaRefKey!==refKey){new Float64Array(ex.memory.buffer,ex.refs_r_ptr(),150001).set(RR.subarray(0,refLoaded));new Float64Array(ex.memory.buffer,ex.refs_i_ptr(),150001).set(RI.subarray(0,refLoaded));blaRefKey=refKey;blaRefLoaded=refLoaded;blaBuiltKey=''}else if(refLoaded>blaRefLoaded){new Float64Array(ex.memory.buffer,ex.refs_r_ptr(),150001).set(RR.subarray(blaRefLoaded,refLoaded),blaRefLoaded);blaRefLoaded=refLoaded;blaBuiltKey=''}lastBlaBuildMs=0;if(blaBuiltKey!==key){const t=performance.now(),levels=ex.build_bla(d.refLen,d.cMax,eps);lastBlaBuildMs=performance.now()-t;if(!levels)return null;blaBuiltKey=key}return b}
-function smoothBatch(srcMags,npx){const c=ensureColor(),ex=c.ex,mi=new Float64Array(ex.memory.buffer,ex.mags_ptr(),65536),co=new Float32Array(ex.memory.buffer,ex.corr_ptr(),65536);mi.set(srcMags.subarray(0,npx),0);ex.smooth_batch(npx);return co}
-function strictOne(ex,x,y,d){const counts=new Uint32Array(ex.memory.buffer,ex.counts_ptr(),65536),mags=new Float64Array(ex.memory.buffer,ex.mags_ptr(),65536);ex.render_perturb_rebase_rect(d.spanMant,d.spanBucket,d.offR,d.offI,d.offBucket,d.refLen,d.w,d.h,d.cx,d.cy,x,y,1,1,d.iter,0,0,0,0,0,0,0);return[counts[0],mags[0]]}
-function stats(bx){return{blaSteps:bx.stat_bla_steps?bx.stat_bla_steps():0,ptbSteps:bx.stat_ptb_steps?bx.stat_ptb_steps():0,rebases:bx.stat_rebases?bx.stat_rebases():0,interior:bx.stat_interior?bx.stat_interior():0,unresolved:bx.stat_unresolved?bx.stat_unresolved():0,fail:bx.stat_fail?bx.stat_fail():0}}
-function renderBla(d,b,key,eps,bcap,pcap){const bx=b.ex;if(key!==d.blaKey||eps!==d.blaEps)b=syncRefsToBla(d,key,eps)||b;const t=performance.now(),npx=bx.render_bla_rect_v2?bx.render_bla_rect_v2(d.spanNormal,d.offRn,d.offIn,d.baseCr,d.baseCi,d.refLen,d.w,d.h,d.x0||0,d.y0,d.rectW||d.w,d.rows,d.iter,bcap||0,pcap||0,1):bx.render_bla_rect(d.spanNormal,d.offRn,d.offIn,d.refLen,d.w,d.h,d.x0||0,d.y0,d.rectW||d.w,d.rows,d.iter);return{npx,kernelMs:performance.now()-t,counts:new Uint32Array(bx.memory.buffer,bx.counts_ptr(),65536),mags:new Float64Array(bx.memory.buffer,bx.mags_ptr(),65536),stats:stats(bx)}}
-function verifyAgainstSafe(d,result,rw,npx,b){const want=d.verifySamples||0;if(!want||!b)return{samples:0,mismatch:0};const counts=Uint32Array.from(result.counts.subarray(0,npx)),mags=Float64Array.from(result.mags.subarray(0,npx));result.counts=counts;result.mags=mags;const picks=[],seen=new Set(),add=i=>{if(picks.length>=want)return;i=Math.max(0,Math.min(npx-1,i|0));if(!seen.has(i)){seen.add(i);picks.push(i)}};for(let k=0;k<Math.max(2,want>>1);k++)add(((k+.37)*npx/Math.max(2,want>>1))|0);const stride=Math.max(1,Math.floor(npx/Math.max(16,want*10))),top=[];for(let i=stride;i<npx;i+=stride){const n=counts[i],p=counts[i-stride];if(n<0xfffffffe&&p<0xfffffffe&&((n>=d.iter)!==(p>=d.iter))){add(i);add(i-stride)}if(n<d.iter&&n<0xfffffffe){top.push([n,i]);top.sort((a,b)=>b[0]-a[0]);if(top.length>want)top.length=want}}for(const x of top)add(x[1]);for(let k=0;picks.length<want&&k<want*2;k++)add(((k+.73)*npx/want)|0);let mismatch=0;const bad=[];for(const i of picks){const bn=counts[i];if(bn>=0xfffffffe)continue;const x=(d.x0||0)+(i%rw),y=d.y0+((i/rw)|0),sr=renderBla({...d,x0:x,y0:y,rectW:1,rows:1},b,d.safeBlaKey||d.blaKey,d.safeBlaEps||d.blaEps,0,0),sn=sr.counts[0];if(sn>=0xfffffffe)continue;if((bn>=d.iter)!==(sn>=d.iter)||Math.abs((bn|0)-(sn|0))>(d.verifyDelta||64)){mismatch++;bad.push(i)}}return{samples:picks.length,mismatch,bad}}
-self.onmessage=async e=>{const d=e.data;if(!d)return;if(d.type==='init'){try{core={ex:new WebAssembly.Instance(d.modules.deep.module,{}).exports,simd:!!d.modules.deep.simd};blaCore={ex:new WebAssembly.Instance(d.modules.bla.module,{}).exports,simd:!!d.modules.bla.simd};colorCore={ex:new WebAssembly.Instance(d.modules.color.module,{}).exports,simd:!!d.modules.color.simd};postMessage({type:'ready'})}catch(error){postMessage({type:'ready',error:String(error&&error.message||error)})}return}if(d.type!=='render'&&d.type!=='pilot'&&d.type!=='realBench')return;try{const c=ensure(),ex=c.ex;applyRef(d,ex);const b=syncRefsToBla(d);if((d.type==='pilot'||d.type==='realBench')&&!b)throw new Error('BLA unavailable');if(d.type==='pilot'||d.type==='realBench'){const reps=d.type==='realBench'?Math.max(1,d.repeats|0):1;let rr=null,total=0;for(let k=0;k<reps;k++){rr=renderBla({...d,x0:0,y0:0,rectW:d.w,rows:d.h},b,d.blaKey,d.blaEps,0,0);total+=rr.kernelMs}if(d.type==='realBench'){postMessage({type:'realBench',benchId:d.benchId,kernelMs:total,pixels:rr.npx*reps,blaBuildMs:lastBlaBuildMs,simd:b.simd});return}const co=rr.counts;let black=0,bad=0,sum=0;for(let i=0;i<rr.npx;i++){const n=co[i];if(n>=0xfffffffe){bad++;continue}sum+=Math.min(d.iter,n);if(n>=d.iter)black++}postMessage({type:'pilot',pilotId:d.pilotId,kernelMs:total,pixels:rr.npx,blaBuildMs:lastBlaBuildMs,blackRatio:black/Math.max(1,rr.npx),badRatio:bad/Math.max(1,rr.npx),meanIter:sum/Math.max(1,rr.npx-bad),stats:rr.stats,simd:b.simd});return}
-const rx=d.x0||0,rw=d.rectW||d.w,field=d.fieldBuffer&&d.fieldBuffer.byteLength>=rw*d.rows*4?new Float32Array(d.fieldBuffer,0,rw*d.rows):new Float32Array(rw*d.rows),iterations=d.iterationBuffer&&d.iterationBuffer.byteLength>=rw*d.rows*4?new Uint32Array(d.iterationBuffer,0,rw*d.rows):new Uint32Array(rw*d.rows),classes=d.classBuffer&&d.classBuffer.byteLength>=rw*d.rows?new Uint8Array(d.classBuffer,0,rw*d.rows):new Uint8Array(rw*d.rows),bad=[];let result,repaired=0,verifyMs=0;if(b){result=renderBla(d,b,d.blaKey,d.blaEps,d.maxBlaSteps||0,d.maxPtbSteps||0);let unresolved=result.stats.unresolved||0;if(unresolved&&d.covered){const co=result.counts,ma=result.mags;for(let i=0;i<result.npx;i++)if(co[i]===0xfffffffe){const x=rx+(i%rw),y=d.y0+((i/rw)|0),r=strictOne(ex,x,y,d);co[i]=r[0];ma[i]=r[1]}}
-const tv=performance.now();let v=verifyAgainstSafe(d,result,rw,result.npx,b);verifyMs=performance.now()-tv;if(v.mismatch){const safeKey=d.safeBlaKey||d.blaKey,safeEps=d.safeBlaEps||d.blaEps;result=renderBla(d,b,safeKey,safeEps,0,0);repaired=1}
-}else{const t=performance.now(),npx=ex.render_perturb_rebase_rect(d.spanMant,d.spanBucket,d.offR,d.offI,d.offBucket,d.refLen,d.w,d.h,d.cx,d.cy,rx,d.y0,rw,d.rows,d.iter,d.skip||0,d.Ar||0,d.Ai||0,d.Ab||0,d.Br||0,d.Bi||0,d.Bb||0);result={npx,kernelMs:performance.now()-t,counts:new Uint32Array(ex.memory.buffer,ex.counts_ptr(),65536),mags:new Float64Array(ex.memory.buffer,ex.mags_ptr(),65536),stats:{blaSteps:0,ptbSteps:0,rebases:0,interior:0,unresolved:0,fail:0}}}
-const corr=smoothBatch(result.mags,result.npx);let blackCount=0,sumIter=0;for(let i=0;i<result.npx;i++){let n=result.counts[i],m=result.mags[i];const x=rx+(i%rw),y=d.y0+((i/rw)|0);if(n>=0xfffffffe){if(n===0xffffffff){const r=strictOne(ex,x,y,d);n=r[0];m=r[1]}else{n=d.iter;m=0}}iterations[i]=n;if(n===0xffffffff){classes[i]=4;field[i]=NaN;bad.push(i);continue}sumIter+=Math.min(d.iter,n);if(n>=d.iter){classes[i]=4;field[i]=NaN;blackCount++;continue}classes[i]=1;field[i]=n+corr[i]}
-postMessage({type:'render',jobId:d.jobId,x0:rx,rectW:rw,y0:d.y0,rows:d.rows,field:field.buffer,iterations:iterations.buffer,classes:classes.buffer,bad,simd:c.simd,bla:!!b,blaSimd:b?b.simd:false,colorSimd:colorCore?colorCore.simd:false,kernelMs:result.kernelMs,verifyMs,blaBuildMs:lastBlaBuildMs,pixels:result.npx,blackCount,sumIter,stats:result.stats,verifySamples:d.verifySamples||0,repaired},[field.buffer,iterations.buffer,classes.buffer])}catch(err){postMessage({type:'render',jobId:d.jobId,error:String(err&&err.message||err)})}};
-`;
-}
-function destroyDeepPool(){
-  if(deepPool.current)deepPool.current.cancelled=true;deepPool.current=null;
-  for(const w of deepPool.workers){try{w.terminate()}catch{}}
-  deepPool.workers.length=0;if(deepPool.url){try{URL.revokeObjectURL(deepPool.url)}catch{}deepPool.url=null}
-  deepPool.activeToken=0;deepPool.maxWorkers=0
-}
-function retireDeepAssets(){destroyDeepPool();deepPool.failed=false;deepWasm=null;deepWasmTried=false;deepModuleBundle=null;deepModulePromise=null;referenceCache.rr=null;referenceCache.ri=null;referenceCache.series=null;referenceCache.n=0;referenceCache.escape=0;referenceCache.loadedLen=0;referenceCache.conditionLog2=0;referenceCache.derivative=[0,0,NEG_BUCKET]}
-function cancelDeepPoolJob(){
-  // Logical cancellation: keep Worker, WASM, reference and BLA caches alive.
-  deepPool.activeToken=0;
-  if(deepPool.current){deepPool.current.cancelled=true;deepPool.current=null}
-}
-function handleDeepWorkerMessage(worker,d){
-  const job=worker._job;worker._job=null;worker._busy=false;
-  if(d&&d.type==='ready'){if(d.error){worker._ready=false;deepPool.failed=true;destroyDeepPool();return}worker._ready=true;kickDeepWorker(worker);return}
-  if(!job){kickDeepWorker(worker);return}
-  if(job.type==='bench'){if(d&&d.type==='bench'&&d.benchId===job.benchId)job.resolve(d);else job.reject(new Error('benchmark reply mismatch'));kickDeepWorker(worker);return}
-  if(job.type==='pilot'||job.type==='realBench'){if(d&&((job.type==='pilot'&&d.type==='pilot'&&d.pilotId===job.id)||(job.type==='realBench'&&d.type==='realBench'&&d.benchId===job.id)))job.resolve(d);else job.reject(new Error(job.type+' reply mismatch'));kickDeepWorker(worker);return}
-  if(job.type==='render')job.runner.onResult(worker,d,job);
-  kickDeepWorker(worker)
-}
-function handleDeepWorkerError(worker,e){
-  const job=worker._job;worker._job=null;worker._busy=false;
-  if(job&&(job.type==='bench'||job.type==='pilot'||job.type==='realBench'))job.reject(e instanceof Error?e:new Error('worker job failed'));
-  else if(job&&job.type==='render')job.runner.fail(e);
-  else{deepPool.failed=true;destroyDeepPool()}
-}
-function deepWorkerLimit(){const hc=Math.max(1,navigator.hardwareConcurrency||4),memoryLimited=Number(navigator.deviceMemory||8)<=4?1:2;return Math.max(1,Math.min(memoryLimited,hc>2?hc-1:1))}
-function addDeepWorker(){if(!deepModuleBundle)throw new Error('deep modules are not ready');const i=deepPool.workers.length,w=new Worker(deepPool.url);w._index=i;w._refKey='';w._refLoaded=0;w._busy=false;w._ready=false;w._job=null;w._recycle=null;w.onmessage=e=>handleDeepWorkerMessage(w,e.data);w.onerror=e=>handleDeepWorkerError(w,e);deepPool.workers.push(w);w.postMessage({type:'init',modules:deepModuleBundle});return w}
-function ensureDeepPool(){
-  if(deepPool.failed||!deepModuleBundle||typeof Worker==='undefined'||typeof Blob==='undefined')return false;
-  if(deepPool.workers.length)return true;
-  try{
-    const count=deepWorkerLimit();
-    deepPool.url=URL.createObjectURL(new Blob([deepWorkerSource()],{type:'text/javascript'}));
-    deepPool.maxWorkers=count;deepWisdom.maxWorkers=count;deepWisdom.workerCount=1;addDeepWorker();
-    return true
-  }catch(e){deepPool.failed=true;destroyDeepPool();return false}
-}
-function prewarmDeepAssets(){prepareDeepModules().then(()=>{if(deepResolutionRatio()<=128)ensureDeepPool()}).catch(()=>{})}
-function kickDeepWorker(worker){
-  if(worker._busy||!worker._ready)return;
-  const r=deepPool.current;if(!r||r.cancelled||r.token!==state.token)return;
-  const active=Math.max(1,Math.min(deepWisdom.ready?deepWisdom.workerCount:Math.min(2,deepPool.workers.length),deepPool.workers.length));
-  if(worker._index>=active)return;
-  r.dispatch(worker)
-}
-function attachReference(worker,msg,ref,refLen,refKey,transfer){
-  let start=worker._refKey===refKey?worker._refLoaded:0;start=Math.max(0,Math.min(start,refLen+1));
-  if(start<refLen+1){const rr=ref.rr.slice(start,refLen+1),ri=ref.ri.slice(start,refLen+1);msg.rr=rr.buffer;msg.ri=ri.buffer;msg.rrStart=start;transfer.push(rr.buffer,ri.buffer);worker._refKey=refKey;worker._refLoaded=refLen+1}
-}
-function blaProfile(profile){
-  const z=zoomExp(),exp=profile.covered?32:(z<16?28:23);
-  // Fast pass + local verification/repair is cheaper than making the entire frame
-  // conservative.  Safe strips are rebuilt at e-48 only when a probe disagrees.
-  const safeExp=z<16?48:Math.min(48,Math.max(32,exp+8));
-  return{exp,eps:Math.pow(2,-exp),safeExp}
-}
-function runDeepPool(profile,snap,w,h,iter,colorIter,token,t0,out,sb,refC,off,ref,refLen,series,onFallback,rects=null){
-  if(!ensureDeepPool())return false;if(deepPool.current)deepPool.current.cancelled=true;
-  const centered=pixelCenteredOffset(snap,refC,w),workers=deepPool.workers,refKey=String(ref.id),bad=[],field=makeField(w*h,colorIter),spanNormal=fixedNum(snap.span,snap.bits),offRn=fixedNum(centered.r,snap.bits),offIn=fixedNum(centered.i,snap.bits),baseCr=fixedNum(refC.re,snap.bits),baseCi=fixedNum(refC.im,snap.bits);
-  const cMaxRaw=Math.hypot(offRn,offIn)+Math.abs(spanNormal)*Math.hypot(.5,h/(2*Math.max(1,w))),cBucket=cMaxRaw>0&&Number.isFinite(cMaxRaw)?Math.ceil(Math.log2(cMaxRaw)*8):0,cMaxSafe=cMaxRaw>0?Math.pow(2,cBucket/8):0,bp=blaProfile(profile),useBla=Number.isFinite(spanNormal)&&Math.abs(spanNormal)>=1e-280&&refLen>8,wp=workProfile(profile),colorCtx=makeColorCtx(colorIter);
-  const regions=(rects?rects:[{x0:0,y0:0,w,h}]).map(r=>({x0:Math.max(0,r.x0|0),y0:Math.max(0,r.y0|0),w:Math.max(0,Math.min(w-(r.x0|0),r.w|0)),h:Math.max(0,Math.min(h-(r.y0|0),r.h|0))})).filter(r=>r.w>0&&r.h>0),chunks=[];let preferredRows=deepWisdom.stripRows||16;if(deepWisdom.rowMsEMA>0)preferredRows=Math.round(deepWisdom.targetStripMs/deepWisdom.rowMsEMA);for(const r of regions){const rows=Math.max(2,Math.min(Math.max(1,Math.floor(65536/Math.max(1,r.w))),profile.covered?Math.max(4,preferredRows):Math.min(36,preferredRows)));for(let y=r.y0;y<r.y0+r.h;y+=rows)chunks.push({x0:r.x0,y0:y,w:r.w,rows:Math.min(rows,r.y0+r.h-y)})}chunks.sort((a,b)=>{const ad=Math.hypot((a.x0+a.w*.5)/w-state.focusX,(a.y0+a.rows*.5)/h-state.focusY),bd=Math.hypot((b.x0+b.w*.5)/w-state.focusX,(b.y0+b.rows*.5)/h-state.focusY);return ad-bd});
-  const totalPixels=regions.reduce((a,r)=>a+r.w*r.h,0),verifyJobs=profile.covered?8:3;
-  const runner={token,cancelled:false,chunkIndex:0,donePixels:0,totalPixels,failed:false,finishing:false,simd:true,blaUsed:false,kernelMs:0,verifyMs:0,blaBuildMs:0,sumIter:0,blackCount:0,badCount:0,blaSteps:0,ptbSteps:0,rebases:0,interior:0,unresolved:0,repaired:0,verifiedBuckets:new Set(),
-    fail(err){if(this.failed||this.cancelled)return;this.failed=true;deepPool.failed=true;destroyDeepPool();if(token===state.token)onFallback()},
-    nextChunk(){return this.chunkIndex<chunks.length?chunks[this.chunkIndex++]:null},
-    dispatch(worker){
-      if(this.cancelled||this.failed||token!==state.token)return false;const ch=this.nextChunk();if(!ch){this.maybeFinish();return false}
-      const jobId=token+':'+(++deepPool.serial),vb=Math.min(verifyJobs-1,Math.max(0,Math.floor((ch.y0+ch.rows*.5)*verifyJobs/Math.max(1,h)))),verifySamples=useBla&&!this.verifiedBuckets.has(vb)?(this.verifiedBuckets.add(vb),profile.covered?4:3):0,blaKey=refKey+':'+ref.version+':'+refLen+':'+cBucket+':e'+bp.exp,safeBlaKey=refKey+':'+ref.version+':'+refLen+':'+cBucket+':e'+bp.safeExp;
-      const msg={type:'render',jobId,refKey,refLen,w,h,x0:ch.x0,rectW:ch.w,y0:ch.y0,rows:ch.rows,iter,colorIter,covered:profile.covered,spanMant:sb.mant,spanBucket:sb.bucket,offR:off[0],offI:off[1],offBucket:off[2],cx:w*.5,cy:h*.5,skip:series.skip,Ar:series.Ar,Ai:series.Ai,Ab:series.Ab,Br:series.Br,Bi:series.Bi,Bb:series.Bb,shift:state.shift,cycle:state.cycle,palette:state.palette,useBla,blaEps:bp.eps,blaKey,safeBlaEps:Math.pow(2,-bp.safeExp),safeBlaKey,cMax:cMaxSafe,spanNormal,offRn,offIn,baseCr,baseCi,maxBlaSteps:wp.bla,maxPtbSteps:wp.ptb,verifySamples,verifyDelta:profile.covered?8:64},transfer=[];
-      attachReference(worker,msg,ref,refLen,refKey,transfer);if(worker._recycle){msg.fieldBuffer=worker._recycle.field;msg.iterationBuffer=worker._recycle.iterations;msg.classBuffer=worker._recycle.classes;transfer.push(msg.fieldBuffer,msg.iterationBuffer,msg.classBuffer);worker._recycle=null}worker._busy=true;worker._job={type:'render',runner:this,jobId,x0:ch.x0,y0:ch.y0,rectW:ch.w,rows:ch.rows,pixels:ch.w*ch.rows,started:performance.now()};try{worker.postMessage(msg,transfer)}catch(e){worker._busy=false;worker._job=null;this.fail(e);return false}return true
-    },
-    onResult(worker,d,job){
-      const elapsed=Math.max(.05,performance.now()-job.started),mpr=elapsed/Math.max(1,job.rows);deepWisdom.rowMsEMA=deepWisdom.rowMsEMA?deepWisdom.rowMsEMA*.86+mpr*.14:mpr;deepWisdom.stripRows=Math.round((deepWisdom.stripRows||12)*.75+Math.max(3,Math.min(128,Math.round(deepWisdom.targetStripMs/Math.max(.001,deepWisdom.rowMsEMA))))*.25);
-      if(this.cancelled||this.failed||token!==state.token)return;if(!d||d.jobId!==job.jobId)return;if(d.error){this.fail(new Error(d.error));return}
-      this.simd=this.simd&&!!d.simd;this.blaUsed=this.blaUsed||!!d.bla;this.kernelMs+=d.kernelMs||0;this.verifyMs+=d.verifyMs||0;this.blaBuildMs+=d.blaBuildMs||0;this.sumIter+=d.sumIter||0;this.blackCount+=d.blackCount||0;this.badCount+=(d.bad||[]).length;const st=d.stats||{};this.blaSteps+=st.blaSteps||0;this.ptbSteps+=st.ptbSteps||0;this.rebases+=st.rebases||0;this.interior+=st.interior||0;this.unresolved+=st.unresolved||0;this.repaired+=d.repaired||0;
-      const rw=d.rectW||job.rectW,rx=d.x0==null?job.x0:d.x0,sf=d.field?new Float32Array(d.field):null,it=d.iterations?new Uint32Array(d.iterations):null,cl=d.classes?new Uint8Array(d.classes):null,ro=sf&&cl?colorizeField({smooth:sf,classes:cl,iter:colorIter}):new Uint8ClampedArray(d.out);for(let yy=0;yy<d.rows;yy++){const dst=(d.y0+yy)*w+rx;out.set(ro.subarray(yy*rw*4,(yy+1)*rw*4),dst*4);if(sf)field.smooth.set(sf.subarray(yy*rw,(yy+1)*rw),dst);if(it)field.iterations.set(it.subarray(yy*rw,(yy+1)*rw),dst);if(cl)field.classes.set(cl.subarray(yy*rw,(yy+1)*rw),dst)}presentPartialStripe(ro,rx,d.y0,rw,d.rows,w,h,snap);if(d.field&&d.iterations&&d.classes)worker._recycle={field:d.field,iterations:d.iterations,classes:d.classes};if(d.bad)for(const local of d.bad){const gx=rx+(local%rw),gy=d.y0+((local/rw)|0);bad.push(gy*w+gx)}this.donePixels+=job.pixels;if(profile.covered&&workers.length<deepPool.maxWorkers&&memoryLedger().managedBytes+24*1048576<rendererMemoryBudget()&&this.totalPixels-this.donePixels>job.pixels*4&&elapsed>deepWisdom.targetStripMs){const added=addDeepWorker();deepWisdom.workerCount=workers.length;deepWisdom.ready=true;kickDeepWorker(added)}this.maybeFinish()
-    },
-    maybeFinish(){
-      if(this.cancelled||this.failed||token!==state.token||this.finishing||this.donePixels<this.totalPixels)return;this.finishing=true;if(deepPool.current===this)deepPool.current=null;deepPool.activeToken=0;const px=Math.max(1,this.totalPixels),kmpp=this.kernelMs/px;deepTelemetry.frames++;deepTelemetry.kernelMPP=deepTelemetry.kernelMPP?deepTelemetry.kernelMPP*.78+kmpp*.22:kmpp;deepTelemetry.meanIter=this.sumIter/px;deepTelemetry.blackRatio=this.blackCount/px;deepTelemetry.badRatio=this.badCount/px;deepTelemetry.blaBuildEMA=deepTelemetry.blaBuildEMA?deepTelemetry.blaBuildEMA*.85+this.blaBuildMs*.15:this.blaBuildMs;deepTelemetry.interiorRatio=this.interior/px;deepTelemetry.repairRatio=this.repaired/Math.max(1,regions.length);deepTelemetry.unresolvedRatio=this.unresolved/px;deepTelemetry.blaStepsPerPixel=this.blaSteps/px;deepTelemetry.ptbStepsPerPixel=this.ptbSteps/px;deepTelemetry.rebasePerPixel=this.rebases/px;deepTelemetry.lastKernelMs=this.kernelMs;deepTelemetry.lastVerifyMs=this.verifyMs;deepTelemetry.lastPixels=px;deepTelemetry.refDistance=refC.dist||0;refControl.lastMPP=kmpp;refControl.lastPixels=px;if(refControl.refId!==ref.id){refControl.refId=ref.id;refControl.baseMPP=kmpp}else if((refC.dist||0)<.2)refControl.baseMPP=refControl.baseMPP?refControl.baseMPP*.8+kmpp*.2:kmpp;persistDeepWisdom();
-      const label='WASM '+(this.simd?'SIMD':'scalar')+' ×'+Math.max(1,Math.min(deepWisdom.workerCount,workers.length))+' · '+(this.blaUsed?'BLA e-'+bp.exp+' + ':'')+'rebase'+(this.interior?' · 内部早期終了 '+Math.round(100*this.interior/px)+'%':'')+(this.repaired?' · 局所補修 '+this.repaired:'')+(this.totalPixels<w*h?' · 既存画像再利用 '+Math.round(100*(1-this.totalPixels/(w*h)))+'%':'');
-      const completeField=this.totalPixels===w*h?field:null;if(!bad.length){finishRender(token,t0,profile,snap,w,h,out,label,this.totalPixels,completeField);return}let k=0;const residual=async()=>{if(token!==state.token||this.cancelled)return;const deadline=performance.now()+5;while(k<bad.length&&performance.now()<deadline){const idx=bad[k++],x=idx%w,py=(idx/w)|0,result=await highPrecisionDirectPixelAsync(snap,w,h,iter,x,py,false,()=>token!==state.token||this.cancelled);if(!result)return;const[n,m]=result;putField(field,idx,n,m,n<iter?FIELD_ESCAPED:FIELD_UNKNOWN);putDeepPixel(out,w,iter,colorIter,x,py,n,m,colorCtx)}if(k<bad.length)requestAnimationFrame(residual);else finishRender(token,t0,profile,snap,w,h,out,label+' · 残差 '+bad.length,this.totalPixels,completeField)};requestAnimationFrame(residual)
-    }
-  };
-  deepPool.current=runner;deepPool.activeToken=token;if(totalPixels===0){queueMicrotask(()=>runner.maybeFinish());return true}const active=Math.max(1,Math.min(deepWisdom.ready?deepWisdom.workerCount:Math.min(2,workers.length),workers.length));for(let i=0;i<active;i++)kickDeepWorker(workers[i]);return true
-}
-
-// ── Frame reprojection / world-space detail cache ───────────────────────
-const frameCanvas=document.createElement('canvas'),frameCtx=frameCanvas.getContext('2d',{alpha:false});
+function fmtFixedExact(v){let neg=v<0n;if(neg)v=-v;const maxD=state.bits,scale=10n**BigInt(maxD),q=v*scale>>BigInt(state.bits);let s=q.toString().padStart(maxD+1,'0');s=s.slice(0,-maxD)+'.'+s.slice(-maxD);s=s.replace(/(\.\d*?)0+$/,'$1').replace(/\.$/,'');return(neg?'-':'')+s}
 function snapshot(){return{bits:state.bits,re:state.re,im:state.im,span:state.span}}
-function snapshotToCurrent(s){if(s.bits===state.bits)return s;return{bits:state.bits,re:align(s.re,s.bits,state.bits),im:align(s.im,s.bits,state.bits),span:align(s.span,s.bits,state.bits)}}
-function styleSignature(){return state.palette+':'+state.cycle.toFixed(6)+':'+state.shift.toFixed(5)}
-function commitImage(data,w,h,snap,field=null){
-  frameCanvas.width=w;frameCanvas.height=h;const id=frameCtx.createImageData(w,h);id.data.set(data);frameCtx.putImageData(id,0,0);runtimeMetrics.canvasWrites++;
-  state.frameView=snapshotToCurrent(snap);state.fieldView=field?{field,w,h,snap:state.frameView}:null;invalidateView();
-}
-function presentPartialStripe(data,x,y,w,h,frameW,frameH,snap){if(frameCanvas.width!==frameW||frameCanvas.height!==frameH||!sameSnapshot(state.frameView,snap)){frameCanvas.width=frameW;frameCanvas.height=frameH;frameCtx.fillStyle='#050813';frameCtx.fillRect(0,0,frameW,frameH);state.frameView=snapshotToCurrent(snap);state.fieldView=null}const id=frameCtx.createImageData(w,h);id.data.set(data);frameCtx.putImageData(id,x,y);runtimeMetrics.canvasWrites++;invalidateView(false)}
-function sameSnapshot(a,b){return!!a&&!!b&&a.bits===b.bits&&a.re===b.re&&a.im===b.im&&a.span===b.span}
-function recolorCurrentField(){const fv=state.fieldView;if(!fv||state.dirty||state.rendering||!sameSnapshot(fv.snap,state.frameView))return false;const out=colorizeField(fv.field);commitImage(out,fv.w,fv.h,fv.snap,fv.field);state.lastEngine='フィールド再彩色';state.lastRender=0;recolorCachedDetails();invalidateView();return true}
-const validationJob={active:false,key:''};
-const unknownContinuationJob={active:false,key:''};let unknownContinuationTimer=0;
-function cancelUnknownContinuation(){if(unknownContinuationTimer){clearTimeout(unknownContinuationTimer);unknownContinuationTimer=0}unknownContinuationJob.active=false;state.continuationProgress=0}
-function scheduleUnknownContinuation(delay=120){
-  const fv=state.fieldView;if(state.processMode!=='fine'||state.dirty||state.rendering||!fv||!state.unresolved)return;
-  const key=viewSpecKey(currentViewSpec())+':'+fv.w+'x'+fv.h+':'+fv.field.iter;
-  if(unknownContinuationJob.key===key||unknownContinuationTimer)return;
-  unknownContinuationTimer=setTimeout(()=>{unknownContinuationTimer=0;startUnknownContinuation(key)},delay)
-}
-function startUnknownContinuation(key){
-  const fv=state.fieldView;if(unknownContinuationJob.active||state.dirty||state.rendering||!fv||!sameSnapshot(fv.snap,state.frameView))return;
-  const field=fv.field,ranked=[];for(let i=0;i<field.classes.length;i++){if(field.classes[i]!==FIELD_UNKNOWN)continue;const x=i%fv.w,y=(i/fv.w)|0;let boundary=false;for(let yy=Math.max(0,y-1);yy<=Math.min(fv.h-1,y+1)&&!boundary;yy++)for(let xx=Math.max(0,x-1);xx<=Math.min(fv.w-1,x+1);xx++)if(field.classes[yy*fv.w+xx]===FIELD_ESCAPED){boundary=true;break}if(boundary)ranked.push({i,d:Math.hypot(x/fv.w-state.focusX,y/fv.h-state.focusY)})}if(!ranked.length)return;
-  const deep=deepEngineNeeded(fv.snap,fv.w),cap=Math.min(ranked.length,deep?384:4096);ranked.sort((a,b)=>a.d-b.d);const indices=ranked.slice(0,cap).map(v=>v.i);
-  unknownContinuationJob.active=true;unknownContinuationJob.key=key;const token=state.token,snap=fv.snap,baseIter=field.iter,extendedIter=Math.min(280000,Math.max(baseIter+256,baseIter*2)),cre=fixedNum(snap.re,snap.bits),cim=fixedNum(snap.im,snap.bits),scale=fixedNum(snap.span,snap.bits)/fv.w;let p=0;
-  state.drawState='RESOLVING';state.continuationProgress=0;invalidateStats();
-  async function slice(){
-    if(token!==state.token||state.dirty){unknownContinuationJob.active=false;return}
-    const deadline=performance.now()+7;while(p<indices.length&&performance.now()<deadline){const i=indices[p++],x=i%fv.w,y=(i/fv.w)|0,result=deep?await highPrecisionDirectPixelAsync(snap,fv.w,fv.h,extendedIter,x,y,false,()=>token!==state.token||state.dirty):exportSampleShallow(cre,cim,scale,fv.w,fv.h,extendedIter,x,y);if(!result){unknownContinuationJob.active=false;return}const[n,m]=result;putField(field,i,n,m,n<extendedIter?FIELD_ESCAPED:FIELD_UNKNOWN)}
-    state.continuationProgress=p/indices.length;if(p<indices.length){invalidateStats();requestAnimationFrame(slice);return}
-    state.unresolved=field.classes.reduce((n,c)=>n+(c===FIELD_UNKNOWN),0);unknownContinuationJob.active=false;state.continuationProgress=1;state.drawState='COVERED';commitImage(colorizeField(field),fv.w,fv.h,snap,field);state.lastEngine+=' · 境界 '+indices.length+'点を追加反復';invalidateStats()
-  }
-  requestAnimationFrame(slice)
-}
-function scheduleValidation(delay=350){if(state.processMode!=='validate'||state.dirty||state.rendering)return;scheduleBackground(()=>{if(state.processMode==='validate'&&!state.detailActive&&!unknownContinuationJob.active)startValidation();else if(state.processMode==='validate')scheduleValidation(300)},delay)}
-function startValidation(){
-  const fv=state.fieldView;if(validationJob.active||!fv||state.dirty||state.rendering||!sameSnapshot(fv.snap,state.frameView))return;
-  const key=viewSpecKey(currentViewSpec())+':'+fv.w+'x'+fv.h+':'+fv.field.iter;if(validationJob.key===key)return;
-  validationJob.active=true;validationJob.key=key;
-  const token=state.token,snap=fv.snap,field=fv.field,baseIter=field.iter,extendedIter=Math.min(280000,Math.max(baseIter+256,baseIter*2));let i=0,lastStatus=0;
-  state.drawState='VALIDATING';state.coverage=0;invalidateStats();
-  async function slice(now){
-    if(token!==state.token||state.processMode!=='validate'){validationJob.active=false;return}
-    const deadline=performance.now()+9;
-    while(i<field.classes.length&&performance.now()<deadline){
-      const old=field.classes[i],x=i%fv.w,y=(i/fv.w)|0,limit=old===FIELD_ESCAPED?baseIter:extendedIter;
-      if(fixedAnalyticPixelProven(snap,fv.w,fv.h,x,y)){putField(field,i,limit,0,FIELD_INTERIOR_PROVEN);i++;continue}
-      const result=await highPrecisionDirectPixelAsync(snap,fv.w,fv.h,limit,x,y,true,()=>token!==state.token||state.processMode!=='validate');
-      if(!result){validationJob.active=false;return}
-      const[n,m]=result;if(n<limit)putField(field,i,n,m,FIELD_ESCAPED);else putField(field,i,n,0,FIELD_UNKNOWN);i++
-    }
-    if(now-lastStatus>180){lastStatus=now;state.coverage=i/field.classes.length;invalidateStats()}
-    if(i<field.classes.length){requestAnimationFrame(slice);return}
-    field.iter=extendedIter;state.unresolved=field.classes.reduce((n,c)=>n+(c!==FIELD_ESCAPED&&c!==FIELD_INTERIOR_PROVEN),0);state.drawState=state.unresolved?'VALIDATION_INCOMPLETE':'VALIDATED';state.coverage=1;validationJob.active=false;const out=colorizeField(field);commitImage(out,fv.w,fv.h,snap,field);state.lastEngine='高精度direct照合';invalidateStats()
-  }
-  requestAnimationFrame(slice)
-}
-function drawWorldDetail(entry){
-  if(!entry||!entry.complete||entry.style!==styleSignature()||!entry.canvas)return;if(entry.iter){const rr=entry.iter/Math.max(1,maxIter());if(rr<.82||rr>1.22)return}
-  const re=align(entry.re,entry.bits,state.bits),im=align(entry.im,entry.bits,state.bits),sxv=align(entry.spanX,entry.bits,state.bits),syv=align(entry.spanY,entry.bits,state.bits);
-  const x=canvas.width*.5+fixedRatio(re-state.re,state.span)*canvas.width,y=canvas.height*.5-fixedRatio(im-state.im,state.span)*canvas.width;
-  const dw=Math.abs(fixedRatio(sxv,state.span)*canvas.width),dh=Math.abs(fixedRatio(syv,state.span)*canvas.width);
-  if(!Number.isFinite(x+y+dw+dh)||dw<5||dh<5||x+dw*.5<0||x-dw*.5>canvas.width||y+dh*.5<0||y-dh*.5>canvas.height)return;
-  // Do not magnify a cached tile beyond ~1.7 display pixels per source pixel.
-  if(dw/Math.max(1,entry.canvas.width)>1.7)return;
-  entry.lastUsed=performance.now();
-  ctx.imageSmoothingEnabled=true;try{ctx.imageSmoothingQuality='high'}catch{}
-  ctx.drawImage(entry.canvas,x-dw*.5,y-dh*.5,dw,dh);
-}
-function paintFrame(){
-  if(!state.frameView||!frameCanvas.width)return;
-  runtimeMetrics.canvasWrites++;
-  const fv=state.frameView;
-  const a=fixedRatio(fv.span,state.span);if(!Number.isFinite(a)||a<=0)return;
-  const dx=fixedRatio(fv.re-state.re,state.span)*canvas.width;
-  const dy=-fixedRatio(fv.im-state.im,state.span)*canvas.width;
-  ctx.save();ctx.setTransform(1,0,0,1,0,0);ctx.fillStyle='#050813';ctx.fillRect(0,0,canvas.width,canvas.height);
-  ctx.translate(canvas.width*.5+dx,canvas.height*.5+dy);ctx.scale(a,a);ctx.imageSmoothingEnabled=true;try{ctx.imageSmoothingQuality=state.lastPass===RENDER_PASS.COVERED?'high':'medium'}catch{}
-  const fw=canvas.width,fh=fw*(frameCanvas.height/Math.max(1,frameCanvas.width));ctx.drawImage(frameCanvas,-fw*.5,-fh*.5,fw,fh);ctx.restore();
-  // Only completed, world-validated tiles are composited. Partial tiles remain offscreen.
-  ctx.save();ctx.setTransform(1,0,0,1,0,0);for(const e of DETAIL_TILE_CACHE.values())drawWorldDetail(e);ctx.restore();
-}
-
-function renderBudget(profile,deep){return profile.budgetMs}
-function targetSize(profile,deep){
-  // Resolution is intentionally independent of zoom depth. 10^20, 10^100 and
-  // beyond use the same quality targets as low zoom; only the numerical engine changes.
-  const cssW=Math.max(1,canvas.clientWidth),cssH=Math.max(1,canvas.clientHeight),aspect=cssH/cssW,dpr=Math.max(.25,state.effectiveDpr||1);
-  if(profile.covered)return[canvas.width,canvas.height];
-  let nominal=Math.max(profile.minWidth,cssW*dpr*profile.nominalScale),minW=profile.minWidth,maxW=profile.maxWidth;
-  const measured=renderPerf[deep?'deepMPP':'shallowMPP'];
-  if(deep&&!profile.covered&&measured<=0){nominal=Math.min(nominal,48);minW=32}
-  if(measured>0){
-    const timedW=Math.sqrt(renderBudget(profile,deep)/Math.max(1e-7,measured*aspect));
-    nominal=Math.min(nominal,timedW);minW=deep?32:240
-  }
-  let w=Math.max(minW,Math.min(maxW,Math.round(nominal))),h=Math.max(deep&&!profile.covered?32:96,Math.round(w*aspect));
-  if(h>2200){const sc=2200/h;h=2200;w=Math.round(w*sc)}return[w,h]
-}
-function analyzeDetailTiles(data,w,h,baseMs,deep){
-  const field=state.fieldView&&state.fieldView.w===w&&state.fieldView.h===h?state.fieldView.field:null;if(!field)return[];
-  const leaves=[],minTile=32,rootTile=256;
-  function scoreRect(x0,y0,tw,th){
-    const step=Math.max(1,Math.floor(Math.min(tw,th)/14));let grad=0,edges=0,uncertain=0,samples=0;
-    for(let y=y0;y<y0+th;y+=step)for(let x=x0;x<x0+tw;x+=step){const i=y*w+x,c=field.classes[i],s=field.smooth[i];samples++;uncertain+=(255-(field.confidence?field.confidence[i]:fieldConfidence(c)))/255;if(x+step<x0+tw){const j=i+step,c2=field.classes[j];if((c===FIELD_ESCAPED)!==(c2===FIELD_ESCAPED))edges++;else if(c===FIELD_ESCAPED&&c2===FIELD_ESCAPED)grad+=Math.min(12,Math.abs(s-field.smooth[j]))}if(y+step<y0+th){const j=i+step*w,c2=field.classes[j];if((c===FIELD_ESCAPED)!==(c2===FIELD_ESCAPED))edges++;else if(c===FIELD_ESCAPED&&c2===FIELD_ESCAPED)grad+=Math.min(12,Math.abs(s-field.smooth[j]))}}
-    return edges/Math.max(1,samples)*4.4+grad/Math.max(1,samples*12)*1.5+uncertain/Math.max(1,samples)*.9
-  }
-  function visit(x,y,tw,th){const score=scoreRect(x,y,tw,th);if(score<.055)return;if((tw>minTile||th>minTile)&&score>.11){const aw=Math.max(1,tw>>1),bw=tw-aw,ah=Math.max(1,th>>1),bh=th-ah;visit(x,y,aw,ah);if(bw)visit(x+aw,y,bw,ah);if(bh)visit(x,y+ah,aw,bh);if(bw&&bh)visit(x+aw,y+ah,bw,bh);return}leaves.push({x,y,w:tw,h:th,score,area:tw*th})}
-  for(let y=0;y<h;y+=rootTile)for(let x=0;x<w;x+=rootTile)visit(x,y,Math.min(rootTile,w-x),Math.min(rootTile,h-y));
-  leaves.sort((a,b)=>{const ad=Math.hypot((a.x+a.w*.5)/w-state.focusX,(a.y+a.h*.5)/h-state.focusY),bd=Math.hypot((b.x+b.w*.5)/w-state.focusX,(b.y+b.h*.5)/h-state.focusY);return(b.score+.08/(.08+bd))-(a.score+.08/(.08+ad))});const byteCap=Math.max(0,detailCacheBudget()-detailCacheBytes),baseBudget=renderBudget(RENDER_PROFILE[RENDER_PASS.COVERED],deep),spare=Math.max(0,baseBudget*1.7-baseMs),sampleCap=Math.floor(w*h*Math.min(2.6,spare/Math.max(1,baseMs)));let bytes=0,sampleArea=0,n=0;while(n<leaves.length){const tile=leaves[n],sampleScale=tile.score>=1.15?4:2,costBytes=tile.area*(sampleScale*sampleScale*10+4),costSamples=tile.area*sampleScale*sampleScale;if(bytes+costBytes>byteCap||sampleArea+costSamples>sampleCap)break;bytes+=costBytes;sampleArea+=costSamples;n++}return leaves.slice(0,n)
-}
-function detailGeometry(tile,plan){
-  const s=plan.snap,den=BigInt(2*plan.w),re=s.re+s.span*BigInt(2*tile.x+tile.w-plan.w)/den,im=s.im+s.span*BigInt(plan.h-2*tile.y-tile.h)/den;
-  const spanX=s.span*BigInt(tile.w)/BigInt(plan.w),spanY=s.span*BigInt(tile.h)/BigInt(plan.w);
-  return{bits:s.bits,re,im,spanX,spanY}
-}
-function detailKey(tile,plan,sampleScale){const g=detailGeometry(tile,plan);return [g.bits,g.re,g.im,g.spanX,g.spanY,plan.iter,'aa'+sampleScale,'centered-v23'].join(':')}
-function rendererMemoryBudget(){return(Number(navigator.deviceMemory||8)<=4||matchMedia('(max-width:700px)').matches?96:192)*1048576}
-function wasmBytes(core){try{return core&&core.ex&&core.ex.memory?core.ex.memory.buffer.byteLength:0}catch{return 0}}
-function memoryLedger(includeDetail=true){
-  const screenCanvasBytes=canvas.width*canvas.height*4,frameCanvasBytes=frameCanvas.width*frameCanvas.height*4;
-  const fieldBytes=state.fieldView?state.fieldView.w*state.fieldView.h*10:0;
-  const referenceBytes=(referenceCache.rr?.byteLength||0)+(referenceCache.ri?.byteLength||0);
-  const mainWasmBytes=wasmBytes(wasm)+wasmBytes(deepWasm);
-  // Worker memories are isolated, so browsers do not expose their byteLength.
-  // Account them conservatively: reference copies + kernel scratch/linear memory.
-  const workerEstimateBytes=(shallowWorker?2*1048576:0)+deepPool.workers.length*24*1048576;
-  const renderBytes=state.rendering?(()=>{const size=targetSize(renderProfile(state.lastPass),deepMode),pixels=size[0]*size[1];return pixels*18})():0;
-  const exportBytes=exportJob&&exportJob.active?exportJob.bytes||0:0,activeDetailBytes=activeDetailTiles.reduce((sum,e)=>sum+(e.transientBytes||0),0);
-  const cacheBytes=includeDetail?detailCacheBytes:0;
-  const managedBytes=fieldBytes+referenceBytes+mainWasmBytes+workerEstimateBytes+renderBytes+exportBytes+activeDetailBytes+cacheBytes;
-  const canvasBytes=screenCanvasBytes+frameCanvasBytes;
-  return{managedBytes,logicalBytes:managedBytes+canvasBytes,canvasBytes,screenCanvasBytes,frameCanvasBytes,fieldBytes,referenceBytes,mainWasmBytes,workerEstimateBytes,renderBytes,exportBytes,activeDetailBytes,detailCacheBytes:cacheBytes,budget:rendererMemoryBudget()}
-}
-function detailCacheBudget(){const base=memoryLedger(false).managedBytes,reserve=16*1048576;return Math.max(0,Math.floor(Math.min(rendererMemoryBudget()*.18,rendererMemoryBudget()-base-reserve)))}
-function detailEntryBytes(entry){return entry&&entry.canvas?entry.canvas.width*entry.canvas.height*4+(entry.field?entry.field.classes.length*10:0):0}
-function detailDistance(entry){try{const re=align(entry.re,entry.bits,state.bits),im=align(entry.im,entry.bits,state.bits);return Math.hypot(fixedRatio(re-state.re,state.span),fixedRatio(im-state.im,state.span))}catch{return Infinity}}
-function trimDetailCache(){const budget=detailCacheBudget();while(detailCacheBytes>budget&&DETAIL_TILE_CACHE.size){let victim=null,rank=-Infinity;const now=performance.now();for(const [key,entry]of DETAIL_TILE_CACHE){const age=Math.max(0,now-(entry.lastUsed||0))/60000,distance=detailDistance(entry),score=(Number.isFinite(distance)?distance:1000)*4+age;if(score>rank){rank=score;victim=[key,entry]}}if(!victim)break;DETAIL_TILE_CACHE.delete(victim[0]);detailCacheBytes=Math.max(0,detailCacheBytes-detailEntryBytes(victim[1]))}}
-function linearChannel(v){v/=255;return v<=.04045?v/12.92:Math.pow((v+.055)/1.055,2.4)}
-function srgbChannel(v){v=Math.max(0,Math.min(1,v));return Math.round(255*(v<=.0031308?12.92*v:1.055*Math.pow(v,1/2.4)-.055))}
-function resolveSubsampleField(field,w,h,scale=2){const hi=colorizeField(field),c=document.createElement('canvas');c.width=w;c.height=h;const cc=c.getContext('2d',{alpha:false}),id=cc.createImageData(w,h),out=id.data,samples=scale*scale;for(let y=0;y<h;y++)for(let x=0;x<w;x++){let r=0,g=0,b=0;for(let sy=0;sy<scale;sy++)for(let sx=0;sx<scale;sx++){const i=(((y*scale+sy)*w*scale)+(x*scale+sx))*4;r+=linearChannel(hi[i]);g+=linearChannel(hi[i+1]);b+=linearChannel(hi[i+2])}const oi=(y*w+x)*4;out[oi]=srgbChannel(r/samples);out[oi+1]=srgbChannel(g/samples);out[oi+2]=srgbChannel(b/samples);out[oi+3]=255}cc.putImageData(id,0,0);return c}
-function recolorDetailEntry(entry){if(!entry||!entry.field)return;entry.canvas=resolveSubsampleField(entry.field,entry.baseW,entry.baseH,entry.sampleScale||2);entry.style=styleSignature()}
-function recolorCachedDetails(){cancelDetailRefinement(true);for(const entry of DETAIL_TILE_CACHE.values())recolorDetailEntry(entry)}
-function makeDetailTask(tile,plan){
-  const sampleScale=tile.score>=1.15?4:2,key=detailKey(tile,plan,sampleScale),cached=DETAIL_TILE_CACHE.get(key);if(cached){DETAIL_TILE_CACHE.delete(key);DETAIL_TILE_CACHE.set(key,cached);cached.lastUsed=performance.now();if(cached.style!==styleSignature())recolorDetailEntry(cached);return{cached:true,entry:cached}}
-  const c=document.createElement('canvas');c.width=Math.max(2,tile.w*sampleScale);c.height=Math.max(2,tile.h*sampleScale);const dc=c.getContext('2d',{alpha:false});
-  dc.imageSmoothingEnabled=true;try{dc.imageSmoothingQuality='high'}catch{};dc.drawImage(frameCanvas,tile.x,tile.y,tile.w,tile.h,0,0,c.width,c.height);
-  const g=detailGeometry(tile,plan),entry={...g,canvas:c,field:null,baseW:tile.w,baseH:tile.h,sampleScale,style:styleSignature(),key,score:tile.score,iter:plan.iter,complete:false,lastUsed:performance.now(),transientBytes:c.width*c.height*18};
-  const task={tile,canvas:c,ctx:dc,field:makeField(c.width*c.height,plan.iter),entry,phases:0,plan};activeDetailTiles.push(entry);return task
-}
-function validateDetailTask(task){
-  const plan=task&&task.plan,t=task&&task.tile,base=plan&&plan.baseData;if(!plan||!t||!base)return false;
-  let samples=0,blackMismatch=0,rgbDiff=0,colorSamples=0;const sampleScale=task.entry.sampleScale||2,step=Math.max(3,Math.floor(Math.min(t.w,t.h)/7)),pix=task.ctx.getImageData(0,0,task.canvas.width,task.canvas.height).data;
-  for(let by=t.y+1;by<t.y+t.h-1;by+=step)for(let bx=t.x+1;bx<t.x+t.w-1;bx+=step){
-    const bi=(by*plan.w+bx)*4,lx=Math.min(task.canvas.width-1,Math.max(0,sampleScale*(bx-t.x)+(sampleScale>>1))),ly=Math.min(task.canvas.height-1,Math.max(0,sampleScale*(by-t.y)+(sampleScale>>1))),hi=(ly*task.canvas.width+lx)*4;
-    const bb=(base[bi]|base[bi+1]|base[bi+2])===0,hb=(pix[hi]|pix[hi+1]|pix[hi+2])===0;samples++;if(bb!==hb)blackMismatch++;else if(!bb){rgbDiff+=Math.abs(base[bi]-pix[hi])+Math.abs(base[bi+1]-pix[hi+1])+Math.abs(base[bi+2]-pix[hi+2]);colorSamples++}
-  }
-  if(samples<4)return false;const classRate=blackMismatch/samples,meanDiff=colorSamples?rgbDiff/(3*colorSamples):0;return classRate<=.035&&meanDiff<=48
-}
-function cacheDetailTask(task){
-  if(!task||task.cached)return;const i=activeDetailTiles.indexOf(task.entry);if(i>=0)activeDetailTiles.splice(i,1);
-  if(!validateDetailTask(task))return;fillFieldConfidence(task.field);task.entry.field=task.field;task.entry.canvas=resolveSubsampleField(task.field,task.tile.w,task.tile.h,task.entry.sampleScale);task.entry.style=styleSignature();task.entry.complete=true;task.entry.lastUsed=performance.now();task.entry.transientBytes=0;const old=DETAIL_TILE_CACHE.get(task.entry.key);if(old)detailCacheBytes-=detailEntryBytes(old);DETAIL_TILE_CACHE.delete(task.entry.key);DETAIL_TILE_CACHE.set(task.entry.key,task.entry);detailCacheBytes+=detailEntryBytes(task.entry);
-  trimDetailCache()
-}
-function phaseRect(task,phase){
-  const t=task.tile,scale=task.entry.sampleScale,left=(phase%scale)*t.w,top=((phase/scale)|0)*t.h;
-  return{x0:t.x*scale+left,y0:t.y*scale+top,rw:t.w,rows:t.h,dx:left,dy:top}
-}
-function prepareDeepTileContext(plan,iter,sampleScale,done){
-  const cacheKey='i'+iter+':s'+sampleScale;if(plan.deepCtx&&plan.deepCtx[cacheKey]){done(plan.deepCtx[cacheKey]);return}if(!plan.deepCtx)plan.deepCtx={};
-  const snap=plan.snap,refC=chooseReference(snap),W=plan.w*sampleScale,H=plan.h*sampleScale,refX=W*.5-.5+fixedRatio(refC.re-snap.re,snap.span)*W,refY=H*.5-.5-fixedRatio(refC.im-snap.im,snap.span)*W;
-  const cornerR=Math.max(Math.hypot(refX,refY),Math.hypot(W-refX,refY),Math.hypot(refX,H-refY),Math.hypot(W-refX,H-refY))/Math.max(1,W),logMaxDc=log2FixedAt(snap.span,snap.bits)+Math.log2(Math.max(1e-300,cornerR));
-  buildReferenceAt(snap.bits,refC.re,refC.im,iter,state.token,(ref,refLen)=>{
-    if(plan.gen!==state.detailGeneration)return;const series=computeSeries(ref,refLen,logMaxDc),centered=pixelCenteredOffset(snap,refC,W),sb=spanMantBucket(snap.span,snap.bits),off=fixedComplexScaled(centered.r,centered.i,snap.bits),spanNormal=fixedNum(snap.span,snap.bits),offRn=fixedNum(centered.r,snap.bits),offIn=fixedNum(centered.i,snap.bits);
-    const cMaxRaw=Math.hypot(offRn,offIn)+Math.abs(spanNormal)*Math.hypot(.5,H/(2*Math.max(1,W))),cBucket=cMaxRaw>0&&Number.isFinite(cMaxRaw)?Math.ceil(Math.log2(cMaxRaw)*8):0,cMaxSafe=cMaxRaw>0?Math.pow(2,cBucket/8):0;
-    const ctx={snap,refC,ref,refLen,series,sb,off,spanNormal,offRn,offIn,cBucket,cMaxSafe,W,H,iter};plan.deepCtx[cacheKey]=ctx;done(ctx)
-  })
-}
-function renderGuardedDeepDetailRect(task,phase,iter,done){
-  const plan=task.plan,r=phaseRect(task,phase),W=plan.w*task.entry.sampleScale,H=plan.h*task.entry.sampleScale,snap=plan.snap;let yy=0;
-  async function slice(){if(plan.gen!==state.detailGeneration){done(false);return}const deadline=performance.now()+6;while(yy<r.rows&&performance.now()<deadline){const gy=r.y0+yy;for(let xx=0;xx<r.rw;xx++){const gx=r.x0+xx,result=await highPrecisionDirectPixelAsync(snap,W,H,iter,gx,gy,true,()=>plan.gen!==state.detailGeneration);if(!result){done(false);return}const[n,m]=result,fi=(r.dy+yy)*task.canvas.width+r.dx+xx;putField(task.field,fi,n,m,n<iter?FIELD_ESCAPED:FIELD_UNKNOWN)}yy++}if(yy<r.rows){requestAnimationFrame(slice);return}const stripe=makeField(r.rw*r.rows,iter);for(let y=0;y<r.rows;y++){const src=(r.dy+y)*task.canvas.width+r.dx,dst=y*r.rw;stripe.smooth.set(task.field.smooth.subarray(src,src+r.rw),dst);stripe.iterations.set(task.field.iterations.subarray(src,src+r.rw),dst);stripe.classes.set(task.field.classes.subarray(src,src+r.rw),dst)}const id=task.ctx.createImageData(r.rw,r.rows);id.data.set(colorizeField(stripe));task.ctx.putImageData(id,r.dx,r.dy);task.phases|=(1<<phase);invalidateView(false);done(true)}
-  requestAnimationFrame(slice)
-}
-function sendDeepDetailRect(task,phase,iter,colorIter,done){
-  const plan=task.plan,gen=plan.gen;if(gen!==state.detailGeneration){done(false);return}if(state.processMode==='validate'||task.tile.score>1.35){renderGuardedDeepDetailRect(task,phase,iter,done);return}if(!ensureDeepPool()){done(false);return}
-  prepareDeepTileContext(plan,iter,task.entry.sampleScale,dc=>{
-    if(gen!==state.detailGeneration){done(false);return}const worker=deepPool.workers.find(w=>!w._busy);if(!worker){scheduleBackground(()=>sendDeepDetailRect(task,phase,iter,colorIter,done),18);return}
-    const r=phaseRect(task,phase),ref=dc.ref,refKey=String(ref.id),bpExp=32,useBla=Number.isFinite(dc.spanNormal)&&Math.abs(dc.spanNormal)>=1e-280&&dc.refLen>8,blaEps=Math.pow(2,-bpExp),blaKey=refKey+':'+ref.version+':'+dc.refLen+':'+dc.cBucket+':e'+bpExp;
-    const jobId='detail:'+gen+':'+Date.now()+':'+Math.random(),msg={type:'render',jobId,refKey,refLen:dc.refLen,w:dc.W,h:dc.H,x0:r.x0,y0:r.y0,rectW:r.rw,rows:r.rows,iter,colorIter,spanMant:dc.sb.mant,spanBucket:dc.sb.bucket,offR:dc.off[0],offI:dc.off[1],offBucket:dc.off[2],cx:dc.W*.5,cy:dc.H*.5,skip:dc.series.skip,Ar:dc.series.Ar,Ai:dc.series.Ai,Ab:dc.series.Ab,Br:dc.series.Br,Bi:dc.series.Bi,Bb:dc.series.Bb,shift:state.shift,cycle:state.cycle,palette:state.palette,useBla,blaEps,blaKey,cMax:dc.cMaxSafe,spanNormal:dc.spanNormal,offRn:dc.offRn,offIn:dc.offIn,baseCr:fixedNum(dc.refC.re,dc.snap.bits),baseCi:fixedNum(dc.refC.im,dc.snap.bits),maxBlaSteps:0,maxPtbSteps:0,verifySamples:3,verifyDelta:6,safeBlaEps:Math.pow(2,-48),safeBlaKey:blaKey+':safe48'},transfer=[];
-    let start=worker._refKey===refKey?worker._refLoaded:0;start=Math.max(0,Math.min(start,dc.refLen+1));if(start<dc.refLen+1){const rr=ref.rr.slice(start,dc.refLen+1),ri=ref.ri.slice(start,dc.refLen+1);msg.rr=rr.buffer;msg.ri=ri.buffer;msg.rrStart=start;transfer.push(rr.buffer,ri.buffer);worker._refKey=refKey;worker._refLoaded=dc.refLen+1}
-    const runner={token:state.token,cancelled:false,fail(){done(false)},onResult(w,d){if(gen!==state.detailGeneration||!d||d.error){done(false);return}const sf=d.field?new Float32Array(d.field):null,it=d.iterations?new Uint32Array(d.iterations):null,cl=d.classes?new Uint8Array(d.classes):null,arr=sf&&cl?colorizeField({smooth:sf,classes:cl,iter:colorIter}):new Uint8ClampedArray(d.out),id=task.ctx.createImageData(r.rw,r.rows);id.data.set(arr);task.ctx.putImageData(id,r.dx,r.dy);if(sf&&it&&cl)for(let yy=0;yy<r.rows;yy++){const dst=(r.dy+yy)*task.canvas.width+r.dx;task.field.smooth.set(sf.subarray(yy*r.rw,(yy+1)*r.rw),dst);task.field.iterations.set(it.subarray(yy*r.rw,(yy+1)*r.rw),dst);task.field.classes.set(cl.subarray(yy*r.rw,(yy+1)*r.rw),dst)}if(d.field&&d.iterations&&d.classes)w._recycle={field:d.field,iterations:d.iterations,classes:d.classes};task.phases|=(1<<phase);task.entry.canvas=task.canvas;invalidateView(false);done(true)}};
-    if(worker._recycle){msg.fieldBuffer=worker._recycle.field;msg.iterationBuffer=worker._recycle.iterations;msg.classBuffer=worker._recycle.classes;transfer.push(msg.fieldBuffer,msg.iterationBuffer,msg.classBuffer);worker._recycle=null}worker._busy=true;worker._job={type:'render',runner,jobId,y0:r.y0,rows:r.rows,started:performance.now()};try{worker.postMessage(msg,transfer)}catch(e){worker._busy=false;worker._job=null;done(false)}
-  })
-}
-function renderShallowDetailRect(task,phase,done){
-  const plan=task.plan,r=phaseRect(task,phase),sampleScale=task.entry.sampleScale,W=plan.w*sampleScale,H=plan.h*sampleScale,iter=plan.iter,snap=plan.snap,sp=fixedNum(snap.span,snap.bits),cre=fixedNum(snap.re,snap.bits),cim=fixedNum(snap.im,snap.bits),scale=sp/W,colorCtx=makeColorCtx(iter),out=new Uint8ClampedArray(r.rw*r.rows*4);let yy=0;
-  function inBulbs(cr,ci){const y2=ci*ci,x=cr-.25,q=x*x+y2;if(q*(q+x)<=.25*y2)return true;const x2=cr+1;return x2*x2+y2<=.0625}
-  function slice(){if(plan.gen!==state.detailGeneration){done(false);return}const deadline=performance.now()+5;while(yy<r.rows&&performance.now()<deadline){const gy=r.y0+yy,ci=cim+(H*.5-gy-.5)*scale;let oi=yy*r.rw*4;for(let xx=0;xx<r.rw;xx++){const gx=r.x0+xx,cr=cre+(gx+.5-W*.5)*scale;let zr=0,zi=0,zr2=0,zi2=0,n=0,inside=inBulbs(cr,ci);if(inside)n=iter;else while(n<iter&&zr2+zi2<=4){zi=(zr+zr)*zi+ci;zr=zr2-zi2+cr;zr2=zr*zr;zi2=zi*zi;n++}const m=n<iter?Math.max(4.0000001,zr2+zi2):0,fi=(r.dy+yy)*task.canvas.width+r.dx+xx;putField(task.field,fi,n,m,n<iter?FIELD_ESCAPED:(inside?FIELD_INTERIOR_LIKELY:FIELD_UNKNOWN));if(n>=iter){out[oi]=out[oi+1]=out[oi+2]=0;out[oi+3]=255}else putFastColor(out,oi,n,m,iter,colorCtx);oi+=4}yy++}if(yy<r.rows)requestAnimationFrame(slice);else{const id=task.ctx.createImageData(r.rw,r.rows),data=id.data;data.set(out);task.ctx.putImageData(id,r.dx,r.dy);task.phases|=(1<<phase);invalidateView(false);done(true)}}requestAnimationFrame(slice)
-}
-function pumpDetailRefinement(){
-  const plan=detailPlan;if(!plan||plan.gen!==state.detailGeneration||!state.hq){state.detailActive=false;return}if(state.rendering||unknownContinuationJob.active||performance.now()-state.lastInteraction<720){scheduleBackground(pumpDetailRefinement,90);return}
-  while(plan.index<plan.tasks.length&&plan.tasks[plan.index].cached)plan.index++;
-  if(plan.index>=plan.tasks.length){state.detailActive=false;state.detailDone=plan.tasks.length;state.drawState='REFINED';updateStats();scheduleValidation();return}
-  const task=plan.tasks[plan.index],phase=task.nextPhase||0,cb=ok=>{if(!ok){const i=activeDetailTiles.indexOf(task.entry);if(i>=0)activeDetailTiles.splice(i,1);plan.index++;scheduleBackground(pumpDetailRefinement,10);return}task.nextPhase=phase+1;if(task.nextPhase>=task.entry.sampleScale*task.entry.sampleScale){cacheDetailTask(task);plan.index++}state.detailDone=plan.tasks.reduce((n,t)=>n+(t.cached||t.entry.complete?1:0),0);updateStats();scheduleBackground(pumpDetailRefinement,0)};
-  if(plan.deep)sendDeepDetailRect(task,phase,plan.iter,plan.iter,cb);else renderShallowDetailRect(task,phase,cb)
-}
-
-// ── Idle-only adaptive detail refinement ────────────────────────────────
-function scheduleDetailRefinement(data,w,h,snap,iter,baseMs,deep){
-  if(!state.hq)return;cancelDetailRefinement(true);const gen=state.detailGeneration,tiles=analyzeDetailTiles(data,w,h,baseMs,deep);if(!tiles.length){state.drawState='REFINED';invalidateStats();scheduleValidation();return}
-  const plan={gen,snap,w,h,iter,deep,tiles,tasks:[],index:0,deepCtx:null,baseData:data};for(const t of tiles)plan.tasks.push(makeDetailTask(t,plan));detailPlan=plan;state.detailActive=true;state.drawState='REFINING';state.detailQueued=plan.tasks.length;state.detailDone=plan.tasks.filter(t=>t.cached).length;scheduleBackground(pumpDetailRefinement,160)
-}
-
-function finishRender(token,t0,profile,snap,w,h,out,engine,computedPixels=w*h,field=null){
-  if(token!==state.token)return;const elapsed=Math.max(.1,performance.now()-t0),deep=deepEngineNeeded(snap,Math.max(1,canvas.width));
-  // Reproject-only frames must not poison performance estimates with near-zero work.
-  if(computedPixels>Math.max(512,w*h*.01)){const mpp=elapsed/computedPixels,key=deep?'deepMPP':'shallowMPP';renderPerf[key]=renderPerf[key]?renderPerf[key]*.72+mpp*.28:mpp}
-  if(field){fillFieldConfidence(field);out=colorizeField(field)}commitImage(out,w,h,snap,field);state.rendering=false;state.lastRender=elapsed;state.lastPass=profile.id;state.dirty=false;state.lastEngine=engine;state.lastFrameDone=performance.now();state.coverage=Math.min(1,w*h/Math.max(1,canvas.width*canvas.height));state.drawState=profile.covered&&state.coverage>=.999?'COVERED':'PREVIEW';state.unresolved=field?field.classes.reduce((n,c)=>n+(c===FIELD_UNKNOWN),0):0;flushPendingPrecision();
-  if(!profile.covered&&adaptStandardDeepBudget(deep)){updateStats();return}
-  if(profile.covered&&state.unresolved)scheduleUnknownContinuation();
-  if(profile.covered&&state.hq){const gen=state.detailGeneration;const schedule=()=>{if(gen!==state.detailGeneration||state.rendering)return;if(unknownContinuationJob.active||unknownContinuationTimer){scheduleBackground(schedule,90);return}const fv=state.fieldView,base=fv&&sameSnapshot(fv.snap,snap)?colorizeField(fv.field):out;scheduleDetailRefinement(base,w,h,snap,fv?fv.field.iter:iterationPlan(profile,deep).colorIter,elapsed,deep)};scheduleIdle(schedule,350);clearPanReuse()}
-  if(profile.covered&&state.processMode==='validate')scheduleValidation();
-  updateStats();
-}
-
-// ── Shallow renderers ───────────────────────────────────────────────────
-function renderShallowReuse(profile,snap,w,h,iter,token,t0,reuse){
-  const out=reuse.out,colorCtx=makeColorCtx(iter),sp=fixedNum(snap.span,snap.bits),cre=fixedNum(snap.re,snap.bits),cim=fixedNum(snap.im,snap.bits),scale=sp/w,rects=reuse.rects;let ri=0,yy=0;
-  function inBulbs(cr,ci){const y2=ci*ci,x=cr-.25,qq=x*x+y2;if(qq*(qq+x)<=.25*y2)return true;const x2=cr+1;return x2*x2+y2<=.0625}
-  function slice(){if(token!==state.token)return;const deadline=performance.now()+7;while(ri<rects.length&&performance.now()<deadline){const r=rects[ri];while(yy<r.h&&performance.now()<deadline){const gy=r.y0+yy,ci=cim+(h*.5-gy-.5)*scale;for(let xx=0;xx<r.w;xx++){const gx=r.x0+xx,cr=cre+(gx+.5-w*.5)*scale;let zr=0,zi=0,zr2=0,zi2=0,n=0;if(inBulbs(cr,ci))n=iter;else while(n<iter&&zr2+zi2<=4){zi=(zr+zr)*zi+ci;zr=zr2-zi2+cr;zr2=zr*zr;zi2=zi*zi;n++}const oi=(gy*w+gx)*4;if(n>=iter){out[oi]=out[oi+1]=out[oi+2]=0;out[oi+3]=255}else putFastColor(out,oi,n,Math.max(4.0000001,zr2+zi2),iter,colorCtx)}yy++}if(yy>=r.h){ri++;yy=0}}
-    if(ri<rects.length)requestAnimationFrame(slice);else finishRender(token,t0,profile,snap,w,h,out,'JavaScript f64 · 既存画像再利用 '+Math.round(100*reuse.reusedPixels/(w*h))+'%',reuse.exposedPixels)
-  }requestAnimationFrame(slice)
-}
-function renderWasmMain(profile,snap,w,h,iter,token,t0){
-  const out=new Uint8ClampedArray(w*h*4),field=makeField(w*h,iter),colorCtx=makeColorCtx(iter);
-  const cre=fixedNum(snap.re,snap.bits),cim=fixedNum(snap.im,snap.bits),sp=fixedNum(snap.span,snap.bits),scale=sp/w;
-  function proven(cr,ci){const y2=ci*ci,x=cr-.25,q0=x*x+y2;if(q0*(q0+x)<=.25*y2)return true;const x2=cr+1;return x2*x2+y2<=.0625}
-  let y=0;const counts=wasm.counts(),mags=wasm.mags();
-  function slice(){
-    if(token!==state.token)return;const deadline=performance.now()+(profile.covered?11:8);
-    while(y<h&&performance.now()<deadline){
-      const rows=Math.min(24,h-y),y0=y,npx=wasm.ex.render_rows(cre+scale*.5,cim-scale*.5,sp,w,h,y,rows,iter);let oi=y*w*4;
-      for(let i=0;i<npx;i++){
-        const n=counts[i],m=mags[i],px=i%w,py=y0+((i/w)|0);
-        const cr=cre+(px+.5-w*.5)*scale,ci=cim+(h*.5-py-.5)*scale,kind=n<iter?FIELD_ESCAPED:(proven(cr,ci)?FIELD_INTERIOR_LIKELY:FIELD_UNKNOWN);putField(field,py*w+px,n,m,kind);
-        if(n>=iter){out[oi++]=0;out[oi++]=0;out[oi++]=0;out[oi++]=255}
-        else{
-          putFastColor(out,oi,n,Math.max(4.0000001,m),iter,colorCtx);oi+=4;
-        }
-      }y+=rows;
-    }
-    if(y<h)requestAnimationFrame(slice);else finishRender(token,t0,profile,snap,w,h,out,'WebAssembly f64',w*h,field);
-  }requestAnimationFrame(slice);
-}
-function renderWasm(profile,snap,w,h,iter,token,t0){
-  if(!ensureShallowWorker()||shallowWorkerBusy){renderWasmMain(profile,snap,w,h,iter,token,t0);return}
-  const worker=shallowWorker,out=new Uint8ClampedArray(w*h*4),field=makeField(w*h,iter),cre=fixedNum(snap.re,snap.bits),cim=fixedNum(snap.im,snap.bits),sp=fixedNum(snap.span,snap.bits),jobId='shallow:'+token+':'+Date.now(),rowsPerChunk=Math.min(h,Math.max(4,Math.floor(32768/Math.max(1,w)))),chunks=[];for(let y=0;y<h;y+=rowsPerChunk)chunks.push({y,rows:Math.min(rowsPerChunk,h-y)});chunks.sort((a,b)=>Math.abs((a.y+a.rows*.5)/h-state.focusY)-Math.abs((b.y+b.rows*.5)/h-state.focusY));let next=0;shallowWorkerBusy=true;
-  const dispatch=()=>{if(token!==state.token){shallowWorkerBusy=false;return}if(next>=chunks.length){shallowWorkerBusy=false;finishRender(token,t0,profile,snap,w,h,out,'WebAssembly '+(wasm.simd?'SIMD':'scalar')+' Worker',w*h,field);return}const chunk=chunks[next++],msg={type:'render',jobId,cre,cim,sp,w,h,y:chunk.y,rows:chunk.rows,iter},transfer=[];if(shallowRecycle){msg.fieldBuffer=shallowRecycle.field;msg.iterationBuffer=shallowRecycle.iterations;msg.classBuffer=shallowRecycle.classes;transfer.push(msg.fieldBuffer,msg.iterationBuffer,msg.classBuffer);shallowRecycle=null}worker.postMessage(msg,transfer)};
-  worker.onmessage=e=>{const d=e.data;if(!d||d.type==='ready')return;if(d.jobId!==jobId)return;if(d.error){shallowWorkerBusy=false;renderWasmMain(profile,snap,w,h,iter,token,t0);return}const sf=new Float32Array(d.field),it=new Uint32Array(d.iterations),cl=new Uint8Array(d.classes);if(token!==state.token){shallowRecycle={field:d.field,iterations:d.iterations,classes:d.classes};shallowWorkerBusy=false;return}const stripe=colorizeField({smooth:sf,classes:cl,iter}),dst=d.y*w;field.smooth.set(sf,dst);field.iterations.set(it,dst);field.classes.set(cl,dst);out.set(stripe,dst*4);presentPartialStripe(stripe,0,d.y,w,d.rows,w,h,snap);shallowRecycle={field:d.field,iterations:d.iterations,classes:d.classes};dispatch()};worker.onerror=()=>{shallowWorkerBusy=false;destroyShallowWorker();if(token===state.token)renderWasmMain(profile,snap,w,h,iter,token,t0)};dispatch()
-}
-function renderJsDouble(profile,snap,w,h,iter,token,t0){
-  const out=new Uint8ClampedArray(w*h*4),field=makeField(w*h,iter),colorCtx=makeColorCtx(iter),sp=fixedNum(snap.span,snap.bits),cre=fixedNum(snap.re,snap.bits),cim=fixedNum(snap.im,snap.bits),scale=sp/w;let y=0;
-  function inBulbs(cr,ci){const y2=ci*ci,x=cr-.25,qq=x*x+y2;if(qq*(qq+x)<=.25*y2)return true;const x2=cr+1;return x2*x2+y2<=.0625}
-  function slice(){if(token!==state.token)return;const deadline=performance.now()+(profile.covered?10:7);while(y<h&&performance.now()<deadline){let oi=y*w*4,ci=cim+(h*.5-y-.5)*scale,cr=cre+(.5-w*.5)*scale;for(let x=0;x<w;x++,cr+=scale){let zr=0,zi=0,zr2=0,zi2=0,n=0,inside=inBulbs(cr,ci);if(inside)n=iter;else{let oldr=0,oldi=0;while(n<iter&&zr2+zi2<=4){zi=(zr+zr)*zi+ci;zr=zr2-zi2+cr;zr2=zr*zr;zi2=zi*zi;n++;if((n&63)===0){if(Math.abs(zr-oldr)+Math.abs(zi-oldi)<1e-15){n=iter;break}oldr=zr;oldi=zi}}}const mm=n>=iter?0:Math.max(4.0000001,zr2+zi2),kind=n<iter?FIELD_ESCAPED:(inside?FIELD_INTERIOR_LIKELY:FIELD_UNKNOWN);putField(field,y*w+x,n,mm,kind);if(n>=iter){out[oi++]=0;out[oi++]=0;out[oi++]=0;out[oi++]=255}else{putFastColor(out,oi,n,mm,iter,colorCtx);oi+=4}}y++}if(y<h)requestAnimationFrame(slice);else finishRender(token,t0,profile,snap,w,h,out,'JavaScript f64',w*h,field);}requestAnimationFrame(slice);
-}
-
-function spanMantBucket(span,bits){
-  const l=log2FixedAt(span,bits);let bucket=Math.round(l/256),mant=Math.pow(2,l-bucket*256);return{mant,bucket};
-}
-function normalizeBucket(r,i,b){
-  let m=Math.max(Math.abs(r),Math.abs(i));if(!m)return[0,0,NEG_BUCKET];
-  while(m>HI128){r*=INV256;i*=INV256;b++;m*=INV256}
-  while(m<LO128){r*=POW256;i*=POW256;b--;m*=POW256}
-  return[r,i,b];
-}
-function scAdd(a,b){
-  if(a[2]===NEG_BUCKET)return b;if(b[2]===NEG_BUCKET)return a;
-  const eb=Math.max(a[2],b[2]);let r=0,i=0;
-  if(a[2]===eb){r+=a[0];i+=a[1]}else if(a[2]===eb-1){r+=a[0]*INV256;i+=a[1]*INV256}
-  if(b[2]===eb){r+=b[0];i+=b[1]}else if(b[2]===eb-1){r+=b[0]*INV256;i+=b[1]*INV256}
-  return normalizeBucket(r,i,eb);
-}
-function scLog2(a){return a[2]===NEG_BUCKET?-Infinity:Math.log2(Math.hypot(a[0],a[1]))+256*a[2]}
-function fixedMantAtBucket(v,bits,bucket){
-  if(v===0n)return 0;const neg=v<0n;let a=neg?-v:v,bl=bitLen(a),take=Math.min(53,bl),sh=bl-take,top=Number(a>>BigInt(sh));
-  const exp=sh-bits-256*bucket;const n=top*Math.pow(2,exp);return neg?-n:n;
-}
-function fixedComplexScaled(r,i,bits){
-  if(r===0n&&i===0n)return[0,0,NEG_BUCKET];
-  const lr=r===0n?-Infinity:log2FixedAt(r,bits),li=i===0n?-Infinity:log2FixedAt(i,bits),bucket=Math.round(Math.max(lr,li)/256);
-  return normalizeBucket(fixedMantAtBucket(r,bits,bucket),fixedMantAtBucket(i,bits,bucket),bucket);
-}
-function pixelCenteredOffset(snap,refC,w){const half=roundDiv(snap.span,BigInt(2*Math.max(1,w)));return{r:snap.re-refC.re+half,i:snap.im-refC.im-half}}
-function roundDiv(v,d){const neg=v<0n,a=neg?-v:v,q=(a+d/2n)/d;return neg?-q:q}
-function fixedPixelPoint(snap,w,h,x,y,bits=snap.bits){const den=BigInt(2*w),re=align(snap.re,snap.bits,bits),im=align(snap.im,snap.bits,bits),span=align(snap.span,snap.bits,bits);return[re+roundDiv(span*BigInt(2*x+1-w),den),im+roundDiv(span*BigInt(h-2*y-1),den)]}
-function fixedAnalyticInterior(cr,ci,bits){const S=1n<<BigInt(bits),X=cr-(S>>2n),Y=ci,Q=X*X+Y*Y;if(4n*Q*(Q+X*S)<=Y*Y*S*S)return true;const D=cr+S;return 16n*(D*D+Y*Y)<=S*S}
-function fixedAnalyticPixelProven(snap,w,h,x,y){const p=fixedPixelPoint(snap,w,h,x,y),g=fixedPixelPoint(snap,w,h,x,y,snap.bits+64);return fixedAnalyticInterior(p[0],p[1],snap.bits)&&fixedAnalyticInterior(g[0],g[1],snap.bits+64)}
-function roundShift(v,bits){const neg=v<0n,a=neg?-v:v,half=1n<<(BigInt(bits)-1n),q=(a+half)>>BigInt(bits);return neg?-q:q}
-// ── Arbitrary-precision reference orbit / perturbation setup ────────────
-const referenceCache={id:0,bits:0,re:0n,im:0n,n:0,escape:0,zr:0n,zi:0n,rr:null,ri:null,series:null,version:0,loadedLen:0,derivative:[0,0,NEG_BUCKET],conditionLog2:0,checkpointVersion:0,checkpointBits:0,checkpointCount:0,checkpointMismatch:false};
-function promoteReferenceCache(shift,oldBits){
-  const c=referenceCache;if(!c.rr||c.bits!==oldBits)return;
-  const sh=BigInt(shift);c.re<<=sh;c.im<<=sh;c.zr<<=sh;c.zi<<=sh;c.bits+=shift;
-  // rr/ri are normalized Float64 values, so neither they nor Worker-side copies
-  // need to change when only the fixed-point radix moves.
-}
-function sameReference(bits,re,im){
-  return referenceCache.rr&&referenceCache.bits===bits&&referenceCache.re===re&&referenceCache.im===im;
-}
-function resetReference(bits,re,im){
-  const c=referenceCache;c.id++;c.bits=bits;c.re=re;c.im=im;c.n=0;c.escape=0;c.zr=0n;c.zi=0n;c.derivative=[0,0,NEG_BUCKET];c.conditionLog2=0;
-  if(!c.rr){c.rr=new Float64Array(150001);c.ri=new Float64Array(150001)}
-  c.series=null;c.version=1;c.loadedLen=0;c.checkpointVersion=0;c.checkpointBits=0;c.checkpointCount=0;c.checkpointMismatch=false;
-}
-function invalidateReferenceOrbit(){const c=referenceCache;c.id++;c.bits=0;c.re=0n;c.im=0n;c.n=0;c.escape=0;c.zr=0n;c.zi=0n;c.rr=null;c.ri=null;c.series=null;c.version=0;c.loadedLen=0;c.derivative=[0,0,NEG_BUCKET];c.conditionLog2=0;c.checkpointVersion=0;c.checkpointBits=0;c.checkpointCount=0;c.checkpointMismatch=false;for(const worker of deepPool.workers){worker._refKey='';worker._refLoaded=0}}
-function buildReferenceAt(bits,cRe,cIm,iter,token,done){
-  if(!sameReference(bits,cRe,cIm))resetReference(bits,cRe,cIm);
-  const c=referenceCache,B=BigInt(bits),ONE=1n<<B,BAIL=16n*ONE,startN=c.n,refT0=performance.now();
-  if((c.escape&&c.escape<=iter)||c.n>=iter){
-    const refLen=c.escape&&c.escape<=iter?c.escape:iter;done(c,refLen);return
-  }
-  function slice(){
-    if(token!==state.token)return;const deadline=performance.now()+6.5;
-    while(c.n<iter&&!c.escape&&performance.now()<deadline){
-      c.rr[c.n]=fixedOrbitNum(c.zr,bits);c.ri[c.n]=fixedOrbitNum(c.zi,bits);const Rr=c.rr[c.n],Ri=c.ri[c.n],d=c.derivative,term=d[2]===NEG_BUCKET?[0,0,NEG_BUCKET]:normalizeBucket(2*(Rr*d[0]-Ri*d[1]),2*(Rr*d[1]+Ri*d[0]),d[2]);c.derivative=scAdd(term,[1,0,0]);c.conditionLog2=Math.max(c.conditionLog2,scLog2(c.derivative));
-      const zr2=roundShift(c.zr*c.zr,bits),zi2=roundShift(c.zi*c.zi,bits);c.zi=roundShift(2n*c.zr*c.zi,bits)+cIm;c.zr=zr2-zi2+cRe;c.n++;
-      const mag=roundShift(c.zr*c.zr,bits)+roundShift(c.zi*c.zi,bits);if(mag>BAIL)c.escape=c.n;
-    }
-    if(c.escape||c.n>=iter){
-      c.rr[c.n]=fixedOrbitNum(c.zr,bits);c.ri[c.n]=fixedOrbitNum(c.zi,bits);c.version++;if(c.n>startN){const ms=performance.now()-refT0;refControl.lastBuildMs=ms;refControl.buildEMA=refControl.buildEMA?refControl.buildEMA*.82+ms*.18:ms}
-      const refLen=c.escape&&c.escape<=iter?c.escape:iter;done(c,refLen)
-    }else requestAnimationFrame(slice);
-  }
-  requestAnimationFrame(slice);
-}
-function verifyReferenceCheckpoints(ref,refLen,token,done){
-  const guardBits=ref.bits+64;
-  if(ref.checkpointVersion===ref.version&&ref.checkpointBits===guardBits&&!ref.checkpointMismatch){done(true);return}
-  const cRe=align(ref.re,ref.bits,guardBits),cIm=align(ref.im,ref.bits,guardBits),ONE=1n<<BigInt(guardBits),BAIL=16n*ONE;
-  const targets=new Set([0,refLen]);for(let n=1;n<refLen;n*=2)targets.add(n);const stride=Math.max(1,Math.floor(refLen/32));for(let n=stride;n<refLen;n+=stride)targets.add(n);
-  let zr=0n,zi=0n,n=0,escape=0,checked=0,mismatch=false;
-  function compare(){if(!targets.has(n)||n>refLen)return;checked++;const rr=fixedOrbitNum(zr,guardBits),ri=fixedOrbitNum(zi,guardBits);if(!Object.is(rr,ref.rr[n])||!Object.is(ri,ref.ri[n]))mismatch=true}
-  function slice(){
-    if(token!==state.token)return;const deadline=performance.now()+6;compare();
-    while(n<refLen&&!escape&&!mismatch&&performance.now()<deadline){const zr2=roundShift(zr*zr,guardBits),zi2=roundShift(zi*zi,guardBits);zi=roundShift(2n*zr*zi,guardBits)+cIm;zr=zr2-zi2+cRe;n++;const mag=roundShift(zr*zr,guardBits)+roundShift(zi*zi,guardBits);if(mag>BAIL)escape=n;compare()}
-    if(mismatch||escape||n>=refLen){if((ref.escape||0)!==escape&&((ref.escape||0)<=refLen||escape<=refLen))mismatch=true;ref.checkpointVersion=ref.version;ref.checkpointBits=guardBits;ref.checkpointCount=checked;ref.checkpointMismatch=mismatch;done(!mismatch)}else requestAnimationFrame(slice)
-  }
-  requestAnimationFrame(slice)
-}
-function computeSeries(ref,refLen,logMaxDc){
-  // A series valid for a wider image remains valid after zooming further in.
-  if(ref.series&&logMaxDc<=ref.series.logMaxDc+.02&&ref.series.skip<refLen)return ref.series;
-  let A=[0,0,NEG_BUCKET],Bc=[0,0,NEG_BUCKET],bestSkip=0,bestA=[0,0,NEG_BUCKET],bestB=[0,0,NEG_BUCKET];
-  const LOG_LIMIT=Math.log2(2.2e-4),LOG_RATIO=Math.log2(.10);
-  for(let n=0;n<refLen;n++){
-    const R=ref.rr[n],I=ref.ri[n],oldA=A;
-    const at=oldA[2]===NEG_BUCKET?[0,0,NEG_BUCKET]:normalizeBucket(2*(R*oldA[0]-I*oldA[1]),2*(R*oldA[1]+I*oldA[0]),oldA[2]);
-    A=scAdd(at,[1,0,0]);
-    const bt=Bc[2]===NEG_BUCKET?[0,0,NEG_BUCKET]:normalizeBucket(2*(R*Bc[0]-I*Bc[1]),2*(R*Bc[1]+I*Bc[0]),Bc[2]);
-    const a2=oldA[2]===NEG_BUCKET?[0,0,NEG_BUCKET]:normalizeBucket(oldA[0]*oldA[0]-oldA[1]*oldA[1],2*oldA[0]*oldA[1],2*oldA[2]);
-    Bc=scAdd(bt,a2);
-    const l1=scLog2(A)+logMaxDc,l2=scLog2(Bc)+2*logMaxDc;
-    if(Number.isFinite(l1)&&l1<LOG_LIMIT&&(!Number.isFinite(l2)||(l2<LOG_LIMIT&&l2<l1+LOG_RATIO))){bestSkip=n+1;bestA=A.slice();bestB=Bc.slice()}
-  }
-  if(bestSkip>=refLen)bestSkip=Math.max(0,refLen-1);
-  ref.series={logMaxDc,skip:bestSkip,Ar:bestA[0],Ai:bestA[1],Ab:bestA[2],Br:bestB[0],Bi:bestB[1],Bb:bestB[2]};
-  return ref.series;
-}
-function chooseReference(snap){
-  const c=referenceCache;if(c.rr&&c.n>8){const rr=align(c.re,c.bits,snap.bits),ri=align(c.im,c.bits,snap.bits),dx=fixedRatio(rr-snap.re,snap.span),dy=fixedRatio(ri-snap.im,snap.span),dist=Math.hypot(dx,dy);if(Number.isFinite(dist)){const hard=2.25;if(dist<=hard){let keep=true;if(dist>.45&&refControl.refId===c.id&&refControl.baseMPP>0&&refControl.lastMPP>refControl.baseMPP*1.34&&performance.now()-refControl.lastRecenterAt>refControl.cooldownMs){const extra=(refControl.lastMPP-refControl.baseMPP)*Math.max(1,refControl.lastPixels),build=Math.max(5,refControl.buildEMA||18);if(extra>build*1.65)keep=false}if(keep)return{re:rr,im:ri,reused:true,dist};refControl.lastRecenterAt=performance.now()}}}return{re:snap.re,im:snap.im,reused:false,dist:0}
-}
-function putDeepPixel(out,w,computeIter,colorIter,x,y,n,m,colorCtx){
-  const oi=(y*w+x)*4,mm=n>=computeIter?0:Math.max(4.0000001,m);
-  
-  if(n>=computeIter){out[oi]=0;out[oi+1]=0;out[oi+2]=0;out[oi+3]=255;return}
-  putFastColor(out,oi,n,mm,colorIter,colorCtx);
-}
-function directOrbitState(cr,ci,bits,iter){return{cr,ci,bits,iter,zr:0n,zi:0n,mag:0n,n:0,done:false,four:4n*(1n<<BigInt(bits))}}
-function stepDirectOrbit(orbit,deadline){let batch=0;while(!orbit.done){const zr2=roundShift(orbit.zr*orbit.zr,orbit.bits),zi2=roundShift(orbit.zi*orbit.zi,orbit.bits);orbit.mag=zr2+zi2;if(orbit.mag>orbit.four||orbit.n>=orbit.iter){orbit.done=true;break}orbit.zi=roundShift(2n*orbit.zr*orbit.zi,orbit.bits)+orbit.ci;orbit.zr=zr2-zi2+orbit.cr;orbit.n++;if((++batch&31)===0&&performance.now()>=deadline)break}if(orbit.n>=orbit.iter)orbit.done=true}
-async function highPrecisionDirectPixelAsync(snap,w,h,iter,x,y,guarded=true,cancelled=()=>false){const p=fixedPixelPoint(snap,w,h,x,y),base=directOrbitState(p[0],p[1],snap.bits,iter);let guard=null;if(guarded){const bits=snap.bits+64,g=fixedPixelPoint(snap,w,h,x,y,bits);guard=directOrbitState(g[0],g[1],bits,iter)}while(!base.done||(guard&&!guard.done)){if(cancelled())return null;const deadline=performance.now()+6;stepDirectOrbit(base,deadline);if(guard)stepDirectOrbit(guard,deadline);if(!base.done||(guard&&!guard.done))await new Promise(requestAnimationFrame)}if(guard&&(guard.n!==base.n||((guard.n<iter)!==(base.n<iter))))return[iter,0];const chosen=guard||base;return[chosen.n,chosen.n<iter?Math.max(4.0000001,fixedOrbitNum(chosen.mag,chosen.bits)):0]}
-function renderDeepDirect(profile,snap,w,h,iter,colorIter,token,t0){
-  const cap=profile.covered?w:390,scale=Math.min(1,cap/w);if(scale<1){h=Math.max(100,Math.round(h*scale));w=Math.max(160,Math.round(w*scale))}
-  const out=new Uint8ClampedArray(w*h*4),field=makeField(w*h,colorIter),colorCtx=makeColorCtx(colorIter);let y=0;
-  state.lastEngine='BigInt direct fallback';
-  async function slice(){
-    if(token!==state.token)return;const deadline=performance.now()+7;
-    while(y<h&&performance.now()<deadline){const y0=y;for(let x=0;x<w;x++){const result=await highPrecisionDirectPixelAsync(snap,w,h,iter,x,y,false,()=>token!==state.token);if(!result)return;const[n,m]=result;putField(field,y*w+x,n,m,n<iter?FIELD_ESCAPED:FIELD_UNKNOWN);putDeepPixel(out,w,iter,colorIter,x,y,n,m,colorCtx)}presentPartialStripe(out.subarray(y0*w*4,(y0+1)*w*4),0,y0,w,1,w,h,snap);y++}
-    if(y<h)requestAnimationFrame(slice);else finishRender(token,t0,profile,snap,w,h,out,'BigInt direct fallback',w*h,field);
-  }requestAnimationFrame(slice);
-}
-function prepareDeepContext(snap,refC,iter,token,done){
-  const probeW=64,probeH=Math.max(28,Math.round(probeW*canvas.clientHeight/Math.max(1,canvas.clientWidth))),refX=probeW*.5-.5+fixedRatio(refC.re-snap.re,snap.span)*probeW,refY=probeH*.5-.5-fixedRatio(refC.im-snap.im,snap.span)*probeW,cornerR=Math.max(Math.hypot(refX,refY),Math.hypot(probeW-refX,refY),Math.hypot(refX,probeH-refY),Math.hypot(probeW-refX,probeH-refY))/Math.max(1,probeW),logMaxDc=log2FixedAt(snap.span,snap.bits)+Math.log2(Math.max(1e-300,cornerR));
-  buildReferenceAt(snap.bits,refC.re,refC.im,iter,token,(ref,refLen)=>{if(token!==state.token)return;if(ensureOrbitPrecision(iter,Math.max(1,canvas.width))){state.dirty=true;invalidateView();return}const finish=()=>done({ref,refLen,series:computeSeries(ref,refLen,logMaxDc)});if(state.processMode!=='validate'){finish();return}verifyReferenceCheckpoints(ref,refLen,token,ok=>{if(token!==state.token)return;if(ok){finish();return}promoteState(32);invalidateReferenceOrbit();state.dirty=true;invalidateView()})})
-}
-function renderPerturbPrepared(profile,snap,w,h,iter,colorIter,token,t0,refC,ref,refLen,series,reuse=null){
-  const workerReady=ensureDeepPool();if(!workerReady&&(!ensureDeepWasm()||!deepWasm.ex.render_perturb_rebase_rect)){renderDeepDirect(profile,snap,w,h,iter,colorIter,token,t0);return}
-  const centered=pixelCenteredOffset(snap,refC,w),out=reuse?reuse.out:new Uint8ClampedArray(w*h*4),field=makeField(w*h,colorIter),colorCtx=makeColorCtx(colorIter),sb=spanMantBucket(snap.span,snap.bits),off=fixedComplexScaled(centered.r,centered.i,snap.bits);
-  const fallback=(strict=false)=>{if(token!==state.token)return;if(!ensureDeepWasm()||!deepWasm.ex.render_perturb_rebase_rect){renderDeepDirect(profile,snap,w,h,iter,colorIter,token,t0);return}if(ref.loadedLen<refLen+1){deepWasm.refsR().set(ref.rr.subarray(ref.loadedLen,refLen+1),ref.loadedLen);deepWasm.refsI().set(ref.ri.subarray(ref.loadedLen,refLen+1),ref.loadedLen);ref.loadedLen=refLen+1}const counts=deepWasm.counts(),mags=deepWasm.mags(),bad=[];let y=0;function rows(){if(token!==state.token)return;const deadline=performance.now()+(profile.covered?11:8);while(y<h&&performance.now()<deadline){const rows=Math.min(Math.max(1,Math.floor(65536/Math.max(1,w))),h-y),y0=y,npx=deepWasm.ex.render_perturb_rebase_rect(sb.mant,sb.bucket,off[0],off[1],off[2],refLen,w,h,w*.5,h*.5,0,y,w,rows,iter,strict?0:series.skip,strict?0:series.Ar,strict?0:series.Ai,strict?0:series.Ab,strict?0:series.Br,strict?0:series.Bi,strict?0:series.Bb);for(let i=0;i<npx;i++){const x=i%w,py=y0+((i/w)|0),n=counts[i],m=mags[i];if(n===0xffffffff){bad.push(py*w+x);continue}putField(field,py*w+x,n,m,n<iter?FIELD_ESCAPED:FIELD_UNKNOWN);putDeepPixel(out,w,iter,colorIter,x,py,n,m,colorCtx)}y+=rows}if(y<h)requestAnimationFrame(rows);else if(bad.length)runResidual();else finish()}function runResidual(){let k=0;async function slice(){if(token!==state.token)return;const deadline=performance.now()+6;while(k<bad.length&&performance.now()<deadline){const idx=bad[k++],x=idx%w,py=(idx/w)|0,result=await highPrecisionDirectPixelAsync(snap,w,h,iter,x,py,false,()=>token!==state.token);if(!result)return;const[n,m]=result;putField(field,idx,n,m,n<iter?FIELD_ESCAPED:FIELD_UNKNOWN);putDeepPixel(out,w,iter,colorIter,x,py,n,m,colorCtx)}if(k<bad.length)requestAnimationFrame(slice);else finish()}requestAnimationFrame(slice)}function finish(){state.lastEngine='WASM '+(deepWasm.simd?'SIMD':'scalar')+' · '+(strict?'strict ':'')+'main-thread rebase · skip '+(strict?0:series.skip);finishRender(token,t0,profile,snap,w,h,out,state.lastEngine,w*h,field)}requestAnimationFrame(rows)};
-  // Never abort and restart an in-flight frame because a budget estimate was wrong.
-  // Finish it once and feed the measured cost into the next frame.
-  if(!workerReady||!runDeepPool(profile,snap,w,h,iter,colorIter,token,t0,out,sb,refC,off,ref,refLen,series,fallback,reuse?reuse.rects:null))fallback();
-}
-async function renderDeepAdaptive(profile,snap,plan,token,t0){
-  try{await prepareDeepModules()}catch{if(token===state.token){const [fallbackW,fallbackH]=targetSize(profile,true);renderDeepDirect(profile,snap,fallbackW,fallbackH,plan.colorIter,plan.colorIter,token,t0)}return}if(token!==state.token)return;
-  const iter=plan.colorIter,colorIter=plan.colorIter,[w,h]=targetSize(profile,true),reuse=buildPanReuse(snap,w,h,iter,profile);
-  // A zoom-in can be represented entirely by the previous frame. Commit that preview
-  // immediately; the normal idle HQ pass performs the exact full-resolution render.
-  if(reuse&&reuse.rects.length===0&&!profile.covered){finishRender(token,t0,profile,snap,w,h,reuse.out,'既存画像再利用 100%',0);return}
-  const refC=chooseReference(snap);state.lastEngine='参照軌道を準備中…';prepareDeepContext(snap,refC,iter,token,ctx=>{if(token!==state.token)return;renderPerturbPrepared(profile,snap,w,h,iter,colorIter,token,t0,refC,ctx.ref,ctx.refLen,ctx.series,reuse)})
-}
-function render(pass=RENDER_PASS.PREVIEW){
-  const profile=renderProfile(pass);
-  if(pass===RENDER_PASS.COVERED){state.fieldView=null;trimDetailCache()}
-  runtimeMetrics.renderStarts++;if(state.pointerActive||state.wheelActive)runtimeMetrics.renderStartsDuringGesture++;
-  let snap=snapshot(),deep=deepEngineNeeded(snap);if(!deep&&state.adaptivePixelBudget){state.adaptivePixelBudget=0;resize()}if(deep&&ensureOrbitPrecision(maxIter()))snap=snapshot();const plan=iterationPlan(profile,deep),token=++state.token,t0=performance.now();state.rendering=true;state.drawState=profile.covered?'COVERING':'PREVIEW';state.lastPass=profile.id;state.lastEngine=deep?'参照軌道を準備中…':(wasm?('WebAssembly '+(wasm.simd?'SIMD':'scalar')):'JavaScript f64');
-  if(!deep){const ratio=deepResolutionRatio(snap);if(ratio<=128)prewarmDeepAssets();else if(deepPool.workers.length||deepWasm||deepModuleBundle||referenceCache.rr)retireDeepAssets()}
-  invalidateStats();
-  if(deep)renderDeepAdaptive(profile,snap,plan,token,t0);else{const [w,h]=targetSize(profile,false),reuse=buildPanReuse(snap,w,h,plan.computeIter,profile);if(reuse)renderShallowReuse(profile,snap,w,h,plan.computeIter,token,t0,reuse);else if(wasm)renderWasm(profile,snap,w,h,plan.computeIter,token,t0);else renderJsDouble(profile,snap,w,h,plan.computeIter,token,t0)}
-}
-function screenPixelBudget(){
-  const lowMemory=Number(navigator.deviceMemory||8)<=4,small=matchMedia('(max-width:700px)').matches;if(state.processMode==='power')return 1*1048576;if(state.processMode==='fine'||state.processMode==='validate')return(lowMemory||small?4:8)*1048576;
-  const base=(lowMemory||small?2:4)*1048576;return state.adaptivePixelBudget?Math.min(base,state.adaptivePixelBudget):base
-}
-function adaptStandardDeepBudget(deep){if(state.processMode!=='standard'||!deep)return false;const measuredMPP=renderPerf.deepMPP||.03,target=Math.max(32768,Math.min(4*1048576,Math.round(1400/measuredMPP))),oldBudget=state.adaptivePixelBudget||screenPixelBudget();if(target/oldBudget>=.8&&target/oldBudget<=1.25)return false;const oldPixels=canvas.width*canvas.height;state.adaptivePixelBudget=target;resize();return canvas.width*canvas.height!==oldPixels}
-function resize(){
-  const cssW=Math.max(1,innerWidth),cssH=Math.max(1,innerHeight),budget=screenPixelBudget(),nativeDpr=Math.max(1,window.devicePixelRatio||1),budgetDpr=Math.sqrt(budget/Math.max(1,cssW*cssH)),minDpr=Math.min(1,64/Math.max(cssW,cssH)),dpr=Math.max(minDpr,Math.min(nativeDpr,budgetDpr)),w=Math.max(2,Math.round(cssW*dpr)),h=Math.max(2,Math.round(cssH*dpr));
-  state.effectiveDpr=dpr;state.screenPixelBudget=budget;
-  if(canvas.width!==w||canvas.height!==h){clearPanReuse();canvas.width=w;canvas.height=h;trimDetailCache();state.dirty=true;invalidateView()}
-}
-function jaEngine(s){return String(s||'').replace('preparing cached rebase reference…','参照軌道を準備中…').replace('persistent workers','常駐Worker').replace('main-thread','メインスレッド').replace('strict','厳密').replace('fallback','フォールバック').replace('rebase','リベース').replace('skip','スキップ').replace('residual','残差').replace('starting','起動中')}
-function updateStats(){
-  runtimeMetrics.domWrites++;
-  const z=zoomExp(),digits=Math.max(8,Math.min(80,Math.ceil(z)+8));$('#coord').textContent=fmtFixed(state.re,digits)+' '+(state.im<0n?'−':'+')+' '+fmtFixed(state.im<0n?-state.im:state.im,digits)+'i';
-  $('#zoom').textContent=z<4?Math.pow(10,z).toFixed(1)+'×':'≈ 10^'+z.toFixed(2);$('#span').textContent=fmtSpan();const deep=deepEngineNeeded(),diagnosticProfile=RENDER_PROFILE[RENDER_PASS.COVERED],ip=iterationPlan(diagnosticProfile,deep);$('#engine').textContent=deep?'高精度深部':'標準精度';$('#render').textContent=state.rendering?'描画中…':(state.lastRender?state.lastRender.toFixed(0)+' ms':'準備完了');let status;if(state.drawState==='REPROJECTED')status='再投影';else if(state.drawState==='PREVIEW')status=state.rendering?'プレビュー描画中':'プレビュー';else if(state.drawState==='COVERING')status='全域描画中';else if(state.drawState==='RESOLVING')status='未確定を追加計算 '+Math.round(state.continuationProgress*100)+'%';else if(state.drawState==='REFINING')status='境界AA '+state.detailDone+'/'+state.detailQueued;else if(state.drawState==='REFINED')status='境界AA 完了';else if(state.drawState==='VALIDATING')status='精度照合 '+Math.round(state.coverage*100)+'%';else if(state.drawState==='VALIDATION_INCOMPLETE')status='検証未完了';else if(state.drawState==='VALIDATED')status='検証完了';else status='全域描画 完了';if(state.unresolved)status+=' · 未確定 '+state.unresolved;if(state.effectiveDpr<(devicePixelRatio||1)*.99)status+=' · '+canvas.width+'×'+canvas.height;$('#badge').textContent=status;$('#compactStatus').textContent=status;const ledger=memoryLedger(),bp=blaProfile(diagnosticProfile);$('#diagEngine').textContent='engine: '+jaEngine(state.lastEngine)+' | workers '+deepPool.workers.length+' | '+(wasm&&wasm.simd?'SIMD':'scalar/JS');$('#diagNumeric').textContent='numeric: '+state.bits+' bit | iter '+ip.colorIter+' | BLA ε 2^-'+bp.exp+' | condition '+Math.round(referenceCache.conditionLog2||0)+' bit';$('#diagMemory').textContent='memory: managed '+(ledger.managedBytes/1048576).toFixed(1)+' / '+(ledger.budget/1048576).toFixed(0)+' MiB | canvas est. '+(ledger.canvasBytes/1048576).toFixed(1)+' MiB';
-}
-
-
-// ── Scheduler / interaction loop ────────────────────────────────────────
-function nextQualityDue(deep){
-  if(state.processMode==='power'||state.dirty||state.rendering||state.pointerActive||state.wheelActive)return Infinity;
-  if(deep&&state.lastPass!==RENDER_PASS.COVERED)return Math.max(state.lastInteraction+680,state.lastFrameDone+260);
-  if(!deep&&state.lastPass!==RENDER_PASS.COVERED)return Math.max(state.lastInteraction+520,state.lastFrameDone+280);
-  return Infinity
-}
-function loop(now){
-  schedulerRAF=0;if(document.hidden)return;
-  const deep=deepEngineNeeded();
-  if(!state.pointerActive&&!state.wheelActive&&!state.rendering){
-    if(state.dirty)render(RENDER_PASS.PREVIEW);
-    else{
-      const due=nextQualityDue(deep);
-      if(due<=now)render(RENDER_PASS.COVERED)
-    }
-  }
-  if(needsPaint){needsPaint=false;paintFrame()}
-  if(needsStats){needsStats=false;updateStats()}
-  if(!state.rendering&&!state.pointerActive&&!state.wheelActive&&!state.dirty){
-    const due=nextQualityDue(deep);if(Number.isFinite(due))requestScheduler(Math.max(1,due-performance.now()))
-  }
-}
-
-const pts=new Map();let lx=0,ly=0,pinch=0;
-canvas.addEventListener('wheel',e=>{e.preventDefault();updateFocus(e.clientX,e.clientY);if(!state.wheelActive){state.wheelActive=true;cancelDetailRefinement(true);cancelRender();capturePanSource()}zoomAt(e.clientX,e.clientY,Math.exp(e.deltaY*.00125));clearTimeout(wheelSettleTimer);wheelSettleTimer=setTimeout(()=>{wheelSettleTimer=0;state.wheelActive=false;state.lastInteraction=performance.now();state.dirty=true;recordView();saveHash(false);invalidateView()},110)},{passive:false});
-canvas.addEventListener('pointerdown',e=>{updateFocus(e.clientX,e.clientY);try{canvas.setPointerCapture(e.pointerId)}catch{};if(pts.size===0){clearTimeout(pointerSettleTimer);pointerSettleTimer=0;clearTimeout(wheelSettleTimer);wheelSettleTimer=0;state.wheelActive=false;state.pointerActive=true;cancelDetailRefinement(true);cancelRender();capturePanSource()}pts.set(e.pointerId,[e.clientX,e.clientY]);if(pts.size===1){lx=e.clientX;ly=e.clientY}else if(pts.size===2){const a=[...pts.values()];pinch=Math.hypot(a[0][0]-a[1][0],a[0][1]-a[1][1])}});
-canvas.addEventListener('pointermove',e=>{if(!pts.has(e.pointerId))return;updateFocus(e.clientX,e.clientY);pts.set(e.pointerId,[e.clientX,e.clientY]);if(pts.size===1){const dx=e.clientX-lx,dy=e.clientY-ly;pan(dx,dy);lx=e.clientX;ly=e.clientY}else if(pts.size===2){const a=[...pts.values()],d=Math.hypot(a[0][0]-a[1][0],a[0][1]-a[1][1]);if(pinch>0&&d>0)zoomAt((a[0][0]+a[1][0])/2,(a[0][1]+a[1][1])/2,pinch/d);pinch=d}});
-function end(e){pts.delete(e.pointerId);pinch=0;if(pts.size)return;clearTimeout(pointerSettleTimer);pointerSettleTimer=setTimeout(()=>{pointerSettleTimer=0;state.pointerActive=false;state.lastInteraction=performance.now();state.dirty=true;recordView();saveHash(false);invalidateView()},90)}canvas.addEventListener('pointerup',end);canvas.addEventListener('pointercancel',end);
-function applyUiVisibility(){document.body.classList.toggle('ui-hidden',state.uiHidden);$('#uiToggle').textContent=state.uiHidden?'UI＋':'UI−';$('#uiToggle').setAttribute('aria-expanded',String(!state.uiHidden))}
-$('#uiToggle').onclick=()=>{state.uiHidden=!state.uiHidden;applyUiVisibility();try{localStorage.setItem('mandelbrot.uiHidden',state.uiHidden?'1':'0')}catch{}};
-$('#zin').onclick=()=>{capturePanSource();zoomAt(innerWidth/2,innerHeight/2,.5);recordView();saveHash(false)};$('#zout').onclick=()=>{capturePanSource();zoomAt(innerWidth/2,innerHeight/2,2);recordView();saveHash(false)};$('#reset').onclick=()=>{reset();recordView()};
-const exportJob={active:false,cancelled:false,bytes:0};let exportForcePrecision=false;
-function downloadBlob(blob,name){const a=document.createElement('a');a.href=URL.createObjectURL(blob);a.download=name;a.click();setTimeout(()=>URL.revokeObjectURL(a.href),1500)}
-function exportLedgerBytes(){return memoryLedger().logicalBytes}
-function exportSampleShallow(cre,cim,scale,W,H,iter,x,y){const cr=cre+(x+.5-W*.5)*scale,ci=cim+(H*.5-y-.5)*scale;let zr=0,zi=0,zr2=0,zi2=0,n=0;while(n<iter&&zr2+zi2<=4){zi=2*zr*zi+ci;zr=zr2-zi2+cr;zr2=zr*zr;zi2=zi*zi;n++}return[n,n<iter?Math.max(4.0000001,zr2+zi2):0]}
-async function runExport(){if(exportJob.active)return;const scaleChoice=Number($('#exportScale').value),w=Math.max(64,Math.min(16384,Math.round(scaleChoice?canvas.width*scaleChoice:Number($('#exportWidth').value)||canvas.width))),h=Math.max(1,Math.round(w*canvas.height/Math.max(1,canvas.width))),ss=Math.max(1,Math.min(2,Number($('#exportAA').value)||1)),needed=w*h*8,budget=rendererMemoryBudget(),available=Math.max(0,budget-exportLedgerBytes());if(w>16384||h>16384){$('#exportStatus').textContent='辺の長さは 16384px 以下にしてください。';return}if(needed>available){$('#exportStatus').textContent='メモリ予算を超えます。幅または倍率を下げてください（必要 '+Math.ceil(needed/1048576)+' MiB / 空き '+Math.floor(available/1048576)+' MiB）。';return}const outCanvas=document.createElement('canvas');outCanvas.width=w;outCanvas.height=h;const oc=outCanvas.getContext('2d',{alpha:false});if(!oc){$('#exportStatus').textContent='出力 Canvas を作成できません。';return}const snap=snapshot(),iter=maxIter(),deep=deepEngineNeeded(snap,w),cre=fixedNum(snap.re,snap.bits),cim=fixedNum(snap.im,snap.bits),sp=fixedNum(snap.span,snap.bits),W=w*ss,H=h*ss,pixelScale=sp/W,colorCtx=makeColorCtx(iter),tmp=new Uint8ClampedArray(4),tiles=[],tileW=exportForcePrecision?4:(deep?16:128),tileH=exportForcePrecision?1:(deep?4:24);for(let y=0;y<h;y+=tileH)for(let x=0;x<w;x+=tileW)tiles.push({x,y,w:Math.min(tileW,w-x),h:Math.min(tileH,h-y)});exportJob.active=true;exportJob.cancelled=false;exportJob.bytes=needed;$('#exportProgress').hidden=false;$('#exportProgress').value=0;$('#exportStart').disabled=true;$('#exportStatus').textContent='タイル描画中…';let done=0,unresolvedSamples=0;try{for(const tile of tiles){if(exportJob.cancelled)throw new Error('cancelled');const id=oc.createImageData(tile.w,tile.h),data=id.data;for(let yy=0;yy<tile.h;yy++)for(let xx=0;xx<tile.w;xx++){let ar=0,ag=0,ab=0;for(let sy=0;sy<ss;sy++)for(let sx=0;sx<ss;sx++){const gx=(tile.x+xx)*ss+sx,gy=(tile.y+yy)*ss+sy,sample=deep?await highPrecisionDirectPixelAsync(snap,W,H,iter,gx,gy,exportForcePrecision,()=>exportJob.cancelled):exportSampleShallow(cre,cim,pixelScale,W,H,iter,gx,gy);if(!sample)throw new Error('cancelled');const[n,m]=sample;if(n<iter){putFastColor(tmp,0,n,m,iter,colorCtx);ar+=linearChannel(tmp[0]);ag+=linearChannel(tmp[1]);ab+=linearChannel(tmp[2])}else{ar+=linearChannel(20);ag+=linearChannel(22);ab+=linearChannel(30);unresolvedSamples++}}const samples=ss*ss,oi=(yy*tile.w+xx)*4;data[oi]=srgbChannel(ar/samples);data[oi+1]=srgbChannel(ag/samples);data[oi+2]=srgbChannel(ab/samples);data[oi+3]=255}oc.putImageData(id,tile.x,tile.y);done++;$('#exportProgress').value=done/tiles.length;$('#exportStatus').textContent='生成中 '+Math.round(done/tiles.length*100)+'%';await new Promise(requestAnimationFrame)}if(exportJob.cancelled)throw new Error('cancelled');$('#exportStatus').textContent='PNGを圧縮中…';const blob=await new Promise(resolve=>outCanvas.toBlob(resolve,'image/png'));if(!blob)throw new Error('PNG encode failed');const stamp=Date.now(),base='mandelbrot-'+stamp,meta={format:'mandelbrot-view-v23',rendererVersion:23,pixelContract:'centered',width:w,height:h,supersampling:ss,sampleCount:w*h*ss*ss,unresolvedSamples,membershipCertified:false,precisionPolicy:{mode:exportForcePrecision?'validated-direct':'balanced',baseBits:snap.bits,agreementGuardBits:exportForcePrecision?64:0},iterationPolicy:{adaptive:state.adaptive,base:state.baseIter,effective:iter},numericEngine:deep?'bigint-fixed-direct':'javascript-f64-direct',kernelSha256:globalThis.MANDEL_KERNEL_META||null,colorSpace:'sRGB with linear-light sample resolve',encoder:{mime:'image/png',api:'HTMLCanvasElement.toBlob'},view:{bits:snap.bits,re:snap.re.toString(),im:snap.im.toString(),span:snap.span.toString()},palette:{id:state.palette,cycle:state.cycle,shift:state.shift},determinism:{randomSeed:null,tiled:true,allTilesCompleted:true}};downloadBlob(blob,base+'.png');downloadBlob(new Blob([JSON.stringify(meta,null,2)],{type:'application/json'}),base+'.json');$('#exportStatus').textContent='PNG と座標メタデータを保存しました。'}catch(e){$('#exportStatus').textContent=String(e&&e.message)==='cancelled'?'出力を中止しました。':'出力に失敗しました: '+String(e&&e.message||e)}finally{exportJob.active=false;exportJob.bytes=0;$('#exportStart').disabled=false}}
-$('#png').onclick=()=>{const d=$('#exportDialog');$('#exportWidth').value=String(canvas.width);$('#exportScale').value='1';$('#exportProgress').hidden=true;$('#exportStatus').textContent='';d.showModal?d.showModal():d.setAttribute('open','')};
-$('#exportQuick').onclick=()=>canvas.toBlob(blob=>{if(!blob)return;downloadBlob(blob,'mandelbrot-'+state.drawState.toLowerCase()+'-'+Date.now()+'.png');$('#exportStatus').textContent='現在の表示（'+state.drawState+'）を保存しました。'},'image/png');
-$('#exportScale').onchange=e=>{const s=Number(e.target.value);if(s)$('#exportWidth').value=String(Math.min(16384,canvas.width*s))};$('#exportStart').onclick=async()=>{exportForcePrecision=$('#exportPrecision').value==='validated';try{await runExport()}finally{exportForcePrecision=false}};$('#exportCancel').onclick=()=>{if(exportJob.active){exportJob.cancelled=true;$('#exportStatus').textContent='中止しています…'}else $('#exportDialog').close()};
-function toast(s){const t=$('#toast');t.textContent=s;t.classList.add('show');clearTimeout(toast._t);toast._t=setTimeout(()=>t.classList.remove('show'),1500)}
-let lastWrittenHash='',navigationHash='';
-const viewHistory=[];let viewHistoryIndex=-1;
+function zoomExp(){return Math.max(0,Math.log10(3.4)-log2Fixed(state.span)/Math.log2(10))}
+function fmtSpan(){const l=log2Fixed(state.span)/Math.log2(10);if(l>-4)return fmtFixed(state.span,12);const e=Math.floor(l),m=Math.pow(10,l-e);return m.toFixed(7)+'e'+e}
+function spanMantExp(snap){const l=log2FixedAt(snap.span,snap.bits);if(!Number.isFinite(l))return{mant:0,exp:0};const exp=Math.floor(l),mant=Math.pow(2,l-exp);return{mant,exp}}
+function f32Ulp(x){x=Math.fround(Math.abs(x));if(!Number.isFinite(x))return Infinity;if(x===0)return 2**-149;const e=Math.floor(Math.log2(x));return 2**(e-23)}
+function deepNeeded(snap=snapshot(),width=Math.max(1,canvas.width)){const stepLog=log2FixedAt(snap.span,snap.bits)-Math.log2(width),cr=fixedNum(snap.re,snap.bits),ci=fixedNum(snap.im,snap.bits),ulp=Math.max(f32Ulp(cr),f32Ulp(ci),2**-149),ratio=Math.pow(2,Math.min(1024,stepLog-Math.log2(ulp)));return !Number.isFinite(ratio)||ratio<96||stepLog<-120}
 function currentViewSpec(){return{bits:state.bits,re:state.re,im:state.im,span:state.span,palette:state.palette,cycle:state.cycle,shift:state.shift,baseIter:state.baseIter,adaptive:state.adaptive}}
 function viewSpecKey(v){return[v.bits,v.re,v.im,v.span,v.palette,v.cycle,v.shift,v.baseIter,v.adaptive].join(':')}
-function recordView(){const v=currentViewSpec(),key=viewSpecKey(v);if(viewHistoryIndex>=0&&viewSpecKey(viewHistory[viewHistoryIndex])===key)return;viewHistory.splice(viewHistoryIndex+1);viewHistory.push(v);if(viewHistory.length>80)viewHistory.shift();viewHistoryIndex=viewHistory.length-1;syncHistoryButtons()}
-function restoreView(v){if(!v)return;state.bits=v.bits;state.re=v.re;state.im=v.im;state.span=v.span;state.palette=v.palette;state.cycle=v.cycle;state.shift=v.shift;state.baseIter=v.baseIter;state.adaptive=v.adaptive;clearDetailCache();clearPanReuse();ensurePrecision();syncControls();saveHash(false);setDirty()}
-function syncHistoryButtons(){$('#undoView').disabled=viewHistoryIndex<=0;$('#redoView').disabled=viewHistoryIndex<0||viewHistoryIndex>=viewHistory.length-1}
-function syncCoordinateInputs(){$('#coordReInput').value=fmtFixedExact(state.re);$('#coordImInput').value=fmtFixedExact(state.im);$('#coordSpanInput').value=fmtFixedExact(state.span)}
-function saveHash(push){const p=new URLSearchParams();p.set('v','23');p.set('b',String(state.bits));p.set('re',state.re.toString());p.set('im',state.im.toString());p.set('sp',state.span.toString());p.set('pal',String(state.palette));p.set('cy',String(state.cycle));p.set('sh',String(state.shift));p.set('it',String(state.baseIter));p.set('ad',state.adaptive?'1':'0');const h='#'+p.toString();lastWrittenHash=h;try{if(location.protocol==='file:'||location.origin==='null'){if(location.hash!==h)location.hash=h}else{push?history.pushState(null,'',h):history.replaceState(null,'',h)}}catch{}}
+function recordView(){const v=currentViewSpec(),k=viewSpecKey(v);if(viewHistoryIndex>=0&&viewSpecKey(viewHistory[viewHistoryIndex])===k)return;viewHistory.splice(viewHistoryIndex+1);viewHistory.push(v);if(viewHistory.length>80)viewHistory.shift();viewHistoryIndex=viewHistory.length-1;syncHistoryButtons()}
+function restoreView(v){if(!v)return;Object.assign(state,{bits:v.bits,re:v.re,im:v.im,span:v.span,palette:v.palette,cycle:v.cycle,shift:v.shift,baseIter:v.baseIter,adaptive:v.adaptive});ensurePrecision();syncControls();saveHash(false);markDirty()}
+
+// ── iteration / quality policy ───────────────────────────────────────────
+function maxIter(){if(!state.adaptive)return state.baseIter;const z=zoomExp(),bonus=Math.max(0,Math.floor(70*Math.sqrt(z)+15*z));return Math.min(150000,Math.max(state.baseIter,state.baseIter+bonus))}
+function pixelBudget(){const low=Number(navigator.deviceMemory||8)<=4,small=matchMedia('(max-width:700px)').matches;if(!navigator.gpu||state.gpuUnavailable)return 262144;if(state.processMode==='power')return 524288;if(state.processMode==='fine')return(low||small?1572864:3145728);if(state.processMode==='validate')return(low||small?1048576:2097152);return(low||small?786432:1572864)}
+function resize(){const cssW=Math.max(1,innerWidth),cssH=Math.max(1,innerHeight),budget=pixelBudget(),native=Math.max(1,devicePixelRatio||1),bd=Math.sqrt(budget/(cssW*cssH));let dpr=Math.max(Math.min(1,64/Math.max(cssW,cssH)),Math.min(native,bd));if(renderer){const md=Math.max(2,renderer.adapterLimits.maxTextureDimension2D||8192);dpr=Math.min(dpr,md/cssW,md/cssH)}const w=Math.max(2,Math.round(cssW*dpr)),h=Math.max(2,Math.round(cssH*dpr));state.effectiveDpr=dpr;state.screenPixelBudget=budget;if(canvas.width!==w||canvas.height!==h){canvas.width=w;canvas.height=h;if(renderer)renderer.configure();markDirty(false)}}
+
+// ── high precision reference worker ─────────────────────────────────────
+function referenceWorkerSource(){return String.raw`
+'use strict';
+const MAX_REF=150001,MAX_LEVELS=20;
+function bitLen(v){v=v<0n?-v:v;return v===0n?0:v.toString(2).length}
+function roundShift(v,b){const neg=v<0n,a=neg?-v:v,half=1n<<(BigInt(b)-1n),q=(a+half)>>BigInt(b);return neg?-q:q}
+function fixedNum(v,b){if(v===0n)return 0;let neg=v<0n;if(neg)v=-v;const bl=bitLen(v),take=Math.min(53,bl),sh=bl-take,top=Number(v>>BigInt(sh)),n=top*Math.pow(2,sh-b);return neg?-n:n}
+function orbit(bits,re,im,iter){const B=BigInt(bits),ONE=1n<<B,BAIL=16n*ONE;let zr=0n,zi=0n,escape=0,n=0;const rr=new Float64Array(iter+1),ri=new Float64Array(iter+1);for(;n<iter&&!escape;n++){rr[n]=fixedNum(zr,bits);ri[n]=fixedNum(zi,bits);const zr2=roundShift(zr*zr,bits),zi2=roundShift(zi*zi,bits);zi=roundShift(2n*zr*zi,bits)+im;zr=zr2-zi2+re;const mag=roundShift(zr*zr,bits)+roundShift(zi*zi,bits);if(mag>BAIL)escape=n+1}rr[n]=fixedNum(zr,bits);ri[n]=fixedNum(zi,bits);return{rr,ri,refLen:escape||iter,escape}}
+function verify(baseBits,re,im,ref,refLen){const bits=baseBits+64,R=re<<64n,I=im<<64n,B=BigInt(bits),ONE=1n<<B,BAIL=16n*ONE,targets=new Set([0,refLen]);for(let n=1;n<refLen;n*=2)targets.add(n);const stride=Math.max(1,Math.floor(refLen/32));for(let n=stride;n<refLen;n+=stride)targets.add(n);let zr=0n,zi=0n,escape=0,mismatch=false,checked=0;for(let n=0;n<=refLen&&!escape&&!mismatch;n++){if(targets.has(n)){checked++;if(!Object.is(fixedNum(zr,bits),ref.rr[n])||!Object.is(fixedNum(zi,bits),ref.ri[n]))mismatch=true}if(n===refLen)break;const zr2=roundShift(zr*zr,bits),zi2=roundShift(zi*zi,bits);zi=roundShift(2n*zr*zi,bits)+I;zr=zr2-zi2+R;const mag=roundShift(zr*zr,bits)+roundShift(zi*zi,bits);if(mag>BAIL)escape=n+1}return{mismatch,checked}}
+function packRefs(rr,ri,refLen){const buf=new ArrayBuffer((refLen+1)*16),dv=new DataView(buf);for(let i=0;i<=refLen;i++){const hr=Math.fround(rr[i]),hi=Math.fround(ri[i]),lr=Math.fround(rr[i]-hr),li=Math.fround(ri[i]-hi),o=i*16;dv.setFloat32(o,hr,true);dv.setFloat32(o+4,hi,true);dv.setFloat32(o+8,lr,true);dv.setFloat32(o+12,li,true)}return buf}
+self.onmessage=e=>{const d=e.data;if(!d||d.type!=='build')return;const t0=performance.now();try{const bits=d.bits+64,re=BigInt(d.re)<<64n,im=BigInt(d.im)<<64n,ref=orbit(bits,re,im,Math.min(MAX_REF-1,d.iter)),v=verify(bits,re,im,ref,ref.refLen),refs=packRefs(ref.rr,ref.ri,ref.refLen);postMessage({type:'built',id:d.id,key:d.key,refLen:ref.refLen,escape:ref.escape,precisionBits:bits,checkpointMismatch:v.mismatch,checkpointCount:v.checked,buildMs:performance.now()-t0,refs},[refs])}catch(error){postMessage({type:'error',id:d.id,error:String(error&&error.stack||error)})}}
+`}
+class ReferenceService{
+  constructor(){this.worker=null;this.url='';this.serial=0;this.pending=new Map();this.cache=null;this.failed=false}
+  ensure(){if(this.worker)return true;if(this.failed||typeof Worker==='undefined'||typeof Blob==='undefined')return false;try{this.url=URL.createObjectURL(new Blob([referenceWorkerSource()],{type:'text/javascript'}));this.worker=new Worker(this.url);this.worker.onmessage=e=>{const d=e.data,p=this.pending.get(d.id);if(!p)return;this.pending.delete(d.id);if(d.type==='error')p.reject(new Error(d.error));else{runtime.referenceBuilds++;this.cache=d;p.resolve(d)}};this.worker.onerror=e=>{this.failed=true;for(const p of this.pending.values())p.reject(new Error(e.message||'reference worker error'));this.pending.clear();this.destroy()};return true}catch{this.failed=true;return false}}
+  request(snap,iter){const key=[snap.bits,snap.re,snap.im,iter,'guarded-perturb-v24.1'].join(':');if(this.cache&&this.cache.key===key)return Promise.resolve(this.cache);if(this.pending.size)this.cancelPending('superseded reference request');if(!this.ensure())return Promise.reject(new Error('Reference Workerを作成できません'));const id=++this.serial;return new Promise((resolve,reject)=>{this.pending.set(id,{resolve,reject});this.worker.postMessage({type:'build',id,key,bits:snap.bits,re:snap.re.toString(),im:snap.im.toString(),iter})})}
+  cancelPending(reason='cancelled'){if(!this.pending.size)return;for(const p of this.pending.values())p.reject(new Error(reason));this.pending.clear();if(this.worker){try{this.worker.terminate()}catch{}this.worker=null}if(this.url){try{URL.revokeObjectURL(this.url)}catch{}this.url=''}}
+  destroy(){this.cancelPending('destroyed');if(this.worker){try{this.worker.terminate()}catch{}this.worker=null}if(this.url){try{URL.revokeObjectURL(this.url)}catch{}this.url=''}}
+}
+const refs=new ReferenceService();
+
+// ── WebGPU renderer ──────────────────────────────────────────────────────
+function buf(device,size,usage,label){return device.createBuffer({label,size:Math.max(4,Math.ceil(size/4)*4),usage})}
+function destroy(x){if(x&&x.destroy)try{x.destroy()}catch{}}
+function writeU32F32(size,writer){const a=new ArrayBuffer(size),d=new DataView(a);writer(d);return a}
+class WebGpuRenderer{
+  constructor(adapter,device){
+    this.adapter=adapter;this.device=device;
+    const ai=adapter.info||{};
+    this.adapterInfo={vendor:ai.vendor||'',architecture:ai.architecture||'',device:ai.device||'',description:ai.description||''};
+    this.adapterLimits={maxBufferSize:Number(adapter.limits.maxBufferSize),maxStorageBufferBindingSize:Number(adapter.limits.maxStorageBufferBindingSize),maxComputeWorkgroupsPerDimension:Number(adapter.limits.maxComputeWorkgroupsPerDimension),maxTextureDimension2D:Number(adapter.limits.maxTextureDimension2D)};
+    this.context=null;this.format=navigator.gpu.getPreferredCanvasFormat();
+    this.frame=null;this.deepCtx=null;this.exportWs=null;this.compilation=[];this.uncapturedErrors=[];this.lossReason='';this.sampler=device.createSampler({magFilter:'linear',minFilter:'linear'});
+    device.addEventListener?.('uncapturederror',e=>{const msg=String(e.error&&e.error.message||e.error||'WebGPU uncaptured error');this.uncapturedErrors.push(msg);state.gpuError=msg;console.error(e.error||e)});
+    this.ready=this.initPipelines();
+    device.lost.then(info=>{this.lossReason=info.message||info.reason||'device lost';runtime.deviceLosses++;state.gpuError=this.lossReason;renderer=null;markDirty(false);initRenderer()});
+  }
+  configure(){if(this.context)this.context.configure({device:this.device,format:this.format,alphaMode:'opaque'})}
+  async module(label,code){const m=this.device.createShaderModule({label,code});if(m.getCompilationInfo){const info=await m.getCompilationInfo();const errs=info.messages.filter(x=>x.type==='error');this.compilation.push({label,messages:info.messages.map(x=>({type:x.type,line:x.lineNum,message:x.message}))});if(errs.length)throw new Error(label+': '+errs.map(x=>x.message).join('\n'))}return m}
+  async initPipelines(){
+    this.device.pushErrorScope?.('validation');
+    try{
+      const [dm,xm,cm,am,pm]=await Promise.all([this.module('direct',G.DIRECT_F32_WGSL),this.module('deep',G.DEEP_PERTURB_WGSL),this.module('color',G.COLOR_WGSL),this.module('aa-resolve',G.AA_RESOLVE_WGSL),this.module('present',G.PRESENT_WGSL)]);
+      this.direct=this.device.createComputePipeline({layout:'auto',compute:{module:dm,entryPoint:'main'}});
+      this.deep=this.device.createComputePipeline({layout:'auto',compute:{module:xm,entryPoint:'main'}});
+      this.color=this.device.createComputePipeline({layout:'auto',compute:{module:cm,entryPoint:'main'}});
+      this.aaResolve=this.device.createComputePipeline({layout:'auto',compute:{module:am,entryPoint:'main'}});
+      this.present=this.device.createRenderPipeline({layout:'auto',vertex:{module:pm,entryPoint:'vs'},fragment:{module:pm,entryPoint:'fs',targets:[{format:this.format}]},primitive:{topology:'triangle-list'}});
+      this.context=canvas.getContext('webgpu');
+      if(!this.context)throw new Error('WebGPU canvas contextを取得できません');
+      webgpuCanvasClaimed=true;this.configure();
+    }finally{if(this.device.popErrorScope){const error=await this.device.popErrorScope();if(error)throw error}}
+  }
+  frameDestroy(){if(!this.frame)return;for(const k of ['meta','smooth','unresolved','numericParams','colorParams','presentParams','front','back'])destroy(this.frame[k]);this.frame=null}
+  ensureFrame(w,h){
+    const n=w*h;if(this.frame&&this.frame.w===w&&this.frame.h===h)return this.frame;this.frameDestroy();const d=this.device,B=GPUBufferUsage,T=GPUTextureUsage;
+    this.frame={w,h,n,meta:buf(d,n*4,B.STORAGE|B.COPY_SRC|B.COPY_DST,'field-meta'),smooth:buf(d,n*4,B.STORAGE|B.COPY_SRC|B.COPY_DST,'field-smooth'),unresolved:buf(d,16,B.STORAGE|B.COPY_SRC|B.COPY_DST,'unresolved-count'),numericParams:buf(d,64,B.UNIFORM|B.COPY_DST,'numeric-params'),colorParams:buf(d,32,B.UNIFORM|B.COPY_DST,'color-params'),presentParams:buf(d,16,B.UNIFORM|B.COPY_DST,'present-params'),front:d.createTexture({size:[w,h],format:'rgba8unorm',usage:T.STORAGE_BINDING|T.TEXTURE_BINDING|T.COPY_SRC,label:'front-color'}),back:d.createTexture({size:[w,h],format:'rgba8unorm',usage:T.STORAGE_BINDING|T.TEXTURE_BINDING|T.COPY_SRC,label:'back-color'})};return this.frame;
+  }
+  ensureExportWorkspace(){
+    if(this.exportWs)return this.exportWs;const d=this.device,B=GPUBufferUsage,T=GPUTextureUsage,S=512,n=S*S,bpr=S*4,pixelBytes=bpr*S;
+    this.exportWs={size:S,meta:buf(d,n*4,B.STORAGE|B.COPY_DST,'export-meta'),smooth:buf(d,n*4,B.STORAGE|B.COPY_DST,'export-smooth'),unresolved:buf(d,16,B.STORAGE|B.COPY_SRC|B.COPY_DST,'export-unresolved'),pbufs:Array.from({length:4},(_,i)=>buf(d,64,B.UNIFORM|B.COPY_DST,'export-numeric-'+i)),cbuf:buf(d,32,B.UNIFORM|B.COPY_DST,'export-color'),samples:Array.from({length:4},(_,i)=>d.createTexture({label:'export-sample-'+i,size:[S,S],format:'rgba8unorm',usage:T.STORAGE_BINDING|T.TEXTURE_BINDING})),tex:d.createTexture({label:'export-resolve',size:[S,S],format:'rgba8unorm',usage:T.STORAGE_BINDING|T.COPY_SRC}),read:buf(d,pixelBytes+16,B.COPY_DST|B.MAP_READ,'export-readback')};return this.exportWs;
+  }
+  exportWorkspaceDestroy(){if(!this.exportWs)return;for(const k of ['meta','smooth','unresolved','cbuf','tex','read'])destroy(this.exportWs[k]);for(const b of this.exportWs.pbufs)destroy(b);for(const t of this.exportWs.samples)destroy(t);this.exportWs=null}
+  setDeepContext(ctx){if(this.deepCtx&&this.deepCtx.key===ctx.key)return;this.destroyDeepContext();const d=this.device,B=GPUBufferUsage,refsB=buf(d,ctx.refs.byteLength,B.STORAGE|B.COPY_DST,'reference-orbit');d.queue.writeBuffer(refsB,0,ctx.refs);this.deepCtx={...ctx,refsB}}
+  destroyDeepContext(){if(this.deepCtx)destroy(this.deepCtx.refsB);this.deepCtx=null}
+  directParams(w,h,fullW,fullH,tileX,tileY,iter,snap,sx=.5,sy=.5,strict=0){return writeU32F32(64,d=>{[w,h,fullW,fullH,tileX,tileY,iter,strict].forEach((v,i)=>d.setUint32(i*4,v,true));d.setFloat32(32,Math.fround(fixedNum(snap.re,snap.bits)),true);d.setFloat32(36,Math.fround(fixedNum(snap.im,snap.bits)),true);d.setFloat32(40,Math.fround(fixedNum(snap.span,snap.bits)),true);d.setFloat32(44,sx,true);d.setFloat32(48,sy,true)})}
+  deepParams(w,h,fullW,fullH,tileX,tileY,iter,snap,sx=.5,sy=.5,strict=0){const se=spanMantExp(snap);return writeU32F32(64,d=>{[w,h,fullW,fullH,tileX,tileY,iter,this.deepCtx.refLen,strict,0,0,0].forEach((v,i)=>d.setUint32(i*4,v,true));d.setFloat32(48,Math.fround(se.mant),true);d.setInt32(52,se.exp,true);d.setFloat32(56,sx,true);d.setFloat32(60,sy,true)})}
+  colorParamsData(w,h){return writeU32F32(32,d=>{d.setUint32(0,w,true);d.setUint32(4,h,true);d.setUint32(8,state.palette,true);d.setUint32(12,state.hq?1:0,true);d.setFloat32(16,state.cycle,true);d.setFloat32(20,state.shift,true)})}
+  async computeFrame(snap,iter,deep,deepContext,token,forceStrict=false){
+    await this.ready;const f=this.ensureFrame(canvas.width,canvas.height),d=this.device;if(deep)this.setDeepContext(deepContext);d.queue.writeBuffer(f.unresolved,0,new Uint32Array(4));
+    d.queue.writeBuffer(f.numericParams,0,deep?this.deepParams(f.w,f.h,f.w,f.h,0,0,iter,snap,.5,.5,forceStrict?1:0):this.directParams(f.w,f.h,f.w,f.h,0,0,iter,snap));
+    d.queue.writeBuffer(f.colorParams,0,this.colorParamsData(f.w,f.h));const encoder=d.createCommandEncoder({label:'mandelbrot-frame'});
+    if(deep){const bg=d.createBindGroup({layout:this.deep.getBindGroupLayout(0),entries:[{binding:0,resource:{buffer:f.numericParams}},{binding:1,resource:{buffer:this.deepCtx.refsB}},{binding:2,resource:{buffer:f.meta}},{binding:3,resource:{buffer:f.smooth}},{binding:4,resource:{buffer:f.unresolved}}]}),pass=encoder.beginComputePass();pass.setPipeline(this.deep);pass.setBindGroup(0,bg);pass.dispatchWorkgroups(Math.ceil(f.w/8),Math.ceil(f.h/8));pass.end();}
+    else{const bg=d.createBindGroup({layout:this.direct.getBindGroupLayout(0),entries:[{binding:0,resource:{buffer:f.numericParams}},{binding:1,resource:{buffer:f.meta}},{binding:2,resource:{buffer:f.smooth}}]}),pass=encoder.beginComputePass();pass.setPipeline(this.direct);pass.setBindGroup(0,bg);pass.dispatchWorkgroups(Math.ceil(f.w/8),Math.ceil(f.h/8));pass.end();}
+    const cbg=d.createBindGroup({layout:this.color.getBindGroupLayout(0),entries:[{binding:0,resource:{buffer:f.colorParams}},{binding:1,resource:{buffer:f.meta}},{binding:2,resource:{buffer:f.smooth}},{binding:3,resource:f.back.createView()}]}),cp=encoder.beginComputePass();cp.setPipeline(this.color);cp.setBindGroup(0,cbg);cp.dispatchWorkgroups(Math.ceil(f.w/8),Math.ceil(f.h/8));cp.end();
+    d.queue.submit([encoder.finish()]);await d.queue.onSubmittedWorkDone();if(token!==state.token)return false;[f.front,f.back]=[f.back,f.front];runtime.gpuFrames++;return true;
+  }
+  async recolor(token){await this.ready;if(!this.frame)return false;const f=this.frame,d=this.device;d.queue.writeBuffer(f.colorParams,0,this.colorParamsData(f.w,f.h));const e=d.createCommandEncoder(),bg=d.createBindGroup({layout:this.color.getBindGroupLayout(0),entries:[{binding:0,resource:{buffer:f.colorParams}},{binding:1,resource:{buffer:f.meta}},{binding:2,resource:{buffer:f.smooth}},{binding:3,resource:f.back.createView()}]}),p=e.beginComputePass();p.setPipeline(this.color);p.setBindGroup(0,bg);p.dispatchWorkgroups(Math.ceil(f.w/8),Math.ceil(f.h/8));p.end();d.queue.submit([e.finish()]);await d.queue.onSubmittedWorkDone();if(token!==state.token)return false;[f.front,f.back]=[f.back,f.front];runtime.gpuRecolors++;return true}
+  presentTransform(view=state.frameView){if(!this.frame||!view)return{scaleX:1,scaleY:1,offsetX:0,offsetY:0};const cur=snapshot(),b=Math.max(cur.bits,view.bits),cs=align(cur.span,cur.bits,b),ps=align(view.span,view.bits,b),dr=align(cur.re,cur.bits,b)-align(view.re,view.bits,b),di=align(cur.im,cur.bits,b)-align(view.im,view.bits,b),scale=fixedRatio(cs,ps);return{scaleX:scale,scaleY:scale,offsetX:fixedRatio(dr,ps),offsetY:-fixedRatio(di,ps)*this.frame.w/Math.max(1,this.frame.h)}}
+  presentFrame(transform=this.presentTransform()){if(!this.frame)return;const d=this.device,pb=this.frame.presentParams;d.queue.writeBuffer(pb,0,new Float32Array([transform.scaleX,transform.scaleY,transform.offsetX,transform.offsetY]));const bg=d.createBindGroup({layout:this.present.getBindGroupLayout(0),entries:[{binding:0,resource:this.sampler},{binding:1,resource:this.frame.front.createView()},{binding:2,resource:{buffer:pb}}]}),e=d.createCommandEncoder(),pass=e.beginRenderPass({colorAttachments:[{view:this.context.getCurrentTexture().createView(),clearValue:{r:.0196,g:.0314,b:.0745,a:1},loadOp:'clear',storeOp:'store'}]});pass.setPipeline(this.present);pass.setBindGroup(0,bg);pass.draw(3);pass.end();d.queue.submit([e.finish()])}
+  async readMeta(indices){if(!this.frame||!indices.length)return new Uint32Array();const d=this.device,B=GPUBufferUsage,r=buf(d,indices.length*4,B.COPY_DST|B.MAP_READ),e=d.createCommandEncoder();for(let i=0;i<indices.length;i++)e.copyBufferToBuffer(this.frame.meta,indices[i]*4,r,i*4,4);d.queue.submit([e.finish()]);await r.mapAsync(GPUMapMode.READ);const out=new Uint32Array(r.getMappedRange().slice(0));r.unmap();destroy(r);return out}
+  async readUnresolved(){if(!this.frame)return 0;const d=this.device,B=GPUBufferUsage,r=buf(d,16,B.COPY_DST|B.MAP_READ),e=d.createCommandEncoder();e.copyBufferToBuffer(this.frame.unresolved,0,r,0,16);d.queue.submit([e.finish()]);await r.mapAsync(GPUMapMode.READ);const value=new Uint32Array(r.getMappedRange().slice(0))[0];r.unmap();destroy(r);return value}
+  async renderTileMeta({snap,iter,deep,deepContext,fullW,fullH,tileX=0,tileY=0,w,h,sampleX=.5,sampleY=.5,forceStrict=false}){
+    await this.ready;if(deep)this.setDeepContext(deepContext);const d=this.device,B=GPUBufferUsage,n=w*h,meta=buf(d,n*4,B.STORAGE|B.COPY_SRC|B.COPY_DST),smooth=buf(d,n*4,B.STORAGE|B.COPY_DST),unresolved=buf(d,16,B.STORAGE|B.COPY_DST),pbuf=buf(d,64,B.UNIFORM|B.COPY_DST),encoder=d.createCommandEncoder({label:'numeric-probe'});d.queue.writeBuffer(unresolved,0,new Uint32Array(4));
+    if(deep){d.queue.writeBuffer(pbuf,0,this.deepParams(w,h,fullW,fullH,tileX,tileY,iter,snap,sampleX,sampleY,forceStrict?1:0));const bg=d.createBindGroup({layout:this.deep.getBindGroupLayout(0),entries:[{binding:0,resource:{buffer:pbuf}},{binding:1,resource:{buffer:this.deepCtx.refsB}},{binding:2,resource:{buffer:meta}},{binding:3,resource:{buffer:smooth}},{binding:4,resource:{buffer:unresolved}}]}),pass=encoder.beginComputePass();pass.setPipeline(this.deep);pass.setBindGroup(0,bg);pass.dispatchWorkgroups(Math.ceil(w/8),Math.ceil(h/8));pass.end();}
+    else{d.queue.writeBuffer(pbuf,0,this.directParams(w,h,fullW,fullH,tileX,tileY,iter,snap,sampleX,sampleY));const bg=d.createBindGroup({layout:this.direct.getBindGroupLayout(0),entries:[{binding:0,resource:{buffer:pbuf}},{binding:1,resource:{buffer:meta}},{binding:2,resource:{buffer:smooth}}]}),pass=encoder.beginComputePass();pass.setPipeline(this.direct);pass.setBindGroup(0,bg);pass.dispatchWorkgroups(Math.ceil(w/8),Math.ceil(h/8));pass.end();}
+    const read=buf(d,n*4,B.COPY_DST|B.MAP_READ);encoder.copyBufferToBuffer(meta,0,read,0,n*4);d.queue.submit([encoder.finish()]);await read.mapAsync(GPUMapMode.READ);const out=new Uint32Array(read.getMappedRange().slice(0));read.unmap();[meta,smooth,unresolved,pbuf,read].forEach(destroy);return out;
+  }
+  async renderTileRGBA({snap,iter,deep,deepContext,fullW,fullH,tileX,tileY,w,h,sampleX=.5,sampleY=.5,edgeAA=false,forceStrict=false}){
+    await this.ready;if(w>512||h>512)throw new Error('export tile exceeds reusable workspace');if(deep)this.setDeepContext(deepContext);const d=this.device,ws=this.ensureExportWorkspace(),meta=ws.meta,smooth=ws.smooth,unresolved=ws.unresolved,pbuf=ws.pbufs[0],tex=ws.tex,encoder=d.createCommandEncoder();d.queue.writeBuffer(unresolved,0,new Uint32Array(4));
+    if(deep){d.queue.writeBuffer(pbuf,0,this.deepParams(w,h,fullW,fullH,tileX,tileY,iter,snap,sampleX,sampleY,forceStrict?1:0));const bg=d.createBindGroup({layout:this.deep.getBindGroupLayout(0),entries:[{binding:0,resource:{buffer:pbuf}},{binding:1,resource:{buffer:this.deepCtx.refsB}},{binding:2,resource:{buffer:meta}},{binding:3,resource:{buffer:smooth}},{binding:4,resource:{buffer:unresolved}}]}),p=encoder.beginComputePass();p.setPipeline(this.deep);p.setBindGroup(0,bg);p.dispatchWorkgroups(Math.ceil(w/8),Math.ceil(h/8));p.end();}
+    else{d.queue.writeBuffer(pbuf,0,this.directParams(w,h,fullW,fullH,tileX,tileY,iter,snap,sampleX,sampleY));const bg=d.createBindGroup({layout:this.direct.getBindGroupLayout(0),entries:[{binding:0,resource:{buffer:pbuf}},{binding:1,resource:{buffer:meta}},{binding:2,resource:{buffer:smooth}}]}),p=encoder.beginComputePass();p.setPipeline(this.direct);p.setBindGroup(0,bg);p.dispatchWorkgroups(Math.ceil(w/8),Math.ceil(h/8));p.end();}
+    const ca=this.colorParamsData(w,h),cd=new DataView(ca);cd.setUint32(12,edgeAA?1:0,true);d.queue.writeBuffer(ws.cbuf,0,ca);const cbg=d.createBindGroup({layout:this.color.getBindGroupLayout(0),entries:[{binding:0,resource:{buffer:ws.cbuf}},{binding:1,resource:{buffer:meta}},{binding:2,resource:{buffer:smooth}},{binding:3,resource:tex.createView()}]}),cp=encoder.beginComputePass();cp.setPipeline(this.color);cp.setBindGroup(0,cbg);cp.dispatchWorkgroups(Math.ceil(w/8),Math.ceil(h/8));cp.end();
+    const bpr=Math.ceil(w*4/256)*256,pixelBytes=bpr*h;encoder.copyTextureToBuffer({texture:tex},{buffer:ws.read,bytesPerRow:bpr,rowsPerImage:h},{width:w,height:h});encoder.copyBufferToBuffer(unresolved,0,ws.read,pixelBytes,16);d.queue.submit([encoder.finish()]);await ws.read.mapAsync(GPUMapMode.READ,0,pixelBytes+16);const raw=new Uint8Array(ws.read.getMappedRange(0,pixelBytes+16)),out=new Uint8ClampedArray(w*h*4);for(let y=0;y<h;y++)out.set(raw.subarray(y*bpr,y*bpr+w*4),y*w*4);const unresolvedCount=new DataView(raw.buffer,raw.byteOffset+pixelBytes,16).getUint32(0,true);ws.read.unmap();return{rgba:out,unresolved:unresolvedCount};
+  }
+  async renderTileRGBA2x({snap,iter,deep,deepContext,fullW,fullH,tileX,tileY,w,h,forceStrict=false}){
+    await this.ready;if(w>512||h>512)throw new Error('export tile exceeds reusable workspace');if(deep)this.setDeepContext(deepContext);const d=this.device,ws=this.ensureExportWorkspace(),meta=ws.meta,smooth=ws.smooth,unresolved=ws.unresolved,encoder=d.createCommandEncoder({label:'export-aa2x'}),offsets=[[.25,.25],[.75,.25],[.25,.75],[.75,.75]],ca=this.colorParamsData(w,h);new DataView(ca).setUint32(12,0,true);d.queue.writeBuffer(ws.cbuf,0,ca);d.queue.writeBuffer(unresolved,0,new Uint32Array(4));
+    for(let si=0;si<4;si++){const [sampleX,sampleY]=offsets[si],pbuf=ws.pbufs[si];if(deep){d.queue.writeBuffer(pbuf,0,this.deepParams(w,h,fullW,fullH,tileX,tileY,iter,snap,sampleX,sampleY,forceStrict?1:0));const bg=d.createBindGroup({layout:this.deep.getBindGroupLayout(0),entries:[{binding:0,resource:{buffer:pbuf}},{binding:1,resource:{buffer:this.deepCtx.refsB}},{binding:2,resource:{buffer:meta}},{binding:3,resource:{buffer:smooth}},{binding:4,resource:{buffer:unresolved}}]}),pass=encoder.beginComputePass();pass.setPipeline(this.deep);pass.setBindGroup(0,bg);pass.dispatchWorkgroups(Math.ceil(w/8),Math.ceil(h/8));pass.end();}else{d.queue.writeBuffer(pbuf,0,this.directParams(w,h,fullW,fullH,tileX,tileY,iter,snap,sampleX,sampleY));const bg=d.createBindGroup({layout:this.direct.getBindGroupLayout(0),entries:[{binding:0,resource:{buffer:pbuf}},{binding:1,resource:{buffer:meta}},{binding:2,resource:{buffer:smooth}}]}),pass=encoder.beginComputePass();pass.setPipeline(this.direct);pass.setBindGroup(0,bg);pass.dispatchWorkgroups(Math.ceil(w/8),Math.ceil(h/8));pass.end();}const cbg=d.createBindGroup({layout:this.color.getBindGroupLayout(0),entries:[{binding:0,resource:{buffer:ws.cbuf}},{binding:1,resource:{buffer:meta}},{binding:2,resource:{buffer:smooth}},{binding:3,resource:ws.samples[si].createView()}]}),cp=encoder.beginComputePass();cp.setPipeline(this.color);cp.setBindGroup(0,cbg);cp.dispatchWorkgroups(Math.ceil(w/8),Math.ceil(h/8));cp.end();}
+    const abg=d.createBindGroup({layout:this.aaResolve.getBindGroupLayout(0),entries:[{binding:0,resource:ws.samples[0].createView()},{binding:1,resource:ws.samples[1].createView()},{binding:2,resource:ws.samples[2].createView()},{binding:3,resource:ws.samples[3].createView()},{binding:4,resource:ws.tex.createView()}]}),ap=encoder.beginComputePass();ap.setPipeline(this.aaResolve);ap.setBindGroup(0,abg);ap.dispatchWorkgroups(Math.ceil(w/8),Math.ceil(h/8));ap.end();
+    const bpr=Math.ceil(w*4/256)*256,pixelBytes=bpr*h;encoder.copyTextureToBuffer({texture:ws.tex},{buffer:ws.read,bytesPerRow:bpr,rowsPerImage:h},{width:w,height:h});encoder.copyBufferToBuffer(unresolved,0,ws.read,pixelBytes,16);d.queue.submit([encoder.finish()]);await ws.read.mapAsync(GPUMapMode.READ,0,pixelBytes+16);const raw=new Uint8Array(ws.read.getMappedRange(0,pixelBytes+16)),out=new Uint8ClampedArray(w*h*4);for(let y=0;y<h;y++)out.set(raw.subarray(y*bpr,y*bpr+w*4),y*w*4);const unresolvedCount=new DataView(raw.buffer,raw.byteOffset+pixelBytes,16).getUint32(0,true);ws.read.unmap();return{rgba:out,unresolved:unresolvedCount};
+  }
+  destroy(){this.frameDestroy();this.exportWorkspaceDestroy();this.destroyDeepContext()}
+}
+
+// ── GPU startup / rendering orchestration ────────────────────────────────
+async function initRenderer(){if(renderer)return renderer;if(rendererInitPromise)return rendererInitPromise;if(state.gpuInitFailed)return null;if(!navigator.gpu){state.gpuInitFailed=false;state.gpuUnavailable=true;state.gpuError='WebGPU非対応';ensureFallback();return null}rendererInitPromise=(async()=>{try{let adapter=await navigator.gpu.requestAdapter({powerPreference:'high-performance'});if(!adapter)adapter=await navigator.gpu.requestAdapter();if(!adapter){state.gpuInitFailed=false;state.gpuUnavailable=true;state.gpuError='WebGPU adapterがありません';ensureFallback();return null}const device=await adapter.requestDevice();const r=new WebGpuRenderer(adapter,device);await r.ready;renderer=r;state.gpuInitFailed=false;state.gpuUnavailable=false;state.gpuError='';resize();markDirty(false);return r}catch(e){state.gpuInitFailed=true;state.gpuError='WebGPU初期化失敗: '+String(e&&e.message||e);updateStats();return null}finally{rendererInitPromise=null}})();return rendererInitPromise}
+function ensureFallback(){if(fallbackCtx)return fallbackCtx;if(webgpuCanvasClaimed)return null;try{fallbackCtx=canvas.getContext('2d',{alpha:false})}catch{}return fallbackCtx}
+function cancelRender(){state.token++;state.rendering=false;state.recolorPending=false;refs.cancelPending('render cancelled')}
+function markDirty(cancel=true){if(cancel)cancelRender();state.dirty=true;state.lastInteraction=performance.now();state.drawState=state.frameView?'REPROJECTED':'PREVIEW';schedule()}
+function schedule(){if(!raf)raf=requestAnimationFrame(loop)}
+async function renderFrame(){const token=++state.token,snap=snapshot(),iter=maxIter(),deep=deepNeeded(snap,canvas.width),t0=performance.now();state.rendering=true;state.dirty=false;state.drawState='COVERING';runtime.renderStarts++;updateStats();try{const r=renderer||await initRenderer();if(token!==state.token)return;if(!r){if(state.gpuInitFailed){state.rendering=false;state.drawState='ERROR';state.lastEngine='WebGPU shader/pipeline error';updateStats();return}renderFallback(token,snap,iter);return}let ctx=null;if(deep){state.lastEngine='WebGPU · reference準備';updateStats();ctx=await refs.request(snap,iter);if(token!==state.token)return;if(ctx.checkpointMismatch)throw new Error('reference guard checkpoint mismatch');state.lastEngine='WebGPU · guarded rescaled perturbation'}else state.lastEngine='WebGPU · f32 direct';const ok=await r.computeFrame(snap,iter,deep,ctx,token,state.processMode==='validate');if(!ok)return;state.frameView=snap;state.fieldView={...snap,iter,w:canvas.width,h:canvas.height,deep};state.drawState=state.hq?'REFINED':'COVERED';state.lastRender=performance.now()-t0;state.rendering=false;state.unresolved=0;const pendingColor=state.recolorPending;if(pendingColor){state.recolorPending=false;recolor()}else r.presentFrame({scaleX:1,scaleY:1,offsetX:0,offsetY:0});updateStats();if(deep)r.readUnresolved().then(q=>{if(token===state.token){state.unresolved=q||0;updateStats()}}).catch(()=>{})}catch(e){if(token!==state.token)return;state.rendering=false;state.gpuError=String(e&&e.message||e);state.lastEngine='WebGPU error';updateStats();console.error(e)}}
+function renderFallback(token,snap,iter){const ctx=ensureFallback();if(!ctx){state.rendering=false;return}const w=canvas.width,h=canvas.height;if(deepNeeded(snap,w)){state.rendering=false;state.gpuError='このズーム深度はWebGPUが必要です';state.lastEngine='Fallback · deep unsupported';updateStats();return}const img=ctx.createImageData(w,h),out=img.data,cre=fixedNum(snap.re,snap.bits),cim=fixedNum(snap.im,snap.bits),sp=fixedNum(snap.span,snap.bits),scale=sp/w;let y=0;function slice(){if(token!==state.token)return;const end=performance.now()+8;while(y<h&&performance.now()<end){for(let x=0;x<w;x++){const cr=cre+(x+.5-w*.5)*scale,ci=cim+(h*.5-y-.5)*scale;let zr=0,zi=0,n=0,mag=0;while(n<iter&&mag<=4){const zr2=zr*zr,zi2=zi*zi;zi=2*zr*zi+ci;zr=zr2-zi2+cr;mag=zr*zr+zi*zi;n++}const o=(y*w+x)*4;if(n>=iter){out[o]=out[o+1]=out[o+2]=0}else{const t=(n+1-Math.log2(.5*Math.log2(Math.max(4.0001,mag))))*.008+state.shift;out[o]=255*(.3+.7*(.5+.5*Math.cos(6.28318*t)));out[o+1]=255*(.25+.75*(.5+.5*Math.cos(6.28318*(t+.33))));out[o+2]=255*(.2+.8*(.5+.5*Math.cos(6.28318*(t+.67))))}out[o+3]=255}y++}if(y<h)requestAnimationFrame(slice);else{ctx.putImageData(img,0,0);state.frameView=snap;state.rendering=false;state.lastRender=0;state.lastEngine='JavaScript f64 fallback（深部非対応）';state.drawState='COVERED';updateStats()}}requestAnimationFrame(slice)}
+async function recolor(){state.recolorPending=true;if(!renderer||!state.fieldView||state.rendering||state.recoloring)return false;state.recoloring=true;let painted=false;try{while(state.recolorPending&&!state.rendering&&renderer&&state.fieldView){state.recolorPending=false;const token=state.token,ok=await renderer.recolor(token);if(!ok||token!==state.token)continue;renderer.presentFrame({scaleX:1,scaleY:1,offsetX:0,offsetY:0});painted=true;updateStats()}return painted}catch(e){console.error(e);return false}finally{state.recoloring=false;if(state.recolorPending&&!state.rendering)queueMicrotask(recolor)}}
+function loop(){raf=0;if(state.pointerActive||state.wheelActive){if(renderer&&state.frameView)renderer.presentFrame(renderer.presentTransform());updateStats();return}if(state.dirty&&!state.rendering)renderFrame();else if(renderer&&state.frameView)renderer.presentFrame(renderer.presentTransform())}
+
+// ── interaction / view history ──────────────────────────────────────────
+function viewRect(){return canvas.getBoundingClientRect()}
+function updateFocus(x,y){const r=viewRect();state.focusX=Math.max(0,Math.min(1,(x-r.left)/Math.max(1,r.width)));state.focusY=Math.max(0,Math.min(1,(y-r.top)/Math.max(1,r.height)))}
+function zoomAt(x,y,factor){const r=viewRect(),fx=(x-r.left)/Math.max(1,r.width)-.5,fy=(y-r.top)/Math.max(1,r.height)-.5;factor=Math.max(.01,Math.min(100,factor));const old=state.span,neu=mulRatio(old,factor),dx=BigInt(Math.round(fx*1e9)),dy=BigInt(Math.round(fy*1e9));state.re+=(old-neu)*dx/1000000000n;const oldY=old*BigInt(canvas.height)/BigInt(Math.max(1,canvas.width)),newY=neu*BigInt(canvas.height)/BigInt(Math.max(1,canvas.width));state.im-=(oldY-newY)*dy/1000000000n;state.span=neu;ensurePrecision();state.dirty=true;schedule()}
+function pan(dx,dy){const w=Math.max(1,canvas.clientWidth),h=Math.max(1,canvas.clientHeight);state.re-=state.span*BigInt(Math.round(dx*1e6))/BigInt(Math.round(w*1e6));const ys=state.span*BigInt(canvas.height)/BigInt(Math.max(1,canvas.width));state.im+=ys*BigInt(Math.round(dy*1e6))/BigInt(Math.round(h*1e6));ensurePrecision();state.dirty=true;schedule()}
+function reset(){state.bits=INITIAL_BITS;state.re=-fromFrac(1n,2n);state.im=0n;state.span=fromFrac(34n,10n);ensurePrecision();markDirty();saveHash(false)}
+const pts=new Map();let lx=0,ly=0,pinch=0;
+canvas.addEventListener('wheel',e=>{e.preventDefault();updateFocus(e.clientX,e.clientY);if(!state.wheelActive){cancelRender();state.wheelActive=true}zoomAt(e.clientX,e.clientY,Math.exp(e.deltaY*.00125));clearTimeout(settleTimer);settleTimer=setTimeout(()=>{state.wheelActive=false;recordView();saveHash(false);markDirty()},110)},{passive:false});
+canvas.addEventListener('pointerdown',e=>{updateFocus(e.clientX,e.clientY);try{canvas.setPointerCapture(e.pointerId)}catch{};if(!pts.size){cancelRender();state.pointerActive=true}pts.set(e.pointerId,[e.clientX,e.clientY]);if(pts.size===1){lx=e.clientX;ly=e.clientY}else{const a=[...pts.values()];pinch=Math.hypot(a[0][0]-a[1][0],a[0][1]-a[1][1])}});
+canvas.addEventListener('pointermove',e=>{if(!pts.has(e.pointerId))return;updateFocus(e.clientX,e.clientY);pts.set(e.pointerId,[e.clientX,e.clientY]);if(pts.size===1){const dx=e.clientX-lx,dy=e.clientY-ly;pan(dx,dy);lx=e.clientX;ly=e.clientY}else if(pts.size===2){const a=[...pts.values()],d=Math.hypot(a[0][0]-a[1][0],a[0][1]-a[1][1]);if(pinch>0&&d>0)zoomAt((a[0][0]+a[1][0])/2,(a[0][1]+a[1][1])/2,pinch/d);pinch=d}});
+function endPointer(e){pts.delete(e.pointerId);pinch=0;if(pts.size)return;clearTimeout(settleTimer);settleTimer=setTimeout(()=>{state.pointerActive=false;recordView();saveHash(false);markDirty()},90)}canvas.addEventListener('pointerup',endPointer);canvas.addEventListener('pointercancel',endPointer);
+
+// ── URL / controls ───────────────────────────────────────────────────────
+function saveHash(push){const p=new URLSearchParams();p.set('v',String(VERSION));p.set('b',String(state.bits));p.set('re',state.re.toString());p.set('im',state.im.toString());p.set('sp',state.span.toString());p.set('pal',String(state.palette));p.set('cy',String(state.cycle));p.set('sh',String(state.shift));p.set('it',String(state.baseIter));p.set('ad',state.adaptive?'1':'0');const h='#'+p.toString();lastWrittenHash=h;try{push?history.pushState(null,'',h):history.replaceState(null,'',h)}catch{location.hash=h}}
 function loadHash(){const p=new URLSearchParams(location.hash.slice(1));if(!p.has('b'))return false;try{const b=Number(p.get('b')),re=BigInt(p.get('re')),im=BigInt(p.get('im')),sp=BigInt(p.get('sp'));if(!Number.isInteger(b)||b<64||sp<=0n)return false;state.bits=b;state.re=re;state.im=im;state.span=sp;if(p.has('pal'))state.palette=Math.max(0,Math.min(2,Number(p.get('pal'))|0));if(p.has('cy'))state.cycle=Math.max(.001,Math.min(.05,Number(p.get('cy'))||.008));if(p.has('sh'))state.shift=Math.max(0,Math.min(1,Number(p.get('sh'))||0));if(p.has('it'))state.baseIter=Math.max(100,Math.min(2500,Number(p.get('it'))||350));if(p.has('ad'))state.adaptive=p.get('ad')!=='0';ensurePrecision();return true}catch{return false}}
-function syncControls(){$('#processMode').value=state.processMode;$('#palette').value=String(state.palette);$('#cycle').value=String(state.cycle);$('#cycleO').textContent=state.cycle.toFixed(4);$('#shift').value=String(state.shift);$('#shiftO').textContent=state.shift.toFixed(2);$('#iters').value=String(state.baseIter);$('#itersO').textContent=String(Math.round(state.baseIter));$('#adaptive').checked=state.adaptive;$('#hq').checked=state.hq;syncCoordinateInputs();syncHistoryButtons()}
-function applyHashNavigation(){const h=location.hash;if(h===lastWrittenHash){lastWrittenHash='';return}if(h===navigationHash)return;navigationHash=h;setTimeout(()=>{navigationHash=''},0);if(loadHash()){clearDetailCache();clearPanReuse();recordView();syncControls();setDirty()}}
+function syncCoordinateInputs(){$('#coordReInput').value=fmtFixedExact(state.re);$('#coordImInput').value=fmtFixedExact(state.im);$('#coordSpanInput').value=fmtFixedExact(state.span)}
+function syncHistoryButtons(){$('#undoView').disabled=viewHistoryIndex<=0;$('#redoView').disabled=viewHistoryIndex<0||viewHistoryIndex>=viewHistory.length-1}
+function syncControls(){$('#processMode').value=state.processMode;$('#palette').value=String(state.palette);$('#cycle').value=String(state.cycle);$('#cycleO').textContent=state.cycle.toFixed(4);$('#shift').value=String(state.shift);$('#shiftO').textContent=state.shift.toFixed(2);$('#iters').value=String(state.baseIter);$('#itersO').textContent=String(state.baseIter);$('#adaptive').checked=state.adaptive;$('#hq').checked=state.hq;syncCoordinateInputs();syncHistoryButtons()}
+function toast(s){const e=$('#toast');e.textContent=s;e.classList.add('show');setTimeout(()=>e.classList.remove('show'),1500)}
+function applyUi(){document.body.classList.toggle('ui-hidden',state.uiHidden);$('#uiToggle').textContent=state.uiHidden?'UI＋':'UI−';$('#uiToggle').setAttribute('aria-expanded',state.uiHidden?'false':'true')}
+$('#uiToggle').onclick=()=>{state.uiHidden=!state.uiHidden;try{localStorage.setItem('mandelbrot.uiHidden',state.uiHidden?'1':'0')}catch{}applyUi()};
+$('#zin').onclick=()=>{const r=viewRect();zoomAt(r.left+r.width/2,r.top+r.height/2,.5);recordView();saveHash(false);markDirty()};$('#zout').onclick=()=>{const r=viewRect();zoomAt(r.left+r.width/2,r.top+r.height/2,2);recordView();saveHash(false);markDirty()};$('#reset').onclick=()=>{reset();recordView();syncControls()};
 $('#share').onclick=async()=>{saveHash(true);try{await navigator.clipboard.writeText(location.href);toast('共有URLをコピーしました')}catch{toast('URLを更新しました')}};
-$('#coordApply').onclick=()=>{try{const values=[$('#coordReInput').value,$('#coordImInput').value,$('#coordSpanInput').value],required=Math.max(...values.map(decimalRequiredBits));if(required>state.bits)promoteState(Math.ceil((required-state.bits)/64)*64);const re=fromDec(values[0]),im=fromDec(values[1]),span=fromDec(values[2]);if(span<=0n)throw new Error('表示幅は正数にしてください');state.re=re;state.im=im;state.span=span;ensurePrecision();recordView();saveHash(false);setDirty()}catch(e){toast('座標を適用できません: '+String(e&&e.message||e))}};
-$('#coordCopy').onclick=async()=>{const value=JSON.stringify({rendererVersion:23,bits:state.bits,re:state.re.toString(),im:state.im.toString(),span:state.span.toString(),decimal:{re:fmtFixedExact(state.re),im:fmtFixedExact(state.im),span:fmtFixedExact(state.span)}});try{await navigator.clipboard.writeText(value);toast('正確な座標をコピーしました')}catch{toast('コピーできませんでした')}};
+$('#coordApply').onclick=()=>{try{const values=[$('#coordReInput').value,$('#coordImInput').value,$('#coordSpanInput').value],required=Math.max(...values.map(decimalRequiredBits));if(required>state.bits)promoteState(Math.ceil((required-state.bits)/64)*64);const re=fromDec(values[0]),im=fromDec(values[1]),span=fromDec(values[2]);if(span<=0n)throw new Error('表示幅は正数にしてください');state.re=re;state.im=im;state.span=span;ensurePrecision();recordView();saveHash(false);markDirty()}catch(e){toast('座標を適用できません: '+String(e&&e.message||e))}};
+$('#coordCopy').onclick=async()=>{const value=JSON.stringify({rendererVersion:VERSION,bits:state.bits,re:state.re.toString(),im:state.im.toString(),span:state.span.toString(),decimal:{re:fmtFixedExact(state.re),im:fmtFixedExact(state.im),span:fmtFixedExact(state.span)}});try{await navigator.clipboard.writeText(value);toast('正確な座標をコピーしました')}catch{toast('コピーできませんでした')}};
 $('#undoView').onclick=()=>{if(viewHistoryIndex>0){viewHistoryIndex--;restoreView(viewHistory[viewHistoryIndex]);syncHistoryButtons()}};$('#redoView').onclick=()=>{if(viewHistoryIndex<viewHistory.length-1){viewHistoryIndex++;restoreView(viewHistory[viewHistoryIndex]);syncHistoryButtons()}};
-function bind(id,key,out,fmt,flush=false){const el=$(id),o=$(out),apply=()=>{state[key]=Number(el.value);o.textContent=fmt(Number(el.value));if(flush)clearDetailCache();setDirty()};el.addEventListener('input',apply);apply()}
-function bindColor(id,key,out,fmt){const el=$(id),o=$(out),apply=()=>{state[key]=Number(el.value);o.textContent=fmt(Number(el.value));if(!recolorCurrentField())setDirty()};el.addEventListener('input',apply);apply()}
-bind('#iters','baseIter','#itersO',x=>String(Math.round(x)),true);bindColor('#cycle','cycle','#cycleO',x=>x.toFixed(4));bindColor('#shift','shift','#shiftO',x=>x.toFixed(2));
-$('#palette').onchange=e=>{state.palette=Math.max(0,Math.min(2,Number(e.target.value)|0));if(!recolorCurrentField())setDirty()};
-$('#processMode').onchange=e=>{state.processMode=/^(power|standard|fine|validate)$/.test(e.target.value)?e.target.value:'standard';state.hq=state.processMode==='fine'||state.processMode==='validate';state.adaptivePixelBudget=0;$('#hq').checked=state.hq;try{localStorage.setItem('mandelbrot.processMode',state.processMode)}catch{}resize();setDirty()};
-$('#adaptive').onchange=e=>{state.adaptive=e.target.checked;clearDetailCache();setDirty()};$('#hq').onchange=e=>{state.hq=e.target.checked;if(!state.hq)cancelDetailRefinement(true);setDirty()};
-addEventListener('resize',()=>{resize();setDirty()});addEventListener('keydown',e=>{if(/^(INPUT|SELECT|TEXTAREA|BUTTON)$/.test(e.target.tagName))return;let handled=true;if(e.key==='h'||e.key==='H')$('#uiToggle').click();else if(e.key==='r'||e.key==='R')$('#reset').click();else if(e.key==='+'||e.key==='='||e.key==='Enter'&&!e.shiftKey)$('#zin').click();else if(e.key==='-'||e.key==='Enter'&&e.shiftKey)$('#zout').click();else if(e.key==='ArrowLeft'){capturePanSource();pan(innerWidth*.08,0)}else if(e.key==='ArrowRight'){capturePanSource();pan(-innerWidth*.08,0)}else if(e.key==='ArrowUp'){capturePanSource();pan(0,innerHeight*.08)}else if(e.key==='ArrowDown'){capturePanSource();pan(0,-innerHeight*.08)}else handled=false;if(handled){e.preventDefault();recordView();saveHash(false)}});addEventListener('popstate',applyHashNavigation);addEventListener('hashchange',applyHashNavigation);
-function stopSchedulers(){if(schedulerRAF){cancelAnimationFrame(schedulerRAF);schedulerRAF=0}if(schedulerTimer){clearTimeout(schedulerTimer);schedulerTimer=0;schedulerDue=0}if(wheelSettleTimer){clearTimeout(wheelSettleTimer);wheelSettleTimer=0}if(pointerSettleTimer){clearTimeout(pointerSettleTimer);pointerSettleTimer=0}cancelUnknownContinuation()}
-addEventListener('visibilitychange',()=>{if(document.hidden){exportJob.cancelled=true;stopSchedulers();state.wheelActive=false;cancelRender();cancelDetailRefinement(true)}else{state.lastInteraction=performance.now();state.dirty=true;invalidateView()}});
-globalThis.__MANDEL_DIAG__={snapshot:()=>{const deep=deepEngineNeeded(),ledger=memoryLedger(),coveredProfile=RENDER_PROFILE[RENDER_PASS.COVERED];return{rendererVersion:23,pixelContract:'centered',processMode:state.processMode,automaticTarget:modeTarget(),drawState:state.drawState,coverage:state.coverage,unresolved:state.unresolved,zoom:zoomExp(),deep,legacyDeepThreshold:LEGACY_DEEP_ZOOM_THRESHOLD,bits:state.bits,palette:state.palette,rendering:state.rendering,validating:validationJob.active,exporting:exportJob.active,lastRender:state.lastRender,lastPass:state.lastPass,transformReuse:!!state.panReuse,detailCache:DETAIL_TILE_CACHE.size,detailCacheBytes,detailCacheBudget:detailCacheBudget(),detailActive:state.detailActive,frame:frameCanvas.width+'x'+frameCanvas.height,frameCoverage:frameCanvas.width/Math.max(1,canvas.width),hqTarget:targetSize(coveredProfile,deep).join('x'),scheduler:{raf:!!schedulerRAF,timer:!!schedulerTimer,needsPaint,needsStats,wheelActive:state.wheelActive,pointerSettle:!!pointerSettleTimer,unknownTimer:!!unknownContinuationTimer,backgroundJobs:runtimeMetrics.pendingBackgroundJobs},screen:{effectiveDpr:state.effectiveDpr,deviceDpr:window.devicePixelRatio||1,pixelBudget:state.screenPixelBudget,pixels:canvas.width*canvas.height},memory:ledger,shallowAssets:{wasmReady:!!wasm,worker:!!shallowWorker,workerBusy:shallowWorkerBusy},deepAssets:{wasmReady:!!deepWasm,workers:deepPool.workers.length},runtimeMetrics:{...runtimeMetrics},telemetry:{...deepTelemetry},renderPerf:{...renderPerf},wisdom:{workerCount:deepWisdom.workerCount,rowMsEMA:deepWisdom.rowMsEMA,stripRows:deepWisdom.stripRows,realBench:deepWisdom.realBench},reference:{id:referenceCache.id,bits:referenceCache.bits,n:referenceCache.n,escape:referenceCache.escape,buildMs:refControl.lastBuildMs,buildEMA:refControl.buildEMA,baseMPP:refControl.baseMPP,lastMPP:refControl.lastMPP,conditionLog2:referenceCache.conditionLog2,checkpointBits:referenceCache.checkpointBits,checkpointCount:referenceCache.checkpointCount,checkpointMismatch:referenceCache.checkpointMismatch}}},memoryLedger:()=>memoryLedger()};
-addEventListener('pagehide',()=>{stopSchedulers();destroyShallowWorker();destroyDeepPool()},{once:true});
-try{state.uiHidden=localStorage.getItem('mandelbrot.uiHidden')==='1';const savedMode=localStorage.getItem('mandelbrot.processMode');if(/^(power|standard|fine|validate)$/.test(savedMode)){state.processMode=savedMode;state.hq=savedMode==='fine'||savedMode==='validate'}}catch{}restoreDeepWisdom();applyUiVisibility();resize();if(!loadHash())reset();else setDirty();recordView();syncControls();ctx.fillStyle='#050813';ctx.fillRect(0,0,canvas.width,canvas.height);render(RENDER_PASS.PREVIEW);requestScheduler();
+$('#palette').onchange=e=>{state.palette=Math.max(0,Math.min(2,Number(e.target.value)|0));recolor()};$('#cycle').oninput=e=>{state.cycle=Number(e.target.value);$('#cycleO').textContent=state.cycle.toFixed(4);recolor()};$('#shift').oninput=e=>{state.shift=Number(e.target.value);$('#shiftO').textContent=state.shift.toFixed(2);recolor()};
+$('#iters').oninput=e=>{state.baseIter=Number(e.target.value);$('#itersO').textContent=String(state.baseIter);markDirty()};$('#adaptive').onchange=e=>{state.adaptive=e.target.checked;markDirty()};$('#hq').onchange=e=>{state.hq=e.target.checked;recolor()};
+$('#processMode').onchange=e=>{state.processMode=/^(power|standard|fine|validate)$/.test(e.target.value)?e.target.value:'standard';state.hq=state.processMode==='fine'||state.processMode==='validate';$('#hq').checked=state.hq;resize();markDirty();try{localStorage.setItem('mandelbrot.processMode',state.processMode)}catch{}};
+addEventListener('resize',()=>{resize();markDirty()});addEventListener('keydown',e=>{if(/^(INPUT|SELECT|TEXTAREA|BUTTON)$/.test(e.target.tagName))return;let ok=true;if(e.key==='h'||e.key==='H')$('#uiToggle').click();else if(e.key==='r'||e.key==='R')$('#reset').click();else if(e.key==='+'||e.key==='='||e.key==='Enter'&&!e.shiftKey)$('#zin').click();else if(e.key==='-'||e.key==='Enter'&&e.shiftKey)$('#zout').click();else if(e.key==='ArrowLeft')pan(innerWidth*.08,0);else if(e.key==='ArrowRight')pan(-innerWidth*.08,0);else if(e.key==='ArrowUp')pan(0,innerHeight*.08);else if(e.key==='ArrowDown')pan(0,-innerHeight*.08);else ok=false;if(ok){e.preventDefault();recordView();saveHash(false);markDirty()}});
+addEventListener('hashchange',()=>{if(location.hash===lastWrittenHash){lastWrittenHash='';return}if(location.hash===navigationHash)return;navigationHash=location.hash;setTimeout(()=>navigationHash='',0);if(loadHash()){syncControls();recordView();markDirty()}});
+
+// ── export: GPU tiled + streaming PNG, optional GPU 2x2 supersampling ──────
+const exportJob={active:false,cancelled:false};
+function downloadBlob(blob,name){const a=document.createElement('a');a.href=URL.createObjectURL(blob);a.download=name;document.body.appendChild(a);a.click();a.remove();setTimeout(()=>URL.revokeObjectURL(a.href),1000)}
+const CRC_TABLE=(()=>{const t=new Uint32Array(256);for(let n=0;n<256;n++){let c=n;for(let k=0;k<8;k++)c=(c&1)?0xedb88320^(c>>>1):c>>>1;t[n]=c>>>0}return t})();
+function crc32Parts(parts){let c=0xffffffff;for(const part of parts)for(const b of part)c=CRC_TABLE[(c^b)&255]^(c>>>8);return(c^0xffffffff)>>>0}
+function pngChunk(type,data=new Uint8Array()){const tb=new TextEncoder().encode(type),out=new Uint8Array(12+data.length),dv=new DataView(out.buffer);dv.setUint32(0,data.length,false);out.set(tb,4);out.set(data,8);dv.setUint32(8+data.length,crc32Parts([tb,data]),false);return out}
+class StreamingPng{
+  constructor(w,h){if(typeof CompressionStream==='undefined')throw new Error('このブラウザはストリーミングPNG出力に必要なCompressionStreamへ対応していません');this.w=w;this.h=h;this.cs=new CompressionStream('deflate');this.writer=this.cs.writable.getWriter();this.compressed=(async()=>{const r=this.cs.readable.getReader(),chunks=[];for(;;){const q=await r.read();if(q.done)break;chunks.push(q.value)}return chunks})()}
+  async rows(filteredRows){await this.writer.write(filteredRows)}
+  async finish(){await this.writer.close();const chunks=await this.compressed,ihdr=new Uint8Array(13),dv=new DataView(ihdr.buffer);dv.setUint32(0,this.w,false);dv.setUint32(4,this.h,false);ihdr[8]=8;ihdr[9]=6;const parts=[new Uint8Array([137,80,78,71,13,10,26,10]),pngChunk('IHDR',ihdr)];for(const c of chunks)parts.push(pngChunk('IDAT',c));parts.push(pngChunk('IEND'));return new Blob(parts,{type:'image/png'})}
+  async abort(reason){try{await this.writer.abort(reason)}catch{}try{await this.compressed}catch{}}
+}
+function exportDimensions(){const scale=Number($('#exportScale').value),aspect=canvas.height/Math.max(1,canvas.width),requested=Math.max(64,Math.round(scale?canvas.width*scale:Number($('#exportWidth').value)||canvas.width));let w=Math.min(16384,requested),h=Math.max(1,Math.round(w*aspect));if(h>16384){h=16384;w=Math.max(64,Math.round(h/Math.max(1e-12,aspect)))}return{w:Math.min(16384,w),h:Math.min(16384,h)}}
+async function runExport(){
+  if(exportJob.active)return;
+  const r=renderer||await initRenderer();if(!r){$('#exportStatus').textContent='WebGPUが必要です。';return}
+  const{w,h}=exportDimensions(),ss=Math.max(1,Math.min(2,Number($('#exportAA').value)||1)),snap=snapshot(),iter=maxIter(),deep=deepNeeded(snap,w),strict=$('#exportPrecision').value==='strict';
+  let ctx=null;
+  if(deep){$('#exportStatus').textContent='高精度参照軌道を準備中…';ctx=await refs.request(snap,iter);if(ctx.checkpointMismatch){$('#exportStatus').textContent='参照軌道検証に失敗しました。';return}}
+  const tile=512,totalTiles=Math.ceil(w/tile)*Math.ceil(h/tile),png=new StreamingPng(w,h),sampleCount=ss===2?4:1;
+  exportJob.active=true;exportJob.cancelled=false;$('#exportProgress').hidden=false;$('#exportProgress').value=0;$('#exportStart').disabled=true;
+  let done=0,unresolvedSamples=0;
+  try{
+    for(let y=0;y<h;y+=tile){
+      const th=Math.min(tile,h-y),rowStride=1+w*4,band=new Uint8Array(rowStride*th);
+      for(let x=0;x<w;x+=tile){
+        if(exportJob.cancelled)throw new Error('cancelled');const tw=Math.min(tile,w-x);
+        const result=ss===1?await r.renderTileRGBA({snap,iter,deep,deepContext:ctx,fullW:w,fullH:h,tileX:x,tileY:y,w:tw,h:th,sampleX:.5,sampleY:.5,edgeAA:false,forceStrict:strict}):await r.renderTileRGBA2x({snap,iter,deep,deepContext:ctx,fullW:w,fullH:h,tileX:x,tileY:y,w:tw,h:th,forceStrict:strict});
+        const data=result.rgba;unresolvedSamples+=result.unresolved||0;
+        for(let row=0;row<th;row++)band.set(data.subarray(row*tw*4,(row+1)*tw*4),row*rowStride+1+x*4);
+        done++;$('#exportProgress').value=done/totalTiles;$('#exportStatus').textContent='GPUタイル生成 '+Math.round(100*done/totalTiles)+'%'+(unresolvedSamples?' · 未確定sample '+unresolvedSamples:'');
+      }
+      if(exportJob.cancelled)throw new Error('cancelled');await png.rows(band);await new Promise(requestAnimationFrame);
+    }
+    if(exportJob.cancelled)throw new Error('cancelled');$('#exportStatus').textContent='PNGストリームを確定中…';
+    const blob=await png.finish(),stamp=Date.now(),base='mandelbrot-'+stamp,meta={format:'mandelbrot-view-v24',rendererVersion:VERSION,backend:'webgpu',numericEngine:deep?'bigint-reference + guarded-rescaled-f32-perturbation':'f32-direct',membershipCertified:false,precisionPolicy:strict?'strict-gpu':'balanced-gpu',pixelContract:'centered',width:w,height:h,supersampling:ss,numericSamples:w*h*sampleCount,unresolvedSamples,exportPipeline:ss===2?'gpu-4sample-resolve + single-readback-per-tile + streaming-png':'gpu-tile + streaming-png',iterationPolicy:{adaptive:state.adaptive,base:state.baseIter,effective:iter},view:{bits:snap.bits,re:snap.re.toString(),im:snap.im.toString(),span:snap.span.toString()},palette:{id:state.palette,cycle:state.cycle,shift:state.shift},reference:ctx?{precisionBits:ctx.precisionBits,checkpointCount:ctx.checkpointCount,checkpointMismatch:ctx.checkpointMismatch,blaEnabled:false}:null,shaderVersion:G.version};
+    downloadBlob(blob,base+'.png');downloadBlob(new Blob([JSON.stringify(meta,null,2)],{type:'application/json'}),base+'.json');runtime.exports++;
+    $('#exportStatus').textContent=unresolvedSamples?'保存しました · 未確定sample '+unresolvedSamples+'（sidecar参照）':'PNGと座標メタデータを保存しました。';
+  }catch(e){await png.abort(e);$('#exportStatus').textContent=String(e.message)==='cancelled'?'出力を中止しました。':'出力失敗: '+String(e&&e.message||e)}
+  finally{exportJob.active=false;$('#exportStart').disabled=false}
+}
+$('#png').onclick=()=>{const d=$('#exportDialog');$('#exportWidth').value=String(canvas.width);$('#exportScale').value='1';$('#exportProgress').hidden=true;$('#exportStatus').textContent='';d.showModal?d.showModal():d.setAttribute('open','')};$('#exportScale').onchange=e=>{const s=Number(e.target.value);if(s)$('#exportWidth').value=String(exportDimensions().w)};$('#exportStart').onclick=runExport;$('#exportCancel').onclick=()=>{if(exportJob.active){exportJob.cancelled=true;$('#exportStatus').textContent='中止しています…'}else $('#exportDialog').close()};$('#exportQuick').onclick=()=>canvas.toBlob(blob=>{if(blob)downloadBlob(blob,'mandelbrot-'+Date.now()+'.png')},'image/png');
+
+// ── diagnostics ──────────────────────────────────────────────────────────
+function updateStats(){const z=zoomExp(),digits=Math.max(8,Math.min(80,Math.ceil(z)+8));$('#coord').textContent=fmtFixed(state.re,digits)+' '+(state.im<0n?'−':'+')+' '+fmtFixed(state.im<0n?-state.im:state.im,digits)+'i';$('#zoom').textContent=z<4?Math.pow(10,z).toFixed(1)+'×':'≈ 10^'+z.toFixed(2);$('#span').textContent=fmtSpan();$('#engine').textContent=renderer?(deepNeeded()?'WebGPU 深部':'WebGPU 標準'):(state.gpuInitFailed?'WebGPU エラー':state.gpuError?'Fallback':'起動中');$('#render').textContent=state.rendering?'描画中…':state.lastRender?state.lastRender.toFixed(0)+' ms':'準備完了';let status=state.drawState==='ERROR'?'描画停止':state.drawState==='REPROJECTED'?'再投影':state.drawState==='COVERING'?'GPU描画中':state.drawState==='REFINED'?'GPU境界平滑化':state.drawState==='COVERED'?'全域描画 完了':'準備中';if(state.unresolved)status+=' · 未確定 '+state.unresolved;if(state.gpuError){const ge=state.gpuError.length>120?state.gpuError.slice(0,117)+'…':state.gpuError;status+=' · '+ge;}$('#badge').textContent=status;$('#compactStatus').textContent=status;const d=renderer&&renderer.deepCtx;$('#diagEngine').textContent='engine: '+state.lastEngine+' | WebGPU '+(renderer?'ready':'unavailable')+' | shader '+G.version;$('#diagNumeric').textContent='numeric: view '+state.bits+' bit | iter '+maxIter()+(d?' | ref '+d.precisionBits+' bit':'');const frameBytes=renderer&&renderer.frame?renderer.frame.n*16:0,deepBytes=d?d.refs.byteLength:0;$('#diagMemory').textContent='GPU managed est: '+((frameBytes+deepBytes)/1048576).toFixed(1)+' MiB | canvas '+canvas.width+'×'+canvas.height}
+
+globalThis.__MANDEL_TEST__={
+  async setView({re,im,span,bits,baseIter=350,adaptive=false,processMode='standard'}){cancelRender();if(bits){state.bits=bits}else{state.bits=Math.max(256,decimalRequiredBits(re),decimalRequiredBits(im),decimalRequiredBits(span))}state.re=fromDec(re);state.im=fromDec(im);state.span=fromDec(span);state.baseIter=baseIter;state.adaptive=adaptive;state.processMode=processMode;state.hq=false;ensurePrecision();resize();markDirty(false);const start=performance.now();while((state.dirty||state.rendering)&&performance.now()-start<120000){schedule();await new Promise(r=>setTimeout(r,20))}if(state.dirty||state.rendering)throw new Error('test render timeout');return{width:canvas.width,height:canvas.height,diag:globalThis.__MANDEL_DIAG__.snapshot()}},
+  async sampleMeta(points){if(!renderer||!renderer.frame)throw new Error('GPU field unavailable');const idx=points.map(([x,y])=>y*renderer.frame.w+x);const m=await renderer.readMeta(idx);return Array.from(m)},
+  state:()=>({bits:state.bits,re:state.re.toString(),im:state.im.toString(),span:state.span.toString(),width:canvas.width,height:canvas.height,iter:maxIter()}),
+  async probeMeta({w,h,strict=true}={}){if(!renderer)throw new Error('WebGPU renderer unavailable');const snap=snapshot(),iter=maxIter(),deep=deepNeeded(snap,w);let ctx=null;if(deep)ctx=await refs.request(snap,iter);return Array.from(await renderer.renderTileMeta({snap,iter,deep,deepContext:ctx,fullW:w,fullH:h,w,h,forceStrict:strict}))},
+  async smokeExportTile({w=48,h=32,strict=true,ss=1}={}){if(!renderer)throw new Error('WebGPU renderer unavailable');const snap=snapshot(),iter=maxIter(),deep=deepNeeded(snap,w);let ctx=null;if(deep)ctx=await refs.request(snap,iter);const result=ss===2?await renderer.renderTileRGBA2x({snap,iter,deep,deepContext:ctx,fullW:w,fullH:h,tileX:0,tileY:0,w,h,forceStrict:strict}):await renderer.renderTileRGBA({snap,iter,deep,deepContext:ctx,fullW:w,fullH:h,tileX:0,tileY:0,w,h,sampleX:.5,sampleY:.5,edgeAA:false,forceStrict:strict}),data=result.rgba;let checksum=2166136261>>>0;for(const v of data){checksum^=v;checksum=Math.imul(checksum,16777619)>>>0}return{length:data.length,expected:w*h*4,checksum,deep,strict,ss,unresolved:result.unresolved||0}}
+};
+globalThis.__MANDEL_DIAG__={snapshot:()=>({rendererVersion:VERSION,backend:renderer?'webgpu':'fallback',shaderVersion:G.version,webgpuError:state.gpuError,pixelContract:'centered',drawState:state.drawState,rendering:state.rendering,zoom:zoomExp(),deep:deepNeeded(),bits:state.bits,iteration:maxIter(),unresolved:state.unresolved,screen:{width:canvas.width,height:canvas.height,effectiveDpr:state.effectiveDpr,pixelBudget:state.screenPixelBudget},reference:renderer&&renderer.deepCtx?{key:renderer.deepCtx.key,precisionBits:renderer.deepCtx.precisionBits,refLen:renderer.deepCtx.refLen,checkpointMismatch:renderer.deepCtx.checkpointMismatch,checkpointCount:renderer.deepCtx.checkpointCount,blaEnabled:false}:null,runtime:{...runtime},adapter:renderer?renderer.adapterInfo:null,limits:renderer?renderer.adapterLimits:null,compilation:renderer?renderer.compilation:null,uncapturedErrors:renderer?renderer.uncapturedErrors.slice():[]})};
+
+// ── boot / teardown ──────────────────────────────────────────────────────
+addEventListener('visibilitychange',()=>{if(document.hidden){cancelRender();exportJob.cancelled=true}else markDirty(false)});addEventListener('pagehide',()=>{cancelRender();refs.destroy();if(renderer)renderer.destroy()},{once:true});
+try{state.uiHidden=localStorage.getItem('mandelbrot.uiHidden')==='1';const m=localStorage.getItem('mandelbrot.processMode');if(/^(power|standard|fine|validate)$/.test(m)){state.processMode=m;state.hq=m==='fine'||m==='validate'}}catch{}applyUi();resize();if(!loadHash())reset();recordView();syncControls();updateStats();initRenderer().then(()=>{resize();markDirty(false)});schedule();
 })();
diff --git a/dist/standalone/gpu-kernels.js b/dist/standalone/gpu-kernels.js
new file mode 100644
index 0000000..93b7e33
--- /dev/null
+++ b/dist/standalone/gpu-kernels.js
@@ -0,0 +1,258 @@
+(()=>{'use strict';
+const COMMON=String.raw`
+const FIELD_UNKNOWN:u32=0u;
+const FIELD_ESCAPED:u32=1u;
+const FIELD_INTERIOR_LIKELY:u32=2u;
+const FIELD_INTERIOR_PROVEN:u32=3u;
+const ITER_MASK:u32=0x0fffffffu;
+const STATUS_UNRESOLVED:u32=0xfffffffeu;
+
+fn pack_meta(n:u32, cls:u32)->u32 { return (n & ITER_MASK) | ((cls & 3u) << 28u); }
+fn cmul(a:vec2<f32>, b:vec2<f32>)->vec2<f32>{
+  return vec2<f32>(a.x*b.x-a.y*b.y, a.x*b.y+a.y*b.x);
+}
+fn maxabs(v:vec2<f32>)->f32 { return max(abs(v.x),abs(v.y)); }
+const F32_U:f32=5.960464477539063e-8;
+fn pow2_safe(e:i32)->f32 {
+  if(e < -126){ return 0.0; }
+  if(e > 126){ return 8.507059e37; }
+  return ldexp(1.0,e);
+}
+fn safe_abs_error(errScaled:f32, scaleExp:i32, z:vec2<f32>, delta:vec2<f32>)->f32{
+  let propagated=abs(errScaled*pow2_safe(scaleExp));
+  let reconstruction=64.0*F32_U*(maxabs(z)+maxabs(delta)+1.0e-30);
+  return propagated+reconstruction;
+}
+fn scaled_to_f32(v:vec2<f32>, e:i32)->vec2<f32>{
+  if(e < -126){ return vec2<f32>(0.0); }
+  if(e > 126){ return vec2<f32>(8.507059e37); }
+  return ldexp(v,vec2<i32>(e));
+}
+fn smooth_escape(n:u32, mag2:f32)->f32{
+  let u=log2(max(4.0000005,mag2));
+  return f32(n)+1.0-log2(max(1.0e-20,0.5*u));
+}
+`;
+
+const DIRECT_F32_WGSL=COMMON+String.raw`
+struct Params{
+  tileW:u32, tileH:u32, fullW:u32, fullH:u32,
+  tileX:u32, tileY:u32, maxIter:u32, strict:u32,
+  centerRe:f32, centerIm:f32, span:f32, sampleX:f32,
+  sampleY:f32, _p0:f32, _p1:f32, _p2:f32,
+};
+@group(0) @binding(0) var<uniform> p:Params;
+@group(0) @binding(1) var<storage,read_write> fieldMeta:array<u32>;
+@group(0) @binding(2) var<storage,read_write> fieldSmooth:array<f32>;
+fn analytic(cr:f32,ci:f32)->bool{
+  let y2=ci*ci; let x=cr-0.25; let q=x*x+y2;
+  let lhs=q*(q+x); let rhs=0.25*y2;
+  let margin=16.0*F32_U*(abs(lhs)+abs(rhs)+1.0);
+  if(lhs<rhs-margin){return true;}
+  let x2=cr+1.0; let bulb=x2*x2+y2;
+  let bulbMargin=16.0*F32_U*(abs(bulb)+0.0625+1.0);
+  return bulb<0.0625-bulbMargin;
+}
+@compute @workgroup_size(8,8)
+fn main(@builtin(global_invocation_id) gid:vec3<u32>){
+  if(gid.x>=p.tileW||gid.y>=p.tileH){return;}
+  let out=gid.y*p.tileW+gid.x;
+  let gx=f32(p.tileX+gid.x)+p.sampleX;
+  let gy=f32(p.tileY+gid.y)+p.sampleY;
+  let scale=p.span/f32(p.fullW);
+  let cr=p.centerRe+(gx-0.5*f32(p.fullW))*scale;
+  let ci=p.centerIm+(0.5*f32(p.fullH)-gy)*scale;
+  if(analytic(cr,ci)){
+    fieldMeta[out]=pack_meta(p.maxIter,FIELD_INTERIOR_PROVEN); fieldSmooth[out]=0.0; return;
+  }
+  var zr=0.0; var zi=0.0; var n=0u;
+  loop{
+    if(n>=p.maxIter){break;}
+    let zr2=zr*zr; let zi2=zi*zi;
+    zi=2.0*zr*zi+ci; zr=zr2-zi2+cr; n+=1u;
+    let mag=zr*zr+zi*zi;
+    if(mag>4.0){fieldMeta[out]=pack_meta(n,FIELD_ESCAPED); fieldSmooth[out]=smooth_escape(n,mag); return;}
+  }
+  fieldMeta[out]=pack_meta(p.maxIter,FIELD_INTERIOR_LIKELY); fieldSmooth[out]=0.0;
+}
+`;
+
+// Deep path: high-precision CPU reference + guarded rescaled f32 perturbation.
+const DEEP_PERTURB_WGSL=COMMON+String.raw`
+struct Params{
+  tileW:u32, tileH:u32, fullW:u32, fullH:u32,
+  tileX:u32, tileY:u32, maxIter:u32, refLen:u32,
+  strict:u32, _numeric0:u32, _numeric1:u32, _numeric2:u32,
+  spanMant:f32, spanExp:i32, sampleX:f32, sampleY:f32,
+};
+struct RefPoint{ hi:vec2<f32>, lo:vec2<f32> };
+struct UnresolvedHead{ remaining:atomic<u32>, _p0:u32, _p1:u32, _p2:u32 };
+@group(0) @binding(0) var<uniform> p:Params;
+@group(0) @binding(1) var<storage,read> refs:array<RefPoint>;
+@group(0) @binding(2) var<storage,read_write> fieldMeta:array<u32>;
+@group(0) @binding(3) var<storage,read_write> fieldSmooth:array<f32>;
+@group(0) @binding(4) var<storage,read_write> unresolved:UnresolvedHead;
+
+fn mark_unresolved(out:u32,n:u32){
+  fieldMeta[out]=pack_meta(n,FIELD_UNKNOWN); fieldSmooth[out]=0.0;
+  atomicAdd(&unresolved.remaining,1u);
+}
+fn render_pixel(out:u32,gx:f32,gy:f32,strictMode:bool){
+  let dx=(gx-0.5*f32(p.fullW))/f32(p.fullW);
+  let dy=(0.5*f32(p.fullH)-gy)/f32(p.fullW);
+  // dc = d * 2^scaleExp. Keep d and w in one shared scale.
+  var d=vec2<f32>(p.spanMant*dx,p.spanMant*dy);
+  var w=vec2<f32>(0.0);
+  var scaleExp=p.spanExp;
+  var n=0u; var m=0u; var operations=0u;
+  var errScaled=64.0*F32_U*maxabs(d);
+  loop{
+    if(n>=p.maxIter){
+      let rpEnd=refs[min(m,p.refLen)];
+      let deltaEnd=scaled_to_f32(w,scaleExp);
+      let zEnd=rpEnd.hi+(rpEnd.lo+deltaEnd);
+      let errAbs=safe_abs_error(errScaled,scaleExp,zEnd,deltaEnd);
+      let limit=select(1.0e-3,1.0e-4,strictMode);
+      if(errAbs<=limit){fieldMeta[out]=pack_meta(p.maxIter,FIELD_INTERIOR_LIKELY);fieldSmooth[out]=0.0;}else{mark_unresolved(out,n);}
+      return;
+    }
+    if(m>p.refLen){mark_unresolved(out,n);return;}
+    let rp=refs[m];
+    let delta=scaled_to_f32(w,scaleExp);
+    let z=rp.hi+(rp.lo+delta);
+    let mag=dot(z,z);
+    if(mag>4.0){
+      let errAbs=safe_abs_error(errScaled,scaleExp,z,delta);
+      if(length(z)-errAbs>2.0){fieldMeta[out]=pack_meta(n,FIELD_ESCAPED);fieldSmooth[out]=smooth_escape(n,mag);return;}
+      mark_unresolved(out,n);return;
+    }
+
+    // Rebase only when dc remains numerically representable in the new scale.
+    if(m>0u && dot(delta,delta)>0.0 && mag<dot(delta,delta)){
+      if(p.spanExp-scaleExp < -96){mark_unresolved(out,n);return;}
+      errScaled=safe_abs_error(errScaled,scaleExp,z,delta);
+      w=z; d=scaled_to_f32(vec2<f32>(p.spanMant*dx,p.spanMant*dy),p.spanExp); scaleExp=0; m=0u;
+      errScaled+=64.0*F32_U*maxabs(d);
+      continue;
+    }
+
+    if(m>=p.refLen){mark_unresolved(out,n);return;}
+    let r=refs[m];
+    let refAbs=maxabs(r.hi)+maxabs(r.lo);
+    let wAbs=maxabs(w); let dAbs=maxabs(d); let p2=abs(pow2_safe(scaleExp));
+    let gain=2.0*refAbs+2.0*wAbs*p2;
+    let roundErr=64.0*F32_U*(2.0*refAbs*wAbs+wAbs*wAbs*p2+dAbs+1.0e-30);
+    errScaled=gain*errScaled+roundErr;
+    let linear=2.0*(cmul(r.hi,w)+cmul(r.lo,w));
+    // delta^2 / 2^scaleExp = w^2 * 2^scaleExp
+    let sq=cmul(w,w)*pow2_safe(scaleExp);
+    w=linear+sq+d; m+=1u; n+=1u; operations+=1u;
+    if(maxabs(w)>=1.0e30 || maxabs(d)>=1.0e30){mark_unresolved(out,n);return;}
+    let mm=max(maxabs(w),maxabs(d));
+    if(mm>65536.0){
+      w*=0.0000152587890625; d*=0.0000152587890625; errScaled*=0.0000152587890625; scaleExp+=16;
+    }else if(mm>0.0 && mm<0.0000152587890625 && scaleExp>p.spanExp){
+      w*=65536.0; d*=65536.0; errScaled*=65536.0; scaleExp-=16;
+    }
+    if(scaleExp>126 || errScaled!=errScaled || errScaled>1.0e35){mark_unresolved(out,n);return;}
+    if(operations>p.maxIter*2u+2048u){mark_unresolved(out,n);return;}
+  }
+}
+@compute @workgroup_size(8,8)
+fn main(@builtin(global_invocation_id) gid:vec3<u32>){
+  if(gid.x>=p.tileW||gid.y>=p.tileH){return;}
+  let out=gid.y*p.tileW+gid.x;
+  let gx=f32(p.tileX+gid.x)+p.sampleX; let gy=f32(p.tileY+gid.y)+p.sampleY;
+  render_pixel(out,gx,gy,p.strict!=0u);
+}
+`;
+
+const COLOR_WGSL=String.raw`
+struct Params{
+  width:u32,height:u32,palette:u32,edgeAA:u32,
+  cycle:f32,shift:f32,_p0:f32,_p1:f32,
+};
+@group(0) @binding(0) var<uniform> p:Params;
+@group(0) @binding(1) var<storage,read> fieldMeta:array<u32>;
+@group(0) @binding(2) var<storage,read> fieldSmooth:array<f32>;
+@group(0) @binding(3) var outTex:texture_storage_2d<rgba8unorm,write>;
+fn hsv(h:f32,s:f32,v:f32)->vec3<f32>{
+  let x=fract(h)*6.0; let i=i32(floor(x)); let f=x-floor(x); let pp=v*(1.0-s); let q=v*(1.0-s*f); let t=v*(1.0-s*(1.0-f));
+  if(i==0){return vec3<f32>(v,t,pp);} if(i==1){return vec3<f32>(q,v,pp);} if(i==2){return vec3<f32>(pp,v,t);} if(i==3){return vec3<f32>(pp,q,v);} if(i==4){return vec3<f32>(t,pp,v);} return vec3<f32>(v,pp,q);
+}
+fn current_palette(t0:f32)->vec3<f32>{
+  let t=select(2.0-2.0*t0,2.0*t0,t0<=0.5);
+  if(t<0.11){return mix(vec3<f32>(4,10,27),vec3<f32>(12,53,79),smoothstep(0.0,0.11,t))/255.0;}
+  if(t<0.25){return mix(vec3<f32>(12,53,79),vec3<f32>(31,156,184),smoothstep(0.11,0.25,t))/255.0;}
+  if(t<0.38){return mix(vec3<f32>(31,156,184),vec3<f32>(91,226,234),smoothstep(0.25,0.38,t))/255.0;}
+  if(t<0.50){return mix(vec3<f32>(91,226,234),vec3<f32>(66,53,151),smoothstep(0.38,0.50,t))/255.0;}
+  if(t<0.62){return mix(vec3<f32>(66,53,151),vec3<f32>(139,49,170),smoothstep(0.50,0.62,t))/255.0;}
+  if(t<0.73){return mix(vec3<f32>(139,49,170),vec3<f32>(232,72,145),smoothstep(0.62,0.73,t))/255.0;}
+  if(t<0.84){return mix(vec3<f32>(232,72,145),vec3<f32>(255,137,64),smoothstep(0.73,0.84,t))/255.0;}
+  if(t<0.93){return mix(vec3<f32>(255,137,64),vec3<f32>(255,211,99),smoothstep(0.84,0.93,t))/255.0;}
+  return mix(vec3<f32>(255,211,99),vec3<f32>(255,250,223),smoothstep(0.93,1.0,t))/255.0;
+}
+fn base_color(i:u32)->vec3<f32>{
+  let m=fieldMeta[i]; let cls=(m>>28u)&3u;
+  if(cls==0u){return vec3<f32>(20,22,30)/255.0;} if(cls!=1u){return vec3<f32>(0.0);}
+  let sm=fieldSmooth[i]; let phase=fract(p.shift+sm*p.cycle); var c=vec3<f32>(0.0);
+  if(p.palette==1u){c=hsv(phase,0.92,1.0);}else if(p.palette==2u){let g=(22.0+233.0*(0.5-0.5*cos(6.283185307*phase)))/255.0;c=vec3<f32>(g);}else{c=current_palette(phase);}
+  let n=f32(m&0x0fffffffu); let edge=clamp(log(1.0+n)/log(1.0+max(8.0,n+32.0)),0.0,1.0); let mixv=0.34+0.66*pow(edge,0.38);
+  let floorc=select(vec3<f32>(2,5,15)/255.0,vec3<f32>(8.0/255.0),p.palette==2u); return mix(floorc,c,mixv);
+}
+fn linearize(c:vec3<f32>)->vec3<f32>{return pow(c,vec3<f32>(2.2));}
+fn delinearize(c:vec3<f32>)->vec3<f32>{return pow(max(c,vec3<f32>(0.0)),vec3<f32>(1.0/2.2));}
+@compute @workgroup_size(8,8)
+fn main(@builtin(global_invocation_id) gid:vec3<u32>){
+  if(gid.x>=p.width||gid.y>=p.height){return;} let i=gid.y*p.width+gid.x; var c=base_color(i);
+  if(p.edgeAA!=0u){
+    let m=fieldMeta[i]; let cls=(m>>28u)&3u; var boundary=false; var sum=linearize(c); var cnt=1.0;
+    let x=i32(gid.x); let y=i32(gid.y);
+    for(var oy=-1;oy<=1;oy+=1){for(var ox=-1;ox<=1;ox+=1){if(ox==0&&oy==0){continue;} let xx=x+ox;let yy=y+oy;if(xx<0||yy<0||xx>=i32(p.width)||yy>=i32(p.height)){continue;}let j=u32(yy)*p.width+u32(xx);let mj=fieldMeta[j];let cj=(mj>>28u)&3u;if(cj!=cls||abs(i32(mj&0x0fffffffu)-i32(m&0x0fffffffu))>2){boundary=true;}sum+=linearize(base_color(j));cnt+=1.0;}}
+    if(boundary){c=delinearize(sum/cnt);}
+  }
+  textureStore(outTex,vec2<i32>(gid.xy),vec4<f32>(c,1.0));
+}
+`;
+
+
+const AA_RESOLVE_WGSL=String.raw`
+@group(0) @binding(0) var a:texture_2d<f32>;
+@group(0) @binding(1) var b:texture_2d<f32>;
+@group(0) @binding(2) var c:texture_2d<f32>;
+@group(0) @binding(3) var d:texture_2d<f32>;
+@group(0) @binding(4) var outTex:texture_storage_2d<rgba8unorm,write>;
+fn to_linear(x:f32)->f32{return select(x/12.92,pow((x+0.055)/1.055,2.4),x>0.04045);}
+fn to_srgb(x0:f32)->f32{let x=clamp(x0,0.0,1.0);return select(12.92*x,1.055*pow(x,1.0/2.4)-0.055,x>0.0031308);}
+fn lin3(v:vec3<f32>)->vec3<f32>{return vec3<f32>(to_linear(v.x),to_linear(v.y),to_linear(v.z));}
+fn srgb3(v:vec3<f32>)->vec3<f32>{return vec3<f32>(to_srgb(v.x),to_srgb(v.y),to_srgb(v.z));}
+@compute @workgroup_size(8,8)
+fn main(@builtin(global_invocation_id) gid:vec3<u32>){
+  let size=textureDimensions(a); if(gid.x>=size.x||gid.y>=size.y){return;}
+  let q=vec2<i32>(gid.xy);
+  let sum=lin3(textureLoad(a,q,0).rgb)+lin3(textureLoad(b,q,0).rgb)+lin3(textureLoad(c,q,0).rgb)+lin3(textureLoad(d,q,0).rgb);
+  textureStore(outTex,q,vec4<f32>(srgb3(sum*0.25),1.0));
+}
+`;
+
+const PRESENT_WGSL=String.raw`
+struct Params{scaleX:f32,scaleY:f32,offsetX:f32,offsetY:f32};
+@group(0) @binding(0) var samp:sampler;
+@group(0) @binding(1) var tex:texture_2d<f32>;
+@group(0) @binding(2) var<uniform> p:Params;
+struct VSOut{@builtin(position) pos:vec4<f32>,@location(0) uv:vec2<f32>};
+@vertex fn vs(@builtin(vertex_index) i:u32)->VSOut{
+  var pos=array<vec2<f32>,3>(vec2<f32>(-1.0,-1.0),vec2<f32>(3.0,-1.0),vec2<f32>(-1.0,3.0));
+  var uv=array<vec2<f32>,3>(vec2<f32>(0.0,1.0),vec2<f32>(2.0,1.0),vec2<f32>(0.0,-1.0));
+  var o:VSOut;o.pos=vec4<f32>(pos[i],0.0,1.0);o.uv=uv[i];return o;
+}
+@fragment fn fs(in:VSOut)->@location(0) vec4<f32>{
+  let uv=vec2<f32>(0.5)+(in.uv-vec2<f32>(0.5))*vec2<f32>(p.scaleX,p.scaleY)+vec2<f32>(p.offsetX,p.offsetY);
+  if(any(uv<vec2<f32>(0.0))||any(uv>vec2<f32>(1.0))){return vec4<f32>(0.0196,0.0314,0.0745,1.0);} return textureSampleLevel(tex,samp,uv,0.0);
+}
+`;
+
+globalThis.MANDEL_WEBGPU_KERNELS=Object.freeze({
+  version:'24.1.3',DIRECT_F32_WGSL,DEEP_PERTURB_WGSL,COLOR_WGSL,AA_RESOLVE_WGSL,PRESENT_WGSL
+});
+})();
diff --git a/dist/standalone/index.html b/dist/standalone/index.html
index 96f0f1b..186da65 100644
--- a/dist/standalone/index.html
+++ b/dist/standalone/index.html
@@ -4,7 +4,7 @@
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width,initial-scale=1,viewport-fit=cover">
 <meta name="theme-color" content="#050813">
-<title>Mandelbrot Deep Zoom v23</title>
+<title>Mandelbrot Deep Zoom v24.1.3 WebGPU</title>
 <style>
 :root{color-scheme:dark;--panel:rgba(7,12,25,.88);--line:rgba(255,255,255,.12);--text:#f7f8ff;--muted:#a9b3ca;--accent:#61dbe9}
 *{box-sizing:border-box}html,body{margin:0;width:100%;height:100%;overflow:hidden;background:#050813;font-family:Inter,-apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif}body{-webkit-user-select:none;user-select:none}
@@ -34,13 +34,13 @@ dialog{width:min(430px,calc(100vw - 24px));border:1px solid var(--line);border-r
 <div id="controls" class="panel">
   <div class="toolbar"><button id="zin" aria-label="中心を拡大">＋</button><button id="zout" aria-label="中心を縮小">−</button><button id="reset">リセット</button><button id="png">出力</button></div>
   <div class="group">
-    <div class="line"><label for="processMode">処理モード</label><select id="processMode"><option value="power">省電力</option><option value="standard" selected>標準</option><option value="fine">精細</option><option value="validate">精度優先</option></select><output></output></div>
+    <div class="line"><label for="processMode">処理モード</label><select id="processMode"><option value="power">省電力</option><option value="standard" selected>標準</option><option value="fine">精細</option><option value="validate">保守的 (Strict)</option></select><output></output></div>
     <div class="line"><label for="palette">彩色</label><select id="palette"><option value="0">昼夜</option><option value="1">虹色</option><option value="2">白黒</option></select><output></output></div>
     <div class="line"><label for="cycle">色周期</label><input id="cycle" type="range" min="0.001" max="0.05" step="0.0005" value="0.008"><output id="cycleO" for="cycle">0.0080</output></div>
     <div class="line"><label for="shift">色相位置</label><input id="shift" type="range" min="0" max="1" step="0.005" value="0.18"><output id="shiftO" for="shift">.18</output></div>
     <details><summary>詳細設定・正確な座標</summary>
       <div class="line"><label for="iters">基準反復</label><input id="iters" type="range" min="100" max="2500" step="25" value="350"><output id="itersO" for="iters">350</output></div>
-      <div class="checks"><label><input id="adaptive" type="checkbox" checked> 反復回数を自動調整</label><label><input id="hq" type="checkbox"> 境界AAを追加</label></div>
+      <div class="checks"><label><input id="adaptive" type="checkbox" checked> 反復回数を自動調整</label><label><input id="hq" type="checkbox"> GPU境界平滑化</label></div>
       <div class="exact-grid"><label for="coordReInput">実部</label><input id="coordReInput"><label for="coordImInput">虚部</label><input id="coordImInput"><label for="coordSpanInput">表示幅</label><input id="coordSpanInput"></div>
       <div class="mini-actions"><button id="coordApply">座標を適用</button><button id="coordCopy">正確値をコピー</button><button id="undoView">戻す</button><button id="redoView">進む</button></div>
     </details>
@@ -57,13 +57,13 @@ dialog{width:min(430px,calc(100vw - 24px));border:1px solid var(--line);border-r
     <label for="exportScale">出力倍率</label><select id="exportScale"><option value="1">1×</option><option value="2">2×</option><option value="4">4×</option><option value="0">カスタム幅</option></select>
     <label for="exportWidth">幅（px）</label><input id="exportWidth" type="number" min="64" max="16384" step="1">
     <label for="exportAA">サブサンプル</label><select id="exportAA"><option value="1">1×（高速）</option><option value="2">2×2 AA</option></select>
-    <label for="exportPrecision">精度方針</label><select id="exportPrecision"><option value="balanced">Balanced</option><option value="validated">Validated direct</option></select>
+    <label for="exportPrecision">精度方針</label><select id="exportPrecision"><option value="balanced">Balanced</option><option value="strict">保守的 (Strict)</option></select>
   </div>
   <progress id="exportProgress" max="1" value="0" hidden></progress>
   <div id="exportStatus" role="status" aria-live="polite"></div>
   <div class="export-actions"><button id="exportCancel" type="button">閉じる</button><button id="exportQuick" type="button">表示を即時保存</button><button id="exportStart" class="primary" type="button">PNGを生成</button></div>
 </dialog>
-<script src="kernels.js"></script>
+<script src="gpu-kernels.js"></script>
 <script src="script.js"></script>
 </body>
 </html>
diff --git a/dist/standalone/script.js b/dist/standalone/script.js
index 10f7903..44822b7 100644
--- a/dist/standalone/script.js
+++ b/dist/standalone/script.js
@@ -1,912 +1,248 @@
 (()=>{'use strict';
-const K=globalThis.MANDEL_KERNELS;
-if(!K)throw new Error('kernels.js が読み込まれていません');
-const {WASM_SIMD_B64,WASM_SCALAR_B64,DEEP_SIMD_B64,DEEP_SCALAR_B64,BLA_SIMD_B64,BLA_SCALAR_B64,COLOR_SIMD_B64,COLOR_SCALAR_B64}=K;
-const $=s=>document.querySelector(s);
-const canvas=$('#view');
-const ctx=canvas.getContext('2d',{alpha:false,desynchronized:true})||canvas.getContext('2d',{alpha:false});
-if(!ctx){document.body.innerHTML='<div style="padding:30px;color:white">Canvas 2Dを利用できません。</div>';return;}
-
-const INITIAL_BITS=256;
-const MIN_SPAN_BITS=224;
-const TARGET_SPAN_BITS=240;
-const RATIO_DEN=4503599627370496n; // 2^52
-const POW256=1.157920892373162e77;
-const INV256=8.636168555094445e-78;
-const HI128=3.402823669209385e38;
-const LO128=2.938735877055719e-39;
-const NEG_BUCKET=-1000000000;
-const LEGACY_DEEP_ZOOM_THRESHOLD=11.5;
-const RENDER_PASS=Object.freeze({PREVIEW:'preview',COVERED:'covered'});
-const MODE_TARGET=Object.freeze({power:'PREVIEW',standard:'COVERED',fine:'REFINED',validate:'VALIDATED'});
-function modeTarget(mode=state.processMode){return MODE_TARGET[mode]||MODE_TARGET.standard}
-const RENDER_PROFILE=Object.freeze({
-  [RENDER_PASS.PREVIEW]:Object.freeze({id:RENDER_PASS.PREVIEW,covered:false,budgetMs:110,nominalScale:.42,minWidth:360,maxWidth:900,densityLimit:1.55,blaSteps:1700,ptbSteps:2500}),
-  [RENDER_PASS.COVERED]:Object.freeze({id:RENDER_PASS.COVERED,covered:true,budgetMs:1050,nominalScale:1,minWidth:0,maxWidth:Infinity,densityLimit:1,blaSteps:0,ptbSteps:0})
-});
-function renderProfile(pass){return RENDER_PROFILE[pass]||RENDER_PROFILE[RENDER_PASS.PREVIEW]}
-let deepMode=false;
-
-const state={
-  bits:INITIAL_BITS,re:0n,im:0n,span:0n,
-  baseIter:350,adaptive:true,hq:false,processMode:'standard',palette:0,cycle:.008,shift:.18,
-  token:0,rendering:false,lastRender:0,lastEngine:'起動中',lastPass:null,lastInteraction:performance.now(),dirty:true,
-  uiHidden:false,frameView:null,fieldView:null,lastFrameDone:0,
-  detailGeneration:0,detailActive:false,detailQueued:0,detailDone:0,
-  drawState:'REPROJECTED',coverage:0,unresolved:0,
-  precisionPending:false,
-  pointerActive:false,wheelActive:false,panReuse:null,effectiveDpr:1,screenPixelBudget:0,adaptivePixelBudget:0,continuationProgress:0,focusX:.5,focusY:.5
-};
-
-// Deep telemetry is collected from the actual BLA/perturbation
-// kernel rather than from a synthetic JavaScript loop.
-const deepTelemetry={
-  frames:0,kernelMPP:0,meanIter:0,blackRatio:0,badRatio:0,blaBuildEMA:0,
-  refDistance:0,interiorRatio:0,repairRatio:0,unresolvedRatio:0,
-  blaStepsPerPixel:0,ptbStepsPerPixel:0,rebasePerPixel:0,lastPilotMs:0,lastPilotMPP:0,lastKernelMs:0,lastVerifyMs:0,lastPixels:0
-};
-const refControl={buildEMA:18,lastBuildMs:0,lastRecenterAt:0,refId:0,baseMPP:0,lastMPP:0,lastPixels:0,cooldownMs:900};
-
-// Adaptive quality controller: instead of tying a quality level to a fixed
-// pixel width, learn the recent cost per pixel and spend a bounded amount of time.
-const renderPerf={deepMPP:0,shallowMPP:0};
-const runtimeMetrics={canvasWrites:0,domWrites:0,renderStarts:0,renderStartsDuringGesture:0,longTasks:0,maxLongTaskMs:0,pendingBackgroundJobs:0};
-try{if('PerformanceObserver'in globalThis){const observer=new PerformanceObserver(list=>{for(const entry of list.getEntries()){runtimeMetrics.longTasks++;runtimeMetrics.maxLongTaskMs=Math.max(runtimeMetrics.maxLongTaskMs,entry.duration||0)}});observer.observe({type:'longtask',buffered:true})}}catch{}
-function scheduleBackground(fn,delay=0){runtimeMetrics.pendingBackgroundJobs++;return setTimeout(()=>{runtimeMetrics.pendingBackgroundJobs=Math.max(0,runtimeMetrics.pendingBackgroundJobs-1);fn()},delay)}
-function scheduleIdle(fn,timeout=350){runtimeMetrics.pendingBackgroundJobs++;const run=()=>{runtimeMetrics.pendingBackgroundJobs=Math.max(0,runtimeMetrics.pendingBackgroundJobs-1);fn()};return'requestIdleCallback'in window?requestIdleCallback(run,{timeout}):setTimeout(run,Math.min(80,timeout))}
-const DETAIL_TILE_CACHE=new Map();
-let detailCacheBytes=0;
-const activeDetailTiles=[];
-let detailPlan=null;
-let schedulerRAF=0,schedulerTimer=0,schedulerDue=0,needsPaint=true,needsStats=true,wheelSettleTimer=0,pointerSettleTimer=0;
-
-function requestScheduler(delay=0){
-  if(document.hidden)return;
-  if(delay>0){
-    const due=performance.now()+delay;
-    if(schedulerTimer&&schedulerDue<=due)return;
-    if(schedulerTimer)clearTimeout(schedulerTimer);
-    schedulerDue=due;
-    schedulerTimer=setTimeout(()=>{schedulerTimer=0;schedulerDue=0;requestScheduler()},Math.max(0,Math.ceil(delay)));
-    return
-  }
-  if(schedulerTimer){clearTimeout(schedulerTimer);schedulerTimer=0;schedulerDue=0}
-  if(!schedulerRAF)schedulerRAF=requestAnimationFrame(loop)
-}
-function invalidateView(withStats=true){needsPaint=true;if(withStats)needsStats=true;requestScheduler()}
-function invalidateStats(){needsStats=true;requestScheduler()}
-
-// Device-specific runtime wisdom. It is populated by a small background CPU
-// concurrency benchmark and then refined by real deep-render strip timings.
-const deepWisdom={
-  ready:false,running:false,maxWorkers:1,workerCount:1,
-  targetStripMs:12,stripRows:24,rowMsEMA:0,
-  realBench:false
-};
-function deepWisdomStorageKey(){
-  const meta=globalThis.MANDEL_KERNEL_META||{},kernel=String(meta.BLA_SIMD_B64||meta.BLA_SCALAR_B64||'embedded').slice(0,16),hc=Math.max(1,navigator.hardwareConcurrency||1),dm=Number(navigator.deviceMemory||0);return'mandelbrot.wisdom.v23.'+[kernel,hc,dm].join('.')
-}
-function restoreDeepWisdom(){
-  try{const saved=JSON.parse(localStorage.getItem(deepWisdomStorageKey())||'null');if(!saved||saved.version!==23)return;const row=Number(saved.rowMsEMA),rows=Number(saved.stripRows),workers=Number(saved.workerCount);if(Number.isFinite(row)&&row>0&&row<1000)deepWisdom.rowMsEMA=row;if(Number.isInteger(rows)&&rows>=2&&rows<=128)deepWisdom.stripRows=rows;if(Number.isInteger(workers)&&workers>=1&&workers<=deepWorkerLimit())deepWisdom.workerCount=workers;deepWisdom.ready=deepWisdom.rowMsEMA>0}catch{}
-}
-function persistDeepWisdom(){
-  if(!deepWisdom.rowMsEMA)return;try{localStorage.setItem(deepWisdomStorageKey(),JSON.stringify({version:23,rowMsEMA:deepWisdom.rowMsEMA,stripRows:deepWisdom.stripRows,workerCount:deepWisdom.workerCount}))}catch{}
-}
+const G=globalThis.MANDEL_WEBGPU_KERNELS;if(!G)throw new Error('gpu-kernels.js が読み込まれていません');
+const $=s=>document.querySelector(s),canvas=$('#view');
+const VERSION=24,INITIAL_BITS=256,MIN_SPAN_BITS=224,TARGET_SPAN_BITS=240,RATIO_DEN=4503599627370496n;
+const FIELD_UNKNOWN=0,FIELD_ESCAPED=1,FIELD_INTERIOR_LIKELY=2,FIELD_INTERIOR_PROVEN=3;
+const state={bits:INITIAL_BITS,re:0n,im:0n,span:0n,baseIter:350,adaptive:true,hq:false,processMode:'standard',palette:0,cycle:.008,shift:.18,token:0,rendering:false,recoloring:false,recolorPending:false,dirty:true,lastRender:0,lastEngine:'起動中',drawState:'REPROJECTED',frameView:null,fieldView:null,pointerActive:false,wheelActive:false,effectiveDpr:1,screenPixelBudget:0,unresolved:0,gpuError:'',gpuInitFailed:false,gpuUnavailable:false,lastInteraction:performance.now(),focusX:.5,focusY:.5,uiHidden:false};
+let renderer=null,rendererInitPromise=null,fallbackCtx=null,webgpuCanvasClaimed=false,raf=0,settleTimer=0,lastWrittenHash='',navigationHash='';
+const viewHistory=[];let viewHistoryIndex=-1;
+const runtime={renderStarts:0,deviceLosses:0,referenceBuilds:0,gpuFrames:0,gpuRecolors:0,exports:0};
 
+// ── exact fixed-point view state ─────────────────────────────────────────
 function one(bits=state.bits){return 1n<<BigInt(bits)}
 function fromFrac(n,d=1n){return n*one()/d}
-function fromDec(s){
-  s=String(s).trim();let neg=s[0]==='-';if(neg)s=s.slice(1);
-  const p=s.toLowerCase().split('e'),mant=p[0],exp=p[1]?parseInt(p[1],10):0;
-  const a=mant.split('.'),i=a[0]||'0',f=a[1]||'';
-  let digits=(i+f).replace(/^0+(?=\d)/,'')||'0',decPlaces=f.length-exp;
-  if(decPlaces<0){digits+='0'.repeat(-decPlaces);decPlaces=0}
-  const den=10n**BigInt(decPlaces),v=(BigInt(digits)*one()+den/2n)/den;return neg?-v:v;
-}
-function decimalRequiredBits(s){s=String(s).trim().replace(/^[+-]/,'');const p=s.toLowerCase().split('e'),f=(p[0].split('.')[1]||'').length,e=p[1]?parseInt(p[1],10):0,places=Math.max(0,f-e);return Math.max(64,Math.ceil(places*Math.log2(10))+32)}
-function bitLen(n){n=n<0n?-n:n;return n===0n?0:n.toString(2).length}
-function fixedNum(v,bits=state.bits){
-  if(v===0n)return 0;let neg=v<0n;if(neg)v=-v;
-  const bl=bitLen(v),keep=52;let top,exp;
-  if(bl>keep){const sh=BigInt(bl-keep);top=Number(v>>sh);exp=(bl-keep)-bits}else{top=Number(v);exp=-bits}
-  const x=top*Math.pow(2,exp);return neg?-x:x;
-}
-// Hot-path conversion for orbit values known to stay O(1).
-function fixedOrbitNum(v,bits){
-  if(v===0n)return 0;
-  const sh=bits-54;
-  if(sh>0)return Number(v>>BigInt(sh))*Math.pow(2,-54);
-  return Number(v)*Math.pow(2,-bits);
-}
+function fromDec(s){s=String(s).trim();let neg=s.startsWith('-');if(neg)s=s.slice(1);if(s.startsWith('+'))s=s.slice(1);const p=s.toLowerCase().split('e'),mant=p[0],exp=p[1]?parseInt(p[1],10):0,a=mant.split('.'),i=a[0]||'0',f=a[1]||'';let digits=(i+f).replace(/^0+(?=\d)/,'')||'0',places=f.length-exp;if(places<0){digits+='0'.repeat(-places);places=0}const den=10n**BigInt(places),v=(BigInt(digits)*one()+den/2n)/den;return neg?-v:v}
+function decimalRequiredBits(s){s=String(s).trim().replace(/^[+-]/,'');const p=s.toLowerCase().split('e'),f=(p[0].split('.')[1]||'').length,e=p[1]?parseInt(p[1],10):0;return Math.max(64,Math.ceil(Math.max(0,f-e)*Math.log2(10))+32)}
+function bitLen(v){v=v<0n?-v:v;return v===0n?0:v.toString(2).length}
+function align(v,fromBits,toBits){const d=toBits-fromBits;return d===0?v:d>0?v<<BigInt(d):v>>BigInt(-d)}
+function fixedNum(v,bits=state.bits){if(v===0n)return 0;const neg=v<0n;if(neg)v=-v;const bl=bitLen(v),keep=52;let top,exp;if(bl>keep){const sh=BigInt(bl-keep);top=Number(v>>sh);exp=bl-keep-bits}else{top=Number(v);exp=-bits}const x=top*Math.pow(2,exp);return neg?-x:x}
 function log2FixedAt(v,bits){v=v<0n?-v:v;if(v===0n)return-Infinity;const bl=bitLen(v),take=Math.min(53,bl),sh=bl-take,top=Number(v>>BigInt(sh));return Math.log2(top)+sh-bits}
 function log2Fixed(v){return log2FixedAt(v,state.bits)}
-function zoomExp(){return Math.max(0,Math.log10(3.4)-log2Fixed(state.span)/Math.log2(10))}
-function fixedRatio(a,b){
-  if(b===0n)return 0;if(a===0n)return 0;const neg=a<0n;if(neg)a=-a;
-  const q=(a<<52n)/b;const v=Number(q)/4503599627370496;return neg?-v:v;
-}
-function align(v,fromBits,toBits){const d=toBits-fromBits;return d===0?v:d>0?v<<BigInt(d):v>>BigInt(-d)}
-function promoteState(shift){
-  // Precision promotion used to invalidate the reference orbit. Keep the same
-  // mathematical values by shifting their fixed-point representation instead.
-  // If a render is in flight, logically cancel it before mutating shared cache state.
-  if(state.rendering)cancelRender();
-  const oldBits=state.bits,s=BigInt(shift);state.re<<=s;state.im<<=s;state.span<<=s;
-  if(state.frameView){state.frameView.re<<=s;state.frameView.im<<=s;state.frameView.span<<=s;state.frameView.bits+=shift}
-  state.bits+=shift;
-  promoteReferenceCache(shift,oldBits);
-}
-function ensurePrecision(){
-  const bl=bitLen(state.span);
-  if(bl>=MIN_SPAN_BITS)return false;
-  // Defer representation-only precision promotion until the current frame finishes.
-  if(state.rendering){state.precisionPending=true;return false}
-  state.precisionPending=false;promoteState(TARGET_SPAN_BITS-bl);return true
-}
-function flushPendingPrecision(){
-  if(state.rendering||!state.precisionPending)return false;state.precisionPending=false;
-  const bl=bitLen(state.span);if(bl<MIN_SPAN_BITS){promoteState(TARGET_SPAN_BITS-bl);return true}return false
-}
-function mulRatio(v,factor){
-  const n=BigInt(Math.max(1,Math.round(factor*Number(RATIO_DEN))));return v*n/RATIO_DEN;
-}
+function fixedRatio(a,b){if(!b||!a)return 0;let neg=a<0n;if(neg)a=-a;const q=(a<<52n)/b,v=Number(q)/4503599627370496;return neg?-v:v}
+function mulRatio(v,f){const n=BigInt(Math.max(1,Math.round(f*Number(RATIO_DEN))));return v*n/RATIO_DEN}
+function promoteState(shift){const s=BigInt(shift);state.re<<=s;state.im<<=s;state.span<<=s;if(state.frameView){state.frameView={...state.frameView,bits:state.frameView.bits+shift,re:state.frameView.re<<s,im:state.frameView.im<<s,span:state.frameView.span<<s}}state.bits+=shift}
+function ensurePrecision(){const bl=bitLen(state.span);if(bl<MIN_SPAN_BITS)promoteState(TARGET_SPAN_BITS-bl)}
 function fmtFixed(v,d=17){let neg=v<0n;if(neg)v=-v;const scale=10n**BigInt(d),q=v*scale>>BigInt(state.bits);let s=q.toString().padStart(d+1,'0');s=s.slice(0,-d)+'.'+s.slice(-d);s=s.replace(/(\.\d*?)0+$/,'$1').replace(/\.$/,'');return(neg?'-':'')+s}
-function fmtFixedExact(v){let neg=v<0n;if(neg)v=-v;const d=state.bits,q=v*(10n**BigInt(d))>>BigInt(state.bits);let s=q.toString().padStart(d+1,'0');s=s.slice(0,-d)+'.'+s.slice(-d);s=s.replace(/(\.\d*?)0+$/,'$1').replace(/\.$/,'');return(neg?'-':'')+s}
-function fmtSpan(){const l=log2Fixed(state.span);if(!Number.isFinite(l))return'0';const e=Math.floor(l/Math.log2(10)),m=Math.pow(2,l-e*Math.log2(10));return m.toFixed(4)+'e'+e}
-function maxIter(){if(!state.adaptive)return state.baseIter;const z=zoomExp();if(z<12)return Math.min(12000,Math.round(state.baseIter+22*Math.sqrt(z)*Math.log2(2+z)));return Math.min(140000,Math.round(state.baseIter+150*z+260*Math.log2(2+z)))}
-function ensureOrbitPrecision(iter,width=Math.max(1,canvas.width)){const conditionBits=referenceCache.rr?Math.max(0,Math.min(256,Math.ceil(referenceCache.conditionLog2||0))):0,required=160+conditionBits,available=bitLen(state.span)-Math.ceil(Math.log2(width))-Math.ceil(Math.log2(Math.max(2,iter)));if(available>=required)return false;promoteState(required+32-available);invalidateReferenceOrbit();return true}
-function f64Ulp(x){x=Math.abs(x);if(!Number.isFinite(x))return Infinity;if(x===0)return Number.MIN_VALUE;return Math.pow(2,Math.floor(Math.log2(x))-52)}
-function deepResolutionRatio(snap=snapshot(),width=Math.max(1,canvas.width)){const step=Math.abs(fixedNum(snap.span,snap.bits))/Math.max(1,width),ulp=Math.max(f64Ulp(fixedNum(snap.re,snap.bits)),f64Ulp(fixedNum(snap.im,snap.bits)));return step===0||!Number.isFinite(step)?0:step/Math.max(Number.MIN_VALUE,ulp)}
-function deepEngineNeeded(snap=snapshot(),width=Math.max(1,canvas.width)){if(exportForcePrecision)return true;const ratio=deepResolutionRatio(snap,width),orbitRisk=ratio<=128&&(deepTelemetry.badRatio>1e-4||deepTelemetry.unresolvedRatio>2e-3||deepTelemetry.repairRatio>.08);deepMode=orbitRisk||(deepMode?ratio<64:ratio<=32);return deepMode}
-function iterationPlan(profile,deep){
-  const colorIter=maxIter();return{colorIter,computeIter:colorIter};
-}
-function workProfile(profile){return{bla:profile.blaSteps,ptb:profile.ptbSteps}}
-function cancelRender(){state.token++;state.rendering=false;cancelDeepPoolJob();flushPendingPrecision()}
-function cancelDetailRefinement(clearCurrent=true){
-  state.detailGeneration++;state.detailActive=false;state.detailQueued=0;state.detailDone=0;detailPlan=null;
-  if(clearCurrent)activeDetailTiles.length=0;
-}
-function clearDetailCache(){DETAIL_TILE_CACHE.clear();detailCacheBytes=0;activeDetailTiles.length=0;cancelDetailRefinement(false)}
-function setDirty(cancel=true){cancelUnknownContinuation();state.lastInteraction=performance.now();state.dirty=true;state.lastPass=null;state.drawState=state.frameView?'REPROJECTED':'PREVIEW';state.coverage=0;cancelDetailRefinement(true);if(cancel)cancelRender();invalidateView()}
-function reset(){
-  clearDetailCache();clearPanReuse();state.bits=INITIAL_BITS;state.re=-fromFrac(1n,2n);state.im=0n;state.span=fromFrac(34n,10n);setDirty();saveHash(false)
-}
-function viewRect(){return canvas.getBoundingClientRect()}
-function updateFocus(x,y){const r=viewRect();state.focusX=Math.max(0,Math.min(1,(x-r.left)/Math.max(1,r.width)));state.focusY=Math.max(0,Math.min(1,(y-r.top)/Math.max(1,r.height)))}
-function zoomAt(x,y,factor){
-  if(!state.panReuse)capturePanSource();
-  const r=viewRect(),fx=(x-r.left)/Math.max(1,r.width)-.5,fy=(y-r.top)/Math.max(1,r.height)-.5;
-  factor=Math.max(.01,Math.min(100,factor));const old=state.span,neu=mulRatio(old,factor);
-  const dx=BigInt(Math.round(fx*1e9)),dy=BigInt(Math.round(fy*1e9));
-  state.re+=(old-neu)*dx/1000000000n;
-  const oldY=old*BigInt(canvas.height)/BigInt(Math.max(1,canvas.width)),newY=neu*BigInt(canvas.height)/BigInt(Math.max(1,canvas.width));
-  state.im-=(oldY-newY)*dy/1000000000n;state.span=neu;ensurePrecision();setDirty(!(state.pointerActive||state.wheelActive));
-}
-function pan(dx,dy){
-  const w=Math.max(1,canvas.clientWidth),h=Math.max(1,canvas.clientHeight);
-  state.re-=state.span*BigInt(Math.round(dx*100000))/BigInt(Math.round(w*100000));
-  const ys=state.span*BigInt(canvas.height)/BigInt(Math.max(1,canvas.width));
-  state.im+=ys*BigInt(Math.round(dy*100000))/BigInt(Math.round(h*100000));setDirty(!(state.pointerActive||state.wheelActive));
-}
-
-
-function clearPanReuse(){state.panReuse=null}
-function capturePanSource(){
-  if(!state.frameView||!frameCanvas.width||!frameCanvas.height)return false;
-  const fv=state.frameView;state.panReuse={canvas:frameCanvas,snap:{bits:fv.bits,re:fv.re,im:fv.im,span:fv.span},style:styleSignature(),pass:state.lastPass,iter:maxIter(),created:performance.now()};return true
-}
-function buildPanReuse(snap,w,h,iter,profile){
-  const src=state.panReuse;if(!src||!src.canvas||src.style!==styleSignature())return null;
-  // Final HQ must recompute after a real scale change. Interactive/base passes may
-  // reproject a much larger range so wheel/pinch zoom can reuse existing pixels.
-  const re=align(src.snap.re,src.snap.bits,snap.bits),im=align(src.snap.im,src.snap.bits,snap.bits),sp=align(src.snap.span,src.snap.bits,snap.bits),scale=fixedRatio(sp,snap.span);
-  if(!Number.isFinite(scale)||scale<.22||scale>4.5)return null;
-  const scaleChange=Math.abs(Math.log2(Math.max(1e-12,scale)));
-  // Covered is a sampling contract, not a presentation shortcut. Reprojection
-  // is allowed only for Preview; the target grid is always recomputed in full.
-  if(profile.covered)return null;
-  const dx=fixedRatio(re-snap.re,snap.span)*w,dy=-fixedRatio(im-snap.im,snap.span)*w,move=Math.hypot(dx/Math.max(1,w),dy/Math.max(1,w));if(!Number.isFinite(move)||move>1.35)return null;
-  const dw=w*scale,dh=w*scale*(src.canvas.height/Math.max(1,src.canvas.width)),density=dw/Math.max(1,src.canvas.width);
-  // A zoomed preview may stretch old pixels temporarily, but the idle HQ pass will
-  // recompute it. Keep the stretch bounded so interaction never becomes misleading.
-  if(density>profile.densityLimit)return null;
-  const x0=w*.5+dx-dw*.5,y0=h*.5+dy-dh*.5,x1=x0+dw,y1=y0+dh;
-  let ix0=Math.max(0,Math.ceil(x0)+2),iy0=Math.max(0,Math.ceil(y0)+2),ix1=Math.min(w,Math.floor(x1)-2),iy1=Math.min(h,Math.floor(y1)-2);
-  if(ix1<=ix0||iy1<=iy0)return null;
-  const overlap=(ix1-ix0)*(iy1-iy0),frac=overlap/Math.max(1,w*h);if(frac<.20)return null;
-  const c=document.createElement('canvas');c.width=w;c.height=h;const cc=c.getContext('2d',{alpha:false});if(!cc)return null;cc.fillStyle='#050813';cc.fillRect(0,0,w,h);cc.imageSmoothingEnabled=true;try{cc.imageSmoothingQuality='high'}catch{};cc.drawImage(src.canvas,x0,y0,dw,dh);
-  const out=new Uint8ClampedArray(cc.getImageData(0,0,w,h).data),rects=[];
-  const add=(x,y,rw,rh)=>{x=Math.max(0,x|0);y=Math.max(0,y|0);rw=Math.min(w-x,rw|0);rh=Math.min(h-y,rh|0);if(rw>0&&rh>0)rects.push({x0:x,y0:y,w:rw,h:rh})};
-  add(0,0,w,iy0);add(0,iy1,w,h-iy1);add(0,iy0,ix0,iy1-iy0);add(ix1,iy0,w-ix1,iy1-iy0);
-  const exposed=rects.reduce((a,r)=>a+r.w*r.h,0);if(exposed>w*h*.80)return null;
-  return{out,rects,reusedPixels:w*h-exposed,exposedPixels:exposed,scale};
-}
-
-// ── Palette / smooth colouring ───────────────────────────────────────────
-const PALETTE_CURRENT=0,PALETTE_RAINBOW=1,PALETTE_MONO=2;
-const FIELD_ESCAPED=1,FIELD_INTERIOR_PROVEN=2,FIELD_INTERIOR_LIKELY=3,FIELD_UNKNOWN=4;
-const stops=[[0,[4,10,27]],[.11,[12,53,79]],[.25,[31,156,184]],[.38,[91,226,234]],[.50,[66,53,151]],[.62,[139,49,170]],[.73,[232,72,145]],[.84,[255,137,64]],[.93,[255,211,99]],[1,[255,250,223]]];
-const COLOR_PHASES=2048,COLOR_MIXES=64;
-function hsvRgb(h,sat,val){h=((h%1)+1)%1;const x=h*6,i=Math.floor(x),f=x-i,p=val*(1-sat),q=val*(1-sat*f),s=val*(1-sat*(1-f));let r,g,b;switch(i%6){case 0:r=val;g=s;b=p;break;case 1:r=q;g=val;b=p;break;case 2:r=p;g=val;b=s;break;case 3:r=p;g=q;b=val;break;case 4:r=s;g=p;b=val;break;default:r=val;g=p;b=q}return[r*255,g*255,b*255]}
-function basePalette(kind,t){
-  t=((t%1)+1)%1;
-  if(kind===PALETTE_RAINBOW)return hsvRgb(t,.92,1);
-  if(kind===PALETTE_MONO){const g=22+233*(.5-.5*Math.cos(Math.PI*2*t));return[g,g,g]}
-  let a=stops[0],b=stops[stops.length-1];for(let j=1;j<stops.length;j++){if(t<=stops[j][0]){a=stops[j-1];b=stops[j];break}}
-  let f=(t-a[0])/(b[0]-a[0]||1);f=f*f*(3-2*f);return[a[1][0]+(b[1][0]-a[1][0])*f,a[1][1]+(b[1][1]-a[1][1])*f,a[1][2]+(b[1][2]-a[1][2])*f]
-}
-function buildColorLut(kind){const lut=new Uint8Array(COLOR_PHASES*3);for(let pi=0;pi<COLOR_PHASES;pi++){const u=pi/(COLOR_PHASES-1),t=kind===PALETTE_CURRENT?(u<=.5?u*2:2-u*2):u,c=basePalette(kind,t),k=pi*3;lut[k]=c[0]|0;lut[k+1]=c[1]|0;lut[k+2]=c[2]|0}return lut}
-const COLOR_LUTS=[buildColorLut(PALETTE_CURRENT),buildColorLut(PALETTE_RAINBOW),buildColorLut(PALETTE_MONO)];
-const SMOOTH_U_MIN=2,SMOOTH_U_STEP=1/128,SMOOTH_U_N=4097,SMOOTH_CORR=new Float32Array(SMOOTH_U_N);
-for(let i=0;i<SMOOTH_U_N;i++){const u=SMOOTH_U_MIN+i*SMOOTH_U_STEP;SMOOTH_CORR[i]=1-Math.log2(.5*u)}
-const COLOR_CTX_CACHE=new Map();
-function makeColorCtx(iter){let hit=COLOR_CTX_CACHE.get(iter);if(hit)return hit;const mixBin=new Uint8Array(iter+1),den=Math.log1p(Math.max(8,iter));for(let n=0;n<=iter;n++){const edge=Math.max(0,Math.min(1,Math.log1p(n)/den));mixBin[n]=Math.min(COLOR_MIXES-1,Math.round((COLOR_MIXES-1)*Math.pow(edge,.38)))}hit={mixBin};COLOR_CTX_CACHE.set(iter,hit);if(COLOR_CTX_CACHE.size>8)COLOR_CTX_CACHE.delete(COLOR_CTX_CACHE.keys().next().value);return hit}
-function smoothEscape(n,m){const u=Math.log2(Math.max(4.0000001,m));let corr;const fi=(u-SMOOTH_U_MIN)/SMOOTH_U_STEP;if(fi>=0&&fi<SMOOTH_U_N-1){const i=fi|0,f=fi-i;corr=SMOOTH_CORR[i]+(SMOOTH_CORR[i+1]-SMOOTH_CORR[i])*f}else corr=1-Math.log2(.5*u);return n+corr}
-function putPaletteColor(out,oi,sm,n,iter,colorCtx){let phase=state.shift+sm*state.cycle;phase-=Math.floor(phase);const pi=Math.min(COLOR_PHASES-1,(phase*COLOR_PHASES)|0),mi=colorCtx.mixBin[Math.min(iter,n)],mix=.34+.66*(mi/(COLOR_MIXES-1)),kind=state.palette,lut=COLOR_LUTS[kind]||COLOR_LUTS[0],k=pi*3,f0=kind===PALETTE_MONO?8:2,f1=kind===PALETTE_MONO?8:5,f2=kind===PALETTE_MONO?8:15;out[oi]=(f0+(lut[k]-f0)*mix)|0;out[oi+1]=(f1+(lut[k+1]-f1)*mix)|0;out[oi+2]=(f2+(lut[k+2]-f2)*mix)|0;out[oi+3]=255}
-function putFastColor(out,oi,n,m,iter,colorCtx){putPaletteColor(out,oi,smoothEscape(n,m),n,iter,colorCtx)}
-function makeField(size,iter){return{smooth:new Float32Array(size),iterations:new Uint32Array(size),classes:new Uint8Array(size),confidence:new Uint8Array(size),iter}}
-function fieldConfidence(kind){return kind===FIELD_ESCAPED||kind===FIELD_INTERIOR_PROVEN?255:kind===FIELD_INTERIOR_LIKELY?192:0}
-function putField(field,index,n,m,kind){field.classes[index]=kind;if(field.iterations)field.iterations[index]=Math.max(0,n)>>>0;if(field.confidence)field.confidence[index]=fieldConfidence(kind);if(kind===FIELD_ESCAPED)field.smooth[index]=smoothEscape(n,m);else field.smooth[index]=NaN}
-function fillFieldConfidence(field){if(!field.confidence)field.confidence=new Uint8Array(field.classes.length);for(let i=0;i<field.classes.length;i++)field.confidence[i]=fieldConfidence(field.classes[i])}
-function colorizeField(field){const out=new Uint8ClampedArray(field.classes.length*4),colorCtx=makeColorCtx(field.iter);for(let i=0,oi=0;i<field.classes.length;i++,oi+=4){const kind=field.classes[i];if(kind!==FIELD_ESCAPED){const neutral=kind===FIELD_UNKNOWN;out[oi]=neutral?20:0;out[oi+1]=neutral?22:0;out[oi+2]=neutral?30:0;out[oi+3]=255;continue}const sm=field.smooth[i],n=Math.max(0,Math.min(field.iter,Math.floor(sm)));putPaletteColor(out,oi,sm,n,field.iter,colorCtx)}return out}
-
-// Embedded WebAssembly: SIMD-optimized kernel with a scalar fallback.
-
-
-let wasm=null;
-function instantiateWasm(b64){
-  const module=b64 instanceof WebAssembly.Module?b64:(()=>{const raw=atob(b64),bytes=new Uint8Array(raw.length);for(let i=0;i<raw.length;i++)bytes[i]=raw.charCodeAt(i);return new WebAssembly.Module(bytes)})(),inst=new WebAssembly.Instance(module,{}),ex=inst.exports;
-  return {module,ex,counts:()=>new Uint32Array(ex.memory.buffer,ex.counts_ptr(),65536),mags:()=>new Float64Array(ex.memory.buffer,ex.mags_ptr(),65536),refsR:()=>new Float64Array(ex.memory.buffer,ex.refs_r_ptr(),150001),refsI:()=>new Float64Array(ex.memory.buffer,ex.refs_i_ptr(),150001)};
-}
-try{wasm=instantiateWasm(WASM_SIMD_B64);wasm.simd=globalThis.MANDEL_HOSTED_SHALLOW_SIMD!==false}catch(e){try{wasm=instantiateWasm(WASM_SCALAR_B64);wasm.simd=false}catch(_e){wasm=null}}
-let shallowWorker=null,shallowWorkerUrl=null,shallowWorkerBusy=false,shallowRecycle=null;
-function shallowWorkerSource(){return `'use strict';let ex=null;function smooth(n,m){const u=Math.log2(Math.max(4.0000001,m));return n+1-Math.log2(.5*u)}function likely(cr,ci){const y2=ci*ci,x=cr-.25,q=x*x+y2;if(q*(q+x)<=.25*y2)return true;const x2=cr+1;return x2*x2+y2<=.0625}self.onmessage=e=>{const d=e.data;if(d.type==='init'){ex=new WebAssembly.Instance(d.module,{}).exports;postMessage({type:'ready'});return}if(d.type!=='render'||!ex)return;try{const scale=d.sp/d.w,npx=ex.render_rows(d.cre+scale*.5,d.cim-scale*.5,d.sp,d.w,d.h,d.y,d.rows,d.iter),counts=new Uint32Array(ex.memory.buffer,ex.counts_ptr(),65536),mags=new Float64Array(ex.memory.buffer,ex.mags_ptr(),65536),field=d.fieldBuffer&&d.fieldBuffer.byteLength>=npx*4?new Float32Array(d.fieldBuffer,0,npx):new Float32Array(npx),iterations=d.iterationBuffer&&d.iterationBuffer.byteLength>=npx*4?new Uint32Array(d.iterationBuffer,0,npx):new Uint32Array(npx),classes=d.classBuffer&&d.classBuffer.byteLength>=npx?new Uint8Array(d.classBuffer,0,npx):new Uint8Array(npx);for(let i=0;i<npx;i++){const n=counts[i],x=i%d.w,y=d.y+((i/d.w)|0),cr=d.cre+(x+.5-d.w*.5)*scale,ci=d.cim+(d.h*.5-y-.5)*scale;iterations[i]=n;if(n<d.iter){classes[i]=1;field[i]=smooth(n,mags[i])}else{classes[i]=likely(cr,ci)?3:4;field[i]=NaN}}postMessage({type:'render',jobId:d.jobId,y:d.y,rows:d.rows,field:field.buffer,iterations:iterations.buffer,classes:classes.buffer},[field.buffer,iterations.buffer,classes.buffer])}catch(error){postMessage({type:'render',jobId:d.jobId,error:String(error&&error.message||error)})}}`}
-function ensureShallowWorker(){if(shallowWorker||!wasm||typeof Worker==='undefined'||typeof Blob==='undefined')return!!shallowWorker;try{shallowWorkerUrl=URL.createObjectURL(new Blob([shallowWorkerSource()],{type:'text/javascript'}));shallowWorker=new Worker(shallowWorkerUrl);shallowWorker.postMessage({type:'init',module:wasm.module});return true}catch{shallowWorker=null;return false}}
-function destroyShallowWorker(){if(shallowWorker){try{shallowWorker.terminate()}catch{}shallowWorker=null}if(shallowWorkerUrl){try{URL.revokeObjectURL(shallowWorkerUrl)}catch{}shallowWorkerUrl=null}shallowWorkerBusy=false;shallowRecycle=null}
-
-
-
-function instantiateDeepWasm(b64){
-  const module=b64 instanceof WebAssembly.Module?b64:(()=>{const raw=atob(b64),bytes=new Uint8Array(raw.length);for(let i=0;i<raw.length;i++)bytes[i]=raw.charCodeAt(i);return new WebAssembly.Module(bytes)})();
-  const ex=new WebAssembly.Instance(module,{}).exports;
-  return {ex,counts:()=>new Uint32Array(ex.memory.buffer,ex.counts_ptr(),65536),mags:()=>new Float64Array(ex.memory.buffer,ex.mags_ptr(),65536),refsR:()=>new Float64Array(ex.memory.buffer,ex.refs_r_ptr(),150001),refsI:()=>new Float64Array(ex.memory.buffer,ex.refs_i_ptr(),150001)};
-}
-let deepWasm=null,deepWasmTried=false,deepModuleBundle=null,deepModulePromise=null;
-async function compileKernelSource(source){if(source instanceof WebAssembly.Module)return source;if(/^https?:/i.test(source)){const response=await fetch(source,{cache:'force-cache'});if(!response.ok)throw new Error('WASM request failed '+response.status);if(WebAssembly.compileStreaming){try{return await WebAssembly.compileStreaming(Promise.resolve(response.clone()))}catch{}}return WebAssembly.compile(await response.arrayBuffer())}const raw=atob(source),bytes=new Uint8Array(raw.length);for(let i=0;i<raw.length;i++)bytes[i]=raw.charCodeAt(i);return WebAssembly.compile(bytes)}
-async function compileKernelPair(simd,scalar){try{return{module:await compileKernelSource(simd),simd:true}}catch{return{module:await compileKernelSource(scalar),simd:false}}}
-function prepareDeepModules(){if(deepModuleBundle)return Promise.resolve(deepModuleBundle);if(!deepModulePromise)deepModulePromise=Promise.all([compileKernelPair(DEEP_SIMD_B64,DEEP_SCALAR_B64),compileKernelPair(BLA_SIMD_B64,BLA_SCALAR_B64),compileKernelPair(COLOR_SIMD_B64,COLOR_SCALAR_B64)]).then(([deep,bla,color])=>deepModuleBundle={deep,bla,color}).catch(error=>{deepModulePromise=null;throw error});return deepModulePromise}
-function ensureDeepWasm(){
-  if(deepWasm)return true;if(deepWasmTried)return false;deepWasmTried=true;if(deepModuleBundle){try{deepWasm=instantiateDeepWasm(deepModuleBundle.deep.module);deepWasm.simd=deepModuleBundle.deep.simd}catch{deepWasm=null}return!!deepWasm}if(/^https?:/i.test(DEEP_SIMD_B64)||/^https?:/i.test(DEEP_SCALAR_B64))return false;
-  try{deepWasm=instantiateDeepWasm(DEEP_SIMD_B64);deepWasm.simd=true}catch(e){try{deepWasm=instantiateDeepWasm(DEEP_SCALAR_B64);deepWasm.simd=false}catch(_e){deepWasm=null}}
-  return!!deepWasm
-}
-
-
-
-
-
-
-
-// Deep renderer worker pool. Each worker owns a WASM instance and performs both the
-// perturbation kernel and colour mapping, so colourful frames no longer funnel all
-// post-processing through the UI thread. Jobs are striped dynamically for load balance.
-const deepPool={workers:[],url:null,activeToken:0,serial:0,failed:false,current:null,maxWorkers:0,benchTimer:0};
-// ── Persistent deep-render workers / BLA kernel ──────────────────────────
-function deepWorkerSource(){
-  return `'use strict';
-let core=null,blaCore=null,colorCore=null,refKey='',refLoaded=0,RR=new Float64Array(150001),RI=new Float64Array(150001),blaRefKey='',blaRefLoaded=0,blaBuiltKey='',lastBlaBuildMs=0;
-function ensure(){if(!core)throw new Error('deep module not initialized');return core}
-function ensureBla(){if(!blaCore)throw new Error('BLA module not initialized');return blaCore}
-function ensureColor(){if(!colorCore)throw new Error('color module not initialized');return colorCore}
-function applyRef(d,ex){if(d.refKey!==refKey){refKey=d.refKey;refLoaded=0;blaRefKey='';blaRefLoaded=0;blaBuiltKey=''}if(d.rr){const ar=new Float64Array(d.rr),ai=new Float64Array(d.ri),st=d.rrStart|0;RR.set(ar,st);RI.set(ai,st);new Float64Array(ex.memory.buffer,ex.refs_r_ptr(),150001).set(ar,st);new Float64Array(ex.memory.buffer,ex.refs_i_ptr(),150001).set(ai,st);refLoaded=Math.max(refLoaded,st+ar.length);if(blaCore&&blaRefKey===refKey){const bx=blaCore.ex;new Float64Array(bx.memory.buffer,bx.refs_r_ptr(),150001).set(ar,st);new Float64Array(bx.memory.buffer,bx.refs_i_ptr(),150001).set(ai,st);blaRefLoaded=Math.max(blaRefLoaded,st+ar.length);blaBuiltKey=''}}if(refLoaded<d.refLen+1)throw new Error('reference cache miss')}
-function syncRefsToBla(d,key=d.blaKey,eps=d.blaEps){if(!d.useBla)return null;const b=ensureBla(),ex=b.ex;if(blaRefKey!==refKey){new Float64Array(ex.memory.buffer,ex.refs_r_ptr(),150001).set(RR.subarray(0,refLoaded));new Float64Array(ex.memory.buffer,ex.refs_i_ptr(),150001).set(RI.subarray(0,refLoaded));blaRefKey=refKey;blaRefLoaded=refLoaded;blaBuiltKey=''}else if(refLoaded>blaRefLoaded){new Float64Array(ex.memory.buffer,ex.refs_r_ptr(),150001).set(RR.subarray(blaRefLoaded,refLoaded),blaRefLoaded);blaRefLoaded=refLoaded;blaBuiltKey=''}lastBlaBuildMs=0;if(blaBuiltKey!==key){const t=performance.now(),levels=ex.build_bla(d.refLen,d.cMax,eps);lastBlaBuildMs=performance.now()-t;if(!levels)return null;blaBuiltKey=key}return b}
-function smoothBatch(srcMags,npx){const c=ensureColor(),ex=c.ex,mi=new Float64Array(ex.memory.buffer,ex.mags_ptr(),65536),co=new Float32Array(ex.memory.buffer,ex.corr_ptr(),65536);mi.set(srcMags.subarray(0,npx),0);ex.smooth_batch(npx);return co}
-function strictOne(ex,x,y,d){const counts=new Uint32Array(ex.memory.buffer,ex.counts_ptr(),65536),mags=new Float64Array(ex.memory.buffer,ex.mags_ptr(),65536);ex.render_perturb_rebase_rect(d.spanMant,d.spanBucket,d.offR,d.offI,d.offBucket,d.refLen,d.w,d.h,d.cx,d.cy,x,y,1,1,d.iter,0,0,0,0,0,0,0);return[counts[0],mags[0]]}
-function stats(bx){return{blaSteps:bx.stat_bla_steps?bx.stat_bla_steps():0,ptbSteps:bx.stat_ptb_steps?bx.stat_ptb_steps():0,rebases:bx.stat_rebases?bx.stat_rebases():0,interior:bx.stat_interior?bx.stat_interior():0,unresolved:bx.stat_unresolved?bx.stat_unresolved():0,fail:bx.stat_fail?bx.stat_fail():0}}
-function renderBla(d,b,key,eps,bcap,pcap){const bx=b.ex;if(key!==d.blaKey||eps!==d.blaEps)b=syncRefsToBla(d,key,eps)||b;const t=performance.now(),npx=bx.render_bla_rect_v2?bx.render_bla_rect_v2(d.spanNormal,d.offRn,d.offIn,d.baseCr,d.baseCi,d.refLen,d.w,d.h,d.x0||0,d.y0,d.rectW||d.w,d.rows,d.iter,bcap||0,pcap||0,1):bx.render_bla_rect(d.spanNormal,d.offRn,d.offIn,d.refLen,d.w,d.h,d.x0||0,d.y0,d.rectW||d.w,d.rows,d.iter);return{npx,kernelMs:performance.now()-t,counts:new Uint32Array(bx.memory.buffer,bx.counts_ptr(),65536),mags:new Float64Array(bx.memory.buffer,bx.mags_ptr(),65536),stats:stats(bx)}}
-function verifyAgainstSafe(d,result,rw,npx,b){const want=d.verifySamples||0;if(!want||!b)return{samples:0,mismatch:0};const counts=Uint32Array.from(result.counts.subarray(0,npx)),mags=Float64Array.from(result.mags.subarray(0,npx));result.counts=counts;result.mags=mags;const picks=[],seen=new Set(),add=i=>{if(picks.length>=want)return;i=Math.max(0,Math.min(npx-1,i|0));if(!seen.has(i)){seen.add(i);picks.push(i)}};for(let k=0;k<Math.max(2,want>>1);k++)add(((k+.37)*npx/Math.max(2,want>>1))|0);const stride=Math.max(1,Math.floor(npx/Math.max(16,want*10))),top=[];for(let i=stride;i<npx;i+=stride){const n=counts[i],p=counts[i-stride];if(n<0xfffffffe&&p<0xfffffffe&&((n>=d.iter)!==(p>=d.iter))){add(i);add(i-stride)}if(n<d.iter&&n<0xfffffffe){top.push([n,i]);top.sort((a,b)=>b[0]-a[0]);if(top.length>want)top.length=want}}for(const x of top)add(x[1]);for(let k=0;picks.length<want&&k<want*2;k++)add(((k+.73)*npx/want)|0);let mismatch=0;const bad=[];for(const i of picks){const bn=counts[i];if(bn>=0xfffffffe)continue;const x=(d.x0||0)+(i%rw),y=d.y0+((i/rw)|0),sr=renderBla({...d,x0:x,y0:y,rectW:1,rows:1},b,d.safeBlaKey||d.blaKey,d.safeBlaEps||d.blaEps,0,0),sn=sr.counts[0];if(sn>=0xfffffffe)continue;if((bn>=d.iter)!==(sn>=d.iter)||Math.abs((bn|0)-(sn|0))>(d.verifyDelta||64)){mismatch++;bad.push(i)}}return{samples:picks.length,mismatch,bad}}
-self.onmessage=async e=>{const d=e.data;if(!d)return;if(d.type==='init'){try{core={ex:new WebAssembly.Instance(d.modules.deep.module,{}).exports,simd:!!d.modules.deep.simd};blaCore={ex:new WebAssembly.Instance(d.modules.bla.module,{}).exports,simd:!!d.modules.bla.simd};colorCore={ex:new WebAssembly.Instance(d.modules.color.module,{}).exports,simd:!!d.modules.color.simd};postMessage({type:'ready'})}catch(error){postMessage({type:'ready',error:String(error&&error.message||error)})}return}if(d.type!=='render'&&d.type!=='pilot'&&d.type!=='realBench')return;try{const c=ensure(),ex=c.ex;applyRef(d,ex);const b=syncRefsToBla(d);if((d.type==='pilot'||d.type==='realBench')&&!b)throw new Error('BLA unavailable');if(d.type==='pilot'||d.type==='realBench'){const reps=d.type==='realBench'?Math.max(1,d.repeats|0):1;let rr=null,total=0;for(let k=0;k<reps;k++){rr=renderBla({...d,x0:0,y0:0,rectW:d.w,rows:d.h},b,d.blaKey,d.blaEps,0,0);total+=rr.kernelMs}if(d.type==='realBench'){postMessage({type:'realBench',benchId:d.benchId,kernelMs:total,pixels:rr.npx*reps,blaBuildMs:lastBlaBuildMs,simd:b.simd});return}const co=rr.counts;let black=0,bad=0,sum=0;for(let i=0;i<rr.npx;i++){const n=co[i];if(n>=0xfffffffe){bad++;continue}sum+=Math.min(d.iter,n);if(n>=d.iter)black++}postMessage({type:'pilot',pilotId:d.pilotId,kernelMs:total,pixels:rr.npx,blaBuildMs:lastBlaBuildMs,blackRatio:black/Math.max(1,rr.npx),badRatio:bad/Math.max(1,rr.npx),meanIter:sum/Math.max(1,rr.npx-bad),stats:rr.stats,simd:b.simd});return}
-const rx=d.x0||0,rw=d.rectW||d.w,field=d.fieldBuffer&&d.fieldBuffer.byteLength>=rw*d.rows*4?new Float32Array(d.fieldBuffer,0,rw*d.rows):new Float32Array(rw*d.rows),iterations=d.iterationBuffer&&d.iterationBuffer.byteLength>=rw*d.rows*4?new Uint32Array(d.iterationBuffer,0,rw*d.rows):new Uint32Array(rw*d.rows),classes=d.classBuffer&&d.classBuffer.byteLength>=rw*d.rows?new Uint8Array(d.classBuffer,0,rw*d.rows):new Uint8Array(rw*d.rows),bad=[];let result,repaired=0,verifyMs=0;if(b){result=renderBla(d,b,d.blaKey,d.blaEps,d.maxBlaSteps||0,d.maxPtbSteps||0);let unresolved=result.stats.unresolved||0;if(unresolved&&d.covered){const co=result.counts,ma=result.mags;for(let i=0;i<result.npx;i++)if(co[i]===0xfffffffe){const x=rx+(i%rw),y=d.y0+((i/rw)|0),r=strictOne(ex,x,y,d);co[i]=r[0];ma[i]=r[1]}}
-const tv=performance.now();let v=verifyAgainstSafe(d,result,rw,result.npx,b);verifyMs=performance.now()-tv;if(v.mismatch){const safeKey=d.safeBlaKey||d.blaKey,safeEps=d.safeBlaEps||d.blaEps;result=renderBla(d,b,safeKey,safeEps,0,0);repaired=1}
-}else{const t=performance.now(),npx=ex.render_perturb_rebase_rect(d.spanMant,d.spanBucket,d.offR,d.offI,d.offBucket,d.refLen,d.w,d.h,d.cx,d.cy,rx,d.y0,rw,d.rows,d.iter,d.skip||0,d.Ar||0,d.Ai||0,d.Ab||0,d.Br||0,d.Bi||0,d.Bb||0);result={npx,kernelMs:performance.now()-t,counts:new Uint32Array(ex.memory.buffer,ex.counts_ptr(),65536),mags:new Float64Array(ex.memory.buffer,ex.mags_ptr(),65536),stats:{blaSteps:0,ptbSteps:0,rebases:0,interior:0,unresolved:0,fail:0}}}
-const corr=smoothBatch(result.mags,result.npx);let blackCount=0,sumIter=0;for(let i=0;i<result.npx;i++){let n=result.counts[i],m=result.mags[i];const x=rx+(i%rw),y=d.y0+((i/rw)|0);if(n>=0xfffffffe){if(n===0xffffffff){const r=strictOne(ex,x,y,d);n=r[0];m=r[1]}else{n=d.iter;m=0}}iterations[i]=n;if(n===0xffffffff){classes[i]=4;field[i]=NaN;bad.push(i);continue}sumIter+=Math.min(d.iter,n);if(n>=d.iter){classes[i]=4;field[i]=NaN;blackCount++;continue}classes[i]=1;field[i]=n+corr[i]}
-postMessage({type:'render',jobId:d.jobId,x0:rx,rectW:rw,y0:d.y0,rows:d.rows,field:field.buffer,iterations:iterations.buffer,classes:classes.buffer,bad,simd:c.simd,bla:!!b,blaSimd:b?b.simd:false,colorSimd:colorCore?colorCore.simd:false,kernelMs:result.kernelMs,verifyMs,blaBuildMs:lastBlaBuildMs,pixels:result.npx,blackCount,sumIter,stats:result.stats,verifySamples:d.verifySamples||0,repaired},[field.buffer,iterations.buffer,classes.buffer])}catch(err){postMessage({type:'render',jobId:d.jobId,error:String(err&&err.message||err)})}};
-`;
-}
-function destroyDeepPool(){
-  if(deepPool.current)deepPool.current.cancelled=true;deepPool.current=null;
-  for(const w of deepPool.workers){try{w.terminate()}catch{}}
-  deepPool.workers.length=0;if(deepPool.url){try{URL.revokeObjectURL(deepPool.url)}catch{}deepPool.url=null}
-  deepPool.activeToken=0;deepPool.maxWorkers=0
-}
-function retireDeepAssets(){destroyDeepPool();deepPool.failed=false;deepWasm=null;deepWasmTried=false;deepModuleBundle=null;deepModulePromise=null;referenceCache.rr=null;referenceCache.ri=null;referenceCache.series=null;referenceCache.n=0;referenceCache.escape=0;referenceCache.loadedLen=0;referenceCache.conditionLog2=0;referenceCache.derivative=[0,0,NEG_BUCKET]}
-function cancelDeepPoolJob(){
-  // Logical cancellation: keep Worker, WASM, reference and BLA caches alive.
-  deepPool.activeToken=0;
-  if(deepPool.current){deepPool.current.cancelled=true;deepPool.current=null}
-}
-function handleDeepWorkerMessage(worker,d){
-  const job=worker._job;worker._job=null;worker._busy=false;
-  if(d&&d.type==='ready'){if(d.error){worker._ready=false;deepPool.failed=true;destroyDeepPool();return}worker._ready=true;kickDeepWorker(worker);return}
-  if(!job){kickDeepWorker(worker);return}
-  if(job.type==='bench'){if(d&&d.type==='bench'&&d.benchId===job.benchId)job.resolve(d);else job.reject(new Error('benchmark reply mismatch'));kickDeepWorker(worker);return}
-  if(job.type==='pilot'||job.type==='realBench'){if(d&&((job.type==='pilot'&&d.type==='pilot'&&d.pilotId===job.id)||(job.type==='realBench'&&d.type==='realBench'&&d.benchId===job.id)))job.resolve(d);else job.reject(new Error(job.type+' reply mismatch'));kickDeepWorker(worker);return}
-  if(job.type==='render')job.runner.onResult(worker,d,job);
-  kickDeepWorker(worker)
-}
-function handleDeepWorkerError(worker,e){
-  const job=worker._job;worker._job=null;worker._busy=false;
-  if(job&&(job.type==='bench'||job.type==='pilot'||job.type==='realBench'))job.reject(e instanceof Error?e:new Error('worker job failed'));
-  else if(job&&job.type==='render')job.runner.fail(e);
-  else{deepPool.failed=true;destroyDeepPool()}
-}
-function deepWorkerLimit(){const hc=Math.max(1,navigator.hardwareConcurrency||4),memoryLimited=Number(navigator.deviceMemory||8)<=4?1:2;return Math.max(1,Math.min(memoryLimited,hc>2?hc-1:1))}
-function addDeepWorker(){if(!deepModuleBundle)throw new Error('deep modules are not ready');const i=deepPool.workers.length,w=new Worker(deepPool.url);w._index=i;w._refKey='';w._refLoaded=0;w._busy=false;w._ready=false;w._job=null;w._recycle=null;w.onmessage=e=>handleDeepWorkerMessage(w,e.data);w.onerror=e=>handleDeepWorkerError(w,e);deepPool.workers.push(w);w.postMessage({type:'init',modules:deepModuleBundle});return w}
-function ensureDeepPool(){
-  if(deepPool.failed||!deepModuleBundle||typeof Worker==='undefined'||typeof Blob==='undefined')return false;
-  if(deepPool.workers.length)return true;
-  try{
-    const count=deepWorkerLimit();
-    deepPool.url=URL.createObjectURL(new Blob([deepWorkerSource()],{type:'text/javascript'}));
-    deepPool.maxWorkers=count;deepWisdom.maxWorkers=count;deepWisdom.workerCount=1;addDeepWorker();
-    return true
-  }catch(e){deepPool.failed=true;destroyDeepPool();return false}
-}
-function prewarmDeepAssets(){prepareDeepModules().then(()=>{if(deepResolutionRatio()<=128)ensureDeepPool()}).catch(()=>{})}
-function kickDeepWorker(worker){
-  if(worker._busy||!worker._ready)return;
-  const r=deepPool.current;if(!r||r.cancelled||r.token!==state.token)return;
-  const active=Math.max(1,Math.min(deepWisdom.ready?deepWisdom.workerCount:Math.min(2,deepPool.workers.length),deepPool.workers.length));
-  if(worker._index>=active)return;
-  r.dispatch(worker)
-}
-function attachReference(worker,msg,ref,refLen,refKey,transfer){
-  let start=worker._refKey===refKey?worker._refLoaded:0;start=Math.max(0,Math.min(start,refLen+1));
-  if(start<refLen+1){const rr=ref.rr.slice(start,refLen+1),ri=ref.ri.slice(start,refLen+1);msg.rr=rr.buffer;msg.ri=ri.buffer;msg.rrStart=start;transfer.push(rr.buffer,ri.buffer);worker._refKey=refKey;worker._refLoaded=refLen+1}
-}
-function blaProfile(profile){
-  const z=zoomExp(),exp=profile.covered?32:(z<16?28:23);
-  // Fast pass + local verification/repair is cheaper than making the entire frame
-  // conservative.  Safe strips are rebuilt at e-48 only when a probe disagrees.
-  const safeExp=z<16?48:Math.min(48,Math.max(32,exp+8));
-  return{exp,eps:Math.pow(2,-exp),safeExp}
-}
-function runDeepPool(profile,snap,w,h,iter,colorIter,token,t0,out,sb,refC,off,ref,refLen,series,onFallback,rects=null){
-  if(!ensureDeepPool())return false;if(deepPool.current)deepPool.current.cancelled=true;
-  const centered=pixelCenteredOffset(snap,refC,w),workers=deepPool.workers,refKey=String(ref.id),bad=[],field=makeField(w*h,colorIter),spanNormal=fixedNum(snap.span,snap.bits),offRn=fixedNum(centered.r,snap.bits),offIn=fixedNum(centered.i,snap.bits),baseCr=fixedNum(refC.re,snap.bits),baseCi=fixedNum(refC.im,snap.bits);
-  const cMaxRaw=Math.hypot(offRn,offIn)+Math.abs(spanNormal)*Math.hypot(.5,h/(2*Math.max(1,w))),cBucket=cMaxRaw>0&&Number.isFinite(cMaxRaw)?Math.ceil(Math.log2(cMaxRaw)*8):0,cMaxSafe=cMaxRaw>0?Math.pow(2,cBucket/8):0,bp=blaProfile(profile),useBla=Number.isFinite(spanNormal)&&Math.abs(spanNormal)>=1e-280&&refLen>8,wp=workProfile(profile),colorCtx=makeColorCtx(colorIter);
-  const regions=(rects?rects:[{x0:0,y0:0,w,h}]).map(r=>({x0:Math.max(0,r.x0|0),y0:Math.max(0,r.y0|0),w:Math.max(0,Math.min(w-(r.x0|0),r.w|0)),h:Math.max(0,Math.min(h-(r.y0|0),r.h|0))})).filter(r=>r.w>0&&r.h>0),chunks=[];let preferredRows=deepWisdom.stripRows||16;if(deepWisdom.rowMsEMA>0)preferredRows=Math.round(deepWisdom.targetStripMs/deepWisdom.rowMsEMA);for(const r of regions){const rows=Math.max(2,Math.min(Math.max(1,Math.floor(65536/Math.max(1,r.w))),profile.covered?Math.max(4,preferredRows):Math.min(36,preferredRows)));for(let y=r.y0;y<r.y0+r.h;y+=rows)chunks.push({x0:r.x0,y0:y,w:r.w,rows:Math.min(rows,r.y0+r.h-y)})}chunks.sort((a,b)=>{const ad=Math.hypot((a.x0+a.w*.5)/w-state.focusX,(a.y0+a.rows*.5)/h-state.focusY),bd=Math.hypot((b.x0+b.w*.5)/w-state.focusX,(b.y0+b.rows*.5)/h-state.focusY);return ad-bd});
-  const totalPixels=regions.reduce((a,r)=>a+r.w*r.h,0),verifyJobs=profile.covered?8:3;
-  const runner={token,cancelled:false,chunkIndex:0,donePixels:0,totalPixels,failed:false,finishing:false,simd:true,blaUsed:false,kernelMs:0,verifyMs:0,blaBuildMs:0,sumIter:0,blackCount:0,badCount:0,blaSteps:0,ptbSteps:0,rebases:0,interior:0,unresolved:0,repaired:0,verifiedBuckets:new Set(),
-    fail(err){if(this.failed||this.cancelled)return;this.failed=true;deepPool.failed=true;destroyDeepPool();if(token===state.token)onFallback()},
-    nextChunk(){return this.chunkIndex<chunks.length?chunks[this.chunkIndex++]:null},
-    dispatch(worker){
-      if(this.cancelled||this.failed||token!==state.token)return false;const ch=this.nextChunk();if(!ch){this.maybeFinish();return false}
-      const jobId=token+':'+(++deepPool.serial),vb=Math.min(verifyJobs-1,Math.max(0,Math.floor((ch.y0+ch.rows*.5)*verifyJobs/Math.max(1,h)))),verifySamples=useBla&&!this.verifiedBuckets.has(vb)?(this.verifiedBuckets.add(vb),profile.covered?4:3):0,blaKey=refKey+':'+ref.version+':'+refLen+':'+cBucket+':e'+bp.exp,safeBlaKey=refKey+':'+ref.version+':'+refLen+':'+cBucket+':e'+bp.safeExp;
-      const msg={type:'render',jobId,refKey,refLen,w,h,x0:ch.x0,rectW:ch.w,y0:ch.y0,rows:ch.rows,iter,colorIter,covered:profile.covered,spanMant:sb.mant,spanBucket:sb.bucket,offR:off[0],offI:off[1],offBucket:off[2],cx:w*.5,cy:h*.5,skip:series.skip,Ar:series.Ar,Ai:series.Ai,Ab:series.Ab,Br:series.Br,Bi:series.Bi,Bb:series.Bb,shift:state.shift,cycle:state.cycle,palette:state.palette,useBla,blaEps:bp.eps,blaKey,safeBlaEps:Math.pow(2,-bp.safeExp),safeBlaKey,cMax:cMaxSafe,spanNormal,offRn,offIn,baseCr,baseCi,maxBlaSteps:wp.bla,maxPtbSteps:wp.ptb,verifySamples,verifyDelta:profile.covered?8:64},transfer=[];
-      attachReference(worker,msg,ref,refLen,refKey,transfer);if(worker._recycle){msg.fieldBuffer=worker._recycle.field;msg.iterationBuffer=worker._recycle.iterations;msg.classBuffer=worker._recycle.classes;transfer.push(msg.fieldBuffer,msg.iterationBuffer,msg.classBuffer);worker._recycle=null}worker._busy=true;worker._job={type:'render',runner:this,jobId,x0:ch.x0,y0:ch.y0,rectW:ch.w,rows:ch.rows,pixels:ch.w*ch.rows,started:performance.now()};try{worker.postMessage(msg,transfer)}catch(e){worker._busy=false;worker._job=null;this.fail(e);return false}return true
-    },
-    onResult(worker,d,job){
-      const elapsed=Math.max(.05,performance.now()-job.started),mpr=elapsed/Math.max(1,job.rows);deepWisdom.rowMsEMA=deepWisdom.rowMsEMA?deepWisdom.rowMsEMA*.86+mpr*.14:mpr;deepWisdom.stripRows=Math.round((deepWisdom.stripRows||12)*.75+Math.max(3,Math.min(128,Math.round(deepWisdom.targetStripMs/Math.max(.001,deepWisdom.rowMsEMA))))*.25);
-      if(this.cancelled||this.failed||token!==state.token)return;if(!d||d.jobId!==job.jobId)return;if(d.error){this.fail(new Error(d.error));return}
-      this.simd=this.simd&&!!d.simd;this.blaUsed=this.blaUsed||!!d.bla;this.kernelMs+=d.kernelMs||0;this.verifyMs+=d.verifyMs||0;this.blaBuildMs+=d.blaBuildMs||0;this.sumIter+=d.sumIter||0;this.blackCount+=d.blackCount||0;this.badCount+=(d.bad||[]).length;const st=d.stats||{};this.blaSteps+=st.blaSteps||0;this.ptbSteps+=st.ptbSteps||0;this.rebases+=st.rebases||0;this.interior+=st.interior||0;this.unresolved+=st.unresolved||0;this.repaired+=d.repaired||0;
-      const rw=d.rectW||job.rectW,rx=d.x0==null?job.x0:d.x0,sf=d.field?new Float32Array(d.field):null,it=d.iterations?new Uint32Array(d.iterations):null,cl=d.classes?new Uint8Array(d.classes):null,ro=sf&&cl?colorizeField({smooth:sf,classes:cl,iter:colorIter}):new Uint8ClampedArray(d.out);for(let yy=0;yy<d.rows;yy++){const dst=(d.y0+yy)*w+rx;out.set(ro.subarray(yy*rw*4,(yy+1)*rw*4),dst*4);if(sf)field.smooth.set(sf.subarray(yy*rw,(yy+1)*rw),dst);if(it)field.iterations.set(it.subarray(yy*rw,(yy+1)*rw),dst);if(cl)field.classes.set(cl.subarray(yy*rw,(yy+1)*rw),dst)}presentPartialStripe(ro,rx,d.y0,rw,d.rows,w,h,snap);if(d.field&&d.iterations&&d.classes)worker._recycle={field:d.field,iterations:d.iterations,classes:d.classes};if(d.bad)for(const local of d.bad){const gx=rx+(local%rw),gy=d.y0+((local/rw)|0);bad.push(gy*w+gx)}this.donePixels+=job.pixels;if(profile.covered&&workers.length<deepPool.maxWorkers&&memoryLedger().managedBytes+24*1048576<rendererMemoryBudget()&&this.totalPixels-this.donePixels>job.pixels*4&&elapsed>deepWisdom.targetStripMs){const added=addDeepWorker();deepWisdom.workerCount=workers.length;deepWisdom.ready=true;kickDeepWorker(added)}this.maybeFinish()
-    },
-    maybeFinish(){
-      if(this.cancelled||this.failed||token!==state.token||this.finishing||this.donePixels<this.totalPixels)return;this.finishing=true;if(deepPool.current===this)deepPool.current=null;deepPool.activeToken=0;const px=Math.max(1,this.totalPixels),kmpp=this.kernelMs/px;deepTelemetry.frames++;deepTelemetry.kernelMPP=deepTelemetry.kernelMPP?deepTelemetry.kernelMPP*.78+kmpp*.22:kmpp;deepTelemetry.meanIter=this.sumIter/px;deepTelemetry.blackRatio=this.blackCount/px;deepTelemetry.badRatio=this.badCount/px;deepTelemetry.blaBuildEMA=deepTelemetry.blaBuildEMA?deepTelemetry.blaBuildEMA*.85+this.blaBuildMs*.15:this.blaBuildMs;deepTelemetry.interiorRatio=this.interior/px;deepTelemetry.repairRatio=this.repaired/Math.max(1,regions.length);deepTelemetry.unresolvedRatio=this.unresolved/px;deepTelemetry.blaStepsPerPixel=this.blaSteps/px;deepTelemetry.ptbStepsPerPixel=this.ptbSteps/px;deepTelemetry.rebasePerPixel=this.rebases/px;deepTelemetry.lastKernelMs=this.kernelMs;deepTelemetry.lastVerifyMs=this.verifyMs;deepTelemetry.lastPixels=px;deepTelemetry.refDistance=refC.dist||0;refControl.lastMPP=kmpp;refControl.lastPixels=px;if(refControl.refId!==ref.id){refControl.refId=ref.id;refControl.baseMPP=kmpp}else if((refC.dist||0)<.2)refControl.baseMPP=refControl.baseMPP?refControl.baseMPP*.8+kmpp*.2:kmpp;persistDeepWisdom();
-      const label='WASM '+(this.simd?'SIMD':'scalar')+' ×'+Math.max(1,Math.min(deepWisdom.workerCount,workers.length))+' · '+(this.blaUsed?'BLA e-'+bp.exp+' + ':'')+'rebase'+(this.interior?' · 内部早期終了 '+Math.round(100*this.interior/px)+'%':'')+(this.repaired?' · 局所補修 '+this.repaired:'')+(this.totalPixels<w*h?' · 既存画像再利用 '+Math.round(100*(1-this.totalPixels/(w*h)))+'%':'');
-      const completeField=this.totalPixels===w*h?field:null;if(!bad.length){finishRender(token,t0,profile,snap,w,h,out,label,this.totalPixels,completeField);return}let k=0;const residual=async()=>{if(token!==state.token||this.cancelled)return;const deadline=performance.now()+5;while(k<bad.length&&performance.now()<deadline){const idx=bad[k++],x=idx%w,py=(idx/w)|0,result=await highPrecisionDirectPixelAsync(snap,w,h,iter,x,py,false,()=>token!==state.token||this.cancelled);if(!result)return;const[n,m]=result;putField(field,idx,n,m,n<iter?FIELD_ESCAPED:FIELD_UNKNOWN);putDeepPixel(out,w,iter,colorIter,x,py,n,m,colorCtx)}if(k<bad.length)requestAnimationFrame(residual);else finishRender(token,t0,profile,snap,w,h,out,label+' · 残差 '+bad.length,this.totalPixels,completeField)};requestAnimationFrame(residual)
-    }
-  };
-  deepPool.current=runner;deepPool.activeToken=token;if(totalPixels===0){queueMicrotask(()=>runner.maybeFinish());return true}const active=Math.max(1,Math.min(deepWisdom.ready?deepWisdom.workerCount:Math.min(2,workers.length),workers.length));for(let i=0;i<active;i++)kickDeepWorker(workers[i]);return true
-}
-
-// ── Frame reprojection / world-space detail cache ───────────────────────
-const frameCanvas=document.createElement('canvas'),frameCtx=frameCanvas.getContext('2d',{alpha:false});
+function fmtFixedExact(v){let neg=v<0n;if(neg)v=-v;const maxD=state.bits,scale=10n**BigInt(maxD),q=v*scale>>BigInt(state.bits);let s=q.toString().padStart(maxD+1,'0');s=s.slice(0,-maxD)+'.'+s.slice(-maxD);s=s.replace(/(\.\d*?)0+$/,'$1').replace(/\.$/,'');return(neg?'-':'')+s}
 function snapshot(){return{bits:state.bits,re:state.re,im:state.im,span:state.span}}
-function snapshotToCurrent(s){if(s.bits===state.bits)return s;return{bits:state.bits,re:align(s.re,s.bits,state.bits),im:align(s.im,s.bits,state.bits),span:align(s.span,s.bits,state.bits)}}
-function styleSignature(){return state.palette+':'+state.cycle.toFixed(6)+':'+state.shift.toFixed(5)}
-function commitImage(data,w,h,snap,field=null){
-  frameCanvas.width=w;frameCanvas.height=h;const id=frameCtx.createImageData(w,h);id.data.set(data);frameCtx.putImageData(id,0,0);runtimeMetrics.canvasWrites++;
-  state.frameView=snapshotToCurrent(snap);state.fieldView=field?{field,w,h,snap:state.frameView}:null;invalidateView();
-}
-function presentPartialStripe(data,x,y,w,h,frameW,frameH,snap){if(frameCanvas.width!==frameW||frameCanvas.height!==frameH||!sameSnapshot(state.frameView,snap)){frameCanvas.width=frameW;frameCanvas.height=frameH;frameCtx.fillStyle='#050813';frameCtx.fillRect(0,0,frameW,frameH);state.frameView=snapshotToCurrent(snap);state.fieldView=null}const id=frameCtx.createImageData(w,h);id.data.set(data);frameCtx.putImageData(id,x,y);runtimeMetrics.canvasWrites++;invalidateView(false)}
-function sameSnapshot(a,b){return!!a&&!!b&&a.bits===b.bits&&a.re===b.re&&a.im===b.im&&a.span===b.span}
-function recolorCurrentField(){const fv=state.fieldView;if(!fv||state.dirty||state.rendering||!sameSnapshot(fv.snap,state.frameView))return false;const out=colorizeField(fv.field);commitImage(out,fv.w,fv.h,fv.snap,fv.field);state.lastEngine='フィールド再彩色';state.lastRender=0;recolorCachedDetails();invalidateView();return true}
-const validationJob={active:false,key:''};
-const unknownContinuationJob={active:false,key:''};let unknownContinuationTimer=0;
-function cancelUnknownContinuation(){if(unknownContinuationTimer){clearTimeout(unknownContinuationTimer);unknownContinuationTimer=0}unknownContinuationJob.active=false;state.continuationProgress=0}
-function scheduleUnknownContinuation(delay=120){
-  const fv=state.fieldView;if(state.processMode!=='fine'||state.dirty||state.rendering||!fv||!state.unresolved)return;
-  const key=viewSpecKey(currentViewSpec())+':'+fv.w+'x'+fv.h+':'+fv.field.iter;
-  if(unknownContinuationJob.key===key||unknownContinuationTimer)return;
-  unknownContinuationTimer=setTimeout(()=>{unknownContinuationTimer=0;startUnknownContinuation(key)},delay)
-}
-function startUnknownContinuation(key){
-  const fv=state.fieldView;if(unknownContinuationJob.active||state.dirty||state.rendering||!fv||!sameSnapshot(fv.snap,state.frameView))return;
-  const field=fv.field,ranked=[];for(let i=0;i<field.classes.length;i++){if(field.classes[i]!==FIELD_UNKNOWN)continue;const x=i%fv.w,y=(i/fv.w)|0;let boundary=false;for(let yy=Math.max(0,y-1);yy<=Math.min(fv.h-1,y+1)&&!boundary;yy++)for(let xx=Math.max(0,x-1);xx<=Math.min(fv.w-1,x+1);xx++)if(field.classes[yy*fv.w+xx]===FIELD_ESCAPED){boundary=true;break}if(boundary)ranked.push({i,d:Math.hypot(x/fv.w-state.focusX,y/fv.h-state.focusY)})}if(!ranked.length)return;
-  const deep=deepEngineNeeded(fv.snap,fv.w),cap=Math.min(ranked.length,deep?384:4096);ranked.sort((a,b)=>a.d-b.d);const indices=ranked.slice(0,cap).map(v=>v.i);
-  unknownContinuationJob.active=true;unknownContinuationJob.key=key;const token=state.token,snap=fv.snap,baseIter=field.iter,extendedIter=Math.min(280000,Math.max(baseIter+256,baseIter*2)),cre=fixedNum(snap.re,snap.bits),cim=fixedNum(snap.im,snap.bits),scale=fixedNum(snap.span,snap.bits)/fv.w;let p=0;
-  state.drawState='RESOLVING';state.continuationProgress=0;invalidateStats();
-  async function slice(){
-    if(token!==state.token||state.dirty){unknownContinuationJob.active=false;return}
-    const deadline=performance.now()+7;while(p<indices.length&&performance.now()<deadline){const i=indices[p++],x=i%fv.w,y=(i/fv.w)|0,result=deep?await highPrecisionDirectPixelAsync(snap,fv.w,fv.h,extendedIter,x,y,false,()=>token!==state.token||state.dirty):exportSampleShallow(cre,cim,scale,fv.w,fv.h,extendedIter,x,y);if(!result){unknownContinuationJob.active=false;return}const[n,m]=result;putField(field,i,n,m,n<extendedIter?FIELD_ESCAPED:FIELD_UNKNOWN)}
-    state.continuationProgress=p/indices.length;if(p<indices.length){invalidateStats();requestAnimationFrame(slice);return}
-    state.unresolved=field.classes.reduce((n,c)=>n+(c===FIELD_UNKNOWN),0);unknownContinuationJob.active=false;state.continuationProgress=1;state.drawState='COVERED';commitImage(colorizeField(field),fv.w,fv.h,snap,field);state.lastEngine+=' · 境界 '+indices.length+'点を追加反復';invalidateStats()
-  }
-  requestAnimationFrame(slice)
-}
-function scheduleValidation(delay=350){if(state.processMode!=='validate'||state.dirty||state.rendering)return;scheduleBackground(()=>{if(state.processMode==='validate'&&!state.detailActive&&!unknownContinuationJob.active)startValidation();else if(state.processMode==='validate')scheduleValidation(300)},delay)}
-function startValidation(){
-  const fv=state.fieldView;if(validationJob.active||!fv||state.dirty||state.rendering||!sameSnapshot(fv.snap,state.frameView))return;
-  const key=viewSpecKey(currentViewSpec())+':'+fv.w+'x'+fv.h+':'+fv.field.iter;if(validationJob.key===key)return;
-  validationJob.active=true;validationJob.key=key;
-  const token=state.token,snap=fv.snap,field=fv.field,baseIter=field.iter,extendedIter=Math.min(280000,Math.max(baseIter+256,baseIter*2));let i=0,lastStatus=0;
-  state.drawState='VALIDATING';state.coverage=0;invalidateStats();
-  async function slice(now){
-    if(token!==state.token||state.processMode!=='validate'){validationJob.active=false;return}
-    const deadline=performance.now()+9;
-    while(i<field.classes.length&&performance.now()<deadline){
-      const old=field.classes[i],x=i%fv.w,y=(i/fv.w)|0,limit=old===FIELD_ESCAPED?baseIter:extendedIter;
-      if(fixedAnalyticPixelProven(snap,fv.w,fv.h,x,y)){putField(field,i,limit,0,FIELD_INTERIOR_PROVEN);i++;continue}
-      const result=await highPrecisionDirectPixelAsync(snap,fv.w,fv.h,limit,x,y,true,()=>token!==state.token||state.processMode!=='validate');
-      if(!result){validationJob.active=false;return}
-      const[n,m]=result;if(n<limit)putField(field,i,n,m,FIELD_ESCAPED);else putField(field,i,n,0,FIELD_UNKNOWN);i++
-    }
-    if(now-lastStatus>180){lastStatus=now;state.coverage=i/field.classes.length;invalidateStats()}
-    if(i<field.classes.length){requestAnimationFrame(slice);return}
-    field.iter=extendedIter;state.unresolved=field.classes.reduce((n,c)=>n+(c!==FIELD_ESCAPED&&c!==FIELD_INTERIOR_PROVEN),0);state.drawState=state.unresolved?'VALIDATION_INCOMPLETE':'VALIDATED';state.coverage=1;validationJob.active=false;const out=colorizeField(field);commitImage(out,fv.w,fv.h,snap,field);state.lastEngine='高精度direct照合';invalidateStats()
-  }
-  requestAnimationFrame(slice)
-}
-function drawWorldDetail(entry){
-  if(!entry||!entry.complete||entry.style!==styleSignature()||!entry.canvas)return;if(entry.iter){const rr=entry.iter/Math.max(1,maxIter());if(rr<.82||rr>1.22)return}
-  const re=align(entry.re,entry.bits,state.bits),im=align(entry.im,entry.bits,state.bits),sxv=align(entry.spanX,entry.bits,state.bits),syv=align(entry.spanY,entry.bits,state.bits);
-  const x=canvas.width*.5+fixedRatio(re-state.re,state.span)*canvas.width,y=canvas.height*.5-fixedRatio(im-state.im,state.span)*canvas.width;
-  const dw=Math.abs(fixedRatio(sxv,state.span)*canvas.width),dh=Math.abs(fixedRatio(syv,state.span)*canvas.width);
-  if(!Number.isFinite(x+y+dw+dh)||dw<5||dh<5||x+dw*.5<0||x-dw*.5>canvas.width||y+dh*.5<0||y-dh*.5>canvas.height)return;
-  // Do not magnify a cached tile beyond ~1.7 display pixels per source pixel.
-  if(dw/Math.max(1,entry.canvas.width)>1.7)return;
-  entry.lastUsed=performance.now();
-  ctx.imageSmoothingEnabled=true;try{ctx.imageSmoothingQuality='high'}catch{}
-  ctx.drawImage(entry.canvas,x-dw*.5,y-dh*.5,dw,dh);
-}
-function paintFrame(){
-  if(!state.frameView||!frameCanvas.width)return;
-  runtimeMetrics.canvasWrites++;
-  const fv=state.frameView;
-  const a=fixedRatio(fv.span,state.span);if(!Number.isFinite(a)||a<=0)return;
-  const dx=fixedRatio(fv.re-state.re,state.span)*canvas.width;
-  const dy=-fixedRatio(fv.im-state.im,state.span)*canvas.width;
-  ctx.save();ctx.setTransform(1,0,0,1,0,0);ctx.fillStyle='#050813';ctx.fillRect(0,0,canvas.width,canvas.height);
-  ctx.translate(canvas.width*.5+dx,canvas.height*.5+dy);ctx.scale(a,a);ctx.imageSmoothingEnabled=true;try{ctx.imageSmoothingQuality=state.lastPass===RENDER_PASS.COVERED?'high':'medium'}catch{}
-  const fw=canvas.width,fh=fw*(frameCanvas.height/Math.max(1,frameCanvas.width));ctx.drawImage(frameCanvas,-fw*.5,-fh*.5,fw,fh);ctx.restore();
-  // Only completed, world-validated tiles are composited. Partial tiles remain offscreen.
-  ctx.save();ctx.setTransform(1,0,0,1,0,0);for(const e of DETAIL_TILE_CACHE.values())drawWorldDetail(e);ctx.restore();
-}
-
-function renderBudget(profile,deep){return profile.budgetMs}
-function targetSize(profile,deep){
-  // Resolution is intentionally independent of zoom depth. 10^20, 10^100 and
-  // beyond use the same quality targets as low zoom; only the numerical engine changes.
-  const cssW=Math.max(1,canvas.clientWidth),cssH=Math.max(1,canvas.clientHeight),aspect=cssH/cssW,dpr=Math.max(.25,state.effectiveDpr||1);
-  if(profile.covered)return[canvas.width,canvas.height];
-  let nominal=Math.max(profile.minWidth,cssW*dpr*profile.nominalScale),minW=profile.minWidth,maxW=profile.maxWidth;
-  const measured=renderPerf[deep?'deepMPP':'shallowMPP'];
-  if(deep&&!profile.covered&&measured<=0){nominal=Math.min(nominal,48);minW=32}
-  if(measured>0){
-    const timedW=Math.sqrt(renderBudget(profile,deep)/Math.max(1e-7,measured*aspect));
-    nominal=Math.min(nominal,timedW);minW=deep?32:240
-  }
-  let w=Math.max(minW,Math.min(maxW,Math.round(nominal))),h=Math.max(deep&&!profile.covered?32:96,Math.round(w*aspect));
-  if(h>2200){const sc=2200/h;h=2200;w=Math.round(w*sc)}return[w,h]
-}
-function analyzeDetailTiles(data,w,h,baseMs,deep){
-  const field=state.fieldView&&state.fieldView.w===w&&state.fieldView.h===h?state.fieldView.field:null;if(!field)return[];
-  const leaves=[],minTile=32,rootTile=256;
-  function scoreRect(x0,y0,tw,th){
-    const step=Math.max(1,Math.floor(Math.min(tw,th)/14));let grad=0,edges=0,uncertain=0,samples=0;
-    for(let y=y0;y<y0+th;y+=step)for(let x=x0;x<x0+tw;x+=step){const i=y*w+x,c=field.classes[i],s=field.smooth[i];samples++;uncertain+=(255-(field.confidence?field.confidence[i]:fieldConfidence(c)))/255;if(x+step<x0+tw){const j=i+step,c2=field.classes[j];if((c===FIELD_ESCAPED)!==(c2===FIELD_ESCAPED))edges++;else if(c===FIELD_ESCAPED&&c2===FIELD_ESCAPED)grad+=Math.min(12,Math.abs(s-field.smooth[j]))}if(y+step<y0+th){const j=i+step*w,c2=field.classes[j];if((c===FIELD_ESCAPED)!==(c2===FIELD_ESCAPED))edges++;else if(c===FIELD_ESCAPED&&c2===FIELD_ESCAPED)grad+=Math.min(12,Math.abs(s-field.smooth[j]))}}
-    return edges/Math.max(1,samples)*4.4+grad/Math.max(1,samples*12)*1.5+uncertain/Math.max(1,samples)*.9
-  }
-  function visit(x,y,tw,th){const score=scoreRect(x,y,tw,th);if(score<.055)return;if((tw>minTile||th>minTile)&&score>.11){const aw=Math.max(1,tw>>1),bw=tw-aw,ah=Math.max(1,th>>1),bh=th-ah;visit(x,y,aw,ah);if(bw)visit(x+aw,y,bw,ah);if(bh)visit(x,y+ah,aw,bh);if(bw&&bh)visit(x+aw,y+ah,bw,bh);return}leaves.push({x,y,w:tw,h:th,score,area:tw*th})}
-  for(let y=0;y<h;y+=rootTile)for(let x=0;x<w;x+=rootTile)visit(x,y,Math.min(rootTile,w-x),Math.min(rootTile,h-y));
-  leaves.sort((a,b)=>{const ad=Math.hypot((a.x+a.w*.5)/w-state.focusX,(a.y+a.h*.5)/h-state.focusY),bd=Math.hypot((b.x+b.w*.5)/w-state.focusX,(b.y+b.h*.5)/h-state.focusY);return(b.score+.08/(.08+bd))-(a.score+.08/(.08+ad))});const byteCap=Math.max(0,detailCacheBudget()-detailCacheBytes),baseBudget=renderBudget(RENDER_PROFILE[RENDER_PASS.COVERED],deep),spare=Math.max(0,baseBudget*1.7-baseMs),sampleCap=Math.floor(w*h*Math.min(2.6,spare/Math.max(1,baseMs)));let bytes=0,sampleArea=0,n=0;while(n<leaves.length){const tile=leaves[n],sampleScale=tile.score>=1.15?4:2,costBytes=tile.area*(sampleScale*sampleScale*10+4),costSamples=tile.area*sampleScale*sampleScale;if(bytes+costBytes>byteCap||sampleArea+costSamples>sampleCap)break;bytes+=costBytes;sampleArea+=costSamples;n++}return leaves.slice(0,n)
-}
-function detailGeometry(tile,plan){
-  const s=plan.snap,den=BigInt(2*plan.w),re=s.re+s.span*BigInt(2*tile.x+tile.w-plan.w)/den,im=s.im+s.span*BigInt(plan.h-2*tile.y-tile.h)/den;
-  const spanX=s.span*BigInt(tile.w)/BigInt(plan.w),spanY=s.span*BigInt(tile.h)/BigInt(plan.w);
-  return{bits:s.bits,re,im,spanX,spanY}
-}
-function detailKey(tile,plan,sampleScale){const g=detailGeometry(tile,plan);return [g.bits,g.re,g.im,g.spanX,g.spanY,plan.iter,'aa'+sampleScale,'centered-v23'].join(':')}
-function rendererMemoryBudget(){return(Number(navigator.deviceMemory||8)<=4||matchMedia('(max-width:700px)').matches?96:192)*1048576}
-function wasmBytes(core){try{return core&&core.ex&&core.ex.memory?core.ex.memory.buffer.byteLength:0}catch{return 0}}
-function memoryLedger(includeDetail=true){
-  const screenCanvasBytes=canvas.width*canvas.height*4,frameCanvasBytes=frameCanvas.width*frameCanvas.height*4;
-  const fieldBytes=state.fieldView?state.fieldView.w*state.fieldView.h*10:0;
-  const referenceBytes=(referenceCache.rr?.byteLength||0)+(referenceCache.ri?.byteLength||0);
-  const mainWasmBytes=wasmBytes(wasm)+wasmBytes(deepWasm);
-  // Worker memories are isolated, so browsers do not expose their byteLength.
-  // Account them conservatively: reference copies + kernel scratch/linear memory.
-  const workerEstimateBytes=(shallowWorker?2*1048576:0)+deepPool.workers.length*24*1048576;
-  const renderBytes=state.rendering?(()=>{const size=targetSize(renderProfile(state.lastPass),deepMode),pixels=size[0]*size[1];return pixels*18})():0;
-  const exportBytes=exportJob&&exportJob.active?exportJob.bytes||0:0,activeDetailBytes=activeDetailTiles.reduce((sum,e)=>sum+(e.transientBytes||0),0);
-  const cacheBytes=includeDetail?detailCacheBytes:0;
-  const managedBytes=fieldBytes+referenceBytes+mainWasmBytes+workerEstimateBytes+renderBytes+exportBytes+activeDetailBytes+cacheBytes;
-  const canvasBytes=screenCanvasBytes+frameCanvasBytes;
-  return{managedBytes,logicalBytes:managedBytes+canvasBytes,canvasBytes,screenCanvasBytes,frameCanvasBytes,fieldBytes,referenceBytes,mainWasmBytes,workerEstimateBytes,renderBytes,exportBytes,activeDetailBytes,detailCacheBytes:cacheBytes,budget:rendererMemoryBudget()}
-}
-function detailCacheBudget(){const base=memoryLedger(false).managedBytes,reserve=16*1048576;return Math.max(0,Math.floor(Math.min(rendererMemoryBudget()*.18,rendererMemoryBudget()-base-reserve)))}
-function detailEntryBytes(entry){return entry&&entry.canvas?entry.canvas.width*entry.canvas.height*4+(entry.field?entry.field.classes.length*10:0):0}
-function detailDistance(entry){try{const re=align(entry.re,entry.bits,state.bits),im=align(entry.im,entry.bits,state.bits);return Math.hypot(fixedRatio(re-state.re,state.span),fixedRatio(im-state.im,state.span))}catch{return Infinity}}
-function trimDetailCache(){const budget=detailCacheBudget();while(detailCacheBytes>budget&&DETAIL_TILE_CACHE.size){let victim=null,rank=-Infinity;const now=performance.now();for(const [key,entry]of DETAIL_TILE_CACHE){const age=Math.max(0,now-(entry.lastUsed||0))/60000,distance=detailDistance(entry),score=(Number.isFinite(distance)?distance:1000)*4+age;if(score>rank){rank=score;victim=[key,entry]}}if(!victim)break;DETAIL_TILE_CACHE.delete(victim[0]);detailCacheBytes=Math.max(0,detailCacheBytes-detailEntryBytes(victim[1]))}}
-function linearChannel(v){v/=255;return v<=.04045?v/12.92:Math.pow((v+.055)/1.055,2.4)}
-function srgbChannel(v){v=Math.max(0,Math.min(1,v));return Math.round(255*(v<=.0031308?12.92*v:1.055*Math.pow(v,1/2.4)-.055))}
-function resolveSubsampleField(field,w,h,scale=2){const hi=colorizeField(field),c=document.createElement('canvas');c.width=w;c.height=h;const cc=c.getContext('2d',{alpha:false}),id=cc.createImageData(w,h),out=id.data,samples=scale*scale;for(let y=0;y<h;y++)for(let x=0;x<w;x++){let r=0,g=0,b=0;for(let sy=0;sy<scale;sy++)for(let sx=0;sx<scale;sx++){const i=(((y*scale+sy)*w*scale)+(x*scale+sx))*4;r+=linearChannel(hi[i]);g+=linearChannel(hi[i+1]);b+=linearChannel(hi[i+2])}const oi=(y*w+x)*4;out[oi]=srgbChannel(r/samples);out[oi+1]=srgbChannel(g/samples);out[oi+2]=srgbChannel(b/samples);out[oi+3]=255}cc.putImageData(id,0,0);return c}
-function recolorDetailEntry(entry){if(!entry||!entry.field)return;entry.canvas=resolveSubsampleField(entry.field,entry.baseW,entry.baseH,entry.sampleScale||2);entry.style=styleSignature()}
-function recolorCachedDetails(){cancelDetailRefinement(true);for(const entry of DETAIL_TILE_CACHE.values())recolorDetailEntry(entry)}
-function makeDetailTask(tile,plan){
-  const sampleScale=tile.score>=1.15?4:2,key=detailKey(tile,plan,sampleScale),cached=DETAIL_TILE_CACHE.get(key);if(cached){DETAIL_TILE_CACHE.delete(key);DETAIL_TILE_CACHE.set(key,cached);cached.lastUsed=performance.now();if(cached.style!==styleSignature())recolorDetailEntry(cached);return{cached:true,entry:cached}}
-  const c=document.createElement('canvas');c.width=Math.max(2,tile.w*sampleScale);c.height=Math.max(2,tile.h*sampleScale);const dc=c.getContext('2d',{alpha:false});
-  dc.imageSmoothingEnabled=true;try{dc.imageSmoothingQuality='high'}catch{};dc.drawImage(frameCanvas,tile.x,tile.y,tile.w,tile.h,0,0,c.width,c.height);
-  const g=detailGeometry(tile,plan),entry={...g,canvas:c,field:null,baseW:tile.w,baseH:tile.h,sampleScale,style:styleSignature(),key,score:tile.score,iter:plan.iter,complete:false,lastUsed:performance.now(),transientBytes:c.width*c.height*18};
-  const task={tile,canvas:c,ctx:dc,field:makeField(c.width*c.height,plan.iter),entry,phases:0,plan};activeDetailTiles.push(entry);return task
-}
-function validateDetailTask(task){
-  const plan=task&&task.plan,t=task&&task.tile,base=plan&&plan.baseData;if(!plan||!t||!base)return false;
-  let samples=0,blackMismatch=0,rgbDiff=0,colorSamples=0;const sampleScale=task.entry.sampleScale||2,step=Math.max(3,Math.floor(Math.min(t.w,t.h)/7)),pix=task.ctx.getImageData(0,0,task.canvas.width,task.canvas.height).data;
-  for(let by=t.y+1;by<t.y+t.h-1;by+=step)for(let bx=t.x+1;bx<t.x+t.w-1;bx+=step){
-    const bi=(by*plan.w+bx)*4,lx=Math.min(task.canvas.width-1,Math.max(0,sampleScale*(bx-t.x)+(sampleScale>>1))),ly=Math.min(task.canvas.height-1,Math.max(0,sampleScale*(by-t.y)+(sampleScale>>1))),hi=(ly*task.canvas.width+lx)*4;
-    const bb=(base[bi]|base[bi+1]|base[bi+2])===0,hb=(pix[hi]|pix[hi+1]|pix[hi+2])===0;samples++;if(bb!==hb)blackMismatch++;else if(!bb){rgbDiff+=Math.abs(base[bi]-pix[hi])+Math.abs(base[bi+1]-pix[hi+1])+Math.abs(base[bi+2]-pix[hi+2]);colorSamples++}
-  }
-  if(samples<4)return false;const classRate=blackMismatch/samples,meanDiff=colorSamples?rgbDiff/(3*colorSamples):0;return classRate<=.035&&meanDiff<=48
-}
-function cacheDetailTask(task){
-  if(!task||task.cached)return;const i=activeDetailTiles.indexOf(task.entry);if(i>=0)activeDetailTiles.splice(i,1);
-  if(!validateDetailTask(task))return;fillFieldConfidence(task.field);task.entry.field=task.field;task.entry.canvas=resolveSubsampleField(task.field,task.tile.w,task.tile.h,task.entry.sampleScale);task.entry.style=styleSignature();task.entry.complete=true;task.entry.lastUsed=performance.now();task.entry.transientBytes=0;const old=DETAIL_TILE_CACHE.get(task.entry.key);if(old)detailCacheBytes-=detailEntryBytes(old);DETAIL_TILE_CACHE.delete(task.entry.key);DETAIL_TILE_CACHE.set(task.entry.key,task.entry);detailCacheBytes+=detailEntryBytes(task.entry);
-  trimDetailCache()
-}
-function phaseRect(task,phase){
-  const t=task.tile,scale=task.entry.sampleScale,left=(phase%scale)*t.w,top=((phase/scale)|0)*t.h;
-  return{x0:t.x*scale+left,y0:t.y*scale+top,rw:t.w,rows:t.h,dx:left,dy:top}
-}
-function prepareDeepTileContext(plan,iter,sampleScale,done){
-  const cacheKey='i'+iter+':s'+sampleScale;if(plan.deepCtx&&plan.deepCtx[cacheKey]){done(plan.deepCtx[cacheKey]);return}if(!plan.deepCtx)plan.deepCtx={};
-  const snap=plan.snap,refC=chooseReference(snap),W=plan.w*sampleScale,H=plan.h*sampleScale,refX=W*.5-.5+fixedRatio(refC.re-snap.re,snap.span)*W,refY=H*.5-.5-fixedRatio(refC.im-snap.im,snap.span)*W;
-  const cornerR=Math.max(Math.hypot(refX,refY),Math.hypot(W-refX,refY),Math.hypot(refX,H-refY),Math.hypot(W-refX,H-refY))/Math.max(1,W),logMaxDc=log2FixedAt(snap.span,snap.bits)+Math.log2(Math.max(1e-300,cornerR));
-  buildReferenceAt(snap.bits,refC.re,refC.im,iter,state.token,(ref,refLen)=>{
-    if(plan.gen!==state.detailGeneration)return;const series=computeSeries(ref,refLen,logMaxDc),centered=pixelCenteredOffset(snap,refC,W),sb=spanMantBucket(snap.span,snap.bits),off=fixedComplexScaled(centered.r,centered.i,snap.bits),spanNormal=fixedNum(snap.span,snap.bits),offRn=fixedNum(centered.r,snap.bits),offIn=fixedNum(centered.i,snap.bits);
-    const cMaxRaw=Math.hypot(offRn,offIn)+Math.abs(spanNormal)*Math.hypot(.5,H/(2*Math.max(1,W))),cBucket=cMaxRaw>0&&Number.isFinite(cMaxRaw)?Math.ceil(Math.log2(cMaxRaw)*8):0,cMaxSafe=cMaxRaw>0?Math.pow(2,cBucket/8):0;
-    const ctx={snap,refC,ref,refLen,series,sb,off,spanNormal,offRn,offIn,cBucket,cMaxSafe,W,H,iter};plan.deepCtx[cacheKey]=ctx;done(ctx)
-  })
-}
-function renderGuardedDeepDetailRect(task,phase,iter,done){
-  const plan=task.plan,r=phaseRect(task,phase),W=plan.w*task.entry.sampleScale,H=plan.h*task.entry.sampleScale,snap=plan.snap;let yy=0;
-  async function slice(){if(plan.gen!==state.detailGeneration){done(false);return}const deadline=performance.now()+6;while(yy<r.rows&&performance.now()<deadline){const gy=r.y0+yy;for(let xx=0;xx<r.rw;xx++){const gx=r.x0+xx,result=await highPrecisionDirectPixelAsync(snap,W,H,iter,gx,gy,true,()=>plan.gen!==state.detailGeneration);if(!result){done(false);return}const[n,m]=result,fi=(r.dy+yy)*task.canvas.width+r.dx+xx;putField(task.field,fi,n,m,n<iter?FIELD_ESCAPED:FIELD_UNKNOWN)}yy++}if(yy<r.rows){requestAnimationFrame(slice);return}const stripe=makeField(r.rw*r.rows,iter);for(let y=0;y<r.rows;y++){const src=(r.dy+y)*task.canvas.width+r.dx,dst=y*r.rw;stripe.smooth.set(task.field.smooth.subarray(src,src+r.rw),dst);stripe.iterations.set(task.field.iterations.subarray(src,src+r.rw),dst);stripe.classes.set(task.field.classes.subarray(src,src+r.rw),dst)}const id=task.ctx.createImageData(r.rw,r.rows);id.data.set(colorizeField(stripe));task.ctx.putImageData(id,r.dx,r.dy);task.phases|=(1<<phase);invalidateView(false);done(true)}
-  requestAnimationFrame(slice)
-}
-function sendDeepDetailRect(task,phase,iter,colorIter,done){
-  const plan=task.plan,gen=plan.gen;if(gen!==state.detailGeneration){done(false);return}if(state.processMode==='validate'||task.tile.score>1.35){renderGuardedDeepDetailRect(task,phase,iter,done);return}if(!ensureDeepPool()){done(false);return}
-  prepareDeepTileContext(plan,iter,task.entry.sampleScale,dc=>{
-    if(gen!==state.detailGeneration){done(false);return}const worker=deepPool.workers.find(w=>!w._busy);if(!worker){scheduleBackground(()=>sendDeepDetailRect(task,phase,iter,colorIter,done),18);return}
-    const r=phaseRect(task,phase),ref=dc.ref,refKey=String(ref.id),bpExp=32,useBla=Number.isFinite(dc.spanNormal)&&Math.abs(dc.spanNormal)>=1e-280&&dc.refLen>8,blaEps=Math.pow(2,-bpExp),blaKey=refKey+':'+ref.version+':'+dc.refLen+':'+dc.cBucket+':e'+bpExp;
-    const jobId='detail:'+gen+':'+Date.now()+':'+Math.random(),msg={type:'render',jobId,refKey,refLen:dc.refLen,w:dc.W,h:dc.H,x0:r.x0,y0:r.y0,rectW:r.rw,rows:r.rows,iter,colorIter,spanMant:dc.sb.mant,spanBucket:dc.sb.bucket,offR:dc.off[0],offI:dc.off[1],offBucket:dc.off[2],cx:dc.W*.5,cy:dc.H*.5,skip:dc.series.skip,Ar:dc.series.Ar,Ai:dc.series.Ai,Ab:dc.series.Ab,Br:dc.series.Br,Bi:dc.series.Bi,Bb:dc.series.Bb,shift:state.shift,cycle:state.cycle,palette:state.palette,useBla,blaEps,blaKey,cMax:dc.cMaxSafe,spanNormal:dc.spanNormal,offRn:dc.offRn,offIn:dc.offIn,baseCr:fixedNum(dc.refC.re,dc.snap.bits),baseCi:fixedNum(dc.refC.im,dc.snap.bits),maxBlaSteps:0,maxPtbSteps:0,verifySamples:3,verifyDelta:6,safeBlaEps:Math.pow(2,-48),safeBlaKey:blaKey+':safe48'},transfer=[];
-    let start=worker._refKey===refKey?worker._refLoaded:0;start=Math.max(0,Math.min(start,dc.refLen+1));if(start<dc.refLen+1){const rr=ref.rr.slice(start,dc.refLen+1),ri=ref.ri.slice(start,dc.refLen+1);msg.rr=rr.buffer;msg.ri=ri.buffer;msg.rrStart=start;transfer.push(rr.buffer,ri.buffer);worker._refKey=refKey;worker._refLoaded=dc.refLen+1}
-    const runner={token:state.token,cancelled:false,fail(){done(false)},onResult(w,d){if(gen!==state.detailGeneration||!d||d.error){done(false);return}const sf=d.field?new Float32Array(d.field):null,it=d.iterations?new Uint32Array(d.iterations):null,cl=d.classes?new Uint8Array(d.classes):null,arr=sf&&cl?colorizeField({smooth:sf,classes:cl,iter:colorIter}):new Uint8ClampedArray(d.out),id=task.ctx.createImageData(r.rw,r.rows);id.data.set(arr);task.ctx.putImageData(id,r.dx,r.dy);if(sf&&it&&cl)for(let yy=0;yy<r.rows;yy++){const dst=(r.dy+yy)*task.canvas.width+r.dx;task.field.smooth.set(sf.subarray(yy*r.rw,(yy+1)*r.rw),dst);task.field.iterations.set(it.subarray(yy*r.rw,(yy+1)*r.rw),dst);task.field.classes.set(cl.subarray(yy*r.rw,(yy+1)*r.rw),dst)}if(d.field&&d.iterations&&d.classes)w._recycle={field:d.field,iterations:d.iterations,classes:d.classes};task.phases|=(1<<phase);task.entry.canvas=task.canvas;invalidateView(false);done(true)}};
-    if(worker._recycle){msg.fieldBuffer=worker._recycle.field;msg.iterationBuffer=worker._recycle.iterations;msg.classBuffer=worker._recycle.classes;transfer.push(msg.fieldBuffer,msg.iterationBuffer,msg.classBuffer);worker._recycle=null}worker._busy=true;worker._job={type:'render',runner,jobId,y0:r.y0,rows:r.rows,started:performance.now()};try{worker.postMessage(msg,transfer)}catch(e){worker._busy=false;worker._job=null;done(false)}
-  })
-}
-function renderShallowDetailRect(task,phase,done){
-  const plan=task.plan,r=phaseRect(task,phase),sampleScale=task.entry.sampleScale,W=plan.w*sampleScale,H=plan.h*sampleScale,iter=plan.iter,snap=plan.snap,sp=fixedNum(snap.span,snap.bits),cre=fixedNum(snap.re,snap.bits),cim=fixedNum(snap.im,snap.bits),scale=sp/W,colorCtx=makeColorCtx(iter),out=new Uint8ClampedArray(r.rw*r.rows*4);let yy=0;
-  function inBulbs(cr,ci){const y2=ci*ci,x=cr-.25,q=x*x+y2;if(q*(q+x)<=.25*y2)return true;const x2=cr+1;return x2*x2+y2<=.0625}
-  function slice(){if(plan.gen!==state.detailGeneration){done(false);return}const deadline=performance.now()+5;while(yy<r.rows&&performance.now()<deadline){const gy=r.y0+yy,ci=cim+(H*.5-gy-.5)*scale;let oi=yy*r.rw*4;for(let xx=0;xx<r.rw;xx++){const gx=r.x0+xx,cr=cre+(gx+.5-W*.5)*scale;let zr=0,zi=0,zr2=0,zi2=0,n=0,inside=inBulbs(cr,ci);if(inside)n=iter;else while(n<iter&&zr2+zi2<=4){zi=(zr+zr)*zi+ci;zr=zr2-zi2+cr;zr2=zr*zr;zi2=zi*zi;n++}const m=n<iter?Math.max(4.0000001,zr2+zi2):0,fi=(r.dy+yy)*task.canvas.width+r.dx+xx;putField(task.field,fi,n,m,n<iter?FIELD_ESCAPED:(inside?FIELD_INTERIOR_LIKELY:FIELD_UNKNOWN));if(n>=iter){out[oi]=out[oi+1]=out[oi+2]=0;out[oi+3]=255}else putFastColor(out,oi,n,m,iter,colorCtx);oi+=4}yy++}if(yy<r.rows)requestAnimationFrame(slice);else{const id=task.ctx.createImageData(r.rw,r.rows),data=id.data;data.set(out);task.ctx.putImageData(id,r.dx,r.dy);task.phases|=(1<<phase);invalidateView(false);done(true)}}requestAnimationFrame(slice)
-}
-function pumpDetailRefinement(){
-  const plan=detailPlan;if(!plan||plan.gen!==state.detailGeneration||!state.hq){state.detailActive=false;return}if(state.rendering||unknownContinuationJob.active||performance.now()-state.lastInteraction<720){scheduleBackground(pumpDetailRefinement,90);return}
-  while(plan.index<plan.tasks.length&&plan.tasks[plan.index].cached)plan.index++;
-  if(plan.index>=plan.tasks.length){state.detailActive=false;state.detailDone=plan.tasks.length;state.drawState='REFINED';updateStats();scheduleValidation();return}
-  const task=plan.tasks[plan.index],phase=task.nextPhase||0,cb=ok=>{if(!ok){const i=activeDetailTiles.indexOf(task.entry);if(i>=0)activeDetailTiles.splice(i,1);plan.index++;scheduleBackground(pumpDetailRefinement,10);return}task.nextPhase=phase+1;if(task.nextPhase>=task.entry.sampleScale*task.entry.sampleScale){cacheDetailTask(task);plan.index++}state.detailDone=plan.tasks.reduce((n,t)=>n+(t.cached||t.entry.complete?1:0),0);updateStats();scheduleBackground(pumpDetailRefinement,0)};
-  if(plan.deep)sendDeepDetailRect(task,phase,plan.iter,plan.iter,cb);else renderShallowDetailRect(task,phase,cb)
-}
-
-// ── Idle-only adaptive detail refinement ────────────────────────────────
-function scheduleDetailRefinement(data,w,h,snap,iter,baseMs,deep){
-  if(!state.hq)return;cancelDetailRefinement(true);const gen=state.detailGeneration,tiles=analyzeDetailTiles(data,w,h,baseMs,deep);if(!tiles.length){state.drawState='REFINED';invalidateStats();scheduleValidation();return}
-  const plan={gen,snap,w,h,iter,deep,tiles,tasks:[],index:0,deepCtx:null,baseData:data};for(const t of tiles)plan.tasks.push(makeDetailTask(t,plan));detailPlan=plan;state.detailActive=true;state.drawState='REFINING';state.detailQueued=plan.tasks.length;state.detailDone=plan.tasks.filter(t=>t.cached).length;scheduleBackground(pumpDetailRefinement,160)
-}
-
-function finishRender(token,t0,profile,snap,w,h,out,engine,computedPixels=w*h,field=null){
-  if(token!==state.token)return;const elapsed=Math.max(.1,performance.now()-t0),deep=deepEngineNeeded(snap,Math.max(1,canvas.width));
-  // Reproject-only frames must not poison performance estimates with near-zero work.
-  if(computedPixels>Math.max(512,w*h*.01)){const mpp=elapsed/computedPixels,key=deep?'deepMPP':'shallowMPP';renderPerf[key]=renderPerf[key]?renderPerf[key]*.72+mpp*.28:mpp}
-  if(field){fillFieldConfidence(field);out=colorizeField(field)}commitImage(out,w,h,snap,field);state.rendering=false;state.lastRender=elapsed;state.lastPass=profile.id;state.dirty=false;state.lastEngine=engine;state.lastFrameDone=performance.now();state.coverage=Math.min(1,w*h/Math.max(1,canvas.width*canvas.height));state.drawState=profile.covered&&state.coverage>=.999?'COVERED':'PREVIEW';state.unresolved=field?field.classes.reduce((n,c)=>n+(c===FIELD_UNKNOWN),0):0;flushPendingPrecision();
-  if(!profile.covered&&adaptStandardDeepBudget(deep)){updateStats();return}
-  if(profile.covered&&state.unresolved)scheduleUnknownContinuation();
-  if(profile.covered&&state.hq){const gen=state.detailGeneration;const schedule=()=>{if(gen!==state.detailGeneration||state.rendering)return;if(unknownContinuationJob.active||unknownContinuationTimer){scheduleBackground(schedule,90);return}const fv=state.fieldView,base=fv&&sameSnapshot(fv.snap,snap)?colorizeField(fv.field):out;scheduleDetailRefinement(base,w,h,snap,fv?fv.field.iter:iterationPlan(profile,deep).colorIter,elapsed,deep)};scheduleIdle(schedule,350);clearPanReuse()}
-  if(profile.covered&&state.processMode==='validate')scheduleValidation();
-  updateStats();
-}
-
-// ── Shallow renderers ───────────────────────────────────────────────────
-function renderShallowReuse(profile,snap,w,h,iter,token,t0,reuse){
-  const out=reuse.out,colorCtx=makeColorCtx(iter),sp=fixedNum(snap.span,snap.bits),cre=fixedNum(snap.re,snap.bits),cim=fixedNum(snap.im,snap.bits),scale=sp/w,rects=reuse.rects;let ri=0,yy=0;
-  function inBulbs(cr,ci){const y2=ci*ci,x=cr-.25,qq=x*x+y2;if(qq*(qq+x)<=.25*y2)return true;const x2=cr+1;return x2*x2+y2<=.0625}
-  function slice(){if(token!==state.token)return;const deadline=performance.now()+7;while(ri<rects.length&&performance.now()<deadline){const r=rects[ri];while(yy<r.h&&performance.now()<deadline){const gy=r.y0+yy,ci=cim+(h*.5-gy-.5)*scale;for(let xx=0;xx<r.w;xx++){const gx=r.x0+xx,cr=cre+(gx+.5-w*.5)*scale;let zr=0,zi=0,zr2=0,zi2=0,n=0;if(inBulbs(cr,ci))n=iter;else while(n<iter&&zr2+zi2<=4){zi=(zr+zr)*zi+ci;zr=zr2-zi2+cr;zr2=zr*zr;zi2=zi*zi;n++}const oi=(gy*w+gx)*4;if(n>=iter){out[oi]=out[oi+1]=out[oi+2]=0;out[oi+3]=255}else putFastColor(out,oi,n,Math.max(4.0000001,zr2+zi2),iter,colorCtx)}yy++}if(yy>=r.h){ri++;yy=0}}
-    if(ri<rects.length)requestAnimationFrame(slice);else finishRender(token,t0,profile,snap,w,h,out,'JavaScript f64 · 既存画像再利用 '+Math.round(100*reuse.reusedPixels/(w*h))+'%',reuse.exposedPixels)
-  }requestAnimationFrame(slice)
-}
-function renderWasmMain(profile,snap,w,h,iter,token,t0){
-  const out=new Uint8ClampedArray(w*h*4),field=makeField(w*h,iter),colorCtx=makeColorCtx(iter);
-  const cre=fixedNum(snap.re,snap.bits),cim=fixedNum(snap.im,snap.bits),sp=fixedNum(snap.span,snap.bits),scale=sp/w;
-  function proven(cr,ci){const y2=ci*ci,x=cr-.25,q0=x*x+y2;if(q0*(q0+x)<=.25*y2)return true;const x2=cr+1;return x2*x2+y2<=.0625}
-  let y=0;const counts=wasm.counts(),mags=wasm.mags();
-  function slice(){
-    if(token!==state.token)return;const deadline=performance.now()+(profile.covered?11:8);
-    while(y<h&&performance.now()<deadline){
-      const rows=Math.min(24,h-y),y0=y,npx=wasm.ex.render_rows(cre+scale*.5,cim-scale*.5,sp,w,h,y,rows,iter);let oi=y*w*4;
-      for(let i=0;i<npx;i++){
-        const n=counts[i],m=mags[i],px=i%w,py=y0+((i/w)|0);
-        const cr=cre+(px+.5-w*.5)*scale,ci=cim+(h*.5-py-.5)*scale,kind=n<iter?FIELD_ESCAPED:(proven(cr,ci)?FIELD_INTERIOR_LIKELY:FIELD_UNKNOWN);putField(field,py*w+px,n,m,kind);
-        if(n>=iter){out[oi++]=0;out[oi++]=0;out[oi++]=0;out[oi++]=255}
-        else{
-          putFastColor(out,oi,n,Math.max(4.0000001,m),iter,colorCtx);oi+=4;
-        }
-      }y+=rows;
-    }
-    if(y<h)requestAnimationFrame(slice);else finishRender(token,t0,profile,snap,w,h,out,'WebAssembly f64',w*h,field);
-  }requestAnimationFrame(slice);
-}
-function renderWasm(profile,snap,w,h,iter,token,t0){
-  if(!ensureShallowWorker()||shallowWorkerBusy){renderWasmMain(profile,snap,w,h,iter,token,t0);return}
-  const worker=shallowWorker,out=new Uint8ClampedArray(w*h*4),field=makeField(w*h,iter),cre=fixedNum(snap.re,snap.bits),cim=fixedNum(snap.im,snap.bits),sp=fixedNum(snap.span,snap.bits),jobId='shallow:'+token+':'+Date.now(),rowsPerChunk=Math.min(h,Math.max(4,Math.floor(32768/Math.max(1,w)))),chunks=[];for(let y=0;y<h;y+=rowsPerChunk)chunks.push({y,rows:Math.min(rowsPerChunk,h-y)});chunks.sort((a,b)=>Math.abs((a.y+a.rows*.5)/h-state.focusY)-Math.abs((b.y+b.rows*.5)/h-state.focusY));let next=0;shallowWorkerBusy=true;
-  const dispatch=()=>{if(token!==state.token){shallowWorkerBusy=false;return}if(next>=chunks.length){shallowWorkerBusy=false;finishRender(token,t0,profile,snap,w,h,out,'WebAssembly '+(wasm.simd?'SIMD':'scalar')+' Worker',w*h,field);return}const chunk=chunks[next++],msg={type:'render',jobId,cre,cim,sp,w,h,y:chunk.y,rows:chunk.rows,iter},transfer=[];if(shallowRecycle){msg.fieldBuffer=shallowRecycle.field;msg.iterationBuffer=shallowRecycle.iterations;msg.classBuffer=shallowRecycle.classes;transfer.push(msg.fieldBuffer,msg.iterationBuffer,msg.classBuffer);shallowRecycle=null}worker.postMessage(msg,transfer)};
-  worker.onmessage=e=>{const d=e.data;if(!d||d.type==='ready')return;if(d.jobId!==jobId)return;if(d.error){shallowWorkerBusy=false;renderWasmMain(profile,snap,w,h,iter,token,t0);return}const sf=new Float32Array(d.field),it=new Uint32Array(d.iterations),cl=new Uint8Array(d.classes);if(token!==state.token){shallowRecycle={field:d.field,iterations:d.iterations,classes:d.classes};shallowWorkerBusy=false;return}const stripe=colorizeField({smooth:sf,classes:cl,iter}),dst=d.y*w;field.smooth.set(sf,dst);field.iterations.set(it,dst);field.classes.set(cl,dst);out.set(stripe,dst*4);presentPartialStripe(stripe,0,d.y,w,d.rows,w,h,snap);shallowRecycle={field:d.field,iterations:d.iterations,classes:d.classes};dispatch()};worker.onerror=()=>{shallowWorkerBusy=false;destroyShallowWorker();if(token===state.token)renderWasmMain(profile,snap,w,h,iter,token,t0)};dispatch()
-}
-function renderJsDouble(profile,snap,w,h,iter,token,t0){
-  const out=new Uint8ClampedArray(w*h*4),field=makeField(w*h,iter),colorCtx=makeColorCtx(iter),sp=fixedNum(snap.span,snap.bits),cre=fixedNum(snap.re,snap.bits),cim=fixedNum(snap.im,snap.bits),scale=sp/w;let y=0;
-  function inBulbs(cr,ci){const y2=ci*ci,x=cr-.25,qq=x*x+y2;if(qq*(qq+x)<=.25*y2)return true;const x2=cr+1;return x2*x2+y2<=.0625}
-  function slice(){if(token!==state.token)return;const deadline=performance.now()+(profile.covered?10:7);while(y<h&&performance.now()<deadline){let oi=y*w*4,ci=cim+(h*.5-y-.5)*scale,cr=cre+(.5-w*.5)*scale;for(let x=0;x<w;x++,cr+=scale){let zr=0,zi=0,zr2=0,zi2=0,n=0,inside=inBulbs(cr,ci);if(inside)n=iter;else{let oldr=0,oldi=0;while(n<iter&&zr2+zi2<=4){zi=(zr+zr)*zi+ci;zr=zr2-zi2+cr;zr2=zr*zr;zi2=zi*zi;n++;if((n&63)===0){if(Math.abs(zr-oldr)+Math.abs(zi-oldi)<1e-15){n=iter;break}oldr=zr;oldi=zi}}}const mm=n>=iter?0:Math.max(4.0000001,zr2+zi2),kind=n<iter?FIELD_ESCAPED:(inside?FIELD_INTERIOR_LIKELY:FIELD_UNKNOWN);putField(field,y*w+x,n,mm,kind);if(n>=iter){out[oi++]=0;out[oi++]=0;out[oi++]=0;out[oi++]=255}else{putFastColor(out,oi,n,mm,iter,colorCtx);oi+=4}}y++}if(y<h)requestAnimationFrame(slice);else finishRender(token,t0,profile,snap,w,h,out,'JavaScript f64',w*h,field);}requestAnimationFrame(slice);
-}
-
-function spanMantBucket(span,bits){
-  const l=log2FixedAt(span,bits);let bucket=Math.round(l/256),mant=Math.pow(2,l-bucket*256);return{mant,bucket};
-}
-function normalizeBucket(r,i,b){
-  let m=Math.max(Math.abs(r),Math.abs(i));if(!m)return[0,0,NEG_BUCKET];
-  while(m>HI128){r*=INV256;i*=INV256;b++;m*=INV256}
-  while(m<LO128){r*=POW256;i*=POW256;b--;m*=POW256}
-  return[r,i,b];
-}
-function scAdd(a,b){
-  if(a[2]===NEG_BUCKET)return b;if(b[2]===NEG_BUCKET)return a;
-  const eb=Math.max(a[2],b[2]);let r=0,i=0;
-  if(a[2]===eb){r+=a[0];i+=a[1]}else if(a[2]===eb-1){r+=a[0]*INV256;i+=a[1]*INV256}
-  if(b[2]===eb){r+=b[0];i+=b[1]}else if(b[2]===eb-1){r+=b[0]*INV256;i+=b[1]*INV256}
-  return normalizeBucket(r,i,eb);
-}
-function scLog2(a){return a[2]===NEG_BUCKET?-Infinity:Math.log2(Math.hypot(a[0],a[1]))+256*a[2]}
-function fixedMantAtBucket(v,bits,bucket){
-  if(v===0n)return 0;const neg=v<0n;let a=neg?-v:v,bl=bitLen(a),take=Math.min(53,bl),sh=bl-take,top=Number(a>>BigInt(sh));
-  const exp=sh-bits-256*bucket;const n=top*Math.pow(2,exp);return neg?-n:n;
-}
-function fixedComplexScaled(r,i,bits){
-  if(r===0n&&i===0n)return[0,0,NEG_BUCKET];
-  const lr=r===0n?-Infinity:log2FixedAt(r,bits),li=i===0n?-Infinity:log2FixedAt(i,bits),bucket=Math.round(Math.max(lr,li)/256);
-  return normalizeBucket(fixedMantAtBucket(r,bits,bucket),fixedMantAtBucket(i,bits,bucket),bucket);
-}
-function pixelCenteredOffset(snap,refC,w){const half=roundDiv(snap.span,BigInt(2*Math.max(1,w)));return{r:snap.re-refC.re+half,i:snap.im-refC.im-half}}
-function roundDiv(v,d){const neg=v<0n,a=neg?-v:v,q=(a+d/2n)/d;return neg?-q:q}
-function fixedPixelPoint(snap,w,h,x,y,bits=snap.bits){const den=BigInt(2*w),re=align(snap.re,snap.bits,bits),im=align(snap.im,snap.bits,bits),span=align(snap.span,snap.bits,bits);return[re+roundDiv(span*BigInt(2*x+1-w),den),im+roundDiv(span*BigInt(h-2*y-1),den)]}
-function fixedAnalyticInterior(cr,ci,bits){const S=1n<<BigInt(bits),X=cr-(S>>2n),Y=ci,Q=X*X+Y*Y;if(4n*Q*(Q+X*S)<=Y*Y*S*S)return true;const D=cr+S;return 16n*(D*D+Y*Y)<=S*S}
-function fixedAnalyticPixelProven(snap,w,h,x,y){const p=fixedPixelPoint(snap,w,h,x,y),g=fixedPixelPoint(snap,w,h,x,y,snap.bits+64);return fixedAnalyticInterior(p[0],p[1],snap.bits)&&fixedAnalyticInterior(g[0],g[1],snap.bits+64)}
-function roundShift(v,bits){const neg=v<0n,a=neg?-v:v,half=1n<<(BigInt(bits)-1n),q=(a+half)>>BigInt(bits);return neg?-q:q}
-// ── Arbitrary-precision reference orbit / perturbation setup ────────────
-const referenceCache={id:0,bits:0,re:0n,im:0n,n:0,escape:0,zr:0n,zi:0n,rr:null,ri:null,series:null,version:0,loadedLen:0,derivative:[0,0,NEG_BUCKET],conditionLog2:0,checkpointVersion:0,checkpointBits:0,checkpointCount:0,checkpointMismatch:false};
-function promoteReferenceCache(shift,oldBits){
-  const c=referenceCache;if(!c.rr||c.bits!==oldBits)return;
-  const sh=BigInt(shift);c.re<<=sh;c.im<<=sh;c.zr<<=sh;c.zi<<=sh;c.bits+=shift;
-  // rr/ri are normalized Float64 values, so neither they nor Worker-side copies
-  // need to change when only the fixed-point radix moves.
-}
-function sameReference(bits,re,im){
-  return referenceCache.rr&&referenceCache.bits===bits&&referenceCache.re===re&&referenceCache.im===im;
-}
-function resetReference(bits,re,im){
-  const c=referenceCache;c.id++;c.bits=bits;c.re=re;c.im=im;c.n=0;c.escape=0;c.zr=0n;c.zi=0n;c.derivative=[0,0,NEG_BUCKET];c.conditionLog2=0;
-  if(!c.rr){c.rr=new Float64Array(150001);c.ri=new Float64Array(150001)}
-  c.series=null;c.version=1;c.loadedLen=0;c.checkpointVersion=0;c.checkpointBits=0;c.checkpointCount=0;c.checkpointMismatch=false;
-}
-function invalidateReferenceOrbit(){const c=referenceCache;c.id++;c.bits=0;c.re=0n;c.im=0n;c.n=0;c.escape=0;c.zr=0n;c.zi=0n;c.rr=null;c.ri=null;c.series=null;c.version=0;c.loadedLen=0;c.derivative=[0,0,NEG_BUCKET];c.conditionLog2=0;c.checkpointVersion=0;c.checkpointBits=0;c.checkpointCount=0;c.checkpointMismatch=false;for(const worker of deepPool.workers){worker._refKey='';worker._refLoaded=0}}
-function buildReferenceAt(bits,cRe,cIm,iter,token,done){
-  if(!sameReference(bits,cRe,cIm))resetReference(bits,cRe,cIm);
-  const c=referenceCache,B=BigInt(bits),ONE=1n<<B,BAIL=16n*ONE,startN=c.n,refT0=performance.now();
-  if((c.escape&&c.escape<=iter)||c.n>=iter){
-    const refLen=c.escape&&c.escape<=iter?c.escape:iter;done(c,refLen);return
-  }
-  function slice(){
-    if(token!==state.token)return;const deadline=performance.now()+6.5;
-    while(c.n<iter&&!c.escape&&performance.now()<deadline){
-      c.rr[c.n]=fixedOrbitNum(c.zr,bits);c.ri[c.n]=fixedOrbitNum(c.zi,bits);const Rr=c.rr[c.n],Ri=c.ri[c.n],d=c.derivative,term=d[2]===NEG_BUCKET?[0,0,NEG_BUCKET]:normalizeBucket(2*(Rr*d[0]-Ri*d[1]),2*(Rr*d[1]+Ri*d[0]),d[2]);c.derivative=scAdd(term,[1,0,0]);c.conditionLog2=Math.max(c.conditionLog2,scLog2(c.derivative));
-      const zr2=roundShift(c.zr*c.zr,bits),zi2=roundShift(c.zi*c.zi,bits);c.zi=roundShift(2n*c.zr*c.zi,bits)+cIm;c.zr=zr2-zi2+cRe;c.n++;
-      const mag=roundShift(c.zr*c.zr,bits)+roundShift(c.zi*c.zi,bits);if(mag>BAIL)c.escape=c.n;
-    }
-    if(c.escape||c.n>=iter){
-      c.rr[c.n]=fixedOrbitNum(c.zr,bits);c.ri[c.n]=fixedOrbitNum(c.zi,bits);c.version++;if(c.n>startN){const ms=performance.now()-refT0;refControl.lastBuildMs=ms;refControl.buildEMA=refControl.buildEMA?refControl.buildEMA*.82+ms*.18:ms}
-      const refLen=c.escape&&c.escape<=iter?c.escape:iter;done(c,refLen)
-    }else requestAnimationFrame(slice);
-  }
-  requestAnimationFrame(slice);
-}
-function verifyReferenceCheckpoints(ref,refLen,token,done){
-  const guardBits=ref.bits+64;
-  if(ref.checkpointVersion===ref.version&&ref.checkpointBits===guardBits&&!ref.checkpointMismatch){done(true);return}
-  const cRe=align(ref.re,ref.bits,guardBits),cIm=align(ref.im,ref.bits,guardBits),ONE=1n<<BigInt(guardBits),BAIL=16n*ONE;
-  const targets=new Set([0,refLen]);for(let n=1;n<refLen;n*=2)targets.add(n);const stride=Math.max(1,Math.floor(refLen/32));for(let n=stride;n<refLen;n+=stride)targets.add(n);
-  let zr=0n,zi=0n,n=0,escape=0,checked=0,mismatch=false;
-  function compare(){if(!targets.has(n)||n>refLen)return;checked++;const rr=fixedOrbitNum(zr,guardBits),ri=fixedOrbitNum(zi,guardBits);if(!Object.is(rr,ref.rr[n])||!Object.is(ri,ref.ri[n]))mismatch=true}
-  function slice(){
-    if(token!==state.token)return;const deadline=performance.now()+6;compare();
-    while(n<refLen&&!escape&&!mismatch&&performance.now()<deadline){const zr2=roundShift(zr*zr,guardBits),zi2=roundShift(zi*zi,guardBits);zi=roundShift(2n*zr*zi,guardBits)+cIm;zr=zr2-zi2+cRe;n++;const mag=roundShift(zr*zr,guardBits)+roundShift(zi*zi,guardBits);if(mag>BAIL)escape=n;compare()}
-    if(mismatch||escape||n>=refLen){if((ref.escape||0)!==escape&&((ref.escape||0)<=refLen||escape<=refLen))mismatch=true;ref.checkpointVersion=ref.version;ref.checkpointBits=guardBits;ref.checkpointCount=checked;ref.checkpointMismatch=mismatch;done(!mismatch)}else requestAnimationFrame(slice)
-  }
-  requestAnimationFrame(slice)
-}
-function computeSeries(ref,refLen,logMaxDc){
-  // A series valid for a wider image remains valid after zooming further in.
-  if(ref.series&&logMaxDc<=ref.series.logMaxDc+.02&&ref.series.skip<refLen)return ref.series;
-  let A=[0,0,NEG_BUCKET],Bc=[0,0,NEG_BUCKET],bestSkip=0,bestA=[0,0,NEG_BUCKET],bestB=[0,0,NEG_BUCKET];
-  const LOG_LIMIT=Math.log2(2.2e-4),LOG_RATIO=Math.log2(.10);
-  for(let n=0;n<refLen;n++){
-    const R=ref.rr[n],I=ref.ri[n],oldA=A;
-    const at=oldA[2]===NEG_BUCKET?[0,0,NEG_BUCKET]:normalizeBucket(2*(R*oldA[0]-I*oldA[1]),2*(R*oldA[1]+I*oldA[0]),oldA[2]);
-    A=scAdd(at,[1,0,0]);
-    const bt=Bc[2]===NEG_BUCKET?[0,0,NEG_BUCKET]:normalizeBucket(2*(R*Bc[0]-I*Bc[1]),2*(R*Bc[1]+I*Bc[0]),Bc[2]);
-    const a2=oldA[2]===NEG_BUCKET?[0,0,NEG_BUCKET]:normalizeBucket(oldA[0]*oldA[0]-oldA[1]*oldA[1],2*oldA[0]*oldA[1],2*oldA[2]);
-    Bc=scAdd(bt,a2);
-    const l1=scLog2(A)+logMaxDc,l2=scLog2(Bc)+2*logMaxDc;
-    if(Number.isFinite(l1)&&l1<LOG_LIMIT&&(!Number.isFinite(l2)||(l2<LOG_LIMIT&&l2<l1+LOG_RATIO))){bestSkip=n+1;bestA=A.slice();bestB=Bc.slice()}
-  }
-  if(bestSkip>=refLen)bestSkip=Math.max(0,refLen-1);
-  ref.series={logMaxDc,skip:bestSkip,Ar:bestA[0],Ai:bestA[1],Ab:bestA[2],Br:bestB[0],Bi:bestB[1],Bb:bestB[2]};
-  return ref.series;
-}
-function chooseReference(snap){
-  const c=referenceCache;if(c.rr&&c.n>8){const rr=align(c.re,c.bits,snap.bits),ri=align(c.im,c.bits,snap.bits),dx=fixedRatio(rr-snap.re,snap.span),dy=fixedRatio(ri-snap.im,snap.span),dist=Math.hypot(dx,dy);if(Number.isFinite(dist)){const hard=2.25;if(dist<=hard){let keep=true;if(dist>.45&&refControl.refId===c.id&&refControl.baseMPP>0&&refControl.lastMPP>refControl.baseMPP*1.34&&performance.now()-refControl.lastRecenterAt>refControl.cooldownMs){const extra=(refControl.lastMPP-refControl.baseMPP)*Math.max(1,refControl.lastPixels),build=Math.max(5,refControl.buildEMA||18);if(extra>build*1.65)keep=false}if(keep)return{re:rr,im:ri,reused:true,dist};refControl.lastRecenterAt=performance.now()}}}return{re:snap.re,im:snap.im,reused:false,dist:0}
-}
-function putDeepPixel(out,w,computeIter,colorIter,x,y,n,m,colorCtx){
-  const oi=(y*w+x)*4,mm=n>=computeIter?0:Math.max(4.0000001,m);
-  
-  if(n>=computeIter){out[oi]=0;out[oi+1]=0;out[oi+2]=0;out[oi+3]=255;return}
-  putFastColor(out,oi,n,mm,colorIter,colorCtx);
-}
-function directOrbitState(cr,ci,bits,iter){return{cr,ci,bits,iter,zr:0n,zi:0n,mag:0n,n:0,done:false,four:4n*(1n<<BigInt(bits))}}
-function stepDirectOrbit(orbit,deadline){let batch=0;while(!orbit.done){const zr2=roundShift(orbit.zr*orbit.zr,orbit.bits),zi2=roundShift(orbit.zi*orbit.zi,orbit.bits);orbit.mag=zr2+zi2;if(orbit.mag>orbit.four||orbit.n>=orbit.iter){orbit.done=true;break}orbit.zi=roundShift(2n*orbit.zr*orbit.zi,orbit.bits)+orbit.ci;orbit.zr=zr2-zi2+orbit.cr;orbit.n++;if((++batch&31)===0&&performance.now()>=deadline)break}if(orbit.n>=orbit.iter)orbit.done=true}
-async function highPrecisionDirectPixelAsync(snap,w,h,iter,x,y,guarded=true,cancelled=()=>false){const p=fixedPixelPoint(snap,w,h,x,y),base=directOrbitState(p[0],p[1],snap.bits,iter);let guard=null;if(guarded){const bits=snap.bits+64,g=fixedPixelPoint(snap,w,h,x,y,bits);guard=directOrbitState(g[0],g[1],bits,iter)}while(!base.done||(guard&&!guard.done)){if(cancelled())return null;const deadline=performance.now()+6;stepDirectOrbit(base,deadline);if(guard)stepDirectOrbit(guard,deadline);if(!base.done||(guard&&!guard.done))await new Promise(requestAnimationFrame)}if(guard&&(guard.n!==base.n||((guard.n<iter)!==(base.n<iter))))return[iter,0];const chosen=guard||base;return[chosen.n,chosen.n<iter?Math.max(4.0000001,fixedOrbitNum(chosen.mag,chosen.bits)):0]}
-function renderDeepDirect(profile,snap,w,h,iter,colorIter,token,t0){
-  const cap=profile.covered?w:390,scale=Math.min(1,cap/w);if(scale<1){h=Math.max(100,Math.round(h*scale));w=Math.max(160,Math.round(w*scale))}
-  const out=new Uint8ClampedArray(w*h*4),field=makeField(w*h,colorIter),colorCtx=makeColorCtx(colorIter);let y=0;
-  state.lastEngine='BigInt direct fallback';
-  async function slice(){
-    if(token!==state.token)return;const deadline=performance.now()+7;
-    while(y<h&&performance.now()<deadline){const y0=y;for(let x=0;x<w;x++){const result=await highPrecisionDirectPixelAsync(snap,w,h,iter,x,y,false,()=>token!==state.token);if(!result)return;const[n,m]=result;putField(field,y*w+x,n,m,n<iter?FIELD_ESCAPED:FIELD_UNKNOWN);putDeepPixel(out,w,iter,colorIter,x,y,n,m,colorCtx)}presentPartialStripe(out.subarray(y0*w*4,(y0+1)*w*4),0,y0,w,1,w,h,snap);y++}
-    if(y<h)requestAnimationFrame(slice);else finishRender(token,t0,profile,snap,w,h,out,'BigInt direct fallback',w*h,field);
-  }requestAnimationFrame(slice);
-}
-function prepareDeepContext(snap,refC,iter,token,done){
-  const probeW=64,probeH=Math.max(28,Math.round(probeW*canvas.clientHeight/Math.max(1,canvas.clientWidth))),refX=probeW*.5-.5+fixedRatio(refC.re-snap.re,snap.span)*probeW,refY=probeH*.5-.5-fixedRatio(refC.im-snap.im,snap.span)*probeW,cornerR=Math.max(Math.hypot(refX,refY),Math.hypot(probeW-refX,refY),Math.hypot(refX,probeH-refY),Math.hypot(probeW-refX,probeH-refY))/Math.max(1,probeW),logMaxDc=log2FixedAt(snap.span,snap.bits)+Math.log2(Math.max(1e-300,cornerR));
-  buildReferenceAt(snap.bits,refC.re,refC.im,iter,token,(ref,refLen)=>{if(token!==state.token)return;if(ensureOrbitPrecision(iter,Math.max(1,canvas.width))){state.dirty=true;invalidateView();return}const finish=()=>done({ref,refLen,series:computeSeries(ref,refLen,logMaxDc)});if(state.processMode!=='validate'){finish();return}verifyReferenceCheckpoints(ref,refLen,token,ok=>{if(token!==state.token)return;if(ok){finish();return}promoteState(32);invalidateReferenceOrbit();state.dirty=true;invalidateView()})})
-}
-function renderPerturbPrepared(profile,snap,w,h,iter,colorIter,token,t0,refC,ref,refLen,series,reuse=null){
-  const workerReady=ensureDeepPool();if(!workerReady&&(!ensureDeepWasm()||!deepWasm.ex.render_perturb_rebase_rect)){renderDeepDirect(profile,snap,w,h,iter,colorIter,token,t0);return}
-  const centered=pixelCenteredOffset(snap,refC,w),out=reuse?reuse.out:new Uint8ClampedArray(w*h*4),field=makeField(w*h,colorIter),colorCtx=makeColorCtx(colorIter),sb=spanMantBucket(snap.span,snap.bits),off=fixedComplexScaled(centered.r,centered.i,snap.bits);
-  const fallback=(strict=false)=>{if(token!==state.token)return;if(!ensureDeepWasm()||!deepWasm.ex.render_perturb_rebase_rect){renderDeepDirect(profile,snap,w,h,iter,colorIter,token,t0);return}if(ref.loadedLen<refLen+1){deepWasm.refsR().set(ref.rr.subarray(ref.loadedLen,refLen+1),ref.loadedLen);deepWasm.refsI().set(ref.ri.subarray(ref.loadedLen,refLen+1),ref.loadedLen);ref.loadedLen=refLen+1}const counts=deepWasm.counts(),mags=deepWasm.mags(),bad=[];let y=0;function rows(){if(token!==state.token)return;const deadline=performance.now()+(profile.covered?11:8);while(y<h&&performance.now()<deadline){const rows=Math.min(Math.max(1,Math.floor(65536/Math.max(1,w))),h-y),y0=y,npx=deepWasm.ex.render_perturb_rebase_rect(sb.mant,sb.bucket,off[0],off[1],off[2],refLen,w,h,w*.5,h*.5,0,y,w,rows,iter,strict?0:series.skip,strict?0:series.Ar,strict?0:series.Ai,strict?0:series.Ab,strict?0:series.Br,strict?0:series.Bi,strict?0:series.Bb);for(let i=0;i<npx;i++){const x=i%w,py=y0+((i/w)|0),n=counts[i],m=mags[i];if(n===0xffffffff){bad.push(py*w+x);continue}putField(field,py*w+x,n,m,n<iter?FIELD_ESCAPED:FIELD_UNKNOWN);putDeepPixel(out,w,iter,colorIter,x,py,n,m,colorCtx)}y+=rows}if(y<h)requestAnimationFrame(rows);else if(bad.length)runResidual();else finish()}function runResidual(){let k=0;async function slice(){if(token!==state.token)return;const deadline=performance.now()+6;while(k<bad.length&&performance.now()<deadline){const idx=bad[k++],x=idx%w,py=(idx/w)|0,result=await highPrecisionDirectPixelAsync(snap,w,h,iter,x,py,false,()=>token!==state.token);if(!result)return;const[n,m]=result;putField(field,idx,n,m,n<iter?FIELD_ESCAPED:FIELD_UNKNOWN);putDeepPixel(out,w,iter,colorIter,x,py,n,m,colorCtx)}if(k<bad.length)requestAnimationFrame(slice);else finish()}requestAnimationFrame(slice)}function finish(){state.lastEngine='WASM '+(deepWasm.simd?'SIMD':'scalar')+' · '+(strict?'strict ':'')+'main-thread rebase · skip '+(strict?0:series.skip);finishRender(token,t0,profile,snap,w,h,out,state.lastEngine,w*h,field)}requestAnimationFrame(rows)};
-  // Never abort and restart an in-flight frame because a budget estimate was wrong.
-  // Finish it once and feed the measured cost into the next frame.
-  if(!workerReady||!runDeepPool(profile,snap,w,h,iter,colorIter,token,t0,out,sb,refC,off,ref,refLen,series,fallback,reuse?reuse.rects:null))fallback();
-}
-async function renderDeepAdaptive(profile,snap,plan,token,t0){
-  try{await prepareDeepModules()}catch{if(token===state.token){const [fallbackW,fallbackH]=targetSize(profile,true);renderDeepDirect(profile,snap,fallbackW,fallbackH,plan.colorIter,plan.colorIter,token,t0)}return}if(token!==state.token)return;
-  const iter=plan.colorIter,colorIter=plan.colorIter,[w,h]=targetSize(profile,true),reuse=buildPanReuse(snap,w,h,iter,profile);
-  // A zoom-in can be represented entirely by the previous frame. Commit that preview
-  // immediately; the normal idle HQ pass performs the exact full-resolution render.
-  if(reuse&&reuse.rects.length===0&&!profile.covered){finishRender(token,t0,profile,snap,w,h,reuse.out,'既存画像再利用 100%',0);return}
-  const refC=chooseReference(snap);state.lastEngine='参照軌道を準備中…';prepareDeepContext(snap,refC,iter,token,ctx=>{if(token!==state.token)return;renderPerturbPrepared(profile,snap,w,h,iter,colorIter,token,t0,refC,ctx.ref,ctx.refLen,ctx.series,reuse)})
-}
-function render(pass=RENDER_PASS.PREVIEW){
-  const profile=renderProfile(pass);
-  if(pass===RENDER_PASS.COVERED){state.fieldView=null;trimDetailCache()}
-  runtimeMetrics.renderStarts++;if(state.pointerActive||state.wheelActive)runtimeMetrics.renderStartsDuringGesture++;
-  let snap=snapshot(),deep=deepEngineNeeded(snap);if(!deep&&state.adaptivePixelBudget){state.adaptivePixelBudget=0;resize()}if(deep&&ensureOrbitPrecision(maxIter()))snap=snapshot();const plan=iterationPlan(profile,deep),token=++state.token,t0=performance.now();state.rendering=true;state.drawState=profile.covered?'COVERING':'PREVIEW';state.lastPass=profile.id;state.lastEngine=deep?'参照軌道を準備中…':(wasm?('WebAssembly '+(wasm.simd?'SIMD':'scalar')):'JavaScript f64');
-  if(!deep){const ratio=deepResolutionRatio(snap);if(ratio<=128)prewarmDeepAssets();else if(deepPool.workers.length||deepWasm||deepModuleBundle||referenceCache.rr)retireDeepAssets()}
-  invalidateStats();
-  if(deep)renderDeepAdaptive(profile,snap,plan,token,t0);else{const [w,h]=targetSize(profile,false),reuse=buildPanReuse(snap,w,h,plan.computeIter,profile);if(reuse)renderShallowReuse(profile,snap,w,h,plan.computeIter,token,t0,reuse);else if(wasm)renderWasm(profile,snap,w,h,plan.computeIter,token,t0);else renderJsDouble(profile,snap,w,h,plan.computeIter,token,t0)}
-}
-function screenPixelBudget(){
-  const lowMemory=Number(navigator.deviceMemory||8)<=4,small=matchMedia('(max-width:700px)').matches;if(state.processMode==='power')return 1*1048576;if(state.processMode==='fine'||state.processMode==='validate')return(lowMemory||small?4:8)*1048576;
-  const base=(lowMemory||small?2:4)*1048576;return state.adaptivePixelBudget?Math.min(base,state.adaptivePixelBudget):base
-}
-function adaptStandardDeepBudget(deep){if(state.processMode!=='standard'||!deep)return false;const measuredMPP=renderPerf.deepMPP||.03,target=Math.max(32768,Math.min(4*1048576,Math.round(1400/measuredMPP))),oldBudget=state.adaptivePixelBudget||screenPixelBudget();if(target/oldBudget>=.8&&target/oldBudget<=1.25)return false;const oldPixels=canvas.width*canvas.height;state.adaptivePixelBudget=target;resize();return canvas.width*canvas.height!==oldPixels}
-function resize(){
-  const cssW=Math.max(1,innerWidth),cssH=Math.max(1,innerHeight),budget=screenPixelBudget(),nativeDpr=Math.max(1,window.devicePixelRatio||1),budgetDpr=Math.sqrt(budget/Math.max(1,cssW*cssH)),minDpr=Math.min(1,64/Math.max(cssW,cssH)),dpr=Math.max(minDpr,Math.min(nativeDpr,budgetDpr)),w=Math.max(2,Math.round(cssW*dpr)),h=Math.max(2,Math.round(cssH*dpr));
-  state.effectiveDpr=dpr;state.screenPixelBudget=budget;
-  if(canvas.width!==w||canvas.height!==h){clearPanReuse();canvas.width=w;canvas.height=h;trimDetailCache();state.dirty=true;invalidateView()}
-}
-function jaEngine(s){return String(s||'').replace('preparing cached rebase reference…','参照軌道を準備中…').replace('persistent workers','常駐Worker').replace('main-thread','メインスレッド').replace('strict','厳密').replace('fallback','フォールバック').replace('rebase','リベース').replace('skip','スキップ').replace('residual','残差').replace('starting','起動中')}
-function updateStats(){
-  runtimeMetrics.domWrites++;
-  const z=zoomExp(),digits=Math.max(8,Math.min(80,Math.ceil(z)+8));$('#coord').textContent=fmtFixed(state.re,digits)+' '+(state.im<0n?'−':'+')+' '+fmtFixed(state.im<0n?-state.im:state.im,digits)+'i';
-  $('#zoom').textContent=z<4?Math.pow(10,z).toFixed(1)+'×':'≈ 10^'+z.toFixed(2);$('#span').textContent=fmtSpan();const deep=deepEngineNeeded(),diagnosticProfile=RENDER_PROFILE[RENDER_PASS.COVERED],ip=iterationPlan(diagnosticProfile,deep);$('#engine').textContent=deep?'高精度深部':'標準精度';$('#render').textContent=state.rendering?'描画中…':(state.lastRender?state.lastRender.toFixed(0)+' ms':'準備完了');let status;if(state.drawState==='REPROJECTED')status='再投影';else if(state.drawState==='PREVIEW')status=state.rendering?'プレビュー描画中':'プレビュー';else if(state.drawState==='COVERING')status='全域描画中';else if(state.drawState==='RESOLVING')status='未確定を追加計算 '+Math.round(state.continuationProgress*100)+'%';else if(state.drawState==='REFINING')status='境界AA '+state.detailDone+'/'+state.detailQueued;else if(state.drawState==='REFINED')status='境界AA 完了';else if(state.drawState==='VALIDATING')status='精度照合 '+Math.round(state.coverage*100)+'%';else if(state.drawState==='VALIDATION_INCOMPLETE')status='検証未完了';else if(state.drawState==='VALIDATED')status='検証完了';else status='全域描画 完了';if(state.unresolved)status+=' · 未確定 '+state.unresolved;if(state.effectiveDpr<(devicePixelRatio||1)*.99)status+=' · '+canvas.width+'×'+canvas.height;$('#badge').textContent=status;$('#compactStatus').textContent=status;const ledger=memoryLedger(),bp=blaProfile(diagnosticProfile);$('#diagEngine').textContent='engine: '+jaEngine(state.lastEngine)+' | workers '+deepPool.workers.length+' | '+(wasm&&wasm.simd?'SIMD':'scalar/JS');$('#diagNumeric').textContent='numeric: '+state.bits+' bit | iter '+ip.colorIter+' | BLA ε 2^-'+bp.exp+' | condition '+Math.round(referenceCache.conditionLog2||0)+' bit';$('#diagMemory').textContent='memory: managed '+(ledger.managedBytes/1048576).toFixed(1)+' / '+(ledger.budget/1048576).toFixed(0)+' MiB | canvas est. '+(ledger.canvasBytes/1048576).toFixed(1)+' MiB';
-}
-
-
-// ── Scheduler / interaction loop ────────────────────────────────────────
-function nextQualityDue(deep){
-  if(state.processMode==='power'||state.dirty||state.rendering||state.pointerActive||state.wheelActive)return Infinity;
-  if(deep&&state.lastPass!==RENDER_PASS.COVERED)return Math.max(state.lastInteraction+680,state.lastFrameDone+260);
-  if(!deep&&state.lastPass!==RENDER_PASS.COVERED)return Math.max(state.lastInteraction+520,state.lastFrameDone+280);
-  return Infinity
-}
-function loop(now){
-  schedulerRAF=0;if(document.hidden)return;
-  const deep=deepEngineNeeded();
-  if(!state.pointerActive&&!state.wheelActive&&!state.rendering){
-    if(state.dirty)render(RENDER_PASS.PREVIEW);
-    else{
-      const due=nextQualityDue(deep);
-      if(due<=now)render(RENDER_PASS.COVERED)
-    }
-  }
-  if(needsPaint){needsPaint=false;paintFrame()}
-  if(needsStats){needsStats=false;updateStats()}
-  if(!state.rendering&&!state.pointerActive&&!state.wheelActive&&!state.dirty){
-    const due=nextQualityDue(deep);if(Number.isFinite(due))requestScheduler(Math.max(1,due-performance.now()))
-  }
-}
-
-const pts=new Map();let lx=0,ly=0,pinch=0;
-canvas.addEventListener('wheel',e=>{e.preventDefault();updateFocus(e.clientX,e.clientY);if(!state.wheelActive){state.wheelActive=true;cancelDetailRefinement(true);cancelRender();capturePanSource()}zoomAt(e.clientX,e.clientY,Math.exp(e.deltaY*.00125));clearTimeout(wheelSettleTimer);wheelSettleTimer=setTimeout(()=>{wheelSettleTimer=0;state.wheelActive=false;state.lastInteraction=performance.now();state.dirty=true;recordView();saveHash(false);invalidateView()},110)},{passive:false});
-canvas.addEventListener('pointerdown',e=>{updateFocus(e.clientX,e.clientY);try{canvas.setPointerCapture(e.pointerId)}catch{};if(pts.size===0){clearTimeout(pointerSettleTimer);pointerSettleTimer=0;clearTimeout(wheelSettleTimer);wheelSettleTimer=0;state.wheelActive=false;state.pointerActive=true;cancelDetailRefinement(true);cancelRender();capturePanSource()}pts.set(e.pointerId,[e.clientX,e.clientY]);if(pts.size===1){lx=e.clientX;ly=e.clientY}else if(pts.size===2){const a=[...pts.values()];pinch=Math.hypot(a[0][0]-a[1][0],a[0][1]-a[1][1])}});
-canvas.addEventListener('pointermove',e=>{if(!pts.has(e.pointerId))return;updateFocus(e.clientX,e.clientY);pts.set(e.pointerId,[e.clientX,e.clientY]);if(pts.size===1){const dx=e.clientX-lx,dy=e.clientY-ly;pan(dx,dy);lx=e.clientX;ly=e.clientY}else if(pts.size===2){const a=[...pts.values()],d=Math.hypot(a[0][0]-a[1][0],a[0][1]-a[1][1]);if(pinch>0&&d>0)zoomAt((a[0][0]+a[1][0])/2,(a[0][1]+a[1][1])/2,pinch/d);pinch=d}});
-function end(e){pts.delete(e.pointerId);pinch=0;if(pts.size)return;clearTimeout(pointerSettleTimer);pointerSettleTimer=setTimeout(()=>{pointerSettleTimer=0;state.pointerActive=false;state.lastInteraction=performance.now();state.dirty=true;recordView();saveHash(false);invalidateView()},90)}canvas.addEventListener('pointerup',end);canvas.addEventListener('pointercancel',end);
-function applyUiVisibility(){document.body.classList.toggle('ui-hidden',state.uiHidden);$('#uiToggle').textContent=state.uiHidden?'UI＋':'UI−';$('#uiToggle').setAttribute('aria-expanded',String(!state.uiHidden))}
-$('#uiToggle').onclick=()=>{state.uiHidden=!state.uiHidden;applyUiVisibility();try{localStorage.setItem('mandelbrot.uiHidden',state.uiHidden?'1':'0')}catch{}};
-$('#zin').onclick=()=>{capturePanSource();zoomAt(innerWidth/2,innerHeight/2,.5);recordView();saveHash(false)};$('#zout').onclick=()=>{capturePanSource();zoomAt(innerWidth/2,innerHeight/2,2);recordView();saveHash(false)};$('#reset').onclick=()=>{reset();recordView()};
-const exportJob={active:false,cancelled:false,bytes:0};let exportForcePrecision=false;
-function downloadBlob(blob,name){const a=document.createElement('a');a.href=URL.createObjectURL(blob);a.download=name;a.click();setTimeout(()=>URL.revokeObjectURL(a.href),1500)}
-function exportLedgerBytes(){return memoryLedger().logicalBytes}
-function exportSampleShallow(cre,cim,scale,W,H,iter,x,y){const cr=cre+(x+.5-W*.5)*scale,ci=cim+(H*.5-y-.5)*scale;let zr=0,zi=0,zr2=0,zi2=0,n=0;while(n<iter&&zr2+zi2<=4){zi=2*zr*zi+ci;zr=zr2-zi2+cr;zr2=zr*zr;zi2=zi*zi;n++}return[n,n<iter?Math.max(4.0000001,zr2+zi2):0]}
-async function runExport(){if(exportJob.active)return;const scaleChoice=Number($('#exportScale').value),w=Math.max(64,Math.min(16384,Math.round(scaleChoice?canvas.width*scaleChoice:Number($('#exportWidth').value)||canvas.width))),h=Math.max(1,Math.round(w*canvas.height/Math.max(1,canvas.width))),ss=Math.max(1,Math.min(2,Number($('#exportAA').value)||1)),needed=w*h*8,budget=rendererMemoryBudget(),available=Math.max(0,budget-exportLedgerBytes());if(w>16384||h>16384){$('#exportStatus').textContent='辺の長さは 16384px 以下にしてください。';return}if(needed>available){$('#exportStatus').textContent='メモリ予算を超えます。幅または倍率を下げてください（必要 '+Math.ceil(needed/1048576)+' MiB / 空き '+Math.floor(available/1048576)+' MiB）。';return}const outCanvas=document.createElement('canvas');outCanvas.width=w;outCanvas.height=h;const oc=outCanvas.getContext('2d',{alpha:false});if(!oc){$('#exportStatus').textContent='出力 Canvas を作成できません。';return}const snap=snapshot(),iter=maxIter(),deep=deepEngineNeeded(snap,w),cre=fixedNum(snap.re,snap.bits),cim=fixedNum(snap.im,snap.bits),sp=fixedNum(snap.span,snap.bits),W=w*ss,H=h*ss,pixelScale=sp/W,colorCtx=makeColorCtx(iter),tmp=new Uint8ClampedArray(4),tiles=[],tileW=exportForcePrecision?4:(deep?16:128),tileH=exportForcePrecision?1:(deep?4:24);for(let y=0;y<h;y+=tileH)for(let x=0;x<w;x+=tileW)tiles.push({x,y,w:Math.min(tileW,w-x),h:Math.min(tileH,h-y)});exportJob.active=true;exportJob.cancelled=false;exportJob.bytes=needed;$('#exportProgress').hidden=false;$('#exportProgress').value=0;$('#exportStart').disabled=true;$('#exportStatus').textContent='タイル描画中…';let done=0,unresolvedSamples=0;try{for(const tile of tiles){if(exportJob.cancelled)throw new Error('cancelled');const id=oc.createImageData(tile.w,tile.h),data=id.data;for(let yy=0;yy<tile.h;yy++)for(let xx=0;xx<tile.w;xx++){let ar=0,ag=0,ab=0;for(let sy=0;sy<ss;sy++)for(let sx=0;sx<ss;sx++){const gx=(tile.x+xx)*ss+sx,gy=(tile.y+yy)*ss+sy,sample=deep?await highPrecisionDirectPixelAsync(snap,W,H,iter,gx,gy,exportForcePrecision,()=>exportJob.cancelled):exportSampleShallow(cre,cim,pixelScale,W,H,iter,gx,gy);if(!sample)throw new Error('cancelled');const[n,m]=sample;if(n<iter){putFastColor(tmp,0,n,m,iter,colorCtx);ar+=linearChannel(tmp[0]);ag+=linearChannel(tmp[1]);ab+=linearChannel(tmp[2])}else{ar+=linearChannel(20);ag+=linearChannel(22);ab+=linearChannel(30);unresolvedSamples++}}const samples=ss*ss,oi=(yy*tile.w+xx)*4;data[oi]=srgbChannel(ar/samples);data[oi+1]=srgbChannel(ag/samples);data[oi+2]=srgbChannel(ab/samples);data[oi+3]=255}oc.putImageData(id,tile.x,tile.y);done++;$('#exportProgress').value=done/tiles.length;$('#exportStatus').textContent='生成中 '+Math.round(done/tiles.length*100)+'%';await new Promise(requestAnimationFrame)}if(exportJob.cancelled)throw new Error('cancelled');$('#exportStatus').textContent='PNGを圧縮中…';const blob=await new Promise(resolve=>outCanvas.toBlob(resolve,'image/png'));if(!blob)throw new Error('PNG encode failed');const stamp=Date.now(),base='mandelbrot-'+stamp,meta={format:'mandelbrot-view-v23',rendererVersion:23,pixelContract:'centered',width:w,height:h,supersampling:ss,sampleCount:w*h*ss*ss,unresolvedSamples,membershipCertified:false,precisionPolicy:{mode:exportForcePrecision?'validated-direct':'balanced',baseBits:snap.bits,agreementGuardBits:exportForcePrecision?64:0},iterationPolicy:{adaptive:state.adaptive,base:state.baseIter,effective:iter},numericEngine:deep?'bigint-fixed-direct':'javascript-f64-direct',kernelSha256:globalThis.MANDEL_KERNEL_META||null,colorSpace:'sRGB with linear-light sample resolve',encoder:{mime:'image/png',api:'HTMLCanvasElement.toBlob'},view:{bits:snap.bits,re:snap.re.toString(),im:snap.im.toString(),span:snap.span.toString()},palette:{id:state.palette,cycle:state.cycle,shift:state.shift},determinism:{randomSeed:null,tiled:true,allTilesCompleted:true}};downloadBlob(blob,base+'.png');downloadBlob(new Blob([JSON.stringify(meta,null,2)],{type:'application/json'}),base+'.json');$('#exportStatus').textContent='PNG と座標メタデータを保存しました。'}catch(e){$('#exportStatus').textContent=String(e&&e.message)==='cancelled'?'出力を中止しました。':'出力に失敗しました: '+String(e&&e.message||e)}finally{exportJob.active=false;exportJob.bytes=0;$('#exportStart').disabled=false}}
-$('#png').onclick=()=>{const d=$('#exportDialog');$('#exportWidth').value=String(canvas.width);$('#exportScale').value='1';$('#exportProgress').hidden=true;$('#exportStatus').textContent='';d.showModal?d.showModal():d.setAttribute('open','')};
-$('#exportQuick').onclick=()=>canvas.toBlob(blob=>{if(!blob)return;downloadBlob(blob,'mandelbrot-'+state.drawState.toLowerCase()+'-'+Date.now()+'.png');$('#exportStatus').textContent='現在の表示（'+state.drawState+'）を保存しました。'},'image/png');
-$('#exportScale').onchange=e=>{const s=Number(e.target.value);if(s)$('#exportWidth').value=String(Math.min(16384,canvas.width*s))};$('#exportStart').onclick=async()=>{exportForcePrecision=$('#exportPrecision').value==='validated';try{await runExport()}finally{exportForcePrecision=false}};$('#exportCancel').onclick=()=>{if(exportJob.active){exportJob.cancelled=true;$('#exportStatus').textContent='中止しています…'}else $('#exportDialog').close()};
-function toast(s){const t=$('#toast');t.textContent=s;t.classList.add('show');clearTimeout(toast._t);toast._t=setTimeout(()=>t.classList.remove('show'),1500)}
-let lastWrittenHash='',navigationHash='';
-const viewHistory=[];let viewHistoryIndex=-1;
+function zoomExp(){return Math.max(0,Math.log10(3.4)-log2Fixed(state.span)/Math.log2(10))}
+function fmtSpan(){const l=log2Fixed(state.span)/Math.log2(10);if(l>-4)return fmtFixed(state.span,12);const e=Math.floor(l),m=Math.pow(10,l-e);return m.toFixed(7)+'e'+e}
+function spanMantExp(snap){const l=log2FixedAt(snap.span,snap.bits);if(!Number.isFinite(l))return{mant:0,exp:0};const exp=Math.floor(l),mant=Math.pow(2,l-exp);return{mant,exp}}
+function f32Ulp(x){x=Math.fround(Math.abs(x));if(!Number.isFinite(x))return Infinity;if(x===0)return 2**-149;const e=Math.floor(Math.log2(x));return 2**(e-23)}
+function deepNeeded(snap=snapshot(),width=Math.max(1,canvas.width)){const stepLog=log2FixedAt(snap.span,snap.bits)-Math.log2(width),cr=fixedNum(snap.re,snap.bits),ci=fixedNum(snap.im,snap.bits),ulp=Math.max(f32Ulp(cr),f32Ulp(ci),2**-149),ratio=Math.pow(2,Math.min(1024,stepLog-Math.log2(ulp)));return !Number.isFinite(ratio)||ratio<96||stepLog<-120}
 function currentViewSpec(){return{bits:state.bits,re:state.re,im:state.im,span:state.span,palette:state.palette,cycle:state.cycle,shift:state.shift,baseIter:state.baseIter,adaptive:state.adaptive}}
 function viewSpecKey(v){return[v.bits,v.re,v.im,v.span,v.palette,v.cycle,v.shift,v.baseIter,v.adaptive].join(':')}
-function recordView(){const v=currentViewSpec(),key=viewSpecKey(v);if(viewHistoryIndex>=0&&viewSpecKey(viewHistory[viewHistoryIndex])===key)return;viewHistory.splice(viewHistoryIndex+1);viewHistory.push(v);if(viewHistory.length>80)viewHistory.shift();viewHistoryIndex=viewHistory.length-1;syncHistoryButtons()}
-function restoreView(v){if(!v)return;state.bits=v.bits;state.re=v.re;state.im=v.im;state.span=v.span;state.palette=v.palette;state.cycle=v.cycle;state.shift=v.shift;state.baseIter=v.baseIter;state.adaptive=v.adaptive;clearDetailCache();clearPanReuse();ensurePrecision();syncControls();saveHash(false);setDirty()}
-function syncHistoryButtons(){$('#undoView').disabled=viewHistoryIndex<=0;$('#redoView').disabled=viewHistoryIndex<0||viewHistoryIndex>=viewHistory.length-1}
-function syncCoordinateInputs(){$('#coordReInput').value=fmtFixedExact(state.re);$('#coordImInput').value=fmtFixedExact(state.im);$('#coordSpanInput').value=fmtFixedExact(state.span)}
-function saveHash(push){const p=new URLSearchParams();p.set('v','23');p.set('b',String(state.bits));p.set('re',state.re.toString());p.set('im',state.im.toString());p.set('sp',state.span.toString());p.set('pal',String(state.palette));p.set('cy',String(state.cycle));p.set('sh',String(state.shift));p.set('it',String(state.baseIter));p.set('ad',state.adaptive?'1':'0');const h='#'+p.toString();lastWrittenHash=h;try{if(location.protocol==='file:'||location.origin==='null'){if(location.hash!==h)location.hash=h}else{push?history.pushState(null,'',h):history.replaceState(null,'',h)}}catch{}}
+function recordView(){const v=currentViewSpec(),k=viewSpecKey(v);if(viewHistoryIndex>=0&&viewSpecKey(viewHistory[viewHistoryIndex])===k)return;viewHistory.splice(viewHistoryIndex+1);viewHistory.push(v);if(viewHistory.length>80)viewHistory.shift();viewHistoryIndex=viewHistory.length-1;syncHistoryButtons()}
+function restoreView(v){if(!v)return;Object.assign(state,{bits:v.bits,re:v.re,im:v.im,span:v.span,palette:v.palette,cycle:v.cycle,shift:v.shift,baseIter:v.baseIter,adaptive:v.adaptive});ensurePrecision();syncControls();saveHash(false);markDirty()}
+
+// ── iteration / quality policy ───────────────────────────────────────────
+function maxIter(){if(!state.adaptive)return state.baseIter;const z=zoomExp(),bonus=Math.max(0,Math.floor(70*Math.sqrt(z)+15*z));return Math.min(150000,Math.max(state.baseIter,state.baseIter+bonus))}
+function pixelBudget(){const low=Number(navigator.deviceMemory||8)<=4,small=matchMedia('(max-width:700px)').matches;if(!navigator.gpu||state.gpuUnavailable)return 262144;if(state.processMode==='power')return 524288;if(state.processMode==='fine')return(low||small?1572864:3145728);if(state.processMode==='validate')return(low||small?1048576:2097152);return(low||small?786432:1572864)}
+function resize(){const cssW=Math.max(1,innerWidth),cssH=Math.max(1,innerHeight),budget=pixelBudget(),native=Math.max(1,devicePixelRatio||1),bd=Math.sqrt(budget/(cssW*cssH));let dpr=Math.max(Math.min(1,64/Math.max(cssW,cssH)),Math.min(native,bd));if(renderer){const md=Math.max(2,renderer.adapterLimits.maxTextureDimension2D||8192);dpr=Math.min(dpr,md/cssW,md/cssH)}const w=Math.max(2,Math.round(cssW*dpr)),h=Math.max(2,Math.round(cssH*dpr));state.effectiveDpr=dpr;state.screenPixelBudget=budget;if(canvas.width!==w||canvas.height!==h){canvas.width=w;canvas.height=h;if(renderer)renderer.configure();markDirty(false)}}
+
+// ── high precision reference worker ─────────────────────────────────────
+function referenceWorkerSource(){return String.raw`
+'use strict';
+const MAX_REF=150001,MAX_LEVELS=20;
+function bitLen(v){v=v<0n?-v:v;return v===0n?0:v.toString(2).length}
+function roundShift(v,b){const neg=v<0n,a=neg?-v:v,half=1n<<(BigInt(b)-1n),q=(a+half)>>BigInt(b);return neg?-q:q}
+function fixedNum(v,b){if(v===0n)return 0;let neg=v<0n;if(neg)v=-v;const bl=bitLen(v),take=Math.min(53,bl),sh=bl-take,top=Number(v>>BigInt(sh)),n=top*Math.pow(2,sh-b);return neg?-n:n}
+function orbit(bits,re,im,iter){const B=BigInt(bits),ONE=1n<<B,BAIL=16n*ONE;let zr=0n,zi=0n,escape=0,n=0;const rr=new Float64Array(iter+1),ri=new Float64Array(iter+1);for(;n<iter&&!escape;n++){rr[n]=fixedNum(zr,bits);ri[n]=fixedNum(zi,bits);const zr2=roundShift(zr*zr,bits),zi2=roundShift(zi*zi,bits);zi=roundShift(2n*zr*zi,bits)+im;zr=zr2-zi2+re;const mag=roundShift(zr*zr,bits)+roundShift(zi*zi,bits);if(mag>BAIL)escape=n+1}rr[n]=fixedNum(zr,bits);ri[n]=fixedNum(zi,bits);return{rr,ri,refLen:escape||iter,escape}}
+function verify(baseBits,re,im,ref,refLen){const bits=baseBits+64,R=re<<64n,I=im<<64n,B=BigInt(bits),ONE=1n<<B,BAIL=16n*ONE,targets=new Set([0,refLen]);for(let n=1;n<refLen;n*=2)targets.add(n);const stride=Math.max(1,Math.floor(refLen/32));for(let n=stride;n<refLen;n+=stride)targets.add(n);let zr=0n,zi=0n,escape=0,mismatch=false,checked=0;for(let n=0;n<=refLen&&!escape&&!mismatch;n++){if(targets.has(n)){checked++;if(!Object.is(fixedNum(zr,bits),ref.rr[n])||!Object.is(fixedNum(zi,bits),ref.ri[n]))mismatch=true}if(n===refLen)break;const zr2=roundShift(zr*zr,bits),zi2=roundShift(zi*zi,bits);zi=roundShift(2n*zr*zi,bits)+I;zr=zr2-zi2+R;const mag=roundShift(zr*zr,bits)+roundShift(zi*zi,bits);if(mag>BAIL)escape=n+1}return{mismatch,checked}}
+function packRefs(rr,ri,refLen){const buf=new ArrayBuffer((refLen+1)*16),dv=new DataView(buf);for(let i=0;i<=refLen;i++){const hr=Math.fround(rr[i]),hi=Math.fround(ri[i]),lr=Math.fround(rr[i]-hr),li=Math.fround(ri[i]-hi),o=i*16;dv.setFloat32(o,hr,true);dv.setFloat32(o+4,hi,true);dv.setFloat32(o+8,lr,true);dv.setFloat32(o+12,li,true)}return buf}
+self.onmessage=e=>{const d=e.data;if(!d||d.type!=='build')return;const t0=performance.now();try{const bits=d.bits+64,re=BigInt(d.re)<<64n,im=BigInt(d.im)<<64n,ref=orbit(bits,re,im,Math.min(MAX_REF-1,d.iter)),v=verify(bits,re,im,ref,ref.refLen),refs=packRefs(ref.rr,ref.ri,ref.refLen);postMessage({type:'built',id:d.id,key:d.key,refLen:ref.refLen,escape:ref.escape,precisionBits:bits,checkpointMismatch:v.mismatch,checkpointCount:v.checked,buildMs:performance.now()-t0,refs},[refs])}catch(error){postMessage({type:'error',id:d.id,error:String(error&&error.stack||error)})}}
+`}
+class ReferenceService{
+  constructor(){this.worker=null;this.url='';this.serial=0;this.pending=new Map();this.cache=null;this.failed=false}
+  ensure(){if(this.worker)return true;if(this.failed||typeof Worker==='undefined'||typeof Blob==='undefined')return false;try{this.url=URL.createObjectURL(new Blob([referenceWorkerSource()],{type:'text/javascript'}));this.worker=new Worker(this.url);this.worker.onmessage=e=>{const d=e.data,p=this.pending.get(d.id);if(!p)return;this.pending.delete(d.id);if(d.type==='error')p.reject(new Error(d.error));else{runtime.referenceBuilds++;this.cache=d;p.resolve(d)}};this.worker.onerror=e=>{this.failed=true;for(const p of this.pending.values())p.reject(new Error(e.message||'reference worker error'));this.pending.clear();this.destroy()};return true}catch{this.failed=true;return false}}
+  request(snap,iter){const key=[snap.bits,snap.re,snap.im,iter,'guarded-perturb-v24.1'].join(':');if(this.cache&&this.cache.key===key)return Promise.resolve(this.cache);if(this.pending.size)this.cancelPending('superseded reference request');if(!this.ensure())return Promise.reject(new Error('Reference Workerを作成できません'));const id=++this.serial;return new Promise((resolve,reject)=>{this.pending.set(id,{resolve,reject});this.worker.postMessage({type:'build',id,key,bits:snap.bits,re:snap.re.toString(),im:snap.im.toString(),iter})})}
+  cancelPending(reason='cancelled'){if(!this.pending.size)return;for(const p of this.pending.values())p.reject(new Error(reason));this.pending.clear();if(this.worker){try{this.worker.terminate()}catch{}this.worker=null}if(this.url){try{URL.revokeObjectURL(this.url)}catch{}this.url=''}}
+  destroy(){this.cancelPending('destroyed');if(this.worker){try{this.worker.terminate()}catch{}this.worker=null}if(this.url){try{URL.revokeObjectURL(this.url)}catch{}this.url=''}}
+}
+const refs=new ReferenceService();
+
+// ── WebGPU renderer ──────────────────────────────────────────────────────
+function buf(device,size,usage,label){return device.createBuffer({label,size:Math.max(4,Math.ceil(size/4)*4),usage})}
+function destroy(x){if(x&&x.destroy)try{x.destroy()}catch{}}
+function writeU32F32(size,writer){const a=new ArrayBuffer(size),d=new DataView(a);writer(d);return a}
+class WebGpuRenderer{
+  constructor(adapter,device){
+    this.adapter=adapter;this.device=device;
+    const ai=adapter.info||{};
+    this.adapterInfo={vendor:ai.vendor||'',architecture:ai.architecture||'',device:ai.device||'',description:ai.description||''};
+    this.adapterLimits={maxBufferSize:Number(adapter.limits.maxBufferSize),maxStorageBufferBindingSize:Number(adapter.limits.maxStorageBufferBindingSize),maxComputeWorkgroupsPerDimension:Number(adapter.limits.maxComputeWorkgroupsPerDimension),maxTextureDimension2D:Number(adapter.limits.maxTextureDimension2D)};
+    this.context=null;this.format=navigator.gpu.getPreferredCanvasFormat();
+    this.frame=null;this.deepCtx=null;this.exportWs=null;this.compilation=[];this.uncapturedErrors=[];this.lossReason='';this.sampler=device.createSampler({magFilter:'linear',minFilter:'linear'});
+    device.addEventListener?.('uncapturederror',e=>{const msg=String(e.error&&e.error.message||e.error||'WebGPU uncaptured error');this.uncapturedErrors.push(msg);state.gpuError=msg;console.error(e.error||e)});
+    this.ready=this.initPipelines();
+    device.lost.then(info=>{this.lossReason=info.message||info.reason||'device lost';runtime.deviceLosses++;state.gpuError=this.lossReason;renderer=null;markDirty(false);initRenderer()});
+  }
+  configure(){if(this.context)this.context.configure({device:this.device,format:this.format,alphaMode:'opaque'})}
+  async module(label,code){const m=this.device.createShaderModule({label,code});if(m.getCompilationInfo){const info=await m.getCompilationInfo();const errs=info.messages.filter(x=>x.type==='error');this.compilation.push({label,messages:info.messages.map(x=>({type:x.type,line:x.lineNum,message:x.message}))});if(errs.length)throw new Error(label+': '+errs.map(x=>x.message).join('\n'))}return m}
+  async initPipelines(){
+    this.device.pushErrorScope?.('validation');
+    try{
+      const [dm,xm,cm,am,pm]=await Promise.all([this.module('direct',G.DIRECT_F32_WGSL),this.module('deep',G.DEEP_PERTURB_WGSL),this.module('color',G.COLOR_WGSL),this.module('aa-resolve',G.AA_RESOLVE_WGSL),this.module('present',G.PRESENT_WGSL)]);
+      this.direct=this.device.createComputePipeline({layout:'auto',compute:{module:dm,entryPoint:'main'}});
+      this.deep=this.device.createComputePipeline({layout:'auto',compute:{module:xm,entryPoint:'main'}});
+      this.color=this.device.createComputePipeline({layout:'auto',compute:{module:cm,entryPoint:'main'}});
+      this.aaResolve=this.device.createComputePipeline({layout:'auto',compute:{module:am,entryPoint:'main'}});
+      this.present=this.device.createRenderPipeline({layout:'auto',vertex:{module:pm,entryPoint:'vs'},fragment:{module:pm,entryPoint:'fs',targets:[{format:this.format}]},primitive:{topology:'triangle-list'}});
+      this.context=canvas.getContext('webgpu');
+      if(!this.context)throw new Error('WebGPU canvas contextを取得できません');
+      webgpuCanvasClaimed=true;this.configure();
+    }finally{if(this.device.popErrorScope){const error=await this.device.popErrorScope();if(error)throw error}}
+  }
+  frameDestroy(){if(!this.frame)return;for(const k of ['meta','smooth','unresolved','numericParams','colorParams','presentParams','front','back'])destroy(this.frame[k]);this.frame=null}
+  ensureFrame(w,h){
+    const n=w*h;if(this.frame&&this.frame.w===w&&this.frame.h===h)return this.frame;this.frameDestroy();const d=this.device,B=GPUBufferUsage,T=GPUTextureUsage;
+    this.frame={w,h,n,meta:buf(d,n*4,B.STORAGE|B.COPY_SRC|B.COPY_DST,'field-meta'),smooth:buf(d,n*4,B.STORAGE|B.COPY_SRC|B.COPY_DST,'field-smooth'),unresolved:buf(d,16,B.STORAGE|B.COPY_SRC|B.COPY_DST,'unresolved-count'),numericParams:buf(d,64,B.UNIFORM|B.COPY_DST,'numeric-params'),colorParams:buf(d,32,B.UNIFORM|B.COPY_DST,'color-params'),presentParams:buf(d,16,B.UNIFORM|B.COPY_DST,'present-params'),front:d.createTexture({size:[w,h],format:'rgba8unorm',usage:T.STORAGE_BINDING|T.TEXTURE_BINDING|T.COPY_SRC,label:'front-color'}),back:d.createTexture({size:[w,h],format:'rgba8unorm',usage:T.STORAGE_BINDING|T.TEXTURE_BINDING|T.COPY_SRC,label:'back-color'})};return this.frame;
+  }
+  ensureExportWorkspace(){
+    if(this.exportWs)return this.exportWs;const d=this.device,B=GPUBufferUsage,T=GPUTextureUsage,S=512,n=S*S,bpr=S*4,pixelBytes=bpr*S;
+    this.exportWs={size:S,meta:buf(d,n*4,B.STORAGE|B.COPY_DST,'export-meta'),smooth:buf(d,n*4,B.STORAGE|B.COPY_DST,'export-smooth'),unresolved:buf(d,16,B.STORAGE|B.COPY_SRC|B.COPY_DST,'export-unresolved'),pbufs:Array.from({length:4},(_,i)=>buf(d,64,B.UNIFORM|B.COPY_DST,'export-numeric-'+i)),cbuf:buf(d,32,B.UNIFORM|B.COPY_DST,'export-color'),samples:Array.from({length:4},(_,i)=>d.createTexture({label:'export-sample-'+i,size:[S,S],format:'rgba8unorm',usage:T.STORAGE_BINDING|T.TEXTURE_BINDING})),tex:d.createTexture({label:'export-resolve',size:[S,S],format:'rgba8unorm',usage:T.STORAGE_BINDING|T.COPY_SRC}),read:buf(d,pixelBytes+16,B.COPY_DST|B.MAP_READ,'export-readback')};return this.exportWs;
+  }
+  exportWorkspaceDestroy(){if(!this.exportWs)return;for(const k of ['meta','smooth','unresolved','cbuf','tex','read'])destroy(this.exportWs[k]);for(const b of this.exportWs.pbufs)destroy(b);for(const t of this.exportWs.samples)destroy(t);this.exportWs=null}
+  setDeepContext(ctx){if(this.deepCtx&&this.deepCtx.key===ctx.key)return;this.destroyDeepContext();const d=this.device,B=GPUBufferUsage,refsB=buf(d,ctx.refs.byteLength,B.STORAGE|B.COPY_DST,'reference-orbit');d.queue.writeBuffer(refsB,0,ctx.refs);this.deepCtx={...ctx,refsB}}
+  destroyDeepContext(){if(this.deepCtx)destroy(this.deepCtx.refsB);this.deepCtx=null}
+  directParams(w,h,fullW,fullH,tileX,tileY,iter,snap,sx=.5,sy=.5,strict=0){return writeU32F32(64,d=>{[w,h,fullW,fullH,tileX,tileY,iter,strict].forEach((v,i)=>d.setUint32(i*4,v,true));d.setFloat32(32,Math.fround(fixedNum(snap.re,snap.bits)),true);d.setFloat32(36,Math.fround(fixedNum(snap.im,snap.bits)),true);d.setFloat32(40,Math.fround(fixedNum(snap.span,snap.bits)),true);d.setFloat32(44,sx,true);d.setFloat32(48,sy,true)})}
+  deepParams(w,h,fullW,fullH,tileX,tileY,iter,snap,sx=.5,sy=.5,strict=0){const se=spanMantExp(snap);return writeU32F32(64,d=>{[w,h,fullW,fullH,tileX,tileY,iter,this.deepCtx.refLen,strict,0,0,0].forEach((v,i)=>d.setUint32(i*4,v,true));d.setFloat32(48,Math.fround(se.mant),true);d.setInt32(52,se.exp,true);d.setFloat32(56,sx,true);d.setFloat32(60,sy,true)})}
+  colorParamsData(w,h){return writeU32F32(32,d=>{d.setUint32(0,w,true);d.setUint32(4,h,true);d.setUint32(8,state.palette,true);d.setUint32(12,state.hq?1:0,true);d.setFloat32(16,state.cycle,true);d.setFloat32(20,state.shift,true)})}
+  async computeFrame(snap,iter,deep,deepContext,token,forceStrict=false){
+    await this.ready;const f=this.ensureFrame(canvas.width,canvas.height),d=this.device;if(deep)this.setDeepContext(deepContext);d.queue.writeBuffer(f.unresolved,0,new Uint32Array(4));
+    d.queue.writeBuffer(f.numericParams,0,deep?this.deepParams(f.w,f.h,f.w,f.h,0,0,iter,snap,.5,.5,forceStrict?1:0):this.directParams(f.w,f.h,f.w,f.h,0,0,iter,snap));
+    d.queue.writeBuffer(f.colorParams,0,this.colorParamsData(f.w,f.h));const encoder=d.createCommandEncoder({label:'mandelbrot-frame'});
+    if(deep){const bg=d.createBindGroup({layout:this.deep.getBindGroupLayout(0),entries:[{binding:0,resource:{buffer:f.numericParams}},{binding:1,resource:{buffer:this.deepCtx.refsB}},{binding:2,resource:{buffer:f.meta}},{binding:3,resource:{buffer:f.smooth}},{binding:4,resource:{buffer:f.unresolved}}]}),pass=encoder.beginComputePass();pass.setPipeline(this.deep);pass.setBindGroup(0,bg);pass.dispatchWorkgroups(Math.ceil(f.w/8),Math.ceil(f.h/8));pass.end();}
+    else{const bg=d.createBindGroup({layout:this.direct.getBindGroupLayout(0),entries:[{binding:0,resource:{buffer:f.numericParams}},{binding:1,resource:{buffer:f.meta}},{binding:2,resource:{buffer:f.smooth}}]}),pass=encoder.beginComputePass();pass.setPipeline(this.direct);pass.setBindGroup(0,bg);pass.dispatchWorkgroups(Math.ceil(f.w/8),Math.ceil(f.h/8));pass.end();}
+    const cbg=d.createBindGroup({layout:this.color.getBindGroupLayout(0),entries:[{binding:0,resource:{buffer:f.colorParams}},{binding:1,resource:{buffer:f.meta}},{binding:2,resource:{buffer:f.smooth}},{binding:3,resource:f.back.createView()}]}),cp=encoder.beginComputePass();cp.setPipeline(this.color);cp.setBindGroup(0,cbg);cp.dispatchWorkgroups(Math.ceil(f.w/8),Math.ceil(f.h/8));cp.end();
+    d.queue.submit([encoder.finish()]);await d.queue.onSubmittedWorkDone();if(token!==state.token)return false;[f.front,f.back]=[f.back,f.front];runtime.gpuFrames++;return true;
+  }
+  async recolor(token){await this.ready;if(!this.frame)return false;const f=this.frame,d=this.device;d.queue.writeBuffer(f.colorParams,0,this.colorParamsData(f.w,f.h));const e=d.createCommandEncoder(),bg=d.createBindGroup({layout:this.color.getBindGroupLayout(0),entries:[{binding:0,resource:{buffer:f.colorParams}},{binding:1,resource:{buffer:f.meta}},{binding:2,resource:{buffer:f.smooth}},{binding:3,resource:f.back.createView()}]}),p=e.beginComputePass();p.setPipeline(this.color);p.setBindGroup(0,bg);p.dispatchWorkgroups(Math.ceil(f.w/8),Math.ceil(f.h/8));p.end();d.queue.submit([e.finish()]);await d.queue.onSubmittedWorkDone();if(token!==state.token)return false;[f.front,f.back]=[f.back,f.front];runtime.gpuRecolors++;return true}
+  presentTransform(view=state.frameView){if(!this.frame||!view)return{scaleX:1,scaleY:1,offsetX:0,offsetY:0};const cur=snapshot(),b=Math.max(cur.bits,view.bits),cs=align(cur.span,cur.bits,b),ps=align(view.span,view.bits,b),dr=align(cur.re,cur.bits,b)-align(view.re,view.bits,b),di=align(cur.im,cur.bits,b)-align(view.im,view.bits,b),scale=fixedRatio(cs,ps);return{scaleX:scale,scaleY:scale,offsetX:fixedRatio(dr,ps),offsetY:-fixedRatio(di,ps)*this.frame.w/Math.max(1,this.frame.h)}}
+  presentFrame(transform=this.presentTransform()){if(!this.frame)return;const d=this.device,pb=this.frame.presentParams;d.queue.writeBuffer(pb,0,new Float32Array([transform.scaleX,transform.scaleY,transform.offsetX,transform.offsetY]));const bg=d.createBindGroup({layout:this.present.getBindGroupLayout(0),entries:[{binding:0,resource:this.sampler},{binding:1,resource:this.frame.front.createView()},{binding:2,resource:{buffer:pb}}]}),e=d.createCommandEncoder(),pass=e.beginRenderPass({colorAttachments:[{view:this.context.getCurrentTexture().createView(),clearValue:{r:.0196,g:.0314,b:.0745,a:1},loadOp:'clear',storeOp:'store'}]});pass.setPipeline(this.present);pass.setBindGroup(0,bg);pass.draw(3);pass.end();d.queue.submit([e.finish()])}
+  async readMeta(indices){if(!this.frame||!indices.length)return new Uint32Array();const d=this.device,B=GPUBufferUsage,r=buf(d,indices.length*4,B.COPY_DST|B.MAP_READ),e=d.createCommandEncoder();for(let i=0;i<indices.length;i++)e.copyBufferToBuffer(this.frame.meta,indices[i]*4,r,i*4,4);d.queue.submit([e.finish()]);await r.mapAsync(GPUMapMode.READ);const out=new Uint32Array(r.getMappedRange().slice(0));r.unmap();destroy(r);return out}
+  async readUnresolved(){if(!this.frame)return 0;const d=this.device,B=GPUBufferUsage,r=buf(d,16,B.COPY_DST|B.MAP_READ),e=d.createCommandEncoder();e.copyBufferToBuffer(this.frame.unresolved,0,r,0,16);d.queue.submit([e.finish()]);await r.mapAsync(GPUMapMode.READ);const value=new Uint32Array(r.getMappedRange().slice(0))[0];r.unmap();destroy(r);return value}
+  async renderTileMeta({snap,iter,deep,deepContext,fullW,fullH,tileX=0,tileY=0,w,h,sampleX=.5,sampleY=.5,forceStrict=false}){
+    await this.ready;if(deep)this.setDeepContext(deepContext);const d=this.device,B=GPUBufferUsage,n=w*h,meta=buf(d,n*4,B.STORAGE|B.COPY_SRC|B.COPY_DST),smooth=buf(d,n*4,B.STORAGE|B.COPY_DST),unresolved=buf(d,16,B.STORAGE|B.COPY_DST),pbuf=buf(d,64,B.UNIFORM|B.COPY_DST),encoder=d.createCommandEncoder({label:'numeric-probe'});d.queue.writeBuffer(unresolved,0,new Uint32Array(4));
+    if(deep){d.queue.writeBuffer(pbuf,0,this.deepParams(w,h,fullW,fullH,tileX,tileY,iter,snap,sampleX,sampleY,forceStrict?1:0));const bg=d.createBindGroup({layout:this.deep.getBindGroupLayout(0),entries:[{binding:0,resource:{buffer:pbuf}},{binding:1,resource:{buffer:this.deepCtx.refsB}},{binding:2,resource:{buffer:meta}},{binding:3,resource:{buffer:smooth}},{binding:4,resource:{buffer:unresolved}}]}),pass=encoder.beginComputePass();pass.setPipeline(this.deep);pass.setBindGroup(0,bg);pass.dispatchWorkgroups(Math.ceil(w/8),Math.ceil(h/8));pass.end();}
+    else{d.queue.writeBuffer(pbuf,0,this.directParams(w,h,fullW,fullH,tileX,tileY,iter,snap,sampleX,sampleY));const bg=d.createBindGroup({layout:this.direct.getBindGroupLayout(0),entries:[{binding:0,resource:{buffer:pbuf}},{binding:1,resource:{buffer:meta}},{binding:2,resource:{buffer:smooth}}]}),pass=encoder.beginComputePass();pass.setPipeline(this.direct);pass.setBindGroup(0,bg);pass.dispatchWorkgroups(Math.ceil(w/8),Math.ceil(h/8));pass.end();}
+    const read=buf(d,n*4,B.COPY_DST|B.MAP_READ);encoder.copyBufferToBuffer(meta,0,read,0,n*4);d.queue.submit([encoder.finish()]);await read.mapAsync(GPUMapMode.READ);const out=new Uint32Array(read.getMappedRange().slice(0));read.unmap();[meta,smooth,unresolved,pbuf,read].forEach(destroy);return out;
+  }
+  async renderTileRGBA({snap,iter,deep,deepContext,fullW,fullH,tileX,tileY,w,h,sampleX=.5,sampleY=.5,edgeAA=false,forceStrict=false}){
+    await this.ready;if(w>512||h>512)throw new Error('export tile exceeds reusable workspace');if(deep)this.setDeepContext(deepContext);const d=this.device,ws=this.ensureExportWorkspace(),meta=ws.meta,smooth=ws.smooth,unresolved=ws.unresolved,pbuf=ws.pbufs[0],tex=ws.tex,encoder=d.createCommandEncoder();d.queue.writeBuffer(unresolved,0,new Uint32Array(4));
+    if(deep){d.queue.writeBuffer(pbuf,0,this.deepParams(w,h,fullW,fullH,tileX,tileY,iter,snap,sampleX,sampleY,forceStrict?1:0));const bg=d.createBindGroup({layout:this.deep.getBindGroupLayout(0),entries:[{binding:0,resource:{buffer:pbuf}},{binding:1,resource:{buffer:this.deepCtx.refsB}},{binding:2,resource:{buffer:meta}},{binding:3,resource:{buffer:smooth}},{binding:4,resource:{buffer:unresolved}}]}),p=encoder.beginComputePass();p.setPipeline(this.deep);p.setBindGroup(0,bg);p.dispatchWorkgroups(Math.ceil(w/8),Math.ceil(h/8));p.end();}
+    else{d.queue.writeBuffer(pbuf,0,this.directParams(w,h,fullW,fullH,tileX,tileY,iter,snap,sampleX,sampleY));const bg=d.createBindGroup({layout:this.direct.getBindGroupLayout(0),entries:[{binding:0,resource:{buffer:pbuf}},{binding:1,resource:{buffer:meta}},{binding:2,resource:{buffer:smooth}}]}),p=encoder.beginComputePass();p.setPipeline(this.direct);p.setBindGroup(0,bg);p.dispatchWorkgroups(Math.ceil(w/8),Math.ceil(h/8));p.end();}
+    const ca=this.colorParamsData(w,h),cd=new DataView(ca);cd.setUint32(12,edgeAA?1:0,true);d.queue.writeBuffer(ws.cbuf,0,ca);const cbg=d.createBindGroup({layout:this.color.getBindGroupLayout(0),entries:[{binding:0,resource:{buffer:ws.cbuf}},{binding:1,resource:{buffer:meta}},{binding:2,resource:{buffer:smooth}},{binding:3,resource:tex.createView()}]}),cp=encoder.beginComputePass();cp.setPipeline(this.color);cp.setBindGroup(0,cbg);cp.dispatchWorkgroups(Math.ceil(w/8),Math.ceil(h/8));cp.end();
+    const bpr=Math.ceil(w*4/256)*256,pixelBytes=bpr*h;encoder.copyTextureToBuffer({texture:tex},{buffer:ws.read,bytesPerRow:bpr,rowsPerImage:h},{width:w,height:h});encoder.copyBufferToBuffer(unresolved,0,ws.read,pixelBytes,16);d.queue.submit([encoder.finish()]);await ws.read.mapAsync(GPUMapMode.READ,0,pixelBytes+16);const raw=new Uint8Array(ws.read.getMappedRange(0,pixelBytes+16)),out=new Uint8ClampedArray(w*h*4);for(let y=0;y<h;y++)out.set(raw.subarray(y*bpr,y*bpr+w*4),y*w*4);const unresolvedCount=new DataView(raw.buffer,raw.byteOffset+pixelBytes,16).getUint32(0,true);ws.read.unmap();return{rgba:out,unresolved:unresolvedCount};
+  }
+  async renderTileRGBA2x({snap,iter,deep,deepContext,fullW,fullH,tileX,tileY,w,h,forceStrict=false}){
+    await this.ready;if(w>512||h>512)throw new Error('export tile exceeds reusable workspace');if(deep)this.setDeepContext(deepContext);const d=this.device,ws=this.ensureExportWorkspace(),meta=ws.meta,smooth=ws.smooth,unresolved=ws.unresolved,encoder=d.createCommandEncoder({label:'export-aa2x'}),offsets=[[.25,.25],[.75,.25],[.25,.75],[.75,.75]],ca=this.colorParamsData(w,h);new DataView(ca).setUint32(12,0,true);d.queue.writeBuffer(ws.cbuf,0,ca);d.queue.writeBuffer(unresolved,0,new Uint32Array(4));
+    for(let si=0;si<4;si++){const [sampleX,sampleY]=offsets[si],pbuf=ws.pbufs[si];if(deep){d.queue.writeBuffer(pbuf,0,this.deepParams(w,h,fullW,fullH,tileX,tileY,iter,snap,sampleX,sampleY,forceStrict?1:0));const bg=d.createBindGroup({layout:this.deep.getBindGroupLayout(0),entries:[{binding:0,resource:{buffer:pbuf}},{binding:1,resource:{buffer:this.deepCtx.refsB}},{binding:2,resource:{buffer:meta}},{binding:3,resource:{buffer:smooth}},{binding:4,resource:{buffer:unresolved}}]}),pass=encoder.beginComputePass();pass.setPipeline(this.deep);pass.setBindGroup(0,bg);pass.dispatchWorkgroups(Math.ceil(w/8),Math.ceil(h/8));pass.end();}else{d.queue.writeBuffer(pbuf,0,this.directParams(w,h,fullW,fullH,tileX,tileY,iter,snap,sampleX,sampleY));const bg=d.createBindGroup({layout:this.direct.getBindGroupLayout(0),entries:[{binding:0,resource:{buffer:pbuf}},{binding:1,resource:{buffer:meta}},{binding:2,resource:{buffer:smooth}}]}),pass=encoder.beginComputePass();pass.setPipeline(this.direct);pass.setBindGroup(0,bg);pass.dispatchWorkgroups(Math.ceil(w/8),Math.ceil(h/8));pass.end();}const cbg=d.createBindGroup({layout:this.color.getBindGroupLayout(0),entries:[{binding:0,resource:{buffer:ws.cbuf}},{binding:1,resource:{buffer:meta}},{binding:2,resource:{buffer:smooth}},{binding:3,resource:ws.samples[si].createView()}]}),cp=encoder.beginComputePass();cp.setPipeline(this.color);cp.setBindGroup(0,cbg);cp.dispatchWorkgroups(Math.ceil(w/8),Math.ceil(h/8));cp.end();}
+    const abg=d.createBindGroup({layout:this.aaResolve.getBindGroupLayout(0),entries:[{binding:0,resource:ws.samples[0].createView()},{binding:1,resource:ws.samples[1].createView()},{binding:2,resource:ws.samples[2].createView()},{binding:3,resource:ws.samples[3].createView()},{binding:4,resource:ws.tex.createView()}]}),ap=encoder.beginComputePass();ap.setPipeline(this.aaResolve);ap.setBindGroup(0,abg);ap.dispatchWorkgroups(Math.ceil(w/8),Math.ceil(h/8));ap.end();
+    const bpr=Math.ceil(w*4/256)*256,pixelBytes=bpr*h;encoder.copyTextureToBuffer({texture:ws.tex},{buffer:ws.read,bytesPerRow:bpr,rowsPerImage:h},{width:w,height:h});encoder.copyBufferToBuffer(unresolved,0,ws.read,pixelBytes,16);d.queue.submit([encoder.finish()]);await ws.read.mapAsync(GPUMapMode.READ,0,pixelBytes+16);const raw=new Uint8Array(ws.read.getMappedRange(0,pixelBytes+16)),out=new Uint8ClampedArray(w*h*4);for(let y=0;y<h;y++)out.set(raw.subarray(y*bpr,y*bpr+w*4),y*w*4);const unresolvedCount=new DataView(raw.buffer,raw.byteOffset+pixelBytes,16).getUint32(0,true);ws.read.unmap();return{rgba:out,unresolved:unresolvedCount};
+  }
+  destroy(){this.frameDestroy();this.exportWorkspaceDestroy();this.destroyDeepContext()}
+}
+
+// ── GPU startup / rendering orchestration ────────────────────────────────
+async function initRenderer(){if(renderer)return renderer;if(rendererInitPromise)return rendererInitPromise;if(state.gpuInitFailed)return null;if(!navigator.gpu){state.gpuInitFailed=false;state.gpuUnavailable=true;state.gpuError='WebGPU非対応';ensureFallback();return null}rendererInitPromise=(async()=>{try{let adapter=await navigator.gpu.requestAdapter({powerPreference:'high-performance'});if(!adapter)adapter=await navigator.gpu.requestAdapter();if(!adapter){state.gpuInitFailed=false;state.gpuUnavailable=true;state.gpuError='WebGPU adapterがありません';ensureFallback();return null}const device=await adapter.requestDevice();const r=new WebGpuRenderer(adapter,device);await r.ready;renderer=r;state.gpuInitFailed=false;state.gpuUnavailable=false;state.gpuError='';resize();markDirty(false);return r}catch(e){state.gpuInitFailed=true;state.gpuError='WebGPU初期化失敗: '+String(e&&e.message||e);updateStats();return null}finally{rendererInitPromise=null}})();return rendererInitPromise}
+function ensureFallback(){if(fallbackCtx)return fallbackCtx;if(webgpuCanvasClaimed)return null;try{fallbackCtx=canvas.getContext('2d',{alpha:false})}catch{}return fallbackCtx}
+function cancelRender(){state.token++;state.rendering=false;state.recolorPending=false;refs.cancelPending('render cancelled')}
+function markDirty(cancel=true){if(cancel)cancelRender();state.dirty=true;state.lastInteraction=performance.now();state.drawState=state.frameView?'REPROJECTED':'PREVIEW';schedule()}
+function schedule(){if(!raf)raf=requestAnimationFrame(loop)}
+async function renderFrame(){const token=++state.token,snap=snapshot(),iter=maxIter(),deep=deepNeeded(snap,canvas.width),t0=performance.now();state.rendering=true;state.dirty=false;state.drawState='COVERING';runtime.renderStarts++;updateStats();try{const r=renderer||await initRenderer();if(token!==state.token)return;if(!r){if(state.gpuInitFailed){state.rendering=false;state.drawState='ERROR';state.lastEngine='WebGPU shader/pipeline error';updateStats();return}renderFallback(token,snap,iter);return}let ctx=null;if(deep){state.lastEngine='WebGPU · reference準備';updateStats();ctx=await refs.request(snap,iter);if(token!==state.token)return;if(ctx.checkpointMismatch)throw new Error('reference guard checkpoint mismatch');state.lastEngine='WebGPU · guarded rescaled perturbation'}else state.lastEngine='WebGPU · f32 direct';const ok=await r.computeFrame(snap,iter,deep,ctx,token,state.processMode==='validate');if(!ok)return;state.frameView=snap;state.fieldView={...snap,iter,w:canvas.width,h:canvas.height,deep};state.drawState=state.hq?'REFINED':'COVERED';state.lastRender=performance.now()-t0;state.rendering=false;state.unresolved=0;const pendingColor=state.recolorPending;if(pendingColor){state.recolorPending=false;recolor()}else r.presentFrame({scaleX:1,scaleY:1,offsetX:0,offsetY:0});updateStats();if(deep)r.readUnresolved().then(q=>{if(token===state.token){state.unresolved=q||0;updateStats()}}).catch(()=>{})}catch(e){if(token!==state.token)return;state.rendering=false;state.gpuError=String(e&&e.message||e);state.lastEngine='WebGPU error';updateStats();console.error(e)}}
+function renderFallback(token,snap,iter){const ctx=ensureFallback();if(!ctx){state.rendering=false;return}const w=canvas.width,h=canvas.height;if(deepNeeded(snap,w)){state.rendering=false;state.gpuError='このズーム深度はWebGPUが必要です';state.lastEngine='Fallback · deep unsupported';updateStats();return}const img=ctx.createImageData(w,h),out=img.data,cre=fixedNum(snap.re,snap.bits),cim=fixedNum(snap.im,snap.bits),sp=fixedNum(snap.span,snap.bits),scale=sp/w;let y=0;function slice(){if(token!==state.token)return;const end=performance.now()+8;while(y<h&&performance.now()<end){for(let x=0;x<w;x++){const cr=cre+(x+.5-w*.5)*scale,ci=cim+(h*.5-y-.5)*scale;let zr=0,zi=0,n=0,mag=0;while(n<iter&&mag<=4){const zr2=zr*zr,zi2=zi*zi;zi=2*zr*zi+ci;zr=zr2-zi2+cr;mag=zr*zr+zi*zi;n++}const o=(y*w+x)*4;if(n>=iter){out[o]=out[o+1]=out[o+2]=0}else{const t=(n+1-Math.log2(.5*Math.log2(Math.max(4.0001,mag))))*.008+state.shift;out[o]=255*(.3+.7*(.5+.5*Math.cos(6.28318*t)));out[o+1]=255*(.25+.75*(.5+.5*Math.cos(6.28318*(t+.33))));out[o+2]=255*(.2+.8*(.5+.5*Math.cos(6.28318*(t+.67))))}out[o+3]=255}y++}if(y<h)requestAnimationFrame(slice);else{ctx.putImageData(img,0,0);state.frameView=snap;state.rendering=false;state.lastRender=0;state.lastEngine='JavaScript f64 fallback（深部非対応）';state.drawState='COVERED';updateStats()}}requestAnimationFrame(slice)}
+async function recolor(){state.recolorPending=true;if(!renderer||!state.fieldView||state.rendering||state.recoloring)return false;state.recoloring=true;let painted=false;try{while(state.recolorPending&&!state.rendering&&renderer&&state.fieldView){state.recolorPending=false;const token=state.token,ok=await renderer.recolor(token);if(!ok||token!==state.token)continue;renderer.presentFrame({scaleX:1,scaleY:1,offsetX:0,offsetY:0});painted=true;updateStats()}return painted}catch(e){console.error(e);return false}finally{state.recoloring=false;if(state.recolorPending&&!state.rendering)queueMicrotask(recolor)}}
+function loop(){raf=0;if(state.pointerActive||state.wheelActive){if(renderer&&state.frameView)renderer.presentFrame(renderer.presentTransform());updateStats();return}if(state.dirty&&!state.rendering)renderFrame();else if(renderer&&state.frameView)renderer.presentFrame(renderer.presentTransform())}
+
+// ── interaction / view history ──────────────────────────────────────────
+function viewRect(){return canvas.getBoundingClientRect()}
+function updateFocus(x,y){const r=viewRect();state.focusX=Math.max(0,Math.min(1,(x-r.left)/Math.max(1,r.width)));state.focusY=Math.max(0,Math.min(1,(y-r.top)/Math.max(1,r.height)))}
+function zoomAt(x,y,factor){const r=viewRect(),fx=(x-r.left)/Math.max(1,r.width)-.5,fy=(y-r.top)/Math.max(1,r.height)-.5;factor=Math.max(.01,Math.min(100,factor));const old=state.span,neu=mulRatio(old,factor),dx=BigInt(Math.round(fx*1e9)),dy=BigInt(Math.round(fy*1e9));state.re+=(old-neu)*dx/1000000000n;const oldY=old*BigInt(canvas.height)/BigInt(Math.max(1,canvas.width)),newY=neu*BigInt(canvas.height)/BigInt(Math.max(1,canvas.width));state.im-=(oldY-newY)*dy/1000000000n;state.span=neu;ensurePrecision();state.dirty=true;schedule()}
+function pan(dx,dy){const w=Math.max(1,canvas.clientWidth),h=Math.max(1,canvas.clientHeight);state.re-=state.span*BigInt(Math.round(dx*1e6))/BigInt(Math.round(w*1e6));const ys=state.span*BigInt(canvas.height)/BigInt(Math.max(1,canvas.width));state.im+=ys*BigInt(Math.round(dy*1e6))/BigInt(Math.round(h*1e6));ensurePrecision();state.dirty=true;schedule()}
+function reset(){state.bits=INITIAL_BITS;state.re=-fromFrac(1n,2n);state.im=0n;state.span=fromFrac(34n,10n);ensurePrecision();markDirty();saveHash(false)}
+const pts=new Map();let lx=0,ly=0,pinch=0;
+canvas.addEventListener('wheel',e=>{e.preventDefault();updateFocus(e.clientX,e.clientY);if(!state.wheelActive){cancelRender();state.wheelActive=true}zoomAt(e.clientX,e.clientY,Math.exp(e.deltaY*.00125));clearTimeout(settleTimer);settleTimer=setTimeout(()=>{state.wheelActive=false;recordView();saveHash(false);markDirty()},110)},{passive:false});
+canvas.addEventListener('pointerdown',e=>{updateFocus(e.clientX,e.clientY);try{canvas.setPointerCapture(e.pointerId)}catch{};if(!pts.size){cancelRender();state.pointerActive=true}pts.set(e.pointerId,[e.clientX,e.clientY]);if(pts.size===1){lx=e.clientX;ly=e.clientY}else{const a=[...pts.values()];pinch=Math.hypot(a[0][0]-a[1][0],a[0][1]-a[1][1])}});
+canvas.addEventListener('pointermove',e=>{if(!pts.has(e.pointerId))return;updateFocus(e.clientX,e.clientY);pts.set(e.pointerId,[e.clientX,e.clientY]);if(pts.size===1){const dx=e.clientX-lx,dy=e.clientY-ly;pan(dx,dy);lx=e.clientX;ly=e.clientY}else if(pts.size===2){const a=[...pts.values()],d=Math.hypot(a[0][0]-a[1][0],a[0][1]-a[1][1]);if(pinch>0&&d>0)zoomAt((a[0][0]+a[1][0])/2,(a[0][1]+a[1][1])/2,pinch/d);pinch=d}});
+function endPointer(e){pts.delete(e.pointerId);pinch=0;if(pts.size)return;clearTimeout(settleTimer);settleTimer=setTimeout(()=>{state.pointerActive=false;recordView();saveHash(false);markDirty()},90)}canvas.addEventListener('pointerup',endPointer);canvas.addEventListener('pointercancel',endPointer);
+
+// ── URL / controls ───────────────────────────────────────────────────────
+function saveHash(push){const p=new URLSearchParams();p.set('v',String(VERSION));p.set('b',String(state.bits));p.set('re',state.re.toString());p.set('im',state.im.toString());p.set('sp',state.span.toString());p.set('pal',String(state.palette));p.set('cy',String(state.cycle));p.set('sh',String(state.shift));p.set('it',String(state.baseIter));p.set('ad',state.adaptive?'1':'0');const h='#'+p.toString();lastWrittenHash=h;try{push?history.pushState(null,'',h):history.replaceState(null,'',h)}catch{location.hash=h}}
 function loadHash(){const p=new URLSearchParams(location.hash.slice(1));if(!p.has('b'))return false;try{const b=Number(p.get('b')),re=BigInt(p.get('re')),im=BigInt(p.get('im')),sp=BigInt(p.get('sp'));if(!Number.isInteger(b)||b<64||sp<=0n)return false;state.bits=b;state.re=re;state.im=im;state.span=sp;if(p.has('pal'))state.palette=Math.max(0,Math.min(2,Number(p.get('pal'))|0));if(p.has('cy'))state.cycle=Math.max(.001,Math.min(.05,Number(p.get('cy'))||.008));if(p.has('sh'))state.shift=Math.max(0,Math.min(1,Number(p.get('sh'))||0));if(p.has('it'))state.baseIter=Math.max(100,Math.min(2500,Number(p.get('it'))||350));if(p.has('ad'))state.adaptive=p.get('ad')!=='0';ensurePrecision();return true}catch{return false}}
-function syncControls(){$('#processMode').value=state.processMode;$('#palette').value=String(state.palette);$('#cycle').value=String(state.cycle);$('#cycleO').textContent=state.cycle.toFixed(4);$('#shift').value=String(state.shift);$('#shiftO').textContent=state.shift.toFixed(2);$('#iters').value=String(state.baseIter);$('#itersO').textContent=String(Math.round(state.baseIter));$('#adaptive').checked=state.adaptive;$('#hq').checked=state.hq;syncCoordinateInputs();syncHistoryButtons()}
-function applyHashNavigation(){const h=location.hash;if(h===lastWrittenHash){lastWrittenHash='';return}if(h===navigationHash)return;navigationHash=h;setTimeout(()=>{navigationHash=''},0);if(loadHash()){clearDetailCache();clearPanReuse();recordView();syncControls();setDirty()}}
+function syncCoordinateInputs(){$('#coordReInput').value=fmtFixedExact(state.re);$('#coordImInput').value=fmtFixedExact(state.im);$('#coordSpanInput').value=fmtFixedExact(state.span)}
+function syncHistoryButtons(){$('#undoView').disabled=viewHistoryIndex<=0;$('#redoView').disabled=viewHistoryIndex<0||viewHistoryIndex>=viewHistory.length-1}
+function syncControls(){$('#processMode').value=state.processMode;$('#palette').value=String(state.palette);$('#cycle').value=String(state.cycle);$('#cycleO').textContent=state.cycle.toFixed(4);$('#shift').value=String(state.shift);$('#shiftO').textContent=state.shift.toFixed(2);$('#iters').value=String(state.baseIter);$('#itersO').textContent=String(state.baseIter);$('#adaptive').checked=state.adaptive;$('#hq').checked=state.hq;syncCoordinateInputs();syncHistoryButtons()}
+function toast(s){const e=$('#toast');e.textContent=s;e.classList.add('show');setTimeout(()=>e.classList.remove('show'),1500)}
+function applyUi(){document.body.classList.toggle('ui-hidden',state.uiHidden);$('#uiToggle').textContent=state.uiHidden?'UI＋':'UI−';$('#uiToggle').setAttribute('aria-expanded',state.uiHidden?'false':'true')}
+$('#uiToggle').onclick=()=>{state.uiHidden=!state.uiHidden;try{localStorage.setItem('mandelbrot.uiHidden',state.uiHidden?'1':'0')}catch{}applyUi()};
+$('#zin').onclick=()=>{const r=viewRect();zoomAt(r.left+r.width/2,r.top+r.height/2,.5);recordView();saveHash(false);markDirty()};$('#zout').onclick=()=>{const r=viewRect();zoomAt(r.left+r.width/2,r.top+r.height/2,2);recordView();saveHash(false);markDirty()};$('#reset').onclick=()=>{reset();recordView();syncControls()};
 $('#share').onclick=async()=>{saveHash(true);try{await navigator.clipboard.writeText(location.href);toast('共有URLをコピーしました')}catch{toast('URLを更新しました')}};
-$('#coordApply').onclick=()=>{try{const values=[$('#coordReInput').value,$('#coordImInput').value,$('#coordSpanInput').value],required=Math.max(...values.map(decimalRequiredBits));if(required>state.bits)promoteState(Math.ceil((required-state.bits)/64)*64);const re=fromDec(values[0]),im=fromDec(values[1]),span=fromDec(values[2]);if(span<=0n)throw new Error('表示幅は正数にしてください');state.re=re;state.im=im;state.span=span;ensurePrecision();recordView();saveHash(false);setDirty()}catch(e){toast('座標を適用できません: '+String(e&&e.message||e))}};
-$('#coordCopy').onclick=async()=>{const value=JSON.stringify({rendererVersion:23,bits:state.bits,re:state.re.toString(),im:state.im.toString(),span:state.span.toString(),decimal:{re:fmtFixedExact(state.re),im:fmtFixedExact(state.im),span:fmtFixedExact(state.span)}});try{await navigator.clipboard.writeText(value);toast('正確な座標をコピーしました')}catch{toast('コピーできませんでした')}};
+$('#coordApply').onclick=()=>{try{const values=[$('#coordReInput').value,$('#coordImInput').value,$('#coordSpanInput').value],required=Math.max(...values.map(decimalRequiredBits));if(required>state.bits)promoteState(Math.ceil((required-state.bits)/64)*64);const re=fromDec(values[0]),im=fromDec(values[1]),span=fromDec(values[2]);if(span<=0n)throw new Error('表示幅は正数にしてください');state.re=re;state.im=im;state.span=span;ensurePrecision();recordView();saveHash(false);markDirty()}catch(e){toast('座標を適用できません: '+String(e&&e.message||e))}};
+$('#coordCopy').onclick=async()=>{const value=JSON.stringify({rendererVersion:VERSION,bits:state.bits,re:state.re.toString(),im:state.im.toString(),span:state.span.toString(),decimal:{re:fmtFixedExact(state.re),im:fmtFixedExact(state.im),span:fmtFixedExact(state.span)}});try{await navigator.clipboard.writeText(value);toast('正確な座標をコピーしました')}catch{toast('コピーできませんでした')}};
 $('#undoView').onclick=()=>{if(viewHistoryIndex>0){viewHistoryIndex--;restoreView(viewHistory[viewHistoryIndex]);syncHistoryButtons()}};$('#redoView').onclick=()=>{if(viewHistoryIndex<viewHistory.length-1){viewHistoryIndex++;restoreView(viewHistory[viewHistoryIndex]);syncHistoryButtons()}};
-function bind(id,key,out,fmt,flush=false){const el=$(id),o=$(out),apply=()=>{state[key]=Number(el.value);o.textContent=fmt(Number(el.value));if(flush)clearDetailCache();setDirty()};el.addEventListener('input',apply);apply()}
-function bindColor(id,key,out,fmt){const el=$(id),o=$(out),apply=()=>{state[key]=Number(el.value);o.textContent=fmt(Number(el.value));if(!recolorCurrentField())setDirty()};el.addEventListener('input',apply);apply()}
-bind('#iters','baseIter','#itersO',x=>String(Math.round(x)),true);bindColor('#cycle','cycle','#cycleO',x=>x.toFixed(4));bindColor('#shift','shift','#shiftO',x=>x.toFixed(2));
-$('#palette').onchange=e=>{state.palette=Math.max(0,Math.min(2,Number(e.target.value)|0));if(!recolorCurrentField())setDirty()};
-$('#processMode').onchange=e=>{state.processMode=/^(power|standard|fine|validate)$/.test(e.target.value)?e.target.value:'standard';state.hq=state.processMode==='fine'||state.processMode==='validate';state.adaptivePixelBudget=0;$('#hq').checked=state.hq;try{localStorage.setItem('mandelbrot.processMode',state.processMode)}catch{}resize();setDirty()};
-$('#adaptive').onchange=e=>{state.adaptive=e.target.checked;clearDetailCache();setDirty()};$('#hq').onchange=e=>{state.hq=e.target.checked;if(!state.hq)cancelDetailRefinement(true);setDirty()};
-addEventListener('resize',()=>{resize();setDirty()});addEventListener('keydown',e=>{if(/^(INPUT|SELECT|TEXTAREA|BUTTON)$/.test(e.target.tagName))return;let handled=true;if(e.key==='h'||e.key==='H')$('#uiToggle').click();else if(e.key==='r'||e.key==='R')$('#reset').click();else if(e.key==='+'||e.key==='='||e.key==='Enter'&&!e.shiftKey)$('#zin').click();else if(e.key==='-'||e.key==='Enter'&&e.shiftKey)$('#zout').click();else if(e.key==='ArrowLeft'){capturePanSource();pan(innerWidth*.08,0)}else if(e.key==='ArrowRight'){capturePanSource();pan(-innerWidth*.08,0)}else if(e.key==='ArrowUp'){capturePanSource();pan(0,innerHeight*.08)}else if(e.key==='ArrowDown'){capturePanSource();pan(0,-innerHeight*.08)}else handled=false;if(handled){e.preventDefault();recordView();saveHash(false)}});addEventListener('popstate',applyHashNavigation);addEventListener('hashchange',applyHashNavigation);
-function stopSchedulers(){if(schedulerRAF){cancelAnimationFrame(schedulerRAF);schedulerRAF=0}if(schedulerTimer){clearTimeout(schedulerTimer);schedulerTimer=0;schedulerDue=0}if(wheelSettleTimer){clearTimeout(wheelSettleTimer);wheelSettleTimer=0}if(pointerSettleTimer){clearTimeout(pointerSettleTimer);pointerSettleTimer=0}cancelUnknownContinuation()}
-addEventListener('visibilitychange',()=>{if(document.hidden){exportJob.cancelled=true;stopSchedulers();state.wheelActive=false;cancelRender();cancelDetailRefinement(true)}else{state.lastInteraction=performance.now();state.dirty=true;invalidateView()}});
-globalThis.__MANDEL_DIAG__={snapshot:()=>{const deep=deepEngineNeeded(),ledger=memoryLedger(),coveredProfile=RENDER_PROFILE[RENDER_PASS.COVERED];return{rendererVersion:23,pixelContract:'centered',processMode:state.processMode,automaticTarget:modeTarget(),drawState:state.drawState,coverage:state.coverage,unresolved:state.unresolved,zoom:zoomExp(),deep,legacyDeepThreshold:LEGACY_DEEP_ZOOM_THRESHOLD,bits:state.bits,palette:state.palette,rendering:state.rendering,validating:validationJob.active,exporting:exportJob.active,lastRender:state.lastRender,lastPass:state.lastPass,transformReuse:!!state.panReuse,detailCache:DETAIL_TILE_CACHE.size,detailCacheBytes,detailCacheBudget:detailCacheBudget(),detailActive:state.detailActive,frame:frameCanvas.width+'x'+frameCanvas.height,frameCoverage:frameCanvas.width/Math.max(1,canvas.width),hqTarget:targetSize(coveredProfile,deep).join('x'),scheduler:{raf:!!schedulerRAF,timer:!!schedulerTimer,needsPaint,needsStats,wheelActive:state.wheelActive,pointerSettle:!!pointerSettleTimer,unknownTimer:!!unknownContinuationTimer,backgroundJobs:runtimeMetrics.pendingBackgroundJobs},screen:{effectiveDpr:state.effectiveDpr,deviceDpr:window.devicePixelRatio||1,pixelBudget:state.screenPixelBudget,pixels:canvas.width*canvas.height},memory:ledger,shallowAssets:{wasmReady:!!wasm,worker:!!shallowWorker,workerBusy:shallowWorkerBusy},deepAssets:{wasmReady:!!deepWasm,workers:deepPool.workers.length},runtimeMetrics:{...runtimeMetrics},telemetry:{...deepTelemetry},renderPerf:{...renderPerf},wisdom:{workerCount:deepWisdom.workerCount,rowMsEMA:deepWisdom.rowMsEMA,stripRows:deepWisdom.stripRows,realBench:deepWisdom.realBench},reference:{id:referenceCache.id,bits:referenceCache.bits,n:referenceCache.n,escape:referenceCache.escape,buildMs:refControl.lastBuildMs,buildEMA:refControl.buildEMA,baseMPP:refControl.baseMPP,lastMPP:refControl.lastMPP,conditionLog2:referenceCache.conditionLog2,checkpointBits:referenceCache.checkpointBits,checkpointCount:referenceCache.checkpointCount,checkpointMismatch:referenceCache.checkpointMismatch}}},memoryLedger:()=>memoryLedger()};
-addEventListener('pagehide',()=>{stopSchedulers();destroyShallowWorker();destroyDeepPool()},{once:true});
-try{state.uiHidden=localStorage.getItem('mandelbrot.uiHidden')==='1';const savedMode=localStorage.getItem('mandelbrot.processMode');if(/^(power|standard|fine|validate)$/.test(savedMode)){state.processMode=savedMode;state.hq=savedMode==='fine'||savedMode==='validate'}}catch{}restoreDeepWisdom();applyUiVisibility();resize();if(!loadHash())reset();else setDirty();recordView();syncControls();ctx.fillStyle='#050813';ctx.fillRect(0,0,canvas.width,canvas.height);render(RENDER_PASS.PREVIEW);requestScheduler();
+$('#palette').onchange=e=>{state.palette=Math.max(0,Math.min(2,Number(e.target.value)|0));recolor()};$('#cycle').oninput=e=>{state.cycle=Number(e.target.value);$('#cycleO').textContent=state.cycle.toFixed(4);recolor()};$('#shift').oninput=e=>{state.shift=Number(e.target.value);$('#shiftO').textContent=state.shift.toFixed(2);recolor()};
+$('#iters').oninput=e=>{state.baseIter=Number(e.target.value);$('#itersO').textContent=String(state.baseIter);markDirty()};$('#adaptive').onchange=e=>{state.adaptive=e.target.checked;markDirty()};$('#hq').onchange=e=>{state.hq=e.target.checked;recolor()};
+$('#processMode').onchange=e=>{state.processMode=/^(power|standard|fine|validate)$/.test(e.target.value)?e.target.value:'standard';state.hq=state.processMode==='fine'||state.processMode==='validate';$('#hq').checked=state.hq;resize();markDirty();try{localStorage.setItem('mandelbrot.processMode',state.processMode)}catch{}};
+addEventListener('resize',()=>{resize();markDirty()});addEventListener('keydown',e=>{if(/^(INPUT|SELECT|TEXTAREA|BUTTON)$/.test(e.target.tagName))return;let ok=true;if(e.key==='h'||e.key==='H')$('#uiToggle').click();else if(e.key==='r'||e.key==='R')$('#reset').click();else if(e.key==='+'||e.key==='='||e.key==='Enter'&&!e.shiftKey)$('#zin').click();else if(e.key==='-'||e.key==='Enter'&&e.shiftKey)$('#zout').click();else if(e.key==='ArrowLeft')pan(innerWidth*.08,0);else if(e.key==='ArrowRight')pan(-innerWidth*.08,0);else if(e.key==='ArrowUp')pan(0,innerHeight*.08);else if(e.key==='ArrowDown')pan(0,-innerHeight*.08);else ok=false;if(ok){e.preventDefault();recordView();saveHash(false);markDirty()}});
+addEventListener('hashchange',()=>{if(location.hash===lastWrittenHash){lastWrittenHash='';return}if(location.hash===navigationHash)return;navigationHash=location.hash;setTimeout(()=>navigationHash='',0);if(loadHash()){syncControls();recordView();markDirty()}});
+
+// ── export: GPU tiled + streaming PNG, optional GPU 2x2 supersampling ──────
+const exportJob={active:false,cancelled:false};
+function downloadBlob(blob,name){const a=document.createElement('a');a.href=URL.createObjectURL(blob);a.download=name;document.body.appendChild(a);a.click();a.remove();setTimeout(()=>URL.revokeObjectURL(a.href),1000)}
+const CRC_TABLE=(()=>{const t=new Uint32Array(256);for(let n=0;n<256;n++){let c=n;for(let k=0;k<8;k++)c=(c&1)?0xedb88320^(c>>>1):c>>>1;t[n]=c>>>0}return t})();
+function crc32Parts(parts){let c=0xffffffff;for(const part of parts)for(const b of part)c=CRC_TABLE[(c^b)&255]^(c>>>8);return(c^0xffffffff)>>>0}
+function pngChunk(type,data=new Uint8Array()){const tb=new TextEncoder().encode(type),out=new Uint8Array(12+data.length),dv=new DataView(out.buffer);dv.setUint32(0,data.length,false);out.set(tb,4);out.set(data,8);dv.setUint32(8+data.length,crc32Parts([tb,data]),false);return out}
+class StreamingPng{
+  constructor(w,h){if(typeof CompressionStream==='undefined')throw new Error('このブラウザはストリーミングPNG出力に必要なCompressionStreamへ対応していません');this.w=w;this.h=h;this.cs=new CompressionStream('deflate');this.writer=this.cs.writable.getWriter();this.compressed=(async()=>{const r=this.cs.readable.getReader(),chunks=[];for(;;){const q=await r.read();if(q.done)break;chunks.push(q.value)}return chunks})()}
+  async rows(filteredRows){await this.writer.write(filteredRows)}
+  async finish(){await this.writer.close();const chunks=await this.compressed,ihdr=new Uint8Array(13),dv=new DataView(ihdr.buffer);dv.setUint32(0,this.w,false);dv.setUint32(4,this.h,false);ihdr[8]=8;ihdr[9]=6;const parts=[new Uint8Array([137,80,78,71,13,10,26,10]),pngChunk('IHDR',ihdr)];for(const c of chunks)parts.push(pngChunk('IDAT',c));parts.push(pngChunk('IEND'));return new Blob(parts,{type:'image/png'})}
+  async abort(reason){try{await this.writer.abort(reason)}catch{}try{await this.compressed}catch{}}
+}
+function exportDimensions(){const scale=Number($('#exportScale').value),aspect=canvas.height/Math.max(1,canvas.width),requested=Math.max(64,Math.round(scale?canvas.width*scale:Number($('#exportWidth').value)||canvas.width));let w=Math.min(16384,requested),h=Math.max(1,Math.round(w*aspect));if(h>16384){h=16384;w=Math.max(64,Math.round(h/Math.max(1e-12,aspect)))}return{w:Math.min(16384,w),h:Math.min(16384,h)}}
+async function runExport(){
+  if(exportJob.active)return;
+  const r=renderer||await initRenderer();if(!r){$('#exportStatus').textContent='WebGPUが必要です。';return}
+  const{w,h}=exportDimensions(),ss=Math.max(1,Math.min(2,Number($('#exportAA').value)||1)),snap=snapshot(),iter=maxIter(),deep=deepNeeded(snap,w),strict=$('#exportPrecision').value==='strict';
+  let ctx=null;
+  if(deep){$('#exportStatus').textContent='高精度参照軌道を準備中…';ctx=await refs.request(snap,iter);if(ctx.checkpointMismatch){$('#exportStatus').textContent='参照軌道検証に失敗しました。';return}}
+  const tile=512,totalTiles=Math.ceil(w/tile)*Math.ceil(h/tile),png=new StreamingPng(w,h),sampleCount=ss===2?4:1;
+  exportJob.active=true;exportJob.cancelled=false;$('#exportProgress').hidden=false;$('#exportProgress').value=0;$('#exportStart').disabled=true;
+  let done=0,unresolvedSamples=0;
+  try{
+    for(let y=0;y<h;y+=tile){
+      const th=Math.min(tile,h-y),rowStride=1+w*4,band=new Uint8Array(rowStride*th);
+      for(let x=0;x<w;x+=tile){
+        if(exportJob.cancelled)throw new Error('cancelled');const tw=Math.min(tile,w-x);
+        const result=ss===1?await r.renderTileRGBA({snap,iter,deep,deepContext:ctx,fullW:w,fullH:h,tileX:x,tileY:y,w:tw,h:th,sampleX:.5,sampleY:.5,edgeAA:false,forceStrict:strict}):await r.renderTileRGBA2x({snap,iter,deep,deepContext:ctx,fullW:w,fullH:h,tileX:x,tileY:y,w:tw,h:th,forceStrict:strict});
+        const data=result.rgba;unresolvedSamples+=result.unresolved||0;
+        for(let row=0;row<th;row++)band.set(data.subarray(row*tw*4,(row+1)*tw*4),row*rowStride+1+x*4);
+        done++;$('#exportProgress').value=done/totalTiles;$('#exportStatus').textContent='GPUタイル生成 '+Math.round(100*done/totalTiles)+'%'+(unresolvedSamples?' · 未確定sample '+unresolvedSamples:'');
+      }
+      if(exportJob.cancelled)throw new Error('cancelled');await png.rows(band);await new Promise(requestAnimationFrame);
+    }
+    if(exportJob.cancelled)throw new Error('cancelled');$('#exportStatus').textContent='PNGストリームを確定中…';
+    const blob=await png.finish(),stamp=Date.now(),base='mandelbrot-'+stamp,meta={format:'mandelbrot-view-v24',rendererVersion:VERSION,backend:'webgpu',numericEngine:deep?'bigint-reference + guarded-rescaled-f32-perturbation':'f32-direct',membershipCertified:false,precisionPolicy:strict?'strict-gpu':'balanced-gpu',pixelContract:'centered',width:w,height:h,supersampling:ss,numericSamples:w*h*sampleCount,unresolvedSamples,exportPipeline:ss===2?'gpu-4sample-resolve + single-readback-per-tile + streaming-png':'gpu-tile + streaming-png',iterationPolicy:{adaptive:state.adaptive,base:state.baseIter,effective:iter},view:{bits:snap.bits,re:snap.re.toString(),im:snap.im.toString(),span:snap.span.toString()},palette:{id:state.palette,cycle:state.cycle,shift:state.shift},reference:ctx?{precisionBits:ctx.precisionBits,checkpointCount:ctx.checkpointCount,checkpointMismatch:ctx.checkpointMismatch,blaEnabled:false}:null,shaderVersion:G.version};
+    downloadBlob(blob,base+'.png');downloadBlob(new Blob([JSON.stringify(meta,null,2)],{type:'application/json'}),base+'.json');runtime.exports++;
+    $('#exportStatus').textContent=unresolvedSamples?'保存しました · 未確定sample '+unresolvedSamples+'（sidecar参照）':'PNGと座標メタデータを保存しました。';
+  }catch(e){await png.abort(e);$('#exportStatus').textContent=String(e.message)==='cancelled'?'出力を中止しました。':'出力失敗: '+String(e&&e.message||e)}
+  finally{exportJob.active=false;$('#exportStart').disabled=false}
+}
+$('#png').onclick=()=>{const d=$('#exportDialog');$('#exportWidth').value=String(canvas.width);$('#exportScale').value='1';$('#exportProgress').hidden=true;$('#exportStatus').textContent='';d.showModal?d.showModal():d.setAttribute('open','')};$('#exportScale').onchange=e=>{const s=Number(e.target.value);if(s)$('#exportWidth').value=String(exportDimensions().w)};$('#exportStart').onclick=runExport;$('#exportCancel').onclick=()=>{if(exportJob.active){exportJob.cancelled=true;$('#exportStatus').textContent='中止しています…'}else $('#exportDialog').close()};$('#exportQuick').onclick=()=>canvas.toBlob(blob=>{if(blob)downloadBlob(blob,'mandelbrot-'+Date.now()+'.png')},'image/png');
+
+// ── diagnostics ──────────────────────────────────────────────────────────
+function updateStats(){const z=zoomExp(),digits=Math.max(8,Math.min(80,Math.ceil(z)+8));$('#coord').textContent=fmtFixed(state.re,digits)+' '+(state.im<0n?'−':'+')+' '+fmtFixed(state.im<0n?-state.im:state.im,digits)+'i';$('#zoom').textContent=z<4?Math.pow(10,z).toFixed(1)+'×':'≈ 10^'+z.toFixed(2);$('#span').textContent=fmtSpan();$('#engine').textContent=renderer?(deepNeeded()?'WebGPU 深部':'WebGPU 標準'):(state.gpuInitFailed?'WebGPU エラー':state.gpuError?'Fallback':'起動中');$('#render').textContent=state.rendering?'描画中…':state.lastRender?state.lastRender.toFixed(0)+' ms':'準備完了';let status=state.drawState==='ERROR'?'描画停止':state.drawState==='REPROJECTED'?'再投影':state.drawState==='COVERING'?'GPU描画中':state.drawState==='REFINED'?'GPU境界平滑化':state.drawState==='COVERED'?'全域描画 完了':'準備中';if(state.unresolved)status+=' · 未確定 '+state.unresolved;if(state.gpuError){const ge=state.gpuError.length>120?state.gpuError.slice(0,117)+'…':state.gpuError;status+=' · '+ge;}$('#badge').textContent=status;$('#compactStatus').textContent=status;const d=renderer&&renderer.deepCtx;$('#diagEngine').textContent='engine: '+state.lastEngine+' | WebGPU '+(renderer?'ready':'unavailable')+' | shader '+G.version;$('#diagNumeric').textContent='numeric: view '+state.bits+' bit | iter '+maxIter()+(d?' | ref '+d.precisionBits+' bit':'');const frameBytes=renderer&&renderer.frame?renderer.frame.n*16:0,deepBytes=d?d.refs.byteLength:0;$('#diagMemory').textContent='GPU managed est: '+((frameBytes+deepBytes)/1048576).toFixed(1)+' MiB | canvas '+canvas.width+'×'+canvas.height}
+
+globalThis.__MANDEL_TEST__={
+  async setView({re,im,span,bits,baseIter=350,adaptive=false,processMode='standard'}){cancelRender();if(bits){state.bits=bits}else{state.bits=Math.max(256,decimalRequiredBits(re),decimalRequiredBits(im),decimalRequiredBits(span))}state.re=fromDec(re);state.im=fromDec(im);state.span=fromDec(span);state.baseIter=baseIter;state.adaptive=adaptive;state.processMode=processMode;state.hq=false;ensurePrecision();resize();markDirty(false);const start=performance.now();while((state.dirty||state.rendering)&&performance.now()-start<120000){schedule();await new Promise(r=>setTimeout(r,20))}if(state.dirty||state.rendering)throw new Error('test render timeout');return{width:canvas.width,height:canvas.height,diag:globalThis.__MANDEL_DIAG__.snapshot()}},
+  async sampleMeta(points){if(!renderer||!renderer.frame)throw new Error('GPU field unavailable');const idx=points.map(([x,y])=>y*renderer.frame.w+x);const m=await renderer.readMeta(idx);return Array.from(m)},
+  state:()=>({bits:state.bits,re:state.re.toString(),im:state.im.toString(),span:state.span.toString(),width:canvas.width,height:canvas.height,iter:maxIter()}),
+  async probeMeta({w,h,strict=true}={}){if(!renderer)throw new Error('WebGPU renderer unavailable');const snap=snapshot(),iter=maxIter(),deep=deepNeeded(snap,w);let ctx=null;if(deep)ctx=await refs.request(snap,iter);return Array.from(await renderer.renderTileMeta({snap,iter,deep,deepContext:ctx,fullW:w,fullH:h,w,h,forceStrict:strict}))},
+  async smokeExportTile({w=48,h=32,strict=true,ss=1}={}){if(!renderer)throw new Error('WebGPU renderer unavailable');const snap=snapshot(),iter=maxIter(),deep=deepNeeded(snap,w);let ctx=null;if(deep)ctx=await refs.request(snap,iter);const result=ss===2?await renderer.renderTileRGBA2x({snap,iter,deep,deepContext:ctx,fullW:w,fullH:h,tileX:0,tileY:0,w,h,forceStrict:strict}):await renderer.renderTileRGBA({snap,iter,deep,deepContext:ctx,fullW:w,fullH:h,tileX:0,tileY:0,w,h,sampleX:.5,sampleY:.5,edgeAA:false,forceStrict:strict}),data=result.rgba;let checksum=2166136261>>>0;for(const v of data){checksum^=v;checksum=Math.imul(checksum,16777619)>>>0}return{length:data.length,expected:w*h*4,checksum,deep,strict,ss,unresolved:result.unresolved||0}}
+};
+globalThis.__MANDEL_DIAG__={snapshot:()=>({rendererVersion:VERSION,backend:renderer?'webgpu':'fallback',shaderVersion:G.version,webgpuError:state.gpuError,pixelContract:'centered',drawState:state.drawState,rendering:state.rendering,zoom:zoomExp(),deep:deepNeeded(),bits:state.bits,iteration:maxIter(),unresolved:state.unresolved,screen:{width:canvas.width,height:canvas.height,effectiveDpr:state.effectiveDpr,pixelBudget:state.screenPixelBudget},reference:renderer&&renderer.deepCtx?{key:renderer.deepCtx.key,precisionBits:renderer.deepCtx.precisionBits,refLen:renderer.deepCtx.refLen,checkpointMismatch:renderer.deepCtx.checkpointMismatch,checkpointCount:renderer.deepCtx.checkpointCount,blaEnabled:false}:null,runtime:{...runtime},adapter:renderer?renderer.adapterInfo:null,limits:renderer?renderer.adapterLimits:null,compilation:renderer?renderer.compilation:null,uncapturedErrors:renderer?renderer.uncapturedErrors.slice():[]})};
+
+// ── boot / teardown ──────────────────────────────────────────────────────
+addEventListener('visibilitychange',()=>{if(document.hidden){cancelRender();exportJob.cancelled=true}else markDirty(false)});addEventListener('pagehide',()=>{cancelRender();refs.destroy();if(renderer)renderer.destroy()},{once:true});
+try{state.uiHidden=localStorage.getItem('mandelbrot.uiHidden')==='1';const m=localStorage.getItem('mandelbrot.processMode');if(/^(power|standard|fine|validate)$/.test(m)){state.processMode=m;state.hq=m==='fine'||m==='validate'}}catch{}applyUi();resize();if(!loadHash())reset();recordView();syncControls();updateStats();initRenderer().then(()=>{resize();markDirty(false)});schedule();
 })();
diff --git a/dist/wasm/manifest.json b/dist/wasm/manifest.json
index 95f4b16..cc258ae 100644
--- a/dist/wasm/manifest.json
+++ b/dist/wasm/manifest.json
@@ -1,6 +1,6 @@
 {
     "format":  "mandelbrot-wasm-manifest-v1",
-    "generatedUtc":  "2026-08-22T10:48:30.5652322Z",
+    "generatedUtc":  "2026-08-22T12:30:26.3193366Z",
     "input":  "kernels.js",
     "payloads":  [
                      {
diff --git a/gpu-kernels.js b/gpu-kernels.js
new file mode 100644
index 0000000..93b7e33
--- /dev/null
+++ b/gpu-kernels.js
@@ -0,0 +1,258 @@
+(()=>{'use strict';
+const COMMON=String.raw`
+const FIELD_UNKNOWN:u32=0u;
+const FIELD_ESCAPED:u32=1u;
+const FIELD_INTERIOR_LIKELY:u32=2u;
+const FIELD_INTERIOR_PROVEN:u32=3u;
+const ITER_MASK:u32=0x0fffffffu;
+const STATUS_UNRESOLVED:u32=0xfffffffeu;
+
+fn pack_meta(n:u32, cls:u32)->u32 { return (n & ITER_MASK) | ((cls & 3u) << 28u); }
+fn cmul(a:vec2<f32>, b:vec2<f32>)->vec2<f32>{
+  return vec2<f32>(a.x*b.x-a.y*b.y, a.x*b.y+a.y*b.x);
+}
+fn maxabs(v:vec2<f32>)->f32 { return max(abs(v.x),abs(v.y)); }
+const F32_U:f32=5.960464477539063e-8;
+fn pow2_safe(e:i32)->f32 {
+  if(e < -126){ return 0.0; }
+  if(e > 126){ return 8.507059e37; }
+  return ldexp(1.0,e);
+}
+fn safe_abs_error(errScaled:f32, scaleExp:i32, z:vec2<f32>, delta:vec2<f32>)->f32{
+  let propagated=abs(errScaled*pow2_safe(scaleExp));
+  let reconstruction=64.0*F32_U*(maxabs(z)+maxabs(delta)+1.0e-30);
+  return propagated+reconstruction;
+}
+fn scaled_to_f32(v:vec2<f32>, e:i32)->vec2<f32>{
+  if(e < -126){ return vec2<f32>(0.0); }
+  if(e > 126){ return vec2<f32>(8.507059e37); }
+  return ldexp(v,vec2<i32>(e));
+}
+fn smooth_escape(n:u32, mag2:f32)->f32{
+  let u=log2(max(4.0000005,mag2));
+  return f32(n)+1.0-log2(max(1.0e-20,0.5*u));
+}
+`;
+
+const DIRECT_F32_WGSL=COMMON+String.raw`
+struct Params{
+  tileW:u32, tileH:u32, fullW:u32, fullH:u32,
+  tileX:u32, tileY:u32, maxIter:u32, strict:u32,
+  centerRe:f32, centerIm:f32, span:f32, sampleX:f32,
+  sampleY:f32, _p0:f32, _p1:f32, _p2:f32,
+};
+@group(0) @binding(0) var<uniform> p:Params;
+@group(0) @binding(1) var<storage,read_write> fieldMeta:array<u32>;
+@group(0) @binding(2) var<storage,read_write> fieldSmooth:array<f32>;
+fn analytic(cr:f32,ci:f32)->bool{
+  let y2=ci*ci; let x=cr-0.25; let q=x*x+y2;
+  let lhs=q*(q+x); let rhs=0.25*y2;
+  let margin=16.0*F32_U*(abs(lhs)+abs(rhs)+1.0);
+  if(lhs<rhs-margin){return true;}
+  let x2=cr+1.0; let bulb=x2*x2+y2;
+  let bulbMargin=16.0*F32_U*(abs(bulb)+0.0625+1.0);
+  return bulb<0.0625-bulbMargin;
+}
+@compute @workgroup_size(8,8)
+fn main(@builtin(global_invocation_id) gid:vec3<u32>){
+  if(gid.x>=p.tileW||gid.y>=p.tileH){return;}
+  let out=gid.y*p.tileW+gid.x;
+  let gx=f32(p.tileX+gid.x)+p.sampleX;
+  let gy=f32(p.tileY+gid.y)+p.sampleY;
+  let scale=p.span/f32(p.fullW);
+  let cr=p.centerRe+(gx-0.5*f32(p.fullW))*scale;
+  let ci=p.centerIm+(0.5*f32(p.fullH)-gy)*scale;
+  if(analytic(cr,ci)){
+    fieldMeta[out]=pack_meta(p.maxIter,FIELD_INTERIOR_PROVEN); fieldSmooth[out]=0.0; return;
+  }
+  var zr=0.0; var zi=0.0; var n=0u;
+  loop{
+    if(n>=p.maxIter){break;}
+    let zr2=zr*zr; let zi2=zi*zi;
+    zi=2.0*zr*zi+ci; zr=zr2-zi2+cr; n+=1u;
+    let mag=zr*zr+zi*zi;
+    if(mag>4.0){fieldMeta[out]=pack_meta(n,FIELD_ESCAPED); fieldSmooth[out]=smooth_escape(n,mag); return;}
+  }
+  fieldMeta[out]=pack_meta(p.maxIter,FIELD_INTERIOR_LIKELY); fieldSmooth[out]=0.0;
+}
+`;
+
+// Deep path: high-precision CPU reference + guarded rescaled f32 perturbation.
+const DEEP_PERTURB_WGSL=COMMON+String.raw`
+struct Params{
+  tileW:u32, tileH:u32, fullW:u32, fullH:u32,
+  tileX:u32, tileY:u32, maxIter:u32, refLen:u32,
+  strict:u32, _numeric0:u32, _numeric1:u32, _numeric2:u32,
+  spanMant:f32, spanExp:i32, sampleX:f32, sampleY:f32,
+};
+struct RefPoint{ hi:vec2<f32>, lo:vec2<f32> };
+struct UnresolvedHead{ remaining:atomic<u32>, _p0:u32, _p1:u32, _p2:u32 };
+@group(0) @binding(0) var<uniform> p:Params;
+@group(0) @binding(1) var<storage,read> refs:array<RefPoint>;
+@group(0) @binding(2) var<storage,read_write> fieldMeta:array<u32>;
+@group(0) @binding(3) var<storage,read_write> fieldSmooth:array<f32>;
+@group(0) @binding(4) var<storage,read_write> unresolved:UnresolvedHead;
+
+fn mark_unresolved(out:u32,n:u32){
+  fieldMeta[out]=pack_meta(n,FIELD_UNKNOWN); fieldSmooth[out]=0.0;
+  atomicAdd(&unresolved.remaining,1u);
+}
+fn render_pixel(out:u32,gx:f32,gy:f32,strictMode:bool){
+  let dx=(gx-0.5*f32(p.fullW))/f32(p.fullW);
+  let dy=(0.5*f32(p.fullH)-gy)/f32(p.fullW);
+  // dc = d * 2^scaleExp. Keep d and w in one shared scale.
+  var d=vec2<f32>(p.spanMant*dx,p.spanMant*dy);
+  var w=vec2<f32>(0.0);
+  var scaleExp=p.spanExp;
+  var n=0u; var m=0u; var operations=0u;
+  var errScaled=64.0*F32_U*maxabs(d);
+  loop{
+    if(n>=p.maxIter){
+      let rpEnd=refs[min(m,p.refLen)];
+      let deltaEnd=scaled_to_f32(w,scaleExp);
+      let zEnd=rpEnd.hi+(rpEnd.lo+deltaEnd);
+      let errAbs=safe_abs_error(errScaled,scaleExp,zEnd,deltaEnd);
+      let limit=select(1.0e-3,1.0e-4,strictMode);
+      if(errAbs<=limit){fieldMeta[out]=pack_meta(p.maxIter,FIELD_INTERIOR_LIKELY);fieldSmooth[out]=0.0;}else{mark_unresolved(out,n);}
+      return;
+    }
+    if(m>p.refLen){mark_unresolved(out,n);return;}
+    let rp=refs[m];
+    let delta=scaled_to_f32(w,scaleExp);
+    let z=rp.hi+(rp.lo+delta);
+    let mag=dot(z,z);
+    if(mag>4.0){
+      let errAbs=safe_abs_error(errScaled,scaleExp,z,delta);
+      if(length(z)-errAbs>2.0){fieldMeta[out]=pack_meta(n,FIELD_ESCAPED);fieldSmooth[out]=smooth_escape(n,mag);return;}
+      mark_unresolved(out,n);return;
+    }
+
+    // Rebase only when dc remains numerically representable in the new scale.
+    if(m>0u && dot(delta,delta)>0.0 && mag<dot(delta,delta)){
+      if(p.spanExp-scaleExp < -96){mark_unresolved(out,n);return;}
+      errScaled=safe_abs_error(errScaled,scaleExp,z,delta);
+      w=z; d=scaled_to_f32(vec2<f32>(p.spanMant*dx,p.spanMant*dy),p.spanExp); scaleExp=0; m=0u;
+      errScaled+=64.0*F32_U*maxabs(d);
+      continue;
+    }
+
+    if(m>=p.refLen){mark_unresolved(out,n);return;}
+    let r=refs[m];
+    let refAbs=maxabs(r.hi)+maxabs(r.lo);
+    let wAbs=maxabs(w); let dAbs=maxabs(d); let p2=abs(pow2_safe(scaleExp));
+    let gain=2.0*refAbs+2.0*wAbs*p2;
+    let roundErr=64.0*F32_U*(2.0*refAbs*wAbs+wAbs*wAbs*p2+dAbs+1.0e-30);
+    errScaled=gain*errScaled+roundErr;
+    let linear=2.0*(cmul(r.hi,w)+cmul(r.lo,w));
+    // delta^2 / 2^scaleExp = w^2 * 2^scaleExp
+    let sq=cmul(w,w)*pow2_safe(scaleExp);
+    w=linear+sq+d; m+=1u; n+=1u; operations+=1u;
+    if(maxabs(w)>=1.0e30 || maxabs(d)>=1.0e30){mark_unresolved(out,n);return;}
+    let mm=max(maxabs(w),maxabs(d));
+    if(mm>65536.0){
+      w*=0.0000152587890625; d*=0.0000152587890625; errScaled*=0.0000152587890625; scaleExp+=16;
+    }else if(mm>0.0 && mm<0.0000152587890625 && scaleExp>p.spanExp){
+      w*=65536.0; d*=65536.0; errScaled*=65536.0; scaleExp-=16;
+    }
+    if(scaleExp>126 || errScaled!=errScaled || errScaled>1.0e35){mark_unresolved(out,n);return;}
+    if(operations>p.maxIter*2u+2048u){mark_unresolved(out,n);return;}
+  }
+}
+@compute @workgroup_size(8,8)
+fn main(@builtin(global_invocation_id) gid:vec3<u32>){
+  if(gid.x>=p.tileW||gid.y>=p.tileH){return;}
+  let out=gid.y*p.tileW+gid.x;
+  let gx=f32(p.tileX+gid.x)+p.sampleX; let gy=f32(p.tileY+gid.y)+p.sampleY;
+  render_pixel(out,gx,gy,p.strict!=0u);
+}
+`;
+
+const COLOR_WGSL=String.raw`
+struct Params{
+  width:u32,height:u32,palette:u32,edgeAA:u32,
+  cycle:f32,shift:f32,_p0:f32,_p1:f32,
+};
+@group(0) @binding(0) var<uniform> p:Params;
+@group(0) @binding(1) var<storage,read> fieldMeta:array<u32>;
+@group(0) @binding(2) var<storage,read> fieldSmooth:array<f32>;
+@group(0) @binding(3) var outTex:texture_storage_2d<rgba8unorm,write>;
+fn hsv(h:f32,s:f32,v:f32)->vec3<f32>{
+  let x=fract(h)*6.0; let i=i32(floor(x)); let f=x-floor(x); let pp=v*(1.0-s); let q=v*(1.0-s*f); let t=v*(1.0-s*(1.0-f));
+  if(i==0){return vec3<f32>(v,t,pp);} if(i==1){return vec3<f32>(q,v,pp);} if(i==2){return vec3<f32>(pp,v,t);} if(i==3){return vec3<f32>(pp,q,v);} if(i==4){return vec3<f32>(t,pp,v);} return vec3<f32>(v,pp,q);
+}
+fn current_palette(t0:f32)->vec3<f32>{
+  let t=select(2.0-2.0*t0,2.0*t0,t0<=0.5);
+  if(t<0.11){return mix(vec3<f32>(4,10,27),vec3<f32>(12,53,79),smoothstep(0.0,0.11,t))/255.0;}
+  if(t<0.25){return mix(vec3<f32>(12,53,79),vec3<f32>(31,156,184),smoothstep(0.11,0.25,t))/255.0;}
+  if(t<0.38){return mix(vec3<f32>(31,156,184),vec3<f32>(91,226,234),smoothstep(0.25,0.38,t))/255.0;}
+  if(t<0.50){return mix(vec3<f32>(91,226,234),vec3<f32>(66,53,151),smoothstep(0.38,0.50,t))/255.0;}
+  if(t<0.62){return mix(vec3<f32>(66,53,151),vec3<f32>(139,49,170),smoothstep(0.50,0.62,t))/255.0;}
+  if(t<0.73){return mix(vec3<f32>(139,49,170),vec3<f32>(232,72,145),smoothstep(0.62,0.73,t))/255.0;}
+  if(t<0.84){return mix(vec3<f32>(232,72,145),vec3<f32>(255,137,64),smoothstep(0.73,0.84,t))/255.0;}
+  if(t<0.93){return mix(vec3<f32>(255,137,64),vec3<f32>(255,211,99),smoothstep(0.84,0.93,t))/255.0;}
+  return mix(vec3<f32>(255,211,99),vec3<f32>(255,250,223),smoothstep(0.93,1.0,t))/255.0;
+}
+fn base_color(i:u32)->vec3<f32>{
+  let m=fieldMeta[i]; let cls=(m>>28u)&3u;
+  if(cls==0u){return vec3<f32>(20,22,30)/255.0;} if(cls!=1u){return vec3<f32>(0.0);}
+  let sm=fieldSmooth[i]; let phase=fract(p.shift+sm*p.cycle); var c=vec3<f32>(0.0);
+  if(p.palette==1u){c=hsv(phase,0.92,1.0);}else if(p.palette==2u){let g=(22.0+233.0*(0.5-0.5*cos(6.283185307*phase)))/255.0;c=vec3<f32>(g);}else{c=current_palette(phase);}
+  let n=f32(m&0x0fffffffu); let edge=clamp(log(1.0+n)/log(1.0+max(8.0,n+32.0)),0.0,1.0); let mixv=0.34+0.66*pow(edge,0.38);
+  let floorc=select(vec3<f32>(2,5,15)/255.0,vec3<f32>(8.0/255.0),p.palette==2u); return mix(floorc,c,mixv);
+}
+fn linearize(c:vec3<f32>)->vec3<f32>{return pow(c,vec3<f32>(2.2));}
+fn delinearize(c:vec3<f32>)->vec3<f32>{return pow(max(c,vec3<f32>(0.0)),vec3<f32>(1.0/2.2));}
+@compute @workgroup_size(8,8)
+fn main(@builtin(global_invocation_id) gid:vec3<u32>){
+  if(gid.x>=p.width||gid.y>=p.height){return;} let i=gid.y*p.width+gid.x; var c=base_color(i);
+  if(p.edgeAA!=0u){
+    let m=fieldMeta[i]; let cls=(m>>28u)&3u; var boundary=false; var sum=linearize(c); var cnt=1.0;
+    let x=i32(gid.x); let y=i32(gid.y);
+    for(var oy=-1;oy<=1;oy+=1){for(var ox=-1;ox<=1;ox+=1){if(ox==0&&oy==0){continue;} let xx=x+ox;let yy=y+oy;if(xx<0||yy<0||xx>=i32(p.width)||yy>=i32(p.height)){continue;}let j=u32(yy)*p.width+u32(xx);let mj=fieldMeta[j];let cj=(mj>>28u)&3u;if(cj!=cls||abs(i32(mj&0x0fffffffu)-i32(m&0x0fffffffu))>2){boundary=true;}sum+=linearize(base_color(j));cnt+=1.0;}}
+    if(boundary){c=delinearize(sum/cnt);}
+  }
+  textureStore(outTex,vec2<i32>(gid.xy),vec4<f32>(c,1.0));
+}
+`;
+
+
+const AA_RESOLVE_WGSL=String.raw`
+@group(0) @binding(0) var a:texture_2d<f32>;
+@group(0) @binding(1) var b:texture_2d<f32>;
+@group(0) @binding(2) var c:texture_2d<f32>;
+@group(0) @binding(3) var d:texture_2d<f32>;
+@group(0) @binding(4) var outTex:texture_storage_2d<rgba8unorm,write>;
+fn to_linear(x:f32)->f32{return select(x/12.92,pow((x+0.055)/1.055,2.4),x>0.04045);}
+fn to_srgb(x0:f32)->f32{let x=clamp(x0,0.0,1.0);return select(12.92*x,1.055*pow(x,1.0/2.4)-0.055,x>0.0031308);}
+fn lin3(v:vec3<f32>)->vec3<f32>{return vec3<f32>(to_linear(v.x),to_linear(v.y),to_linear(v.z));}
+fn srgb3(v:vec3<f32>)->vec3<f32>{return vec3<f32>(to_srgb(v.x),to_srgb(v.y),to_srgb(v.z));}
+@compute @workgroup_size(8,8)
+fn main(@builtin(global_invocation_id) gid:vec3<u32>){
+  let size=textureDimensions(a); if(gid.x>=size.x||gid.y>=size.y){return;}
+  let q=vec2<i32>(gid.xy);
+  let sum=lin3(textureLoad(a,q,0).rgb)+lin3(textureLoad(b,q,0).rgb)+lin3(textureLoad(c,q,0).rgb)+lin3(textureLoad(d,q,0).rgb);
+  textureStore(outTex,q,vec4<f32>(srgb3(sum*0.25),1.0));
+}
+`;
+
+const PRESENT_WGSL=String.raw`
+struct Params{scaleX:f32,scaleY:f32,offsetX:f32,offsetY:f32};
+@group(0) @binding(0) var samp:sampler;
+@group(0) @binding(1) var tex:texture_2d<f32>;
+@group(0) @binding(2) var<uniform> p:Params;
+struct VSOut{@builtin(position) pos:vec4<f32>,@location(0) uv:vec2<f32>};
+@vertex fn vs(@builtin(vertex_index) i:u32)->VSOut{
+  var pos=array<vec2<f32>,3>(vec2<f32>(-1.0,-1.0),vec2<f32>(3.0,-1.0),vec2<f32>(-1.0,3.0));
+  var uv=array<vec2<f32>,3>(vec2<f32>(0.0,1.0),vec2<f32>(2.0,1.0),vec2<f32>(0.0,-1.0));
+  var o:VSOut;o.pos=vec4<f32>(pos[i],0.0,1.0);o.uv=uv[i];return o;
+}
+@fragment fn fs(in:VSOut)->@location(0) vec4<f32>{
+  let uv=vec2<f32>(0.5)+(in.uv-vec2<f32>(0.5))*vec2<f32>(p.scaleX,p.scaleY)+vec2<f32>(p.offsetX,p.offsetY);
+  if(any(uv<vec2<f32>(0.0))||any(uv>vec2<f32>(1.0))){return vec4<f32>(0.0196,0.0314,0.0745,1.0);} return textureSampleLevel(tex,samp,uv,0.0);
+}
+`;
+
+globalThis.MANDEL_WEBGPU_KERNELS=Object.freeze({
+  version:'24.1.3',DIRECT_F32_WGSL,DEEP_PERTURB_WGSL,COLOR_WGSL,AA_RESOLVE_WGSL,PRESENT_WGSL
+});
+})();
diff --git a/index.html b/index.html
index 96f0f1b..186da65 100644
--- a/index.html
+++ b/index.html
@@ -4,7 +4,7 @@
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width,initial-scale=1,viewport-fit=cover">
 <meta name="theme-color" content="#050813">
-<title>Mandelbrot Deep Zoom v23</title>
+<title>Mandelbrot Deep Zoom v24.1.3 WebGPU</title>
 <style>
 :root{color-scheme:dark;--panel:rgba(7,12,25,.88);--line:rgba(255,255,255,.12);--text:#f7f8ff;--muted:#a9b3ca;--accent:#61dbe9}
 *{box-sizing:border-box}html,body{margin:0;width:100%;height:100%;overflow:hidden;background:#050813;font-family:Inter,-apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif}body{-webkit-user-select:none;user-select:none}
@@ -34,13 +34,13 @@ dialog{width:min(430px,calc(100vw - 24px));border:1px solid var(--line);border-r
 <div id="controls" class="panel">
   <div class="toolbar"><button id="zin" aria-label="中心を拡大">＋</button><button id="zout" aria-label="中心を縮小">−</button><button id="reset">リセット</button><button id="png">出力</button></div>
   <div class="group">
-    <div class="line"><label for="processMode">処理モード</label><select id="processMode"><option value="power">省電力</option><option value="standard" selected>標準</option><option value="fine">精細</option><option value="validate">精度優先</option></select><output></output></div>
+    <div class="line"><label for="processMode">処理モード</label><select id="processMode"><option value="power">省電力</option><option value="standard" selected>標準</option><option value="fine">精細</option><option value="validate">保守的 (Strict)</option></select><output></output></div>
     <div class="line"><label for="palette">彩色</label><select id="palette"><option value="0">昼夜</option><option value="1">虹色</option><option value="2">白黒</option></select><output></output></div>
     <div class="line"><label for="cycle">色周期</label><input id="cycle" type="range" min="0.001" max="0.05" step="0.0005" value="0.008"><output id="cycleO" for="cycle">0.0080</output></div>
     <div class="line"><label for="shift">色相位置</label><input id="shift" type="range" min="0" max="1" step="0.005" value="0.18"><output id="shiftO" for="shift">.18</output></div>
     <details><summary>詳細設定・正確な座標</summary>
       <div class="line"><label for="iters">基準反復</label><input id="iters" type="range" min="100" max="2500" step="25" value="350"><output id="itersO" for="iters">350</output></div>
-      <div class="checks"><label><input id="adaptive" type="checkbox" checked> 反復回数を自動調整</label><label><input id="hq" type="checkbox"> 境界AAを追加</label></div>
+      <div class="checks"><label><input id="adaptive" type="checkbox" checked> 反復回数を自動調整</label><label><input id="hq" type="checkbox"> GPU境界平滑化</label></div>
       <div class="exact-grid"><label for="coordReInput">実部</label><input id="coordReInput"><label for="coordImInput">虚部</label><input id="coordImInput"><label for="coordSpanInput">表示幅</label><input id="coordSpanInput"></div>
       <div class="mini-actions"><button id="coordApply">座標を適用</button><button id="coordCopy">正確値をコピー</button><button id="undoView">戻す</button><button id="redoView">進む</button></div>
     </details>
@@ -57,13 +57,13 @@ dialog{width:min(430px,calc(100vw - 24px));border:1px solid var(--line);border-r
     <label for="exportScale">出力倍率</label><select id="exportScale"><option value="1">1×</option><option value="2">2×</option><option value="4">4×</option><option value="0">カスタム幅</option></select>
     <label for="exportWidth">幅（px）</label><input id="exportWidth" type="number" min="64" max="16384" step="1">
     <label for="exportAA">サブサンプル</label><select id="exportAA"><option value="1">1×（高速）</option><option value="2">2×2 AA</option></select>
-    <label for="exportPrecision">精度方針</label><select id="exportPrecision"><option value="balanced">Balanced</option><option value="validated">Validated direct</option></select>
+    <label for="exportPrecision">精度方針</label><select id="exportPrecision"><option value="balanced">Balanced</option><option value="strict">保守的 (Strict)</option></select>
   </div>
   <progress id="exportProgress" max="1" value="0" hidden></progress>
   <div id="exportStatus" role="status" aria-live="polite"></div>
   <div class="export-actions"><button id="exportCancel" type="button">閉じる</button><button id="exportQuick" type="button">表示を即時保存</button><button id="exportStart" class="primary" type="button">PNGを生成</button></div>
 </dialog>
-<script src="kernels.js"></script>
+<script src="gpu-kernels.js"></script>
 <script src="script.js"></script>
 </body>
 </html>
diff --git a/package.json b/package.json
new file mode 100644
index 0000000..d42ef04
--- /dev/null
+++ b/package.json
@@ -0,0 +1,10 @@
+{
+  "name": "mandelbrot-webgpu-v24",
+  "version": "24.1.3",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "test": "node scripts/test-all.mjs",
+    "build": "node scripts/build.mjs"
+  }
+}
diff --git a/script.js b/script.js
index 10f7903..44822b7 100644
--- a/script.js
+++ b/script.js
@@ -1,912 +1,248 @@
 (()=>{'use strict';
-const K=globalThis.MANDEL_KERNELS;
-if(!K)throw new Error('kernels.js が読み込まれていません');
-const {WASM_SIMD_B64,WASM_SCALAR_B64,DEEP_SIMD_B64,DEEP_SCALAR_B64,BLA_SIMD_B64,BLA_SCALAR_B64,COLOR_SIMD_B64,COLOR_SCALAR_B64}=K;
-const $=s=>document.querySelector(s);
-const canvas=$('#view');
-const ctx=canvas.getContext('2d',{alpha:false,desynchronized:true})||canvas.getContext('2d',{alpha:false});
-if(!ctx){document.body.innerHTML='<div style="padding:30px;color:white">Canvas 2Dを利用できません。</div>';return;}
-
-const INITIAL_BITS=256;
-const MIN_SPAN_BITS=224;
-const TARGET_SPAN_BITS=240;
-const RATIO_DEN=4503599627370496n; // 2^52
-const POW256=1.157920892373162e77;
-const INV256=8.636168555094445e-78;
-const HI128=3.402823669209385e38;
-const LO128=2.938735877055719e-39;
-const NEG_BUCKET=-1000000000;
-const LEGACY_DEEP_ZOOM_THRESHOLD=11.5;
-const RENDER_PASS=Object.freeze({PREVIEW:'preview',COVERED:'covered'});
-const MODE_TARGET=Object.freeze({power:'PREVIEW',standard:'COVERED',fine:'REFINED',validate:'VALIDATED'});
-function modeTarget(mode=state.processMode){return MODE_TARGET[mode]||MODE_TARGET.standard}
-const RENDER_PROFILE=Object.freeze({
-  [RENDER_PASS.PREVIEW]:Object.freeze({id:RENDER_PASS.PREVIEW,covered:false,budgetMs:110,nominalScale:.42,minWidth:360,maxWidth:900,densityLimit:1.55,blaSteps:1700,ptbSteps:2500}),
-  [RENDER_PASS.COVERED]:Object.freeze({id:RENDER_PASS.COVERED,covered:true,budgetMs:1050,nominalScale:1,minWidth:0,maxWidth:Infinity,densityLimit:1,blaSteps:0,ptbSteps:0})
-});
-function renderProfile(pass){return RENDER_PROFILE[pass]||RENDER_PROFILE[RENDER_PASS.PREVIEW]}
-let deepMode=false;
-
-const state={
-  bits:INITIAL_BITS,re:0n,im:0n,span:0n,
-  baseIter:350,adaptive:true,hq:false,processMode:'standard',palette:0,cycle:.008,shift:.18,
-  token:0,rendering:false,lastRender:0,lastEngine:'起動中',lastPass:null,lastInteraction:performance.now(),dirty:true,
-  uiHidden:false,frameView:null,fieldView:null,lastFrameDone:0,
-  detailGeneration:0,detailActive:false,detailQueued:0,detailDone:0,
-  drawState:'REPROJECTED',coverage:0,unresolved:0,
-  precisionPending:false,
-  pointerActive:false,wheelActive:false,panReuse:null,effectiveDpr:1,screenPixelBudget:0,adaptivePixelBudget:0,continuationProgress:0,focusX:.5,focusY:.5
-};
-
-// Deep telemetry is collected from the actual BLA/perturbation
-// kernel rather than from a synthetic JavaScript loop.
-const deepTelemetry={
-  frames:0,kernelMPP:0,meanIter:0,blackRatio:0,badRatio:0,blaBuildEMA:0,
-  refDistance:0,interiorRatio:0,repairRatio:0,unresolvedRatio:0,
-  blaStepsPerPixel:0,ptbStepsPerPixel:0,rebasePerPixel:0,lastPilotMs:0,lastPilotMPP:0,lastKernelMs:0,lastVerifyMs:0,lastPixels:0
-};
-const refControl={buildEMA:18,lastBuildMs:0,lastRecenterAt:0,refId:0,baseMPP:0,lastMPP:0,lastPixels:0,cooldownMs:900};
-
-// Adaptive quality controller: instead of tying a quality level to a fixed
-// pixel width, learn the recent cost per pixel and spend a bounded amount of time.
-const renderPerf={deepMPP:0,shallowMPP:0};
-const runtimeMetrics={canvasWrites:0,domWrites:0,renderStarts:0,renderStartsDuringGesture:0,longTasks:0,maxLongTaskMs:0,pendingBackgroundJobs:0};
-try{if('PerformanceObserver'in globalThis){const observer=new PerformanceObserver(list=>{for(const entry of list.getEntries()){runtimeMetrics.longTasks++;runtimeMetrics.maxLongTaskMs=Math.max(runtimeMetrics.maxLongTaskMs,entry.duration||0)}});observer.observe({type:'longtask',buffered:true})}}catch{}
-function scheduleBackground(fn,delay=0){runtimeMetrics.pendingBackgroundJobs++;return setTimeout(()=>{runtimeMetrics.pendingBackgroundJobs=Math.max(0,runtimeMetrics.pendingBackgroundJobs-1);fn()},delay)}
-function scheduleIdle(fn,timeout=350){runtimeMetrics.pendingBackgroundJobs++;const run=()=>{runtimeMetrics.pendingBackgroundJobs=Math.max(0,runtimeMetrics.pendingBackgroundJobs-1);fn()};return'requestIdleCallback'in window?requestIdleCallback(run,{timeout}):setTimeout(run,Math.min(80,timeout))}
-const DETAIL_TILE_CACHE=new Map();
-let detailCacheBytes=0;
-const activeDetailTiles=[];
-let detailPlan=null;
-let schedulerRAF=0,schedulerTimer=0,schedulerDue=0,needsPaint=true,needsStats=true,wheelSettleTimer=0,pointerSettleTimer=0;
-
-function requestScheduler(delay=0){
-  if(document.hidden)return;
-  if(delay>0){
-    const due=performance.now()+delay;
-    if(schedulerTimer&&schedulerDue<=due)return;
-    if(schedulerTimer)clearTimeout(schedulerTimer);
-    schedulerDue=due;
-    schedulerTimer=setTimeout(()=>{schedulerTimer=0;schedulerDue=0;requestScheduler()},Math.max(0,Math.ceil(delay)));
-    return
-  }
-  if(schedulerTimer){clearTimeout(schedulerTimer);schedulerTimer=0;schedulerDue=0}
-  if(!schedulerRAF)schedulerRAF=requestAnimationFrame(loop)
-}
-function invalidateView(withStats=true){needsPaint=true;if(withStats)needsStats=true;requestScheduler()}
-function invalidateStats(){needsStats=true;requestScheduler()}
-
-// Device-specific runtime wisdom. It is populated by a small background CPU
-// concurrency benchmark and then refined by real deep-render strip timings.
-const deepWisdom={
-  ready:false,running:false,maxWorkers:1,workerCount:1,
-  targetStripMs:12,stripRows:24,rowMsEMA:0,
-  realBench:false
-};
-function deepWisdomStorageKey(){
-  const meta=globalThis.MANDEL_KERNEL_META||{},kernel=String(meta.BLA_SIMD_B64||meta.BLA_SCALAR_B64||'embedded').slice(0,16),hc=Math.max(1,navigator.hardwareConcurrency||1),dm=Number(navigator.deviceMemory||0);return'mandelbrot.wisdom.v23.'+[kernel,hc,dm].join('.')
-}
-function restoreDeepWisdom(){
-  try{const saved=JSON.parse(localStorage.getItem(deepWisdomStorageKey())||'null');if(!saved||saved.version!==23)return;const row=Number(saved.rowMsEMA),rows=Number(saved.stripRows),workers=Number(saved.workerCount);if(Number.isFinite(row)&&row>0&&row<1000)deepWisdom.rowMsEMA=row;if(Number.isInteger(rows)&&rows>=2&&rows<=128)deepWisdom.stripRows=rows;if(Number.isInteger(workers)&&workers>=1&&workers<=deepWorkerLimit())deepWisdom.workerCount=workers;deepWisdom.ready=deepWisdom.rowMsEMA>0}catch{}
-}
-function persistDeepWisdom(){
-  if(!deepWisdom.rowMsEMA)return;try{localStorage.setItem(deepWisdomStorageKey(),JSON.stringify({version:23,rowMsEMA:deepWisdom.rowMsEMA,stripRows:deepWisdom.stripRows,workerCount:deepWisdom.workerCount}))}catch{}
-}
+const G=globalThis.MANDEL_WEBGPU_KERNELS;if(!G)throw new Error('gpu-kernels.js が読み込まれていません');
+const $=s=>document.querySelector(s),canvas=$('#view');
+const VERSION=24,INITIAL_BITS=256,MIN_SPAN_BITS=224,TARGET_SPAN_BITS=240,RATIO_DEN=4503599627370496n;
+const FIELD_UNKNOWN=0,FIELD_ESCAPED=1,FIELD_INTERIOR_LIKELY=2,FIELD_INTERIOR_PROVEN=3;
+const state={bits:INITIAL_BITS,re:0n,im:0n,span:0n,baseIter:350,adaptive:true,hq:false,processMode:'standard',palette:0,cycle:.008,shift:.18,token:0,rendering:false,recoloring:false,recolorPending:false,dirty:true,lastRender:0,lastEngine:'起動中',drawState:'REPROJECTED',frameView:null,fieldView:null,pointerActive:false,wheelActive:false,effectiveDpr:1,screenPixelBudget:0,unresolved:0,gpuError:'',gpuInitFailed:false,gpuUnavailable:false,lastInteraction:performance.now(),focusX:.5,focusY:.5,uiHidden:false};
+let renderer=null,rendererInitPromise=null,fallbackCtx=null,webgpuCanvasClaimed=false,raf=0,settleTimer=0,lastWrittenHash='',navigationHash='';
+const viewHistory=[];let viewHistoryIndex=-1;
+const runtime={renderStarts:0,deviceLosses:0,referenceBuilds:0,gpuFrames:0,gpuRecolors:0,exports:0};
 
+// ── exact fixed-point view state ─────────────────────────────────────────
 function one(bits=state.bits){return 1n<<BigInt(bits)}
 function fromFrac(n,d=1n){return n*one()/d}
-function fromDec(s){
-  s=String(s).trim();let neg=s[0]==='-';if(neg)s=s.slice(1);
-  const p=s.toLowerCase().split('e'),mant=p[0],exp=p[1]?parseInt(p[1],10):0;
-  const a=mant.split('.'),i=a[0]||'0',f=a[1]||'';
-  let digits=(i+f).replace(/^0+(?=\d)/,'')||'0',decPlaces=f.length-exp;
-  if(decPlaces<0){digits+='0'.repeat(-decPlaces);decPlaces=0}
-  const den=10n**BigInt(decPlaces),v=(BigInt(digits)*one()+den/2n)/den;return neg?-v:v;
-}
-function decimalRequiredBits(s){s=String(s).trim().replace(/^[+-]/,'');const p=s.toLowerCase().split('e'),f=(p[0].split('.')[1]||'').length,e=p[1]?parseInt(p[1],10):0,places=Math.max(0,f-e);return Math.max(64,Math.ceil(places*Math.log2(10))+32)}
-function bitLen(n){n=n<0n?-n:n;return n===0n?0:n.toString(2).length}
-function fixedNum(v,bits=state.bits){
-  if(v===0n)return 0;let neg=v<0n;if(neg)v=-v;
-  const bl=bitLen(v),keep=52;let top,exp;
-  if(bl>keep){const sh=BigInt(bl-keep);top=Number(v>>sh);exp=(bl-keep)-bits}else{top=Number(v);exp=-bits}
-  const x=top*Math.pow(2,exp);return neg?-x:x;
-}
-// Hot-path conversion for orbit values known to stay O(1).
-function fixedOrbitNum(v,bits){
-  if(v===0n)return 0;
-  const sh=bits-54;
-  if(sh>0)return Number(v>>BigInt(sh))*Math.pow(2,-54);
-  return Number(v)*Math.pow(2,-bits);
-}
+function fromDec(s){s=String(s).trim();let neg=s.startsWith('-');if(neg)s=s.slice(1);if(s.startsWith('+'))s=s.slice(1);const p=s.toLowerCase().split('e'),mant=p[0],exp=p[1]?parseInt(p[1],10):0,a=mant.split('.'),i=a[0]||'0',f=a[1]||'';let digits=(i+f).replace(/^0+(?=\d)/,'')||'0',places=f.length-exp;if(places<0){digits+='0'.repeat(-places);places=0}const den=10n**BigInt(places),v=(BigInt(digits)*one()+den/2n)/den;return neg?-v:v}
+function decimalRequiredBits(s){s=String(s).trim().replace(/^[+-]/,'');const p=s.toLowerCase().split('e'),f=(p[0].split('.')[1]||'').length,e=p[1]?parseInt(p[1],10):0;return Math.max(64,Math.ceil(Math.max(0,f-e)*Math.log2(10))+32)}
+function bitLen(v){v=v<0n?-v:v;return v===0n?0:v.toString(2).length}
+function align(v,fromBits,toBits){const d=toBits-fromBits;return d===0?v:d>0?v<<BigInt(d):v>>BigInt(-d)}
+function fixedNum(v,bits=state.bits){if(v===0n)return 0;const neg=v<0n;if(neg)v=-v;const bl=bitLen(v),keep=52;let top,exp;if(bl>keep){const sh=BigInt(bl-keep);top=Number(v>>sh);exp=bl-keep-bits}else{top=Number(v);exp=-bits}const x=top*Math.pow(2,exp);return neg?-x:x}
 function log2FixedAt(v,bits){v=v<0n?-v:v;if(v===0n)return-Infinity;const bl=bitLen(v),take=Math.min(53,bl),sh=bl-take,top=Number(v>>BigInt(sh));return Math.log2(top)+sh-bits}
 function log2Fixed(v){return log2FixedAt(v,state.bits)}
-function zoomExp(){return Math.max(0,Math.log10(3.4)-log2Fixed(state.span)/Math.log2(10))}
-function fixedRatio(a,b){
-  if(b===0n)return 0;if(a===0n)return 0;const neg=a<0n;if(neg)a=-a;
-  const q=(a<<52n)/b;const v=Number(q)/4503599627370496;return neg?-v:v;
-}
-function align(v,fromBits,toBits){const d=toBits-fromBits;return d===0?v:d>0?v<<BigInt(d):v>>BigInt(-d)}
-function promoteState(shift){
-  // Precision promotion used to invalidate the reference orbit. Keep the same
-  // mathematical values by shifting their fixed-point representation instead.
-  // If a render is in flight, logically cancel it before mutating shared cache state.
-  if(state.rendering)cancelRender();
-  const oldBits=state.bits,s=BigInt(shift);state.re<<=s;state.im<<=s;state.span<<=s;
-  if(state.frameView){state.frameView.re<<=s;state.frameView.im<<=s;state.frameView.span<<=s;state.frameView.bits+=shift}
-  state.bits+=shift;
-  promoteReferenceCache(shift,oldBits);
-}
-function ensurePrecision(){
-  const bl=bitLen(state.span);
-  if(bl>=MIN_SPAN_BITS)return false;
-  // Defer representation-only precision promotion until the current frame finishes.
-  if(state.rendering){state.precisionPending=true;return false}
-  state.precisionPending=false;promoteState(TARGET_SPAN_BITS-bl);return true
-}
-function flushPendingPrecision(){
-  if(state.rendering||!state.precisionPending)return false;state.precisionPending=false;
-  const bl=bitLen(state.span);if(bl<MIN_SPAN_BITS){promoteState(TARGET_SPAN_BITS-bl);return true}return false
-}
-function mulRatio(v,factor){
-  const n=BigInt(Math.max(1,Math.round(factor*Number(RATIO_DEN))));return v*n/RATIO_DEN;
-}
+function fixedRatio(a,b){if(!b||!a)return 0;let neg=a<0n;if(neg)a=-a;const q=(a<<52n)/b,v=Number(q)/4503599627370496;return neg?-v:v}
+function mulRatio(v,f){const n=BigInt(Math.max(1,Math.round(f*Number(RATIO_DEN))));return v*n/RATIO_DEN}
+function promoteState(shift){const s=BigInt(shift);state.re<<=s;state.im<<=s;state.span<<=s;if(state.frameView){state.frameView={...state.frameView,bits:state.frameView.bits+shift,re:state.frameView.re<<s,im:state.frameView.im<<s,span:state.frameView.span<<s}}state.bits+=shift}
+function ensurePrecision(){const bl=bitLen(state.span);if(bl<MIN_SPAN_BITS)promoteState(TARGET_SPAN_BITS-bl)}
 function fmtFixed(v,d=17){let neg=v<0n;if(neg)v=-v;const scale=10n**BigInt(d),q=v*scale>>BigInt(state.bits);let s=q.toString().padStart(d+1,'0');s=s.slice(0,-d)+'.'+s.slice(-d);s=s.replace(/(\.\d*?)0+$/,'$1').replace(/\.$/,'');return(neg?'-':'')+s}
-function fmtFixedExact(v){let neg=v<0n;if(neg)v=-v;const d=state.bits,q=v*(10n**BigInt(d))>>BigInt(state.bits);let s=q.toString().padStart(d+1,'0');s=s.slice(0,-d)+'.'+s.slice(-d);s=s.replace(/(\.\d*?)0+$/,'$1').replace(/\.$/,'');return(neg?'-':'')+s}
-function fmtSpan(){const l=log2Fixed(state.span);if(!Number.isFinite(l))return'0';const e=Math.floor(l/Math.log2(10)),m=Math.pow(2,l-e*Math.log2(10));return m.toFixed(4)+'e'+e}
-function maxIter(){if(!state.adaptive)return state.baseIter;const z=zoomExp();if(z<12)return Math.min(12000,Math.round(state.baseIter+22*Math.sqrt(z)*Math.log2(2+z)));return Math.min(140000,Math.round(state.baseIter+150*z+260*Math.log2(2+z)))}
-function ensureOrbitPrecision(iter,width=Math.max(1,canvas.width)){const conditionBits=referenceCache.rr?Math.max(0,Math.min(256,Math.ceil(referenceCache.conditionLog2||0))):0,required=160+conditionBits,available=bitLen(state.span)-Math.ceil(Math.log2(width))-Math.ceil(Math.log2(Math.max(2,iter)));if(available>=required)return false;promoteState(required+32-available);invalidateReferenceOrbit();return true}
-function f64Ulp(x){x=Math.abs(x);if(!Number.isFinite(x))return Infinity;if(x===0)return Number.MIN_VALUE;return Math.pow(2,Math.floor(Math.log2(x))-52)}
-function deepResolutionRatio(snap=snapshot(),width=Math.max(1,canvas.width)){const step=Math.abs(fixedNum(snap.span,snap.bits))/Math.max(1,width),ulp=Math.max(f64Ulp(fixedNum(snap.re,snap.bits)),f64Ulp(fixedNum(snap.im,snap.bits)));return step===0||!Number.isFinite(step)?0:step/Math.max(Number.MIN_VALUE,ulp)}
-function deepEngineNeeded(snap=snapshot(),width=Math.max(1,canvas.width)){if(exportForcePrecision)return true;const ratio=deepResolutionRatio(snap,width),orbitRisk=ratio<=128&&(deepTelemetry.badRatio>1e-4||deepTelemetry.unresolvedRatio>2e-3||deepTelemetry.repairRatio>.08);deepMode=orbitRisk||(deepMode?ratio<64:ratio<=32);return deepMode}
-function iterationPlan(profile,deep){
-  const colorIter=maxIter();return{colorIter,computeIter:colorIter};
-}
-function workProfile(profile){return{bla:profile.blaSteps,ptb:profile.ptbSteps}}
-function cancelRender(){state.token++;state.rendering=false;cancelDeepPoolJob();flushPendingPrecision()}
-function cancelDetailRefinement(clearCurrent=true){
-  state.detailGeneration++;state.detailActive=false;state.detailQueued=0;state.detailDone=0;detailPlan=null;
-  if(clearCurrent)activeDetailTiles.length=0;
-}
-function clearDetailCache(){DETAIL_TILE_CACHE.clear();detailCacheBytes=0;activeDetailTiles.length=0;cancelDetailRefinement(false)}
-function setDirty(cancel=true){cancelUnknownContinuation();state.lastInteraction=performance.now();state.dirty=true;state.lastPass=null;state.drawState=state.frameView?'REPROJECTED':'PREVIEW';state.coverage=0;cancelDetailRefinement(true);if(cancel)cancelRender();invalidateView()}
-function reset(){
-  clearDetailCache();clearPanReuse();state.bits=INITIAL_BITS;state.re=-fromFrac(1n,2n);state.im=0n;state.span=fromFrac(34n,10n);setDirty();saveHash(false)
-}
-function viewRect(){return canvas.getBoundingClientRect()}
-function updateFocus(x,y){const r=viewRect();state.focusX=Math.max(0,Math.min(1,(x-r.left)/Math.max(1,r.width)));state.focusY=Math.max(0,Math.min(1,(y-r.top)/Math.max(1,r.height)))}
-function zoomAt(x,y,factor){
-  if(!state.panReuse)capturePanSource();
-  const r=viewRect(),fx=(x-r.left)/Math.max(1,r.width)-.5,fy=(y-r.top)/Math.max(1,r.height)-.5;
-  factor=Math.max(.01,Math.min(100,factor));const old=state.span,neu=mulRatio(old,factor);
-  const dx=BigInt(Math.round(fx*1e9)),dy=BigInt(Math.round(fy*1e9));
-  state.re+=(old-neu)*dx/1000000000n;
-  const oldY=old*BigInt(canvas.height)/BigInt(Math.max(1,canvas.width)),newY=neu*BigInt(canvas.height)/BigInt(Math.max(1,canvas.width));
-  state.im-=(oldY-newY)*dy/1000000000n;state.span=neu;ensurePrecision();setDirty(!(state.pointerActive||state.wheelActive));
-}
-function pan(dx,dy){
-  const w=Math.max(1,canvas.clientWidth),h=Math.max(1,canvas.clientHeight);
-  state.re-=state.span*BigInt(Math.round(dx*100000))/BigInt(Math.round(w*100000));
-  const ys=state.span*BigInt(canvas.height)/BigInt(Math.max(1,canvas.width));
-  state.im+=ys*BigInt(Math.round(dy*100000))/BigInt(Math.round(h*100000));setDirty(!(state.pointerActive||state.wheelActive));
-}
-
-
-function clearPanReuse(){state.panReuse=null}
-function capturePanSource(){
-  if(!state.frameView||!frameCanvas.width||!frameCanvas.height)return false;
-  const fv=state.frameView;state.panReuse={canvas:frameCanvas,snap:{bits:fv.bits,re:fv.re,im:fv.im,span:fv.span},style:styleSignature(),pass:state.lastPass,iter:maxIter(),created:performance.now()};return true
-}
-function buildPanReuse(snap,w,h,iter,profile){
-  const src=state.panReuse;if(!src||!src.canvas||src.style!==styleSignature())return null;
-  // Final HQ must recompute after a real scale change. Interactive/base passes may
-  // reproject a much larger range so wheel/pinch zoom can reuse existing pixels.
-  const re=align(src.snap.re,src.snap.bits,snap.bits),im=align(src.snap.im,src.snap.bits,snap.bits),sp=align(src.snap.span,src.snap.bits,snap.bits),scale=fixedRatio(sp,snap.span);
-  if(!Number.isFinite(scale)||scale<.22||scale>4.5)return null;
-  const scaleChange=Math.abs(Math.log2(Math.max(1e-12,scale)));
-  // Covered is a sampling contract, not a presentation shortcut. Reprojection
-  // is allowed only for Preview; the target grid is always recomputed in full.
-  if(profile.covered)return null;
-  const dx=fixedRatio(re-snap.re,snap.span)*w,dy=-fixedRatio(im-snap.im,snap.span)*w,move=Math.hypot(dx/Math.max(1,w),dy/Math.max(1,w));if(!Number.isFinite(move)||move>1.35)return null;
-  const dw=w*scale,dh=w*scale*(src.canvas.height/Math.max(1,src.canvas.width)),density=dw/Math.max(1,src.canvas.width);
-  // A zoomed preview may stretch old pixels temporarily, but the idle HQ pass will
-  // recompute it. Keep the stretch bounded so interaction never becomes misleading.
-  if(density>profile.densityLimit)return null;
-  const x0=w*.5+dx-dw*.5,y0=h*.5+dy-dh*.5,x1=x0+dw,y1=y0+dh;
-  let ix0=Math.max(0,Math.ceil(x0)+2),iy0=Math.max(0,Math.ceil(y0)+2),ix1=Math.min(w,Math.floor(x1)-2),iy1=Math.min(h,Math.floor(y1)-2);
-  if(ix1<=ix0||iy1<=iy0)return null;
-  const overlap=(ix1-ix0)*(iy1-iy0),frac=overlap/Math.max(1,w*h);if(frac<.20)return null;
-  const c=document.createElement('canvas');c.width=w;c.height=h;const cc=c.getContext('2d',{alpha:false});if(!cc)return null;cc.fillStyle='#050813';cc.fillRect(0,0,w,h);cc.imageSmoothingEnabled=true;try{cc.imageSmoothingQuality='high'}catch{};cc.drawImage(src.canvas,x0,y0,dw,dh);
-  const out=new Uint8ClampedArray(cc.getImageData(0,0,w,h).data),rects=[];
-  const add=(x,y,rw,rh)=>{x=Math.max(0,x|0);y=Math.max(0,y|0);rw=Math.min(w-x,rw|0);rh=Math.min(h-y,rh|0);if(rw>0&&rh>0)rects.push({x0:x,y0:y,w:rw,h:rh})};
-  add(0,0,w,iy0);add(0,iy1,w,h-iy1);add(0,iy0,ix0,iy1-iy0);add(ix1,iy0,w-ix1,iy1-iy0);
-  const exposed=rects.reduce((a,r)=>a+r.w*r.h,0);if(exposed>w*h*.80)return null;
-  return{out,rects,reusedPixels:w*h-exposed,exposedPixels:exposed,scale};
-}
-
-// ── Palette / smooth colouring ───────────────────────────────────────────
-const PALETTE_CURRENT=0,PALETTE_RAINBOW=1,PALETTE_MONO=2;
-const FIELD_ESCAPED=1,FIELD_INTERIOR_PROVEN=2,FIELD_INTERIOR_LIKELY=3,FIELD_UNKNOWN=4;
-const stops=[[0,[4,10,27]],[.11,[12,53,79]],[.25,[31,156,184]],[.38,[91,226,234]],[.50,[66,53,151]],[.62,[139,49,170]],[.73,[232,72,145]],[.84,[255,137,64]],[.93,[255,211,99]],[1,[255,250,223]]];
-const COLOR_PHASES=2048,COLOR_MIXES=64;
-function hsvRgb(h,sat,val){h=((h%1)+1)%1;const x=h*6,i=Math.floor(x),f=x-i,p=val*(1-sat),q=val*(1-sat*f),s=val*(1-sat*(1-f));let r,g,b;switch(i%6){case 0:r=val;g=s;b=p;break;case 1:r=q;g=val;b=p;break;case 2:r=p;g=val;b=s;break;case 3:r=p;g=q;b=val;break;case 4:r=s;g=p;b=val;break;default:r=val;g=p;b=q}return[r*255,g*255,b*255]}
-function basePalette(kind,t){
-  t=((t%1)+1)%1;
-  if(kind===PALETTE_RAINBOW)return hsvRgb(t,.92,1);
-  if(kind===PALETTE_MONO){const g=22+233*(.5-.5*Math.cos(Math.PI*2*t));return[g,g,g]}
-  let a=stops[0],b=stops[stops.length-1];for(let j=1;j<stops.length;j++){if(t<=stops[j][0]){a=stops[j-1];b=stops[j];break}}
-  let f=(t-a[0])/(b[0]-a[0]||1);f=f*f*(3-2*f);return[a[1][0]+(b[1][0]-a[1][0])*f,a[1][1]+(b[1][1]-a[1][1])*f,a[1][2]+(b[1][2]-a[1][2])*f]
-}
-function buildColorLut(kind){const lut=new Uint8Array(COLOR_PHASES*3);for(let pi=0;pi<COLOR_PHASES;pi++){const u=pi/(COLOR_PHASES-1),t=kind===PALETTE_CURRENT?(u<=.5?u*2:2-u*2):u,c=basePalette(kind,t),k=pi*3;lut[k]=c[0]|0;lut[k+1]=c[1]|0;lut[k+2]=c[2]|0}return lut}
-const COLOR_LUTS=[buildColorLut(PALETTE_CURRENT),buildColorLut(PALETTE_RAINBOW),buildColorLut(PALETTE_MONO)];
-const SMOOTH_U_MIN=2,SMOOTH_U_STEP=1/128,SMOOTH_U_N=4097,SMOOTH_CORR=new Float32Array(SMOOTH_U_N);
-for(let i=0;i<SMOOTH_U_N;i++){const u=SMOOTH_U_MIN+i*SMOOTH_U_STEP;SMOOTH_CORR[i]=1-Math.log2(.5*u)}
-const COLOR_CTX_CACHE=new Map();
-function makeColorCtx(iter){let hit=COLOR_CTX_CACHE.get(iter);if(hit)return hit;const mixBin=new Uint8Array(iter+1),den=Math.log1p(Math.max(8,iter));for(let n=0;n<=iter;n++){const edge=Math.max(0,Math.min(1,Math.log1p(n)/den));mixBin[n]=Math.min(COLOR_MIXES-1,Math.round((COLOR_MIXES-1)*Math.pow(edge,.38)))}hit={mixBin};COLOR_CTX_CACHE.set(iter,hit);if(COLOR_CTX_CACHE.size>8)COLOR_CTX_CACHE.delete(COLOR_CTX_CACHE.keys().next().value);return hit}
-function smoothEscape(n,m){const u=Math.log2(Math.max(4.0000001,m));let corr;const fi=(u-SMOOTH_U_MIN)/SMOOTH_U_STEP;if(fi>=0&&fi<SMOOTH_U_N-1){const i=fi|0,f=fi-i;corr=SMOOTH_CORR[i]+(SMOOTH_CORR[i+1]-SMOOTH_CORR[i])*f}else corr=1-Math.log2(.5*u);return n+corr}
-function putPaletteColor(out,oi,sm,n,iter,colorCtx){let phase=state.shift+sm*state.cycle;phase-=Math.floor(phase);const pi=Math.min(COLOR_PHASES-1,(phase*COLOR_PHASES)|0),mi=colorCtx.mixBin[Math.min(iter,n)],mix=.34+.66*(mi/(COLOR_MIXES-1)),kind=state.palette,lut=COLOR_LUTS[kind]||COLOR_LUTS[0],k=pi*3,f0=kind===PALETTE_MONO?8:2,f1=kind===PALETTE_MONO?8:5,f2=kind===PALETTE_MONO?8:15;out[oi]=(f0+(lut[k]-f0)*mix)|0;out[oi+1]=(f1+(lut[k+1]-f1)*mix)|0;out[oi+2]=(f2+(lut[k+2]-f2)*mix)|0;out[oi+3]=255}
-function putFastColor(out,oi,n,m,iter,colorCtx){putPaletteColor(out,oi,smoothEscape(n,m),n,iter,colorCtx)}
-function makeField(size,iter){return{smooth:new Float32Array(size),iterations:new Uint32Array(size),classes:new Uint8Array(size),confidence:new Uint8Array(size),iter}}
-function fieldConfidence(kind){return kind===FIELD_ESCAPED||kind===FIELD_INTERIOR_PROVEN?255:kind===FIELD_INTERIOR_LIKELY?192:0}
-function putField(field,index,n,m,kind){field.classes[index]=kind;if(field.iterations)field.iterations[index]=Math.max(0,n)>>>0;if(field.confidence)field.confidence[index]=fieldConfidence(kind);if(kind===FIELD_ESCAPED)field.smooth[index]=smoothEscape(n,m);else field.smooth[index]=NaN}
-function fillFieldConfidence(field){if(!field.confidence)field.confidence=new Uint8Array(field.classes.length);for(let i=0;i<field.classes.length;i++)field.confidence[i]=fieldConfidence(field.classes[i])}
-function colorizeField(field){const out=new Uint8ClampedArray(field.classes.length*4),colorCtx=makeColorCtx(field.iter);for(let i=0,oi=0;i<field.classes.length;i++,oi+=4){const kind=field.classes[i];if(kind!==FIELD_ESCAPED){const neutral=kind===FIELD_UNKNOWN;out[oi]=neutral?20:0;out[oi+1]=neutral?22:0;out[oi+2]=neutral?30:0;out[oi+3]=255;continue}const sm=field.smooth[i],n=Math.max(0,Math.min(field.iter,Math.floor(sm)));putPaletteColor(out,oi,sm,n,field.iter,colorCtx)}return out}
-
-// Embedded WebAssembly: SIMD-optimized kernel with a scalar fallback.
-
-
-let wasm=null;
-function instantiateWasm(b64){
-  const module=b64 instanceof WebAssembly.Module?b64:(()=>{const raw=atob(b64),bytes=new Uint8Array(raw.length);for(let i=0;i<raw.length;i++)bytes[i]=raw.charCodeAt(i);return new WebAssembly.Module(bytes)})(),inst=new WebAssembly.Instance(module,{}),ex=inst.exports;
-  return {module,ex,counts:()=>new Uint32Array(ex.memory.buffer,ex.counts_ptr(),65536),mags:()=>new Float64Array(ex.memory.buffer,ex.mags_ptr(),65536),refsR:()=>new Float64Array(ex.memory.buffer,ex.refs_r_ptr(),150001),refsI:()=>new Float64Array(ex.memory.buffer,ex.refs_i_ptr(),150001)};
-}
-try{wasm=instantiateWasm(WASM_SIMD_B64);wasm.simd=globalThis.MANDEL_HOSTED_SHALLOW_SIMD!==false}catch(e){try{wasm=instantiateWasm(WASM_SCALAR_B64);wasm.simd=false}catch(_e){wasm=null}}
-let shallowWorker=null,shallowWorkerUrl=null,shallowWorkerBusy=false,shallowRecycle=null;
-function shallowWorkerSource(){return `'use strict';let ex=null;function smooth(n,m){const u=Math.log2(Math.max(4.0000001,m));return n+1-Math.log2(.5*u)}function likely(cr,ci){const y2=ci*ci,x=cr-.25,q=x*x+y2;if(q*(q+x)<=.25*y2)return true;const x2=cr+1;return x2*x2+y2<=.0625}self.onmessage=e=>{const d=e.data;if(d.type==='init'){ex=new WebAssembly.Instance(d.module,{}).exports;postMessage({type:'ready'});return}if(d.type!=='render'||!ex)return;try{const scale=d.sp/d.w,npx=ex.render_rows(d.cre+scale*.5,d.cim-scale*.5,d.sp,d.w,d.h,d.y,d.rows,d.iter),counts=new Uint32Array(ex.memory.buffer,ex.counts_ptr(),65536),mags=new Float64Array(ex.memory.buffer,ex.mags_ptr(),65536),field=d.fieldBuffer&&d.fieldBuffer.byteLength>=npx*4?new Float32Array(d.fieldBuffer,0,npx):new Float32Array(npx),iterations=d.iterationBuffer&&d.iterationBuffer.byteLength>=npx*4?new Uint32Array(d.iterationBuffer,0,npx):new Uint32Array(npx),classes=d.classBuffer&&d.classBuffer.byteLength>=npx?new Uint8Array(d.classBuffer,0,npx):new Uint8Array(npx);for(let i=0;i<npx;i++){const n=counts[i],x=i%d.w,y=d.y+((i/d.w)|0),cr=d.cre+(x+.5-d.w*.5)*scale,ci=d.cim+(d.h*.5-y-.5)*scale;iterations[i]=n;if(n<d.iter){classes[i]=1;field[i]=smooth(n,mags[i])}else{classes[i]=likely(cr,ci)?3:4;field[i]=NaN}}postMessage({type:'render',jobId:d.jobId,y:d.y,rows:d.rows,field:field.buffer,iterations:iterations.buffer,classes:classes.buffer},[field.buffer,iterations.buffer,classes.buffer])}catch(error){postMessage({type:'render',jobId:d.jobId,error:String(error&&error.message||error)})}}`}
-function ensureShallowWorker(){if(shallowWorker||!wasm||typeof Worker==='undefined'||typeof Blob==='undefined')return!!shallowWorker;try{shallowWorkerUrl=URL.createObjectURL(new Blob([shallowWorkerSource()],{type:'text/javascript'}));shallowWorker=new Worker(shallowWorkerUrl);shallowWorker.postMessage({type:'init',module:wasm.module});return true}catch{shallowWorker=null;return false}}
-function destroyShallowWorker(){if(shallowWorker){try{shallowWorker.terminate()}catch{}shallowWorker=null}if(shallowWorkerUrl){try{URL.revokeObjectURL(shallowWorkerUrl)}catch{}shallowWorkerUrl=null}shallowWorkerBusy=false;shallowRecycle=null}
-
-
-
-function instantiateDeepWasm(b64){
-  const module=b64 instanceof WebAssembly.Module?b64:(()=>{const raw=atob(b64),bytes=new Uint8Array(raw.length);for(let i=0;i<raw.length;i++)bytes[i]=raw.charCodeAt(i);return new WebAssembly.Module(bytes)})();
-  const ex=new WebAssembly.Instance(module,{}).exports;
-  return {ex,counts:()=>new Uint32Array(ex.memory.buffer,ex.counts_ptr(),65536),mags:()=>new Float64Array(ex.memory.buffer,ex.mags_ptr(),65536),refsR:()=>new Float64Array(ex.memory.buffer,ex.refs_r_ptr(),150001),refsI:()=>new Float64Array(ex.memory.buffer,ex.refs_i_ptr(),150001)};
-}
-let deepWasm=null,deepWasmTried=false,deepModuleBundle=null,deepModulePromise=null;
-async function compileKernelSource(source){if(source instanceof WebAssembly.Module)return source;if(/^https?:/i.test(source)){const response=await fetch(source,{cache:'force-cache'});if(!response.ok)throw new Error('WASM request failed '+response.status);if(WebAssembly.compileStreaming){try{return await WebAssembly.compileStreaming(Promise.resolve(response.clone()))}catch{}}return WebAssembly.compile(await response.arrayBuffer())}const raw=atob(source),bytes=new Uint8Array(raw.length);for(let i=0;i<raw.length;i++)bytes[i]=raw.charCodeAt(i);return WebAssembly.compile(bytes)}
-async function compileKernelPair(simd,scalar){try{return{module:await compileKernelSource(simd),simd:true}}catch{return{module:await compileKernelSource(scalar),simd:false}}}
-function prepareDeepModules(){if(deepModuleBundle)return Promise.resolve(deepModuleBundle);if(!deepModulePromise)deepModulePromise=Promise.all([compileKernelPair(DEEP_SIMD_B64,DEEP_SCALAR_B64),compileKernelPair(BLA_SIMD_B64,BLA_SCALAR_B64),compileKernelPair(COLOR_SIMD_B64,COLOR_SCALAR_B64)]).then(([deep,bla,color])=>deepModuleBundle={deep,bla,color}).catch(error=>{deepModulePromise=null;throw error});return deepModulePromise}
-function ensureDeepWasm(){
-  if(deepWasm)return true;if(deepWasmTried)return false;deepWasmTried=true;if(deepModuleBundle){try{deepWasm=instantiateDeepWasm(deepModuleBundle.deep.module);deepWasm.simd=deepModuleBundle.deep.simd}catch{deepWasm=null}return!!deepWasm}if(/^https?:/i.test(DEEP_SIMD_B64)||/^https?:/i.test(DEEP_SCALAR_B64))return false;
-  try{deepWasm=instantiateDeepWasm(DEEP_SIMD_B64);deepWasm.simd=true}catch(e){try{deepWasm=instantiateDeepWasm(DEEP_SCALAR_B64);deepWasm.simd=false}catch(_e){deepWasm=null}}
-  return!!deepWasm
-}
-
-
-
-
-
-
-
-// Deep renderer worker pool. Each worker owns a WASM instance and performs both the
-// perturbation kernel and colour mapping, so colourful frames no longer funnel all
-// post-processing through the UI thread. Jobs are striped dynamically for load balance.
-const deepPool={workers:[],url:null,activeToken:0,serial:0,failed:false,current:null,maxWorkers:0,benchTimer:0};
-// ── Persistent deep-render workers / BLA kernel ──────────────────────────
-function deepWorkerSource(){
-  return `'use strict';
-let core=null,blaCore=null,colorCore=null,refKey='',refLoaded=0,RR=new Float64Array(150001),RI=new Float64Array(150001),blaRefKey='',blaRefLoaded=0,blaBuiltKey='',lastBlaBuildMs=0;
-function ensure(){if(!core)throw new Error('deep module not initialized');return core}
-function ensureBla(){if(!blaCore)throw new Error('BLA module not initialized');return blaCore}
-function ensureColor(){if(!colorCore)throw new Error('color module not initialized');return colorCore}
-function applyRef(d,ex){if(d.refKey!==refKey){refKey=d.refKey;refLoaded=0;blaRefKey='';blaRefLoaded=0;blaBuiltKey=''}if(d.rr){const ar=new Float64Array(d.rr),ai=new Float64Array(d.ri),st=d.rrStart|0;RR.set(ar,st);RI.set(ai,st);new Float64Array(ex.memory.buffer,ex.refs_r_ptr(),150001).set(ar,st);new Float64Array(ex.memory.buffer,ex.refs_i_ptr(),150001).set(ai,st);refLoaded=Math.max(refLoaded,st+ar.length);if(blaCore&&blaRefKey===refKey){const bx=blaCore.ex;new Float64Array(bx.memory.buffer,bx.refs_r_ptr(),150001).set(ar,st);new Float64Array(bx.memory.buffer,bx.refs_i_ptr(),150001).set(ai,st);blaRefLoaded=Math.max(blaRefLoaded,st+ar.length);blaBuiltKey=''}}if(refLoaded<d.refLen+1)throw new Error('reference cache miss')}
-function syncRefsToBla(d,key=d.blaKey,eps=d.blaEps){if(!d.useBla)return null;const b=ensureBla(),ex=b.ex;if(blaRefKey!==refKey){new Float64Array(ex.memory.buffer,ex.refs_r_ptr(),150001).set(RR.subarray(0,refLoaded));new Float64Array(ex.memory.buffer,ex.refs_i_ptr(),150001).set(RI.subarray(0,refLoaded));blaRefKey=refKey;blaRefLoaded=refLoaded;blaBuiltKey=''}else if(refLoaded>blaRefLoaded){new Float64Array(ex.memory.buffer,ex.refs_r_ptr(),150001).set(RR.subarray(blaRefLoaded,refLoaded),blaRefLoaded);blaRefLoaded=refLoaded;blaBuiltKey=''}lastBlaBuildMs=0;if(blaBuiltKey!==key){const t=performance.now(),levels=ex.build_bla(d.refLen,d.cMax,eps);lastBlaBuildMs=performance.now()-t;if(!levels)return null;blaBuiltKey=key}return b}
-function smoothBatch(srcMags,npx){const c=ensureColor(),ex=c.ex,mi=new Float64Array(ex.memory.buffer,ex.mags_ptr(),65536),co=new Float32Array(ex.memory.buffer,ex.corr_ptr(),65536);mi.set(srcMags.subarray(0,npx),0);ex.smooth_batch(npx);return co}
-function strictOne(ex,x,y,d){const counts=new Uint32Array(ex.memory.buffer,ex.counts_ptr(),65536),mags=new Float64Array(ex.memory.buffer,ex.mags_ptr(),65536);ex.render_perturb_rebase_rect(d.spanMant,d.spanBucket,d.offR,d.offI,d.offBucket,d.refLen,d.w,d.h,d.cx,d.cy,x,y,1,1,d.iter,0,0,0,0,0,0,0);return[counts[0],mags[0]]}
-function stats(bx){return{blaSteps:bx.stat_bla_steps?bx.stat_bla_steps():0,ptbSteps:bx.stat_ptb_steps?bx.stat_ptb_steps():0,rebases:bx.stat_rebases?bx.stat_rebases():0,interior:bx.stat_interior?bx.stat_interior():0,unresolved:bx.stat_unresolved?bx.stat_unresolved():0,fail:bx.stat_fail?bx.stat_fail():0}}
-function renderBla(d,b,key,eps,bcap,pcap){const bx=b.ex;if(key!==d.blaKey||eps!==d.blaEps)b=syncRefsToBla(d,key,eps)||b;const t=performance.now(),npx=bx.render_bla_rect_v2?bx.render_bla_rect_v2(d.spanNormal,d.offRn,d.offIn,d.baseCr,d.baseCi,d.refLen,d.w,d.h,d.x0||0,d.y0,d.rectW||d.w,d.rows,d.iter,bcap||0,pcap||0,1):bx.render_bla_rect(d.spanNormal,d.offRn,d.offIn,d.refLen,d.w,d.h,d.x0||0,d.y0,d.rectW||d.w,d.rows,d.iter);return{npx,kernelMs:performance.now()-t,counts:new Uint32Array(bx.memory.buffer,bx.counts_ptr(),65536),mags:new Float64Array(bx.memory.buffer,bx.mags_ptr(),65536),stats:stats(bx)}}
-function verifyAgainstSafe(d,result,rw,npx,b){const want=d.verifySamples||0;if(!want||!b)return{samples:0,mismatch:0};const counts=Uint32Array.from(result.counts.subarray(0,npx)),mags=Float64Array.from(result.mags.subarray(0,npx));result.counts=counts;result.mags=mags;const picks=[],seen=new Set(),add=i=>{if(picks.length>=want)return;i=Math.max(0,Math.min(npx-1,i|0));if(!seen.has(i)){seen.add(i);picks.push(i)}};for(let k=0;k<Math.max(2,want>>1);k++)add(((k+.37)*npx/Math.max(2,want>>1))|0);const stride=Math.max(1,Math.floor(npx/Math.max(16,want*10))),top=[];for(let i=stride;i<npx;i+=stride){const n=counts[i],p=counts[i-stride];if(n<0xfffffffe&&p<0xfffffffe&&((n>=d.iter)!==(p>=d.iter))){add(i);add(i-stride)}if(n<d.iter&&n<0xfffffffe){top.push([n,i]);top.sort((a,b)=>b[0]-a[0]);if(top.length>want)top.length=want}}for(const x of top)add(x[1]);for(let k=0;picks.length<want&&k<want*2;k++)add(((k+.73)*npx/want)|0);let mismatch=0;const bad=[];for(const i of picks){const bn=counts[i];if(bn>=0xfffffffe)continue;const x=(d.x0||0)+(i%rw),y=d.y0+((i/rw)|0),sr=renderBla({...d,x0:x,y0:y,rectW:1,rows:1},b,d.safeBlaKey||d.blaKey,d.safeBlaEps||d.blaEps,0,0),sn=sr.counts[0];if(sn>=0xfffffffe)continue;if((bn>=d.iter)!==(sn>=d.iter)||Math.abs((bn|0)-(sn|0))>(d.verifyDelta||64)){mismatch++;bad.push(i)}}return{samples:picks.length,mismatch,bad}}
-self.onmessage=async e=>{const d=e.data;if(!d)return;if(d.type==='init'){try{core={ex:new WebAssembly.Instance(d.modules.deep.module,{}).exports,simd:!!d.modules.deep.simd};blaCore={ex:new WebAssembly.Instance(d.modules.bla.module,{}).exports,simd:!!d.modules.bla.simd};colorCore={ex:new WebAssembly.Instance(d.modules.color.module,{}).exports,simd:!!d.modules.color.simd};postMessage({type:'ready'})}catch(error){postMessage({type:'ready',error:String(error&&error.message||error)})}return}if(d.type!=='render'&&d.type!=='pilot'&&d.type!=='realBench')return;try{const c=ensure(),ex=c.ex;applyRef(d,ex);const b=syncRefsToBla(d);if((d.type==='pilot'||d.type==='realBench')&&!b)throw new Error('BLA unavailable');if(d.type==='pilot'||d.type==='realBench'){const reps=d.type==='realBench'?Math.max(1,d.repeats|0):1;let rr=null,total=0;for(let k=0;k<reps;k++){rr=renderBla({...d,x0:0,y0:0,rectW:d.w,rows:d.h},b,d.blaKey,d.blaEps,0,0);total+=rr.kernelMs}if(d.type==='realBench'){postMessage({type:'realBench',benchId:d.benchId,kernelMs:total,pixels:rr.npx*reps,blaBuildMs:lastBlaBuildMs,simd:b.simd});return}const co=rr.counts;let black=0,bad=0,sum=0;for(let i=0;i<rr.npx;i++){const n=co[i];if(n>=0xfffffffe){bad++;continue}sum+=Math.min(d.iter,n);if(n>=d.iter)black++}postMessage({type:'pilot',pilotId:d.pilotId,kernelMs:total,pixels:rr.npx,blaBuildMs:lastBlaBuildMs,blackRatio:black/Math.max(1,rr.npx),badRatio:bad/Math.max(1,rr.npx),meanIter:sum/Math.max(1,rr.npx-bad),stats:rr.stats,simd:b.simd});return}
-const rx=d.x0||0,rw=d.rectW||d.w,field=d.fieldBuffer&&d.fieldBuffer.byteLength>=rw*d.rows*4?new Float32Array(d.fieldBuffer,0,rw*d.rows):new Float32Array(rw*d.rows),iterations=d.iterationBuffer&&d.iterationBuffer.byteLength>=rw*d.rows*4?new Uint32Array(d.iterationBuffer,0,rw*d.rows):new Uint32Array(rw*d.rows),classes=d.classBuffer&&d.classBuffer.byteLength>=rw*d.rows?new Uint8Array(d.classBuffer,0,rw*d.rows):new Uint8Array(rw*d.rows),bad=[];let result,repaired=0,verifyMs=0;if(b){result=renderBla(d,b,d.blaKey,d.blaEps,d.maxBlaSteps||0,d.maxPtbSteps||0);let unresolved=result.stats.unresolved||0;if(unresolved&&d.covered){const co=result.counts,ma=result.mags;for(let i=0;i<result.npx;i++)if(co[i]===0xfffffffe){const x=rx+(i%rw),y=d.y0+((i/rw)|0),r=strictOne(ex,x,y,d);co[i]=r[0];ma[i]=r[1]}}
-const tv=performance.now();let v=verifyAgainstSafe(d,result,rw,result.npx,b);verifyMs=performance.now()-tv;if(v.mismatch){const safeKey=d.safeBlaKey||d.blaKey,safeEps=d.safeBlaEps||d.blaEps;result=renderBla(d,b,safeKey,safeEps,0,0);repaired=1}
-}else{const t=performance.now(),npx=ex.render_perturb_rebase_rect(d.spanMant,d.spanBucket,d.offR,d.offI,d.offBucket,d.refLen,d.w,d.h,d.cx,d.cy,rx,d.y0,rw,d.rows,d.iter,d.skip||0,d.Ar||0,d.Ai||0,d.Ab||0,d.Br||0,d.Bi||0,d.Bb||0);result={npx,kernelMs:performance.now()-t,counts:new Uint32Array(ex.memory.buffer,ex.counts_ptr(),65536),mags:new Float64Array(ex.memory.buffer,ex.mags_ptr(),65536),stats:{blaSteps:0,ptbSteps:0,rebases:0,interior:0,unresolved:0,fail:0}}}
-const corr=smoothBatch(result.mags,result.npx);let blackCount=0,sumIter=0;for(let i=0;i<result.npx;i++){let n=result.counts[i],m=result.mags[i];const x=rx+(i%rw),y=d.y0+((i/rw)|0);if(n>=0xfffffffe){if(n===0xffffffff){const r=strictOne(ex,x,y,d);n=r[0];m=r[1]}else{n=d.iter;m=0}}iterations[i]=n;if(n===0xffffffff){classes[i]=4;field[i]=NaN;bad.push(i);continue}sumIter+=Math.min(d.iter,n);if(n>=d.iter){classes[i]=4;field[i]=NaN;blackCount++;continue}classes[i]=1;field[i]=n+corr[i]}
-postMessage({type:'render',jobId:d.jobId,x0:rx,rectW:rw,y0:d.y0,rows:d.rows,field:field.buffer,iterations:iterations.buffer,classes:classes.buffer,bad,simd:c.simd,bla:!!b,blaSimd:b?b.simd:false,colorSimd:colorCore?colorCore.simd:false,kernelMs:result.kernelMs,verifyMs,blaBuildMs:lastBlaBuildMs,pixels:result.npx,blackCount,sumIter,stats:result.stats,verifySamples:d.verifySamples||0,repaired},[field.buffer,iterations.buffer,classes.buffer])}catch(err){postMessage({type:'render',jobId:d.jobId,error:String(err&&err.message||err)})}};
-`;
-}
-function destroyDeepPool(){
-  if(deepPool.current)deepPool.current.cancelled=true;deepPool.current=null;
-  for(const w of deepPool.workers){try{w.terminate()}catch{}}
-  deepPool.workers.length=0;if(deepPool.url){try{URL.revokeObjectURL(deepPool.url)}catch{}deepPool.url=null}
-  deepPool.activeToken=0;deepPool.maxWorkers=0
-}
-function retireDeepAssets(){destroyDeepPool();deepPool.failed=false;deepWasm=null;deepWasmTried=false;deepModuleBundle=null;deepModulePromise=null;referenceCache.rr=null;referenceCache.ri=null;referenceCache.series=null;referenceCache.n=0;referenceCache.escape=0;referenceCache.loadedLen=0;referenceCache.conditionLog2=0;referenceCache.derivative=[0,0,NEG_BUCKET]}
-function cancelDeepPoolJob(){
-  // Logical cancellation: keep Worker, WASM, reference and BLA caches alive.
-  deepPool.activeToken=0;
-  if(deepPool.current){deepPool.current.cancelled=true;deepPool.current=null}
-}
-function handleDeepWorkerMessage(worker,d){
-  const job=worker._job;worker._job=null;worker._busy=false;
-  if(d&&d.type==='ready'){if(d.error){worker._ready=false;deepPool.failed=true;destroyDeepPool();return}worker._ready=true;kickDeepWorker(worker);return}
-  if(!job){kickDeepWorker(worker);return}
-  if(job.type==='bench'){if(d&&d.type==='bench'&&d.benchId===job.benchId)job.resolve(d);else job.reject(new Error('benchmark reply mismatch'));kickDeepWorker(worker);return}
-  if(job.type==='pilot'||job.type==='realBench'){if(d&&((job.type==='pilot'&&d.type==='pilot'&&d.pilotId===job.id)||(job.type==='realBench'&&d.type==='realBench'&&d.benchId===job.id)))job.resolve(d);else job.reject(new Error(job.type+' reply mismatch'));kickDeepWorker(worker);return}
-  if(job.type==='render')job.runner.onResult(worker,d,job);
-  kickDeepWorker(worker)
-}
-function handleDeepWorkerError(worker,e){
-  const job=worker._job;worker._job=null;worker._busy=false;
-  if(job&&(job.type==='bench'||job.type==='pilot'||job.type==='realBench'))job.reject(e instanceof Error?e:new Error('worker job failed'));
-  else if(job&&job.type==='render')job.runner.fail(e);
-  else{deepPool.failed=true;destroyDeepPool()}
-}
-function deepWorkerLimit(){const hc=Math.max(1,navigator.hardwareConcurrency||4),memoryLimited=Number(navigator.deviceMemory||8)<=4?1:2;return Math.max(1,Math.min(memoryLimited,hc>2?hc-1:1))}
-function addDeepWorker(){if(!deepModuleBundle)throw new Error('deep modules are not ready');const i=deepPool.workers.length,w=new Worker(deepPool.url);w._index=i;w._refKey='';w._refLoaded=0;w._busy=false;w._ready=false;w._job=null;w._recycle=null;w.onmessage=e=>handleDeepWorkerMessage(w,e.data);w.onerror=e=>handleDeepWorkerError(w,e);deepPool.workers.push(w);w.postMessage({type:'init',modules:deepModuleBundle});return w}
-function ensureDeepPool(){
-  if(deepPool.failed||!deepModuleBundle||typeof Worker==='undefined'||typeof Blob==='undefined')return false;
-  if(deepPool.workers.length)return true;
-  try{
-    const count=deepWorkerLimit();
-    deepPool.url=URL.createObjectURL(new Blob([deepWorkerSource()],{type:'text/javascript'}));
-    deepPool.maxWorkers=count;deepWisdom.maxWorkers=count;deepWisdom.workerCount=1;addDeepWorker();
-    return true
-  }catch(e){deepPool.failed=true;destroyDeepPool();return false}
-}
-function prewarmDeepAssets(){prepareDeepModules().then(()=>{if(deepResolutionRatio()<=128)ensureDeepPool()}).catch(()=>{})}
-function kickDeepWorker(worker){
-  if(worker._busy||!worker._ready)return;
-  const r=deepPool.current;if(!r||r.cancelled||r.token!==state.token)return;
-  const active=Math.max(1,Math.min(deepWisdom.ready?deepWisdom.workerCount:Math.min(2,deepPool.workers.length),deepPool.workers.length));
-  if(worker._index>=active)return;
-  r.dispatch(worker)
-}
-function attachReference(worker,msg,ref,refLen,refKey,transfer){
-  let start=worker._refKey===refKey?worker._refLoaded:0;start=Math.max(0,Math.min(start,refLen+1));
-  if(start<refLen+1){const rr=ref.rr.slice(start,refLen+1),ri=ref.ri.slice(start,refLen+1);msg.rr=rr.buffer;msg.ri=ri.buffer;msg.rrStart=start;transfer.push(rr.buffer,ri.buffer);worker._refKey=refKey;worker._refLoaded=refLen+1}
-}
-function blaProfile(profile){
-  const z=zoomExp(),exp=profile.covered?32:(z<16?28:23);
-  // Fast pass + local verification/repair is cheaper than making the entire frame
-  // conservative.  Safe strips are rebuilt at e-48 only when a probe disagrees.
-  const safeExp=z<16?48:Math.min(48,Math.max(32,exp+8));
-  return{exp,eps:Math.pow(2,-exp),safeExp}
-}
-function runDeepPool(profile,snap,w,h,iter,colorIter,token,t0,out,sb,refC,off,ref,refLen,series,onFallback,rects=null){
-  if(!ensureDeepPool())return false;if(deepPool.current)deepPool.current.cancelled=true;
-  const centered=pixelCenteredOffset(snap,refC,w),workers=deepPool.workers,refKey=String(ref.id),bad=[],field=makeField(w*h,colorIter),spanNormal=fixedNum(snap.span,snap.bits),offRn=fixedNum(centered.r,snap.bits),offIn=fixedNum(centered.i,snap.bits),baseCr=fixedNum(refC.re,snap.bits),baseCi=fixedNum(refC.im,snap.bits);
-  const cMaxRaw=Math.hypot(offRn,offIn)+Math.abs(spanNormal)*Math.hypot(.5,h/(2*Math.max(1,w))),cBucket=cMaxRaw>0&&Number.isFinite(cMaxRaw)?Math.ceil(Math.log2(cMaxRaw)*8):0,cMaxSafe=cMaxRaw>0?Math.pow(2,cBucket/8):0,bp=blaProfile(profile),useBla=Number.isFinite(spanNormal)&&Math.abs(spanNormal)>=1e-280&&refLen>8,wp=workProfile(profile),colorCtx=makeColorCtx(colorIter);
-  const regions=(rects?rects:[{x0:0,y0:0,w,h}]).map(r=>({x0:Math.max(0,r.x0|0),y0:Math.max(0,r.y0|0),w:Math.max(0,Math.min(w-(r.x0|0),r.w|0)),h:Math.max(0,Math.min(h-(r.y0|0),r.h|0))})).filter(r=>r.w>0&&r.h>0),chunks=[];let preferredRows=deepWisdom.stripRows||16;if(deepWisdom.rowMsEMA>0)preferredRows=Math.round(deepWisdom.targetStripMs/deepWisdom.rowMsEMA);for(const r of regions){const rows=Math.max(2,Math.min(Math.max(1,Math.floor(65536/Math.max(1,r.w))),profile.covered?Math.max(4,preferredRows):Math.min(36,preferredRows)));for(let y=r.y0;y<r.y0+r.h;y+=rows)chunks.push({x0:r.x0,y0:y,w:r.w,rows:Math.min(rows,r.y0+r.h-y)})}chunks.sort((a,b)=>{const ad=Math.hypot((a.x0+a.w*.5)/w-state.focusX,(a.y0+a.rows*.5)/h-state.focusY),bd=Math.hypot((b.x0+b.w*.5)/w-state.focusX,(b.y0+b.rows*.5)/h-state.focusY);return ad-bd});
-  const totalPixels=regions.reduce((a,r)=>a+r.w*r.h,0),verifyJobs=profile.covered?8:3;
-  const runner={token,cancelled:false,chunkIndex:0,donePixels:0,totalPixels,failed:false,finishing:false,simd:true,blaUsed:false,kernelMs:0,verifyMs:0,blaBuildMs:0,sumIter:0,blackCount:0,badCount:0,blaSteps:0,ptbSteps:0,rebases:0,interior:0,unresolved:0,repaired:0,verifiedBuckets:new Set(),
-    fail(err){if(this.failed||this.cancelled)return;this.failed=true;deepPool.failed=true;destroyDeepPool();if(token===state.token)onFallback()},
-    nextChunk(){return this.chunkIndex<chunks.length?chunks[this.chunkIndex++]:null},
-    dispatch(worker){
-      if(this.cancelled||this.failed||token!==state.token)return false;const ch=this.nextChunk();if(!ch){this.maybeFinish();return false}
-      const jobId=token+':'+(++deepPool.serial),vb=Math.min(verifyJobs-1,Math.max(0,Math.floor((ch.y0+ch.rows*.5)*verifyJobs/Math.max(1,h)))),verifySamples=useBla&&!this.verifiedBuckets.has(vb)?(this.verifiedBuckets.add(vb),profile.covered?4:3):0,blaKey=refKey+':'+ref.version+':'+refLen+':'+cBucket+':e'+bp.exp,safeBlaKey=refKey+':'+ref.version+':'+refLen+':'+cBucket+':e'+bp.safeExp;
-      const msg={type:'render',jobId,refKey,refLen,w,h,x0:ch.x0,rectW:ch.w,y0:ch.y0,rows:ch.rows,iter,colorIter,covered:profile.covered,spanMant:sb.mant,spanBucket:sb.bucket,offR:off[0],offI:off[1],offBucket:off[2],cx:w*.5,cy:h*.5,skip:series.skip,Ar:series.Ar,Ai:series.Ai,Ab:series.Ab,Br:series.Br,Bi:series.Bi,Bb:series.Bb,shift:state.shift,cycle:state.cycle,palette:state.palette,useBla,blaEps:bp.eps,blaKey,safeBlaEps:Math.pow(2,-bp.safeExp),safeBlaKey,cMax:cMaxSafe,spanNormal,offRn,offIn,baseCr,baseCi,maxBlaSteps:wp.bla,maxPtbSteps:wp.ptb,verifySamples,verifyDelta:profile.covered?8:64},transfer=[];
-      attachReference(worker,msg,ref,refLen,refKey,transfer);if(worker._recycle){msg.fieldBuffer=worker._recycle.field;msg.iterationBuffer=worker._recycle.iterations;msg.classBuffer=worker._recycle.classes;transfer.push(msg.fieldBuffer,msg.iterationBuffer,msg.classBuffer);worker._recycle=null}worker._busy=true;worker._job={type:'render',runner:this,jobId,x0:ch.x0,y0:ch.y0,rectW:ch.w,rows:ch.rows,pixels:ch.w*ch.rows,started:performance.now()};try{worker.postMessage(msg,transfer)}catch(e){worker._busy=false;worker._job=null;this.fail(e);return false}return true
-    },
-    onResult(worker,d,job){
-      const elapsed=Math.max(.05,performance.now()-job.started),mpr=elapsed/Math.max(1,job.rows);deepWisdom.rowMsEMA=deepWisdom.rowMsEMA?deepWisdom.rowMsEMA*.86+mpr*.14:mpr;deepWisdom.stripRows=Math.round((deepWisdom.stripRows||12)*.75+Math.max(3,Math.min(128,Math.round(deepWisdom.targetStripMs/Math.max(.001,deepWisdom.rowMsEMA))))*.25);
-      if(this.cancelled||this.failed||token!==state.token)return;if(!d||d.jobId!==job.jobId)return;if(d.error){this.fail(new Error(d.error));return}
-      this.simd=this.simd&&!!d.simd;this.blaUsed=this.blaUsed||!!d.bla;this.kernelMs+=d.kernelMs||0;this.verifyMs+=d.verifyMs||0;this.blaBuildMs+=d.blaBuildMs||0;this.sumIter+=d.sumIter||0;this.blackCount+=d.blackCount||0;this.badCount+=(d.bad||[]).length;const st=d.stats||{};this.blaSteps+=st.blaSteps||0;this.ptbSteps+=st.ptbSteps||0;this.rebases+=st.rebases||0;this.interior+=st.interior||0;this.unresolved+=st.unresolved||0;this.repaired+=d.repaired||0;
-      const rw=d.rectW||job.rectW,rx=d.x0==null?job.x0:d.x0,sf=d.field?new Float32Array(d.field):null,it=d.iterations?new Uint32Array(d.iterations):null,cl=d.classes?new Uint8Array(d.classes):null,ro=sf&&cl?colorizeField({smooth:sf,classes:cl,iter:colorIter}):new Uint8ClampedArray(d.out);for(let yy=0;yy<d.rows;yy++){const dst=(d.y0+yy)*w+rx;out.set(ro.subarray(yy*rw*4,(yy+1)*rw*4),dst*4);if(sf)field.smooth.set(sf.subarray(yy*rw,(yy+1)*rw),dst);if(it)field.iterations.set(it.subarray(yy*rw,(yy+1)*rw),dst);if(cl)field.classes.set(cl.subarray(yy*rw,(yy+1)*rw),dst)}presentPartialStripe(ro,rx,d.y0,rw,d.rows,w,h,snap);if(d.field&&d.iterations&&d.classes)worker._recycle={field:d.field,iterations:d.iterations,classes:d.classes};if(d.bad)for(const local of d.bad){const gx=rx+(local%rw),gy=d.y0+((local/rw)|0);bad.push(gy*w+gx)}this.donePixels+=job.pixels;if(profile.covered&&workers.length<deepPool.maxWorkers&&memoryLedger().managedBytes+24*1048576<rendererMemoryBudget()&&this.totalPixels-this.donePixels>job.pixels*4&&elapsed>deepWisdom.targetStripMs){const added=addDeepWorker();deepWisdom.workerCount=workers.length;deepWisdom.ready=true;kickDeepWorker(added)}this.maybeFinish()
-    },
-    maybeFinish(){
-      if(this.cancelled||this.failed||token!==state.token||this.finishing||this.donePixels<this.totalPixels)return;this.finishing=true;if(deepPool.current===this)deepPool.current=null;deepPool.activeToken=0;const px=Math.max(1,this.totalPixels),kmpp=this.kernelMs/px;deepTelemetry.frames++;deepTelemetry.kernelMPP=deepTelemetry.kernelMPP?deepTelemetry.kernelMPP*.78+kmpp*.22:kmpp;deepTelemetry.meanIter=this.sumIter/px;deepTelemetry.blackRatio=this.blackCount/px;deepTelemetry.badRatio=this.badCount/px;deepTelemetry.blaBuildEMA=deepTelemetry.blaBuildEMA?deepTelemetry.blaBuildEMA*.85+this.blaBuildMs*.15:this.blaBuildMs;deepTelemetry.interiorRatio=this.interior/px;deepTelemetry.repairRatio=this.repaired/Math.max(1,regions.length);deepTelemetry.unresolvedRatio=this.unresolved/px;deepTelemetry.blaStepsPerPixel=this.blaSteps/px;deepTelemetry.ptbStepsPerPixel=this.ptbSteps/px;deepTelemetry.rebasePerPixel=this.rebases/px;deepTelemetry.lastKernelMs=this.kernelMs;deepTelemetry.lastVerifyMs=this.verifyMs;deepTelemetry.lastPixels=px;deepTelemetry.refDistance=refC.dist||0;refControl.lastMPP=kmpp;refControl.lastPixels=px;if(refControl.refId!==ref.id){refControl.refId=ref.id;refControl.baseMPP=kmpp}else if((refC.dist||0)<.2)refControl.baseMPP=refControl.baseMPP?refControl.baseMPP*.8+kmpp*.2:kmpp;persistDeepWisdom();
-      const label='WASM '+(this.simd?'SIMD':'scalar')+' ×'+Math.max(1,Math.min(deepWisdom.workerCount,workers.length))+' · '+(this.blaUsed?'BLA e-'+bp.exp+' + ':'')+'rebase'+(this.interior?' · 内部早期終了 '+Math.round(100*this.interior/px)+'%':'')+(this.repaired?' · 局所補修 '+this.repaired:'')+(this.totalPixels<w*h?' · 既存画像再利用 '+Math.round(100*(1-this.totalPixels/(w*h)))+'%':'');
-      const completeField=this.totalPixels===w*h?field:null;if(!bad.length){finishRender(token,t0,profile,snap,w,h,out,label,this.totalPixels,completeField);return}let k=0;const residual=async()=>{if(token!==state.token||this.cancelled)return;const deadline=performance.now()+5;while(k<bad.length&&performance.now()<deadline){const idx=bad[k++],x=idx%w,py=(idx/w)|0,result=await highPrecisionDirectPixelAsync(snap,w,h,iter,x,py,false,()=>token!==state.token||this.cancelled);if(!result)return;const[n,m]=result;putField(field,idx,n,m,n<iter?FIELD_ESCAPED:FIELD_UNKNOWN);putDeepPixel(out,w,iter,colorIter,x,py,n,m,colorCtx)}if(k<bad.length)requestAnimationFrame(residual);else finishRender(token,t0,profile,snap,w,h,out,label+' · 残差 '+bad.length,this.totalPixels,completeField)};requestAnimationFrame(residual)
-    }
-  };
-  deepPool.current=runner;deepPool.activeToken=token;if(totalPixels===0){queueMicrotask(()=>runner.maybeFinish());return true}const active=Math.max(1,Math.min(deepWisdom.ready?deepWisdom.workerCount:Math.min(2,workers.length),workers.length));for(let i=0;i<active;i++)kickDeepWorker(workers[i]);return true
-}
-
-// ── Frame reprojection / world-space detail cache ───────────────────────
-const frameCanvas=document.createElement('canvas'),frameCtx=frameCanvas.getContext('2d',{alpha:false});
+function fmtFixedExact(v){let neg=v<0n;if(neg)v=-v;const maxD=state.bits,scale=10n**BigInt(maxD),q=v*scale>>BigInt(state.bits);let s=q.toString().padStart(maxD+1,'0');s=s.slice(0,-maxD)+'.'+s.slice(-maxD);s=s.replace(/(\.\d*?)0+$/,'$1').replace(/\.$/,'');return(neg?'-':'')+s}
 function snapshot(){return{bits:state.bits,re:state.re,im:state.im,span:state.span}}
-function snapshotToCurrent(s){if(s.bits===state.bits)return s;return{bits:state.bits,re:align(s.re,s.bits,state.bits),im:align(s.im,s.bits,state.bits),span:align(s.span,s.bits,state.bits)}}
-function styleSignature(){return state.palette+':'+state.cycle.toFixed(6)+':'+state.shift.toFixed(5)}
-function commitImage(data,w,h,snap,field=null){
-  frameCanvas.width=w;frameCanvas.height=h;const id=frameCtx.createImageData(w,h);id.data.set(data);frameCtx.putImageData(id,0,0);runtimeMetrics.canvasWrites++;
-  state.frameView=snapshotToCurrent(snap);state.fieldView=field?{field,w,h,snap:state.frameView}:null;invalidateView();
-}
-function presentPartialStripe(data,x,y,w,h,frameW,frameH,snap){if(frameCanvas.width!==frameW||frameCanvas.height!==frameH||!sameSnapshot(state.frameView,snap)){frameCanvas.width=frameW;frameCanvas.height=frameH;frameCtx.fillStyle='#050813';frameCtx.fillRect(0,0,frameW,frameH);state.frameView=snapshotToCurrent(snap);state.fieldView=null}const id=frameCtx.createImageData(w,h);id.data.set(data);frameCtx.putImageData(id,x,y);runtimeMetrics.canvasWrites++;invalidateView(false)}
-function sameSnapshot(a,b){return!!a&&!!b&&a.bits===b.bits&&a.re===b.re&&a.im===b.im&&a.span===b.span}
-function recolorCurrentField(){const fv=state.fieldView;if(!fv||state.dirty||state.rendering||!sameSnapshot(fv.snap,state.frameView))return false;const out=colorizeField(fv.field);commitImage(out,fv.w,fv.h,fv.snap,fv.field);state.lastEngine='フィールド再彩色';state.lastRender=0;recolorCachedDetails();invalidateView();return true}
-const validationJob={active:false,key:''};
-const unknownContinuationJob={active:false,key:''};let unknownContinuationTimer=0;
-function cancelUnknownContinuation(){if(unknownContinuationTimer){clearTimeout(unknownContinuationTimer);unknownContinuationTimer=0}unknownContinuationJob.active=false;state.continuationProgress=0}
-function scheduleUnknownContinuation(delay=120){
-  const fv=state.fieldView;if(state.processMode!=='fine'||state.dirty||state.rendering||!fv||!state.unresolved)return;
-  const key=viewSpecKey(currentViewSpec())+':'+fv.w+'x'+fv.h+':'+fv.field.iter;
-  if(unknownContinuationJob.key===key||unknownContinuationTimer)return;
-  unknownContinuationTimer=setTimeout(()=>{unknownContinuationTimer=0;startUnknownContinuation(key)},delay)
-}
-function startUnknownContinuation(key){
-  const fv=state.fieldView;if(unknownContinuationJob.active||state.dirty||state.rendering||!fv||!sameSnapshot(fv.snap,state.frameView))return;
-  const field=fv.field,ranked=[];for(let i=0;i<field.classes.length;i++){if(field.classes[i]!==FIELD_UNKNOWN)continue;const x=i%fv.w,y=(i/fv.w)|0;let boundary=false;for(let yy=Math.max(0,y-1);yy<=Math.min(fv.h-1,y+1)&&!boundary;yy++)for(let xx=Math.max(0,x-1);xx<=Math.min(fv.w-1,x+1);xx++)if(field.classes[yy*fv.w+xx]===FIELD_ESCAPED){boundary=true;break}if(boundary)ranked.push({i,d:Math.hypot(x/fv.w-state.focusX,y/fv.h-state.focusY)})}if(!ranked.length)return;
-  const deep=deepEngineNeeded(fv.snap,fv.w),cap=Math.min(ranked.length,deep?384:4096);ranked.sort((a,b)=>a.d-b.d);const indices=ranked.slice(0,cap).map(v=>v.i);
-  unknownContinuationJob.active=true;unknownContinuationJob.key=key;const token=state.token,snap=fv.snap,baseIter=field.iter,extendedIter=Math.min(280000,Math.max(baseIter+256,baseIter*2)),cre=fixedNum(snap.re,snap.bits),cim=fixedNum(snap.im,snap.bits),scale=fixedNum(snap.span,snap.bits)/fv.w;let p=0;
-  state.drawState='RESOLVING';state.continuationProgress=0;invalidateStats();
-  async function slice(){
-    if(token!==state.token||state.dirty){unknownContinuationJob.active=false;return}
-    const deadline=performance.now()+7;while(p<indices.length&&performance.now()<deadline){const i=indices[p++],x=i%fv.w,y=(i/fv.w)|0,result=deep?await highPrecisionDirectPixelAsync(snap,fv.w,fv.h,extendedIter,x,y,false,()=>token!==state.token||state.dirty):exportSampleShallow(cre,cim,scale,fv.w,fv.h,extendedIter,x,y);if(!result){unknownContinuationJob.active=false;return}const[n,m]=result;putField(field,i,n,m,n<extendedIter?FIELD_ESCAPED:FIELD_UNKNOWN)}
-    state.continuationProgress=p/indices.length;if(p<indices.length){invalidateStats();requestAnimationFrame(slice);return}
-    state.unresolved=field.classes.reduce((n,c)=>n+(c===FIELD_UNKNOWN),0);unknownContinuationJob.active=false;state.continuationProgress=1;state.drawState='COVERED';commitImage(colorizeField(field),fv.w,fv.h,snap,field);state.lastEngine+=' · 境界 '+indices.length+'点を追加反復';invalidateStats()
-  }
-  requestAnimationFrame(slice)
-}
-function scheduleValidation(delay=350){if(state.processMode!=='validate'||state.dirty||state.rendering)return;scheduleBackground(()=>{if(state.processMode==='validate'&&!state.detailActive&&!unknownContinuationJob.active)startValidation();else if(state.processMode==='validate')scheduleValidation(300)},delay)}
-function startValidation(){
-  const fv=state.fieldView;if(validationJob.active||!fv||state.dirty||state.rendering||!sameSnapshot(fv.snap,state.frameView))return;
-  const key=viewSpecKey(currentViewSpec())+':'+fv.w+'x'+fv.h+':'+fv.field.iter;if(validationJob.key===key)return;
-  validationJob.active=true;validationJob.key=key;
-  const token=state.token,snap=fv.snap,field=fv.field,baseIter=field.iter,extendedIter=Math.min(280000,Math.max(baseIter+256,baseIter*2));let i=0,lastStatus=0;
-  state.drawState='VALIDATING';state.coverage=0;invalidateStats();
-  async function slice(now){
-    if(token!==state.token||state.processMode!=='validate'){validationJob.active=false;return}
-    const deadline=performance.now()+9;
-    while(i<field.classes.length&&performance.now()<deadline){
-      const old=field.classes[i],x=i%fv.w,y=(i/fv.w)|0,limit=old===FIELD_ESCAPED?baseIter:extendedIter;
-      if(fixedAnalyticPixelProven(snap,fv.w,fv.h,x,y)){putField(field,i,limit,0,FIELD_INTERIOR_PROVEN);i++;continue}
-      const result=await highPrecisionDirectPixelAsync(snap,fv.w,fv.h,limit,x,y,true,()=>token!==state.token||state.processMode!=='validate');
-      if(!result){validationJob.active=false;return}
-      const[n,m]=result;if(n<limit)putField(field,i,n,m,FIELD_ESCAPED);else putField(field,i,n,0,FIELD_UNKNOWN);i++
-    }
-    if(now-lastStatus>180){lastStatus=now;state.coverage=i/field.classes.length;invalidateStats()}
-    if(i<field.classes.length){requestAnimationFrame(slice);return}
-    field.iter=extendedIter;state.unresolved=field.classes.reduce((n,c)=>n+(c!==FIELD_ESCAPED&&c!==FIELD_INTERIOR_PROVEN),0);state.drawState=state.unresolved?'VALIDATION_INCOMPLETE':'VALIDATED';state.coverage=1;validationJob.active=false;const out=colorizeField(field);commitImage(out,fv.w,fv.h,snap,field);state.lastEngine='高精度direct照合';invalidateStats()
-  }
-  requestAnimationFrame(slice)
-}
-function drawWorldDetail(entry){
-  if(!entry||!entry.complete||entry.style!==styleSignature()||!entry.canvas)return;if(entry.iter){const rr=entry.iter/Math.max(1,maxIter());if(rr<.82||rr>1.22)return}
-  const re=align(entry.re,entry.bits,state.bits),im=align(entry.im,entry.bits,state.bits),sxv=align(entry.spanX,entry.bits,state.bits),syv=align(entry.spanY,entry.bits,state.bits);
-  const x=canvas.width*.5+fixedRatio(re-state.re,state.span)*canvas.width,y=canvas.height*.5-fixedRatio(im-state.im,state.span)*canvas.width;
-  const dw=Math.abs(fixedRatio(sxv,state.span)*canvas.width),dh=Math.abs(fixedRatio(syv,state.span)*canvas.width);
-  if(!Number.isFinite(x+y+dw+dh)||dw<5||dh<5||x+dw*.5<0||x-dw*.5>canvas.width||y+dh*.5<0||y-dh*.5>canvas.height)return;
-  // Do not magnify a cached tile beyond ~1.7 display pixels per source pixel.
-  if(dw/Math.max(1,entry.canvas.width)>1.7)return;
-  entry.lastUsed=performance.now();
-  ctx.imageSmoothingEnabled=true;try{ctx.imageSmoothingQuality='high'}catch{}
-  ctx.drawImage(entry.canvas,x-dw*.5,y-dh*.5,dw,dh);
-}
-function paintFrame(){
-  if(!state.frameView||!frameCanvas.width)return;
-  runtimeMetrics.canvasWrites++;
-  const fv=state.frameView;
-  const a=fixedRatio(fv.span,state.span);if(!Number.isFinite(a)||a<=0)return;
-  const dx=fixedRatio(fv.re-state.re,state.span)*canvas.width;
-  const dy=-fixedRatio(fv.im-state.im,state.span)*canvas.width;
-  ctx.save();ctx.setTransform(1,0,0,1,0,0);ctx.fillStyle='#050813';ctx.fillRect(0,0,canvas.width,canvas.height);
-  ctx.translate(canvas.width*.5+dx,canvas.height*.5+dy);ctx.scale(a,a);ctx.imageSmoothingEnabled=true;try{ctx.imageSmoothingQuality=state.lastPass===RENDER_PASS.COVERED?'high':'medium'}catch{}
-  const fw=canvas.width,fh=fw*(frameCanvas.height/Math.max(1,frameCanvas.width));ctx.drawImage(frameCanvas,-fw*.5,-fh*.5,fw,fh);ctx.restore();
-  // Only completed, world-validated tiles are composited. Partial tiles remain offscreen.
-  ctx.save();ctx.setTransform(1,0,0,1,0,0);for(const e of DETAIL_TILE_CACHE.values())drawWorldDetail(e);ctx.restore();
-}
-
-function renderBudget(profile,deep){return profile.budgetMs}
-function targetSize(profile,deep){
-  // Resolution is intentionally independent of zoom depth. 10^20, 10^100 and
-  // beyond use the same quality targets as low zoom; only the numerical engine changes.
-  const cssW=Math.max(1,canvas.clientWidth),cssH=Math.max(1,canvas.clientHeight),aspect=cssH/cssW,dpr=Math.max(.25,state.effectiveDpr||1);
-  if(profile.covered)return[canvas.width,canvas.height];
-  let nominal=Math.max(profile.minWidth,cssW*dpr*profile.nominalScale),minW=profile.minWidth,maxW=profile.maxWidth;
-  const measured=renderPerf[deep?'deepMPP':'shallowMPP'];
-  if(deep&&!profile.covered&&measured<=0){nominal=Math.min(nominal,48);minW=32}
-  if(measured>0){
-    const timedW=Math.sqrt(renderBudget(profile,deep)/Math.max(1e-7,measured*aspect));
-    nominal=Math.min(nominal,timedW);minW=deep?32:240
-  }
-  let w=Math.max(minW,Math.min(maxW,Math.round(nominal))),h=Math.max(deep&&!profile.covered?32:96,Math.round(w*aspect));
-  if(h>2200){const sc=2200/h;h=2200;w=Math.round(w*sc)}return[w,h]
-}
-function analyzeDetailTiles(data,w,h,baseMs,deep){
-  const field=state.fieldView&&state.fieldView.w===w&&state.fieldView.h===h?state.fieldView.field:null;if(!field)return[];
-  const leaves=[],minTile=32,rootTile=256;
-  function scoreRect(x0,y0,tw,th){
-    const step=Math.max(1,Math.floor(Math.min(tw,th)/14));let grad=0,edges=0,uncertain=0,samples=0;
-    for(let y=y0;y<y0+th;y+=step)for(let x=x0;x<x0+tw;x+=step){const i=y*w+x,c=field.classes[i],s=field.smooth[i];samples++;uncertain+=(255-(field.confidence?field.confidence[i]:fieldConfidence(c)))/255;if(x+step<x0+tw){const j=i+step,c2=field.classes[j];if((c===FIELD_ESCAPED)!==(c2===FIELD_ESCAPED))edges++;else if(c===FIELD_ESCAPED&&c2===FIELD_ESCAPED)grad+=Math.min(12,Math.abs(s-field.smooth[j]))}if(y+step<y0+th){const j=i+step*w,c2=field.classes[j];if((c===FIELD_ESCAPED)!==(c2===FIELD_ESCAPED))edges++;else if(c===FIELD_ESCAPED&&c2===FIELD_ESCAPED)grad+=Math.min(12,Math.abs(s-field.smooth[j]))}}
-    return edges/Math.max(1,samples)*4.4+grad/Math.max(1,samples*12)*1.5+uncertain/Math.max(1,samples)*.9
-  }
-  function visit(x,y,tw,th){const score=scoreRect(x,y,tw,th);if(score<.055)return;if((tw>minTile||th>minTile)&&score>.11){const aw=Math.max(1,tw>>1),bw=tw-aw,ah=Math.max(1,th>>1),bh=th-ah;visit(x,y,aw,ah);if(bw)visit(x+aw,y,bw,ah);if(bh)visit(x,y+ah,aw,bh);if(bw&&bh)visit(x+aw,y+ah,bw,bh);return}leaves.push({x,y,w:tw,h:th,score,area:tw*th})}
-  for(let y=0;y<h;y+=rootTile)for(let x=0;x<w;x+=rootTile)visit(x,y,Math.min(rootTile,w-x),Math.min(rootTile,h-y));
-  leaves.sort((a,b)=>{const ad=Math.hypot((a.x+a.w*.5)/w-state.focusX,(a.y+a.h*.5)/h-state.focusY),bd=Math.hypot((b.x+b.w*.5)/w-state.focusX,(b.y+b.h*.5)/h-state.focusY);return(b.score+.08/(.08+bd))-(a.score+.08/(.08+ad))});const byteCap=Math.max(0,detailCacheBudget()-detailCacheBytes),baseBudget=renderBudget(RENDER_PROFILE[RENDER_PASS.COVERED],deep),spare=Math.max(0,baseBudget*1.7-baseMs),sampleCap=Math.floor(w*h*Math.min(2.6,spare/Math.max(1,baseMs)));let bytes=0,sampleArea=0,n=0;while(n<leaves.length){const tile=leaves[n],sampleScale=tile.score>=1.15?4:2,costBytes=tile.area*(sampleScale*sampleScale*10+4),costSamples=tile.area*sampleScale*sampleScale;if(bytes+costBytes>byteCap||sampleArea+costSamples>sampleCap)break;bytes+=costBytes;sampleArea+=costSamples;n++}return leaves.slice(0,n)
-}
-function detailGeometry(tile,plan){
-  const s=plan.snap,den=BigInt(2*plan.w),re=s.re+s.span*BigInt(2*tile.x+tile.w-plan.w)/den,im=s.im+s.span*BigInt(plan.h-2*tile.y-tile.h)/den;
-  const spanX=s.span*BigInt(tile.w)/BigInt(plan.w),spanY=s.span*BigInt(tile.h)/BigInt(plan.w);
-  return{bits:s.bits,re,im,spanX,spanY}
-}
-function detailKey(tile,plan,sampleScale){const g=detailGeometry(tile,plan);return [g.bits,g.re,g.im,g.spanX,g.spanY,plan.iter,'aa'+sampleScale,'centered-v23'].join(':')}
-function rendererMemoryBudget(){return(Number(navigator.deviceMemory||8)<=4||matchMedia('(max-width:700px)').matches?96:192)*1048576}
-function wasmBytes(core){try{return core&&core.ex&&core.ex.memory?core.ex.memory.buffer.byteLength:0}catch{return 0}}
-function memoryLedger(includeDetail=true){
-  const screenCanvasBytes=canvas.width*canvas.height*4,frameCanvasBytes=frameCanvas.width*frameCanvas.height*4;
-  const fieldBytes=state.fieldView?state.fieldView.w*state.fieldView.h*10:0;
-  const referenceBytes=(referenceCache.rr?.byteLength||0)+(referenceCache.ri?.byteLength||0);
-  const mainWasmBytes=wasmBytes(wasm)+wasmBytes(deepWasm);
-  // Worker memories are isolated, so browsers do not expose their byteLength.
-  // Account them conservatively: reference copies + kernel scratch/linear memory.
-  const workerEstimateBytes=(shallowWorker?2*1048576:0)+deepPool.workers.length*24*1048576;
-  const renderBytes=state.rendering?(()=>{const size=targetSize(renderProfile(state.lastPass),deepMode),pixels=size[0]*size[1];return pixels*18})():0;
-  const exportBytes=exportJob&&exportJob.active?exportJob.bytes||0:0,activeDetailBytes=activeDetailTiles.reduce((sum,e)=>sum+(e.transientBytes||0),0);
-  const cacheBytes=includeDetail?detailCacheBytes:0;
-  const managedBytes=fieldBytes+referenceBytes+mainWasmBytes+workerEstimateBytes+renderBytes+exportBytes+activeDetailBytes+cacheBytes;
-  const canvasBytes=screenCanvasBytes+frameCanvasBytes;
-  return{managedBytes,logicalBytes:managedBytes+canvasBytes,canvasBytes,screenCanvasBytes,frameCanvasBytes,fieldBytes,referenceBytes,mainWasmBytes,workerEstimateBytes,renderBytes,exportBytes,activeDetailBytes,detailCacheBytes:cacheBytes,budget:rendererMemoryBudget()}
-}
-function detailCacheBudget(){const base=memoryLedger(false).managedBytes,reserve=16*1048576;return Math.max(0,Math.floor(Math.min(rendererMemoryBudget()*.18,rendererMemoryBudget()-base-reserve)))}
-function detailEntryBytes(entry){return entry&&entry.canvas?entry.canvas.width*entry.canvas.height*4+(entry.field?entry.field.classes.length*10:0):0}
-function detailDistance(entry){try{const re=align(entry.re,entry.bits,state.bits),im=align(entry.im,entry.bits,state.bits);return Math.hypot(fixedRatio(re-state.re,state.span),fixedRatio(im-state.im,state.span))}catch{return Infinity}}
-function trimDetailCache(){const budget=detailCacheBudget();while(detailCacheBytes>budget&&DETAIL_TILE_CACHE.size){let victim=null,rank=-Infinity;const now=performance.now();for(const [key,entry]of DETAIL_TILE_CACHE){const age=Math.max(0,now-(entry.lastUsed||0))/60000,distance=detailDistance(entry),score=(Number.isFinite(distance)?distance:1000)*4+age;if(score>rank){rank=score;victim=[key,entry]}}if(!victim)break;DETAIL_TILE_CACHE.delete(victim[0]);detailCacheBytes=Math.max(0,detailCacheBytes-detailEntryBytes(victim[1]))}}
-function linearChannel(v){v/=255;return v<=.04045?v/12.92:Math.pow((v+.055)/1.055,2.4)}
-function srgbChannel(v){v=Math.max(0,Math.min(1,v));return Math.round(255*(v<=.0031308?12.92*v:1.055*Math.pow(v,1/2.4)-.055))}
-function resolveSubsampleField(field,w,h,scale=2){const hi=colorizeField(field),c=document.createElement('canvas');c.width=w;c.height=h;const cc=c.getContext('2d',{alpha:false}),id=cc.createImageData(w,h),out=id.data,samples=scale*scale;for(let y=0;y<h;y++)for(let x=0;x<w;x++){let r=0,g=0,b=0;for(let sy=0;sy<scale;sy++)for(let sx=0;sx<scale;sx++){const i=(((y*scale+sy)*w*scale)+(x*scale+sx))*4;r+=linearChannel(hi[i]);g+=linearChannel(hi[i+1]);b+=linearChannel(hi[i+2])}const oi=(y*w+x)*4;out[oi]=srgbChannel(r/samples);out[oi+1]=srgbChannel(g/samples);out[oi+2]=srgbChannel(b/samples);out[oi+3]=255}cc.putImageData(id,0,0);return c}
-function recolorDetailEntry(entry){if(!entry||!entry.field)return;entry.canvas=resolveSubsampleField(entry.field,entry.baseW,entry.baseH,entry.sampleScale||2);entry.style=styleSignature()}
-function recolorCachedDetails(){cancelDetailRefinement(true);for(const entry of DETAIL_TILE_CACHE.values())recolorDetailEntry(entry)}
-function makeDetailTask(tile,plan){
-  const sampleScale=tile.score>=1.15?4:2,key=detailKey(tile,plan,sampleScale),cached=DETAIL_TILE_CACHE.get(key);if(cached){DETAIL_TILE_CACHE.delete(key);DETAIL_TILE_CACHE.set(key,cached);cached.lastUsed=performance.now();if(cached.style!==styleSignature())recolorDetailEntry(cached);return{cached:true,entry:cached}}
-  const c=document.createElement('canvas');c.width=Math.max(2,tile.w*sampleScale);c.height=Math.max(2,tile.h*sampleScale);const dc=c.getContext('2d',{alpha:false});
-  dc.imageSmoothingEnabled=true;try{dc.imageSmoothingQuality='high'}catch{};dc.drawImage(frameCanvas,tile.x,tile.y,tile.w,tile.h,0,0,c.width,c.height);
-  const g=detailGeometry(tile,plan),entry={...g,canvas:c,field:null,baseW:tile.w,baseH:tile.h,sampleScale,style:styleSignature(),key,score:tile.score,iter:plan.iter,complete:false,lastUsed:performance.now(),transientBytes:c.width*c.height*18};
-  const task={tile,canvas:c,ctx:dc,field:makeField(c.width*c.height,plan.iter),entry,phases:0,plan};activeDetailTiles.push(entry);return task
-}
-function validateDetailTask(task){
-  const plan=task&&task.plan,t=task&&task.tile,base=plan&&plan.baseData;if(!plan||!t||!base)return false;
-  let samples=0,blackMismatch=0,rgbDiff=0,colorSamples=0;const sampleScale=task.entry.sampleScale||2,step=Math.max(3,Math.floor(Math.min(t.w,t.h)/7)),pix=task.ctx.getImageData(0,0,task.canvas.width,task.canvas.height).data;
-  for(let by=t.y+1;by<t.y+t.h-1;by+=step)for(let bx=t.x+1;bx<t.x+t.w-1;bx+=step){
-    const bi=(by*plan.w+bx)*4,lx=Math.min(task.canvas.width-1,Math.max(0,sampleScale*(bx-t.x)+(sampleScale>>1))),ly=Math.min(task.canvas.height-1,Math.max(0,sampleScale*(by-t.y)+(sampleScale>>1))),hi=(ly*task.canvas.width+lx)*4;
-    const bb=(base[bi]|base[bi+1]|base[bi+2])===0,hb=(pix[hi]|pix[hi+1]|pix[hi+2])===0;samples++;if(bb!==hb)blackMismatch++;else if(!bb){rgbDiff+=Math.abs(base[bi]-pix[hi])+Math.abs(base[bi+1]-pix[hi+1])+Math.abs(base[bi+2]-pix[hi+2]);colorSamples++}
-  }
-  if(samples<4)return false;const classRate=blackMismatch/samples,meanDiff=colorSamples?rgbDiff/(3*colorSamples):0;return classRate<=.035&&meanDiff<=48
-}
-function cacheDetailTask(task){
-  if(!task||task.cached)return;const i=activeDetailTiles.indexOf(task.entry);if(i>=0)activeDetailTiles.splice(i,1);
-  if(!validateDetailTask(task))return;fillFieldConfidence(task.field);task.entry.field=task.field;task.entry.canvas=resolveSubsampleField(task.field,task.tile.w,task.tile.h,task.entry.sampleScale);task.entry.style=styleSignature();task.entry.complete=true;task.entry.lastUsed=performance.now();task.entry.transientBytes=0;const old=DETAIL_TILE_CACHE.get(task.entry.key);if(old)detailCacheBytes-=detailEntryBytes(old);DETAIL_TILE_CACHE.delete(task.entry.key);DETAIL_TILE_CACHE.set(task.entry.key,task.entry);detailCacheBytes+=detailEntryBytes(task.entry);
-  trimDetailCache()
-}
-function phaseRect(task,phase){
-  const t=task.tile,scale=task.entry.sampleScale,left=(phase%scale)*t.w,top=((phase/scale)|0)*t.h;
-  return{x0:t.x*scale+left,y0:t.y*scale+top,rw:t.w,rows:t.h,dx:left,dy:top}
-}
-function prepareDeepTileContext(plan,iter,sampleScale,done){
-  const cacheKey='i'+iter+':s'+sampleScale;if(plan.deepCtx&&plan.deepCtx[cacheKey]){done(plan.deepCtx[cacheKey]);return}if(!plan.deepCtx)plan.deepCtx={};
-  const snap=plan.snap,refC=chooseReference(snap),W=plan.w*sampleScale,H=plan.h*sampleScale,refX=W*.5-.5+fixedRatio(refC.re-snap.re,snap.span)*W,refY=H*.5-.5-fixedRatio(refC.im-snap.im,snap.span)*W;
-  const cornerR=Math.max(Math.hypot(refX,refY),Math.hypot(W-refX,refY),Math.hypot(refX,H-refY),Math.hypot(W-refX,H-refY))/Math.max(1,W),logMaxDc=log2FixedAt(snap.span,snap.bits)+Math.log2(Math.max(1e-300,cornerR));
-  buildReferenceAt(snap.bits,refC.re,refC.im,iter,state.token,(ref,refLen)=>{
-    if(plan.gen!==state.detailGeneration)return;const series=computeSeries(ref,refLen,logMaxDc),centered=pixelCenteredOffset(snap,refC,W),sb=spanMantBucket(snap.span,snap.bits),off=fixedComplexScaled(centered.r,centered.i,snap.bits),spanNormal=fixedNum(snap.span,snap.bits),offRn=fixedNum(centered.r,snap.bits),offIn=fixedNum(centered.i,snap.bits);
-    const cMaxRaw=Math.hypot(offRn,offIn)+Math.abs(spanNormal)*Math.hypot(.5,H/(2*Math.max(1,W))),cBucket=cMaxRaw>0&&Number.isFinite(cMaxRaw)?Math.ceil(Math.log2(cMaxRaw)*8):0,cMaxSafe=cMaxRaw>0?Math.pow(2,cBucket/8):0;
-    const ctx={snap,refC,ref,refLen,series,sb,off,spanNormal,offRn,offIn,cBucket,cMaxSafe,W,H,iter};plan.deepCtx[cacheKey]=ctx;done(ctx)
-  })
-}
-function renderGuardedDeepDetailRect(task,phase,iter,done){
-  const plan=task.plan,r=phaseRect(task,phase),W=plan.w*task.entry.sampleScale,H=plan.h*task.entry.sampleScale,snap=plan.snap;let yy=0;
-  async function slice(){if(plan.gen!==state.detailGeneration){done(false);return}const deadline=performance.now()+6;while(yy<r.rows&&performance.now()<deadline){const gy=r.y0+yy;for(let xx=0;xx<r.rw;xx++){const gx=r.x0+xx,result=await highPrecisionDirectPixelAsync(snap,W,H,iter,gx,gy,true,()=>plan.gen!==state.detailGeneration);if(!result){done(false);return}const[n,m]=result,fi=(r.dy+yy)*task.canvas.width+r.dx+xx;putField(task.field,fi,n,m,n<iter?FIELD_ESCAPED:FIELD_UNKNOWN)}yy++}if(yy<r.rows){requestAnimationFrame(slice);return}const stripe=makeField(r.rw*r.rows,iter);for(let y=0;y<r.rows;y++){const src=(r.dy+y)*task.canvas.width+r.dx,dst=y*r.rw;stripe.smooth.set(task.field.smooth.subarray(src,src+r.rw),dst);stripe.iterations.set(task.field.iterations.subarray(src,src+r.rw),dst);stripe.classes.set(task.field.classes.subarray(src,src+r.rw),dst)}const id=task.ctx.createImageData(r.rw,r.rows);id.data.set(colorizeField(stripe));task.ctx.putImageData(id,r.dx,r.dy);task.phases|=(1<<phase);invalidateView(false);done(true)}
-  requestAnimationFrame(slice)
-}
-function sendDeepDetailRect(task,phase,iter,colorIter,done){
-  const plan=task.plan,gen=plan.gen;if(gen!==state.detailGeneration){done(false);return}if(state.processMode==='validate'||task.tile.score>1.35){renderGuardedDeepDetailRect(task,phase,iter,done);return}if(!ensureDeepPool()){done(false);return}
-  prepareDeepTileContext(plan,iter,task.entry.sampleScale,dc=>{
-    if(gen!==state.detailGeneration){done(false);return}const worker=deepPool.workers.find(w=>!w._busy);if(!worker){scheduleBackground(()=>sendDeepDetailRect(task,phase,iter,colorIter,done),18);return}
-    const r=phaseRect(task,phase),ref=dc.ref,refKey=String(ref.id),bpExp=32,useBla=Number.isFinite(dc.spanNormal)&&Math.abs(dc.spanNormal)>=1e-280&&dc.refLen>8,blaEps=Math.pow(2,-bpExp),blaKey=refKey+':'+ref.version+':'+dc.refLen+':'+dc.cBucket+':e'+bpExp;
-    const jobId='detail:'+gen+':'+Date.now()+':'+Math.random(),msg={type:'render',jobId,refKey,refLen:dc.refLen,w:dc.W,h:dc.H,x0:r.x0,y0:r.y0,rectW:r.rw,rows:r.rows,iter,colorIter,spanMant:dc.sb.mant,spanBucket:dc.sb.bucket,offR:dc.off[0],offI:dc.off[1],offBucket:dc.off[2],cx:dc.W*.5,cy:dc.H*.5,skip:dc.series.skip,Ar:dc.series.Ar,Ai:dc.series.Ai,Ab:dc.series.Ab,Br:dc.series.Br,Bi:dc.series.Bi,Bb:dc.series.Bb,shift:state.shift,cycle:state.cycle,palette:state.palette,useBla,blaEps,blaKey,cMax:dc.cMaxSafe,spanNormal:dc.spanNormal,offRn:dc.offRn,offIn:dc.offIn,baseCr:fixedNum(dc.refC.re,dc.snap.bits),baseCi:fixedNum(dc.refC.im,dc.snap.bits),maxBlaSteps:0,maxPtbSteps:0,verifySamples:3,verifyDelta:6,safeBlaEps:Math.pow(2,-48),safeBlaKey:blaKey+':safe48'},transfer=[];
-    let start=worker._refKey===refKey?worker._refLoaded:0;start=Math.max(0,Math.min(start,dc.refLen+1));if(start<dc.refLen+1){const rr=ref.rr.slice(start,dc.refLen+1),ri=ref.ri.slice(start,dc.refLen+1);msg.rr=rr.buffer;msg.ri=ri.buffer;msg.rrStart=start;transfer.push(rr.buffer,ri.buffer);worker._refKey=refKey;worker._refLoaded=dc.refLen+1}
-    const runner={token:state.token,cancelled:false,fail(){done(false)},onResult(w,d){if(gen!==state.detailGeneration||!d||d.error){done(false);return}const sf=d.field?new Float32Array(d.field):null,it=d.iterations?new Uint32Array(d.iterations):null,cl=d.classes?new Uint8Array(d.classes):null,arr=sf&&cl?colorizeField({smooth:sf,classes:cl,iter:colorIter}):new Uint8ClampedArray(d.out),id=task.ctx.createImageData(r.rw,r.rows);id.data.set(arr);task.ctx.putImageData(id,r.dx,r.dy);if(sf&&it&&cl)for(let yy=0;yy<r.rows;yy++){const dst=(r.dy+yy)*task.canvas.width+r.dx;task.field.smooth.set(sf.subarray(yy*r.rw,(yy+1)*r.rw),dst);task.field.iterations.set(it.subarray(yy*r.rw,(yy+1)*r.rw),dst);task.field.classes.set(cl.subarray(yy*r.rw,(yy+1)*r.rw),dst)}if(d.field&&d.iterations&&d.classes)w._recycle={field:d.field,iterations:d.iterations,classes:d.classes};task.phases|=(1<<phase);task.entry.canvas=task.canvas;invalidateView(false);done(true)}};
-    if(worker._recycle){msg.fieldBuffer=worker._recycle.field;msg.iterationBuffer=worker._recycle.iterations;msg.classBuffer=worker._recycle.classes;transfer.push(msg.fieldBuffer,msg.iterationBuffer,msg.classBuffer);worker._recycle=null}worker._busy=true;worker._job={type:'render',runner,jobId,y0:r.y0,rows:r.rows,started:performance.now()};try{worker.postMessage(msg,transfer)}catch(e){worker._busy=false;worker._job=null;done(false)}
-  })
-}
-function renderShallowDetailRect(task,phase,done){
-  const plan=task.plan,r=phaseRect(task,phase),sampleScale=task.entry.sampleScale,W=plan.w*sampleScale,H=plan.h*sampleScale,iter=plan.iter,snap=plan.snap,sp=fixedNum(snap.span,snap.bits),cre=fixedNum(snap.re,snap.bits),cim=fixedNum(snap.im,snap.bits),scale=sp/W,colorCtx=makeColorCtx(iter),out=new Uint8ClampedArray(r.rw*r.rows*4);let yy=0;
-  function inBulbs(cr,ci){const y2=ci*ci,x=cr-.25,q=x*x+y2;if(q*(q+x)<=.25*y2)return true;const x2=cr+1;return x2*x2+y2<=.0625}
-  function slice(){if(plan.gen!==state.detailGeneration){done(false);return}const deadline=performance.now()+5;while(yy<r.rows&&performance.now()<deadline){const gy=r.y0+yy,ci=cim+(H*.5-gy-.5)*scale;let oi=yy*r.rw*4;for(let xx=0;xx<r.rw;xx++){const gx=r.x0+xx,cr=cre+(gx+.5-W*.5)*scale;let zr=0,zi=0,zr2=0,zi2=0,n=0,inside=inBulbs(cr,ci);if(inside)n=iter;else while(n<iter&&zr2+zi2<=4){zi=(zr+zr)*zi+ci;zr=zr2-zi2+cr;zr2=zr*zr;zi2=zi*zi;n++}const m=n<iter?Math.max(4.0000001,zr2+zi2):0,fi=(r.dy+yy)*task.canvas.width+r.dx+xx;putField(task.field,fi,n,m,n<iter?FIELD_ESCAPED:(inside?FIELD_INTERIOR_LIKELY:FIELD_UNKNOWN));if(n>=iter){out[oi]=out[oi+1]=out[oi+2]=0;out[oi+3]=255}else putFastColor(out,oi,n,m,iter,colorCtx);oi+=4}yy++}if(yy<r.rows)requestAnimationFrame(slice);else{const id=task.ctx.createImageData(r.rw,r.rows),data=id.data;data.set(out);task.ctx.putImageData(id,r.dx,r.dy);task.phases|=(1<<phase);invalidateView(false);done(true)}}requestAnimationFrame(slice)
-}
-function pumpDetailRefinement(){
-  const plan=detailPlan;if(!plan||plan.gen!==state.detailGeneration||!state.hq){state.detailActive=false;return}if(state.rendering||unknownContinuationJob.active||performance.now()-state.lastInteraction<720){scheduleBackground(pumpDetailRefinement,90);return}
-  while(plan.index<plan.tasks.length&&plan.tasks[plan.index].cached)plan.index++;
-  if(plan.index>=plan.tasks.length){state.detailActive=false;state.detailDone=plan.tasks.length;state.drawState='REFINED';updateStats();scheduleValidation();return}
-  const task=plan.tasks[plan.index],phase=task.nextPhase||0,cb=ok=>{if(!ok){const i=activeDetailTiles.indexOf(task.entry);if(i>=0)activeDetailTiles.splice(i,1);plan.index++;scheduleBackground(pumpDetailRefinement,10);return}task.nextPhase=phase+1;if(task.nextPhase>=task.entry.sampleScale*task.entry.sampleScale){cacheDetailTask(task);plan.index++}state.detailDone=plan.tasks.reduce((n,t)=>n+(t.cached||t.entry.complete?1:0),0);updateStats();scheduleBackground(pumpDetailRefinement,0)};
-  if(plan.deep)sendDeepDetailRect(task,phase,plan.iter,plan.iter,cb);else renderShallowDetailRect(task,phase,cb)
-}
-
-// ── Idle-only adaptive detail refinement ────────────────────────────────
-function scheduleDetailRefinement(data,w,h,snap,iter,baseMs,deep){
-  if(!state.hq)return;cancelDetailRefinement(true);const gen=state.detailGeneration,tiles=analyzeDetailTiles(data,w,h,baseMs,deep);if(!tiles.length){state.drawState='REFINED';invalidateStats();scheduleValidation();return}
-  const plan={gen,snap,w,h,iter,deep,tiles,tasks:[],index:0,deepCtx:null,baseData:data};for(const t of tiles)plan.tasks.push(makeDetailTask(t,plan));detailPlan=plan;state.detailActive=true;state.drawState='REFINING';state.detailQueued=plan.tasks.length;state.detailDone=plan.tasks.filter(t=>t.cached).length;scheduleBackground(pumpDetailRefinement,160)
-}
-
-function finishRender(token,t0,profile,snap,w,h,out,engine,computedPixels=w*h,field=null){
-  if(token!==state.token)return;const elapsed=Math.max(.1,performance.now()-t0),deep=deepEngineNeeded(snap,Math.max(1,canvas.width));
-  // Reproject-only frames must not poison performance estimates with near-zero work.
-  if(computedPixels>Math.max(512,w*h*.01)){const mpp=elapsed/computedPixels,key=deep?'deepMPP':'shallowMPP';renderPerf[key]=renderPerf[key]?renderPerf[key]*.72+mpp*.28:mpp}
-  if(field){fillFieldConfidence(field);out=colorizeField(field)}commitImage(out,w,h,snap,field);state.rendering=false;state.lastRender=elapsed;state.lastPass=profile.id;state.dirty=false;state.lastEngine=engine;state.lastFrameDone=performance.now();state.coverage=Math.min(1,w*h/Math.max(1,canvas.width*canvas.height));state.drawState=profile.covered&&state.coverage>=.999?'COVERED':'PREVIEW';state.unresolved=field?field.classes.reduce((n,c)=>n+(c===FIELD_UNKNOWN),0):0;flushPendingPrecision();
-  if(!profile.covered&&adaptStandardDeepBudget(deep)){updateStats();return}
-  if(profile.covered&&state.unresolved)scheduleUnknownContinuation();
-  if(profile.covered&&state.hq){const gen=state.detailGeneration;const schedule=()=>{if(gen!==state.detailGeneration||state.rendering)return;if(unknownContinuationJob.active||unknownContinuationTimer){scheduleBackground(schedule,90);return}const fv=state.fieldView,base=fv&&sameSnapshot(fv.snap,snap)?colorizeField(fv.field):out;scheduleDetailRefinement(base,w,h,snap,fv?fv.field.iter:iterationPlan(profile,deep).colorIter,elapsed,deep)};scheduleIdle(schedule,350);clearPanReuse()}
-  if(profile.covered&&state.processMode==='validate')scheduleValidation();
-  updateStats();
-}
-
-// ── Shallow renderers ───────────────────────────────────────────────────
-function renderShallowReuse(profile,snap,w,h,iter,token,t0,reuse){
-  const out=reuse.out,colorCtx=makeColorCtx(iter),sp=fixedNum(snap.span,snap.bits),cre=fixedNum(snap.re,snap.bits),cim=fixedNum(snap.im,snap.bits),scale=sp/w,rects=reuse.rects;let ri=0,yy=0;
-  function inBulbs(cr,ci){const y2=ci*ci,x=cr-.25,qq=x*x+y2;if(qq*(qq+x)<=.25*y2)return true;const x2=cr+1;return x2*x2+y2<=.0625}
-  function slice(){if(token!==state.token)return;const deadline=performance.now()+7;while(ri<rects.length&&performance.now()<deadline){const r=rects[ri];while(yy<r.h&&performance.now()<deadline){const gy=r.y0+yy,ci=cim+(h*.5-gy-.5)*scale;for(let xx=0;xx<r.w;xx++){const gx=r.x0+xx,cr=cre+(gx+.5-w*.5)*scale;let zr=0,zi=0,zr2=0,zi2=0,n=0;if(inBulbs(cr,ci))n=iter;else while(n<iter&&zr2+zi2<=4){zi=(zr+zr)*zi+ci;zr=zr2-zi2+cr;zr2=zr*zr;zi2=zi*zi;n++}const oi=(gy*w+gx)*4;if(n>=iter){out[oi]=out[oi+1]=out[oi+2]=0;out[oi+3]=255}else putFastColor(out,oi,n,Math.max(4.0000001,zr2+zi2),iter,colorCtx)}yy++}if(yy>=r.h){ri++;yy=0}}
-    if(ri<rects.length)requestAnimationFrame(slice);else finishRender(token,t0,profile,snap,w,h,out,'JavaScript f64 · 既存画像再利用 '+Math.round(100*reuse.reusedPixels/(w*h))+'%',reuse.exposedPixels)
-  }requestAnimationFrame(slice)
-}
-function renderWasmMain(profile,snap,w,h,iter,token,t0){
-  const out=new Uint8ClampedArray(w*h*4),field=makeField(w*h,iter),colorCtx=makeColorCtx(iter);
-  const cre=fixedNum(snap.re,snap.bits),cim=fixedNum(snap.im,snap.bits),sp=fixedNum(snap.span,snap.bits),scale=sp/w;
-  function proven(cr,ci){const y2=ci*ci,x=cr-.25,q0=x*x+y2;if(q0*(q0+x)<=.25*y2)return true;const x2=cr+1;return x2*x2+y2<=.0625}
-  let y=0;const counts=wasm.counts(),mags=wasm.mags();
-  function slice(){
-    if(token!==state.token)return;const deadline=performance.now()+(profile.covered?11:8);
-    while(y<h&&performance.now()<deadline){
-      const rows=Math.min(24,h-y),y0=y,npx=wasm.ex.render_rows(cre+scale*.5,cim-scale*.5,sp,w,h,y,rows,iter);let oi=y*w*4;
-      for(let i=0;i<npx;i++){
-        const n=counts[i],m=mags[i],px=i%w,py=y0+((i/w)|0);
-        const cr=cre+(px+.5-w*.5)*scale,ci=cim+(h*.5-py-.5)*scale,kind=n<iter?FIELD_ESCAPED:(proven(cr,ci)?FIELD_INTERIOR_LIKELY:FIELD_UNKNOWN);putField(field,py*w+px,n,m,kind);
-        if(n>=iter){out[oi++]=0;out[oi++]=0;out[oi++]=0;out[oi++]=255}
-        else{
-          putFastColor(out,oi,n,Math.max(4.0000001,m),iter,colorCtx);oi+=4;
-        }
-      }y+=rows;
-    }
-    if(y<h)requestAnimationFrame(slice);else finishRender(token,t0,profile,snap,w,h,out,'WebAssembly f64',w*h,field);
-  }requestAnimationFrame(slice);
-}
-function renderWasm(profile,snap,w,h,iter,token,t0){
-  if(!ensureShallowWorker()||shallowWorkerBusy){renderWasmMain(profile,snap,w,h,iter,token,t0);return}
-  const worker=shallowWorker,out=new Uint8ClampedArray(w*h*4),field=makeField(w*h,iter),cre=fixedNum(snap.re,snap.bits),cim=fixedNum(snap.im,snap.bits),sp=fixedNum(snap.span,snap.bits),jobId='shallow:'+token+':'+Date.now(),rowsPerChunk=Math.min(h,Math.max(4,Math.floor(32768/Math.max(1,w)))),chunks=[];for(let y=0;y<h;y+=rowsPerChunk)chunks.push({y,rows:Math.min(rowsPerChunk,h-y)});chunks.sort((a,b)=>Math.abs((a.y+a.rows*.5)/h-state.focusY)-Math.abs((b.y+b.rows*.5)/h-state.focusY));let next=0;shallowWorkerBusy=true;
-  const dispatch=()=>{if(token!==state.token){shallowWorkerBusy=false;return}if(next>=chunks.length){shallowWorkerBusy=false;finishRender(token,t0,profile,snap,w,h,out,'WebAssembly '+(wasm.simd?'SIMD':'scalar')+' Worker',w*h,field);return}const chunk=chunks[next++],msg={type:'render',jobId,cre,cim,sp,w,h,y:chunk.y,rows:chunk.rows,iter},transfer=[];if(shallowRecycle){msg.fieldBuffer=shallowRecycle.field;msg.iterationBuffer=shallowRecycle.iterations;msg.classBuffer=shallowRecycle.classes;transfer.push(msg.fieldBuffer,msg.iterationBuffer,msg.classBuffer);shallowRecycle=null}worker.postMessage(msg,transfer)};
-  worker.onmessage=e=>{const d=e.data;if(!d||d.type==='ready')return;if(d.jobId!==jobId)return;if(d.error){shallowWorkerBusy=false;renderWasmMain(profile,snap,w,h,iter,token,t0);return}const sf=new Float32Array(d.field),it=new Uint32Array(d.iterations),cl=new Uint8Array(d.classes);if(token!==state.token){shallowRecycle={field:d.field,iterations:d.iterations,classes:d.classes};shallowWorkerBusy=false;return}const stripe=colorizeField({smooth:sf,classes:cl,iter}),dst=d.y*w;field.smooth.set(sf,dst);field.iterations.set(it,dst);field.classes.set(cl,dst);out.set(stripe,dst*4);presentPartialStripe(stripe,0,d.y,w,d.rows,w,h,snap);shallowRecycle={field:d.field,iterations:d.iterations,classes:d.classes};dispatch()};worker.onerror=()=>{shallowWorkerBusy=false;destroyShallowWorker();if(token===state.token)renderWasmMain(profile,snap,w,h,iter,token,t0)};dispatch()
-}
-function renderJsDouble(profile,snap,w,h,iter,token,t0){
-  const out=new Uint8ClampedArray(w*h*4),field=makeField(w*h,iter),colorCtx=makeColorCtx(iter),sp=fixedNum(snap.span,snap.bits),cre=fixedNum(snap.re,snap.bits),cim=fixedNum(snap.im,snap.bits),scale=sp/w;let y=0;
-  function inBulbs(cr,ci){const y2=ci*ci,x=cr-.25,qq=x*x+y2;if(qq*(qq+x)<=.25*y2)return true;const x2=cr+1;return x2*x2+y2<=.0625}
-  function slice(){if(token!==state.token)return;const deadline=performance.now()+(profile.covered?10:7);while(y<h&&performance.now()<deadline){let oi=y*w*4,ci=cim+(h*.5-y-.5)*scale,cr=cre+(.5-w*.5)*scale;for(let x=0;x<w;x++,cr+=scale){let zr=0,zi=0,zr2=0,zi2=0,n=0,inside=inBulbs(cr,ci);if(inside)n=iter;else{let oldr=0,oldi=0;while(n<iter&&zr2+zi2<=4){zi=(zr+zr)*zi+ci;zr=zr2-zi2+cr;zr2=zr*zr;zi2=zi*zi;n++;if((n&63)===0){if(Math.abs(zr-oldr)+Math.abs(zi-oldi)<1e-15){n=iter;break}oldr=zr;oldi=zi}}}const mm=n>=iter?0:Math.max(4.0000001,zr2+zi2),kind=n<iter?FIELD_ESCAPED:(inside?FIELD_INTERIOR_LIKELY:FIELD_UNKNOWN);putField(field,y*w+x,n,mm,kind);if(n>=iter){out[oi++]=0;out[oi++]=0;out[oi++]=0;out[oi++]=255}else{putFastColor(out,oi,n,mm,iter,colorCtx);oi+=4}}y++}if(y<h)requestAnimationFrame(slice);else finishRender(token,t0,profile,snap,w,h,out,'JavaScript f64',w*h,field);}requestAnimationFrame(slice);
-}
-
-function spanMantBucket(span,bits){
-  const l=log2FixedAt(span,bits);let bucket=Math.round(l/256),mant=Math.pow(2,l-bucket*256);return{mant,bucket};
-}
-function normalizeBucket(r,i,b){
-  let m=Math.max(Math.abs(r),Math.abs(i));if(!m)return[0,0,NEG_BUCKET];
-  while(m>HI128){r*=INV256;i*=INV256;b++;m*=INV256}
-  while(m<LO128){r*=POW256;i*=POW256;b--;m*=POW256}
-  return[r,i,b];
-}
-function scAdd(a,b){
-  if(a[2]===NEG_BUCKET)return b;if(b[2]===NEG_BUCKET)return a;
-  const eb=Math.max(a[2],b[2]);let r=0,i=0;
-  if(a[2]===eb){r+=a[0];i+=a[1]}else if(a[2]===eb-1){r+=a[0]*INV256;i+=a[1]*INV256}
-  if(b[2]===eb){r+=b[0];i+=b[1]}else if(b[2]===eb-1){r+=b[0]*INV256;i+=b[1]*INV256}
-  return normalizeBucket(r,i,eb);
-}
-function scLog2(a){return a[2]===NEG_BUCKET?-Infinity:Math.log2(Math.hypot(a[0],a[1]))+256*a[2]}
-function fixedMantAtBucket(v,bits,bucket){
-  if(v===0n)return 0;const neg=v<0n;let a=neg?-v:v,bl=bitLen(a),take=Math.min(53,bl),sh=bl-take,top=Number(a>>BigInt(sh));
-  const exp=sh-bits-256*bucket;const n=top*Math.pow(2,exp);return neg?-n:n;
-}
-function fixedComplexScaled(r,i,bits){
-  if(r===0n&&i===0n)return[0,0,NEG_BUCKET];
-  const lr=r===0n?-Infinity:log2FixedAt(r,bits),li=i===0n?-Infinity:log2FixedAt(i,bits),bucket=Math.round(Math.max(lr,li)/256);
-  return normalizeBucket(fixedMantAtBucket(r,bits,bucket),fixedMantAtBucket(i,bits,bucket),bucket);
-}
-function pixelCenteredOffset(snap,refC,w){const half=roundDiv(snap.span,BigInt(2*Math.max(1,w)));return{r:snap.re-refC.re+half,i:snap.im-refC.im-half}}
-function roundDiv(v,d){const neg=v<0n,a=neg?-v:v,q=(a+d/2n)/d;return neg?-q:q}
-function fixedPixelPoint(snap,w,h,x,y,bits=snap.bits){const den=BigInt(2*w),re=align(snap.re,snap.bits,bits),im=align(snap.im,snap.bits,bits),span=align(snap.span,snap.bits,bits);return[re+roundDiv(span*BigInt(2*x+1-w),den),im+roundDiv(span*BigInt(h-2*y-1),den)]}
-function fixedAnalyticInterior(cr,ci,bits){const S=1n<<BigInt(bits),X=cr-(S>>2n),Y=ci,Q=X*X+Y*Y;if(4n*Q*(Q+X*S)<=Y*Y*S*S)return true;const D=cr+S;return 16n*(D*D+Y*Y)<=S*S}
-function fixedAnalyticPixelProven(snap,w,h,x,y){const p=fixedPixelPoint(snap,w,h,x,y),g=fixedPixelPoint(snap,w,h,x,y,snap.bits+64);return fixedAnalyticInterior(p[0],p[1],snap.bits)&&fixedAnalyticInterior(g[0],g[1],snap.bits+64)}
-function roundShift(v,bits){const neg=v<0n,a=neg?-v:v,half=1n<<(BigInt(bits)-1n),q=(a+half)>>BigInt(bits);return neg?-q:q}
-// ── Arbitrary-precision reference orbit / perturbation setup ────────────
-const referenceCache={id:0,bits:0,re:0n,im:0n,n:0,escape:0,zr:0n,zi:0n,rr:null,ri:null,series:null,version:0,loadedLen:0,derivative:[0,0,NEG_BUCKET],conditionLog2:0,checkpointVersion:0,checkpointBits:0,checkpointCount:0,checkpointMismatch:false};
-function promoteReferenceCache(shift,oldBits){
-  const c=referenceCache;if(!c.rr||c.bits!==oldBits)return;
-  const sh=BigInt(shift);c.re<<=sh;c.im<<=sh;c.zr<<=sh;c.zi<<=sh;c.bits+=shift;
-  // rr/ri are normalized Float64 values, so neither they nor Worker-side copies
-  // need to change when only the fixed-point radix moves.
-}
-function sameReference(bits,re,im){
-  return referenceCache.rr&&referenceCache.bits===bits&&referenceCache.re===re&&referenceCache.im===im;
-}
-function resetReference(bits,re,im){
-  const c=referenceCache;c.id++;c.bits=bits;c.re=re;c.im=im;c.n=0;c.escape=0;c.zr=0n;c.zi=0n;c.derivative=[0,0,NEG_BUCKET];c.conditionLog2=0;
-  if(!c.rr){c.rr=new Float64Array(150001);c.ri=new Float64Array(150001)}
-  c.series=null;c.version=1;c.loadedLen=0;c.checkpointVersion=0;c.checkpointBits=0;c.checkpointCount=0;c.checkpointMismatch=false;
-}
-function invalidateReferenceOrbit(){const c=referenceCache;c.id++;c.bits=0;c.re=0n;c.im=0n;c.n=0;c.escape=0;c.zr=0n;c.zi=0n;c.rr=null;c.ri=null;c.series=null;c.version=0;c.loadedLen=0;c.derivative=[0,0,NEG_BUCKET];c.conditionLog2=0;c.checkpointVersion=0;c.checkpointBits=0;c.checkpointCount=0;c.checkpointMismatch=false;for(const worker of deepPool.workers){worker._refKey='';worker._refLoaded=0}}
-function buildReferenceAt(bits,cRe,cIm,iter,token,done){
-  if(!sameReference(bits,cRe,cIm))resetReference(bits,cRe,cIm);
-  const c=referenceCache,B=BigInt(bits),ONE=1n<<B,BAIL=16n*ONE,startN=c.n,refT0=performance.now();
-  if((c.escape&&c.escape<=iter)||c.n>=iter){
-    const refLen=c.escape&&c.escape<=iter?c.escape:iter;done(c,refLen);return
-  }
-  function slice(){
-    if(token!==state.token)return;const deadline=performance.now()+6.5;
-    while(c.n<iter&&!c.escape&&performance.now()<deadline){
-      c.rr[c.n]=fixedOrbitNum(c.zr,bits);c.ri[c.n]=fixedOrbitNum(c.zi,bits);const Rr=c.rr[c.n],Ri=c.ri[c.n],d=c.derivative,term=d[2]===NEG_BUCKET?[0,0,NEG_BUCKET]:normalizeBucket(2*(Rr*d[0]-Ri*d[1]),2*(Rr*d[1]+Ri*d[0]),d[2]);c.derivative=scAdd(term,[1,0,0]);c.conditionLog2=Math.max(c.conditionLog2,scLog2(c.derivative));
-      const zr2=roundShift(c.zr*c.zr,bits),zi2=roundShift(c.zi*c.zi,bits);c.zi=roundShift(2n*c.zr*c.zi,bits)+cIm;c.zr=zr2-zi2+cRe;c.n++;
-      const mag=roundShift(c.zr*c.zr,bits)+roundShift(c.zi*c.zi,bits);if(mag>BAIL)c.escape=c.n;
-    }
-    if(c.escape||c.n>=iter){
-      c.rr[c.n]=fixedOrbitNum(c.zr,bits);c.ri[c.n]=fixedOrbitNum(c.zi,bits);c.version++;if(c.n>startN){const ms=performance.now()-refT0;refControl.lastBuildMs=ms;refControl.buildEMA=refControl.buildEMA?refControl.buildEMA*.82+ms*.18:ms}
-      const refLen=c.escape&&c.escape<=iter?c.escape:iter;done(c,refLen)
-    }else requestAnimationFrame(slice);
-  }
-  requestAnimationFrame(slice);
-}
-function verifyReferenceCheckpoints(ref,refLen,token,done){
-  const guardBits=ref.bits+64;
-  if(ref.checkpointVersion===ref.version&&ref.checkpointBits===guardBits&&!ref.checkpointMismatch){done(true);return}
-  const cRe=align(ref.re,ref.bits,guardBits),cIm=align(ref.im,ref.bits,guardBits),ONE=1n<<BigInt(guardBits),BAIL=16n*ONE;
-  const targets=new Set([0,refLen]);for(let n=1;n<refLen;n*=2)targets.add(n);const stride=Math.max(1,Math.floor(refLen/32));for(let n=stride;n<refLen;n+=stride)targets.add(n);
-  let zr=0n,zi=0n,n=0,escape=0,checked=0,mismatch=false;
-  function compare(){if(!targets.has(n)||n>refLen)return;checked++;const rr=fixedOrbitNum(zr,guardBits),ri=fixedOrbitNum(zi,guardBits);if(!Object.is(rr,ref.rr[n])||!Object.is(ri,ref.ri[n]))mismatch=true}
-  function slice(){
-    if(token!==state.token)return;const deadline=performance.now()+6;compare();
-    while(n<refLen&&!escape&&!mismatch&&performance.now()<deadline){const zr2=roundShift(zr*zr,guardBits),zi2=roundShift(zi*zi,guardBits);zi=roundShift(2n*zr*zi,guardBits)+cIm;zr=zr2-zi2+cRe;n++;const mag=roundShift(zr*zr,guardBits)+roundShift(zi*zi,guardBits);if(mag>BAIL)escape=n;compare()}
-    if(mismatch||escape||n>=refLen){if((ref.escape||0)!==escape&&((ref.escape||0)<=refLen||escape<=refLen))mismatch=true;ref.checkpointVersion=ref.version;ref.checkpointBits=guardBits;ref.checkpointCount=checked;ref.checkpointMismatch=mismatch;done(!mismatch)}else requestAnimationFrame(slice)
-  }
-  requestAnimationFrame(slice)
-}
-function computeSeries(ref,refLen,logMaxDc){
-  // A series valid for a wider image remains valid after zooming further in.
-  if(ref.series&&logMaxDc<=ref.series.logMaxDc+.02&&ref.series.skip<refLen)return ref.series;
-  let A=[0,0,NEG_BUCKET],Bc=[0,0,NEG_BUCKET],bestSkip=0,bestA=[0,0,NEG_BUCKET],bestB=[0,0,NEG_BUCKET];
-  const LOG_LIMIT=Math.log2(2.2e-4),LOG_RATIO=Math.log2(.10);
-  for(let n=0;n<refLen;n++){
-    const R=ref.rr[n],I=ref.ri[n],oldA=A;
-    const at=oldA[2]===NEG_BUCKET?[0,0,NEG_BUCKET]:normalizeBucket(2*(R*oldA[0]-I*oldA[1]),2*(R*oldA[1]+I*oldA[0]),oldA[2]);
-    A=scAdd(at,[1,0,0]);
-    const bt=Bc[2]===NEG_BUCKET?[0,0,NEG_BUCKET]:normalizeBucket(2*(R*Bc[0]-I*Bc[1]),2*(R*Bc[1]+I*Bc[0]),Bc[2]);
-    const a2=oldA[2]===NEG_BUCKET?[0,0,NEG_BUCKET]:normalizeBucket(oldA[0]*oldA[0]-oldA[1]*oldA[1],2*oldA[0]*oldA[1],2*oldA[2]);
-    Bc=scAdd(bt,a2);
-    const l1=scLog2(A)+logMaxDc,l2=scLog2(Bc)+2*logMaxDc;
-    if(Number.isFinite(l1)&&l1<LOG_LIMIT&&(!Number.isFinite(l2)||(l2<LOG_LIMIT&&l2<l1+LOG_RATIO))){bestSkip=n+1;bestA=A.slice();bestB=Bc.slice()}
-  }
-  if(bestSkip>=refLen)bestSkip=Math.max(0,refLen-1);
-  ref.series={logMaxDc,skip:bestSkip,Ar:bestA[0],Ai:bestA[1],Ab:bestA[2],Br:bestB[0],Bi:bestB[1],Bb:bestB[2]};
-  return ref.series;
-}
-function chooseReference(snap){
-  const c=referenceCache;if(c.rr&&c.n>8){const rr=align(c.re,c.bits,snap.bits),ri=align(c.im,c.bits,snap.bits),dx=fixedRatio(rr-snap.re,snap.span),dy=fixedRatio(ri-snap.im,snap.span),dist=Math.hypot(dx,dy);if(Number.isFinite(dist)){const hard=2.25;if(dist<=hard){let keep=true;if(dist>.45&&refControl.refId===c.id&&refControl.baseMPP>0&&refControl.lastMPP>refControl.baseMPP*1.34&&performance.now()-refControl.lastRecenterAt>refControl.cooldownMs){const extra=(refControl.lastMPP-refControl.baseMPP)*Math.max(1,refControl.lastPixels),build=Math.max(5,refControl.buildEMA||18);if(extra>build*1.65)keep=false}if(keep)return{re:rr,im:ri,reused:true,dist};refControl.lastRecenterAt=performance.now()}}}return{re:snap.re,im:snap.im,reused:false,dist:0}
-}
-function putDeepPixel(out,w,computeIter,colorIter,x,y,n,m,colorCtx){
-  const oi=(y*w+x)*4,mm=n>=computeIter?0:Math.max(4.0000001,m);
-  
-  if(n>=computeIter){out[oi]=0;out[oi+1]=0;out[oi+2]=0;out[oi+3]=255;return}
-  putFastColor(out,oi,n,mm,colorIter,colorCtx);
-}
-function directOrbitState(cr,ci,bits,iter){return{cr,ci,bits,iter,zr:0n,zi:0n,mag:0n,n:0,done:false,four:4n*(1n<<BigInt(bits))}}
-function stepDirectOrbit(orbit,deadline){let batch=0;while(!orbit.done){const zr2=roundShift(orbit.zr*orbit.zr,orbit.bits),zi2=roundShift(orbit.zi*orbit.zi,orbit.bits);orbit.mag=zr2+zi2;if(orbit.mag>orbit.four||orbit.n>=orbit.iter){orbit.done=true;break}orbit.zi=roundShift(2n*orbit.zr*orbit.zi,orbit.bits)+orbit.ci;orbit.zr=zr2-zi2+orbit.cr;orbit.n++;if((++batch&31)===0&&performance.now()>=deadline)break}if(orbit.n>=orbit.iter)orbit.done=true}
-async function highPrecisionDirectPixelAsync(snap,w,h,iter,x,y,guarded=true,cancelled=()=>false){const p=fixedPixelPoint(snap,w,h,x,y),base=directOrbitState(p[0],p[1],snap.bits,iter);let guard=null;if(guarded){const bits=snap.bits+64,g=fixedPixelPoint(snap,w,h,x,y,bits);guard=directOrbitState(g[0],g[1],bits,iter)}while(!base.done||(guard&&!guard.done)){if(cancelled())return null;const deadline=performance.now()+6;stepDirectOrbit(base,deadline);if(guard)stepDirectOrbit(guard,deadline);if(!base.done||(guard&&!guard.done))await new Promise(requestAnimationFrame)}if(guard&&(guard.n!==base.n||((guard.n<iter)!==(base.n<iter))))return[iter,0];const chosen=guard||base;return[chosen.n,chosen.n<iter?Math.max(4.0000001,fixedOrbitNum(chosen.mag,chosen.bits)):0]}
-function renderDeepDirect(profile,snap,w,h,iter,colorIter,token,t0){
-  const cap=profile.covered?w:390,scale=Math.min(1,cap/w);if(scale<1){h=Math.max(100,Math.round(h*scale));w=Math.max(160,Math.round(w*scale))}
-  const out=new Uint8ClampedArray(w*h*4),field=makeField(w*h,colorIter),colorCtx=makeColorCtx(colorIter);let y=0;
-  state.lastEngine='BigInt direct fallback';
-  async function slice(){
-    if(token!==state.token)return;const deadline=performance.now()+7;
-    while(y<h&&performance.now()<deadline){const y0=y;for(let x=0;x<w;x++){const result=await highPrecisionDirectPixelAsync(snap,w,h,iter,x,y,false,()=>token!==state.token);if(!result)return;const[n,m]=result;putField(field,y*w+x,n,m,n<iter?FIELD_ESCAPED:FIELD_UNKNOWN);putDeepPixel(out,w,iter,colorIter,x,y,n,m,colorCtx)}presentPartialStripe(out.subarray(y0*w*4,(y0+1)*w*4),0,y0,w,1,w,h,snap);y++}
-    if(y<h)requestAnimationFrame(slice);else finishRender(token,t0,profile,snap,w,h,out,'BigInt direct fallback',w*h,field);
-  }requestAnimationFrame(slice);
-}
-function prepareDeepContext(snap,refC,iter,token,done){
-  const probeW=64,probeH=Math.max(28,Math.round(probeW*canvas.clientHeight/Math.max(1,canvas.clientWidth))),refX=probeW*.5-.5+fixedRatio(refC.re-snap.re,snap.span)*probeW,refY=probeH*.5-.5-fixedRatio(refC.im-snap.im,snap.span)*probeW,cornerR=Math.max(Math.hypot(refX,refY),Math.hypot(probeW-refX,refY),Math.hypot(refX,probeH-refY),Math.hypot(probeW-refX,probeH-refY))/Math.max(1,probeW),logMaxDc=log2FixedAt(snap.span,snap.bits)+Math.log2(Math.max(1e-300,cornerR));
-  buildReferenceAt(snap.bits,refC.re,refC.im,iter,token,(ref,refLen)=>{if(token!==state.token)return;if(ensureOrbitPrecision(iter,Math.max(1,canvas.width))){state.dirty=true;invalidateView();return}const finish=()=>done({ref,refLen,series:computeSeries(ref,refLen,logMaxDc)});if(state.processMode!=='validate'){finish();return}verifyReferenceCheckpoints(ref,refLen,token,ok=>{if(token!==state.token)return;if(ok){finish();return}promoteState(32);invalidateReferenceOrbit();state.dirty=true;invalidateView()})})
-}
-function renderPerturbPrepared(profile,snap,w,h,iter,colorIter,token,t0,refC,ref,refLen,series,reuse=null){
-  const workerReady=ensureDeepPool();if(!workerReady&&(!ensureDeepWasm()||!deepWasm.ex.render_perturb_rebase_rect)){renderDeepDirect(profile,snap,w,h,iter,colorIter,token,t0);return}
-  const centered=pixelCenteredOffset(snap,refC,w),out=reuse?reuse.out:new Uint8ClampedArray(w*h*4),field=makeField(w*h,colorIter),colorCtx=makeColorCtx(colorIter),sb=spanMantBucket(snap.span,snap.bits),off=fixedComplexScaled(centered.r,centered.i,snap.bits);
-  const fallback=(strict=false)=>{if(token!==state.token)return;if(!ensureDeepWasm()||!deepWasm.ex.render_perturb_rebase_rect){renderDeepDirect(profile,snap,w,h,iter,colorIter,token,t0);return}if(ref.loadedLen<refLen+1){deepWasm.refsR().set(ref.rr.subarray(ref.loadedLen,refLen+1),ref.loadedLen);deepWasm.refsI().set(ref.ri.subarray(ref.loadedLen,refLen+1),ref.loadedLen);ref.loadedLen=refLen+1}const counts=deepWasm.counts(),mags=deepWasm.mags(),bad=[];let y=0;function rows(){if(token!==state.token)return;const deadline=performance.now()+(profile.covered?11:8);while(y<h&&performance.now()<deadline){const rows=Math.min(Math.max(1,Math.floor(65536/Math.max(1,w))),h-y),y0=y,npx=deepWasm.ex.render_perturb_rebase_rect(sb.mant,sb.bucket,off[0],off[1],off[2],refLen,w,h,w*.5,h*.5,0,y,w,rows,iter,strict?0:series.skip,strict?0:series.Ar,strict?0:series.Ai,strict?0:series.Ab,strict?0:series.Br,strict?0:series.Bi,strict?0:series.Bb);for(let i=0;i<npx;i++){const x=i%w,py=y0+((i/w)|0),n=counts[i],m=mags[i];if(n===0xffffffff){bad.push(py*w+x);continue}putField(field,py*w+x,n,m,n<iter?FIELD_ESCAPED:FIELD_UNKNOWN);putDeepPixel(out,w,iter,colorIter,x,py,n,m,colorCtx)}y+=rows}if(y<h)requestAnimationFrame(rows);else if(bad.length)runResidual();else finish()}function runResidual(){let k=0;async function slice(){if(token!==state.token)return;const deadline=performance.now()+6;while(k<bad.length&&performance.now()<deadline){const idx=bad[k++],x=idx%w,py=(idx/w)|0,result=await highPrecisionDirectPixelAsync(snap,w,h,iter,x,py,false,()=>token!==state.token);if(!result)return;const[n,m]=result;putField(field,idx,n,m,n<iter?FIELD_ESCAPED:FIELD_UNKNOWN);putDeepPixel(out,w,iter,colorIter,x,py,n,m,colorCtx)}if(k<bad.length)requestAnimationFrame(slice);else finish()}requestAnimationFrame(slice)}function finish(){state.lastEngine='WASM '+(deepWasm.simd?'SIMD':'scalar')+' · '+(strict?'strict ':'')+'main-thread rebase · skip '+(strict?0:series.skip);finishRender(token,t0,profile,snap,w,h,out,state.lastEngine,w*h,field)}requestAnimationFrame(rows)};
-  // Never abort and restart an in-flight frame because a budget estimate was wrong.
-  // Finish it once and feed the measured cost into the next frame.
-  if(!workerReady||!runDeepPool(profile,snap,w,h,iter,colorIter,token,t0,out,sb,refC,off,ref,refLen,series,fallback,reuse?reuse.rects:null))fallback();
-}
-async function renderDeepAdaptive(profile,snap,plan,token,t0){
-  try{await prepareDeepModules()}catch{if(token===state.token){const [fallbackW,fallbackH]=targetSize(profile,true);renderDeepDirect(profile,snap,fallbackW,fallbackH,plan.colorIter,plan.colorIter,token,t0)}return}if(token!==state.token)return;
-  const iter=plan.colorIter,colorIter=plan.colorIter,[w,h]=targetSize(profile,true),reuse=buildPanReuse(snap,w,h,iter,profile);
-  // A zoom-in can be represented entirely by the previous frame. Commit that preview
-  // immediately; the normal idle HQ pass performs the exact full-resolution render.
-  if(reuse&&reuse.rects.length===0&&!profile.covered){finishRender(token,t0,profile,snap,w,h,reuse.out,'既存画像再利用 100%',0);return}
-  const refC=chooseReference(snap);state.lastEngine='参照軌道を準備中…';prepareDeepContext(snap,refC,iter,token,ctx=>{if(token!==state.token)return;renderPerturbPrepared(profile,snap,w,h,iter,colorIter,token,t0,refC,ctx.ref,ctx.refLen,ctx.series,reuse)})
-}
-function render(pass=RENDER_PASS.PREVIEW){
-  const profile=renderProfile(pass);
-  if(pass===RENDER_PASS.COVERED){state.fieldView=null;trimDetailCache()}
-  runtimeMetrics.renderStarts++;if(state.pointerActive||state.wheelActive)runtimeMetrics.renderStartsDuringGesture++;
-  let snap=snapshot(),deep=deepEngineNeeded(snap);if(!deep&&state.adaptivePixelBudget){state.adaptivePixelBudget=0;resize()}if(deep&&ensureOrbitPrecision(maxIter()))snap=snapshot();const plan=iterationPlan(profile,deep),token=++state.token,t0=performance.now();state.rendering=true;state.drawState=profile.covered?'COVERING':'PREVIEW';state.lastPass=profile.id;state.lastEngine=deep?'参照軌道を準備中…':(wasm?('WebAssembly '+(wasm.simd?'SIMD':'scalar')):'JavaScript f64');
-  if(!deep){const ratio=deepResolutionRatio(snap);if(ratio<=128)prewarmDeepAssets();else if(deepPool.workers.length||deepWasm||deepModuleBundle||referenceCache.rr)retireDeepAssets()}
-  invalidateStats();
-  if(deep)renderDeepAdaptive(profile,snap,plan,token,t0);else{const [w,h]=targetSize(profile,false),reuse=buildPanReuse(snap,w,h,plan.computeIter,profile);if(reuse)renderShallowReuse(profile,snap,w,h,plan.computeIter,token,t0,reuse);else if(wasm)renderWasm(profile,snap,w,h,plan.computeIter,token,t0);else renderJsDouble(profile,snap,w,h,plan.computeIter,token,t0)}
-}
-function screenPixelBudget(){
-  const lowMemory=Number(navigator.deviceMemory||8)<=4,small=matchMedia('(max-width:700px)').matches;if(state.processMode==='power')return 1*1048576;if(state.processMode==='fine'||state.processMode==='validate')return(lowMemory||small?4:8)*1048576;
-  const base=(lowMemory||small?2:4)*1048576;return state.adaptivePixelBudget?Math.min(base,state.adaptivePixelBudget):base
-}
-function adaptStandardDeepBudget(deep){if(state.processMode!=='standard'||!deep)return false;const measuredMPP=renderPerf.deepMPP||.03,target=Math.max(32768,Math.min(4*1048576,Math.round(1400/measuredMPP))),oldBudget=state.adaptivePixelBudget||screenPixelBudget();if(target/oldBudget>=.8&&target/oldBudget<=1.25)return false;const oldPixels=canvas.width*canvas.height;state.adaptivePixelBudget=target;resize();return canvas.width*canvas.height!==oldPixels}
-function resize(){
-  const cssW=Math.max(1,innerWidth),cssH=Math.max(1,innerHeight),budget=screenPixelBudget(),nativeDpr=Math.max(1,window.devicePixelRatio||1),budgetDpr=Math.sqrt(budget/Math.max(1,cssW*cssH)),minDpr=Math.min(1,64/Math.max(cssW,cssH)),dpr=Math.max(minDpr,Math.min(nativeDpr,budgetDpr)),w=Math.max(2,Math.round(cssW*dpr)),h=Math.max(2,Math.round(cssH*dpr));
-  state.effectiveDpr=dpr;state.screenPixelBudget=budget;
-  if(canvas.width!==w||canvas.height!==h){clearPanReuse();canvas.width=w;canvas.height=h;trimDetailCache();state.dirty=true;invalidateView()}
-}
-function jaEngine(s){return String(s||'').replace('preparing cached rebase reference…','参照軌道を準備中…').replace('persistent workers','常駐Worker').replace('main-thread','メインスレッド').replace('strict','厳密').replace('fallback','フォールバック').replace('rebase','リベース').replace('skip','スキップ').replace('residual','残差').replace('starting','起動中')}
-function updateStats(){
-  runtimeMetrics.domWrites++;
-  const z=zoomExp(),digits=Math.max(8,Math.min(80,Math.ceil(z)+8));$('#coord').textContent=fmtFixed(state.re,digits)+' '+(state.im<0n?'−':'+')+' '+fmtFixed(state.im<0n?-state.im:state.im,digits)+'i';
-  $('#zoom').textContent=z<4?Math.pow(10,z).toFixed(1)+'×':'≈ 10^'+z.toFixed(2);$('#span').textContent=fmtSpan();const deep=deepEngineNeeded(),diagnosticProfile=RENDER_PROFILE[RENDER_PASS.COVERED],ip=iterationPlan(diagnosticProfile,deep);$('#engine').textContent=deep?'高精度深部':'標準精度';$('#render').textContent=state.rendering?'描画中…':(state.lastRender?state.lastRender.toFixed(0)+' ms':'準備完了');let status;if(state.drawState==='REPROJECTED')status='再投影';else if(state.drawState==='PREVIEW')status=state.rendering?'プレビュー描画中':'プレビュー';else if(state.drawState==='COVERING')status='全域描画中';else if(state.drawState==='RESOLVING')status='未確定を追加計算 '+Math.round(state.continuationProgress*100)+'%';else if(state.drawState==='REFINING')status='境界AA '+state.detailDone+'/'+state.detailQueued;else if(state.drawState==='REFINED')status='境界AA 完了';else if(state.drawState==='VALIDATING')status='精度照合 '+Math.round(state.coverage*100)+'%';else if(state.drawState==='VALIDATION_INCOMPLETE')status='検証未完了';else if(state.drawState==='VALIDATED')status='検証完了';else status='全域描画 完了';if(state.unresolved)status+=' · 未確定 '+state.unresolved;if(state.effectiveDpr<(devicePixelRatio||1)*.99)status+=' · '+canvas.width+'×'+canvas.height;$('#badge').textContent=status;$('#compactStatus').textContent=status;const ledger=memoryLedger(),bp=blaProfile(diagnosticProfile);$('#diagEngine').textContent='engine: '+jaEngine(state.lastEngine)+' | workers '+deepPool.workers.length+' | '+(wasm&&wasm.simd?'SIMD':'scalar/JS');$('#diagNumeric').textContent='numeric: '+state.bits+' bit | iter '+ip.colorIter+' | BLA ε 2^-'+bp.exp+' | condition '+Math.round(referenceCache.conditionLog2||0)+' bit';$('#diagMemory').textContent='memory: managed '+(ledger.managedBytes/1048576).toFixed(1)+' / '+(ledger.budget/1048576).toFixed(0)+' MiB | canvas est. '+(ledger.canvasBytes/1048576).toFixed(1)+' MiB';
-}
-
-
-// ── Scheduler / interaction loop ────────────────────────────────────────
-function nextQualityDue(deep){
-  if(state.processMode==='power'||state.dirty||state.rendering||state.pointerActive||state.wheelActive)return Infinity;
-  if(deep&&state.lastPass!==RENDER_PASS.COVERED)return Math.max(state.lastInteraction+680,state.lastFrameDone+260);
-  if(!deep&&state.lastPass!==RENDER_PASS.COVERED)return Math.max(state.lastInteraction+520,state.lastFrameDone+280);
-  return Infinity
-}
-function loop(now){
-  schedulerRAF=0;if(document.hidden)return;
-  const deep=deepEngineNeeded();
-  if(!state.pointerActive&&!state.wheelActive&&!state.rendering){
-    if(state.dirty)render(RENDER_PASS.PREVIEW);
-    else{
-      const due=nextQualityDue(deep);
-      if(due<=now)render(RENDER_PASS.COVERED)
-    }
-  }
-  if(needsPaint){needsPaint=false;paintFrame()}
-  if(needsStats){needsStats=false;updateStats()}
-  if(!state.rendering&&!state.pointerActive&&!state.wheelActive&&!state.dirty){
-    const due=nextQualityDue(deep);if(Number.isFinite(due))requestScheduler(Math.max(1,due-performance.now()))
-  }
-}
-
-const pts=new Map();let lx=0,ly=0,pinch=0;
-canvas.addEventListener('wheel',e=>{e.preventDefault();updateFocus(e.clientX,e.clientY);if(!state.wheelActive){state.wheelActive=true;cancelDetailRefinement(true);cancelRender();capturePanSource()}zoomAt(e.clientX,e.clientY,Math.exp(e.deltaY*.00125));clearTimeout(wheelSettleTimer);wheelSettleTimer=setTimeout(()=>{wheelSettleTimer=0;state.wheelActive=false;state.lastInteraction=performance.now();state.dirty=true;recordView();saveHash(false);invalidateView()},110)},{passive:false});
-canvas.addEventListener('pointerdown',e=>{updateFocus(e.clientX,e.clientY);try{canvas.setPointerCapture(e.pointerId)}catch{};if(pts.size===0){clearTimeout(pointerSettleTimer);pointerSettleTimer=0;clearTimeout(wheelSettleTimer);wheelSettleTimer=0;state.wheelActive=false;state.pointerActive=true;cancelDetailRefinement(true);cancelRender();capturePanSource()}pts.set(e.pointerId,[e.clientX,e.clientY]);if(pts.size===1){lx=e.clientX;ly=e.clientY}else if(pts.size===2){const a=[...pts.values()];pinch=Math.hypot(a[0][0]-a[1][0],a[0][1]-a[1][1])}});
-canvas.addEventListener('pointermove',e=>{if(!pts.has(e.pointerId))return;updateFocus(e.clientX,e.clientY);pts.set(e.pointerId,[e.clientX,e.clientY]);if(pts.size===1){const dx=e.clientX-lx,dy=e.clientY-ly;pan(dx,dy);lx=e.clientX;ly=e.clientY}else if(pts.size===2){const a=[...pts.values()],d=Math.hypot(a[0][0]-a[1][0],a[0][1]-a[1][1]);if(pinch>0&&d>0)zoomAt((a[0][0]+a[1][0])/2,(a[0][1]+a[1][1])/2,pinch/d);pinch=d}});
-function end(e){pts.delete(e.pointerId);pinch=0;if(pts.size)return;clearTimeout(pointerSettleTimer);pointerSettleTimer=setTimeout(()=>{pointerSettleTimer=0;state.pointerActive=false;state.lastInteraction=performance.now();state.dirty=true;recordView();saveHash(false);invalidateView()},90)}canvas.addEventListener('pointerup',end);canvas.addEventListener('pointercancel',end);
-function applyUiVisibility(){document.body.classList.toggle('ui-hidden',state.uiHidden);$('#uiToggle').textContent=state.uiHidden?'UI＋':'UI−';$('#uiToggle').setAttribute('aria-expanded',String(!state.uiHidden))}
-$('#uiToggle').onclick=()=>{state.uiHidden=!state.uiHidden;applyUiVisibility();try{localStorage.setItem('mandelbrot.uiHidden',state.uiHidden?'1':'0')}catch{}};
-$('#zin').onclick=()=>{capturePanSource();zoomAt(innerWidth/2,innerHeight/2,.5);recordView();saveHash(false)};$('#zout').onclick=()=>{capturePanSource();zoomAt(innerWidth/2,innerHeight/2,2);recordView();saveHash(false)};$('#reset').onclick=()=>{reset();recordView()};
-const exportJob={active:false,cancelled:false,bytes:0};let exportForcePrecision=false;
-function downloadBlob(blob,name){const a=document.createElement('a');a.href=URL.createObjectURL(blob);a.download=name;a.click();setTimeout(()=>URL.revokeObjectURL(a.href),1500)}
-function exportLedgerBytes(){return memoryLedger().logicalBytes}
-function exportSampleShallow(cre,cim,scale,W,H,iter,x,y){const cr=cre+(x+.5-W*.5)*scale,ci=cim+(H*.5-y-.5)*scale;let zr=0,zi=0,zr2=0,zi2=0,n=0;while(n<iter&&zr2+zi2<=4){zi=2*zr*zi+ci;zr=zr2-zi2+cr;zr2=zr*zr;zi2=zi*zi;n++}return[n,n<iter?Math.max(4.0000001,zr2+zi2):0]}
-async function runExport(){if(exportJob.active)return;const scaleChoice=Number($('#exportScale').value),w=Math.max(64,Math.min(16384,Math.round(scaleChoice?canvas.width*scaleChoice:Number($('#exportWidth').value)||canvas.width))),h=Math.max(1,Math.round(w*canvas.height/Math.max(1,canvas.width))),ss=Math.max(1,Math.min(2,Number($('#exportAA').value)||1)),needed=w*h*8,budget=rendererMemoryBudget(),available=Math.max(0,budget-exportLedgerBytes());if(w>16384||h>16384){$('#exportStatus').textContent='辺の長さは 16384px 以下にしてください。';return}if(needed>available){$('#exportStatus').textContent='メモリ予算を超えます。幅または倍率を下げてください（必要 '+Math.ceil(needed/1048576)+' MiB / 空き '+Math.floor(available/1048576)+' MiB）。';return}const outCanvas=document.createElement('canvas');outCanvas.width=w;outCanvas.height=h;const oc=outCanvas.getContext('2d',{alpha:false});if(!oc){$('#exportStatus').textContent='出力 Canvas を作成できません。';return}const snap=snapshot(),iter=maxIter(),deep=deepEngineNeeded(snap,w),cre=fixedNum(snap.re,snap.bits),cim=fixedNum(snap.im,snap.bits),sp=fixedNum(snap.span,snap.bits),W=w*ss,H=h*ss,pixelScale=sp/W,colorCtx=makeColorCtx(iter),tmp=new Uint8ClampedArray(4),tiles=[],tileW=exportForcePrecision?4:(deep?16:128),tileH=exportForcePrecision?1:(deep?4:24);for(let y=0;y<h;y+=tileH)for(let x=0;x<w;x+=tileW)tiles.push({x,y,w:Math.min(tileW,w-x),h:Math.min(tileH,h-y)});exportJob.active=true;exportJob.cancelled=false;exportJob.bytes=needed;$('#exportProgress').hidden=false;$('#exportProgress').value=0;$('#exportStart').disabled=true;$('#exportStatus').textContent='タイル描画中…';let done=0,unresolvedSamples=0;try{for(const tile of tiles){if(exportJob.cancelled)throw new Error('cancelled');const id=oc.createImageData(tile.w,tile.h),data=id.data;for(let yy=0;yy<tile.h;yy++)for(let xx=0;xx<tile.w;xx++){let ar=0,ag=0,ab=0;for(let sy=0;sy<ss;sy++)for(let sx=0;sx<ss;sx++){const gx=(tile.x+xx)*ss+sx,gy=(tile.y+yy)*ss+sy,sample=deep?await highPrecisionDirectPixelAsync(snap,W,H,iter,gx,gy,exportForcePrecision,()=>exportJob.cancelled):exportSampleShallow(cre,cim,pixelScale,W,H,iter,gx,gy);if(!sample)throw new Error('cancelled');const[n,m]=sample;if(n<iter){putFastColor(tmp,0,n,m,iter,colorCtx);ar+=linearChannel(tmp[0]);ag+=linearChannel(tmp[1]);ab+=linearChannel(tmp[2])}else{ar+=linearChannel(20);ag+=linearChannel(22);ab+=linearChannel(30);unresolvedSamples++}}const samples=ss*ss,oi=(yy*tile.w+xx)*4;data[oi]=srgbChannel(ar/samples);data[oi+1]=srgbChannel(ag/samples);data[oi+2]=srgbChannel(ab/samples);data[oi+3]=255}oc.putImageData(id,tile.x,tile.y);done++;$('#exportProgress').value=done/tiles.length;$('#exportStatus').textContent='生成中 '+Math.round(done/tiles.length*100)+'%';await new Promise(requestAnimationFrame)}if(exportJob.cancelled)throw new Error('cancelled');$('#exportStatus').textContent='PNGを圧縮中…';const blob=await new Promise(resolve=>outCanvas.toBlob(resolve,'image/png'));if(!blob)throw new Error('PNG encode failed');const stamp=Date.now(),base='mandelbrot-'+stamp,meta={format:'mandelbrot-view-v23',rendererVersion:23,pixelContract:'centered',width:w,height:h,supersampling:ss,sampleCount:w*h*ss*ss,unresolvedSamples,membershipCertified:false,precisionPolicy:{mode:exportForcePrecision?'validated-direct':'balanced',baseBits:snap.bits,agreementGuardBits:exportForcePrecision?64:0},iterationPolicy:{adaptive:state.adaptive,base:state.baseIter,effective:iter},numericEngine:deep?'bigint-fixed-direct':'javascript-f64-direct',kernelSha256:globalThis.MANDEL_KERNEL_META||null,colorSpace:'sRGB with linear-light sample resolve',encoder:{mime:'image/png',api:'HTMLCanvasElement.toBlob'},view:{bits:snap.bits,re:snap.re.toString(),im:snap.im.toString(),span:snap.span.toString()},palette:{id:state.palette,cycle:state.cycle,shift:state.shift},determinism:{randomSeed:null,tiled:true,allTilesCompleted:true}};downloadBlob(blob,base+'.png');downloadBlob(new Blob([JSON.stringify(meta,null,2)],{type:'application/json'}),base+'.json');$('#exportStatus').textContent='PNG と座標メタデータを保存しました。'}catch(e){$('#exportStatus').textContent=String(e&&e.message)==='cancelled'?'出力を中止しました。':'出力に失敗しました: '+String(e&&e.message||e)}finally{exportJob.active=false;exportJob.bytes=0;$('#exportStart').disabled=false}}
-$('#png').onclick=()=>{const d=$('#exportDialog');$('#exportWidth').value=String(canvas.width);$('#exportScale').value='1';$('#exportProgress').hidden=true;$('#exportStatus').textContent='';d.showModal?d.showModal():d.setAttribute('open','')};
-$('#exportQuick').onclick=()=>canvas.toBlob(blob=>{if(!blob)return;downloadBlob(blob,'mandelbrot-'+state.drawState.toLowerCase()+'-'+Date.now()+'.png');$('#exportStatus').textContent='現在の表示（'+state.drawState+'）を保存しました。'},'image/png');
-$('#exportScale').onchange=e=>{const s=Number(e.target.value);if(s)$('#exportWidth').value=String(Math.min(16384,canvas.width*s))};$('#exportStart').onclick=async()=>{exportForcePrecision=$('#exportPrecision').value==='validated';try{await runExport()}finally{exportForcePrecision=false}};$('#exportCancel').onclick=()=>{if(exportJob.active){exportJob.cancelled=true;$('#exportStatus').textContent='中止しています…'}else $('#exportDialog').close()};
-function toast(s){const t=$('#toast');t.textContent=s;t.classList.add('show');clearTimeout(toast._t);toast._t=setTimeout(()=>t.classList.remove('show'),1500)}
-let lastWrittenHash='',navigationHash='';
-const viewHistory=[];let viewHistoryIndex=-1;
+function zoomExp(){return Math.max(0,Math.log10(3.4)-log2Fixed(state.span)/Math.log2(10))}
+function fmtSpan(){const l=log2Fixed(state.span)/Math.log2(10);if(l>-4)return fmtFixed(state.span,12);const e=Math.floor(l),m=Math.pow(10,l-e);return m.toFixed(7)+'e'+e}
+function spanMantExp(snap){const l=log2FixedAt(snap.span,snap.bits);if(!Number.isFinite(l))return{mant:0,exp:0};const exp=Math.floor(l),mant=Math.pow(2,l-exp);return{mant,exp}}
+function f32Ulp(x){x=Math.fround(Math.abs(x));if(!Number.isFinite(x))return Infinity;if(x===0)return 2**-149;const e=Math.floor(Math.log2(x));return 2**(e-23)}
+function deepNeeded(snap=snapshot(),width=Math.max(1,canvas.width)){const stepLog=log2FixedAt(snap.span,snap.bits)-Math.log2(width),cr=fixedNum(snap.re,snap.bits),ci=fixedNum(snap.im,snap.bits),ulp=Math.max(f32Ulp(cr),f32Ulp(ci),2**-149),ratio=Math.pow(2,Math.min(1024,stepLog-Math.log2(ulp)));return !Number.isFinite(ratio)||ratio<96||stepLog<-120}
 function currentViewSpec(){return{bits:state.bits,re:state.re,im:state.im,span:state.span,palette:state.palette,cycle:state.cycle,shift:state.shift,baseIter:state.baseIter,adaptive:state.adaptive}}
 function viewSpecKey(v){return[v.bits,v.re,v.im,v.span,v.palette,v.cycle,v.shift,v.baseIter,v.adaptive].join(':')}
-function recordView(){const v=currentViewSpec(),key=viewSpecKey(v);if(viewHistoryIndex>=0&&viewSpecKey(viewHistory[viewHistoryIndex])===key)return;viewHistory.splice(viewHistoryIndex+1);viewHistory.push(v);if(viewHistory.length>80)viewHistory.shift();viewHistoryIndex=viewHistory.length-1;syncHistoryButtons()}
-function restoreView(v){if(!v)return;state.bits=v.bits;state.re=v.re;state.im=v.im;state.span=v.span;state.palette=v.palette;state.cycle=v.cycle;state.shift=v.shift;state.baseIter=v.baseIter;state.adaptive=v.adaptive;clearDetailCache();clearPanReuse();ensurePrecision();syncControls();saveHash(false);setDirty()}
-function syncHistoryButtons(){$('#undoView').disabled=viewHistoryIndex<=0;$('#redoView').disabled=viewHistoryIndex<0||viewHistoryIndex>=viewHistory.length-1}
-function syncCoordinateInputs(){$('#coordReInput').value=fmtFixedExact(state.re);$('#coordImInput').value=fmtFixedExact(state.im);$('#coordSpanInput').value=fmtFixedExact(state.span)}
-function saveHash(push){const p=new URLSearchParams();p.set('v','23');p.set('b',String(state.bits));p.set('re',state.re.toString());p.set('im',state.im.toString());p.set('sp',state.span.toString());p.set('pal',String(state.palette));p.set('cy',String(state.cycle));p.set('sh',String(state.shift));p.set('it',String(state.baseIter));p.set('ad',state.adaptive?'1':'0');const h='#'+p.toString();lastWrittenHash=h;try{if(location.protocol==='file:'||location.origin==='null'){if(location.hash!==h)location.hash=h}else{push?history.pushState(null,'',h):history.replaceState(null,'',h)}}catch{}}
+function recordView(){const v=currentViewSpec(),k=viewSpecKey(v);if(viewHistoryIndex>=0&&viewSpecKey(viewHistory[viewHistoryIndex])===k)return;viewHistory.splice(viewHistoryIndex+1);viewHistory.push(v);if(viewHistory.length>80)viewHistory.shift();viewHistoryIndex=viewHistory.length-1;syncHistoryButtons()}
+function restoreView(v){if(!v)return;Object.assign(state,{bits:v.bits,re:v.re,im:v.im,span:v.span,palette:v.palette,cycle:v.cycle,shift:v.shift,baseIter:v.baseIter,adaptive:v.adaptive});ensurePrecision();syncControls();saveHash(false);markDirty()}
+
+// ── iteration / quality policy ───────────────────────────────────────────
+function maxIter(){if(!state.adaptive)return state.baseIter;const z=zoomExp(),bonus=Math.max(0,Math.floor(70*Math.sqrt(z)+15*z));return Math.min(150000,Math.max(state.baseIter,state.baseIter+bonus))}
+function pixelBudget(){const low=Number(navigator.deviceMemory||8)<=4,small=matchMedia('(max-width:700px)').matches;if(!navigator.gpu||state.gpuUnavailable)return 262144;if(state.processMode==='power')return 524288;if(state.processMode==='fine')return(low||small?1572864:3145728);if(state.processMode==='validate')return(low||small?1048576:2097152);return(low||small?786432:1572864)}
+function resize(){const cssW=Math.max(1,innerWidth),cssH=Math.max(1,innerHeight),budget=pixelBudget(),native=Math.max(1,devicePixelRatio||1),bd=Math.sqrt(budget/(cssW*cssH));let dpr=Math.max(Math.min(1,64/Math.max(cssW,cssH)),Math.min(native,bd));if(renderer){const md=Math.max(2,renderer.adapterLimits.maxTextureDimension2D||8192);dpr=Math.min(dpr,md/cssW,md/cssH)}const w=Math.max(2,Math.round(cssW*dpr)),h=Math.max(2,Math.round(cssH*dpr));state.effectiveDpr=dpr;state.screenPixelBudget=budget;if(canvas.width!==w||canvas.height!==h){canvas.width=w;canvas.height=h;if(renderer)renderer.configure();markDirty(false)}}
+
+// ── high precision reference worker ─────────────────────────────────────
+function referenceWorkerSource(){return String.raw`
+'use strict';
+const MAX_REF=150001,MAX_LEVELS=20;
+function bitLen(v){v=v<0n?-v:v;return v===0n?0:v.toString(2).length}
+function roundShift(v,b){const neg=v<0n,a=neg?-v:v,half=1n<<(BigInt(b)-1n),q=(a+half)>>BigInt(b);return neg?-q:q}
+function fixedNum(v,b){if(v===0n)return 0;let neg=v<0n;if(neg)v=-v;const bl=bitLen(v),take=Math.min(53,bl),sh=bl-take,top=Number(v>>BigInt(sh)),n=top*Math.pow(2,sh-b);return neg?-n:n}
+function orbit(bits,re,im,iter){const B=BigInt(bits),ONE=1n<<B,BAIL=16n*ONE;let zr=0n,zi=0n,escape=0,n=0;const rr=new Float64Array(iter+1),ri=new Float64Array(iter+1);for(;n<iter&&!escape;n++){rr[n]=fixedNum(zr,bits);ri[n]=fixedNum(zi,bits);const zr2=roundShift(zr*zr,bits),zi2=roundShift(zi*zi,bits);zi=roundShift(2n*zr*zi,bits)+im;zr=zr2-zi2+re;const mag=roundShift(zr*zr,bits)+roundShift(zi*zi,bits);if(mag>BAIL)escape=n+1}rr[n]=fixedNum(zr,bits);ri[n]=fixedNum(zi,bits);return{rr,ri,refLen:escape||iter,escape}}
+function verify(baseBits,re,im,ref,refLen){const bits=baseBits+64,R=re<<64n,I=im<<64n,B=BigInt(bits),ONE=1n<<B,BAIL=16n*ONE,targets=new Set([0,refLen]);for(let n=1;n<refLen;n*=2)targets.add(n);const stride=Math.max(1,Math.floor(refLen/32));for(let n=stride;n<refLen;n+=stride)targets.add(n);let zr=0n,zi=0n,escape=0,mismatch=false,checked=0;for(let n=0;n<=refLen&&!escape&&!mismatch;n++){if(targets.has(n)){checked++;if(!Object.is(fixedNum(zr,bits),ref.rr[n])||!Object.is(fixedNum(zi,bits),ref.ri[n]))mismatch=true}if(n===refLen)break;const zr2=roundShift(zr*zr,bits),zi2=roundShift(zi*zi,bits);zi=roundShift(2n*zr*zi,bits)+I;zr=zr2-zi2+R;const mag=roundShift(zr*zr,bits)+roundShift(zi*zi,bits);if(mag>BAIL)escape=n+1}return{mismatch,checked}}
+function packRefs(rr,ri,refLen){const buf=new ArrayBuffer((refLen+1)*16),dv=new DataView(buf);for(let i=0;i<=refLen;i++){const hr=Math.fround(rr[i]),hi=Math.fround(ri[i]),lr=Math.fround(rr[i]-hr),li=Math.fround(ri[i]-hi),o=i*16;dv.setFloat32(o,hr,true);dv.setFloat32(o+4,hi,true);dv.setFloat32(o+8,lr,true);dv.setFloat32(o+12,li,true)}return buf}
+self.onmessage=e=>{const d=e.data;if(!d||d.type!=='build')return;const t0=performance.now();try{const bits=d.bits+64,re=BigInt(d.re)<<64n,im=BigInt(d.im)<<64n,ref=orbit(bits,re,im,Math.min(MAX_REF-1,d.iter)),v=verify(bits,re,im,ref,ref.refLen),refs=packRefs(ref.rr,ref.ri,ref.refLen);postMessage({type:'built',id:d.id,key:d.key,refLen:ref.refLen,escape:ref.escape,precisionBits:bits,checkpointMismatch:v.mismatch,checkpointCount:v.checked,buildMs:performance.now()-t0,refs},[refs])}catch(error){postMessage({type:'error',id:d.id,error:String(error&&error.stack||error)})}}
+`}
+class ReferenceService{
+  constructor(){this.worker=null;this.url='';this.serial=0;this.pending=new Map();this.cache=null;this.failed=false}
+  ensure(){if(this.worker)return true;if(this.failed||typeof Worker==='undefined'||typeof Blob==='undefined')return false;try{this.url=URL.createObjectURL(new Blob([referenceWorkerSource()],{type:'text/javascript'}));this.worker=new Worker(this.url);this.worker.onmessage=e=>{const d=e.data,p=this.pending.get(d.id);if(!p)return;this.pending.delete(d.id);if(d.type==='error')p.reject(new Error(d.error));else{runtime.referenceBuilds++;this.cache=d;p.resolve(d)}};this.worker.onerror=e=>{this.failed=true;for(const p of this.pending.values())p.reject(new Error(e.message||'reference worker error'));this.pending.clear();this.destroy()};return true}catch{this.failed=true;return false}}
+  request(snap,iter){const key=[snap.bits,snap.re,snap.im,iter,'guarded-perturb-v24.1'].join(':');if(this.cache&&this.cache.key===key)return Promise.resolve(this.cache);if(this.pending.size)this.cancelPending('superseded reference request');if(!this.ensure())return Promise.reject(new Error('Reference Workerを作成できません'));const id=++this.serial;return new Promise((resolve,reject)=>{this.pending.set(id,{resolve,reject});this.worker.postMessage({type:'build',id,key,bits:snap.bits,re:snap.re.toString(),im:snap.im.toString(),iter})})}
+  cancelPending(reason='cancelled'){if(!this.pending.size)return;for(const p of this.pending.values())p.reject(new Error(reason));this.pending.clear();if(this.worker){try{this.worker.terminate()}catch{}this.worker=null}if(this.url){try{URL.revokeObjectURL(this.url)}catch{}this.url=''}}
+  destroy(){this.cancelPending('destroyed');if(this.worker){try{this.worker.terminate()}catch{}this.worker=null}if(this.url){try{URL.revokeObjectURL(this.url)}catch{}this.url=''}}
+}
+const refs=new ReferenceService();
+
+// ── WebGPU renderer ──────────────────────────────────────────────────────
+function buf(device,size,usage,label){return device.createBuffer({label,size:Math.max(4,Math.ceil(size/4)*4),usage})}
+function destroy(x){if(x&&x.destroy)try{x.destroy()}catch{}}
+function writeU32F32(size,writer){const a=new ArrayBuffer(size),d=new DataView(a);writer(d);return a}
+class WebGpuRenderer{
+  constructor(adapter,device){
+    this.adapter=adapter;this.device=device;
+    const ai=adapter.info||{};
+    this.adapterInfo={vendor:ai.vendor||'',architecture:ai.architecture||'',device:ai.device||'',description:ai.description||''};
+    this.adapterLimits={maxBufferSize:Number(adapter.limits.maxBufferSize),maxStorageBufferBindingSize:Number(adapter.limits.maxStorageBufferBindingSize),maxComputeWorkgroupsPerDimension:Number(adapter.limits.maxComputeWorkgroupsPerDimension),maxTextureDimension2D:Number(adapter.limits.maxTextureDimension2D)};
+    this.context=null;this.format=navigator.gpu.getPreferredCanvasFormat();
+    this.frame=null;this.deepCtx=null;this.exportWs=null;this.compilation=[];this.uncapturedErrors=[];this.lossReason='';this.sampler=device.createSampler({magFilter:'linear',minFilter:'linear'});
+    device.addEventListener?.('uncapturederror',e=>{const msg=String(e.error&&e.error.message||e.error||'WebGPU uncaptured error');this.uncapturedErrors.push(msg);state.gpuError=msg;console.error(e.error||e)});
+    this.ready=this.initPipelines();
+    device.lost.then(info=>{this.lossReason=info.message||info.reason||'device lost';runtime.deviceLosses++;state.gpuError=this.lossReason;renderer=null;markDirty(false);initRenderer()});
+  }
+  configure(){if(this.context)this.context.configure({device:this.device,format:this.format,alphaMode:'opaque'})}
+  async module(label,code){const m=this.device.createShaderModule({label,code});if(m.getCompilationInfo){const info=await m.getCompilationInfo();const errs=info.messages.filter(x=>x.type==='error');this.compilation.push({label,messages:info.messages.map(x=>({type:x.type,line:x.lineNum,message:x.message}))});if(errs.length)throw new Error(label+': '+errs.map(x=>x.message).join('\n'))}return m}
+  async initPipelines(){
+    this.device.pushErrorScope?.('validation');
+    try{
+      const [dm,xm,cm,am,pm]=await Promise.all([this.module('direct',G.DIRECT_F32_WGSL),this.module('deep',G.DEEP_PERTURB_WGSL),this.module('color',G.COLOR_WGSL),this.module('aa-resolve',G.AA_RESOLVE_WGSL),this.module('present',G.PRESENT_WGSL)]);
+      this.direct=this.device.createComputePipeline({layout:'auto',compute:{module:dm,entryPoint:'main'}});
+      this.deep=this.device.createComputePipeline({layout:'auto',compute:{module:xm,entryPoint:'main'}});
+      this.color=this.device.createComputePipeline({layout:'auto',compute:{module:cm,entryPoint:'main'}});
+      this.aaResolve=this.device.createComputePipeline({layout:'auto',compute:{module:am,entryPoint:'main'}});
+      this.present=this.device.createRenderPipeline({layout:'auto',vertex:{module:pm,entryPoint:'vs'},fragment:{module:pm,entryPoint:'fs',targets:[{format:this.format}]},primitive:{topology:'triangle-list'}});
+      this.context=canvas.getContext('webgpu');
+      if(!this.context)throw new Error('WebGPU canvas contextを取得できません');
+      webgpuCanvasClaimed=true;this.configure();
+    }finally{if(this.device.popErrorScope){const error=await this.device.popErrorScope();if(error)throw error}}
+  }
+  frameDestroy(){if(!this.frame)return;for(const k of ['meta','smooth','unresolved','numericParams','colorParams','presentParams','front','back'])destroy(this.frame[k]);this.frame=null}
+  ensureFrame(w,h){
+    const n=w*h;if(this.frame&&this.frame.w===w&&this.frame.h===h)return this.frame;this.frameDestroy();const d=this.device,B=GPUBufferUsage,T=GPUTextureUsage;
+    this.frame={w,h,n,meta:buf(d,n*4,B.STORAGE|B.COPY_SRC|B.COPY_DST,'field-meta'),smooth:buf(d,n*4,B.STORAGE|B.COPY_SRC|B.COPY_DST,'field-smooth'),unresolved:buf(d,16,B.STORAGE|B.COPY_SRC|B.COPY_DST,'unresolved-count'),numericParams:buf(d,64,B.UNIFORM|B.COPY_DST,'numeric-params'),colorParams:buf(d,32,B.UNIFORM|B.COPY_DST,'color-params'),presentParams:buf(d,16,B.UNIFORM|B.COPY_DST,'present-params'),front:d.createTexture({size:[w,h],format:'rgba8unorm',usage:T.STORAGE_BINDING|T.TEXTURE_BINDING|T.COPY_SRC,label:'front-color'}),back:d.createTexture({size:[w,h],format:'rgba8unorm',usage:T.STORAGE_BINDING|T.TEXTURE_BINDING|T.COPY_SRC,label:'back-color'})};return this.frame;
+  }
+  ensureExportWorkspace(){
+    if(this.exportWs)return this.exportWs;const d=this.device,B=GPUBufferUsage,T=GPUTextureUsage,S=512,n=S*S,bpr=S*4,pixelBytes=bpr*S;
+    this.exportWs={size:S,meta:buf(d,n*4,B.STORAGE|B.COPY_DST,'export-meta'),smooth:buf(d,n*4,B.STORAGE|B.COPY_DST,'export-smooth'),unresolved:buf(d,16,B.STORAGE|B.COPY_SRC|B.COPY_DST,'export-unresolved'),pbufs:Array.from({length:4},(_,i)=>buf(d,64,B.UNIFORM|B.COPY_DST,'export-numeric-'+i)),cbuf:buf(d,32,B.UNIFORM|B.COPY_DST,'export-color'),samples:Array.from({length:4},(_,i)=>d.createTexture({label:'export-sample-'+i,size:[S,S],format:'rgba8unorm',usage:T.STORAGE_BINDING|T.TEXTURE_BINDING})),tex:d.createTexture({label:'export-resolve',size:[S,S],format:'rgba8unorm',usage:T.STORAGE_BINDING|T.COPY_SRC}),read:buf(d,pixelBytes+16,B.COPY_DST|B.MAP_READ,'export-readback')};return this.exportWs;
+  }
+  exportWorkspaceDestroy(){if(!this.exportWs)return;for(const k of ['meta','smooth','unresolved','cbuf','tex','read'])destroy(this.exportWs[k]);for(const b of this.exportWs.pbufs)destroy(b);for(const t of this.exportWs.samples)destroy(t);this.exportWs=null}
+  setDeepContext(ctx){if(this.deepCtx&&this.deepCtx.key===ctx.key)return;this.destroyDeepContext();const d=this.device,B=GPUBufferUsage,refsB=buf(d,ctx.refs.byteLength,B.STORAGE|B.COPY_DST,'reference-orbit');d.queue.writeBuffer(refsB,0,ctx.refs);this.deepCtx={...ctx,refsB}}
+  destroyDeepContext(){if(this.deepCtx)destroy(this.deepCtx.refsB);this.deepCtx=null}
+  directParams(w,h,fullW,fullH,tileX,tileY,iter,snap,sx=.5,sy=.5,strict=0){return writeU32F32(64,d=>{[w,h,fullW,fullH,tileX,tileY,iter,strict].forEach((v,i)=>d.setUint32(i*4,v,true));d.setFloat32(32,Math.fround(fixedNum(snap.re,snap.bits)),true);d.setFloat32(36,Math.fround(fixedNum(snap.im,snap.bits)),true);d.setFloat32(40,Math.fround(fixedNum(snap.span,snap.bits)),true);d.setFloat32(44,sx,true);d.setFloat32(48,sy,true)})}
+  deepParams(w,h,fullW,fullH,tileX,tileY,iter,snap,sx=.5,sy=.5,strict=0){const se=spanMantExp(snap);return writeU32F32(64,d=>{[w,h,fullW,fullH,tileX,tileY,iter,this.deepCtx.refLen,strict,0,0,0].forEach((v,i)=>d.setUint32(i*4,v,true));d.setFloat32(48,Math.fround(se.mant),true);d.setInt32(52,se.exp,true);d.setFloat32(56,sx,true);d.setFloat32(60,sy,true)})}
+  colorParamsData(w,h){return writeU32F32(32,d=>{d.setUint32(0,w,true);d.setUint32(4,h,true);d.setUint32(8,state.palette,true);d.setUint32(12,state.hq?1:0,true);d.setFloat32(16,state.cycle,true);d.setFloat32(20,state.shift,true)})}
+  async computeFrame(snap,iter,deep,deepContext,token,forceStrict=false){
+    await this.ready;const f=this.ensureFrame(canvas.width,canvas.height),d=this.device;if(deep)this.setDeepContext(deepContext);d.queue.writeBuffer(f.unresolved,0,new Uint32Array(4));
+    d.queue.writeBuffer(f.numericParams,0,deep?this.deepParams(f.w,f.h,f.w,f.h,0,0,iter,snap,.5,.5,forceStrict?1:0):this.directParams(f.w,f.h,f.w,f.h,0,0,iter,snap));
+    d.queue.writeBuffer(f.colorParams,0,this.colorParamsData(f.w,f.h));const encoder=d.createCommandEncoder({label:'mandelbrot-frame'});
+    if(deep){const bg=d.createBindGroup({layout:this.deep.getBindGroupLayout(0),entries:[{binding:0,resource:{buffer:f.numericParams}},{binding:1,resource:{buffer:this.deepCtx.refsB}},{binding:2,resource:{buffer:f.meta}},{binding:3,resource:{buffer:f.smooth}},{binding:4,resource:{buffer:f.unresolved}}]}),pass=encoder.beginComputePass();pass.setPipeline(this.deep);pass.setBindGroup(0,bg);pass.dispatchWorkgroups(Math.ceil(f.w/8),Math.ceil(f.h/8));pass.end();}
+    else{const bg=d.createBindGroup({layout:this.direct.getBindGroupLayout(0),entries:[{binding:0,resource:{buffer:f.numericParams}},{binding:1,resource:{buffer:f.meta}},{binding:2,resource:{buffer:f.smooth}}]}),pass=encoder.beginComputePass();pass.setPipeline(this.direct);pass.setBindGroup(0,bg);pass.dispatchWorkgroups(Math.ceil(f.w/8),Math.ceil(f.h/8));pass.end();}
+    const cbg=d.createBindGroup({layout:this.color.getBindGroupLayout(0),entries:[{binding:0,resource:{buffer:f.colorParams}},{binding:1,resource:{buffer:f.meta}},{binding:2,resource:{buffer:f.smooth}},{binding:3,resource:f.back.createView()}]}),cp=encoder.beginComputePass();cp.setPipeline(this.color);cp.setBindGroup(0,cbg);cp.dispatchWorkgroups(Math.ceil(f.w/8),Math.ceil(f.h/8));cp.end();
+    d.queue.submit([encoder.finish()]);await d.queue.onSubmittedWorkDone();if(token!==state.token)return false;[f.front,f.back]=[f.back,f.front];runtime.gpuFrames++;return true;
+  }
+  async recolor(token){await this.ready;if(!this.frame)return false;const f=this.frame,d=this.device;d.queue.writeBuffer(f.colorParams,0,this.colorParamsData(f.w,f.h));const e=d.createCommandEncoder(),bg=d.createBindGroup({layout:this.color.getBindGroupLayout(0),entries:[{binding:0,resource:{buffer:f.colorParams}},{binding:1,resource:{buffer:f.meta}},{binding:2,resource:{buffer:f.smooth}},{binding:3,resource:f.back.createView()}]}),p=e.beginComputePass();p.setPipeline(this.color);p.setBindGroup(0,bg);p.dispatchWorkgroups(Math.ceil(f.w/8),Math.ceil(f.h/8));p.end();d.queue.submit([e.finish()]);await d.queue.onSubmittedWorkDone();if(token!==state.token)return false;[f.front,f.back]=[f.back,f.front];runtime.gpuRecolors++;return true}
+  presentTransform(view=state.frameView){if(!this.frame||!view)return{scaleX:1,scaleY:1,offsetX:0,offsetY:0};const cur=snapshot(),b=Math.max(cur.bits,view.bits),cs=align(cur.span,cur.bits,b),ps=align(view.span,view.bits,b),dr=align(cur.re,cur.bits,b)-align(view.re,view.bits,b),di=align(cur.im,cur.bits,b)-align(view.im,view.bits,b),scale=fixedRatio(cs,ps);return{scaleX:scale,scaleY:scale,offsetX:fixedRatio(dr,ps),offsetY:-fixedRatio(di,ps)*this.frame.w/Math.max(1,this.frame.h)}}
+  presentFrame(transform=this.presentTransform()){if(!this.frame)return;const d=this.device,pb=this.frame.presentParams;d.queue.writeBuffer(pb,0,new Float32Array([transform.scaleX,transform.scaleY,transform.offsetX,transform.offsetY]));const bg=d.createBindGroup({layout:this.present.getBindGroupLayout(0),entries:[{binding:0,resource:this.sampler},{binding:1,resource:this.frame.front.createView()},{binding:2,resource:{buffer:pb}}]}),e=d.createCommandEncoder(),pass=e.beginRenderPass({colorAttachments:[{view:this.context.getCurrentTexture().createView(),clearValue:{r:.0196,g:.0314,b:.0745,a:1},loadOp:'clear',storeOp:'store'}]});pass.setPipeline(this.present);pass.setBindGroup(0,bg);pass.draw(3);pass.end();d.queue.submit([e.finish()])}
+  async readMeta(indices){if(!this.frame||!indices.length)return new Uint32Array();const d=this.device,B=GPUBufferUsage,r=buf(d,indices.length*4,B.COPY_DST|B.MAP_READ),e=d.createCommandEncoder();for(let i=0;i<indices.length;i++)e.copyBufferToBuffer(this.frame.meta,indices[i]*4,r,i*4,4);d.queue.submit([e.finish()]);await r.mapAsync(GPUMapMode.READ);const out=new Uint32Array(r.getMappedRange().slice(0));r.unmap();destroy(r);return out}
+  async readUnresolved(){if(!this.frame)return 0;const d=this.device,B=GPUBufferUsage,r=buf(d,16,B.COPY_DST|B.MAP_READ),e=d.createCommandEncoder();e.copyBufferToBuffer(this.frame.unresolved,0,r,0,16);d.queue.submit([e.finish()]);await r.mapAsync(GPUMapMode.READ);const value=new Uint32Array(r.getMappedRange().slice(0))[0];r.unmap();destroy(r);return value}
+  async renderTileMeta({snap,iter,deep,deepContext,fullW,fullH,tileX=0,tileY=0,w,h,sampleX=.5,sampleY=.5,forceStrict=false}){
+    await this.ready;if(deep)this.setDeepContext(deepContext);const d=this.device,B=GPUBufferUsage,n=w*h,meta=buf(d,n*4,B.STORAGE|B.COPY_SRC|B.COPY_DST),smooth=buf(d,n*4,B.STORAGE|B.COPY_DST),unresolved=buf(d,16,B.STORAGE|B.COPY_DST),pbuf=buf(d,64,B.UNIFORM|B.COPY_DST),encoder=d.createCommandEncoder({label:'numeric-probe'});d.queue.writeBuffer(unresolved,0,new Uint32Array(4));
+    if(deep){d.queue.writeBuffer(pbuf,0,this.deepParams(w,h,fullW,fullH,tileX,tileY,iter,snap,sampleX,sampleY,forceStrict?1:0));const bg=d.createBindGroup({layout:this.deep.getBindGroupLayout(0),entries:[{binding:0,resource:{buffer:pbuf}},{binding:1,resource:{buffer:this.deepCtx.refsB}},{binding:2,resource:{buffer:meta}},{binding:3,resource:{buffer:smooth}},{binding:4,resource:{buffer:unresolved}}]}),pass=encoder.beginComputePass();pass.setPipeline(this.deep);pass.setBindGroup(0,bg);pass.dispatchWorkgroups(Math.ceil(w/8),Math.ceil(h/8));pass.end();}
+    else{d.queue.writeBuffer(pbuf,0,this.directParams(w,h,fullW,fullH,tileX,tileY,iter,snap,sampleX,sampleY));const bg=d.createBindGroup({layout:this.direct.getBindGroupLayout(0),entries:[{binding:0,resource:{buffer:pbuf}},{binding:1,resource:{buffer:meta}},{binding:2,resource:{buffer:smooth}}]}),pass=encoder.beginComputePass();pass.setPipeline(this.direct);pass.setBindGroup(0,bg);pass.dispatchWorkgroups(Math.ceil(w/8),Math.ceil(h/8));pass.end();}
+    const read=buf(d,n*4,B.COPY_DST|B.MAP_READ);encoder.copyBufferToBuffer(meta,0,read,0,n*4);d.queue.submit([encoder.finish()]);await read.mapAsync(GPUMapMode.READ);const out=new Uint32Array(read.getMappedRange().slice(0));read.unmap();[meta,smooth,unresolved,pbuf,read].forEach(destroy);return out;
+  }
+  async renderTileRGBA({snap,iter,deep,deepContext,fullW,fullH,tileX,tileY,w,h,sampleX=.5,sampleY=.5,edgeAA=false,forceStrict=false}){
+    await this.ready;if(w>512||h>512)throw new Error('export tile exceeds reusable workspace');if(deep)this.setDeepContext(deepContext);const d=this.device,ws=this.ensureExportWorkspace(),meta=ws.meta,smooth=ws.smooth,unresolved=ws.unresolved,pbuf=ws.pbufs[0],tex=ws.tex,encoder=d.createCommandEncoder();d.queue.writeBuffer(unresolved,0,new Uint32Array(4));
+    if(deep){d.queue.writeBuffer(pbuf,0,this.deepParams(w,h,fullW,fullH,tileX,tileY,iter,snap,sampleX,sampleY,forceStrict?1:0));const bg=d.createBindGroup({layout:this.deep.getBindGroupLayout(0),entries:[{binding:0,resource:{buffer:pbuf}},{binding:1,resource:{buffer:this.deepCtx.refsB}},{binding:2,resource:{buffer:meta}},{binding:3,resource:{buffer:smooth}},{binding:4,resource:{buffer:unresolved}}]}),p=encoder.beginComputePass();p.setPipeline(this.deep);p.setBindGroup(0,bg);p.dispatchWorkgroups(Math.ceil(w/8),Math.ceil(h/8));p.end();}
+    else{d.queue.writeBuffer(pbuf,0,this.directParams(w,h,fullW,fullH,tileX,tileY,iter,snap,sampleX,sampleY));const bg=d.createBindGroup({layout:this.direct.getBindGroupLayout(0),entries:[{binding:0,resource:{buffer:pbuf}},{binding:1,resource:{buffer:meta}},{binding:2,resource:{buffer:smooth}}]}),p=encoder.beginComputePass();p.setPipeline(this.direct);p.setBindGroup(0,bg);p.dispatchWorkgroups(Math.ceil(w/8),Math.ceil(h/8));p.end();}
+    const ca=this.colorParamsData(w,h),cd=new DataView(ca);cd.setUint32(12,edgeAA?1:0,true);d.queue.writeBuffer(ws.cbuf,0,ca);const cbg=d.createBindGroup({layout:this.color.getBindGroupLayout(0),entries:[{binding:0,resource:{buffer:ws.cbuf}},{binding:1,resource:{buffer:meta}},{binding:2,resource:{buffer:smooth}},{binding:3,resource:tex.createView()}]}),cp=encoder.beginComputePass();cp.setPipeline(this.color);cp.setBindGroup(0,cbg);cp.dispatchWorkgroups(Math.ceil(w/8),Math.ceil(h/8));cp.end();
+    const bpr=Math.ceil(w*4/256)*256,pixelBytes=bpr*h;encoder.copyTextureToBuffer({texture:tex},{buffer:ws.read,bytesPerRow:bpr,rowsPerImage:h},{width:w,height:h});encoder.copyBufferToBuffer(unresolved,0,ws.read,pixelBytes,16);d.queue.submit([encoder.finish()]);await ws.read.mapAsync(GPUMapMode.READ,0,pixelBytes+16);const raw=new Uint8Array(ws.read.getMappedRange(0,pixelBytes+16)),out=new Uint8ClampedArray(w*h*4);for(let y=0;y<h;y++)out.set(raw.subarray(y*bpr,y*bpr+w*4),y*w*4);const unresolvedCount=new DataView(raw.buffer,raw.byteOffset+pixelBytes,16).getUint32(0,true);ws.read.unmap();return{rgba:out,unresolved:unresolvedCount};
+  }
+  async renderTileRGBA2x({snap,iter,deep,deepContext,fullW,fullH,tileX,tileY,w,h,forceStrict=false}){
+    await this.ready;if(w>512||h>512)throw new Error('export tile exceeds reusable workspace');if(deep)this.setDeepContext(deepContext);const d=this.device,ws=this.ensureExportWorkspace(),meta=ws.meta,smooth=ws.smooth,unresolved=ws.unresolved,encoder=d.createCommandEncoder({label:'export-aa2x'}),offsets=[[.25,.25],[.75,.25],[.25,.75],[.75,.75]],ca=this.colorParamsData(w,h);new DataView(ca).setUint32(12,0,true);d.queue.writeBuffer(ws.cbuf,0,ca);d.queue.writeBuffer(unresolved,0,new Uint32Array(4));
+    for(let si=0;si<4;si++){const [sampleX,sampleY]=offsets[si],pbuf=ws.pbufs[si];if(deep){d.queue.writeBuffer(pbuf,0,this.deepParams(w,h,fullW,fullH,tileX,tileY,iter,snap,sampleX,sampleY,forceStrict?1:0));const bg=d.createBindGroup({layout:this.deep.getBindGroupLayout(0),entries:[{binding:0,resource:{buffer:pbuf}},{binding:1,resource:{buffer:this.deepCtx.refsB}},{binding:2,resource:{buffer:meta}},{binding:3,resource:{buffer:smooth}},{binding:4,resource:{buffer:unresolved}}]}),pass=encoder.beginComputePass();pass.setPipeline(this.deep);pass.setBindGroup(0,bg);pass.dispatchWorkgroups(Math.ceil(w/8),Math.ceil(h/8));pass.end();}else{d.queue.writeBuffer(pbuf,0,this.directParams(w,h,fullW,fullH,tileX,tileY,iter,snap,sampleX,sampleY));const bg=d.createBindGroup({layout:this.direct.getBindGroupLayout(0),entries:[{binding:0,resource:{buffer:pbuf}},{binding:1,resource:{buffer:meta}},{binding:2,resource:{buffer:smooth}}]}),pass=encoder.beginComputePass();pass.setPipeline(this.direct);pass.setBindGroup(0,bg);pass.dispatchWorkgroups(Math.ceil(w/8),Math.ceil(h/8));pass.end();}const cbg=d.createBindGroup({layout:this.color.getBindGroupLayout(0),entries:[{binding:0,resource:{buffer:ws.cbuf}},{binding:1,resource:{buffer:meta}},{binding:2,resource:{buffer:smooth}},{binding:3,resource:ws.samples[si].createView()}]}),cp=encoder.beginComputePass();cp.setPipeline(this.color);cp.setBindGroup(0,cbg);cp.dispatchWorkgroups(Math.ceil(w/8),Math.ceil(h/8));cp.end();}
+    const abg=d.createBindGroup({layout:this.aaResolve.getBindGroupLayout(0),entries:[{binding:0,resource:ws.samples[0].createView()},{binding:1,resource:ws.samples[1].createView()},{binding:2,resource:ws.samples[2].createView()},{binding:3,resource:ws.samples[3].createView()},{binding:4,resource:ws.tex.createView()}]}),ap=encoder.beginComputePass();ap.setPipeline(this.aaResolve);ap.setBindGroup(0,abg);ap.dispatchWorkgroups(Math.ceil(w/8),Math.ceil(h/8));ap.end();
+    const bpr=Math.ceil(w*4/256)*256,pixelBytes=bpr*h;encoder.copyTextureToBuffer({texture:ws.tex},{buffer:ws.read,bytesPerRow:bpr,rowsPerImage:h},{width:w,height:h});encoder.copyBufferToBuffer(unresolved,0,ws.read,pixelBytes,16);d.queue.submit([encoder.finish()]);await ws.read.mapAsync(GPUMapMode.READ,0,pixelBytes+16);const raw=new Uint8Array(ws.read.getMappedRange(0,pixelBytes+16)),out=new Uint8ClampedArray(w*h*4);for(let y=0;y<h;y++)out.set(raw.subarray(y*bpr,y*bpr+w*4),y*w*4);const unresolvedCount=new DataView(raw.buffer,raw.byteOffset+pixelBytes,16).getUint32(0,true);ws.read.unmap();return{rgba:out,unresolved:unresolvedCount};
+  }
+  destroy(){this.frameDestroy();this.exportWorkspaceDestroy();this.destroyDeepContext()}
+}
+
+// ── GPU startup / rendering orchestration ────────────────────────────────
+async function initRenderer(){if(renderer)return renderer;if(rendererInitPromise)return rendererInitPromise;if(state.gpuInitFailed)return null;if(!navigator.gpu){state.gpuInitFailed=false;state.gpuUnavailable=true;state.gpuError='WebGPU非対応';ensureFallback();return null}rendererInitPromise=(async()=>{try{let adapter=await navigator.gpu.requestAdapter({powerPreference:'high-performance'});if(!adapter)adapter=await navigator.gpu.requestAdapter();if(!adapter){state.gpuInitFailed=false;state.gpuUnavailable=true;state.gpuError='WebGPU adapterがありません';ensureFallback();return null}const device=await adapter.requestDevice();const r=new WebGpuRenderer(adapter,device);await r.ready;renderer=r;state.gpuInitFailed=false;state.gpuUnavailable=false;state.gpuError='';resize();markDirty(false);return r}catch(e){state.gpuInitFailed=true;state.gpuError='WebGPU初期化失敗: '+String(e&&e.message||e);updateStats();return null}finally{rendererInitPromise=null}})();return rendererInitPromise}
+function ensureFallback(){if(fallbackCtx)return fallbackCtx;if(webgpuCanvasClaimed)return null;try{fallbackCtx=canvas.getContext('2d',{alpha:false})}catch{}return fallbackCtx}
+function cancelRender(){state.token++;state.rendering=false;state.recolorPending=false;refs.cancelPending('render cancelled')}
+function markDirty(cancel=true){if(cancel)cancelRender();state.dirty=true;state.lastInteraction=performance.now();state.drawState=state.frameView?'REPROJECTED':'PREVIEW';schedule()}
+function schedule(){if(!raf)raf=requestAnimationFrame(loop)}
+async function renderFrame(){const token=++state.token,snap=snapshot(),iter=maxIter(),deep=deepNeeded(snap,canvas.width),t0=performance.now();state.rendering=true;state.dirty=false;state.drawState='COVERING';runtime.renderStarts++;updateStats();try{const r=renderer||await initRenderer();if(token!==state.token)return;if(!r){if(state.gpuInitFailed){state.rendering=false;state.drawState='ERROR';state.lastEngine='WebGPU shader/pipeline error';updateStats();return}renderFallback(token,snap,iter);return}let ctx=null;if(deep){state.lastEngine='WebGPU · reference準備';updateStats();ctx=await refs.request(snap,iter);if(token!==state.token)return;if(ctx.checkpointMismatch)throw new Error('reference guard checkpoint mismatch');state.lastEngine='WebGPU · guarded rescaled perturbation'}else state.lastEngine='WebGPU · f32 direct';const ok=await r.computeFrame(snap,iter,deep,ctx,token,state.processMode==='validate');if(!ok)return;state.frameView=snap;state.fieldView={...snap,iter,w:canvas.width,h:canvas.height,deep};state.drawState=state.hq?'REFINED':'COVERED';state.lastRender=performance.now()-t0;state.rendering=false;state.unresolved=0;const pendingColor=state.recolorPending;if(pendingColor){state.recolorPending=false;recolor()}else r.presentFrame({scaleX:1,scaleY:1,offsetX:0,offsetY:0});updateStats();if(deep)r.readUnresolved().then(q=>{if(token===state.token){state.unresolved=q||0;updateStats()}}).catch(()=>{})}catch(e){if(token!==state.token)return;state.rendering=false;state.gpuError=String(e&&e.message||e);state.lastEngine='WebGPU error';updateStats();console.error(e)}}
+function renderFallback(token,snap,iter){const ctx=ensureFallback();if(!ctx){state.rendering=false;return}const w=canvas.width,h=canvas.height;if(deepNeeded(snap,w)){state.rendering=false;state.gpuError='このズーム深度はWebGPUが必要です';state.lastEngine='Fallback · deep unsupported';updateStats();return}const img=ctx.createImageData(w,h),out=img.data,cre=fixedNum(snap.re,snap.bits),cim=fixedNum(snap.im,snap.bits),sp=fixedNum(snap.span,snap.bits),scale=sp/w;let y=0;function slice(){if(token!==state.token)return;const end=performance.now()+8;while(y<h&&performance.now()<end){for(let x=0;x<w;x++){const cr=cre+(x+.5-w*.5)*scale,ci=cim+(h*.5-y-.5)*scale;let zr=0,zi=0,n=0,mag=0;while(n<iter&&mag<=4){const zr2=zr*zr,zi2=zi*zi;zi=2*zr*zi+ci;zr=zr2-zi2+cr;mag=zr*zr+zi*zi;n++}const o=(y*w+x)*4;if(n>=iter){out[o]=out[o+1]=out[o+2]=0}else{const t=(n+1-Math.log2(.5*Math.log2(Math.max(4.0001,mag))))*.008+state.shift;out[o]=255*(.3+.7*(.5+.5*Math.cos(6.28318*t)));out[o+1]=255*(.25+.75*(.5+.5*Math.cos(6.28318*(t+.33))));out[o+2]=255*(.2+.8*(.5+.5*Math.cos(6.28318*(t+.67))))}out[o+3]=255}y++}if(y<h)requestAnimationFrame(slice);else{ctx.putImageData(img,0,0);state.frameView=snap;state.rendering=false;state.lastRender=0;state.lastEngine='JavaScript f64 fallback（深部非対応）';state.drawState='COVERED';updateStats()}}requestAnimationFrame(slice)}
+async function recolor(){state.recolorPending=true;if(!renderer||!state.fieldView||state.rendering||state.recoloring)return false;state.recoloring=true;let painted=false;try{while(state.recolorPending&&!state.rendering&&renderer&&state.fieldView){state.recolorPending=false;const token=state.token,ok=await renderer.recolor(token);if(!ok||token!==state.token)continue;renderer.presentFrame({scaleX:1,scaleY:1,offsetX:0,offsetY:0});painted=true;updateStats()}return painted}catch(e){console.error(e);return false}finally{state.recoloring=false;if(state.recolorPending&&!state.rendering)queueMicrotask(recolor)}}
+function loop(){raf=0;if(state.pointerActive||state.wheelActive){if(renderer&&state.frameView)renderer.presentFrame(renderer.presentTransform());updateStats();return}if(state.dirty&&!state.rendering)renderFrame();else if(renderer&&state.frameView)renderer.presentFrame(renderer.presentTransform())}
+
+// ── interaction / view history ──────────────────────────────────────────
+function viewRect(){return canvas.getBoundingClientRect()}
+function updateFocus(x,y){const r=viewRect();state.focusX=Math.max(0,Math.min(1,(x-r.left)/Math.max(1,r.width)));state.focusY=Math.max(0,Math.min(1,(y-r.top)/Math.max(1,r.height)))}
+function zoomAt(x,y,factor){const r=viewRect(),fx=(x-r.left)/Math.max(1,r.width)-.5,fy=(y-r.top)/Math.max(1,r.height)-.5;factor=Math.max(.01,Math.min(100,factor));const old=state.span,neu=mulRatio(old,factor),dx=BigInt(Math.round(fx*1e9)),dy=BigInt(Math.round(fy*1e9));state.re+=(old-neu)*dx/1000000000n;const oldY=old*BigInt(canvas.height)/BigInt(Math.max(1,canvas.width)),newY=neu*BigInt(canvas.height)/BigInt(Math.max(1,canvas.width));state.im-=(oldY-newY)*dy/1000000000n;state.span=neu;ensurePrecision();state.dirty=true;schedule()}
+function pan(dx,dy){const w=Math.max(1,canvas.clientWidth),h=Math.max(1,canvas.clientHeight);state.re-=state.span*BigInt(Math.round(dx*1e6))/BigInt(Math.round(w*1e6));const ys=state.span*BigInt(canvas.height)/BigInt(Math.max(1,canvas.width));state.im+=ys*BigInt(Math.round(dy*1e6))/BigInt(Math.round(h*1e6));ensurePrecision();state.dirty=true;schedule()}
+function reset(){state.bits=INITIAL_BITS;state.re=-fromFrac(1n,2n);state.im=0n;state.span=fromFrac(34n,10n);ensurePrecision();markDirty();saveHash(false)}
+const pts=new Map();let lx=0,ly=0,pinch=0;
+canvas.addEventListener('wheel',e=>{e.preventDefault();updateFocus(e.clientX,e.clientY);if(!state.wheelActive){cancelRender();state.wheelActive=true}zoomAt(e.clientX,e.clientY,Math.exp(e.deltaY*.00125));clearTimeout(settleTimer);settleTimer=setTimeout(()=>{state.wheelActive=false;recordView();saveHash(false);markDirty()},110)},{passive:false});
+canvas.addEventListener('pointerdown',e=>{updateFocus(e.clientX,e.clientY);try{canvas.setPointerCapture(e.pointerId)}catch{};if(!pts.size){cancelRender();state.pointerActive=true}pts.set(e.pointerId,[e.clientX,e.clientY]);if(pts.size===1){lx=e.clientX;ly=e.clientY}else{const a=[...pts.values()];pinch=Math.hypot(a[0][0]-a[1][0],a[0][1]-a[1][1])}});
+canvas.addEventListener('pointermove',e=>{if(!pts.has(e.pointerId))return;updateFocus(e.clientX,e.clientY);pts.set(e.pointerId,[e.clientX,e.clientY]);if(pts.size===1){const dx=e.clientX-lx,dy=e.clientY-ly;pan(dx,dy);lx=e.clientX;ly=e.clientY}else if(pts.size===2){const a=[...pts.values()],d=Math.hypot(a[0][0]-a[1][0],a[0][1]-a[1][1]);if(pinch>0&&d>0)zoomAt((a[0][0]+a[1][0])/2,(a[0][1]+a[1][1])/2,pinch/d);pinch=d}});
+function endPointer(e){pts.delete(e.pointerId);pinch=0;if(pts.size)return;clearTimeout(settleTimer);settleTimer=setTimeout(()=>{state.pointerActive=false;recordView();saveHash(false);markDirty()},90)}canvas.addEventListener('pointerup',endPointer);canvas.addEventListener('pointercancel',endPointer);
+
+// ── URL / controls ───────────────────────────────────────────────────────
+function saveHash(push){const p=new URLSearchParams();p.set('v',String(VERSION));p.set('b',String(state.bits));p.set('re',state.re.toString());p.set('im',state.im.toString());p.set('sp',state.span.toString());p.set('pal',String(state.palette));p.set('cy',String(state.cycle));p.set('sh',String(state.shift));p.set('it',String(state.baseIter));p.set('ad',state.adaptive?'1':'0');const h='#'+p.toString();lastWrittenHash=h;try{push?history.pushState(null,'',h):history.replaceState(null,'',h)}catch{location.hash=h}}
 function loadHash(){const p=new URLSearchParams(location.hash.slice(1));if(!p.has('b'))return false;try{const b=Number(p.get('b')),re=BigInt(p.get('re')),im=BigInt(p.get('im')),sp=BigInt(p.get('sp'));if(!Number.isInteger(b)||b<64||sp<=0n)return false;state.bits=b;state.re=re;state.im=im;state.span=sp;if(p.has('pal'))state.palette=Math.max(0,Math.min(2,Number(p.get('pal'))|0));if(p.has('cy'))state.cycle=Math.max(.001,Math.min(.05,Number(p.get('cy'))||.008));if(p.has('sh'))state.shift=Math.max(0,Math.min(1,Number(p.get('sh'))||0));if(p.has('it'))state.baseIter=Math.max(100,Math.min(2500,Number(p.get('it'))||350));if(p.has('ad'))state.adaptive=p.get('ad')!=='0';ensurePrecision();return true}catch{return false}}
-function syncControls(){$('#processMode').value=state.processMode;$('#palette').value=String(state.palette);$('#cycle').value=String(state.cycle);$('#cycleO').textContent=state.cycle.toFixed(4);$('#shift').value=String(state.shift);$('#shiftO').textContent=state.shift.toFixed(2);$('#iters').value=String(state.baseIter);$('#itersO').textContent=String(Math.round(state.baseIter));$('#adaptive').checked=state.adaptive;$('#hq').checked=state.hq;syncCoordinateInputs();syncHistoryButtons()}
-function applyHashNavigation(){const h=location.hash;if(h===lastWrittenHash){lastWrittenHash='';return}if(h===navigationHash)return;navigationHash=h;setTimeout(()=>{navigationHash=''},0);if(loadHash()){clearDetailCache();clearPanReuse();recordView();syncControls();setDirty()}}
+function syncCoordinateInputs(){$('#coordReInput').value=fmtFixedExact(state.re);$('#coordImInput').value=fmtFixedExact(state.im);$('#coordSpanInput').value=fmtFixedExact(state.span)}
+function syncHistoryButtons(){$('#undoView').disabled=viewHistoryIndex<=0;$('#redoView').disabled=viewHistoryIndex<0||viewHistoryIndex>=viewHistory.length-1}
+function syncControls(){$('#processMode').value=state.processMode;$('#palette').value=String(state.palette);$('#cycle').value=String(state.cycle);$('#cycleO').textContent=state.cycle.toFixed(4);$('#shift').value=String(state.shift);$('#shiftO').textContent=state.shift.toFixed(2);$('#iters').value=String(state.baseIter);$('#itersO').textContent=String(state.baseIter);$('#adaptive').checked=state.adaptive;$('#hq').checked=state.hq;syncCoordinateInputs();syncHistoryButtons()}
+function toast(s){const e=$('#toast');e.textContent=s;e.classList.add('show');setTimeout(()=>e.classList.remove('show'),1500)}
+function applyUi(){document.body.classList.toggle('ui-hidden',state.uiHidden);$('#uiToggle').textContent=state.uiHidden?'UI＋':'UI−';$('#uiToggle').setAttribute('aria-expanded',state.uiHidden?'false':'true')}
+$('#uiToggle').onclick=()=>{state.uiHidden=!state.uiHidden;try{localStorage.setItem('mandelbrot.uiHidden',state.uiHidden?'1':'0')}catch{}applyUi()};
+$('#zin').onclick=()=>{const r=viewRect();zoomAt(r.left+r.width/2,r.top+r.height/2,.5);recordView();saveHash(false);markDirty()};$('#zout').onclick=()=>{const r=viewRect();zoomAt(r.left+r.width/2,r.top+r.height/2,2);recordView();saveHash(false);markDirty()};$('#reset').onclick=()=>{reset();recordView();syncControls()};
 $('#share').onclick=async()=>{saveHash(true);try{await navigator.clipboard.writeText(location.href);toast('共有URLをコピーしました')}catch{toast('URLを更新しました')}};
-$('#coordApply').onclick=()=>{try{const values=[$('#coordReInput').value,$('#coordImInput').value,$('#coordSpanInput').value],required=Math.max(...values.map(decimalRequiredBits));if(required>state.bits)promoteState(Math.ceil((required-state.bits)/64)*64);const re=fromDec(values[0]),im=fromDec(values[1]),span=fromDec(values[2]);if(span<=0n)throw new Error('表示幅は正数にしてください');state.re=re;state.im=im;state.span=span;ensurePrecision();recordView();saveHash(false);setDirty()}catch(e){toast('座標を適用できません: '+String(e&&e.message||e))}};
-$('#coordCopy').onclick=async()=>{const value=JSON.stringify({rendererVersion:23,bits:state.bits,re:state.re.toString(),im:state.im.toString(),span:state.span.toString(),decimal:{re:fmtFixedExact(state.re),im:fmtFixedExact(state.im),span:fmtFixedExact(state.span)}});try{await navigator.clipboard.writeText(value);toast('正確な座標をコピーしました')}catch{toast('コピーできませんでした')}};
+$('#coordApply').onclick=()=>{try{const values=[$('#coordReInput').value,$('#coordImInput').value,$('#coordSpanInput').value],required=Math.max(...values.map(decimalRequiredBits));if(required>state.bits)promoteState(Math.ceil((required-state.bits)/64)*64);const re=fromDec(values[0]),im=fromDec(values[1]),span=fromDec(values[2]);if(span<=0n)throw new Error('表示幅は正数にしてください');state.re=re;state.im=im;state.span=span;ensurePrecision();recordView();saveHash(false);markDirty()}catch(e){toast('座標を適用できません: '+String(e&&e.message||e))}};
+$('#coordCopy').onclick=async()=>{const value=JSON.stringify({rendererVersion:VERSION,bits:state.bits,re:state.re.toString(),im:state.im.toString(),span:state.span.toString(),decimal:{re:fmtFixedExact(state.re),im:fmtFixedExact(state.im),span:fmtFixedExact(state.span)}});try{await navigator.clipboard.writeText(value);toast('正確な座標をコピーしました')}catch{toast('コピーできませんでした')}};
 $('#undoView').onclick=()=>{if(viewHistoryIndex>0){viewHistoryIndex--;restoreView(viewHistory[viewHistoryIndex]);syncHistoryButtons()}};$('#redoView').onclick=()=>{if(viewHistoryIndex<viewHistory.length-1){viewHistoryIndex++;restoreView(viewHistory[viewHistoryIndex]);syncHistoryButtons()}};
-function bind(id,key,out,fmt,flush=false){const el=$(id),o=$(out),apply=()=>{state[key]=Number(el.value);o.textContent=fmt(Number(el.value));if(flush)clearDetailCache();setDirty()};el.addEventListener('input',apply);apply()}
-function bindColor(id,key,out,fmt){const el=$(id),o=$(out),apply=()=>{state[key]=Number(el.value);o.textContent=fmt(Number(el.value));if(!recolorCurrentField())setDirty()};el.addEventListener('input',apply);apply()}
-bind('#iters','baseIter','#itersO',x=>String(Math.round(x)),true);bindColor('#cycle','cycle','#cycleO',x=>x.toFixed(4));bindColor('#shift','shift','#shiftO',x=>x.toFixed(2));
-$('#palette').onchange=e=>{state.palette=Math.max(0,Math.min(2,Number(e.target.value)|0));if(!recolorCurrentField())setDirty()};
-$('#processMode').onchange=e=>{state.processMode=/^(power|standard|fine|validate)$/.test(e.target.value)?e.target.value:'standard';state.hq=state.processMode==='fine'||state.processMode==='validate';state.adaptivePixelBudget=0;$('#hq').checked=state.hq;try{localStorage.setItem('mandelbrot.processMode',state.processMode)}catch{}resize();setDirty()};
-$('#adaptive').onchange=e=>{state.adaptive=e.target.checked;clearDetailCache();setDirty()};$('#hq').onchange=e=>{state.hq=e.target.checked;if(!state.hq)cancelDetailRefinement(true);setDirty()};
-addEventListener('resize',()=>{resize();setDirty()});addEventListener('keydown',e=>{if(/^(INPUT|SELECT|TEXTAREA|BUTTON)$/.test(e.target.tagName))return;let handled=true;if(e.key==='h'||e.key==='H')$('#uiToggle').click();else if(e.key==='r'||e.key==='R')$('#reset').click();else if(e.key==='+'||e.key==='='||e.key==='Enter'&&!e.shiftKey)$('#zin').click();else if(e.key==='-'||e.key==='Enter'&&e.shiftKey)$('#zout').click();else if(e.key==='ArrowLeft'){capturePanSource();pan(innerWidth*.08,0)}else if(e.key==='ArrowRight'){capturePanSource();pan(-innerWidth*.08,0)}else if(e.key==='ArrowUp'){capturePanSource();pan(0,innerHeight*.08)}else if(e.key==='ArrowDown'){capturePanSource();pan(0,-innerHeight*.08)}else handled=false;if(handled){e.preventDefault();recordView();saveHash(false)}});addEventListener('popstate',applyHashNavigation);addEventListener('hashchange',applyHashNavigation);
-function stopSchedulers(){if(schedulerRAF){cancelAnimationFrame(schedulerRAF);schedulerRAF=0}if(schedulerTimer){clearTimeout(schedulerTimer);schedulerTimer=0;schedulerDue=0}if(wheelSettleTimer){clearTimeout(wheelSettleTimer);wheelSettleTimer=0}if(pointerSettleTimer){clearTimeout(pointerSettleTimer);pointerSettleTimer=0}cancelUnknownContinuation()}
-addEventListener('visibilitychange',()=>{if(document.hidden){exportJob.cancelled=true;stopSchedulers();state.wheelActive=false;cancelRender();cancelDetailRefinement(true)}else{state.lastInteraction=performance.now();state.dirty=true;invalidateView()}});
-globalThis.__MANDEL_DIAG__={snapshot:()=>{const deep=deepEngineNeeded(),ledger=memoryLedger(),coveredProfile=RENDER_PROFILE[RENDER_PASS.COVERED];return{rendererVersion:23,pixelContract:'centered',processMode:state.processMode,automaticTarget:modeTarget(),drawState:state.drawState,coverage:state.coverage,unresolved:state.unresolved,zoom:zoomExp(),deep,legacyDeepThreshold:LEGACY_DEEP_ZOOM_THRESHOLD,bits:state.bits,palette:state.palette,rendering:state.rendering,validating:validationJob.active,exporting:exportJob.active,lastRender:state.lastRender,lastPass:state.lastPass,transformReuse:!!state.panReuse,detailCache:DETAIL_TILE_CACHE.size,detailCacheBytes,detailCacheBudget:detailCacheBudget(),detailActive:state.detailActive,frame:frameCanvas.width+'x'+frameCanvas.height,frameCoverage:frameCanvas.width/Math.max(1,canvas.width),hqTarget:targetSize(coveredProfile,deep).join('x'),scheduler:{raf:!!schedulerRAF,timer:!!schedulerTimer,needsPaint,needsStats,wheelActive:state.wheelActive,pointerSettle:!!pointerSettleTimer,unknownTimer:!!unknownContinuationTimer,backgroundJobs:runtimeMetrics.pendingBackgroundJobs},screen:{effectiveDpr:state.effectiveDpr,deviceDpr:window.devicePixelRatio||1,pixelBudget:state.screenPixelBudget,pixels:canvas.width*canvas.height},memory:ledger,shallowAssets:{wasmReady:!!wasm,worker:!!shallowWorker,workerBusy:shallowWorkerBusy},deepAssets:{wasmReady:!!deepWasm,workers:deepPool.workers.length},runtimeMetrics:{...runtimeMetrics},telemetry:{...deepTelemetry},renderPerf:{...renderPerf},wisdom:{workerCount:deepWisdom.workerCount,rowMsEMA:deepWisdom.rowMsEMA,stripRows:deepWisdom.stripRows,realBench:deepWisdom.realBench},reference:{id:referenceCache.id,bits:referenceCache.bits,n:referenceCache.n,escape:referenceCache.escape,buildMs:refControl.lastBuildMs,buildEMA:refControl.buildEMA,baseMPP:refControl.baseMPP,lastMPP:refControl.lastMPP,conditionLog2:referenceCache.conditionLog2,checkpointBits:referenceCache.checkpointBits,checkpointCount:referenceCache.checkpointCount,checkpointMismatch:referenceCache.checkpointMismatch}}},memoryLedger:()=>memoryLedger()};
-addEventListener('pagehide',()=>{stopSchedulers();destroyShallowWorker();destroyDeepPool()},{once:true});
-try{state.uiHidden=localStorage.getItem('mandelbrot.uiHidden')==='1';const savedMode=localStorage.getItem('mandelbrot.processMode');if(/^(power|standard|fine|validate)$/.test(savedMode)){state.processMode=savedMode;state.hq=savedMode==='fine'||savedMode==='validate'}}catch{}restoreDeepWisdom();applyUiVisibility();resize();if(!loadHash())reset();else setDirty();recordView();syncControls();ctx.fillStyle='#050813';ctx.fillRect(0,0,canvas.width,canvas.height);render(RENDER_PASS.PREVIEW);requestScheduler();
+$('#palette').onchange=e=>{state.palette=Math.max(0,Math.min(2,Number(e.target.value)|0));recolor()};$('#cycle').oninput=e=>{state.cycle=Number(e.target.value);$('#cycleO').textContent=state.cycle.toFixed(4);recolor()};$('#shift').oninput=e=>{state.shift=Number(e.target.value);$('#shiftO').textContent=state.shift.toFixed(2);recolor()};
+$('#iters').oninput=e=>{state.baseIter=Number(e.target.value);$('#itersO').textContent=String(state.baseIter);markDirty()};$('#adaptive').onchange=e=>{state.adaptive=e.target.checked;markDirty()};$('#hq').onchange=e=>{state.hq=e.target.checked;recolor()};
+$('#processMode').onchange=e=>{state.processMode=/^(power|standard|fine|validate)$/.test(e.target.value)?e.target.value:'standard';state.hq=state.processMode==='fine'||state.processMode==='validate';$('#hq').checked=state.hq;resize();markDirty();try{localStorage.setItem('mandelbrot.processMode',state.processMode)}catch{}};
+addEventListener('resize',()=>{resize();markDirty()});addEventListener('keydown',e=>{if(/^(INPUT|SELECT|TEXTAREA|BUTTON)$/.test(e.target.tagName))return;let ok=true;if(e.key==='h'||e.key==='H')$('#uiToggle').click();else if(e.key==='r'||e.key==='R')$('#reset').click();else if(e.key==='+'||e.key==='='||e.key==='Enter'&&!e.shiftKey)$('#zin').click();else if(e.key==='-'||e.key==='Enter'&&e.shiftKey)$('#zout').click();else if(e.key==='ArrowLeft')pan(innerWidth*.08,0);else if(e.key==='ArrowRight')pan(-innerWidth*.08,0);else if(e.key==='ArrowUp')pan(0,innerHeight*.08);else if(e.key==='ArrowDown')pan(0,-innerHeight*.08);else ok=false;if(ok){e.preventDefault();recordView();saveHash(false);markDirty()}});
+addEventListener('hashchange',()=>{if(location.hash===lastWrittenHash){lastWrittenHash='';return}if(location.hash===navigationHash)return;navigationHash=location.hash;setTimeout(()=>navigationHash='',0);if(loadHash()){syncControls();recordView();markDirty()}});
+
+// ── export: GPU tiled + streaming PNG, optional GPU 2x2 supersampling ──────
+const exportJob={active:false,cancelled:false};
+function downloadBlob(blob,name){const a=document.createElement('a');a.href=URL.createObjectURL(blob);a.download=name;document.body.appendChild(a);a.click();a.remove();setTimeout(()=>URL.revokeObjectURL(a.href),1000)}
+const CRC_TABLE=(()=>{const t=new Uint32Array(256);for(let n=0;n<256;n++){let c=n;for(let k=0;k<8;k++)c=(c&1)?0xedb88320^(c>>>1):c>>>1;t[n]=c>>>0}return t})();
+function crc32Parts(parts){let c=0xffffffff;for(const part of parts)for(const b of part)c=CRC_TABLE[(c^b)&255]^(c>>>8);return(c^0xffffffff)>>>0}
+function pngChunk(type,data=new Uint8Array()){const tb=new TextEncoder().encode(type),out=new Uint8Array(12+data.length),dv=new DataView(out.buffer);dv.setUint32(0,data.length,false);out.set(tb,4);out.set(data,8);dv.setUint32(8+data.length,crc32Parts([tb,data]),false);return out}
+class StreamingPng{
+  constructor(w,h){if(typeof CompressionStream==='undefined')throw new Error('このブラウザはストリーミングPNG出力に必要なCompressionStreamへ対応していません');this.w=w;this.h=h;this.cs=new CompressionStream('deflate');this.writer=this.cs.writable.getWriter();this.compressed=(async()=>{const r=this.cs.readable.getReader(),chunks=[];for(;;){const q=await r.read();if(q.done)break;chunks.push(q.value)}return chunks})()}
+  async rows(filteredRows){await this.writer.write(filteredRows)}
+  async finish(){await this.writer.close();const chunks=await this.compressed,ihdr=new Uint8Array(13),dv=new DataView(ihdr.buffer);dv.setUint32(0,this.w,false);dv.setUint32(4,this.h,false);ihdr[8]=8;ihdr[9]=6;const parts=[new Uint8Array([137,80,78,71,13,10,26,10]),pngChunk('IHDR',ihdr)];for(const c of chunks)parts.push(pngChunk('IDAT',c));parts.push(pngChunk('IEND'));return new Blob(parts,{type:'image/png'})}
+  async abort(reason){try{await this.writer.abort(reason)}catch{}try{await this.compressed}catch{}}
+}
+function exportDimensions(){const scale=Number($('#exportScale').value),aspect=canvas.height/Math.max(1,canvas.width),requested=Math.max(64,Math.round(scale?canvas.width*scale:Number($('#exportWidth').value)||canvas.width));let w=Math.min(16384,requested),h=Math.max(1,Math.round(w*aspect));if(h>16384){h=16384;w=Math.max(64,Math.round(h/Math.max(1e-12,aspect)))}return{w:Math.min(16384,w),h:Math.min(16384,h)}}
+async function runExport(){
+  if(exportJob.active)return;
+  const r=renderer||await initRenderer();if(!r){$('#exportStatus').textContent='WebGPUが必要です。';return}
+  const{w,h}=exportDimensions(),ss=Math.max(1,Math.min(2,Number($('#exportAA').value)||1)),snap=snapshot(),iter=maxIter(),deep=deepNeeded(snap,w),strict=$('#exportPrecision').value==='strict';
+  let ctx=null;
+  if(deep){$('#exportStatus').textContent='高精度参照軌道を準備中…';ctx=await refs.request(snap,iter);if(ctx.checkpointMismatch){$('#exportStatus').textContent='参照軌道検証に失敗しました。';return}}
+  const tile=512,totalTiles=Math.ceil(w/tile)*Math.ceil(h/tile),png=new StreamingPng(w,h),sampleCount=ss===2?4:1;
+  exportJob.active=true;exportJob.cancelled=false;$('#exportProgress').hidden=false;$('#exportProgress').value=0;$('#exportStart').disabled=true;
+  let done=0,unresolvedSamples=0;
+  try{
+    for(let y=0;y<h;y+=tile){
+      const th=Math.min(tile,h-y),rowStride=1+w*4,band=new Uint8Array(rowStride*th);
+      for(let x=0;x<w;x+=tile){
+        if(exportJob.cancelled)throw new Error('cancelled');const tw=Math.min(tile,w-x);
+        const result=ss===1?await r.renderTileRGBA({snap,iter,deep,deepContext:ctx,fullW:w,fullH:h,tileX:x,tileY:y,w:tw,h:th,sampleX:.5,sampleY:.5,edgeAA:false,forceStrict:strict}):await r.renderTileRGBA2x({snap,iter,deep,deepContext:ctx,fullW:w,fullH:h,tileX:x,tileY:y,w:tw,h:th,forceStrict:strict});
+        const data=result.rgba;unresolvedSamples+=result.unresolved||0;
+        for(let row=0;row<th;row++)band.set(data.subarray(row*tw*4,(row+1)*tw*4),row*rowStride+1+x*4);
+        done++;$('#exportProgress').value=done/totalTiles;$('#exportStatus').textContent='GPUタイル生成 '+Math.round(100*done/totalTiles)+'%'+(unresolvedSamples?' · 未確定sample '+unresolvedSamples:'');
+      }
+      if(exportJob.cancelled)throw new Error('cancelled');await png.rows(band);await new Promise(requestAnimationFrame);
+    }
+    if(exportJob.cancelled)throw new Error('cancelled');$('#exportStatus').textContent='PNGストリームを確定中…';
+    const blob=await png.finish(),stamp=Date.now(),base='mandelbrot-'+stamp,meta={format:'mandelbrot-view-v24',rendererVersion:VERSION,backend:'webgpu',numericEngine:deep?'bigint-reference + guarded-rescaled-f32-perturbation':'f32-direct',membershipCertified:false,precisionPolicy:strict?'strict-gpu':'balanced-gpu',pixelContract:'centered',width:w,height:h,supersampling:ss,numericSamples:w*h*sampleCount,unresolvedSamples,exportPipeline:ss===2?'gpu-4sample-resolve + single-readback-per-tile + streaming-png':'gpu-tile + streaming-png',iterationPolicy:{adaptive:state.adaptive,base:state.baseIter,effective:iter},view:{bits:snap.bits,re:snap.re.toString(),im:snap.im.toString(),span:snap.span.toString()},palette:{id:state.palette,cycle:state.cycle,shift:state.shift},reference:ctx?{precisionBits:ctx.precisionBits,checkpointCount:ctx.checkpointCount,checkpointMismatch:ctx.checkpointMismatch,blaEnabled:false}:null,shaderVersion:G.version};
+    downloadBlob(blob,base+'.png');downloadBlob(new Blob([JSON.stringify(meta,null,2)],{type:'application/json'}),base+'.json');runtime.exports++;
+    $('#exportStatus').textContent=unresolvedSamples?'保存しました · 未確定sample '+unresolvedSamples+'（sidecar参照）':'PNGと座標メタデータを保存しました。';
+  }catch(e){await png.abort(e);$('#exportStatus').textContent=String(e.message)==='cancelled'?'出力を中止しました。':'出力失敗: '+String(e&&e.message||e)}
+  finally{exportJob.active=false;$('#exportStart').disabled=false}
+}
+$('#png').onclick=()=>{const d=$('#exportDialog');$('#exportWidth').value=String(canvas.width);$('#exportScale').value='1';$('#exportProgress').hidden=true;$('#exportStatus').textContent='';d.showModal?d.showModal():d.setAttribute('open','')};$('#exportScale').onchange=e=>{const s=Number(e.target.value);if(s)$('#exportWidth').value=String(exportDimensions().w)};$('#exportStart').onclick=runExport;$('#exportCancel').onclick=()=>{if(exportJob.active){exportJob.cancelled=true;$('#exportStatus').textContent='中止しています…'}else $('#exportDialog').close()};$('#exportQuick').onclick=()=>canvas.toBlob(blob=>{if(blob)downloadBlob(blob,'mandelbrot-'+Date.now()+'.png')},'image/png');
+
+// ── diagnostics ──────────────────────────────────────────────────────────
+function updateStats(){const z=zoomExp(),digits=Math.max(8,Math.min(80,Math.ceil(z)+8));$('#coord').textContent=fmtFixed(state.re,digits)+' '+(state.im<0n?'−':'+')+' '+fmtFixed(state.im<0n?-state.im:state.im,digits)+'i';$('#zoom').textContent=z<4?Math.pow(10,z).toFixed(1)+'×':'≈ 10^'+z.toFixed(2);$('#span').textContent=fmtSpan();$('#engine').textContent=renderer?(deepNeeded()?'WebGPU 深部':'WebGPU 標準'):(state.gpuInitFailed?'WebGPU エラー':state.gpuError?'Fallback':'起動中');$('#render').textContent=state.rendering?'描画中…':state.lastRender?state.lastRender.toFixed(0)+' ms':'準備完了';let status=state.drawState==='ERROR'?'描画停止':state.drawState==='REPROJECTED'?'再投影':state.drawState==='COVERING'?'GPU描画中':state.drawState==='REFINED'?'GPU境界平滑化':state.drawState==='COVERED'?'全域描画 完了':'準備中';if(state.unresolved)status+=' · 未確定 '+state.unresolved;if(state.gpuError){const ge=state.gpuError.length>120?state.gpuError.slice(0,117)+'…':state.gpuError;status+=' · '+ge;}$('#badge').textContent=status;$('#compactStatus').textContent=status;const d=renderer&&renderer.deepCtx;$('#diagEngine').textContent='engine: '+state.lastEngine+' | WebGPU '+(renderer?'ready':'unavailable')+' | shader '+G.version;$('#diagNumeric').textContent='numeric: view '+state.bits+' bit | iter '+maxIter()+(d?' | ref '+d.precisionBits+' bit':'');const frameBytes=renderer&&renderer.frame?renderer.frame.n*16:0,deepBytes=d?d.refs.byteLength:0;$('#diagMemory').textContent='GPU managed est: '+((frameBytes+deepBytes)/1048576).toFixed(1)+' MiB | canvas '+canvas.width+'×'+canvas.height}
+
+globalThis.__MANDEL_TEST__={
+  async setView({re,im,span,bits,baseIter=350,adaptive=false,processMode='standard'}){cancelRender();if(bits){state.bits=bits}else{state.bits=Math.max(256,decimalRequiredBits(re),decimalRequiredBits(im),decimalRequiredBits(span))}state.re=fromDec(re);state.im=fromDec(im);state.span=fromDec(span);state.baseIter=baseIter;state.adaptive=adaptive;state.processMode=processMode;state.hq=false;ensurePrecision();resize();markDirty(false);const start=performance.now();while((state.dirty||state.rendering)&&performance.now()-start<120000){schedule();await new Promise(r=>setTimeout(r,20))}if(state.dirty||state.rendering)throw new Error('test render timeout');return{width:canvas.width,height:canvas.height,diag:globalThis.__MANDEL_DIAG__.snapshot()}},
+  async sampleMeta(points){if(!renderer||!renderer.frame)throw new Error('GPU field unavailable');const idx=points.map(([x,y])=>y*renderer.frame.w+x);const m=await renderer.readMeta(idx);return Array.from(m)},
+  state:()=>({bits:state.bits,re:state.re.toString(),im:state.im.toString(),span:state.span.toString(),width:canvas.width,height:canvas.height,iter:maxIter()}),
+  async probeMeta({w,h,strict=true}={}){if(!renderer)throw new Error('WebGPU renderer unavailable');const snap=snapshot(),iter=maxIter(),deep=deepNeeded(snap,w);let ctx=null;if(deep)ctx=await refs.request(snap,iter);return Array.from(await renderer.renderTileMeta({snap,iter,deep,deepContext:ctx,fullW:w,fullH:h,w,h,forceStrict:strict}))},
+  async smokeExportTile({w=48,h=32,strict=true,ss=1}={}){if(!renderer)throw new Error('WebGPU renderer unavailable');const snap=snapshot(),iter=maxIter(),deep=deepNeeded(snap,w);let ctx=null;if(deep)ctx=await refs.request(snap,iter);const result=ss===2?await renderer.renderTileRGBA2x({snap,iter,deep,deepContext:ctx,fullW:w,fullH:h,tileX:0,tileY:0,w,h,forceStrict:strict}):await renderer.renderTileRGBA({snap,iter,deep,deepContext:ctx,fullW:w,fullH:h,tileX:0,tileY:0,w,h,sampleX:.5,sampleY:.5,edgeAA:false,forceStrict:strict}),data=result.rgba;let checksum=2166136261>>>0;for(const v of data){checksum^=v;checksum=Math.imul(checksum,16777619)>>>0}return{length:data.length,expected:w*h*4,checksum,deep,strict,ss,unresolved:result.unresolved||0}}
+};
+globalThis.__MANDEL_DIAG__={snapshot:()=>({rendererVersion:VERSION,backend:renderer?'webgpu':'fallback',shaderVersion:G.version,webgpuError:state.gpuError,pixelContract:'centered',drawState:state.drawState,rendering:state.rendering,zoom:zoomExp(),deep:deepNeeded(),bits:state.bits,iteration:maxIter(),unresolved:state.unresolved,screen:{width:canvas.width,height:canvas.height,effectiveDpr:state.effectiveDpr,pixelBudget:state.screenPixelBudget},reference:renderer&&renderer.deepCtx?{key:renderer.deepCtx.key,precisionBits:renderer.deepCtx.precisionBits,refLen:renderer.deepCtx.refLen,checkpointMismatch:renderer.deepCtx.checkpointMismatch,checkpointCount:renderer.deepCtx.checkpointCount,blaEnabled:false}:null,runtime:{...runtime},adapter:renderer?renderer.adapterInfo:null,limits:renderer?renderer.adapterLimits:null,compilation:renderer?renderer.compilation:null,uncapturedErrors:renderer?renderer.uncapturedErrors.slice():[]})};
+
+// ── boot / teardown ──────────────────────────────────────────────────────
+addEventListener('visibilitychange',()=>{if(document.hidden){cancelRender();exportJob.cancelled=true}else markDirty(false)});addEventListener('pagehide',()=>{cancelRender();refs.destroy();if(renderer)renderer.destroy()},{once:true});
+try{state.uiHidden=localStorage.getItem('mandelbrot.uiHidden')==='1';const m=localStorage.getItem('mandelbrot.processMode');if(/^(power|standard|fine|validate)$/.test(m)){state.processMode=m;state.hq=m==='fine'||m==='validate'}}catch{}applyUi();resize();if(!loadHash())reset();recordView();syncControls();updateStats();initRenderer().then(()=>{resize();markDirty(false)});schedule();
 })();
diff --git a/scripts/browserless-audit.ps1 b/scripts/browserless-audit.ps1
new file mode 100644
index 0000000..018ff87
--- /dev/null
+++ b/scripts/browserless-audit.ps1
@@ -0,0 +1,90 @@
+param(
+  [Parameter(Mandatory=$true)][string]$NodePath,
+  [string]$NodeArchivePath,
+  [string]$OutputPath = 'audit/v23-browserless-baseline.json'
+)
+$ErrorActionPreference = 'Stop'
+$workspace = (Resolve-Path -LiteralPath (Join-Path $PSScriptRoot '..')).Path
+$node = (Resolve-Path -LiteralPath $NodePath).Path
+$expectedNodeArchiveSha256 = 'c95d8a7e1c99e669cc08c9f1176e068c1f50847c37908fcb8c35b62482366511'
+
+function Run-PowerShellJson([string]$Path) {
+  $raw = & powershell.exe -NoProfile -ExecutionPolicy Bypass -File $Path
+  if ($LASTEXITCODE -ne 0) { throw "PowerShell gate failed: $Path" }
+  $raw | ConvertFrom-Json
+}
+
+function Run-NodeJson([string]$Path, [string[]]$Arguments = @()) {
+  $raw = & $node $Path @Arguments
+  if ($LASTEXITCODE -ne 0) { throw "Node gate failed: $Path" }
+  ($raw | Select-Object -Last 1) | ConvertFrom-Json
+}
+
+$nodeVersion = (& $node --version | Select-Object -First 1)
+if ($nodeVersion -ne 'v22.18.0') { throw "Expected Node v22.18.0, got $nodeVersion" }
+$nodeArchive = $null
+if ($NodeArchivePath) {
+  $archive = (Resolve-Path -LiteralPath $NodeArchivePath).Path
+  $actual = (Get-FileHash -LiteralPath $archive -Algorithm SHA256).Hash.ToLowerInvariant()
+  if ($actual -ne $expectedNodeArchiveSha256) { throw "Node archive SHA-256 mismatch: $actual" }
+  $nodeArchive = [ordered]@{
+    file=[System.IO.Path]::GetFileName($archive)
+    sha256=$actual
+    source='https://nodejs.org/dist/v22.18.0/node-v22.18.0-win-x64.zip'
+  }
+}
+
+$kernelContract = Run-PowerShellJson (Join-Path $workspace 'tests/kernel-source-contract.ps1')
+$sourceContract = Run-PowerShellJson (Join-Path $workspace 'tests/source-contract.ps1')
+$documentContract = Run-PowerShellJson (Join-Path $workspace 'tests/document-contract.ps1')
+$tests = [ordered]@{}
+foreach ($name in @('js-syntax.mjs','module-clone.mjs','precision-reference.mjs','analytic-interior.mjs','pixel-mapping.mjs','pixel-contract.mjs')) {
+  $tests[$name] = Run-NodeJson (Join-Path $workspace "tests/$name")
+}
+$runtimePath = Join-Path $workspace 'audit/v23-browserless-runtime.json'
+$tests['runtime-budget.mjs'] = Run-NodeJson (Join-Path $workspace 'tests/runtime-budget.mjs') @('--out',$runtimePath)
+$sourceBaseline = Get-Content -LiteralPath (Join-Path $workspace 'audit/v23-source-baseline.json') -Raw -Encoding UTF8 | ConvertFrom-Json
+
+$report = [ordered]@{
+  format='mandelbrot-browserless-audit-v23'
+  generatedUtc=[DateTime]::UtcNow.ToString('o')
+  status='pass'
+  scope='browserless-current-artifacts'
+  fullAcceptance=$false
+  rendererVersion=23
+  node=[ordered]@{ version=$nodeVersion; archive=$nodeArchive }
+  contracts=[ordered]@{
+    kernel=$kernelContract
+    source=$sourceContract
+    document=$documentContract
+  }
+  executableTests=$tests
+  runtime=[ordered]@{
+    status='measured-not-acceptance'
+    report='audit/v23-browserless-runtime.json'
+    reason='Runtime values are environment/load dependent and no browser paint/input/GPU threshold is asserted.'
+  }
+  sourceWasmBuild=[ordered]@{
+    status=if ($sourceBaseline.sourceBuild.goldenStatus -eq 'pass') { 'prior-evidence-reused' } else { 'not-run' }
+    manifest=$sourceBaseline.sourceBuild.generatedManifest
+    reason=$sourceBaseline.sourceBuild.reason
+  }
+  v22Comparison=[ordered]@{
+    status='not-verifiable'
+    reason='No immutable v22 artifacts, hashes, or versioned baseline are present.'
+  }
+  browserAcceptance=[ordered]@{
+    status='not-run'
+    report='audit/v23-browser-baseline.json'
+    nonSubstitutable=@(
+      'actual DPR and visual output',
+      'transform-to-paint and Preview p95',
+      'long tasks and observed browser/GPU memory',
+      'download/cancel behavior',
+      'keyboard/focus/page-zoom/screen-reader behavior'
+    )
+  }
+}
+$target = Join-Path $workspace $OutputPath
+$report | ConvertTo-Json -Depth 12 | Set-Content -LiteralPath $target -Encoding UTF8
+Write-Output $target
diff --git a/scripts/build.mjs b/scripts/build.mjs
new file mode 100644
index 0000000..85c1808
--- /dev/null
+++ b/scripts/build.mjs
@@ -0,0 +1,8 @@
+import fs from 'node:fs/promises';
+const root=new URL('../',import.meta.url),files=['index.html','gpu-kernels.js','script.js'];
+for(const variant of ['standalone','hosted']){
+  const dir=new URL(`../dist/${variant}/`,import.meta.url);await fs.rm(dir,{recursive:true,force:true});await fs.mkdir(dir,{recursive:true});
+  for(const f of files)await fs.copyFile(new URL('../'+f,import.meta.url),new URL(f,dir));
+}
+await fs.writeFile(new URL('../dist/hosted/_headers',import.meta.url),`/*\n  X-Content-Type-Options: nosniff\n  Referrer-Policy: no-referrer\n`);
+console.log(JSON.stringify({status:'pass',outputs:['dist/standalone','dist/hosted'],files},null,2));
diff --git a/scripts/source-baseline.ps1 b/scripts/source-baseline.ps1
index 96584be..0c37f09 100644
--- a/scripts/source-baseline.ps1
+++ b/scripts/source-baseline.ps1
@@ -75,8 +75,9 @@ $baseline = [ordered]@{
   hosted = [ordered]@{
     firstViewFiles = $hostedFiles
     firstViewUncompressedBytes = ($hostedFiles | Measure-Object bytes -Sum).Sum
-    deepRequestsBeforeDeepView = 0
-    note = 'Transfer compression, parse, compile, and runtime timings require the fixed browser benchmark.'
+    deepRequestContractBeforeDeepView = 0
+    deepRequestMeasurementStatus = 'not-run'
+    note = 'The zero is a static loader contract, not a measured request count. Transfer compression, request count, parse, compile, and runtime timings require the fixed Hosted browser benchmark.'
   }
   standalone = [ordered]@{
     files = $standaloneFiles
diff --git a/scripts/test-all.mjs b/scripts/test-all.mjs
new file mode 100644
index 0000000..26aa797
--- /dev/null
+++ b/scripts/test-all.mjs
@@ -0,0 +1,7 @@
+import {spawnSync} from 'node:child_process';
+const commands=[
+ ['node',['--check','script.js']],['node',['--check','gpu-kernels.js']],['node',['--check','tests/webgpu-acceptance.js']],
+ ...['v24-wgsl-reserved.mjs','v24-source-contract.mjs','v24-index-contract.mjs','v24-tree-contract.mjs','v24-reference-worker.mjs','v24-direct-model.mjs','v24-cpu-numeric-model.mjs','v24-bla-model.mjs','v24-geometry-contract.mjs','v24-coordinate-format.mjs','v24-png-stream-model.mjs','v24-acceptance-contract.mjs'].map(f=>['node',['tests/'+f]])
+];
+for(const [cmd,args] of commands){const r=spawnSync(cmd,args,{stdio:'inherit'});if(r.status!==0)process.exit(r.status??1)}
+console.log(JSON.stringify({status:'pass',suite:'v24-static-and-cpu-model',realWebGPU:'run tests/webgpu-acceptance.html in a WebGPU-capable browser'},null,2));
diff --git a/scripts/test-all.ps1 b/scripts/test-all.ps1
index 703e97d..a6a4b54 100644
--- a/scripts/test-all.ps1
+++ b/scripts/test-all.ps1
@@ -8,6 +8,7 @@ function Run-CheckedPowerShell([string]$Path) {
 }
 Run-CheckedPowerShell (Join-Path $workspace 'tests\kernel-source-contract.ps1')
 Run-CheckedPowerShell (Join-Path $workspace 'tests\source-contract.ps1')
+Run-CheckedPowerShell (Join-Path $workspace 'tests\document-contract.ps1')
 
 $node = Get-Command node -ErrorAction SilentlyContinue
 if ($node) {
@@ -29,4 +30,12 @@ if ($clang -and $node -and ((& $clang.Source --version | Select-Object -First 1)
 } elseif ($RequireToolchain) { throw 'clang 17.0.6 is required by -RequireToolchain.' }
 else { Write-Warning 'clang 17.0.6 is unavailable; source-WASM build/golden was skipped.' }
 
-[ordered]@{ status='pass'; nodeTests=[bool]$node; sourceWasmGolden=$sourceGolden } | ConvertTo-Json
+$status = if ($node -and $sourceGolden) { 'pass' } else { 'partial' }
+[ordered]@{
+  status=$status
+  sourceContracts=$true
+  documentContract=$true
+  nodeTests=[bool]$node
+  sourceWasmGolden=$sourceGolden
+  note=if ($status -eq 'partial') { 'Use -RequireToolchain for a full pass; skipped gates are not pass.' } else { $null }
+} | ConvertTo-Json
diff --git a/tests/browser-benchmark.html b/tests/browser-benchmark.html
index e0ecc27..5d60062 100644
--- a/tests/browser-benchmark.html
+++ b/tests/browser-benchmark.html
@@ -1,27 +1,323 @@
 <!doctype html>
 <meta charset="utf-8">
-<title>Mandelbrot v23 browser benchmark</title>
-<style>body{font:14px system-ui;margin:20px;background:#111827;color:#eef2ff}button{padding:8px 14px}iframe{position:fixed;left:-20000px;top:0;border:0}pre{white-space:pre-wrap}</style>
-<h1>v23 browser benchmark</h1>
-<p>HTTP(S)でこのworkspaceを配信して実行します。iframeの実寸と実DPRを結果へ記録します。</p>
-<button id="run">Run corpus</button>
+<title>Mandelbrot v23 browser acceptance runner</title>
+<style>
+  body{font:14px system-ui;margin:20px;background:#111827;color:#eef2ff}
+  button{padding:8px 14px}
+  iframe{position:fixed;left:-20000px;top:0;border:0}
+  pre{white-space:pre-wrap}
+</style>
+<h1>v23 browser acceptance runner</h1>
+<p>
+  HTTP(S)で実行します。1回のrunは1 profile・1 buildだけを検査します。
+  例: <code>?profile=desktop&amp;target=hosted</code>。
+  iframe寸法ではDPRを模擬できないため、要求DPRを持つbrowser contextごとに実行してください。
+</p>
+<button id="run">Run selected profile</button>
 <pre id="output">Ready.</pre>
 <iframe id="app" width="1440" height="900"></iframe>
 <script type="module">
-const out=document.querySelector('#output'),frame=document.querySelector('#app');
-const wait=ms=>new Promise(r=>setTimeout(r,ms));
-function fixed(decimal,bits){let s=String(decimal).toLowerCase(),neg=s.startsWith('-');if(neg)s=s.slice(1);let[m,e='0']=s.split('e'),[i,f='']=m.split('.');let digits=(i+f).replace(/^0+(?=\d)/,'')||'0',places=f.length-Number(e);if(places<0){digits+='0'.repeat(-places);places=0}let v=BigInt(digits)*(1n<<BigInt(bits))/(10n**BigInt(places));return neg?-v:v}
-function bitsFor(span){const n=Math.abs(Number(span));return Number.isFinite(n)&&n>0?Math.max(256,Math.ceil(-Math.log2(n))+256):1280}
-function hash(scene){const bits=bitsFor(scene.span),p=new URLSearchParams({v:'23',b:String(bits),re:String(fixed(scene.re,bits)),im:String(fixed(scene.im,bits)),sp:String(fixed(scene.span,bits)),pal:'0',cy:'.008',sh:'.18',it:'350',ad:'1'});return'#'+p}
-async function poll(fn,timeout,label){const started=performance.now();while(performance.now()-started<timeout){let value;try{value=fn()}catch{}if(value)return{value,ms:performance.now()-started};await wait(25)}throw new Error('timeout: '+label)}
-const p95=values=>values.slice().sort((a,b)=>a-b)[Math.min(values.length-1,Math.floor(values.length*.95))]||0;
-async function canvasHash(win){const blob=await new Promise(resolve=>win.document.querySelector('#view').toBlob(resolve,'image/png'));const digest=await crypto.subtle.digest('SHA-256',await blob.arrayBuffer());return[...new Uint8Array(digest)].map(x=>x.toString(16).padStart(2,'0')).join('')}
-function accessibilityAudit(win){const doc=win.document,failures=[],interactive=[...doc.querySelectorAll('button,select,input,summary')];for(const el of interactive){const target=el.type==='checkbox'?el.closest('label')||el:el,r=target.getBoundingClientRect();if(r.width<44||r.height<44)failures.push('target:'+el.id);if(el.matches('input:not([type=checkbox]),select')&&el.id&&!doc.querySelector(`label[for="${el.id}"]`))failures.push('label:'+el.id)}if(!doc.querySelector('#view[tabindex][aria-label]'))failures.push('canvas-keyboard-name');if(!doc.querySelector('[aria-live]'))failures.push('live-status');if(/user-scalable\s*=\s*no/i.test(doc.querySelector('meta[name=viewport]')?.content||''))failures.push('page-zoom-disabled');const css=[...doc.querySelectorAll('style')].map(x=>x.textContent).join('\n');if(!css.includes('prefers-reduced-motion'))failures.push('reduced-motion');if(!css.includes('prefers-reduced-transparency'))failures.push('reduced-transparency');return{pass:failures.length===0,failures,interactiveCount:interactive.length}}
-async function interactionAudit(win){const canvas=win.document.querySelector('#view'),before=win.__MANDEL_DIAG__.snapshot(),durations=[];for(let i=0;i<16;i++){const t=performance.now();canvas.dispatchEvent(new win.WheelEvent('wheel',{deltaY:0,clientX:canvas.clientWidth/2,clientY:canvas.clientHeight/2,cancelable:true}));durations.push(performance.now()-t)}const during=win.__MANDEL_DIAG__.snapshot();await poll(()=>{const d=win.__MANDEL_DIAG__.snapshot();return d&&!d.rendering&&!d.scheduler.wheelActive&&d.lastPass==='preview'?d:null},120000,'wheel settle preview');await poll(()=>{const d=win.__MANDEL_DIAG__.snapshot();return d&&!d.rendering&&d.coverage>=.999&&['COVERED','RESOLVING','REFINING','REFINED'].includes(d.drawState)?d:null},180000,'wheel settle covered');return{dispatchP95Ms:p95(durations),renderStartsDuringGesture:during.runtimeMetrics.renderStartsDuringGesture-before.runtimeMetrics.renderStartsDuringGesture,renderStartsBeforeSettle:during.runtimeMetrics.renderStarts-before.runtimeMetrics.renderStarts}}
-async function modeAudit(win){const select=win.document.querySelector('#processMode'),hq=win.document.querySelector('#hq');select.value='power';select.dispatchEvent(new win.Event('change',{bubbles:true}));await poll(()=>{const d=win.__MANDEL_DIAG__.snapshot();return d.automaticTarget==='PREVIEW'&&!d.rendering&&d.lastPass==='preview'?d:null},120000,'power preview');const powerBefore=win.__MANDEL_DIAG__.snapshot();await wait(900);const power=win.__MANDEL_DIAG__.snapshot(),powerPass=power.automaticTarget==='PREVIEW'&&power.lastPass==='preview'&&!power.rendering&&!power.scheduler.timer&&!power.detailActive&&!hq.checked&&power.screen.pixelBudget<=1048576&&power.runtimeMetrics.renderStarts===powerBefore.runtimeMetrics.renderStarts;select.value='standard';select.dispatchEvent(new win.Event('change',{bubbles:true}));await poll(()=>{const d=win.__MANDEL_DIAG__.snapshot();return d.automaticTarget==='COVERED'&&!d.rendering&&d.lastPass==='covered'&&d.coverage>=.999?d:null},180000,'standard covered');await wait(900);const standard=win.__MANDEL_DIAG__.snapshot(),standardPass=standard.automaticTarget==='COVERED'&&standard.lastPass==='covered'&&!standard.detailActive&&!standard.scheduler.unknownTimer&&!hq.checked&&standard.screen.pixelBudget<=4194304;return{pass:powerPass&&standardPass,power:{pass:powerPass,target:power.automaticTarget,pixelBudget:power.screen.pixelBudget,renderStartsAfterStable:power.runtimeMetrics.renderStarts-powerBefore.runtimeMetrics.renderStarts},standard:{pass:standardPass,target:standard.automaticTarget,pixelBudget:standard.screen.pixelBudget,detailActive:standard.detailActive,unknownTimer:standard.scheduler.unknownTimer}}}
-async function recolorAudit(win){const select=win.document.querySelector('#palette'),before=win.__MANDEL_DIAG__.snapshot();select.value=before.palette===1?'2':'1';select.dispatchEvent(new win.Event('change',{bubbles:true}));await new Promise(resolve=>win.requestAnimationFrame(()=>win.requestAnimationFrame(resolve)));const after=win.__MANDEL_DIAG__.snapshot();return{pass:after.palette!==before.palette&&after.runtimeMetrics.renderStarts===before.runtimeMetrics.renderStarts,renderStarts:after.runtimeMetrics.renderStarts-before.runtimeMetrics.renderStarts}}
-async function exportAudit(win){const doc=win.document,captured=[],nativeCreate=win.URL.createObjectURL.bind(win.URL),nativeClick=win.HTMLAnchorElement.prototype.click;win.URL.createObjectURL=blob=>{const url=nativeCreate(blob);captured.push({url,blob});return url};win.HTMLAnchorElement.prototype.click=function(){};try{doc.querySelector('#exportScale').value='0';doc.querySelector('#exportWidth').value='64';doc.querySelector('#exportAA').value='1';doc.querySelector('#exportPrecision').value='balanced';doc.querySelector('#exportStart').click();await poll(()=>!win.__MANDEL_DIAG__.snapshot().exporting&&captured.length>=2,120000,'small export');const png=captured.find(x=>x.blob.type==='image/png')?.blob,json=captured.find(x=>x.blob.type==='application/json')?.blob;if(!png||!json)throw new Error('export files missing');const bytes=new Uint8Array(await png.arrayBuffer()),width=(bytes[16]<<24)|(bytes[17]<<16)|(bytes[18]<<8)|bytes[19],height=(bytes[20]<<24)|(bytes[21]<<16)|(bytes[22]<<8)|bytes[23],meta=JSON.parse(await json.text()),completed={width,height,metadataComplete:meta.determinism?.allTilesCompleted===true,sampleCount:meta.sampleCount,kernelHashes:!!meta.kernelSha256};const prior=captured.length;doc.querySelector('#exportWidth').value='256';doc.querySelector('#exportPrecision').value='validated';doc.querySelector('#exportStart').click();doc.querySelector('#exportCancel').click();await poll(()=>!win.__MANDEL_DIAG__.snapshot().exporting,120000,'export cancel');return{pass:width===64&&height===Math.round(64*win.document.querySelector('#view').height/win.document.querySelector('#view').width)&&captured.length===prior,completed,cancelledWithoutDownload:captured.length===prior}}finally{win.URL.createObjectURL=nativeCreate;win.HTMLAnchorElement.prototype.click=nativeClick}}
-async function runScene(scene,viewport){frame.width=viewport.cssWidth;frame.height=viewport.cssHeight;const loaded=new Promise((resolve,reject)=>{frame.onload=resolve;frame.onerror=reject});const started=performance.now();frame.src='../index.html'+hash(scene);await loaded;const win=frame.contentWindow;const label=viewport.id+'/'+scene.id;const preview=await poll(()=>{const d=win.__MANDEL_DIAG__?.snapshot();return d&&d.drawState==='PREVIEW'&&!d.rendering&&d.lastPass==='preview'?d:null},120000,'preview '+label);const previewSnapshot=preview.value,covered=await poll(()=>{const d=win.__MANDEL_DIAG__?.snapshot();return d&&['COVERED','RESOLVING','REFINING','REFINED','VALIDATING','VALIDATED','VALIDATION_INCOMPLETE'].includes(d.drawState)&&d.coverage>=.999?d:null},180000,'covered '+label);const refined=await poll(()=>{const d=win.__MANDEL_DIAG__?.snapshot();return d&&!d.detailActive&&!d.rendering&&!d.validating&&['COVERED','REFINED','VALIDATED','VALIDATION_INCOMPLETE'].includes(d.drawState)?d:null},240000,'refined '+label);const exercise=viewport.id==='desktop'&&scene.id==='z0',interaction=exercise?await interactionAudit(win):null,modes=exercise?await modeAudit(win):null,recolor=exercise?await recolorAudit(win):null,exportResult=exercise?await exportAudit(win):null,accessibility=exercise?accessibilityAudit(win):null,visualSha256=await canvasHash(win),resources=win.performance.getEntriesByType('resource').map(e=>String(e.name)),assetRequests={deep:resources.filter(x=>/\/(deep|bla|color)-/.test(x)),allWasm:resources.filter(x=>/\.wasm(?:$|\?)/.test(x))};await wait(2000);const before=win.__MANDEL_DIAG__.snapshot();await wait(1000);const after=win.__MANDEL_DIAG__.snapshot(),idle={raf:after.scheduler.raf,timer:after.scheduler.timer,pointerSettle:after.scheduler.pointerSettle,unknownTimer:after.scheduler.unknownTimer,backgroundJobs:after.scheduler.backgroundJobs,canvasWrites:after.runtimeMetrics.canvasWrites-before.runtimeMetrics.canvasWrites,domWrites:after.runtimeMetrics.domWrites-before.runtimeMetrics.domWrites,renderStarts:after.runtimeMetrics.renderStarts-before.runtimeMetrics.renderStarts};return{id:scene.id,profile:viewport.id,requestedViewport:viewport,actualViewport:{cssWidth:win.innerWidth,cssHeight:win.innerHeight},actualDevicePixelRatio:win.devicePixelRatio,totalMs:performance.now()-started,previewMs:preview.ms,coveredMs:covered.ms,refinedMs:refined.ms,preview:previewSnapshot,final:after,idle,visualSha256,assetRequests,interaction,modes,recolor,export:exportResult,accessibility}}
-function evaluate(results){const exercise=results.find(x=>x.interaction),checks={idle:results.every(x=>!x.idle.raf&&!x.idle.timer&&!x.idle.pointerSettle&&!x.idle.unknownTimer&&x.idle.backgroundJobs===0&&x.idle.canvasWrites===0&&x.idle.domWrites===0&&x.idle.renderStarts===0),covered:results.every(x=>x.final.coverage>=.999&&x.final.hqTarget===x.final.frame),memory:results.every(x=>x.final.memory.managedBytes<=x.final.memory.budget),visual:results.every(x=>/^[0-9a-f]{64}$/.test(x.visualSha256)),startup:results.filter(x=>x.id==='z0').every(x=>x.assetRequests.deep.length===0),interaction:!!exercise&&exercise.interaction.dispatchP95Ms<16&&exercise.interaction.renderStartsDuringGesture===0&&exercise.interaction.renderStartsBeforeSettle===0,modes:exercise?.modes?.pass===true,recolor:exercise?.recolor?.pass===true,export:exercise?.export?.pass===true,accessibility:exercise?.accessibility?.pass===true,profileFidelity:results.every(x=>x.actualViewport.cssWidth===x.requestedViewport.cssWidth&&x.actualViewport.cssHeight===x.requestedViewport.cssHeight&&Math.abs(x.actualDevicePixelRatio-x.requestedViewport.dpr)<.01),previewBudget:results.every(x=>x.preview.lastRender<120)};const failures=Object.entries(checks).filter(([,pass])=>!pass).map(([name])=>name);return{pass:failures.length===0,checks,failures}}
-document.querySelector('#run').onclick=async()=>{document.querySelector('#run').disabled=true;try{const corpus=await(await fetch('./scenes.json',{cache:'no-store'})).json(),results=[];for(const viewport of corpus.viewports)for(const scene of corpus.scenes){out.textContent='Running '+viewport.id+'/'+scene.id+'…\n'+JSON.stringify(results,null,2);results.push(await runScene(scene,viewport))}const report={format:'mandelbrot-browser-baseline-v23',generatedUtc:new Date().toISOString(),userAgent:navigator.userAgent,hostDevicePixelRatio:devicePixelRatio,profiles:corpus.viewports,results,acceptance:evaluate(results)};out.textContent=JSON.stringify(report,null,2);globalThis.__BENCHMARK_RESULT__=report}catch(error){out.textContent=String(error?.stack||error)}finally{document.querySelector('#run').disabled=false}};
+const out=document.querySelector('#output');
+const frame=document.querySelector('#app');
+const query=new URLSearchParams(location.search);
+const selectedProfile=query.get('profile')||'desktop';
+const target=query.get('target')||'hosted';
+const previewTrials=Math.max(30,Number(query.get('trials'))||30);
+if(!['hosted','standalone'].includes(target))throw new Error('target must be hosted or standalone');
+const appPath=target==='hosted'?'../dist/hosted/index.html':'../index.html';
+const wait=ms=>new Promise(resolve=>setTimeout(resolve,ms));
+const nextFrame=win=>new Promise(resolve=>win.requestAnimationFrame(resolve));
+function fixed(decimal,bits){
+  let s=String(decimal).toLowerCase(),neg=s.startsWith('-');
+  if(neg)s=s.slice(1);
+  let pair=s.split('e'),mantissa=pair[0],exponent=Number(pair[1]||0),parts=mantissa.split('.');
+  let digits=((parts[0]||'0')+(parts[1]||'')).replace(/^0+(?=\d)/,'')||'0';
+  let places=(parts[1]||'').length-exponent;
+  if(places<0){digits+='0'.repeat(-places);places=0}
+  let value=BigInt(digits)*(1n<<BigInt(bits))/(10n**BigInt(places));
+  return neg?-value:value
+}
+function bitsFor(span){
+  const n=Math.abs(Number(span));
+  return Number.isFinite(n)&&n>0?Math.max(256,Math.ceil(-Math.log2(n))+256):1280
+}
+function hash(scene){
+  const bits=bitsFor(scene.span);
+  const p=new URLSearchParams({
+    v:'23',b:String(bits),re:String(fixed(scene.re,bits)),im:String(fixed(scene.im,bits)),
+    sp:String(fixed(scene.span,bits)),pal:'0',cy:'.008',sh:'.18',it:'350',ad:'1'
+  });
+  return '#'+p
+}
+async function poll(fn,timeout,label){
+  const started=performance.now();
+  while(performance.now()-started<timeout){
+    let value;
+    try{value=fn()}catch{}
+    if(value)return{value,ms:performance.now()-started};
+    await wait(25)
+  }
+  throw new Error('timeout: '+label)
+}
+const p95=values=>values.slice().sort((a,b)=>a-b)[Math.min(values.length-1,Math.ceil(values.length*.95)-1)]||0;
+async function sha256(bytes){
+  const digest=await crypto.subtle.digest('SHA-256',bytes);
+  return[...new Uint8Array(digest)].map(x=>x.toString(16).padStart(2,'0')).join('')
+}
+async function canvasAudit(win,scene,profile){
+  const canvas=win.document.querySelector('#view');
+  const context=canvas.getContext('2d',{willReadFrequently:true});
+  const pixels=context.getImageData(0,0,canvas.width,canvas.height).data;
+  const hashValue=await sha256(pixels.buffer);
+  let min=255,max=0;
+  for(let i=0;i<pixels.length;i+=4){min=Math.min(min,pixels[i],pixels[i+1],pixels[i+2]);max=Math.max(max,pixels[i],pixels[i+1],pixels[i+2])}
+  const expected=scene.visualGoldens?.[target]?.[profile.id]||null;
+  return{hash:hashValue,expected,nonBlank:max>min,pass:!!expected&&hashValue===expected&&max>min}
+}
+async function accessibilityAudit(win){
+  const doc=win.document,failures=[],interactive=[...doc.querySelectorAll('button,select,input,summary')];
+  for(const el of interactive){
+    const targetEl=el.type==='checkbox'?el.closest('label')||el:el,r=targetEl.getBoundingClientRect();
+    if(r.width<44||r.height<44)failures.push('target:'+el.id);
+    if(el.matches('input:not([type=checkbox]),select')&&el.id&&!doc.querySelector('label[for="'+el.id+'"]'))failures.push('label:'+el.id)
+  }
+  const canvas=doc.querySelector('#view');
+  if(!canvas?.matches('[tabindex][aria-label]'))failures.push('canvas-keyboard-name');
+  if(!doc.querySelector('[aria-live]'))failures.push('live-status');
+  if(/user-scalable\s*=\s*no/i.test(doc.querySelector('meta[name=viewport]')?.content||''))failures.push('page-zoom-disabled');
+  const css=[...doc.querySelectorAll('style')].map(x=>x.textContent).join('\n');
+  if(!css.includes('prefers-reduced-motion'))failures.push('reduced-motion');
+  if(!css.includes('prefers-reduced-transparency'))failures.push('reduced-transparency');
+  canvas.focus();
+  const before=win.location.hash;
+  canvas.dispatchEvent(new win.KeyboardEvent('keydown',{key:'ArrowRight',bubbles:true,cancelable:true}));
+  const keyboard=await poll(()=>win.location.hash!==before,2000,'keyboard navigation').then(()=>true).catch(()=>false);
+  if(!keyboard)failures.push('keyboard-navigation');
+  if(doc.activeElement!==canvas)failures.push('canvas-focus');
+  return{
+    pass:failures.length===0,failures,interactiveCount:interactive.length,keyboard,
+    pendingExternal:['visible-focus visual review','browser page-zoom and canvas-pinch coexistence','screen-reader announcement order']
+  }
+}
+async function interactionAudit(win){
+  const canvas=win.document.querySelector('#view'),before=win.__MANDEL_DIAG__.snapshot(),paintDurations=[];
+  for(let i=0;i<16;i++){
+    const writes=win.__MANDEL_DIAG__.snapshot().runtimeMetrics.canvasWrites,t=performance.now();
+    canvas.dispatchEvent(new win.WheelEvent('wheel',{
+      deltaY:i%2?6:-4,clientX:canvas.clientWidth/2,clientY:canvas.clientHeight/2,cancelable:true
+    }));
+    await poll(()=>win.__MANDEL_DIAG__.snapshot().runtimeMetrics.canvasWrites>writes,1000,'wheel transform paint');
+    paintDurations.push(performance.now()-t);
+    await nextFrame(win)
+  }
+  const during=win.__MANDEL_DIAG__.snapshot();
+  const preview=await poll(()=>{
+    const d=win.__MANDEL_DIAG__.snapshot();
+    return d&&!d.rendering&&!d.scheduler.wheelActive&&d.lastPass==='preview'?d:null
+  },120000,'wheel settle preview');
+  await poll(()=>{
+    const d=win.__MANDEL_DIAG__.snapshot();
+    return d&&!d.rendering&&d.coverage>=1&&d.drawState==='COVERED'?d:null
+  },180000,'wheel settle covered');
+  const after=win.__MANDEL_DIAG__.snapshot();
+  return{
+    paintP95Ms:p95(paintDurations),
+    previewAfterSettleMs:Math.max(0,preview.ms-110),
+    renderStartsDuringGesture:during.runtimeMetrics.renderStartsDuringGesture-before.runtimeMetrics.renderStartsDuringGesture,
+    renderStartsBeforeSettle:during.runtimeMetrics.renderStarts-before.runtimeMetrics.renderStarts,
+    longTasks:after.runtimeMetrics.longTasks-before.runtimeMetrics.longTasks
+  }
+}
+async function modeAudit(win){
+  const select=win.document.querySelector('#processMode'),hq=win.document.querySelector('#hq'),previewAfterSettle=[];
+  select.value='power';
+  select.dispatchEvent(new win.Event('change',{bubbles:true}));
+  for(let i=0;i<previewTrials;i++){
+    const canvas=win.document.querySelector('#view'),started=performance.now();
+    canvas.dispatchEvent(new win.WheelEvent('wheel',{
+      deltaY:1,clientX:canvas.clientWidth/2,clientY:canvas.clientHeight/2,cancelable:true
+    }));
+    await poll(()=>{
+      const d=win.__MANDEL_DIAG__.snapshot();
+      return d.automaticTarget==='PREVIEW'&&!d.rendering&&!d.scheduler.wheelActive&&d.lastPass==='preview'?d:null
+    },120000,'power preview trial');
+    previewAfterSettle.push(Math.max(0,performance.now()-started-110))
+  }
+  const powerBefore=win.__MANDEL_DIAG__.snapshot();
+  await wait(900);
+  const power=win.__MANDEL_DIAG__.snapshot();
+  const powerPass=power.automaticTarget==='PREVIEW'&&power.lastPass==='preview'&&!power.rendering&&!power.scheduler.timer&&!power.detailActive&&!hq.checked&&power.screen.pixelBudget<=1048576&&power.runtimeMetrics.renderStarts===powerBefore.runtimeMetrics.renderStarts;
+  select.value='standard';
+  select.dispatchEvent(new win.Event('change',{bubbles:true}));
+  await poll(()=>{
+    const d=win.__MANDEL_DIAG__.snapshot();
+    return d.automaticTarget==='COVERED'&&!d.rendering&&d.lastPass==='covered'&&d.coverage>=1&&d.drawState==='COVERED'?d:null
+  },180000,'standard covered');
+  await wait(900);
+  const standard=win.__MANDEL_DIAG__.snapshot();
+  const standardPass=standard.automaticTarget==='COVERED'&&standard.lastPass==='covered'&&!standard.detailActive&&!standard.scheduler.unknownTimer&&!hq.checked&&standard.screen.pixelBudget<=4194304;
+  select.value='fine';
+  select.dispatchEvent(new win.Event('change',{bubbles:true}));
+  const fineResult=await poll(()=>{
+    const d=win.__MANDEL_DIAG__.snapshot();
+    return d.automaticTarget==='REFINED'&&!d.rendering&&!d.detailActive&&d.drawState==='REFINED'?d:null
+  },240000,'fine refined');
+  const fine=fineResult.value;
+  const finePass=fine.coverage>=1&&fine.drawState==='REFINED';
+  return{
+    pass:powerPass&&standardPass&&finePass&&previewAfterSettle.length>=30&&p95(previewAfterSettle)<120,
+    previewTrials:previewAfterSettle.length,previewP95AfterSettleMs:p95(previewAfterSettle),
+    power:{pass:powerPass,target:power.automaticTarget,pixelBudget:power.screen.pixelBudget},
+    standard:{pass:standardPass,target:standard.automaticTarget,pixelBudget:standard.screen.pixelBudget},
+    fine:{pass:finePass,target:fine.automaticTarget,refinedMs:fineResult.ms}
+  }
+}
+async function recolorAudit(win){
+  const select=win.document.querySelector('#palette'),before=win.__MANDEL_DIAG__.snapshot();
+  select.value=before.palette===1?'2':'1';
+  select.dispatchEvent(new win.Event('change',{bubbles:true}));
+  await nextFrame(win);await nextFrame(win);
+  const after=win.__MANDEL_DIAG__.snapshot();
+  return{pass:after.palette!==before.palette&&after.runtimeMetrics.renderStarts===before.runtimeMetrics.renderStarts,renderStarts:after.runtimeMetrics.renderStarts-before.runtimeMetrics.renderStarts}
+}
+async function exportAudit(win){
+  const doc=win.document,captured=[],nativeCreate=win.URL.createObjectURL.bind(win.URL),nativeClick=win.HTMLAnchorElement.prototype.click;
+  win.URL.createObjectURL=blob=>{
+    const url=nativeCreate(blob);
+    captured.push({url,blob,progress:Number(doc.querySelector('#exportProgress').value),active:win.__MANDEL_DIAG__.snapshot().exporting});
+    return url
+  };
+  win.HTMLAnchorElement.prototype.click=function(){};
+  try{
+    async function balancedExport(){
+      const start=captured.length;
+      doc.querySelector('#exportScale').value='0';
+      doc.querySelector('#exportWidth').value='64';
+      doc.querySelector('#exportAA').value='2';
+      doc.querySelector('#exportPrecision').value='balanced';
+      doc.querySelector('#exportStart').click();
+      await poll(()=>!win.__MANDEL_DIAG__.snapshot().exporting&&captured.length>=start+2,120000,'small export');
+      return captured.slice(start)
+    }
+    const first=await balancedExport(),second=await balancedExport();
+    const png=first.find(x=>x.blob.type==='image/png'),json=first.find(x=>x.blob.type==='application/json');
+    const png2=second.find(x=>x.blob.type==='image/png');
+    if(!png||!json||!png2)throw new Error('export files missing');
+    const bytes=new Uint8Array(await png.blob.arrayBuffer()),width=(bytes[16]<<24)|(bytes[17]<<16)|(bytes[18]<<8)|bytes[19],height=(bytes[20]<<24)|(bytes[21]<<16)|(bytes[22]<<8)|bytes[23];
+    const meta=JSON.parse(await json.blob.text()),expectedHeight=Math.round(64*doc.querySelector('#view').height/doc.querySelector('#view').width);
+    const deterministic=await sha256(await png.blob.arrayBuffer())===await sha256(await png2.blob.arrayBuffer());
+    const completed=meta.determinism?.allTilesCompleted===true&&meta.sampleCount===width*height*4&&!!meta.kernelSha256&&typeof meta.unresolvedSamples==='number';
+    const noEarlyDownload=[...first,...second].every(x=>x.progress>=1);
+    const prior=captured.length;
+    doc.querySelector('#exportWidth').value='256';
+    doc.querySelector('#exportPrecision').value='validated';
+    doc.querySelector('#exportStart').click();
+    doc.querySelector('#exportCancel').click();
+    await poll(()=>!win.__MANDEL_DIAG__.snapshot().exporting,120000,'export cancel');
+    const cancelledWithoutDownload=captured.length===prior;
+    return{pass:width===64&&height===expectedHeight&&completed&&noEarlyDownload&&deterministic&&cancelledWithoutDownload,width,height,completed,noEarlyDownload,deterministic,cancelledWithoutDownload}
+  }finally{
+    win.URL.createObjectURL=nativeCreate;
+    win.HTMLAnchorElement.prototype.click=nativeClick
+  }
+}
+async function observedMemory(win){
+  if(typeof win.performance.measureUserAgentSpecificMemory!=='function')return{status:'unsupported'};
+  try{
+    const result=await win.performance.measureUserAgentSpecificMemory();
+    return{status:'measured',bytes:result.bytes}
+  }catch(error){return{status:'error',error:String(error?.message||error)}}
+}
+async function runScene(scene,profile){
+  frame.width=profile.cssWidth;frame.height=profile.cssHeight;
+  const loaded=new Promise((resolve,reject)=>{frame.onload=resolve;frame.onerror=reject});
+  const started=performance.now();
+  frame.src=appPath+hash(scene);
+  await loaded;
+  const win=frame.contentWindow,label=profile.id+'/'+scene.id;
+  const preview=await poll(()=>{
+    const d=win.__MANDEL_DIAG__?.snapshot();
+    return d&&d.drawState==='PREVIEW'&&!d.rendering&&d.lastPass==='preview'?d:null
+  },120000,'preview '+label);
+  const covered=await poll(()=>{
+    const d=win.__MANDEL_DIAG__?.snapshot();
+    return d&&d.drawState==='COVERED'&&d.coverage>=1&&!d.rendering?d:null
+  },180000,'covered '+label);
+  const initial=covered.value,visual=await canvasAudit(win,scene,profile);
+  const exercise=scene.id==='z0';
+  const interaction=exercise?await interactionAudit(win):null;
+  const modes=exercise?await modeAudit(win):null;
+  const recolor=exercise?await recolorAudit(win):null;
+  const exportResult=exercise?await exportAudit(win):null;
+  const accessibility=exercise?await accessibilityAudit(win):null;
+  const resources=win.performance.getEntriesByType('resource').map(e=>String(e.name));
+  const assetRequests={deep:resources.filter(x=>/\/(deep|bla|color)-/.test(x)),allWasm:resources.filter(x=>/\.wasm(?:$|\?)/.test(x))};
+  await wait(2000);
+  const before=win.__MANDEL_DIAG__.snapshot();
+  await wait(1000);
+  const after=win.__MANDEL_DIAG__.snapshot();
+  const idle={
+    raf:after.scheduler.raf,timer:after.scheduler.timer,pointerSettle:after.scheduler.pointerSettle,
+    unknownTimer:after.scheduler.unknownTimer,backgroundJobs:after.scheduler.backgroundJobs,
+    canvasWrites:after.runtimeMetrics.canvasWrites-before.runtimeMetrics.canvasWrites,
+    domWrites:after.runtimeMetrics.domWrites-before.runtimeMetrics.domWrites,
+    renderStarts:after.runtimeMetrics.renderStarts-before.runtimeMetrics.renderStarts
+  };
+  return{
+    id:scene.id,profile:profile.id,target,requestedViewport:profile,
+    actualViewport:{cssWidth:win.innerWidth,cssHeight:win.innerHeight},actualDevicePixelRatio:win.devicePixelRatio,
+    totalMs:performance.now()-started,previewMs:preview.ms,coveredMs:covered.ms,
+    preview:preview.value,initial,final:after,idle,visual,assetRequests,interaction,modes,recolor,
+    export:exportResult,accessibility,memoryObserved:await observedMemory(win)
+  }
+}
+function evaluate(results,profile){
+  const exercise=results.find(x=>x.interaction);
+  const checks={
+    idle:results.every(x=>!x.idle.raf&&!x.idle.timer&&!x.idle.pointerSettle&&!x.idle.unknownTimer&&x.idle.backgroundJobs===0&&x.idle.canvasWrites===0&&x.idle.domWrites===0&&x.idle.renderStarts===0),
+    covered:results.every(x=>x.initial.coverage>=1&&x.initial.hqTarget===x.initial.frame),
+    managedMemory:results.every(x=>x.final.memory.managedBytes<=x.final.memory.budget),
+    visual:results.every(x=>x.visual.pass),
+    startup:results.filter(x=>x.id==='z0').every(x=>target==='hosted'?x.assetRequests.deep.length===0:x.initial.deepAssets.workers===0),
+    interaction:!!exercise&&exercise.interaction.paintP95Ms<16&&exercise.interaction.renderStartsDuringGesture===0&&exercise.interaction.renderStartsBeforeSettle===0&&exercise.interaction.longTasks===0,
+    preview:exercise?.modes?.previewTrials>=30&&exercise?.modes?.previewP95AfterSettleMs<120,
+    modes:exercise?.modes?.pass===true,
+    recolor:exercise?.recolor?.pass===true,
+    export:exercise?.export?.pass===true,
+    accessibilityAutomated:exercise?.accessibility?.pass===true,
+    profileFidelity:results.every(x=>x.actualViewport.cssWidth===profile.cssWidth&&x.actualViewport.cssHeight===profile.cssHeight&&Math.abs(x.actualDevicePixelRatio-profile.dpr)<.01)
+  };
+  const failures=Object.entries(checks).filter(([,pass])=>!pass).map(([name])=>name);
+  const pendingExternal=[
+    'observed browser/GPU peak memory review',
+    'visible-focus and rendered-output visual review',
+    'page zoom and canvas pinch coexistence',
+    'screen-reader live announcement order'
+  ];
+  return{pass:false,automatedPass:failures.length===0,checks,failures,pendingExternal}
+}
+document.querySelector('#run').onclick=async()=>{
+  document.querySelector('#run').disabled=true;
+  try{
+    const corpus=await(await fetch('./scenes.json',{cache:'no-store'})).json();
+    const profile=corpus.viewports.find(x=>x.id===selectedProfile);
+    if(!profile)throw new Error('Unknown profile: '+selectedProfile);
+    const results=[];
+    for(const scene of corpus.scenes){
+      out.textContent='Running '+profile.id+'/'+scene.id+' on '+target+'…\n'+JSON.stringify(results,null,2);
+      results.push(await runScene(scene,profile))
+    }
+    const report={
+      format:'mandelbrot-browser-baseline-v23',generatedUtc:new Date().toISOString(),target,
+      userAgent:navigator.userAgent,hostDevicePixelRatio:devicePixelRatio,profile,results,
+      acceptance:evaluate(results,profile)
+    };
+    out.textContent=JSON.stringify(report,null,2);
+    globalThis.__BENCHMARK_RESULT__=report
+  }catch(error){
+    out.textContent=String(error?.stack||error)
+  }finally{
+    document.querySelector('#run').disabled=false
+  }
+};
 </script>
diff --git a/tests/document-contract.ps1 b/tests/document-contract.ps1
new file mode 100644
index 0000000..02d0c10
--- /dev/null
+++ b/tests/document-contract.ps1
@@ -0,0 +1,133 @@
+$ErrorActionPreference = 'Stop'
+$workspace = (Resolve-Path -LiteralPath (Join-Path $PSScriptRoot '..')).Path
+
+function Assert-Contract([bool]$Condition, [string]$Message) {
+  if (-not $Condition) { throw $Message }
+}
+
+function Decimal-Fraction([string]$Text) {
+  if ($Text -notmatch '^([+-]?)(\d+)(?:\.(\d*))?(?:[eE]([+-]?\d+))?$') {
+    throw "Invalid decimal: $Text"
+  }
+  $negative = $Matches[1] -eq '-'
+  $fraction = if ($null -eq $Matches[3]) { '' } else { $Matches[3] }
+  $digits = ($Matches[2] + $fraction).TrimStart('0')
+  if (-not $digits) { $digits = '0' }
+  $numerator = [System.Numerics.BigInteger]::Parse($digits)
+  if ($negative) { $numerator = -$numerator }
+  $exponent = if ($Matches[4]) { [int]$Matches[4] } else { 0 }
+  $places = $fraction.Length - $exponent
+  if ($places -ge 0) {
+    $denominator = [System.Numerics.BigInteger]::Pow([System.Numerics.BigInteger]10, $places)
+  } else {
+    $numerator *= [System.Numerics.BigInteger]::Pow([System.Numerics.BigInteger]10, -$places)
+    $denominator = [System.Numerics.BigInteger]1
+  }
+  [pscustomobject]@{ numerator=$numerator; denominator=$denominator }
+}
+
+function Assert-ExactCoordinate($Scene, [string]$Axis) {
+  $decimal = Decimal-Fraction ([string]$Scene.$Axis)
+  $prefix = if ($Axis -eq 're') { 're' } else { 'im' }
+  $numerator = [System.Numerics.BigInteger]::Parse([string]$Scene.coordinate.($prefix + 'Numerator'))
+  $denominator = [System.Numerics.BigInteger]::Parse([string]$Scene.coordinate.($prefix + 'Denominator'))
+  Assert-Contract ($denominator -gt 0) "$($Scene.id): $Axis denominator must be positive."
+  Assert-Contract ($decimal.numerator * $denominator -eq $numerator * $decimal.denominator) "$($Scene.id): $Axis decimal does not match its exact rational."
+}
+
+$proposal = Get-Content -LiteralPath (Join-Path $workspace 'IMPROVEMENT_PROPOSAL.md') -Raw -Encoding UTF8
+Assert-Contract ($proposal -match 'Document status: historical-v22 / implemented-v23') 'Proposal status/provenance is missing.'
+Assert-Contract ($proposal -match 'sample coverage.+UNRESOLVED.+resolved coverage') 'Coverage semantics are not separated.'
+Assert-Contract ($proposal -match 'Balanced Export.+Validated Export') 'Export precision tiers are not separated.'
+Assert-Contract ($proposal -match 'exact half.+away-from-zero') 'Fixed-point tie rounding is not specified.'
+Assert-Contract ($proposal -match 'Phase 0A' -and $proposal -match 'Phase 0B') 'Browserless and browser gates are not separated.'
+Assert-Contract ($proposal -match 'threshold.+pass') 'Undefined acceptance thresholds must fail.'
+
+$scenePath = Join-Path $workspace 'tests\scenes.json'
+$scenes = Get-Content -LiteralPath $scenePath -Raw -Encoding UTF8 | ConvertFrom-Json
+$policy = Get-Content -LiteralPath (Join-Path $workspace 'tests\numeric-policy-v23.json') -Raw -Encoding UTF8 | ConvertFrom-Json
+Assert-Contract ($scenes.format -eq 'mandelbrot-scene-corpus-v2') 'Unexpected scene corpus version.'
+Assert-Contract ($scenes.pixelContract -eq 'centered-rational-ties-away-from-zero') 'Unexpected scene pixel contract.'
+Assert-Contract ($scenes.numericPolicy -eq $policy.id) 'Scene corpus and numeric policy IDs differ.'
+Assert-Contract ($policy.validated.falseEscapedMax -eq 0 -and $policy.validated.falseInteriorProvenMax -eq 0 -and $policy.validated.unresolvedMax -eq 0) 'Validated zero-error thresholds changed.'
+
+$ids = @{}
+$maxViewportPixels = ($scenes.viewports | ForEach-Object { [double]$_.cssWidth * [double]$_.dpr } | Measure-Object -Maximum).Maximum
+$viewportDigits = [Math]::Ceiling([Math]::Log10($maxViewportPixels))
+foreach ($scene in $scenes.scenes) {
+  Assert-Contract (-not $ids.ContainsKey($scene.id)) "Duplicate scene ID: $($scene.id)"
+  $ids[$scene.id] = $true
+  Assert-Contract ($null -ne $scene.coordinate -and $null -ne $scene.oracle) "$($scene.id): coordinate/oracle metadata missing."
+  if ($scene.coordinate.kind -eq 'exact-rational') {
+    Assert-ExactCoordinate $scene 're'
+    Assert-ExactCoordinate $scene 'im'
+  } elseif ($scene.coordinate.kind -eq 'decimal') {
+    $reDigits = ([regex]::Replace([string]$scene.re, '[^0-9]', '')).TrimStart('0').Length
+    $imDigits = ([regex]::Replace([string]$scene.im, '[^0-9]', '')).TrimStart('0').Length
+    $actualDigits = [Math]::Min($reDigits, $imDigits)
+    Assert-Contract ($actualDigits -eq [int]$scene.coordinate.significantDigits) "$($scene.id): significantDigits metadata is stale."
+    $span = [Math]::Abs([double]::Parse([string]$scene.span, [Globalization.CultureInfo]::InvariantCulture))
+    $depthDigits = [Math]::Ceiling(-[Math]::Log10($span))
+    $guard = $actualDigits - $depthDigits - $viewportDigits
+    Assert-Contract ($guard -eq [int]$scene.coordinate.guardDigitsAtViewport -and $guard -ge 4) "$($scene.id): coordinate guard digits are insufficient or stale."
+  } else {
+    throw "$($scene.id): unsupported coordinate kind $($scene.coordinate.kind)"
+  }
+}
+foreach ($required in @('z0','period2-cusp-z14','swirly-seahorses-z12','period2-cusp-z20','period2-cusp-z100','period3-interior','period2-cusp-e280')) {
+  Assert-Contract ($ids.ContainsKey($required)) "Required scene missing: $required"
+}
+$runtimeTest = Get-Content -LiteralPath (Join-Path $workspace 'tests\runtime-budget.mjs') -Raw -Encoding UTF8
+Assert-Contract ($runtimeTest -match "sceneById\('swirly-seahorses-z12'\)" -and $runtimeTest -match "acceptance:false") 'Runtime characterization must use the published mixed-boundary scene and remain non-acceptance evidence.'
+
+$runner = Get-Content -LiteralPath (Join-Path $workspace 'tests\browser-benchmark.html') -Raw -Encoding UTF8
+Assert-Contract ($runner -match "target==='hosted'.+dist/hosted/index\.html") 'Browser runner does not target the Hosted build.'
+Assert-Contract ($runner -match "selectedProfile=query\.get\('profile'\)" -and $runner -notmatch 'for\s*\(const profile of corpus\.viewports\)') 'Browser runner must execute one real-DPR profile per run.'
+Assert-Contract ($runner -notmatch 'deltaY\s*:\s*0') 'Wheel audit still uses a zero-delta event.'
+Assert-Contract ($runner -match 'previewTrials>=30' -and $runner -match "drawState==='REFINED'") 'Preview p95 or actual Refined checks are missing.'
+Assert-Contract ($runner -match 'visualGoldens' -and $runner -match 'hashValue===expected') 'Visual acceptance lacks a golden comparison.'
+Assert-Contract ($runner -match 'interaction\.longTasks===0') 'Long tasks are not part of browser acceptance.'
+Assert-Contract ($runner -match 'completed&&noEarlyDownload&&deterministic&&cancelledWithoutDownload') 'Export evidence is not part of the pass condition.'
+Assert-Contract ($runner -match 'pendingExternal' -and $runner -match 'return\{pass:false,automatedPass') 'Browser-only/manual residual gates can be falsely marked complete.'
+
+$baseline = Get-Content -LiteralPath (Join-Path $workspace 'audit\v23-source-baseline.json') -Raw -Encoding UTF8 | ConvertFrom-Json
+Assert-Contract ($baseline.hosted.deepRequestMeasurementStatus -eq 'not-run') 'Static deep-request contract is mislabeled as a measurement.'
+$records = @($baseline.hosted.firstViewFiles) + @($baseline.standalone.files) + @($baseline.sourceBuild.files)
+foreach ($record in $records) {
+  $path = Join-Path $workspace ([string]$record.file).Replace('/', [System.IO.Path]::DirectorySeparatorChar)
+  Assert-Contract (Test-Path -LiteralPath $path) "Baseline file missing: $($record.file)"
+  $item = Get-Item -LiteralPath $path
+  $hash = (Get-FileHash -LiteralPath $path -Algorithm SHA256).Hash.ToLowerInvariant()
+  Assert-Contract ($item.Length -eq [long]$record.bytes -and $hash -eq [string]$record.sha256) "Baseline bytes/hash mismatch: $($record.file)"
+}
+
+$implementation = Get-Content -LiteralPath (Join-Path $workspace 'IMPLEMENTATION_REPORT.md') -Raw -Encoding UTF8
+Assert-Contract ($implementation -match 'Hosted first view ([\d,]+) bytes') 'Hosted implementation size statement missing.'
+$hostedDoc = [long](($Matches[1] -replace ',', ''))
+Assert-Contract ($implementation -match 'Standalone ([\d,]+) bytes') 'Standalone implementation size statement missing.'
+$standaloneDoc = [long](($Matches[1] -replace ',', ''))
+Assert-Contract ($hostedDoc -eq [long]$baseline.hosted.firstViewUncompressedBytes -and $standaloneDoc -eq [long]$baseline.standalone.uncompressedBytes) 'Implementation size statement is stale.'
+
+$completion = Get-Content -LiteralPath (Join-Path $workspace 'COMPLETION_AUDIT.md') -Raw -Encoding UTF8
+Assert-Contract ($completion -notmatch '0\.91|36\.6') 'Completion audit cites performance values absent from the saved v23 JSON.'
+$buildDoc = Get-Content -LiteralPath (Join-Path $workspace 'BUILD_REPRODUCIBILITY.md') -Raw -Encoding UTF8
+Assert-Contract ($buildDoc -match 'Provenance status: tool archive hash not retained') 'Toolchain provenance boundary is overstated.'
+
+$browserless = Get-Content -LiteralPath (Join-Path $workspace 'audit\v23-browserless-baseline.json') -Raw -Encoding UTF8 | ConvertFrom-Json
+Assert-Contract ($browserless.status -eq 'pass' -and $browserless.scope -eq 'browserless-current-artifacts' -and -not $browserless.fullAcceptance) 'Browserless audit scope/status is misleading.'
+Assert-Contract ($browserless.node.version -eq 'v22.18.0' -and $browserless.node.archive.sha256 -eq 'c95d8a7e1c99e669cc08c9f1176e068c1f50847c37908fcb8c35b62482366511') 'Pinned Node provenance is missing.'
+foreach ($test in $browserless.executableTests.psobject.Properties) {
+  Assert-Contract ($test.Value.status -eq 'pass' -or $test.Name -eq 'runtime-budget.mjs') "Browserless executable gate failed: $($test.Name)"
+}
+Assert-Contract ($browserless.runtime.status -eq 'measured-not-acceptance' -and $browserless.v22Comparison.status -eq 'not-verifiable' -and $browserless.browserAcceptance.status -eq 'not-run') 'Residual gates are overstated.'
+
+[ordered]@{
+  status='pass'
+  proposalContract='revised-v23'
+  scenes=@($scenes.scenes).Count
+  viewports=@($scenes.viewports).Count
+  numericPolicy=$policy.id
+  hashedFiles=$records.Count
+  browserRunner='static-contract-pass'
+  browserlessEvidence='pass-with-explicit-limits'
+} | ConvertTo-Json
diff --git a/tests/js-syntax.mjs b/tests/js-syntax.mjs
index 51cd857..006bf46 100644
--- a/tests/js-syntax.mjs
+++ b/tests/js-syntax.mjs
@@ -3,7 +3,8 @@ import vm from 'node:vm';
 
 const root = new URL('../', import.meta.url);
 const kernels = await fs.readFile(new URL('kernels.js', root), 'utf8');
-let app = await fs.readFile(new URL('script.js', root), 'utf8');
+const appSource = await fs.readFile(new URL('script.js', root), 'utf8');
+let app = appSource;
 const browserHarness = await fs.readFile(new URL('tests/browser-benchmark.html', root), 'utf8');
 const browserModule = browserHarness.match(/<script type="module">([\s\S]*?)<\/script>/)?.[1];
 if (!browserModule) throw new Error('Browser benchmark module not found.');
@@ -148,5 +149,9 @@ console.log(JSON.stringify({
   referenceCheckpoints,
   deepWorkerModuleInit: true,
   browserHarnessSyntax: true,
-  sources: { appBytes: app.length, shallowWorkerBytes: sources.shallow.length, deepWorkerBytes: sources.deep.length }
+  sources: {
+    appBytes: Buffer.byteLength(appSource),
+    shallowWorkerCharacters: sources.shallow.length,
+    deepWorkerCharacters: sources.deep.length
+  }
 }));
diff --git a/tests/legacy-v23/numeric-policy-v23.json b/tests/legacy-v23/numeric-policy-v23.json
new file mode 100644
index 0000000..c854853
--- /dev/null
+++ b/tests/legacy-v23/numeric-policy-v23.json
@@ -0,0 +1,30 @@
+{
+  "format": "mandelbrot-numeric-policy-v1",
+  "id": "numeric-policy-v23",
+  "rendererVersion": 23,
+  "pixelContract": {
+    "mapping": "centered-rational",
+    "fixedPointRounding": "nearest-ties-away-from-zero",
+    "fixedPointIntegerMismatchMax": 0,
+    "float64CoordinateUlpMax": 4,
+    "tileSeamPixelMismatchMax": 0
+  },
+  "validated": {
+    "falseEscapedMax": 0,
+    "falseInteriorProvenMax": 0,
+    "unresolvedMax": 0,
+    "escapeIterationAbsMax": 0,
+    "magnitudeRelativeErrorMax": 1e-12,
+    "referenceGuardBits": 64
+  },
+  "balanced": {
+    "falseEscapedMax": 0,
+    "falseInteriorProvenMax": 0,
+    "interiorLikelyMismatch": "record",
+    "unresolved": "record"
+  },
+  "color": {
+    "smoothCorrectionRelativeErrorMax": 0.00003,
+    "simdScalarRelativeErrorMax": 1e-7
+  }
+}
diff --git a/tests/numeric-policy-v23.json b/tests/numeric-policy-v23.json
new file mode 100644
index 0000000..c854853
--- /dev/null
+++ b/tests/numeric-policy-v23.json
@@ -0,0 +1,30 @@
+{
+  "format": "mandelbrot-numeric-policy-v1",
+  "id": "numeric-policy-v23",
+  "rendererVersion": 23,
+  "pixelContract": {
+    "mapping": "centered-rational",
+    "fixedPointRounding": "nearest-ties-away-from-zero",
+    "fixedPointIntegerMismatchMax": 0,
+    "float64CoordinateUlpMax": 4,
+    "tileSeamPixelMismatchMax": 0
+  },
+  "validated": {
+    "falseEscapedMax": 0,
+    "falseInteriorProvenMax": 0,
+    "unresolvedMax": 0,
+    "escapeIterationAbsMax": 0,
+    "magnitudeRelativeErrorMax": 1e-12,
+    "referenceGuardBits": 64
+  },
+  "balanced": {
+    "falseEscapedMax": 0,
+    "falseInteriorProvenMax": 0,
+    "interiorLikelyMismatch": "record",
+    "unresolved": "record"
+  },
+  "color": {
+    "smoothCorrectionRelativeErrorMax": 0.00003,
+    "simdScalarRelativeErrorMax": 1e-7
+  }
+}
diff --git a/tests/pixel-mapping.mjs b/tests/pixel-mapping.mjs
index 9f1c128..1a105d1 100644
--- a/tests/pixel-mapping.mjs
+++ b/tests/pixel-mapping.mjs
@@ -1,12 +1,79 @@
 const assert=(ok,message)=>{if(!ok)throw new Error(message)};
-const close=(a,b)=>Math.abs(a-b)<=1e-15*Math.max(1,Math.abs(a),Math.abs(b));
+const bitsBuffer=new ArrayBuffer(8),bitsView=new DataView(bitsBuffer);
+function ulp(value){
+  if(!Number.isFinite(value))return Infinity;
+  if(value===0)return Number.MIN_VALUE;
+  bitsView.setFloat64(0,value,false);
+  let bits=bitsView.getBigUint64(0,false);
+  bits+=value>0?1n:-1n;
+  bitsView.setBigUint64(0,bits,false);
+  return Math.abs(bitsView.getFloat64(0,false)-value)
+}
+const closeUlp=(a,b,limit=4)=>Math.abs(a-b)<=limit*Math.max(Number.MIN_VALUE,ulp(a),ulp(b));
+const roundDiv=(value,denominator)=>{
+  const negative=value<0n,absolute=negative?-value:value;
+  const quotient=(absolute+denominator/2n)/denominator;
+  return negative?-quotient:quotient
+};
+assert(roundDiv(1n,2n)===1n&&roundDiv(-1n,2n)===-1n,'half ties must round away from zero');
+assert(roundDiv(3n,2n)===2n&&roundDiv(-3n,2n)===-2n,'roundDiv must be sign symmetric');
+
 const view={re:-.743643887037151,im:.13182590420533,span:3.4e-12,w:37,h:23};
-const world=(x,y,w=view.w,h=view.h,span=view.span)=>[view.re+(x+.5-w*.5)*span/w,view.im+(h*.5-y-.5)*span/w];
-const shallow=(x,y)=>{const scale=view.span/view.w,shiftedRe=view.re+scale*.5,shiftedIm=view.im-scale*.5;return[shiftedRe+(x-view.w*.5)*scale,shiftedIm+(view.h*.5-y)*scale]};
-const deep=(x,y)=>{const scale=view.span/view.w,offR=scale*.5,offI=-scale*.5;return[view.re+offR+scale*(x-view.w*.5),view.im+offI+scale*(view.h*.5-y)]};
-const bla=(x,y)=>{const scale=view.span/view.w,offR=scale*.5,offI=-scale*.5;return[view.re+offR+view.span*(x/view.w-.5),view.im+offI+view.span*((.5*view.h-y)/view.w)]};
-let samples=0;for(let y=0;y<view.h;y++)for(let x=0;x<view.w;x++){const expected=world(x,y);for(const [name,actual]of[['shallow',shallow(x,y)],['deep',deep(x,y)],['bla',bla(x,y)]]){assert(close(expected[0],actual[0])&&close(expected[1],actual[1]),`${name} mapping mismatch ${x},${y}`)}samples++}
-for(const sampleScale of[2,4]){const tile={x:7,y:5,w:11,h:9},W=view.w*sampleScale,H=view.h*sampleScale;for(let phase=0;phase<sampleScale*sampleScale;phase++){const left=(phase%sampleScale)*tile.w,top=((phase/sampleScale)|0)*tile.h;for(let yy=0;yy<tile.h;yy++)for(let xx=0;xx<tile.w;xx++){const gx=tile.x*sampleScale+left+xx,gy=tile.y*sampleScale+top+yy,expected=world(gx,gy,W,H,view.span);const direct=[view.re+(gx+.5-W*.5)*view.span/W,view.im+(H*.5-gy-.5)*view.span/W];assert(close(expected[0],direct[0])&&close(expected[1],direct[1]),`tile seam ${sampleScale}x phase ${phase}`)}}}
-const first=world(0,0),last=world(view.w-1,view.h-1);assert(close((first[0]+last[0])/2,view.re),'view center moved on x');assert(close((first[1]+last[1])/2,view.im),'view center moved on y');
-const result={status:'pass',samples,backends:['shallow','deep','bla'],subsampleScales:[2,4],contract:'(x+0.5,y+0.5)'};
-console.log(JSON.stringify(result));export default result;
+const world=(x,y,w=view.w,h=view.h,span=view.span)=>[
+  view.re+(x+.5-w*.5)*span/w,
+  view.im+(h*.5-y-.5)*span/w
+];
+const shallow=(x,y)=>{
+  const scale=view.span/view.w,shiftedRe=view.re+scale*.5,shiftedIm=view.im-scale*.5;
+  return[shiftedRe+(x-view.w*.5)*scale,shiftedIm+(view.h*.5-y)*scale]
+};
+const deep=(x,y)=>{
+  const scale=view.span/view.w,offR=scale*.5,offI=-scale*.5;
+  return[view.re+offR+scale*(x-view.w*.5),view.im+offI+scale*(view.h*.5-y)]
+};
+const bla=(x,y)=>{
+  const scale=view.span/view.w,offR=scale*.5,offI=-scale*.5;
+  return[view.re+offR+view.span*(x/view.w-.5),view.im+offI+view.span*((.5*view.h-y)/view.w)]
+};
+
+let samples=0;
+for(let y=0;y<view.h;y++)for(let x=0;x<view.w;x++){
+  const expected=world(x,y);
+  for(const [name,actual]of[['shallow',shallow(x,y)],['deep',deep(x,y)],['bla',bla(x,y)]]){
+    assert(closeUlp(expected[0],actual[0])&&closeUlp(expected[1],actual[1]),name+' mapping mismatch '+x+','+y)
+  }
+  samples++
+}
+for(const sampleScale of[2,4]){
+  const tile={x:7,y:5,w:11,h:9},W=view.w*sampleScale,H=view.h*sampleScale;
+  for(let phase=0;phase<sampleScale*sampleScale;phase++){
+    const left=(phase%sampleScale)*tile.w,top=((phase/sampleScale)|0)*tile.h;
+    for(let yy=0;yy<tile.h;yy++)for(let xx=0;xx<tile.w;xx++){
+      const gx=tile.x*sampleScale+left+xx,gy=tile.y*sampleScale+top+yy,expected=world(gx,gy,W,H,view.span);
+      const direct=[view.re+(gx+.5-W*.5)*view.span/W,view.im+(H*.5-gy-.5)*view.span/W];
+      assert(closeUlp(expected[0],direct[0])&&closeUlp(expected[1],direct[1]),'tile seam '+sampleScale+'x phase '+phase)
+    }
+  }
+}
+const first=world(0,0),last=world(view.w-1,view.h-1);
+assert(closeUlp((first[0]+last[0])/2,view.re),'view center moved on x');
+assert(closeUlp((first[1]+last[1])/2,view.im),'view center moved on y');
+
+const fixedBits=320n,fixedOne=1n<<fixedBits;
+const fixedView={re:-3n*fixedOne/4n,im:0n,span:1n<<220n,w:37,h:23};
+const fixedWorld=(x,y,w=fixedView.w,h=fixedView.h)=>[
+  fixedView.re+roundDiv(fixedView.span*BigInt(2*x+1-w),BigInt(2*w)),
+  fixedView.im+roundDiv(fixedView.span*BigInt(h-2*y-1),BigInt(2*w))
+];
+for(let y=0;y<fixedView.h;y++)for(let x=0;x<fixedView.w;x++){
+  const point=fixedWorld(x,y),mirror=fixedWorld(fixedView.w-1-x,fixedView.h-1-y);
+  assert(point[0]+mirror[0]===2n*fixedView.re,'fixed x symmetry mismatch '+x+','+y);
+  assert(point[1]+mirror[1]===2n*fixedView.im,'fixed y symmetry mismatch '+x+','+y)
+}
+
+const result={
+  status:'pass',samples,backends:['shallow','deep','bla'],subsampleScales:[2,4],
+  contract:'centered-rational',float64UlpMax:4,fixedPointRounding:'nearest-ties-away-from-zero'
+};
+console.log(JSON.stringify(result));
+export default result;
diff --git a/tests/runtime-budget.mjs b/tests/runtime-budget.mjs
index 99942d1..e8a6112 100644
--- a/tests/runtime-budget.mjs
+++ b/tests/runtime-budget.mjs
@@ -5,6 +5,12 @@ import { fileURLToPath } from 'node:url';
 
 const root=path.resolve(fileURLToPath(new URL('..',import.meta.url)));
 const wasmDir=path.join(root,'build','wasm-v23');
+const corpus=JSON.parse(await fs.readFile(path.join(root,'tests','scenes.json'),'utf8'));
+const sceneById=id=>{
+  const scene=corpus.scenes.find(candidate=>candidate.id===id);
+  if(!scene)throw new Error('Scene missing: '+id);
+  return scene
+};
 const load=async name=>(await WebAssembly.instantiate(await fs.readFile(path.join(wasmDir,name)),{})).instance.exports;
 const median=values=>values.slice().sort((a,b)=>a-b)[values.length>>1];
 const assert=(ok,message)=>{if(!ok)throw new Error(message)};
@@ -20,7 +26,7 @@ async function benchmarkShallow(){
 
 function reference(cr,ci,limit){const rr=new Float64Array(limit+1),ri=new Float64Array(limit+1);let zr=0,zi=0;for(let n=0;n<=limit;n++){rr[n]=zr;ri[n]=zi;const nr=zr*zr-zi*zi+cr;zi=2*zr*zi+ci;zr=nr}return{rr,ri}}
 async function benchmarkDeep(){
-  const ex=await load('bla-simd.wasm'),c={id:'seahorse-bla-2000',re:-.743643887037151,im:.13182590420533,span:3.4e-14,w:256,h:144,iter:2000},ref=reference(c.re,c.im,c.iter),scale=c.span/c.w;
+  const scene=sceneById('swirly-seahorses-z12'),ex=await load('bla-simd.wasm'),c={id:'swirly-seahorses-z12-bla-2000',re:Number(scene.re),im:Number(scene.im),span:Number(scene.span),w:256,h:144,iter:2000},ref=reference(c.re,c.im,c.iter),scale=c.span/c.w;
   new Float64Array(ex.memory.buffer,ex.refs_r_ptr(),150001).set(ref.rr);new Float64Array(ex.memory.buffer,ex.refs_i_ptr(),150001).set(ref.ri);
   const tBuild=performance.now(),entries=ex.build_bla(c.iter,Math.hypot(c.span*.5,c.span*c.h/(2*c.w)),2**-32),buildMs=performance.now()-tBuild;assert(entries>0,'BLA table build failed');
   const run=()=>ex.render_bla_rect_v2(c.span,scale*.5,-scale*.5,c.re,c.im,c.iter,c.w,c.h,0,0,c.w,c.h,c.iter,0,0,1);run();const samples=[];for(let i=0;i<5;i++){const t=performance.now();assert(run()===c.w*c.h,'BLA output size');samples.push(performance.now()-t)}const ms=median(samples),counts=new Uint32Array(ex.memory.buffer,ex.counts_ptr(),c.w*c.h),unresolved=counts.reduce((n,v)=>n+(v>=0xfffffffe),0);return{id:c.id,width:c.w,height:c.h,iterations:c.iter,pixels:c.w*c.h,blaEntries:entries,buildMs,medianMs:ms,msPerMegapixel:ms*1e6/(c.w*c.h),unresolved,samplesMs:samples}
@@ -36,6 +42,6 @@ const source=await fs.readFile(path.join(root,'script.js'),'utf8'),contracts={
   viewportIndependentFloor:/minDpr=Math\.min\(1,64\/Math\.max\(cssW,cssH\)\)/.test(source)
 };
 assert(Object.values(contracts).every(Boolean),`runtime budget contract failed: ${JSON.stringify(contracts)}`);
-const report={format:'mandelbrot-node-runtime-budget-v23',generatedUtc:new Date().toISOString(),node:process.version,contracts,shallow:await benchmarkShallow(),deep:await benchmarkDeep()};
+const report={format:'mandelbrot-node-runtime-budget-v23',generatedUtc:new Date().toISOString(),node:process.version,status:'measured',acceptance:false,sceneCorpus:corpus.format,measurementNote:'Runtime characterization only; browser acceptance has separate thresholds and evidence.',contracts,shallow:await benchmarkShallow(),deep:await benchmarkDeep()};
 const outputArg=process.argv.indexOf('--out');if(outputArg>=0){const target=path.resolve(process.argv[outputArg+1]);await fs.writeFile(target,JSON.stringify(report,null,2)+'\n','utf8')}
 console.log(JSON.stringify(report));
diff --git a/tests/scenes.json b/tests/scenes.json
index b027366..2d3001b 100644
--- a/tests/scenes.json
+++ b/tests/scenes.json
@@ -1,14 +1,72 @@
 {
-  "format": "mandelbrot-scene-corpus-v1",
+  "format": "mandelbrot-scene-corpus-v2",
   "rendererVersion": 23,
-  "pixelContract": "centered",
+  "pixelContract": "centered-rational-ties-away-from-zero",
+  "numericPolicy": "numeric-policy-v23",
   "scenes": [
-    {"id":"z0","re":"-0.5","im":"0","span":"3.4","tags":["shallow","overview"]},
-    {"id":"seahorse-z14","re":"-0.743643887037151","im":"0.13182590420533","span":"3.4e-14","tags":["deep","boundary"]},
-    {"id":"seahorse-z20","re":"-0.743643887037151","im":"0.13182590420533","span":"3.4e-20","tags":["deep","boundary","warm-reference"]},
-    {"id":"seahorse-z100","re":"-0.743643887037151","im":"0.13182590420533","span":"3.4e-100","tags":["deep","precision"]},
-    {"id":"period3-interior","re":"-0.122561166876","im":"0.744861766619","span":"1e-8","tags":["interior","periodic"]},
-    {"id":"deep-cliff-e280","re":"-0.743643887037151","im":"0.13182590420533","span":"1e-280","tags":["deep","scaled-bla-boundary"]}
+    {
+      "id": "z0",
+      "re": "-0.5",
+      "im": "0",
+      "span": "3.4",
+      "coordinate": {"kind":"exact-rational","reNumerator":"-1","reDenominator":"2","imNumerator":"0","imDenominator":"1"},
+      "oracle": {"kind":"overview","membership":"mixed"},
+      "tags": ["shallow","overview"]
+    },
+    {
+      "id": "period2-cusp-z14",
+      "re": "-0.75",
+      "im": "0",
+      "span": "3.4e-14",
+      "coordinate": {"kind":"exact-rational","reNumerator":"-3","reDenominator":"4","imNumerator":"0","imDenominator":"1"},
+      "oracle": {"kind":"known-boundary","id":"main-cardioid-period2-root","membership":"boundary"},
+      "tags": ["deep","boundary","parabolic"]
+    },
+    {
+      "id": "swirly-seahorses-z12",
+      "re": "-0.7453983606667815",
+      "im": "0.1125046349959942",
+      "span": "3.52e-12",
+      "coordinate": {"kind":"exact-rational","reNumerator":"-7453983606667815","reDenominator":"10000000000000000","imNumerator":"1125046349959942","imDenominator":"10000000000000000"},
+      "oracle": {"kind":"published-performance-scene","membership":"mixed","iterations":2000,"source":"https://github.com/ckormanyos/mandelbrot#swirly-seahorses-and-mini-mandelbrot"},
+      "tags": ["deep","boundary","performance"]
+    },
+    {
+      "id": "period2-cusp-z20",
+      "re": "-0.75",
+      "im": "0",
+      "span": "3.4e-20",
+      "coordinate": {"kind":"exact-rational","reNumerator":"-3","reDenominator":"4","imNumerator":"0","imDenominator":"1"},
+      "oracle": {"kind":"known-boundary","id":"main-cardioid-period2-root","membership":"boundary"},
+      "tags": ["deep","boundary","warm-reference","parabolic"]
+    },
+    {
+      "id": "period2-cusp-z100",
+      "re": "-0.75",
+      "im": "0",
+      "span": "3.4e-100",
+      "coordinate": {"kind":"exact-rational","reNumerator":"-3","reDenominator":"4","imNumerator":"0","imDenominator":"1"},
+      "oracle": {"kind":"known-boundary","id":"main-cardioid-period2-root","membership":"boundary"},
+      "tags": ["deep","precision","parabolic"]
+    },
+    {
+      "id": "period3-interior",
+      "re": "-0.122561166876653619975245551820735654052",
+      "im": "0.744861766619744236593170428604392367240",
+      "span": "1e-8",
+      "coordinate": {"kind":"decimal","significantDigits":39,"guardDigitsAtViewport":27},
+      "oracle": {"kind":"polynomial-root","polynomial":"c^3+2c^2+c+1","membership":"interior","period":3},
+      "tags": ["interior","periodic"]
+    },
+    {
+      "id": "period2-cusp-e280",
+      "re": "-0.75",
+      "im": "0",
+      "span": "1e-280",
+      "coordinate": {"kind":"exact-rational","reNumerator":"-3","reDenominator":"4","imNumerator":"0","imDenominator":"1"},
+      "oracle": {"kind":"known-boundary","id":"main-cardioid-period2-root","membership":"boundary"},
+      "tags": ["deep","deep-scaled-boundary","parabolic"]
+    }
   ],
   "viewports": [
     {"id":"mobile","cssWidth":390,"cssHeight":844,"dpr":3},
diff --git a/tests/source-contract.ps1 b/tests/source-contract.ps1
index 13f445a..dcd1312 100644
--- a/tests/source-contract.ps1
+++ b/tests/source-contract.ps1
@@ -47,6 +47,8 @@ Assert-NotContains $script 'n<36' 'Fixed 36-tile refinement cap returned.'
 Assert-Contains $script 'detailCacheBudget\(\)' 'Byte-budget detail cache is missing.'
 Assert-Contains $script 'function memoryLedger' 'Logical memory ledger is missing.'
 Assert-Contains $script 'function deepWisdomStorageKey' 'Versioned per-device wisdom persistence is missing.'
+Assert-Contains $script 'DEEP_WISDOM_TTL_MS=30\*24\*60\*60\*1000' 'Persisted wisdom has no 30-day TTL.'
+Assert-Contains $script 'savedAt:Date\.now\(\)' 'Persisted wisdom has no save timestamp.'
 Assert-Contains $script 'promoteState\(required\+32-available\);invalidateReferenceOrbit\(\)' 'Orbit-condition precision promotion does not rebuild the reference.'
 Assert-Contains $script 'function verifyReferenceCheckpoints' 'P/P+64 reference-orbit checkpoint verification is missing.'
 Assert-Contains $script 'state\.processMode!==''validate''' 'Reference-orbit checkpoint verification is not gated to precision-first rendering.'
@@ -58,6 +60,7 @@ Assert-NotContains $script 'const SIMD=\$\{JSON\.stringify\(DEEP_SIMD_B64\)\}' '
 Assert-Contains $script 'highPrecisionDirectPixelAsync' 'Yielding high-precision direct verifier is missing.'
 Assert-Contains $script "state\.processMode==='validate'\|\|task\.tile\.score>1\.35" 'Validated detail subsamples are not guarded-direct.'
 Assert-Contains $script 'kernelSha256:globalThis\.MANDEL_KERNEL_META' 'Export kernel identity metadata is missing.'
+Assert-Contains $script 'exportForcePrecision&&unresolvedSamples' 'Validated Export can emit a final file with unresolved samples.'
 Assert-NotContains $script 'exactDeepPixel' 'Misleading exactDeepPixel alias returned.'
 Assert-Contains $script 'deepEngineNeeded' 'ULP-based engine selection is missing.'
 Assert-NotContains $script 'scheduleRealWisdom' 'Default active Real Wisdom benchmark returned.'
diff --git a/tests/v24-acceptance-contract.mjs b/tests/v24-acceptance-contract.mjs
new file mode 100644
index 0000000..6ababc3
--- /dev/null
+++ b/tests/v24-acceptance-contract.mjs
@@ -0,0 +1,10 @@
+import fs from 'node:fs/promises';
+const s=await fs.readFile(new URL('./webgpu-acceptance.js',import.meta.url),'utf8');
+const must=(ok,msg)=>{if(!ok)throw new Error(msg)};
+must(/row\.known<12/.test(s),'swirly minimum-known gate missing');
+must(/row\.unknown!==0/.test(s),'stable-scene UNKNOWN=0 gate missing');
+must(/falseEscaped/.test(s)&&/falseBounded/.test(s)&&/guardMismatch/.test(s),'membership/reference gates missing');
+must(/dense false escape/.test(s)&&/dense false bounded/.test(s),'dense regression gates missing');
+must(/exportSmoke\.unresolved!==0/.test(s)&&/exportSmokeAA\.unresolved!==0/.test(s),'export unresolved gate missing');
+must(/uncapturedErrors/.test(s),'uncaptured WebGPU error gate missing');
+console.log(JSON.stringify({status:'pass',checks:6,stableUnknownMax:0,swirlyKnownMin:12},null,2));
diff --git a/tests/v24-bla-model.mjs b/tests/v24-bla-model.mjs
new file mode 100644
index 0000000..19730df
--- /dev/null
+++ b/tests/v24-bla-model.mjs
@@ -0,0 +1,4 @@
+import fs from 'node:fs/promises';
+const root=new URL('../',import.meta.url),script=await fs.readFile(new URL('script.js',root),'utf8'),kernels=await fs.readFile(new URL('gpu-kernels.js',root),'utf8');
+const failures=[];if(/buildBla\(|BlaNode|useBla|blaLevels/.test(script+kernels))failures.push('BLA code remains in production');if(!/blaEnabled:false/.test(script))failures.push('sidecar/diagnostics do not declare BLA disabled');if(failures.length)throw new Error(failures.join('; '));
+console.log(JSON.stringify({status:'pass',kind:'bla-disabled-contract',reason:'dense swirly regression demonstrated unsafe f32-quantized BLA classifications',productionBla:false},null,2));
diff --git a/tests/v24-coordinate-format.mjs b/tests/v24-coordinate-format.mjs
new file mode 100644
index 0000000..6642042
--- /dev/null
+++ b/tests/v24-coordinate-format.mjs
@@ -0,0 +1,7 @@
+function rd(v,d){const neg=v<0n,a=neg?-v:v,q=(a+d/2n)/d;return neg?-q:q}
+function decRatio(t){let s=String(t).trim().toLowerCase(),neg=s.startsWith('-');if(neg)s=s.slice(1);if(s.startsWith('+'))s=s.slice(1);const[m,e0='0']=s.split('e'),e=Number(e0),[i='0',f='']=m.split('.');let digits=(i+f).replace(/^0+(?=\d)/,'')||'0',places=f.length-e;if(places<0){digits+='0'.repeat(-places);places=0}let n=BigInt(digits);if(neg)n=-n;return[n,10n**BigInt(places)]}
+function fixed(t,b){const[n,d]=decRatio(t);return rd(n*(1n<<BigInt(b)),d)}
+function fmt(v,bits){let neg=v<0n;if(neg)v=-v;const scale=10n**BigInt(bits),q=v*scale>>BigInt(bits);let s=q.toString().padStart(bits+1,'0');s=s.slice(0,-bits)+'.'+s.slice(-bits);s=s.replace(/(\.\d*?)0+$/,'$1').replace(/\.$/,'');return(neg?'-':'')+s}
+function parseFixed(s,bits){const[n,d]=decRatio(s);return n*(1n<<BigInt(bits))/d}
+for(const [text,bits] of [['1e-400',1569],['1e-1000',3562],['-0.75',1569]]){const v=fixed(text,bits),s=fmt(v,bits);if(s==='0'||s==='-0')throw new Error('deep formatter collapsed '+text);const r=parseFixed(s,bits);if(r!==v)throw new Error('exact decimal roundtrip failed '+text);}
+console.log(JSON.stringify({status:'pass',kind:'exact-fixed-decimal-format',deep:['1e-400','1e-1000']},null,2));
diff --git a/tests/v24-cpu-numeric-model.mjs b/tests/v24-cpu-numeric-model.mjs
new file mode 100644
index 0000000..5e94930
--- /dev/null
+++ b/tests/v24-cpu-numeric-model.mjs
@@ -0,0 +1,47 @@
+import fs from 'node:fs/promises';
+const corpus=JSON.parse(await fs.readFile(new URL('./scenes.json',import.meta.url),'utf8'));const map=new Map(corpus.scenes.map(s=>[s.id,s]));map.set('period2-cusp-e400',{id:'period2-cusp-e400',re:'-0.75',im:'0',span:'1e-400'});const F=Math.fround;
+function bitLen(v){v=v<0n?-v:v;return v===0n?0:v.toString(2).length}function roundDiv(v,d){const neg=v<0n,a=neg?-v:v,q=(a+d/2n)/d;return neg?-q:q}function roundShift(v,b){const neg=v<0n,a=neg?-v:v,q=(a+(1n<<(BigInt(b)-1n)))>>BigInt(b);return neg?-q:q}function align(v,a,b){const d=b-a;return d===0?v:d>0?v<<BigInt(d):v>>BigInt(-d)}
+function decRatio(t){let s=String(t).trim().toLowerCase(),neg=s.startsWith('-');if(neg)s=s.slice(1);if(s.startsWith('+'))s=s.slice(1);const [m,e0='0']=s.split('e'),e=Number(e0),[i='0',f='']=m.split('.');let digits=(i+f).replace(/^0+(?=\d)/,'')||'0',places=f.length-e;if(places<0){digits+='0'.repeat(-places);places=0}let n=BigInt(digits),d=10n**BigInt(places);if(neg)n=-n;return[n,d]}
+function decFixed(t,b){const[n,d]=decRatio(t);return roundDiv(n*(1n<<BigInt(b)),d)}function bitsForSpan(t){const s=String(t).toLowerCase(),a=s.split('e'),m=Math.abs(Number(a[0])),e=a[1]?Number(a[1]):0,l2=Math.log2(m)+e*Math.log2(10);return Math.max(256,Math.ceil(-l2)+240)}function snap(scene){const bits=bitsForSpan(scene.span);return{bits,re:decFixed(scene.re,bits),im:decFixed(scene.im,bits),span:decFixed(scene.span,bits)}}
+function fixedNum(v,bits){if(v===0n)return 0;let neg=v<0n;if(neg)v=-v;const bl=bitLen(v),take=Math.min(53,bl),sh=bl-take,top=Number(v>>BigInt(sh)),x=top*Math.pow(2,sh-bits);return neg?-x:x}function log2FixedAt(v,b){v=v<0n?-v:v;if(v===0n)return-Infinity;const bl=bitLen(v),take=Math.min(53,bl),sh=bl-take,top=Number(v>>BigInt(sh));return Math.log2(top)+sh-b}function spanME(s){const l=log2FixedAt(s.span,s.bits),exp=Math.floor(l);return{mant:F(Math.pow(2,l-exp)),exp}}
+function pixel(s,w,h,x,y,b=s.bits){const re=align(s.re,s.bits,b),im=align(s.im,s.bits,b),span=align(s.span,s.bits,b),den=BigInt(2*w);return[re+roundDiv(span*BigInt(2*x+1-w),den),im+roundDiv(span*BigInt(h-2*y-1),den)]}
+function direct(cr,ci,b,limit){const bail=4n<<BigInt(b);let zr=0n,zi=0n;for(let n=0;n<limit;n++){const zr2=roundShift(zr*zr,b),zi2=roundShift(zi*zi,b);zi=roundShift(2n*zr*zi,b)+ci;zr=zr2-zi2+cr;if(roundShift(zr*zr,b)+roundShift(zi*zi,b)>bail)return n+1}return limit}
+function buildRef(s,limit){const b=s.bits+64,cr=align(s.re,s.bits,b),ci=align(s.im,s.bits,b);let zr=0n,zi=0n;const hi=new Float32Array((limit+1)*2),lo=new Float32Array((limit+1)*2);for(let n=0;n<=limit;n++){const rr=fixedNum(zr,b),ri=fixedNum(zi,b),hr=F(rr),hii=F(ri);hi[n*2]=hr;hi[n*2+1]=hii;lo[n*2]=F(rr-hr);lo[n*2+1]=F(ri-hii);if(n===limit)break;const zr2=roundShift(zr*zr,b),zi2=roundShift(zi*zi,b);zi=roundShift(2n*zr*zi,b)+ci;zr=zr2-zi2+cr}return{hi,lo,refLen:limit}}
+function cmul(ar,ai,br,bi){return[F(F(ar*br)-F(ai*bi)),F(F(ar*bi)+F(ai*br))]}function scale(v,e){if(e<-126)return 0;if(e>126)return F(8.507059e37);return F(v*Math.pow(2,e))}
+function perturb(ref,s,w,h,x,y,limit,strict=false){const se=spanME(s),dx=F((x+.5-.5*w)/w),dy=F((.5*h-y-.5)/w),U=2**-24;let dr=F(se.mant*dx),di=F(se.mant*dy),wr=0,wi=0,e=se.exp,n=0,m=0,ops=0,err=64*U*Math.max(Math.abs(dr),Math.abs(di));while(true){if(n>=limit){const rp=Math.min(m,ref.refLen)*2,delr=scale(wr,e),deli=scale(wi,e),zr=F(ref.hi[rp]+F(ref.lo[rp]+delr)),zi=F(ref.hi[rp+1]+F(ref.lo[rp+1]+deli)),ea=Math.abs(err*2**e)+64*U*(Math.max(Math.abs(zr),Math.abs(zi))+Math.max(Math.abs(delr),Math.abs(deli))+1e-30),threshold=strict?1e-4:1e-3;return ea<=threshold?{kind:'bounded',n,err:ea}:{kind:'unknown',n,reason:'error-bound',err:ea}}if(m>ref.refLen)return{kind:'unknown',n,reason:'ref'};const rp=m*2,delr=scale(wr,e),deli=scale(wi,e),zr=F(ref.hi[rp]+F(ref.lo[rp]+delr)),zi=F(ref.hi[rp+1]+F(ref.lo[rp+1]+deli)),mag=F(F(zr*zr)+F(zi*zi)),ea=Math.abs(err*2**e)+64*U*(Math.max(Math.abs(zr),Math.abs(zi))+Math.max(Math.abs(delr),Math.abs(deli))+1e-30);if(mag>4){if(Math.hypot(zr,zi)-ea>2)return{kind:'escaped',n,err:ea};return{kind:'unknown',n,reason:'escape-uncertain',err:ea}}const dmag=F(F(delr*delr)+F(deli*deli));if(m>0&&dmag>0&&mag<dmag){if(se.exp-e<-96)return{kind:'unknown',n,reason:'rebase-gap'};err=ea;wr=zr;wi=zi;dr=scale(F(se.mant*dx),se.exp);di=scale(F(se.mant*dy),se.exp);e=0;m=0;err+=64*U*Math.max(Math.abs(dr),Math.abs(di));continue}if(m>=ref.refLen)return{kind:'unknown',n,reason:'ref-end'};const rr=ref.hi[rp],ri=ref.hi[rp+1],lr=ref.lo[rp],li=ref.lo[rp+1],refAbs=Math.max(Math.abs(rr),Math.abs(ri))+Math.max(Math.abs(lr),Math.abs(li)),wAbs=Math.max(Math.abs(wr),Math.abs(wi)),dAbs=Math.max(Math.abs(dr),Math.abs(di)),p2=Math.abs(2**e),gain=2*refAbs+2*wAbs*p2,roundErr=64*U*(2*refAbs*wAbs+wAbs*wAbs*p2+dAbs+1e-30);err=gain*err+roundErr;const[a,b]=cmul(rr,ri,wr,wi),[c,d]=cmul(lr,li,wr,wi),[sqR,sqI]=cmul(wr,wi,wr,wi);wr=F(F(F(2*a)+F(2*c))+F(scale(sqR,e)+dr));wi=F(F(F(2*b)+F(2*d))+F(scale(sqI,e)+di));m++;n++;ops++;if(!Number.isFinite(wr)||!Number.isFinite(wi)||!Number.isFinite(err)||Math.max(Math.abs(wr),Math.abs(wi),Math.abs(dr),Math.abs(di))>=1e30||err>1e35)return{kind:'unknown',n,reason:'range'};const mm=Math.max(Math.abs(wr),Math.abs(wi),Math.abs(dr),Math.abs(di));if(mm>65536){wr=F(wr/65536);wi=F(wi/65536);dr=F(dr/65536);di=F(di/65536);err/=65536;e+=16}else if(mm>0&&mm<1/65536&&e>se.exp){wr=F(wr*65536);wi=F(wi*65536);dr=F(dr*65536);di=F(di*65536);err*=65536;e-=16}if(e>126||ops>limit*2+2048)return{kind:'unknown',n,reason:'guard'}}}
+const cfg=[['period2-cusp-z14',1200],['swirly-seahorses-z12',2000],['period2-cusp-z20',1800],['period2-cusp-z100',2400],['period3-interior',1200],['period2-cusp-e280',2400],['period2-cusp-e400',1600]],w=17,h=11,pts=[];
+for(let y=0;y<h;y++)for(let x=0;x<w;x++)pts.push([x,y]);
+const report=[];
+for(const mode of [{name:'balanced',strict:false},{name:'strict',strict:true}]){
+  for(const[id,limit]of cfg){
+    const sc=map.get(id),s=snap(sc),ref=buildRef(s,limit);
+    let guardMismatch=0,falseEscaped=0,falseBounded=0,unknown=0,exactEscape=0;
+    const mismatch=[];
+    for(const[x,y]of pts){
+      const p=pixel(s,w,h,x,y),g=pixel(s,w,h,x,y,s.bits+64),a=direct(p[0],p[1],s.bits,limit),ag=direct(g[0],g[1],s.bits+64,limit);
+      if(a!==ag){guardMismatch++;continue}
+      const r=perturb(ref,s,w,h,x,y,limit,mode.strict);
+      if(r.kind==='unknown'){unknown++;continue}
+      if(r.kind==='escaped'&&a===limit)falseEscaped++;
+      if(r.kind==='bounded'&&a<limit)falseBounded++;
+      if(r.kind==='escaped'&&a<limit&&r.n===a)exactEscape++;
+      if(((r.kind==='escaped'&&a<limit&&r.n!==a)||(r.kind==='bounded'&&a<limit))&&mismatch.length<5)mismatch.push({x,y,oracle:a,gpu:r});
+    }
+    report.push({mode:mode.name,id,bits:s.bits,limit,guardMismatch,falseEscaped,falseBounded,unknown,known:pts.length-unknown,exactEscape,mismatch});
+  }
+}
+const denseScene=map.get('swirly-seahorses-z12'),denseS=snap(denseScene),denseRef=buildRef(denseS,2000),densePoints=[[25,12],[26,15],[27,25]],dense=[];
+for(const[x,y]of densePoints){
+  const p=pixel(denseS,61,39,x,y),g=pixel(denseS,61,39,x,y,denseS.bits+64),a=direct(p[0],p[1],denseS.bits,2000),ag=direct(g[0],g[1],denseS.bits+64,2000);
+  if(a!==ag)throw new Error('dense oracle guard mismatch '+x+','+y);
+  for(const mode of [{name:'balanced',strict:false},{name:'strict',strict:true}]){
+    const r=perturb(denseRef,denseS,61,39,x,y,2000,mode.strict);
+    if(r.kind==='escaped'&&a===2000)throw new Error('dense false escape '+JSON.stringify({mode:mode.name,x,y,a,r}));
+    if(r.kind==='bounded'&&a<2000)throw new Error('dense false bounded '+JSON.stringify({mode:mode.name,x,y,a,r}));
+    dense.push({mode:mode.name,x,y,oracle:a,gpu:r});
+  }
+}
+if(report.some(r=>r.guardMismatch||r.falseEscaped||r.falseBounded))throw new Error('numeric classification failure '+JSON.stringify(report));
+const allUnknownStrict=report.filter(r=>r.mode==='strict'&&r.unknown===pts.length);
+if(allUnknownStrict.length)throw new Error('strict mode became all UNKNOWN: '+JSON.stringify(allUnknownStrict));
+console.log(JSON.stringify({status:'pass',kind:'guarded-production-equation-cpu-f32-model-not-real-gpu',thresholds:{balanced:1e-3,strict:1e-4},report,denseRegression:dense},null,2));
diff --git a/tests/v24-direct-model.mjs b/tests/v24-direct-model.mjs
new file mode 100644
index 0000000..3b0c04c
--- /dev/null
+++ b/tests/v24-direct-model.mjs
@@ -0,0 +1,13 @@
+import fs from 'node:fs/promises';
+const corpus=JSON.parse(await fs.readFile(new URL('./scenes.json',import.meta.url),'utf8'));
+const scene=corpus.scenes.find(s=>s.id==='z0'); const F=Math.fround;
+function rd(v,d){const neg=v<0n,a=neg?-v:v,q=(a+d/2n)/d;return neg?-q:q}
+function rs(v,b){const neg=v<0n,a=neg?-v:v,q=(a+(1n<<(BigInt(b)-1n)))>>BigInt(b);return neg?-q:q}
+function dec(t,b){let s=String(t).toLowerCase(),neg=s.startsWith('-');if(neg)s=s.slice(1);if(s.startsWith('+'))s=s.slice(1);const[m,e0='0']=s.split('e'),e=Number(e0),[i='0',f='']=m.split('.');let dg=(i+f).replace(/^0+(?=\d)/,'')||'0',p=f.length-e;if(p<0){dg+='0'.repeat(-p);p=0}let n=BigInt(dg);if(neg)n=-n;return rd(n*(1n<<BigInt(b)),10n**BigInt(p))}
+function pixel(re,im,span,b,w,h,x,y){const den=BigInt(2*w);return[re+rd(span*BigInt(2*x+1-w),den),im+rd(span*BigInt(h-2*y-1),den)]}
+function oracle(cr,ci,b,limit){const bail=4n<<BigInt(b);let zr=0n,zi=0n;for(let n=0;n<limit;n++){const a=rs(zr*zr,b),c=rs(zi*zi,b);zi=rs(2n*zr*zi,b)+ci;zr=a-c+cr;if(rs(zr*zr,b)+rs(zi*zi,b)>bail)return n+1}return limit}
+function direct(cr,ci,limit){cr=F(cr);ci=F(ci);const U=2**-24,y2=F(ci*ci),x=F(cr-.25),q=F(F(x*x)+y2),lhs=F(q*F(q+x)),rhs=F(.25*y2),margin=F(16*U*(Math.abs(lhs)+Math.abs(rhs)+1));if(lhs<F(rhs-margin))return limit;const x2=F(cr+1),bulb=F(F(x2*x2)+y2),bulbMargin=F(16*U*(Math.abs(bulb)+.0625+1));if(bulb<F(.0625-bulbMargin))return limit;let zr=0,zi=0;for(let n=0;n<limit;n++){const a=F(zr*zr),c=F(zi*zi);zi=F(F(F(2*zr)*zi)+ci);zr=F(F(a-c)+cr);if(F(F(zr*zr)+F(zi*zi))>4)return n+1}return limit}
+const bits=256,re=dec(scene.re,bits),im=dec(scene.im,bits),span=dec(scene.span,bits),W=33,H=21,limit=800;let falseEscaped=0,falseBounded=0,guardMismatch=0,countMismatch=0,tested=0;
+for(let y=0;y<H;y++)for(let x=0;x<W;x++){const [cr,ci]=pixel(re,im,span,bits,W,H,x,y),[gr,gi]=pixel(re<<64n,im<<64n,span<<64n,bits+64,W,H,x,y),a=oracle(cr,ci,bits,limit),g=oracle(gr,gi,bits+64,limit);if(a!==g){guardMismatch++;continue}const rr=Number(cr)/2**bits,ii=Number(ci)/2**bits,r=direct(rr,ii,limit);tested++;if(r<limit&&a===limit)falseEscaped++;if(r===limit&&a<limit)falseBounded++;if(r<limit&&a<limit&&r!==a)countMismatch++}
+if(falseEscaped||falseBounded)throw new Error(JSON.stringify({falseEscaped,falseBounded,guardMismatch,countMismatch}));
+console.log(JSON.stringify({status:'pass',kind:'direct-f32-cpu-model-not-real-gpu',tested,guardMismatch,falseEscaped,falseBounded,countMismatch},null,2));
diff --git a/tests/v24-geometry-contract.mjs b/tests/v24-geometry-contract.mjs
new file mode 100644
index 0000000..7e4a381
--- /dev/null
+++ b/tests/v24-geometry-contract.mjs
@@ -0,0 +1,6 @@
+const must=(x,m)=>{if(!x)throw new Error(m)};
+for(const [W,H] of [[17,11],[1024,768],[16384,9216]])for(const tile of [64,512])for(const sx of [.25,.5,.75])for(const sy of [.25,.5,.75])for(const [tx,ty,lx,ly] of [[0,0,0,0],[tile,0,3,5],[tile*2,tile,7,11]]){if(tx+lx>=W||ty+ly>=H)continue;const gx=tx+lx+sx,gy=ty+ly+sy,fullX=(gx-.5*W)/W,fullY=(.5*H-gy)/W,tiledX=((tx+lx+sx)-.5*W)/W,tiledY=(.5*H-(ty+ly+sy))/W;must(Object.is(fullX,tiledX)&&Object.is(fullY,tiledY),'tile mapping seam')}
+const maxFramePixels=8*1048576,fieldBytes=maxFramePixels*4;must(fieldBytes<=128*1024*1024,'default storage binding budget exceeded');
+const oldQueueBytes=maxFramePixels*4,newCounterBytes=16;must(newCounterBytes<oldQueueBytes/100000,'unresolved queue was not reduced to a counter');
+for(const [cw,ch] of [[390,844],[1920,1080],[1080,1920]]){const aspect=ch/cw,w0=16384,h0=Math.round(w0*aspect),h=Math.min(16384,h0),w=h0>16384?Math.max(64,Math.round(h/aspect)):w0;must(w<=16384&&h<=16384,'export dimension clamp failed')}
+console.log(JSON.stringify({status:'pass',pixelContract:'centered',exportTile:512,strictRetryPass:false,unresolvedCounterBytes:newCounterBytes,maxExportSide:16384},null,2));
diff --git a/tests/v24-index-contract.mjs b/tests/v24-index-contract.mjs
new file mode 100644
index 0000000..598d4a0
--- /dev/null
+++ b/tests/v24-index-contract.mjs
@@ -0,0 +1 @@
+import fs from 'node:fs/promises';const h=await fs.readFile(new URL('../index.html',import.meta.url),'utf8');const req=['id="view"','id="processMode"','保守的 (Strict)','id="exportPrecision"','gpu-kernels.js','script.js'];for(const x of req)if(!h.includes(x))throw new Error('missing '+x);if(h.includes('<script src="kernels.js"></script>'))throw new Error('legacy kernels.js loaded');console.log(JSON.stringify({status:'pass',checks:req.length+1},null,2));
diff --git a/tests/v24-png-stream-model.mjs b/tests/v24-png-stream-model.mjs
new file mode 100644
index 0000000..f2d29b2
--- /dev/null
+++ b/tests/v24-png-stream-model.mjs
@@ -0,0 +1,40 @@
+import assert from 'node:assert/strict';
+import {inflateSync} from 'node:zlib';
+
+const CRC_TABLE=(()=>{const t=new Uint32Array(256);for(let n=0;n<256;n++){let c=n;for(let k=0;k<8;k++)c=(c&1)?0xedb88320^(c>>>1):c>>>1;t[n]=c>>>0}return t})();
+function crc32Parts(parts){let c=0xffffffff;for(const part of parts)for(const b of part)c=CRC_TABLE[(c^b)&255]^(c>>>8);return(c^0xffffffff)>>>0}
+function pngChunk(type,data=new Uint8Array()){const tb=new TextEncoder().encode(type),out=new Uint8Array(12+data.length),dv=new DataView(out.buffer);dv.setUint32(0,data.length,false);out.set(tb,4);out.set(data,8);dv.setUint32(8+data.length,crc32Parts([tb,data]),false);return out}
+class StreamingPng{
+  constructor(w,h){this.w=w;this.h=h;this.cs=new CompressionStream('deflate');this.writer=this.cs.writable.getWriter();this.compressed=(async()=>{const r=this.cs.readable.getReader(),chunks=[];for(;;){const q=await r.read();if(q.done)break;chunks.push(q.value)}return chunks})()}
+  async rows(filteredRows){await this.writer.write(filteredRows)}
+  async finish(){await this.writer.close();const chunks=await this.compressed,ihdr=new Uint8Array(13),dv=new DataView(ihdr.buffer);dv.setUint32(0,this.w,false);dv.setUint32(4,this.h,false);ihdr[8]=8;ihdr[9]=6;const parts=[new Uint8Array([137,80,78,71,13,10,26,10]),pngChunk('IHDR',ihdr)];for(const c of chunks)parts.push(pngChunk('IDAT',c));parts.push(pngChunk('IEND'));return new Blob(parts,{type:'image/png'})}
+  async abort(reason){try{await this.writer.abort(reason)}catch{}try{await this.compressed}catch{}}
+}
+
+assert.equal(typeof CompressionStream,'function','CompressionStream required for this model');
+const p=new StreamingPng(2,2);
+const row0=Uint8Array.from([255,0,0,255, 0,255,0,255]);
+const row1=Uint8Array.from([0,0,255,255, 255,255,255,128]);
+const filtered=new Uint8Array(18);filtered.set(row0,1);filtered.set(row1,10);await p.rows(filtered);
+const bytes=new Uint8Array(await (await p.finish()).arrayBuffer());
+assert.deepEqual(Array.from(bytes.subarray(0,8)),[137,80,78,71,13,10,26,10]);
+let off=8, width=0, height=0, idats=[], seenIend=false;
+while(off<bytes.length){
+  const dv=new DataView(bytes.buffer,bytes.byteOffset+off);
+  const len=dv.getUint32(0,false); const type=new TextDecoder().decode(bytes.subarray(off+4,off+8));
+  const data=bytes.subarray(off+8,off+8+len); const got=dv.getUint32(8+len,false);
+  assert.equal(got,crc32Parts([bytes.subarray(off+4,off+8),data]),`CRC ${type}`);
+  if(type==='IHDR'){const h=new DataView(data.buffer,data.byteOffset,data.byteLength);width=h.getUint32(0,false);height=h.getUint32(4,false);assert.equal(data[8],8);assert.equal(data[9],6)}
+  if(type==='IDAT')idats.push(data);
+  if(type==='IEND')seenIend=true;
+  off += 12+len;
+}
+assert.equal(width,2); assert.equal(height,2); assert.ok(idats.length>=1); assert.ok(seenIend);
+const packed=Buffer.concat(idats.map(x=>Buffer.from(x)));
+const raw=new Uint8Array(inflateSync(packed));
+assert.equal(raw.length,2*(1+2*4));
+assert.equal(raw[0],0); assert.deepEqual(Array.from(raw.subarray(1,9)),Array.from(row0));
+assert.equal(raw[9],0); assert.deepEqual(Array.from(raw.subarray(10,18)),Array.from(row1));
+
+const aborted=new StreamingPng(1,1); await aborted.rows(Uint8Array.from([0,0,0,0,255])); await aborted.abort(new Error('cancelled'));
+console.log(JSON.stringify({status:'pass',png:{width,height,idatChunks:idats.length,rawBytes:raw.length},abort:'settled'},null,2));
diff --git a/tests/v24-reference-worker.mjs b/tests/v24-reference-worker.mjs
new file mode 100644
index 0000000..bcc6cb6
--- /dev/null
+++ b/tests/v24-reference-worker.mjs
@@ -0,0 +1,3 @@
+import fs from 'node:fs/promises';import vm from 'node:vm';import {performance} from 'node:perf_hooks';
+const source=await fs.readFile(new URL('../script.js',import.meta.url),'utf8'),prefix="function referenceWorkerSource(){return String.raw`",start=source.indexOf(prefix)+prefix.length,end=source.indexOf("`}\nclass ReferenceService",start);if(start<prefix.length||end<0)throw new Error('worker source not found');const workerSource=source.slice(start,end);let message=null;const self={postMessage:m=>{message=m},onmessage:null};const ctx={self,postMessage:(...a)=>self.postMessage(...a),performance,Math,Number,BigInt,ArrayBuffer,DataView,Float32Array,Float64Array,Uint32Array,Set,String,Error};vm.createContext(ctx);vm.runInContext(workerSource,ctx,{timeout:5000});if(typeof self.onmessage!=='function')throw new Error('worker handler missing');
+self.onmessage({data:{type:'build',id:1,key:'test',bits:256,re:(-3n*(1n<<256n)/4n).toString(),im:'0',iter:800}});if(!message)throw new Error('worker produced no message');if(message.type==='error')throw new Error(message.error);if(message.checkpointMismatch)throw new Error('reference +64 guard checkpoint mismatch');if(message.refLen<3||message.refs.byteLength!==(message.refLen+1)*16)throw new Error('reference packing invalid');for(const forbidden of ['nodes','levels','nodeCount','levelCount','invalidNodes'])if(forbidden in message)throw new Error('BLA payload leaked from quarantined reference worker: '+forbidden);const primary=message;message=null;const b=1536,R=(-3n*(1n<<BigInt(b))/4n).toString();self.onmessage({data:{type:'build',id:2,key:'e400',bits:b,re:R,im:'0',iter:120}});if(!message||message.type==='error')throw new Error(message?.error||'e400 worker produced no message');if(message.checkpointMismatch||message.refs.byteLength!==(message.refLen+1)*16)throw new Error('e400 reference contract failed');console.log(JSON.stringify({status:'pass',refLen:primary.refLen,precisionBits:primary.precisionBits,checkpointCount:primary.checkpointCount,buildMs:primary.buildMs,productionBla:false,e400:{checkpointMismatch:message.checkpointMismatch,refLen:message.refLen}},null,2));
diff --git a/tests/v24-source-contract.mjs b/tests/v24-source-contract.mjs
new file mode 100644
index 0000000..61847cb
--- /dev/null
+++ b/tests/v24-source-contract.mjs
@@ -0,0 +1,32 @@
+import fs from 'node:fs/promises';
+const root=new URL('../',import.meta.url),script=await fs.readFile(new URL('script.js',root),'utf8'),kernels=await fs.readFile(new URL('gpu-kernels.js',root),'utf8'),html=await fs.readFile(new URL('index.html',root),'utf8');
+const must=(ok,msg)=>{if(!ok)throw new Error(msg)};
+must(/const VERSION=24/.test(script),'renderer version is not 24');
+must(/navigator\.gpu\.requestAdapter/.test(script),'WebGPU adapter path missing');
+must(/guarded rescaled perturbation/.test(script),'guarded deep WebGPU path missing');
+must(/referenceWorkerSource/.test(script)&&/BigInt\(d\.re\)/.test(script),'BigInt reference worker missing');
+must(!/function buildBla\(/.test(script)&&!/BlaNode/.test(kernels)&&!/useBla/.test(kernels),'unsafe BLA path is not fully quarantined');
+must(/F32_U/.test(kernels)&&/safe_abs_error/.test(kernels)&&/errAbs/.test(kernels),'deep error-bound guard missing');
+must(/struct UnresolvedHead/.test(kernels)&&/atomicAdd\(&unresolved\.remaining/.test(kernels),'unresolved counter missing');
+must(!/strict_queue|QUEUE_FINALIZE_WGSL/.test(kernels)&&!/dispatchWorkgroupsIndirect|qitems|strict-indirect/.test(script),'redundant strict retry queue remains');
+must(/texture_storage_2d<rgba8unorm,write>/.test(kernels),'GPU color field path missing');
+must(/AA_RESOLVE_WGSL/.test(kernels)&&/renderTileRGBA2x/.test(script),'GPU 2x2 export resolve missing');
+must(/class StreamingPng/.test(script)&&/CompressionStream\('deflate'\)/.test(script)&&/async abort\(reason\)/.test(script),'streaming PNG export/abort missing');
+must(/PRESENT_WGSL/.test(kernels),'GPU reprojection/presentation missing');
+must(/recolorPending/.test(script)&&!/const token=\+\+state\.token,stateSnap/.test(script),'recolor race fix missing');
+must(/this\.context=null/.test(script)&&/webgpuCanvasClaimed=true;this\.configure\(\)/.test(script)&&/if\(webgpuCanvasClaimed\)return null/.test(script),'delayed WebGPU canvas claim/fallback guard missing');
+must(/このズーム深度はWebGPUが必要です/.test(script),'deep fallback rejection missing');
+must(!/Math\.min\(340/.test(script),'deep exact-coordinate formatter still capped at 340 digits');
+must(/uncapturederror/.test(script)&&/pushErrorScope/.test(script),'WebGPU error capture missing');
+must(/gpu-kernels\.js/.test(html)&&!/src="kernels\.js"/.test(html),'index is not WebGPU-only');
+must(/numericParams/.test(script)&&/colorParams/.test(script),'persistent frame parameter buffers missing');
+must(/ensureExportWorkspace/.test(script)&&/exportWorkspaceDestroy/.test(script)&&/export tile exceeds reusable workspace/.test(script),'reusable export GPU workspace missing');
+must(/if\(!adapter\)adapter=await navigator\.gpu\.requestAdapter\(\)/.test(script),'adapter fallback request missing');
+must(/gpuInitFailed/.test(script)&&/WebGPU初期化失敗/.test(script),'shader/pipeline failure guard missing');
+must(/if\(state\.gpuInitFailed\)return null/.test(script),'failed shader initialization can be retried on every render');
+must(/if\(!r\)\{if\(state\.gpuInitFailed\)/.test(script),'shader failure still enters CPU fallback');
+must(/return 524288/.test(script)&&/1572864/.test(script),'responsive screen pixel budgets missing');
+must(/gpuUnavailable/.test(script)&&/return 262144/.test(script),'lightweight no-adapter CPU fallback budget missing');
+for(const banned of ['DEEP_SIMD_B64','DEEP_SCALAR_B64','BLA_SIMD_B64','BLA_SCALAR_B64','deepPool','deepWasm','highPrecisionDirectPixelAsync','renderDeepAdaptive','render_perturb_rebase_rect','WebAssembly.Instance'])must(!script.includes(banned),'legacy production deep dependency remains: '+banned);
+must(!/Validated direct/.test(html),'obsolete Validated UI remains');
+console.log(JSON.stringify({status:'pass',rendererVersion:24,shaderVersion:'24.1.3',checks:28},null,2));
diff --git a/tests/v24-tree-contract.mjs b/tests/v24-tree-contract.mjs
new file mode 100644
index 0000000..9fcc0c5
--- /dev/null
+++ b/tests/v24-tree-contract.mjs
@@ -0,0 +1,5 @@
+import fs from 'node:fs/promises';
+const root=new URL('../',import.meta.url);const exists=async p=>{try{await fs.stat(new URL(p,root));return true}catch{return false}};
+for(const banned of ['kernels.js','src/deep_kernel.c','src/bla_kernel_v18.c','src/color_kernel.c','src/shallow_kernel.c','build/wasm-v23'])if(await exists(banned))throw new Error('legacy renderer asset remains: '+banned);
+for(const required of ['index.html','script.js','gpu-kernels.js','tests/webgpu-acceptance.html','tests/webgpu-acceptance.js'])if(!await exists(required))throw new Error('required v24 asset missing: '+required);
+console.log(JSON.stringify({status:'pass',legacyDeepAssets:0,requiredAssets:5},null,2));
diff --git a/tests/v24-wgsl-reserved.mjs b/tests/v24-wgsl-reserved.mjs
new file mode 100644
index 0000000..21682ee
--- /dev/null
+++ b/tests/v24-wgsl-reserved.mjs
@@ -0,0 +1,21 @@
+import fs from 'node:fs/promises';
+import vm from 'node:vm';
+const root=new URL('../',import.meta.url);
+const src=await fs.readFile(new URL('gpu-kernels.js',root),'utf8');
+const context={};context.globalThis=context;vm.runInNewContext(src,context,{filename:'gpu-kernels.js'});
+const kernels=context.MANDEL_WEBGPU_KERNELS;
+if(!kernels)throw new Error('kernel bundle did not initialize');
+// WGSL 16.2 Reserved Words. A module must not contain one of these tokens.
+const reserved=`NULL Self abstract active alignas alignof as asm asm_fragment async attribute auto await become cast catch class co_await co_return co_yield coherent column_major common compile compile_fragment concept const_cast consteval constexpr constinit crate debugger decltype delete demote demote_to_helper do dynamic_cast enum explicit export extends extern external fallthrough filter final finally friend from fxgroup get goto groupshared highp impl implements import inline instanceof interface layout lowp macro macro_rules match mediump meta mod module move mut mutable namespace new nil noexcept noinline nointerpolation non_coherent noncoherent noperspective null nullptr of operator package packoffset partition pass patch pixelfragment precise precision premerge priv protected pub public readonly ref regardless register reinterpret_cast require resource restrict self set shared sizeof smooth snorm static static_assert static_cast std subroutine super target template this thread_local throw trait try type typedef typeid typename typeof union unless unorm unsafe unsized use using varying virtual volatile wgsl where with writeonly yield`.split(/\s+/);
+const strip=s=>s.replace(/\/\*[\s\S]*?\*\//g,' ').replace(/\/\/.*$/gm,' ');
+const failures=[];
+for(const [name,code] of Object.entries(kernels)){
+  if(typeof code!=='string'||!name.endsWith('_WGSL'))continue;
+  const clean=strip(code);
+  for(const word of reserved){
+    const re=new RegExp(`\\b${word}\\b`);
+    if(re.test(clean))failures.push(`${name}: reserved token ${word}`);
+  }
+}
+if(failures.length)throw new Error(failures.join('\n'));
+console.log(JSON.stringify({status:'pass',check:'wgsl-reserved-words',shaderVersion:kernels.version,kernels:Object.keys(kernels).filter(k=>k.endsWith('_WGSL')).length},null,2));
diff --git a/tests/webgpu-acceptance.html b/tests/webgpu-acceptance.html
new file mode 100644
index 0000000..26f8542
--- /dev/null
+++ b/tests/webgpu-acceptance.html
@@ -0,0 +1,4 @@
+<!doctype html><meta charset="utf-8"><title>v24 WebGPU acceptance</title>
+<style>body{font:13px ui-monospace,monospace;background:#09101d;color:#e9efff;margin:16px}iframe{width:320px;height:200px;border:1px solid #445}pre{white-space:pre-wrap}</style>
+<h1>v24 WebGPU acceptance</h1><iframe id="app" src="../index.html"></iframe><pre id="out">starting…</pre>
+<script src="webgpu-acceptance.js"></script>
diff --git a/tests/webgpu-acceptance.js b/tests/webgpu-acceptance.js
new file mode 100644
index 0000000..d9955ac
--- /dev/null
+++ b/tests/webgpu-acceptance.js
@@ -0,0 +1,35 @@
+(()=>{'use strict';
+const out=document.querySelector('#out'),frame=document.querySelector('#app');
+const scenes=[
+ ['z0','-0.5','0','3.4',120],
+ ['period2-cusp-z14','-0.75','0','3.4e-14',1200],
+ ['swirly-seahorses-z12','-0.7453983606667815','0.1125046349959942','3.52e-12',2000],
+ ['period2-cusp-z20','-0.75','0','3.4e-20',1800],
+ ['period2-cusp-z100','-0.75','0','3.4e-100',2400],
+ ['period3-interior','-0.122561166876653619975245551820735654052','0.744861766619744236593170428604392367240','1e-8',1200],
+ ['period2-cusp-e280','-0.75','0','1e-280',2400],
+ ['period2-cusp-e400','-0.75','0','1e-400',1600]
+];
+function roundDiv(v,d){const neg=v<0n,a=neg?-v:v,q=(a+d/2n)/d;return neg?-q:q}
+function align(v,a,b){const d=b-a;return d===0?v:d>0?v<<BigInt(d):v>>BigInt(-d)}
+function roundShift(v,b){const neg=v<0n,a=neg?-v:v,q=(a+(1n<<(BigInt(b)-1n)))>>BigInt(b);return neg?-q:q}
+function pixel(st,x,y,bits=st.bits){const re=align(BigInt(st.re),st.bits,bits),im=align(BigInt(st.im),st.bits,bits),span=align(BigInt(st.span),st.bits,bits),den=BigInt(2*st.width);return[re+roundDiv(span*BigInt(2*x+1-st.width),den),im+roundDiv(span*BigInt(st.height-2*y-1),den)]}
+function orbit(cr,ci,bits,limit){const bail=4n<<BigInt(bits);let zr=0n,zi=0n;for(let n=0;n<limit;n++){const zr2=roundShift(zr*zr,bits),zi2=roundShift(zi*zi,bits);zi=roundShift(2n*zr*zi,bits)+ci;zr=zr2-zi2+cr;if(roundShift(zr*zr,bits)+roundShift(zi*zi,bits)>bail)return n+1}return limit}
+function points(w,h){const xs=[0,.25,.5,.75,1].map(t=>Math.min(w-1,Math.max(0,Math.round(t*(w-1))))),ys=[0,.25,.5,.75,1].map(t=>Math.min(h-1,Math.max(0,Math.round(t*(h-1)))));return ys.flatMap(y=>xs.map(x=>[x,y]))}
+async function waitApp(){if(frame.contentWindow&&frame.contentWindow.__MANDEL_TEST__)return;await new Promise(r=>frame.addEventListener('load',r,{once:true}));const t=performance.now();while(!frame.contentWindow.__MANDEL_TEST__&&performance.now()-t<15000)await new Promise(r=>setTimeout(r,50));if(!frame.contentWindow.__MANDEL_TEST__)throw new Error('test hook not available')}
+async function checkScene(api,id,re,im,span,iter,mode){
+  const r=await api.setView({re,im,span,baseIter:iter,adaptive:false,processMode:mode}),diag=r.diag;
+  if(diag.backend!=='webgpu'||diag.webgpuError)throw new Error(id+'/'+mode+': WebGPU backend unavailable/error: '+(diag.webgpuError||diag.backend));
+  const st=api.state(),ps=points(st.width,st.height),meta=await api.sampleMeta(ps);let guardMismatch=0,falseEscaped=0,falseBounded=0,escapeIterationMismatch=0,unknown=0;
+  for(let i=0;i<ps.length;i++){const [x,y]=ps[i],p=pixel(st,x,y),pg=pixel(st,x,y,st.bits+64),a=orbit(p[0],p[1],st.bits,st.iter),g=orbit(pg[0],pg[1],st.bits+64,st.iter);if(a!==g){guardMismatch++;continue}const m=meta[i],cls=(m>>>28)&3,n=m&0x0fffffff;if(cls===0){unknown++;continue}if(cls===1&&a===st.iter)falseEscaped++;if(cls!==1&&a<st.iter)falseBounded++;if(cls===1&&a<st.iter&&n!==a)escapeIterationMismatch++}
+  const row={id,mode,width:st.width,height:st.height,iter:st.iter,deep:diag.deep,guardMismatch,falseEscaped,falseBounded,escapeIterationMismatch,unknown,known:ps.length-unknown,reference:diag.reference};
+  if(guardMismatch||falseEscaped||falseBounded)throw new Error(id+'/'+mode+' numeric gate failed: '+JSON.stringify(row));
+  if(id==='swirly-seahorses-z12'){if(row.known<12)throw new Error(id+'/'+mode+': excessive UNKNOWN rate: '+JSON.stringify(row));}
+  else if(row.unknown!==0)throw new Error(id+'/'+mode+': stable corpus scene produced UNKNOWN samples: '+JSON.stringify(row));
+  return row;
+}
+async function run(){await waitApp();const api=frame.contentWindow.__MANDEL_TEST__,report=[];for(const [id,re,im,span,iter] of scenes){for(const mode of (id==='z0'?['standard']:['standard','validate'])){out.textContent='running '+id+' / '+mode+'…\n'+JSON.stringify(report,null,2);report.push(await checkScene(api,id,re,im,span,iter,mode));}}
+ await api.setView({re:'-0.7453983606667815',im:'0.1125046349959942',span:'3.52e-12',baseIter:2000,adaptive:false,processMode:'validate'});const denseState={...api.state(),width:61,height:39},denseMeta=await api.probeMeta({w:61,h:39,strict:true}),densePoints=[[25,12],[26,15],[27,25]],denseRegression=[];for(const[x,y]of densePoints){const p=pixel(denseState,x,y),pg=pixel(denseState,x,y,denseState.bits+64),a=orbit(p[0],p[1],denseState.bits,denseState.iter),g=orbit(pg[0],pg[1],denseState.bits+64,denseState.iter);if(a!==g)throw new Error('dense guard mismatch '+x+','+y);const m=denseMeta[y*61+x],cls=(m>>>28)&3,n=m&0x0fffffff;if(cls===1&&a===denseState.iter)throw new Error('dense false escape '+JSON.stringify({x,y,a,cls,n}));if(cls!==0&&cls!==1&&a<denseState.iter)throw new Error('dense false bounded '+JSON.stringify({x,y,a,cls,n}));denseRegression.push({x,y,oracle:a,cls,n})}
+ await api.setView({re:'-0.75',im:'0',span:'3.4e-20',baseIter:1000,adaptive:false,processMode:'validate'});const exportSmoke=await api.smokeExportTile({w:48,h:32,strict:true,ss:1}),exportSmokeAA=await api.smokeExportTile({w:48,h:32,strict:true,ss:2});if(exportSmoke.length!==exportSmoke.expected||exportSmokeAA.length!==exportSmokeAA.expected)throw new Error('GPU export tile readback length mismatch');if(exportSmoke.unresolved!==0||exportSmokeAA.unresolved!==0)throw new Error('GPU export smoke left unresolved samples: '+JSON.stringify({exportSmoke,exportSmokeAA}));const diag=frame.contentWindow.__MANDEL_DIAG__.snapshot();if(diag.uncapturedErrors&&diag.uncapturedErrors.length)throw new Error('uncaptured WebGPU errors: '+JSON.stringify(diag.uncapturedErrors));const result={status:'pass',kind:'real-webgpu-acceptance',date:new Date().toISOString(),shaderVersion:diag.shaderVersion,adapter:diag.adapter,limits:diag.limits,exportSmoke,exportSmokeAA,denseRegression,report};out.textContent=JSON.stringify(result,null,2);document.title='PASS v24.1 WebGPU acceptance';globalThis.__WEBGPU_ACCEPTANCE__=result}
+run().catch(e=>{const result={status:'fail',error:String(e&&e.stack||e)};out.textContent=JSON.stringify(result,null,2);document.title='FAIL v24.1 WebGPU acceptance';globalThis.__WEBGPU_ACCEPTANCE__=result});
+})();