Free, open-source AI video generator for Mac. Run LTX-2.5 and MiniMax H3 (Hailuo) locally on Apple Silicon: text-to-video and image-to-video with sound, lip-sync, character LoRA training, songs from lyrics (YuE2) and image editing (Qwen-Image-Edit). One-click install via Pinokio. Offline: no cloud, no API key, no NVIDIA GPU.
Python ai-filmmakingai-videoai-video-generatorapple-siliconhailuoimage-to-videolip-synclocal-ailora-trainingltx-2ltx-2-5ltx-videomacosminimax-h3mlxmusic-generationoffline-aipinokiotext-to-videovideo-generation
release(v4.15.3): Hailuo H3 on a 36-59 GB Mac, said plainly
mrbizarro1d3cd1401563
diff --git a/README.md b/README.mdindex 36b4ea7..0bd3b55 100644--- a/README.md+++ b/README.md@@ -19,7 +19,7 @@</p>-> **Current release: v4.15.2.** **Lip-sync on LTX audio-to-video now actually follows the audio.** Since v4.8.1 the Audio tab's *Audio conditioning strength* started at 1.0 — and on the Q8 pipeline 1.0 switches audio guidance **off**, so the mouth moved without tracking the song. The slider now starts on **Auto** (the engine's own setting for your Mac: 3.0 on Q8, 1.0 on Q4), and a value you set by hand is kept exactly. Q8 audio-to-video renders take about a quarter longer again, because the audio pass that was being skipped runs. Also: the Pinokio sidebar now offers **Repair Phosphene engine** when the engine package never finished installing — promised in 4.15.1, delivered here. Full notes on the [releases page](https://github.com/mrbizarro/Phosphene/releases).+> **Current release: v4.15.3.** **Hailuo H3 on a 36-59 GB Mac, said plainly.** The H3 install card told every Mac it needed 64 GB, a number no part of Phosphene has ever required: from 36 GB, H3 runs on its compact Q8 engine, which the install builds by itself. The card now states the real floor, says when this Mac runs H3, and the **Install Hailuo H3** entry is in the Pinokio sidebar while the panel is running (it used to appear only with the panel stopped). A Mac that already has the H3 weights but not the compact engine gets a **Build Hailuo H3 compact engine** entry instead of being sent to an install button that was not there. Full notes on the [releases page](https://github.com/mrbizarro/Phosphene/releases).## Overview@@ -69,7 +69,7 @@ Text-to-video, image-to-video, and audio-to-video, all delivered as MP4 with joi| **How you get it** | The base install (27.5 GB) | One click in the Pinokio sidebar (75 GB) || **Modes** | Text, image, keyframes, extend, audio-to-video, character | Text and image || **Character LoRAs** | Yes — trained in-panel, face + voice | Not yet |-| **Memory** | Every tier in the table above; the surface adapts | 64 GB class, or 48 GB with the Q8 DiT pack on disk |+| **Memory** | Every tier in the table above; the surface adapts | 36 GB+ on the compact Q8 engine (the install builds it); 60 GB+ also runs the full bf16 engine || **Best at** | Breadth: every workflow the panel offers, plus your own trained faces | Dialogue: joint video + spoken lines + sound, from one prompt || **Weights licence** | [LTX-2.x Community License](LICENSES/LTX-2.x-Community-License.md) (Lightricks) | MiniMax Community License — territory restrictions apply |diff --git a/VERSION b/VERSIONindex 3e2accd..419cdbb 100644--- a/VERSION+++ b/VERSION@@ -1 +1 @@-4.15.2+4.15.3diff --git a/docs/H3_ENGINE.md b/docs/H3_ENGINE.mdindex 380b900..ae2baea 100644--- a/docs/H3_ENGINE.md+++ b/docs/H3_ENGINE.md@@ -3,7 +3,7 @@MiniMax-H3 (FL2VA) takes one prompt and returns **picture, dialogue and soundgenerated together**. It is a **peer of LTX, not an add-on to it** — but it istoo big to ship in the base install, so it arrives as **its own one-click-install**: ~75 GB of weights, a 46 GB+ Mac, and a licence with territory+install**: ~75 GB of weights, a 36 GB+ Mac, and a licence with territoryrestrictions. LTX remains the default engine and is completely untouched byany of this; whichever engines you have installed sit side by side in theswitcher.@@ -20,9 +20,9 @@ it can.| Band | Lane | State ||---|---|---|| **≥ 60 GB** (`H3_MIN_RAM_GB`) | bf16 master DiT | Renders. 64 GB Macs report ~63.x after firmware reservations, which is why the floor is 60. |-| **≥ 46 GB** (`H3_MIN_RAM_GB_Q8`), Q8 DiT pack on disk | quantised Q8 DiT | Renders. |-| **≥ 46 GB, Q8 DiT pack absent** | — | **Not a hardware verdict.** `scripts/pinokio/h3_build_q8.sh` builds that pack locally in ~5 min / ~22 GB with **no extra download**, and "Install Hailuo H3" runs it automatically below 60 GB. The switcher shows H3 as an offer, the inline card names the step, and `h3_status()` carries `needs_q8_dit: true` with the sentence in `ram_note`. |-| **< 46 GB** | — | Genuinely out of reach. The refusal states 46, not 64. |+| **≥ 36 GB** (`H3_MIN_RAM_GB_Q8`), Q8 DiT pack on disk | quantised Q8 DiT | Renders. |+| **≥ 36 GB, Q8 DiT pack absent** | — | **Not a hardware verdict.** `scripts/pinokio/h3_build_q8.sh` builds that pack locally in ~5 min / ~22 GB with **no extra download**, and "Install Hailuo H3" runs it automatically below 60 GB. The switcher shows H3 as an offer, the inline card names the step, and `h3_status()` carries `needs_q8_dit: true` with the sentence in `ram_note`. The sentence depends on whether the ~75 GB is already on disk: never installed → the sidebar's **Install Hailuo H3** (a real download, the Q8 build is its last step); weights present → **Build Hailuo H3 compact engine** (minutes, no download). Both entries are in the Pinokio sidebar while the panel runs, too (4.15.3; before that they appeared only with the panel stopped). |+| **< 36 GB** | — | Genuinely out of reach. The refusal states 36, not 64. |`h3_ram_verdict()` is the single place those bands are decided. The renderrefusal, the `make_job` fallback line, the switcher tooltip, the engine-row@@ -548,7 +548,7 @@ restart. `GET /status` → `.h3` tells you what resolved:| Symptom | Cause ||---|---|-| Engine switcher not visible at all | Under the **46 GB** floor. `h3.capable` is false, so there is only one engine left to choose between and the switcher hides with its divider. A 48 GB-class Mac whose reduced-RAM Q8 DiT pack is not on disk **no longer lands here** — see the RAM bands below. |+| Engine switcher not visible at all | Under the **36 GB** floor. `h3.capable` is false, so there is only one engine left to choose between and the switcher hides with its divider. A 48 GB-class Mac whose reduced-RAM Q8 DiT pack is not on disk **no longer lands here** — see the RAM bands below. || H3 pill dashed, "not installed" | `h3.missing` lists exactly which component didn't resolve || Image mode snaps back to LTX | `h3.first_frame` false — the installed runner has no `--first-frame` || `ffmpeg not found on PATH` | the runner pipes raw RGB into `ffmpeg`; the panel prepends `FFMPEG_BIN` to the subprocess PATH, so this means the bundled binary is missing |diff --git a/docs/STATE.md b/docs/STATE.mdindex da995d1..6dae20d 100644--- a/docs/STATE.md+++ b/docs/STATE.md@@ -1,3 +1,5 @@+> **🩹 2026-09-24 — v4.15.3: Hailuo H3 on a 36-59 GB Mac, said plainly; public pinokio.js identity.** A Japanese user with a 48 GB Mac wrote on X: "Since it requires 64 GB, I couldn't even install it [H3] from the UI." Every GATE on 4.15.2 would have let that Mac install and render H3 (pinokio.js `H3_MIN_BYTES` 36e9, `h3_preflight.sh` 36e9, panel `H3_MIN_RAM_GB_Q8` 36, Q8 lane peak 25.63 GiB). Reproduced against 59d733d with a fake `sysctl` answering hw.memsize=51539607552 (48.0 GiB) on PATH, panel booted the Pinokio way: `/status.h3` = capable true, available false, needs_q8_dit true, reason not_installed — and **`size_note` = "~75 GB · needs 64 GB unified memory"**, a literal unchanged since v3.4.0 (0ef1a98) that every earlier 46→36 sweep missed. That line sits under the pitch on the H3 install card (engine switcher + the Settings card's "How to enable H3" + the Models row). Second half of the dead end: the card says "click Install Hailuo H3 in the Pinokio sidebar", and while the panel runs pinokio.js returns the Open Panel menu, which had **no H3 entry** — it existed only with the panel stopped. Third: the Settings card and `ram_note` told a Mac that never installed H3 "its low-RAM engine isn't built yet … no extra download". Fourth: a 36-59 GB Mac holding the weights but not the Q8 build was told to click "Install Hailuo H3", which pinokio.js hides once `h3_ready`. **Fixes:** `h3_size_note()` from the constants ("needs 36 GB+ … 60 GB+ also unlocks the full bf16 engine"); `h3_ram_verdict()` splits the band by `h3_paths()` the same way pinokio.js picks its one H3 entry (nothing complete → Install, weights_ok but venv/runner missing → Repair, all present but no Q8 pack → Build; all keep "on its reduced-RAM lane" so `_analytics_refusal_reason` still says h3_ram); `H3_INSTALL_MENU_TEXT` / `H3_REPAIR_MENU_TEXT` / `H3_BUILD_MENU_TEXT` quoted verbatim by pinokio.js; pinokio.js `h3Offer()` puts Install/Repair/"Build Hailuo H3 compact engine (weights kept — no re-download)" in the running AND stopped menus (build entry = h3_ready && no h3-dit-q8 pack && totalmem < 60e9); install card adds "This Mac runs it." on the q8 lane and says the entry is there while the panel runs; Settings card is an offer (download icon, no warn) unless reason is missing_q8_dit; repair card uses ram_note when missing_q8_dit (its missing-list is empty). `h3_build_q8.sh` now waits (30 s polls, 60 min cap, fail-open) while `state/panel_queue.json` has a `current` job and a panel process exists, before the quantizer and before the fresh-process `load_dit` validation — both load the whole ~20 GB Q8 DiT, and the install is now reachable mid-session (residual: a render started DURING the ~1-2 min validation is not blocked). One Codex pass (codex-cli 0.155.1, read-only): 2×P2 — the build sentence could name a Build entry the menu doesn't show when the venv/runner is broken (fixed: menu-aligned sentences + test), and install-while-rendering could stack ~20 GB on a render (fixed: the wait above). Docs: README memory row, H3_ENGINE.md bands 46→36, troubleshooting #h3-compact, preflight "LTX-2.3" → "LTX". **BETA identity:** public pinokio.js carried `title: "Phosphene BETA"` + "[BETA — unreleased builds … port 8199]" since **v4.8.2 (4e1dde6, 2026-09-01)** — the beta checkout's local edit got committed to dev and rode every promote. On Pinokio 8.2.0 users did NOT see it in the sidebar: `kernel/api meta()` and the server's folder view overlay pinokio.json's title/description (Object.assign(pinokio.js, pinokio_meta.json, pinokio.json)), and public pinokio.json says "Phosphene"; it was latent text (app search index, raw file, any Pinokio without the overlay). Restored "Phosphene" / "[MAC ONLY] …". The beta install's sidebar name comes from its own skip-worktree **pinokio.json** ("Phosphene BETA"), which nothing upstream touches. **Beta checkout note:** phosphene-dev.git has pinokio.js skip-worktree; ANY upstream pinokio.js change aborts a pull there ("Please commit your changes or stash them") — already true for the pending 3-commit ff (4.15.2 changed pinokio.js). Its working pinokio.js holds nothing local any more, so at the next panel restart: `git update-index --no-skip-worktree pinokio.js && git checkout -- pinokio.js && git merge --ff-only beta/main` (leave pinokio.json and start.js skip-worktree). New test `test_h3_48gb_install_path.py` (16: panel sentences at 48 GiB both ways, verbatim menu strings, node-evaluated pinokio.js menus on a fake installed root at 32/48/64 GB running and stopped, public identity, preflight at 48 GB via fake sysctl). Fleet read (PostHog, since 09-22): 94/132 active installs on 4.15.2, failure rate 7.8%; 48 GB is not blocked in data — H3 on 24/60 active 48 GB installs, 203 H3 renders / 1 failure; the reporter is a pre-install drop-off analytics cannot see. Open from fleet: new-install "engine venv has a Python but no packages" rose 1.8% → 7.5% (5/67; two M5 Max 128 GB never recovered) — cause not reproduced; oversized a2v on 8 GB not refused (Metal watchdog). Issues: 7 open, none an in-reach bug (#62 retrain still owed; #61/#78/#48 await reporters; #24/#63/#83 features). UI is English-only; the reporter is Japanese — noted, no i18n built.+# Phosphene — project state, history, open work> **🎤 2026-09-22 — v4.15.2: lip-sync on LTX audio-to-video follows the audio again.** The owner saw the improved lip-sync on the study's shot and ordered it shipped, because LTX lip-sync was not good. The order covered the lip-sync fix and nothing else from dev.diff --git a/mlx_ltx_panel.py b/mlx_ltx_panel.pyindex ddf4a94..bacf3b3 100644--- a/mlx_ltx_panel.py+++ b/mlx_ltx_panel.py@@ -10538,6 +10538,28 @@ def h3_capable() -> bool:return SYSTEM_RAM_GB >= H3_MIN_RAM_GB_Q8 and _h3_q8_dit_dir() is not None+# The Pinokio sidebar entry's exact text. pinokio.js carries the same string+# ("the panel's install card quotes this string verbatim -- change both"), and+# test_h3_48gb_install_path.py holds the two files to it.+H3_INSTALL_MENU_TEXT = "Install Hailuo H3 (second video engine, ~75 GB)"+# The entry a 36-59 GB Mac sees when the weights are on disk and only the local+# Q8 build is missing. The message used to say "Run 'Install Hailuo H3'" there,+# an entry pinokio.js never shows once the pack is complete.+H3_BUILD_MENU_TEXT = "Build Hailuo H3 compact engine (weights kept — no re-download)"+H3_REPAIR_MENU_TEXT = "Repair Hailuo H3 (weights kept — no re-download)"+++def h3_size_note() -> str:+ """The one line under every H3 install offer: download size, the memory+ floor, the licence. Its floor read a literal sixty-four from+ v3.4.0 to v4.15.2 — a floor no code ever gated on — and it sat right under+ the install card's pitch, so a 48 GB owner read it as the verdict and gave+ up (X, 2026-09-24). The floors come from the constants the gates use."""+ return (f"~75 GB · needs {H3_MIN_RAM_GB_Q8:.0f} GB+ unified memory "+ f"(compact Q8 engine; {H3_MIN_RAM_GB:.0f} GB+ also unlocks the full "+ f"bf16 engine) · MiniMax Community License (territory restrictions apply)")++def h3_ram_verdict() -> dict:"""What this Mac's memory says about H3 — and, when it says no, WHY andWHAT TO DO. Three bands, and only one of them is a dead end.@@ -10546,7 +10568,7 @@ def h3_ram_verdict() -> dict:a number the product stopped believing on two separate occasions: thebf16 floor is `H3_MIN_RAM_GB` = 60 (a 64 GB Mac reports ~63.x afterfirmware reservations), and the Q8 DiT lane's floor is- `H3_MIN_RAM_GB_Q8` = 46 — the whole point of building that pack was to+ `H3_MIN_RAM_GB_Q8` = 36 (46 until 2026-08-29) — the whole point of building that pack was to"put H3 in reach of 48 GB Macs". So a 48 GB Mac, which CAN render H3, wastold it needed 64 GB. That is not a slightly-off number; it is the kindof wrong that makes somebody give up on a feature their hardware runs,@@ -10559,11 +10581,18 @@ def h3_ram_verdict() -> dict:Bands:* >= 60 GB → lane "bf16", not blocked.- * >= 46 GB, Q8 DiT pack present → lane "q8", not blocked.- * >= 46 GB, no Q8 DiT pack → lane "q8", blocked, `needs_q8_dit`.+ * >= 36 GB, Q8 DiT pack present → lane "q8", not blocked.+ * >= 36 GB, no Q8 DiT pack → lane "q8", blocked, `needs_q8_dit`.NOT a hardware verdict — a missing local build with a named step.- * < 46 GB → lane None, blocked for real. State- 46, the real floor, not 64.+ Three sentences, one per pinokio.js menu state: a Mac that never+ (fully) installed H3 is told to INSTALL it (a real download, the Q8+ build is the install's last step); weights present but venv/runner+ broken -> REPAIR; everything present but the Q8 pack -> BUILD,+ minutes, downloads nothing.+ 4.15.2 said "no extra download" to both, beside a size note that+ claimed a sixty-four floor (X report 2026-09-24, a 48 GB owner who gave up).+ * < 36 GB → lane None, blocked for real. State+ 36, the real floor, not 64.The peaks behind the floors are per-tier, not per-render: measured on thestaged loader at 243 frames / 10.125 s the Q8 DiT peaks at 32.6 GB and@@ -10579,6 +10608,40 @@ def h3_ram_verdict() -> dict:if _h3_q8_dit_dir() is not None:return {"lane": "q8", "blocked": False, "needs_q8_dit": False,"floor_gb": H3_MIN_RAM_GB_Q8, "message": ""}+ # THE SENTENCE FOLLOWS THE MENU. pinokio.js shows exactly one H3 entry+ # per state, from the same manifest (required_files.json ->+ # capabilities.h3): everything present -> Build; every weight present+ # but venv/runner broken -> Repair; anything else -> Install, which+ # resumes and skips what is on disk. Naming any other entry sends the+ # user to a button that is not there.+ _p = h3_paths()+ if _p["missing"] and _p["weights_ok"]:+ return {+ "lane": "q8", "blocked": True, "needs_q8_dit": True,+ "floor_gb": H3_MIN_RAM_GB_Q8,+ "message": (+ f"Hailuo H3 runs on this Mac — on its reduced-RAM lane, "+ f"the compact Q8 engine, which needs "+ f"{H3_MIN_RAM_GB_Q8:.0f} GB ({ram}). Its weights are on "+ f"disk but the engine needs repair: in Pinokio, open "+ f"Phosphene in the sidebar and click "+ f"'{H3_REPAIR_MENU_TEXT}'. That also builds the compact "+ f"engine (about 5 minutes). Render on LTX until then."),+ }+ if _p["missing"]:+ return {+ "lane": "q8", "blocked": True, "needs_q8_dit": True,+ "floor_gb": H3_MIN_RAM_GB_Q8,+ "message": (+ f"Hailuo H3 runs on this Mac — on its reduced-RAM lane, "+ f"the compact Q8 engine, which needs "+ f"{H3_MIN_RAM_GB_Q8:.0f} GB ({ram}). It is not installed "+ f"yet: in Pinokio, open Phosphene in the sidebar and click "+ f"'{H3_INSTALL_MENU_TEXT}'. The install downloads what "+ f"is missing of ~75 GB and builds the compact engine at "+ f"the end (about 5 more minutes). Render on LTX until "+ f"then."),+ }return {"lane": "q8", "blocked": True, "needs_q8_dit": True,"floor_gb": H3_MIN_RAM_GB_Q8,@@ -10587,10 +10650,10 @@ def h3_ram_verdict() -> dict:f"bf16 engine needs {H3_MIN_RAM_GB:.0f} GB and "f"{ram}, but the Q8 engine's floor is "f"{H3_MIN_RAM_GB_Q8:.0f} GB and it is not built here yet. "- f"Run 'Install Hailuo H3' from the Phosphene sidebar in "- f"Pinokio — it builds that engine locally (~5 minutes, "- f"~22 GB on disk, no extra download) and skips everything "- f"already present. Render on LTX until then."),+ f"In Pinokio, open Phosphene in the sidebar and click "+ f"'{H3_BUILD_MENU_TEXT}' — it builds that engine locally "+ f"(~5 minutes, ~22 GB on disk, no extra download) and skips "+ f"everything already present. Render on LTX until then."),}return {"lane": None, "blocked": True, "needs_q8_dit": False,@@ -12939,8 +13002,7 @@ def h3_status() -> dict:"upscale_modes": list(H3_UPSCALE_MODES),"default_upscale": H3_UPSCALE_DEFAULT,"modes": list(H3_MODES),- "size_note": "~75 GB · needs 64 GB unified memory · "- "MiniMax Community License (territory restrictions apply)",+ "size_note": h3_size_note(),}diff --git a/pinokio.js b/pinokio.jsindex 1398356..0e18995 100644--- a/pinokio.js+++ b/pinokio.js@@ -32,6 +32,9 @@ const path = require("path")// the preflight's behind, so a 36-48 GB Mac was told by the panel that H3 runs// and by this menu that H3 does not exist. One number, three files.const H3_MIN_BYTES = 36 * 1000 * 1000 * 1000+// The full bf16 engine's floor (H3_MIN_RAM_GB = 60 in the panel). Below it the+// compact Q8 engine is the only lane that renders, so its build is REQUIRED.+const H3_BF16_BYTES = 60 * 1000 * 1000 * 1000function h3Capable() {try {@@ -120,12 +123,21 @@ function repoComplete(installRoot, repo, minBytes) {module.exports = {version: "7.0",- title: "Phosphene BETA",+ // PUBLIC IDENTITY. From v4.8.2 to v4.15.2 this said "Phosphene BETA" and+ // "[BETA — unreleased builds, runs alongside the stable install on port+ // 8199]": the private beta checkout's local edit got committed and rode+ // every promote since. Pinokio 8.2.0 overlays pinokio.json's title and+ // description on top of these (kernel/api meta(), Object.assign order), so+ // the sidebar read "Phosphene" — but the text shipped to every user, indexed+ // by Pinokio's app search and shown by any build without that overlay. The+ // beta install names itself in its own local pinokio.json (skip-worktree);+ // nothing beta-only belongs in this file.+ title: "Phosphene",// The Pinokio store listing. It still said "via LTX 2.3 (MLX)" three weeks after 2.5// became the generation a fresh install renders with — the first sentence a prospective// user reads, naming the wrong engine, while a confused existing user hunting a "why// does it keep asking for LTX 2.3" answer finds it confirming their suspicion.- description: "[BETA — unreleased builds, runs alongside the stable install on port 8199] Local generative video panel for Apple Silicon. Joint audio+video via LTX-2.5 (MLX), with Hailuo H3 as a second engine. T2V, I2V, FFLF, Extend, trained characters. Lossless h264. Hardware-tier feature gating. Free, open source.",+ description: "[MAC ONLY] Local generative video panel for Apple Silicon. Joint audio+video via LTX-2.5 (MLX), with Hailuo H3 as a second engine. T2V, I2V, FFLF, Extend, trained characters. Lossless h264. Hardware-tier feature gating. Free, open source.",icon: "icon.png",menu: async (kernel, info) => {// Resolve the install root. cocktailpeanut diagnosed that `info.path` is@@ -306,6 +318,49 @@ module.exports = {// "install ~75 GB" when they already have the 75 GB is the thing that// made this look like data loss.const h3_repair = h3_weights && !h3_ready+ // The compact Q8 engine, built locally at the end of install_h3.js. A 36-59+ // GB Mac cannot render H3 without it (the panel's h3_capable()), and once+ // the weights are complete `h3_ready` is true — so the only entry left was+ // "Update Hailuo H3 runner", while the panel told the user to click an+ // "Install Hailuo H3" that was no longer there. Same markers as the panel's+ // _h3_q8_dit_dir(): config + quant recipe + at least one shard.+ const h3_q8 = (capH3.model_roots || []).some(root => {+ try {+ const dir = h3Path(root + "/h3-dit-q8")+ return fs.existsSync(path.join(dir, "config.json"))+ && fs.existsSync(path.join(dir, "quant_config.json"))+ && fs.readdirSync(dir).some(n => /^model-.*\.safetensors$/.test(n))+ } catch (e) { return false }+ })+ let h3_small = false+ try { h3_small = os.totalmem() < H3_BF16_BYTES } catch (e) {}+ const h3_needs_build = h3_ready && !h3_q8 && h3_small && h3Capable()+ // The ONE H3 offer for a machine that cannot render H3 yet, in every menu+ // state that has a Start or an Open Panel. It used to exist only in the+ // stopped-panel menu, while the panel's install card (the thing a user reads+ // WHILE the panel runs) sends them to it: a 48 GB owner on X, 2026-09-24,+ // "couldn't even install it from the UI". install_h3.js touches only+ // minimax-h3-mlx/ and mlx_models/hailuo-h3/, its Q8 build streams one tensor+ // at a time on the CPU, and the panel picks the engine up on its next+ // /status tick — safe beside a running panel, like the music install.+ const h3Offer = () => {+ if (!h3Capable()) return []+ if (!h3_ready) {+ return [h3_repair+ // Quoted verbatim by the panel (H3_REPAIR_MENU_TEXT) -- change both.+ ? { icon: "fa-solid fa-screwdriver-wrench", text: "Repair Hailuo H3 (weights kept — no re-download)", href: "install_h3.js" }+ // ENGINES ARE PEERS: "optional" told a user that half the panel's+ // video capability was a side dish. The entry names what it IS.+ // The panel's install card quotes this string verbatim -- change both+ // (H3_INSTALL_MENU_TEXT in mlx_ltx_panel.py).+ : { icon: "fa-solid fa-comments", text: "Install Hailuo H3 (second video engine, ~75 GB)", href: "install_h3.js" }]+ }+ if (h3_needs_build) {+ // Quoted verbatim by the panel (H3_BUILD_MENU_TEXT) -- change both.+ return [{ icon: "fa-solid fa-screwdriver-wrench", text: "Build Hailuo H3 compact engine (weights kept — no re-download)", href: "install_h3.js" }]+ }+ return []+ }const musicRoot = underRoot(envFile.LTX_MUSIC_ROOT || "yue2-mlx", "")const musicModels = underRoot(envFile.LTX_MUSIC_MODELS || "mlx_models/yue2", "")@@ -538,9 +593,11 @@ module.exports = {// has to exist while the panel runs. The install touches only// yue2-mlx/ and mlx_models/yue2/; the panel picks it up on /status....musicMenu(),+ // Same reasoning for H3: the panel's install card points here.+ ...h3Offer(),]}- return [{ default: true, icon: "fa-solid fa-terminal", text: "Terminal", href: "start.js" }, ...musicMenu()]+ return [{ default: true, icon: "fa-solid fa-terminal", text: "Terminal", href: "start.js" }, ...musicMenu(), ...h3Offer()]}// Healthy install — Start path.@@ -574,17 +631,13 @@ module.exports = {baseMenu.push({ icon: "fa-solid fa-images", text: "Reinstall image engines (Ideogram 4 + Qwen-Edit)", href: "install_qwen.js" })}baseMenu.push(...musicMenu())- if (!h3_ready && h3Capable()) {- // Second VIDEO engine — joint picture + dialogue + sound. Opt-in only:- // ~75 GB, 36 GB+ Macs (H3_MIN_BYTES above), MiniMax Community License- // with territory restrictions. Hidden entirely on machines that can't- // run it, so it never reads as a missing piece of the base install.- baseMenu.push(h3_repair- ? { icon: "fa-solid fa-screwdriver-wrench", text: "Repair Hailuo H3 (weights kept — no re-download)", href: "install_h3.js" }- // ENGINES ARE PEERS: "optional" told a user that half the panel's- // video capability was a side dish. The entry names what it IS.- // The panel's install card quotes this string verbatim -- change both.- : { icon: "fa-solid fa-comments", text: "Install Hailuo H3 (second video engine, ~75 GB)", href: "install_h3.js" })+ // Second VIDEO engine — joint picture + dialogue + sound. Opt-in only:+ // ~75 GB, 36 GB+ Macs (H3_MIN_BYTES above), MiniMax Community License+ // with territory restrictions. Hidden entirely on machines that can't+ // run it, so it never reads as a missing piece of the base install.+ const h3Entry = h3Offer()+ if (h3Entry.length) {+ baseMenu.push(...h3Entry)} else if (h3_ready) {// THE DOOR MUST NOT CLOSE BEHIND THE INSTALL. The panel's live-preview// note tells users with an older H3 runner to update it "from thediff --git a/scripts/pinokio/h3_build_q8.sh b/scripts/pinokio/h3_build_q8.shindex a1d4019..c053ff5 100644--- a/scripts/pinokio/h3_build_q8.sh+++ b/scripts/pinokio/h3_build_q8.sh@@ -121,6 +121,40 @@ load_dit(sys.argv[1], verbose=False)print(f"LOAD OK - pack valid ({time.time() - t0:.1f}s)", flush=True)PY}+# DON'T LOAD ~20 GB ON TOP OF A RENDER. Since 4.15.3 the sidebar offers this+# install while the panel runs (the panel's own install card sends people there+# mid-session). The quantizer streams one tensor at a time on the CPU, but its+# closing check and validate_pack_fresh() load the whole Q8 DiT, and on a 36-59+# GB Mac that plus an LTX render can end in a jetsam kill of either. So wait+# while the panel's persisted queue says a job is running. FAIL-OPEN: no queue+# file, no panel process, or an unreadable file means "idle"; 60 min cap.+STATE_DIR="${LTX_STATE_DIR:-$APP_ROOT/state}"+panel_rendering() {+ [ -f "$STATE_DIR/panel_queue.json" ] || return 1+ pgrep -f mlx_ltx_panel.py > /dev/null 2>&1 || return 1+ .venv/bin/python - "$STATE_DIR/panel_queue.json" <<'PY'+import json, sys+try:+ sys.exit(0 if json.load(open(sys.argv[1])).get("current") else 1)+except Exception:+ sys.exit(1)+PY+}+wait_for_idle_panel() {+ WAITED=0+ while panel_rendering; do+ if [ "$WAITED" -eq 0 ]; then+ echo 'A Phosphene render is running. Waiting for it to finish before'+ echo 'loading the compact engine (it needs ~20 GB of memory briefly).'+ fi+ WAITED=$((WAITED + 1))+ if [ "$WAITED" -ge 120 ]; then+ echo 'Still rendering after 60 minutes - continuing anyway.'+ break+ fi+ sleep 30+ done+}if [ -f "$PACK/.built_ok" ] && pack_shards_present; thenecho 'Q8 engine already built - skipping'else@@ -129,9 +163,11 @@ elseelseecho '=== Building the reduced-RAM Q8 engine (~5 min, one time) ==='rm -f "$PACK/.built_ok"+ wait_for_idle_panel.venv/bin/python scripts/quantize_stream.py --src "$SRC" --out "$PACK"echo "quantizer exit $? (a kill during its own final validation is recovered below)"fi+ wait_for_idle_panelif pack_shards_present && validate_pack_fresh; then: > "$PACK/.built_ok"echo 'Q8 engine built and validated'diff --git a/scripts/pinokio/h3_preflight.sh b/scripts/pinokio/h3_preflight.shindex 11ee1de..4246b5f 100644--- a/scripts/pinokio/h3_preflight.sh+++ b/scripts/pinokio/h3_preflight.sh@@ -32,7 +32,7 @@ if echo "$MEM_BYTES" | grep -qE '^[0-9]+$' && [ "$MEM_BYTES" -lt 36000000000 ];echo "HAILUO H3 NEEDS AT LEAST A 36 GB MAC (this Mac has ${MEM_GB} GB)"echo 'Even the reduced-RAM Q8 engine peaks around 25.6 GiB while rendering;'echo 'below 36 GB it swaps and a 3-second clip takes hours.'- echo 'Nothing was downloaded. Keep using the built-in LTX-2.3 engine.'+ echo 'Nothing was downloaded. Keep using the built-in LTX engine.'echo '=================================================================='exit 1elif [ "$MEM_BYTES" -lt 60000000000 ]; thendiff --git a/test_h3_48gb_install_path.py b/test_h3_48gb_install_path.pynew file mode 100644index 0000000..6a68eb6--- /dev/null+++ b/test_h3_48gb_install_path.py@@ -0,0 +1,262 @@+"""A 48 GB Mac can install and run Hailuo H3 — and every surface says so.++THE REPORT (X, 2026-09-24). A user bought a Mac for Phosphene, a 48 GB one,+and wrote: "Since it requires 64 GB, I couldn't even install it [H3] from the+UI." Every gate on public v4.15.2 would have let that Mac install and render+H3 (pinokio.js 36e9, the preflight 36e9, the panel's Q8 floor 36). What+stopped them was text and a missing button:++ 1. `size_note` — the line under the H3 install card and the Models row —+ said "~75 GB · needs 64 GB unified memory" from v3.4.0 to v4.15.2. No+ gate in the codebase was ever 64. Every OTHER sentence had been moved to+ the real floors; this one was a literal nobody grepped.+ 2. The install card says "open the Phosphene entry in the Pinokio sidebar+ and click Install Hailuo H3". While the panel runs — which is when anyone+ reads that card — pinokio.js returned the Open Panel menu, which had no+ H3 entry at all. The button existed only with the panel stopped.+ 3. The Settings card and the switcher note for this band said "no extra+ download" and "isn't built yet" to a Mac that had never installed H3.+ 4. A Mac that HAD the weights but not the local Q8 build was told to click+ "Install Hailuo H3" — an entry pinokio.js hides once the pack is complete.++Every assertion below is keyed to one of those.+"""+from __future__ import annotations++import json+import os+import shutil+import subprocess+import sys+import tempfile+import unittest+from pathlib import Path++ROOT = Path(__file__).resolve().parent+STATE = Path(tempfile.mkdtemp(prefix="phos-48gb-"))+os.environ["LTX_STATE_DIR"] = str(STATE)+os.environ["PHOSPHENE_ANALYTICS_DISABLED"] = "1"+os.environ["PHOSPHENE_DISABLE_VERSION_CHECK"] = "1"+sys.path.insert(0, str(ROOT))++import mlx_ltx_panel as P # noqa: E402++GIB48 = 51539607552 # hw.memsize / os.totalmem() of a 48 GB Mac+GIB32 = 34359738368+GIB64 = 68719476736+PANEL_JS = "\n".join(p.read_text() for p in sorted((ROOT / "webapp/js").glob("*.js")))+PINOKIO_JS = (ROOT / "pinokio.js").read_text()+++class TestPanelTellsA48GBMacTheTruth(unittest.TestCase):+ def setUp(self):+ P.h3_status_invalidate()+ self.saved = (P.SYSTEM_RAM_GB, P._h3_q8_dit_dir, P.h3_paths)+ P.SYSTEM_RAM_GB = GIB48 / 1024 ** 3+ P._h3_q8_dit_dir = lambda: None++ def tearDown(self):+ P.SYSTEM_RAM_GB, P._h3_q8_dit_dir, P.h3_paths = self.saved+ P.h3_status_invalidate()++ def test_size_note_states_the_real_floor(self):+ note = P.h3_status()["size_note"]+ self.assertNotIn("64", note)+ self.assertIn(f"{P.H3_MIN_RAM_GB_Q8:.0f} GB+", note)+ self.assertIn(f"{P.H3_MIN_RAM_GB:.0f} GB+", note)+ self.assertNotIn("needs 64 GB unified memory", (ROOT / "mlx_ltx_panel.py").read_text())++ def _paths(self, missing, weights_ok):+ real = self.saved[2]+ def fake():+ d = dict(real())+ d.update(missing=list(missing), weights_ok=weights_ok)+ return d+ P.h3_paths = fake++ def test_never_installed_is_an_install_offer_not_a_build_step(self):+ self._paths(["runner x", "pruned bf16 DiT"], weights_ok=False)+ s = P.h3_status()+ self.assertTrue(s["capable"], "the switcher must still draw the offer")+ self.assertFalse(s["available"])+ self.assertEqual(s["ram_lane"], "q8")+ note = s["ram_note"]+ self.assertIn(P.H3_INSTALL_MENU_TEXT, note)+ self.assertIn("~75 GB", note)+ self.assertNotIn("no extra download", note)+ self.assertNotIn("64", note)+ # The refusal series must not fall back into `other`.+ self.assertEqual(P._analytics_refusal_reason(note), "h3_ram")++ def test_weights_on_disk_names_the_build_entry_that_exists(self):+ self._paths([], weights_ok=True)+ note = P.h3_ram_verdict()["message"]+ self.assertIn(P.H3_BUILD_MENU_TEXT, note)+ self.assertIn("no extra download", note)+ self.assertNotIn(P.H3_INSTALL_MENU_TEXT, note)+ self.assertEqual(P._analytics_refusal_reason(note), "h3_ram")++ def test_weights_on_disk_but_broken_engine_names_repair(self):+ # Codex review 4.15.3: the build sentence named an entry pinokio.js+ # does not show when h3_ready is false. The sentence follows the menu.+ self._paths(["venv python under /x/.venv"], weights_ok=True)+ note = P.h3_ram_verdict()["message"]+ self.assertIn(P.H3_REPAIR_MENU_TEXT, note)+ self.assertNotIn(P.H3_BUILD_MENU_TEXT, note)+ self.assertEqual(P._analytics_refusal_reason(note), "h3_ram")++ def test_the_panel_quotes_the_sidebar_verbatim(self):+ self.assertIn(f'text: "{P.H3_INSTALL_MENU_TEXT}"', PINOKIO_JS)+ self.assertIn(f'text: "{P.H3_BUILD_MENU_TEXT}"', PINOKIO_JS)+ self.assertIn(f'text: "{P.H3_REPAIR_MENU_TEXT}"', PINOKIO_JS)+ self.assertIn(P.H3_INSTALL_MENU_TEXT, PANEL_JS)++ def test_settings_card_splits_the_band(self):+ branch = PANEL_JS.split("if (h3s.needs_q8_dit) {")[1][:1600]+ self.assertIn("h3s.reason === 'missing_q8_dit'", branch)+ self.assertIn("How to install H3", branch)++ def test_install_card_says_this_mac_runs_it_and_where_the_button_is(self):+ self.assertIn("H3.ram_lane === 'q8'", PANEL_JS)+ self.assertIn("while the panel is running", PANEL_JS)+++def _menu(root: Path, totalmem: int, running: bool) -> list[str]:+ probe = (+ "const os=require('os');os.totalmem=()=>Number(process.argv[2]);"+ "const path=require('path'),fs=require('fs');const root=process.argv[1];"+ "const running=process.argv[3]==='1';"+ "const mod=require(path.join(root,'pinokio.js'));"+ "const info={path:(...a)=>path.join(root,...a),exists:p=>fs.existsSync(path.join(root,p)),"+ "running:s=>running&&s==='start.js',local:s=>s==='start.js'?{url:'http://127.0.0.1:1'}:{}};"+ "mod.menu({},info).then(m=>console.log(JSON.stringify(m.map(i=>i.text))))"+ )+ out = subprocess.run(["node", "-e", probe, str(root), str(totalmem), "1" if running else "0"],+ capture_output=True, text=True, errors="replace", timeout=30)+ if out.returncode != 0:+ raise AssertionError(out.stderr[-800:])+ return json.loads(out.stdout)++[email protected](shutil.which("node"), "node not on PATH")+class TestSidebarOffersH3WhereTheCardSaysItIs(unittest.TestCase):+ """A fake INSTALLED app root: base models present, H3 in three states."""++ def setUp(self):+ self.root = Path(tempfile.mkdtemp(prefix="phos-menu-"))+ shutil.copy(ROOT / "pinokio.js", self.root / "pinokio.js")+ shutil.copy(ROOT / "required_files.json", self.root / "required_files.json")+ req = json.loads((ROOT / "required_files.json").read_text())+ minb = req.get("min_size_bytes", 1024)++ def touch(rel, size=minb):+ p = self.root / rel+ p.parent.mkdir(parents=True, exist_ok=True)+ with open(p, "wb") as f:+ f.truncate(size)++ touch("ltx-2-mlx/env/pyvenv.cfg", 10)+ touch("ltx-2-mlx/env/bin/python3.11", 10)+ (self.root / "ltx-2-mlx/env/lib/python3.11/site-packages/ltx_pipelines_mlx").mkdir(parents=True)+ render = req["capabilities"]["render"]+ for key in render["repos_by_version"][render["default_version"]]:+ repo = next(r for r in req["repos"] if r["key"] == key)+ for f in repo.get("files", []):+ touch(f"{repo['local_dir']}/{f}")+ self.touch = touch+ self.h3 = req["capabilities"]["h3"]++ def tearDown(self):+ shutil.rmtree(self.root, ignore_errors=True)++ def _install_h3(self, q8: bool):+ self.touch(self.h3["paths"][0], 10)+ self.touch(self.h3["venv_any"][0], 10)+ root = "mlx_models/hailuo-h3"+ for rel in self.h3["models"]:+ self.touch(f"{root}/{rel}", 10)+ if q8:+ for n in ("config.json", "quant_config.json", "model-00001-of-00002.safetensors"):+ self.touch(f"{root}/h3-dit-q8/{n}", 10)++ def test_48gb_fresh_install_is_offered_with_the_panel_running(self):+ items = _menu(self.root, GIB48, running=True)+ self.assertIn("Open Panel", items)+ self.assertIn(P.H3_INSTALL_MENU_TEXT, items)++ def test_48gb_fresh_install_is_offered_with_the_panel_stopped(self):+ items = _menu(self.root, GIB48, running=False)+ self.assertIn("Start", items)+ self.assertIn(P.H3_INSTALL_MENU_TEXT, items)++ def test_48gb_weights_without_q8_build_gets_the_build_entry(self):+ self._install_h3(q8=False)+ for running in (True, False):+ items = _menu(self.root, GIB48, running=running)+ self.assertIn(P.H3_BUILD_MENU_TEXT, items, running)+ self.assertNotIn(P.H3_INSTALL_MENU_TEXT, items)++ def test_48gb_complete_install_has_nothing_to_offer_while_running(self):+ self._install_h3(q8=True)+ running = _menu(self.root, GIB48, running=True)+ self.assertFalse([t for t in running if "Hailuo" in t], running)+ stopped = _menu(self.root, GIB48, running=False)+ self.assertIn("Update Hailuo H3 runner (weights kept — no re-download)", stopped)++ def test_64gb_without_q8_is_not_told_to_build(self):+ # bf16 fits there; the runner-update entry (which also builds Q8) stays.+ self._install_h3(q8=False)+ items = _menu(self.root, GIB64, running=False)+ self.assertNotIn(P.H3_BUILD_MENU_TEXT, items)+ self.assertIn("Update Hailuo H3 runner (weights kept — no re-download)", items)++ def test_32gb_is_never_offered_h3(self):+ for running in (True, False):+ items = _menu(self.root, GIB32, running=running)+ self.assertFalse([t for t in items if "Hailuo" in t], items)+++class TestPublicIdentity(unittest.TestCase):+ """v4.8.2 committed the beta checkout's local title into public main."""++ def test_title_and_description_are_the_public_ones(self):+ head = PINOKIO_JS.split("menu: async")[0]+ self.assertIn('title: "Phosphene",', head)+ self.assertNotIn('title: "Phosphene BETA"', head)+ desc = [l for l in head.splitlines() if l.strip().startswith("description:")]+ self.assertEqual(len(desc), 1)+ self.assertNotIn("BETA", desc[0])+ self.assertNotIn("8199", desc[0])+ self.assertEqual(json.loads((ROOT / "pinokio.json").read_text())["title"], "Phosphene")+++class TestQ8BuildWaitsForARunningRender(unittest.TestCase):+ """The sidebar now offers the install while the panel runs, and the Q8+ build's closing checks load the whole ~20 GB DiT (Codex review, 4.15.3)."""++ def test_both_whole_model_loads_wait_for_an_idle_panel(self):+ src = (ROOT / "scripts/pinokio/h3_build_q8.sh").read_text()+ self.assertIn('"$STATE_DIR/panel_queue.json"', src)+ q = src.index('.venv/bin/python scripts/quantize_stream.py')+ v = src.index('if pack_shards_present && validate_pack_fresh; then')+ self.assertLess(src.rindex('wait_for_idle_panel', 0, q), q)+ self.assertLess(src.rindex('wait_for_idle_panel', 0, v), v)+ self.assertIn('-ge 120', src, "the wait is capped, never forever")+++class TestPreflightLetsA48GBMacThrough(unittest.TestCase):+ def test_preflight_at_48gb(self):+ d = Path(tempfile.mkdtemp(prefix="phos-sysctl-"))+ (d / "sysctl").write_text(f"#!/bin/sh\necho {GIB48}\n")+ (d / "sysctl").chmod(0o755)+ out = subprocess.run(["bash", str(ROOT / "scripts/pinokio/h3_preflight.sh")],+ capture_output=True, text=True, errors="replace", timeout=30,+ env={**os.environ, "PATH": f"{d}:{os.environ['PATH']}"})+ shutil.rmtree(d, ignore_errors=True)+ self.assertEqual(out.returncode, 0, out.stdout + out.stderr)+ self.assertIn("36-60 GB class", out.stdout)+ self.assertNotIn("LTX-2.3", (ROOT / "scripts/pinokio/h3_preflight.sh").read_text())+++if __name__ == "__main__":+ unittest.main()diff --git a/webapp/docs/troubleshooting.md b/webapp/docs/troubleshooting.mdindex a164e52..420069d 100644--- a/webapp/docs/troubleshooting.md+++ b/webapp/docs/troubleshooting.md@@ -12,9 +12,12 @@ The health chip in the header shows memory at a glance; click it for the **Tier*### Hailuo H3 on a 36–60 GB Mac {#h3-compact}-H3's full engine needs 60 GB. From 36 GB it runs on its compact Q8 engine, which has to be built once:+H3's full engine needs 60 GB. From 36 GB it runs on its compact Q8 engine, which is built on your Mac once:-> *"Hailuo H3 runs on this Mac — on its reduced-RAM lane … Run 'Install Hailuo H3' from the Phosphene sidebar in Pinokio — it builds that engine locally (~5 minutes, ~22 GB on disk, no extra download)."*+- **H3 not installed yet:** in Pinokio, open **Phosphene** in the sidebar and click **Install Hailuo H3 (second video engine, ~75 GB)**. The install builds the compact engine at the end by itself (about 5 more minutes).+- **H3 installed, compact engine missing** — *"Hailuo H3 runs on this Mac — on its reduced-RAM lane … it is not built here yet"*: click **Build Hailuo H3 compact engine** in the same sidebar (~5 minutes, no download).++Both entries are in the sidebar while the panel is running.Do that, then choose Settings → **Hailuo H3 model** → Automatic or Compact. Below 36 GB, H3 is not available: render on LTX, which serves every mode.diff --git a/webapp/js/queue.js b/webapp/js/queue.jsindex edc0786..da8aefe 100644--- a/webapp/js/queue.js+++ b/webapp/js/queue.js@@ -633,7 +633,13 @@ function openH3InstallCard(source) {const _missing = (H3.missing || []).map(String);const _missVenv = _missing.some(m => m.includes('venv'));const _missRunner = _missing.some(m => m.includes('runner') || m.includes('scripts/'));- const diagnosis = H3.venv_broken+ // The 36-59 GB Mac holding every weight but not the local Q8 build: its+ // missing-list is EMPTY, so every branch below printed "What broke: a+ // component the probe lists below" above a list that listed nothing. The+ // server's sentence names the build and the sidebar entry that runs it.+ const diagnosis = (H3.reason === 'missing_q8_dit' && H3.ram_note)+ ? escapeHtml(H3.ram_note)+ : H3.venv_broken? 'What broke: H3’s Python environment points at a moved or deleted '+ 'interpreter. Rebuilding the environment takes about two minutes.': _missVenv@@ -674,11 +680,17 @@ function openH3InstallCard(source) {<p style="margin:0 0 10px;color:var(--muted)">${escapeHtml(H3.size_note || '')}</p>+ ${H3.ram_lane === 'q8' ? `<p style="margin:0 0 10px">+ <b>This Mac runs it.</b> With ${escapeHtml(String(Math.round(H3.ram_gb || 0)))} GB+ of memory, H3 uses its compact Q8 engine, which the install builds by+ itself at the end (about 5 more minutes, nothing extra to download).+ </p>` : ''}<p style="margin:0 0 10px">Install it from Pinokio, not from here: open the <b>Phosphene</b> entryin the Pinokio sidebar and click- <b>“Install Hailuo H3 (second video engine, ~75 GB)”</b>. The panel- picks it up within a couple of seconds — no restart.+ <b>“Install Hailuo H3 (second video engine, ~75 GB)”</b>. It is there+ while the panel is running, too. The panel picks it up within a couple+ of seconds — no restart.</p>`;// THE DIAGNOSTIC DUMP GOES BEHIND A DISCLOSURE. `missing` is a list of raw// absolute paths — indispensable when an install half-lands, and purediff --git a/webapp/js/settings.js b/webapp/js/settings.jsindex 658ae99..d9f9f5b 100644--- a/webapp/js/settings.js+++ b/webapp/js/settings.js@@ -145,13 +145,24 @@ function updateModelsCard(s) {// existed this Mac was `capable: false` and got no card, no switcher// segment, and — if it ever reached a render — a refusal claiming it needed// 64 GB. The server owns the sentence; this only places it.+ //+ // Two different Macs share this band. `missing_q8_dit` holds all ~75 GB and+ // lacks only the local build: a warning, it installed H3 and cannot use it.+ // Anything else never installed H3 at all — an offer, not a fault, and "its+ // low-RAM engine isn't built yet" misread as "your Mac is not enough" beside+ // a size note that said 64 GB (X, 2026-09-24).if (h3s.needs_q8_dit) {+ const built = (h3s.reason === 'missing_q8_dit');card.style.display = '';- card.classList.add('state-warn');- icon.innerHTML = '<svg class="ph" aria-hidden="true"><use href="#ph-warning-fill"/></svg>';- title.textContent = 'Hailuo H3 runs on this Mac — its low-RAM engine isn’t built yet';+ if (built) card.classList.add('state-warn');+ icon.innerHTML = built+ ? '<svg class="ph" aria-hidden="true"><use href="#ph-warning-fill"/></svg>'+ : '<svg class="ph" aria-hidden="true"><use href="#ph-download-simple"/></svg>';+ title.textContent = built+ ? 'Hailuo H3 runs on this Mac — its low-RAM engine isn’t built yet'+ : 'Hailuo H3 runs on this Mac — on its compact Q8 engine';sub.textContent = h3s.ram_note || '';- actions.innerHTML = `<button onclick="openH3InstallCard()">How to enable H3</button>`;+ actions.innerHTML = `<button onclick="openH3InstallCard()">${built ? 'How to enable H3' : 'How to install H3'}</button>`;return;}if (h3s.capable && !h3s.available && h3s.repairable) {