diff --git a/.githooks/pre-commit b/.githooks/pre-commit
index 2086d92..d5041b5 100755
--- a/.githooks/pre-commit
+++ b/.githooks/pre-commit
@@ -118,6 +118,18 @@ touches_promptcaps=$(printf '%s\n' "$staged" | grep -E '(^|/)(index\.html|play\.
 # growth/ is gitignored, so these paths only appear here when someone force-adds them — which is when it matters.
 touches_launchfacts=$(printf '%s\n' "$staged" | grep -E '(^|/)(index\.html|README\.md|growth/(launch-checklist|show-hn-draft|product-hunt-draft|launch-alternativeto|2026-07-17-ecosystem-shares|shares)\.md|scripts/check-launch-facts\.mjs)$' || true)
 
+# index.html + play.html share 893 hand-maintained identical lines (identical after the leading and
+# trailing whitespace strip); the targeted twin checks (resize/pricing/combine/cost) only pin named
+# functions. This one pins the WHOLE overlap: a one-sided edit to any shared line fails, a 2-sided
+# DIVERGENT edit fails, and new duplication cannot enter silently.
+touches_twindrift=$(printf '%s\n' "$staged" | grep -E '(^|/)(index\.html|play\.html|scripts/check-twin-drift\.mjs|scripts/twin-drift-baseline\.json)$' || true)
+# The sandbox matrix behind that guard: 16 mutations of the 2 surfaces, each with the verdict the
+# guard must return — the 9 planned extractions of docs/twin-drift.md report 0 divergences (8 of them
+# are fully silent; row 8 keeps the 5 one-sided deletions it cannot avoid), and a 2-sided DIVERGENT
+# edit must still fail. It re-reads both surfaces, so it runs when the RULES move (the guard, the
+# baseline or the matrix), not on every index.html edit.
+touches_twindriftcases=$(printf '%s\n' "$staged" | grep -E '(^|/)(scripts/check-twin-drift\.mjs|scripts/check-twin-drift-cases\.mjs|scripts/twin-drift-baseline\.json)$' || true)
+
 # an imported (#a=) app's spend-capable bridge calls must be refused until a real Run gesture arms it (consent gate).
 touches_consent=$(printf '%s\n' "$staged" | grep -E '(^|/)(play\.html|scripts/check-bridge-consent\.mjs)$' || true)
 # play.html bakes creator sample results into #a= shares so keyless recipients see what the app makes;
@@ -130,7 +142,7 @@ touches_llmsfull=$(printf '%s\n' "$staged" | grep -E '(^|/)(llms-full\.txt|llms\
 # Nothing to check unless an .html file, one of the checkers, or a guarded doc changed.
 # Every touches_* variable belongs in this chain — a gate left out of it never runs on a
 # commit that stages only its own files, which is exactly the commit it exists to catch.
-[ -z "$staged_html" ] && [ -z "$touches_launchfacts" ] && [ -z "$touches_njseditor" ] && [ -z "$touches_llmgate" ] && [ -z "$touches_export" ] && [ -z "$touches_login" ] && [ -z "$touches_sw" ] && [ -z "$touches_compat" ] && [ -z "$touches_run" ] && [ -z "$touches_jsparity" ] && [ -z "$touches_seedcache" ] && [ -z "$touches_imgports" ] && [ -z "$touches_langpages" ] && [ -z "$touches_editorports" ] && [ -z "$touches_settings" ] && [ -z "$touches_quickadd" ] && [ -z "$touches_i18n" ] && [ -z "$touches_updates" ] && [ -z "$touches_createapp" ] && [ -z "$touches_stale" ] && [ -z "$touches_vresume" ] && [ -z "$touches_lipsync" ] && [ -z "$touches_aresume" ] && [ -z "$touches_share" ] && [ -z "$touches_pricing" ] && [ -z "$touches_combine" ] && [ -z "$touches_pacing" ] && [ -z "$touches_graphpersist" ] && [ -z "$touches_graphsigs" ] && [ -z "$touches_describeapply" ] && [ -z "$touches_authlc" ] && [ -z "$touches_mediapriv" ] && [ -z "$touches_verhist" ] && [ -z "$touches_rungating" ] && [ -z "$touches_appsstorage" ] && [ -z "$touches_linkerr" ] && [ -z "$touches_deploy" ] && [ -z "$touches_hiddencss" ] && [ -z "$touches_connect" ] && [ -z "$touches_undo" ] && [ -z "$touches_costaccrue" ] && [ -z "$touches_resize" ] && [ -z "$touches_catalog" ] && [ -z "$touches_upscale" ] && [ -z "$touches_drift" ] && [ -z "$touches_promptcaps" ] && [ -z "$touches_consent" ] && [ -z "$touches_sharesamples" ] && [ -z "$touches_llmsfull" ] && [ -z "$touches_examples" ] && exit 0
+[ -z "$staged_html" ] && [ -z "$touches_launchfacts" ] && [ -z "$touches_njseditor" ] && [ -z "$touches_llmgate" ] && [ -z "$touches_export" ] && [ -z "$touches_login" ] && [ -z "$touches_sw" ] && [ -z "$touches_compat" ] && [ -z "$touches_run" ] && [ -z "$touches_jsparity" ] && [ -z "$touches_seedcache" ] && [ -z "$touches_imgports" ] && [ -z "$touches_langpages" ] && [ -z "$touches_editorports" ] && [ -z "$touches_settings" ] && [ -z "$touches_quickadd" ] && [ -z "$touches_i18n" ] && [ -z "$touches_updates" ] && [ -z "$touches_createapp" ] && [ -z "$touches_stale" ] && [ -z "$touches_vresume" ] && [ -z "$touches_lipsync" ] && [ -z "$touches_aresume" ] && [ -z "$touches_share" ] && [ -z "$touches_pricing" ] && [ -z "$touches_combine" ] && [ -z "$touches_pacing" ] && [ -z "$touches_graphpersist" ] && [ -z "$touches_graphsigs" ] && [ -z "$touches_describeapply" ] && [ -z "$touches_authlc" ] && [ -z "$touches_mediapriv" ] && [ -z "$touches_verhist" ] && [ -z "$touches_rungating" ] && [ -z "$touches_appsstorage" ] && [ -z "$touches_linkerr" ] && [ -z "$touches_deploy" ] && [ -z "$touches_hiddencss" ] && [ -z "$touches_connect" ] && [ -z "$touches_undo" ] && [ -z "$touches_costaccrue" ] && [ -z "$touches_resize" ] && [ -z "$touches_catalog" ] && [ -z "$touches_upscale" ] && [ -z "$touches_drift" ] && [ -z "$touches_promptcaps" ] && [ -z "$touches_consent" ] && [ -z "$touches_sharesamples" ] && [ -z "$touches_llmsfull" ] && [ -z "$touches_examples" ] && [ -z "$touches_twindrift" ] && [ -z "$touches_twindriftcases" ] && exit 0
 if ! command -v node >/dev/null 2>&1; then
   echo "pre-commit: node not found, skipping HTML JS checks" >&2
   exit 0
@@ -516,3 +528,54 @@ fi
 if [ -n "$touches_llmsfull" ]; then
   node "$root/scripts/check-llms-full.mjs"
 fi
+
+# 43) TWIN DRIFT: index.html (editor) and play.html (app player + export) carry 893 hand-maintained
+#     identical lines — identical after a leading/trailing whitespace strip, because play.html nests
+#     the same code deeper; only 415 of the 893 are byte-identical in the files. The other twin
+#     checks each pin ONE named function; nothing compared the two files as wholes, so a one-sided
+#     edit anywhere else shipped silently. This guard pins the whole shared set against
+#     scripts/twin-drift-baseline.json. It FAILS on a line that leaves the set because one surface
+#     moved and the other did not, on a line deleted from one surface while still live on the other,
+#     on a line that loses a copy on one surface only (the baseline stores per-surface occurrence
+#     counts, because a line can appear twice in one file), and on a line that leaves BOTH surfaces
+#     while each surface keeps its own DIFFERENT replacement of it. The count is a ratchet —
+#     extraction may lower it freely, new duplication may not raise it silently. The ratchet number
+#     is DERIVED from the baseline line list, and the required digest pins the per-line counts and
+#     the stored text, so no hand edit of the baseline can lift it.
+#     What leaves the set without failing: a line gone from BOTH surfaces where at most ONE surface
+#     grew a NEW near-identical replacement. The baseline stores, per line, the hashes of the lines
+#     that ALREADY looked like it, because a "replacement" that was there first replaced nothing —
+#     without that memory the guard failed 4 of the 9 planned extractions in docs/twin-drift.md.
+#     Generated regions are excluded, so the library is never booked as hand duplication; the
+#     njs-engine block is found by its data-hash, NOT by a script-tag regex that play.html's own
+#     export-builder string literal can trigger. Offline. Timings vary by machine and by load, and
+#     the load matters more than the code: each range below is scoped to the load band it was
+#     measured in and says nothing outside it. On 2026-07-29, over 30 samples of each case on a
+#     shared 18-core machine with the load average between 3.19 and 5.68, a clean tree took 0.14s to
+#     0.18s. The worst case is a refactor that moves many twins at once: at the 200-departure
+#     classification ceiling it took 1.99s to 3.19s when every departure left both surfaces, and
+#     0.91s to 1.64s when they left one. Never a hang:
+#     201 departures reports totals instead. Each failure list NAMES its first 12 lines and counts
+#     the rest.
+#     Refresh deliberately:
+#       TWIN_DRIFT_UPDATE=1 node scripts/check-twin-drift.mjs
+#     Ranked extraction plan: docs/twin-drift.md
+if [ -n "$touches_twindrift" ]; then
+  node "$root/scripts/check-twin-drift.mjs"
+fi
+
+# 44) The sandbox matrix behind check 43. 16 mutations of index.html + play.html in a scratch copy,
+#     each with the verdict the guard must return: the clean tree, the 9 planned extractions of
+#     docs/twin-drift.md deleted from BOTH surfaces (8 silent, row 8 with the 5 one-sided reports it
+#     cannot avoid), a 2-sided DIVERGENT edit, a 1-sided edit, a 1-sided deletion, a correctly
+#     mirrored edit, and a fresh duplication. It exists because the guard's 2 directions pull against
+#     each other: the first divergence rule failed 4 of those 9 extractions, row 1 included, where
+#     the deletion is perfectly mirrored and sig = deletes = 25. Runs when the RULES change (the
+#     guard, the baseline, or the matrix), not on every surface edit: it runs the guard 16 times over
+#     mutated copies of 1.7 MB of HTML, which took 10.38s to 13.13s wall over 6 samples on 2026-07-29
+#     at a load average of 3.18 to 5.19, against the guard's own 0.14s to 0.18s. Load dominates that
+#     figure: an earlier 15-case run of the same matrix, at a load average of 23.5 and 6 GB into
+#     swap, took 65.9s — roughly 5 times today's slowest sample, on the same verdicts.
+if [ -n "$touches_twindriftcases" ]; then
+  node "$root/scripts/check-twin-drift-cases.mjs"
+fi
diff --git a/docs/twin-drift.md b/docs/twin-drift.md
new file mode 100644
index 0000000..b412518
--- /dev/null
+++ b/docs/twin-drift.md
@@ -0,0 +1,683 @@
+# Twin drift: the index.html ↔ play.html extraction map
+
+Date: 2026-07-28, revised 2026-07-29. Line ranges are on `index.html` and `play.html` as this branch
+commits them, after `origin/main` was merged in (which moved both surfaces); every count here comes
+from `scripts/check-twin-drift.mjs` or `scripts/twin-drift-worklist.mjs`, every verdict from
+`scripts/check-twin-drift-cases.mjs`, and every timing in the Runtime table from
+`scripts/twin-drift-bench.mjs`. The 2 timings outside that table — the baseline refresh and the
+sandbox matrix — were timed by running those 2 commands directly. Every timing states the load
+average of the machine it was measured on.
+
+## The measurement
+
+`index.html` is 12,604 lines. `play.html` is 13,658 lines. They are the two engine surfaces:
+
+- `index.html` — the editor. It may load files from `vendor/`.
+- `play.html` — the app player and the single-file `.html` export. It must stay 1 self-contained file.
+
+**893 distinct lines longer than 40 characters are identical in both files.** They occur
+958 times in `index.html` and 1,011 times in `play.html`. The generated `<script id="njs-engine">`
+bundle, the probe-written `PROMPT-CAPS` table, the generated i18n maps and the Runware AIR table are
+excluded from that count, so the number is hand-maintained duplication only.
+
+**"Identical" means identical after `String.prototype.trim()`** — leading and trailing whitespace
+stripped, nothing inside the line touched. That is not a detail. `play.html` nests most of the
+shared code 1 or 2 levels deeper than `index.html`, so only **415 of the 893 lines are
+byte-identical in the files; the other 478 match only after the strip**. `seekVideo` is the visible
+case: `index.html:9106` starts at column 0 and `play.html:6658` starts at column 2. The guard is
+right to strip — an indentation change is not drift — and the older wording of this document, which
+said "byte-identical" throughout, was wrong about more than half the set.
+
+Reproduce the counts above:
+
+```sh
+TWIN_DRIFT_STATS=1 node scripts/check-twin-drift.mjs
+```
+
+538 of the 893 lines sit in 87 contiguous blocks of 4 lines or more, counted on `index.html` line
+numbers with at most 1 non-shared line inside a block. The other 355 are scattered single lines and
+pairs. This document ranks 16 of the 87 blocks. Reproduce those 3 figures:
+
+```sh
+node scripts/twin-drift-worklist.mjs
+```
+
+### What this map does NOT cover
+
+The ranked list below is a map, not an exhaustive partition. Read it that way.
+
+- **16 of 87 blocks are ranked.** The other 71 blocks and all 355 scattered lines are guarded by
+  `check-twin-drift.mjs` exactly like the ranked ones, but this document does not give them a
+  verdict.
+- **A twin can fall between 2 block ranges and be in no block's `sig` count.** `seekVideo`
+  (`index.html:9106-9115`, `play.html:6658-6667`) is the known example. It sits after block 4's range
+  (which ends at `index.html:8916`) and before block 12's range (which starts at `index.html:9120`),
+  so no ranked block counts it. The guard still holds it, because the guard works on the whole shared
+  set and not on this document's blocks.
+- **Lines of 40 characters or fewer are outside the shared set by design, on every block.** That
+  threshold buys the guard its very low false-positive rate, and it costs coverage. `seekVideo` shows
+  the trade in 1 place: 10 lines, identical on both surfaces after the strip, but only 2 of them are
+  longer than 40 characters. Those 2 are guarded. The other 8 (`let settled = false;`,
+  `vid.addEventListener("seeked", done);` and the like) are not, on either surface.
+- **The deliberately per-page `<head>` lines are guarded by nothing.** `og:title`, `og:description`,
+  `og:url`, `twitter:title` and `twitter:description` differ per page on purpose, so they were never
+  in the shared set, so no whole-file twin guard can cover them. No other check covers them either.
+  Block 10 says this again in place.
+
+### How the generated bundle is identified
+
+The bundle must be excluded, and finding it is not as simple as it looks. `play.html` also holds the
+export builder's **string literal** for the same tag:
+
+```js
+const engTag = engText ? '<script id="njs-engine">\n' + engText.replace(/<\/script/gi, "<\\/script") …
+```
+
+Every `</script` inside `RUNTIME_JS` is written escaped, so a lazy
+`/<script id="njs-engine"[\s\S]*?<\/script>/` that starts on that literal does not close until the
+last real `</script>` in the file. That match blanked `play.html:11259-13656`: 2,398 lines, 17.6% of
+the file, all of it hand-written player code. 197 shared lines were invisible while it did.
+
+The guard therefore matches `<script id="njs-engine" data-hash="…">` and **re-derives the hash**.
+`scripts/gen-js-engine.mjs:165` writes `data-hash = sha256(bundle).slice(0,16)`. A quoted string
+inside `RUNTIME_JS` cannot forge a body that hashes to its own declared hash. The other 3 generated
+regions carry unique `BEGIN`/`END` comment markers and appear at most once per file.
+
+## The guard
+
+`scripts/check-twin-drift.mjs` pins the shared set against `scripts/twin-drift-baseline.json`.
+
+It **fails** on:
+
+- **Drift.** A shared line left the set because 1 surface edited it and the other did not. The guard
+  prints both `file:line` positions and the 2 versions of the line.
+- **One-sided deletion.** A shared line is gone from 1 surface, nothing near-identical replaced it,
+  and the line is still live on the other surface. The code did not move. 1 engine stopped doing the
+  work and the other still does it.
+- **Occurrence drift.** A shared line lost a copy on 1 surface only. 75 of the 893 lines appear more
+  than once inside a surface (28 in `index.html`, 65 in `play.html`), so presence alone is not
+  enough: editing 1 of 2 identical copies leaves the hash present. The baseline stores the
+  per-surface count of every line.
+- **Divergence.** A shared line left BOTH surfaces, and each surface now carries its own, **new**,
+  **different** replacement of it. Both engines still do the work and they now do it differently.
+  See "The one exemption" below for the exact test, and for what **new** costs.
+- **Growth.** The distinct shared-line count went up, or a shared line gained a copy.
+
+It **passes** on:
+
+- **Extraction.** A line that left both surfaces and left no matching pair of replacements behind.
+  The note names both readings — a real extraction, or the old half of a mirrored edit — instead of
+  guessing. When the generated bundle carries the same text, the note says so, because then
+  "extracted into the library" is the reading.
+- **A correctly mirrored edit.** Both surfaces change together, to the same new text, the count
+  holds, and the guard asks for a baseline refresh in a note.
+
+Every departure is **classified**, up to the `MAX_CLASSIFY` ceiling of 200. Each failure list
+**names its first 12 lines and reports the rest as a count**. A departure lands under 1 of 3
+headings — `TWIN DIVERGENCE`, `TWIN DRIFT` or `ONE-SIDED DELETION` — and all 3 can fire in the same
+run, so at the ceiling the guard classifies 200 departures and names **at most 36** of them, 12 under
+each. (An earlier revision of this document said 24. That assumed only 2 headings could fire at
+once. Edit `index.html:9403`/`play.html:6869` divergently, rename `play.html:12717` on 1 surface, and
+delete `play.html:7349` from 1 surface: all 3 headings print together.) How the 200 split between the
+3 headings depends on which lines departed, so no fixed split belongs in this document. The guard
+does not name every line, and no part of it claims to.
+
+### The one exemption, stated exactly
+
+Leaving both surfaces is **not** what makes a departure an extraction. Leaving both surfaces **while
+the 2 surfaces still agree afterwards** is. A departure from both surfaces fails as divergence when
+all 3 of these hold, and passes otherwise:
+
+1. `index.html` carries a **new** line near-identical to the departed line,
+2. `play.html` carries one too,
+3. those 2 replacements are near-identical **to each other**.
+
+"Near-identical" is one number in one place: `DRIFT_SIMILARITY = 0.72`, a Dice coefficient over
+character bigrams, the same test the drift rule already used. Condition 3 makes the 2 replacements 2
+versions of 1 line rather than 2 coincidences, and the surviving pair is always *different*, because
+an identical pair would be in the shared set.
+
+**"New" is the whole rule, and leaving it out failed 4 of the 9 extractions this document plans.**
+Deleting a twin block from both surfaces and editing a twin divergently on both surfaces leave trees
+that differ in exactly one way: the divergent edit **adds text**. Nothing else separates them, so a
+rule that matches a departed line against whatever happens to survive must eventually match a
+coincidence — and coincidences are not rare here. The baseline stores **798 look-alike hashes over
+the 893 lines, on 219 of them**, in the tree as it stands, before anything is edited. Deleting the
+block ranges of the work list below, from both surfaces, then produced this. Re-measured for this
+revision by running the current guard with its look-alike memory switched off, which is exactly what
+the first rule was, against the ranges the work list publishes **today**:
+
+| Row | Verdict of the first divergence rule | The "replacements" it named (positions in the files as committed) |
+|-----|--------------------------------------|-----------------------------|
+| 1 Resize and crop geometry | exit 1, **2 false divergences** | `index.html:7130` and `play.html:9763`, 2 unrelated canvas lines that had been sitting there all along |
+| 3 `encodeWavMono` + `mediaFetchError` | exit 1, **1 false divergence** | `index.html:9006` / `play.html:8812`, an unrelated `FileReader` pair — the demo-image path and the export reader |
+| 7 Local media recorder path | exit 1, **1 false divergence** | `index.html:6651` / `play.html:10810`, an unrelated `createElement` pair |
+| 8 Share packer, card and shorteners | exit 1, **2 false divergences** | the same canvas pair as row 1 |
+
+An earlier revision of this table gave row 7 **3** false divergences, at `index.html:6374` /
+`play.html:6965`, an `onerror` pair. That figure is real but it belongs to row 7's **old** ranges
+(`play.html:6635-6679` + `6979-7169`), which this document no longer publishes. Against the corrected
+ranges the same rule raises 1. Rows 1, 3 and 8 are unchanged, and the headline — **4 of the 9 planned
+extractions failed** — holds under either set of ranges.
+
+Reproduce the table: copy `scripts/check-twin-drift.mjs` into a scratch directory, replace the one
+line in `bestMatch()` that reads the look-alike memory,
+
+```js
+const already = (baseLook.get(baseHash) || {})[mover.file] || new Set();   // becomes: new Set()
+```
+
+then delete each row's ranges from both surfaces and run that copy. The `build()` helper of
+`scripts/check-twin-drift-cases.mjs` does the deleting.
+
+Rows 3, 7 and 9 also reported one-sided deletions, and those were **true**: the ranges those rows
+published paired regions that are not twins. They are corrected below, and the guard is what found
+them.
+
+Row 1 is the plainest mirrored removal in the plan — `sig` = `deletes` = 25, every occurrence of
+every twin inside the 2 ranges — and the guard called it divergence.
+
+So the baseline now stores, per line, the **look-alike set**: the hash of every other line on that
+surface that already scored 0.72 or more against it when the baseline was written. A candidate
+replacement from that set replaced nothing; it was there first. With the sets in place all 4 rows
+above pass, and the 2-sided divergent edit still fails. Both directions are pinned:
+
+```sh
+node scripts/check-twin-drift-cases.mjs
+```
+
+**So the exemption is: a departure from both surfaces where at most 1 surface grew a NEW look-alike
+line.** That includes a case the guard would ideally fail — 1 engine edits the line while the other
+drops it outright. Condition 3 is what keeps that case out, and it is there for a measured reason.
+An earlier draft failed a single-sided match. Run against a genuine extraction control — delete the
+whole MP4CAT block, `index.html:9210-9487` and `play.html:6676-6953`, 123 shared lines gone from both
+surfaces at once — that draft raised 1 FALSE failure out of the 123. The departing banner comment
+`/* ---- Lossless in-browser mp4 concatenation (Combine node) ----…` scored **0.840** against the
+unrelated banner still sitting at `index.html:9197`,
+`/* ---- in-browser video concatenation (the Combine node) ----…`, because a run of dashes carries
+the bigram profile. A guard that fails a correct extraction is a guard that gets bypassed.
+
+**How many lines does the exemption cover today? Zero.** It is a rule about future departures, and
+on the current tree nothing departs. Its size on any given commit is the number of departures from
+both surfaces in that commit where fewer than 2 NEW look-alike replacements appeared.
+
+The look-alike sets also close the MP4CAT banner case above on their own: the surviving banner
+(`index.html:9197`, hash `7f8cbc2c5d8093fb`) is the whole `index.html` look-alike set of the
+departing one (`48b64f163787aa57`), so it can no longer be read as a replacement. Condition 3 stays
+anyway. It is the cheaper guarantee and it holds even when the baseline is stale.
+
+### The sandbox matrix
+
+`scripts/check-twin-drift-cases.mjs` is 16 mutations of the 2 surfaces with the verdict the guard
+must return for each. It copies both files, the guard and the baseline into a scratch directory,
+mutates the copies and runs the guard there. Nothing touches the working tree. The 2 directions sit
+in one table on purpose: a change that fixes one of them can silently break the other, which is
+exactly what the first divergence rule did.
+
+| Case | Must |
+|------|------|
+| Clean tree | pass |
+| The 9 planned extractions, each deleted from BOTH surfaces | 8 pass; row 8 fails, see below |
+| Edit `index.html:9403` to `a+s.durIDX` **and** `play.html:6869` to `a+s.durPLAY` | fail, 1 `TWIN DIVERGENCE` |
+| Edit `index.html:9403` only | fail, 1 `TWIN DRIFT` |
+| Delete `play.html:6869` only | fail, 1 `ONE-SIDED DELETION` |
+| Edit both surfaces to the SAME new text | pass, note asks for a refresh |
+| Paste an `index.html`-only line into `play.html` as well | fail, the ratchet |
+
+**Row 8 is the one planned extraction that cannot be silent, and the guard is right.** Deleting the
+2 share blocks leaves 5 twins live on exactly 1 surface, because their other copy is in unrelated
+code:
+
+- `index.html:10825` and `10827` are an inline copy of `play.html`'s `explicitLang()`
+  (`play.html:11381-11394`). `index.html` has no other copy; `play.html` keeps its function.
+- `index.html:10742` and `10747` (the share card's thumbnail downscale) twin `play.html:9764,9771`,
+  a thumbnail helper outside the share block.
+- `play.html:13075` twins `index.html:7983,8064`, the canvas fit bounds.
+
+Plus 1 occurrence drift: the `noodle_lang` read lives twice in each file, and only `index.html`'s
+second copy is inside the block. No choice of ranges fixes this — the extra copies are somewhere
+else entirely. Whoever does row 8 refreshes the baseline as part of the move, deliberately, which is
+what the guard's own remedy line asks for. The matrix pins the exact counts, so if that extraction
+ever starts reporting something *else*, it fails the matrix.
+
+### The bundle is never an exemption
+
+A line still live on 1 surface always fails, and it fails even when the generated bundle happens to
+carry the same text. That clause is load-bearing. An earlier version of the guard read "the text is
+somewhere inside the bundle" as proof of extraction. It is not: **131 of the 893 baseline lines are
+identical to a line already inside the bundle while both hand copies are still live**, because the
+library ships MP4CAT, the pricing resolver and the resize geometry too. Under that rule a one-sided
+deletion of live MP4CAT code
+(`play.html:6869`, `const totalTicks = t.samples.reduce((a,s)=>a+s.dur, 0);`) exited 0 with a
+"moved into the generated bundle" note, so the one-sided-deletion rule was off on 15% of the guarded
+set. The same text-presence rule, 1 level down, also exited 0 on the **2-sided divergent** edit of
+that same line, which is the hole the exemption above closes. Presence in the bundle now only picks
+the wording of a note on a departure that is already classified as extraction. Count the 131 for
+yourself:
+
+```sh
+TWIN_DRIFT_STATS=1 node scripts/check-twin-drift.mjs
+```
+
+Refresh the baseline deliberately:
+
+```sh
+TWIN_DRIFT_UPDATE=1 node scripts/check-twin-drift.mjs
+```
+
+### What the baseline stores, and why it cannot be hand edited
+
+Each `lines` entry is `<hash> <n in index.html> <n in play.html> <look-alikes in index.html>
+<look-alikes in play.html> <the stripped line>`, each look-alike field being `-` or a
+comma-separated list of hashes.
+
+- The **text** is there because a line gone from both surfaces has no copy left in either file. The
+  divergence test above cannot run without it.
+- The **look-alike sets** are the guard's memory of what the tree looked like when the baseline was
+  written, and the divergence test is wrong without them: it reads a line that was already there as
+  a "replacement". **798 hashes over the 893 entries, on 219 of them.** They are written at refresh
+  only, because each one costs a scan of both surfaces.
+- Together those 2 fields are most of the file. The baseline is **118,273 bytes** today. Blanking the
+  look-alike fields in it drops it to **106,105 bytes**; blanking the stored text as well drops it to
+  **26,272 bytes**. Those 2 are reconstructions from today's file, not measurements of any earlier
+  revision of the format — an earlier revision of this document quoted a 25,747 / 101,630 / 118,241
+  chain that cannot be re-derived from the file as it now stands, so it is withdrawn rather than
+  restated.
+- The **hash is a checksum of the text**: the guard re-hashes every stored line and refuses the
+  baseline if any entry's text does not hash to its own hash. A stored line cannot be swapped for a
+  friendlier one.
+- The **count is a ratchet, derived from the `lines` array**, never read from the `count:` field. The
+  `count`, `occurrencesIndexHtml` and `occurrencesPlayHtml` fields stay in the JSON for a human
+  reader, and the guard fails if any of them stops describing `lines`.
+- The **`digest` field is required**. It hashes the `lines` array, which now carries the per-line
+  occurrence counts and the text, so it is the only thing pinning those. It used to be checked as
+  `if (baseline.digest && …)`, which made *deleting the field* a way to switch the check off:
+  inflate 1 line's stored counts from `1 1` to `2 2` (the guard reads a drop on both surfaces as a
+  mirrored deletion and allows it), move `occurrencesIndexHtml` and `occurrencesPlayHtml` to match,
+  delete `digest`, and a clean tree exited 0 with that line's ratchet silently raised. A missing or
+  malformed digest is now an error.
+
+The pre-commit hook runs the guard when `index.html`, `play.html`, the guard or the baseline is
+staged, and the sandbox matrix when the guard, the baseline or the matrix is staged.
+
+`touches_twindrift` was missing from the hook's early-exit condition, so a commit that staged **only**
+`scripts/twin-drift-baseline.json` returned before any check ran — the one file to edit to defeat the
+ratchet was the one file that skipped it. Both variables are in the condition now. Reproduce the old
+behaviour by removing them: stage a baseline with its `digest` field deleted, on its own, and commit.
+
+### Runtime
+
+Offline, no network, no API spend.
+
+The cost that matters is the drift classifier: for every baseline line that left the shared set it
+scores the departing text against every candidate line of the surface that moved. A departure that
+left BOTH surfaces is the dearest kind, because the divergence test scores it against both.
+`MAX_CLASSIFY` caps the work at 200 departures; at 201 the guard reports totals instead, so the run
+is always bounded. The ceiling is not free, and a normal commit never reaches it.
+
+**Every range below is scoped to the load band it was measured in. Outside that band it says
+nothing, and none of it is a promise about your machine — on this evidence the load matters more than
+the code. Measure your own before you quote one.** 30 samples of each case, 6 runs of 5, on
+2026-07-29 after `origin/main` was merged into this branch, on a shared 18-core machine whose
+1-minute load average ran between **3.19 and 5.68** across those runs. Each range is the full spread
+of the 30: the low end of every row came from the lightest-loaded runs and the high end from the
+busiest.
+
+| Case | Wall clock | CPU time |
+|------|------------|----------|
+| Clean tree, nothing departs | 0.14-0.18 s | 0.16-0.20 s |
+| 200 departures, all gone from BOTH surfaces | 1.99-3.19 s | 2.08-3.39 s |
+| 200 departures, all gone from 1 surface | 0.91-1.64 s | 0.94-1.72 s |
+
+CPU exceeds wall on the clean-tree row because Node's own startup runs on more than 1 thread.
+
+Two costs are NOT in that table, and both are paid on purpose:
+
+- **The baseline refresh takes 9.50-11.83 s wall** (6 samples, same machine, load average 3.63-4.17),
+  because it scores every one of the 893 shared lines against every line of both surfaces to build
+  the look-alike sets. It runs only when someone asks for it.
+- **The sandbox matrix takes 10.38-13.13 s wall** (6 samples, same machine, load average 3.18-5.19):
+  it runs the guard 16 times over mutated copies of 1.7 MB of HTML. The pre-commit hook runs it when
+  the RULES change — the guard, the baseline or the matrix itself — not on every surface edit. It is
+  the slowest check in the hook, which is why it is not on every surface edit.
+
+**How little of any of this is the code.** Every range on this page was re-measured after the
+`origin/main` merge, and every one of them came in FASTER and NARROWER than the range the same
+commands produced before it — on the same code, on a quieter box. The clean tree went from a
+0.13-0.57 s spread at a load average of 2.6-12.1 to 0.14-0.18 s at 3.19-5.68; the matrix from
+12.2-29.9 s to 10.38-13.13 s. Nothing in the guard got faster. The load band moved. An earlier
+15-case run of the same matrix, taken while an unrelated Rust build held this box at a load average
+of **23.5** and 6 GB into swap, took **65.9 s** — same verdicts, roughly 5 times today's slowest
+sample. That is the point of every load band on this page: quote your own numbers, not these.
+
+An earlier round measured the 200-departure ceiling at 23-30 s wall, on a machine under a load
+average of 25 to 34, before `bestMatch` got its candidate index — it rebuilt the bigram profile of
+every candidate line on every call, while the header claimed "well under 2 seconds" and the hook
+claimed "~0.2s". That figure is not comparable to the table above: different code, and a far busier
+machine.
+
+Reproduce the whole table:
+
+```sh
+node scripts/twin-drift-bench.mjs        # 5 samples of each case, prints the load average too
+time node scripts/check-twin-drift.mjs   # just the clean-tree row
+```
+
+## Why extraction is hard here
+
+Both surfaces run the nanoodle-js bundle **behind a flag**. `njsOn()` reads `?engine=js`,
+`?engine=play` and `localStorage.njs_engine`. When the flag is off, or before the bundle arrives,
+both engines fall back to their built-in copies:
+
+- `index.html:8253` appends `vendor/njs-engine.js` **asynchronously**, and only when the flag is on.
+  `index.html:8234-8239` states the contract: until the bundle loads, `njsRunFor()` returns null and
+  the built-in runners execute.
+- `play.html` embeds the bundle inline, but `play.html:11257-11260` copies it into an export only
+  when the script element carries text.
+
+So the built-in copy on each surface is a **live fallback path**, not dead code. You cannot delete a
+duplicated block until one of these is true:
+
+1. `index.html` loads the bundle unconditionally and waits for it before the first run, or
+2. the block is moved into the bundle **and** the flag stops gating it.
+
+Both are architecture decisions with a first-paint cost. Neither belongs in a drive-by refactor.
+
+Local media is a second constraint. `index.html:8234` and `play.html:7966` both say local media nodes
+keep the canvas and Web Audio paths, because a browser has no ffmpeg fallback. The library's
+`local-media.mjs` therefore does not drive the Combine, Resize, Extract-frames or Trim nodes on
+either surface today.
+
+## Ranked blocks
+
+`sig` is the number of distinct shared lines longer than 40 characters that have a hit inside the
+`index.html` range **and** a hit inside the paired `play.html` range. It measures how much of the
+shared set a block touches; it is **not** a deletion count, and the work-list table below explains
+where the 2 differ. Line ranges are on both surfaces as this branch commits them.
+
+### 1. Share packer, share card and shorteners — sig 140
+
+- `index.html:10725-11041` (`shrinkShareMedia`, `packShareFit`, `buildShareUrl`, `drawShareCard`,
+  `shareCardB64`, `shortenWith`, `socLinks`, `setShareUrl`, `syncShortenButtons`, `openShareMenu`)
+- `play.html:12823-13142`
+
+This block was invisible until the region detection was fixed, and it is now the largest single
+duplicated block in the repo. The code itself says so: `index.html:10727` and `index.html:10762`
+both end a header comment with "(Twin of play.html's.)".
+
+**Verdict: extractable, and nothing in the library covers it yet.** `nanoodle-js/src/share.mjs`
+exports `isShareRef`, `decodeShareFragment` and `decodeShareUrl` — it **decodes** share links and
+does not pack them. The 2 hand copies are the only packer that exists.
+`scripts/check-share-link.mjs` already lifts `packShareFit` out of both files as text and runs it, so
+that 1 function is pinned. The card drawing, the shortener client and the button-state logic had no
+guard at all before this one. The work is a new `share-pack.mjs` in nanoodle-js, then the same
+flag-off decision as block 2.
+
+### 2. MP4CAT lossless mp4 remux — sig 123
+
+- `index.html:9210-9487`
+- `play.html:6676-6953`
+
+The Combine node copies compressed H.264 and AAC samples onto 1 timeline. It is duplicated 3 times:
+both surfaces plus `nanoodle-js/src/mp4cat.mjs`, which the bundle already carries as a dependency of
+`local-media.mjs`.
+
+**Verdict: extractable, but not in 1 PR.** `browser.mjs` does not re-export `MP4CAT`, so
+`window.NanoodleEngine.MP4CAT` is undefined today. The work is:
+
+1. nanoodle-js: add `export { MP4CAT } from "./mp4cat.mjs";` to `src/browser.mjs`. 1 line.
+2. nanoodle: regenerate the bundle and `vendor/njs-engine.js` with `node scripts/gen-js-engine.mjs`.
+3. nanoodle: make `index.html` load the bundle unconditionally, or keep a local fallback for the
+   flag-off path. This is the blocking decision.
+4. Delete both hand copies. `scripts/check-combine.mjs` must then run the library copy against the
+   same `scripts/fixtures/clip[AB].mp4` fixtures, so the test value is not lost.
+
+Removing this block alone drops the baseline from 893 to 770. That is 14% of the duplication in
+1 move.
+
+### 3. Local media: the MediaRecorder fallback — sig 68
+
+- `index.html:9489-9741` (`pickVideoMime`, `loadVideoMeta`, `prepClip`, `recordClip`,
+  `concatViaRecorder`, the MediaRecorder and AudioContext fallback path, async audio polling)
+- `play.html:6635-6640`, `play.html:6668-6675` and `play.html:6954-7167`
+
+The MediaRecorder fallback runs when the clips are not matching mp4s.
+
+The `play.html` ranges used to read `6635-6679` and `6979-7169`, and both ends were wrong. The first
+swallowed `toLocalMediaUrl`, `seekVideo` and MP4CAT's opening 4 lines, none of which
+`index.html:9489-9741` holds; the second started **after** `prepClip` and `recordClip`
+(`play.html:6954-6994`), which `index.html:9489-9741` does hold. Deleting the old pair from both
+surfaces reported 11 one-sided deletions. `scripts/check-twin-drift-cases.mjs` holds the corrected
+pair and proves it is silent.
+
+**Verdict: needs a new library module first.** This path is not in nanoodle-js at all, because the
+library's `local-media.mjs` uses ffmpeg for the same case in Node. A browser has no ffmpeg, so the
+library needs a browser-only recorder module before either hand copy can go.
+
+### 4. NanoGPT client, built-in runner fallback — sig 81
+
+- `index.html:8576-8916` (`b64ImageMime`, `normalizeLoraUrl`, `nodeLoras`, `genImage`, `genVideo`,
+  the chat body build, audio content-type repair, blob size guards)
+- `play.html:6179-6499`
+
+**Verdict: already covered by the bundle path — do not extract again.** This is exactly the surface
+`scripts/check-js-parity.mjs`, `scripts/check-njs-delegation.mjs` and
+`scripts/check-njs-editor-delegation.mjs` lock against the library. These lines are the
+flag-off fallback that the delegation design deliberately keeps. They disappear when the flag
+disappears, not before.
+
+### 5. Pricing resolver — sig 68
+
+- `index.html:5571-5715` (`pickByRes`, `pickObjByRes`, `videoUnitUsd`, `genericScanUsd`,
+  `audioUnitUsd`, the `per_duration` and `referenceToVideoPrices` branches)
+- `play.html:5929-6058`
+
+Every NanoGPT price shape maps to 1 USD number here. It feeds the picker prices and the
+"~$X to run" chip.
+
+**Verdict: extractable, and a third copy already exists.** `nanoodle-js/src/estimate.mjs` carries
+the same `pickByRes` / `pickObjByRes` / `videoUnitUsd` / `genericScanUsd` / `audioUnitUsd`, but
+`src/index.mjs` exports it and `src/browser.mjs` does not. The module is therefore **absent from the
+browser bundle**. Add it to `browser.mjs`, regenerate, then route both surfaces at it. The same
+flag-off blocker as block 2 applies.
+
+`scripts/check-pricing.mjs` already runs both engine copies over `scripts/pricing-fixtures.json`.
+Point it at the library copy when the hand copies go.
+
+Note that `if(raw[k]){ v=pickByRes(raw[k], res, defRes); if(v!=null) return v*dur; }` appears **twice**
+inside `index.html` (5664 and 5673). It is 1 of the 75 lines that need the occurrence count, not just
+presence, to stay protected.
+
+### 6. Vision, LLM and frame-extraction node bodies — sig 54
+
+Paired range by range, because a later row of the work list needs 1 of these pairs exactly:
+
+- `index.html:4379-4392` (`audioInputPart`) ↔ `play.html:7296-7309`
+- `index.html:5215-5223` (the music/remix song-count clamp) ↔ `play.html:7235-7243`
+- `index.html:5414-5423` (`llmOpts`, the chat sampling options) ↔ `play.html:6157-6166`
+- `index.html:6070-6146` (message assembly, the 4 MB reference-image guard) and `6229-6258` (the
+  Resize node body) ↔ `play.html:7437-7537`
+- `index.html:6362-6390` (Extract-frames stepping) ↔ `play.html:7602-7627`
+- `index.html:7211-7229` (`maskToSource`) ↔ `play.html:7320-7338`
+
+**Verdict: mixed.** `maskToSource` is already exported from `browser.mjs` — extract it now, it is
+the cheapest win in the whole list at 5 shared lines. The message-assembly lines belong to block 4's
+delegation surface. The Extract-frames stepping is local media and needs a library module first.
+
+### 7. njs delegation shim — sig 35
+
+- `index.html:8163-8170` (`topoOrder`), `8244-8252` (`NJS_TYPES`), `8300-8375`, `8464-8470`
+  (`fieldOverrides`)
+- `play.html:7768-7775`, `7972-8079`, `8145-8151`
+
+**Verdict: deliberate twin. Leave it.** `index.html:8228-8242` names it "Twin of play.html's Phase-E
+shim". `scripts/check-njs-editor-delegation.mjs` exists to hold the 2 copies byte-identical. Note
+that `topoSort` and `MAX_FRAMES` are already exported from `browser.mjs`, so `topoOrder` could go if
+the shim ever collapses.
+
+### 8. Resize and crop geometry — sig 25
+
+- `index.html:6928-6988` (`resizePlan`, `resizeCropImage`, the aspect derivation)
+- `play.html:7342-7377` and `play.html:8822-8836`
+
+**Verdict: extractable, blocked only by the flag.** `browser.mjs` already exports `resizePlan` and
+`resizeCropImage`. `scripts/check-resize-plan.mjs` already proves the 2 hand copies agree with each
+other. This block is the safest candidate in the list, because the library copy is exported and
+tested today.
+
+### 9. Share-menu wiring — sig 24
+
+- `index.html:11154-11194` (the `#sharemenu` button handlers, the shorten-in-flight disable, the
+  Escape closer)
+- `play.html:13281`, `play.html:13363-13415` and `play.html:13519`
+
+The `play.html` range used to read `13281-13519` in one piece. That swallowed the whole agent-pill
+popover (`play.html:13283-13362`) and the model-picker search, which `index.html` keeps at
+`11694-11710` and `10480` — so deleting the pair reported 6 one-sided deletions.
+
+**Verdict: extract with block 1, not before.** These are DOM handlers over the same 2 element ids on
+2 separate documents. They only collapse if the share popover itself becomes a shared component,
+which is a bigger move than extracting the packer.
+
+### 10. `<head>` metadata and the share-menu markup — sig 21
+
+- `index.html:8-31` (`og:image`, `twitter:card`, the icon and manifest links),
+  `index.html:1108-1131` (`sm-urlrow`, `sm-svc`, `sm-social`, the shortener button row)
+- `play.html:8-31`, `play.html:470-509`
+
+**Verdict: genuinely surface-specific. Leave it.** This is HTML markup, not engine code. The 2 pages
+are separate documents with separate CSP paths (see `_headers`). A build step that templated the
+head would break the "1 self-contained file" property of the export.
+
+Be precise about what the guard covers here. `og:image`, `og:image:width`, `og:image:height`,
+`og:image:alt`, `twitter:card`, `twitter:image`, `twitter:image:alt` and the icon and manifest links
+are byte-identical on the 2 pages, so they are in the shared set and a 1-page change to any of them
+fails. `og:title`, `og:description`, `og:url`, `twitter:title` and `twitter:description` are
+**deliberately different per page**. They were never in the shared set, so they cannot leave it, and
+this guard cannot protect them. Nothing else guards them either — that is a real gap, and it is not
+one this guard can close.
+
+### 11. OAuth PKCE login — sig 17
+
+- `index.html:11778-11815`
+- `play.html:10371-10505`
+
+**Verdict: extractable in principle, low priority.** The library has no auth module.
+`scripts/check-login-state.mjs` already replays a sign-in round-trip on both files. The exported app
+also runs this code from `file://`, where OAuth does not work, so any move must keep the
+paste-key path intact.
+
+### 12. Local media: WAV encode and fetch-error text — sig 26
+
+- `index.html:9120-9195` (`mediaFetchError`, `encodeWavMono` and its header writes,
+  `trimAudioToWavUrl`, `extractAudioToWavUrl`)
+- `play.html:6516-6633`
+
+The `index.html` range used to stop at `9181`. `play.html:6516-6633` carries the twins of
+`trimAudioToWavUrl` and `extractAudioToWavUrl` as well (`index.html:9182-9195`), so the short range
+deleted those 3 shared lines from `play.html` only.
+
+**Verdict: partly covered.** `browser.mjs` already exports `encodeWavMono` from `local-media.mjs`.
+`mediaFetchError` is not in the library. Extract `encodeWavMono` with block 8; the other needs a home
+first. `seekVideo` (`index.html:9106-9115`, `play.html:6658-6667`) is a third twin. It sits before
+this block's range and after block 4's, so no ranked block counts it. Only 2 of its 10 lines are
+longer than 40 characters, so only those 2 are in the shared set at all. See "What this map does NOT
+cover".
+
+### 13. i18n `translateTree` and `withLocale` — sig 12
+
+- `index.html:3813-3848`
+- `play.html:5690-5740`
+
+**Verdict: surface-specific for now.** The editor localizes its own chrome; exported apps ship
+English-only chrome plus the app-player chrome. `scripts/check-i18n-coverage.mjs` covers the maps.
+The 2 helper functions could move to a shared module, but the payoff is 12 lines.
+
+### 14. Prompt-cap helpers — sig 9
+
+- `index.html:4203-4253` (`learnPromptCap`, `fitPromptText`, `promptCapFromError`)
+- `play.html:7880-7929`
+
+**Verdict: extractable, and the library copy is already in the bundle.**
+`nanoodle-js/src/prompt-caps.mjs` exports `fitPromptText`, `promptCapFromError` and
+`learnPromptCap`, and the bundle carries the module. `browser.mjs` does not re-export them. Add the
+re-export, then route both surfaces at it. The generated `PROMPT-CAPS` table itself is already
+excluded from the drift count, because `scripts/probe-prompt-caps.mjs` writes it into both files.
+
+### 15. Small shared helpers — sig 6
+
+- `index.html:4052-4057` (`verParts` version compare), `index.html:9745-9750` (`isLowFundsError`)
+- `play.html:8561-8566`, `play.html:5771-5776`
+
+**Verdict: leave them.** 6 lines. The guard is cheaper than the extraction.
+
+### 16. Chat SSE stream loop — sig 5, agent-pill popover — sig 5
+
+- `index.html:12487-12496` / `play.html:11814-11826`
+- `index.html:11731-11756` / `play.html:13314-13354`
+
+Both were invisible before the region fix. 10 lines between them. **Verdict: leave them.** The SSE
+lines belong to block 4's delegation surface.
+
+## The work list, in order
+
+Three different numbers, one definition each. Nothing in this table is hand arithmetic — every cell
+comes from `node scripts/twin-drift-worklist.mjs`, which reads the same shared set the guard pins and
+prints the table below verbatim.
+
+- **`sig`** — distinct shared lines with at least 1 occurrence inside the row's `index.html` range
+  **and** at least 1 inside its `play.html` range. How much of the shared set the block touches.
+- **`deletes`** — distinct shared lines whose **every** occurrence, on **both** surfaces, sits inside
+  the row's ranges. Only these leave the shared set when the block goes. A twin with a copy outside
+  the ranges survives the deletion, so `deletes` ≤ `sig`.
+- **`new`** — this row's `deletes`, minus everything the rows above it already deleted.
+- **`Baseline after`** — 893 minus the running union of `new`.
+
+The old version of this table stated the `deletes` rule in prose and then subtracted `sig`. The 2
+rules disagree on rows 3, 7 and 8, so every "Baseline after" cell from row 3 down was wrong. The
+numbers below also move because rows 3, 7 and 9 now quote **corrected ranges**: the sandbox matrix
+deleted the old ones from both surfaces and the guard reported one-sided deletions, which is what a
+range that pairs 2 regions that are not twins looks like.
+
+| # | Block | sig | deletes | new | Baseline after | Blocker |
+|---|-------|-----|---------|-----|----------------|---------|
+| 1 | Resize and crop geometry | 25 | 25 | 25 | 868 | flag-off fallback only |
+| 2 | `maskToSource` | 5 | 5 | 5 | 863 | flag-off fallback only |
+| 3 | `encodeWavMono` + `mediaFetchError` | 26 | 25 | 25 | 838 | `mediaFetchError` has no library home |
+| 4 | Prompt-cap helpers | 9 | 9 | 9 | 829 | 1-line `browser.mjs` re-export |
+| 5 | Pricing resolver | 68 | 68 | 68 | 761 | `estimate.mjs` not in the browser bundle |
+| 6 | MP4CAT | 123 | 123 | 123 | 638 | `MP4CAT` not re-exported; `check-combine.mjs` must move |
+| 7 | Local media recorder path | 68 | 66 | 66 | 572 | needs a new library module |
+| 8 | Share packer, card and shorteners | 140 | 136 | 136 | 436 | needs a new `share-pack.mjs` |
+| 9 | Share-menu wiring | 24 | 24 | 24 | 412 | only after row 8 |
+
+**No row overlaps another.** The rows where `sig` and `deletes` disagree are 3 (26/25), 7 (68/66) and
+8 (140/136), and every line in the gap is named here:
+
+- `const AC = window.AudioContext || window.webkitAudioContext;` — `index.html:9162,9577,9639`,
+  `play.html:6556,6584,7023,7074`. Rows 3 and 7 each hold some of those copies and neither holds all
+  of them, so **neither row deletes it**. It is the whole of row 3's gap and half of row 7's.
+- `const vid = document.createElement("video");` — `index.html:6368,9511`, `play.html:6963,7608`.
+  The other half of row 7's gap.
+- Row 8's 4: `let x0=Infinity,y0=Infinity,x1=-Infinity,y1=-Infinity;`,
+  `c.getContext("2d").drawImage(img, 0, 0, w, h);`, `try{ img.src = src; }catch(_){ finish(null); }`
+  and `const packed = await gzip(json).catch(()=>null);`, each with a copy outside the share packer.
+
+Rows 1 to 6 all sit behind the same decision: **does `index.html` load `vendor/njs-engine.js`
+unconditionally, and does the built-in fallback survive?** Answer that once and 255 of the 893 shared
+lines become deletable (893 down to 638).
+
+Recompute the whole table, including the agreement check against the guard's baseline:
+
+```sh
+node scripts/twin-drift-worklist.mjs
+```
+
+Blocks 4, 7, 10, 13, 15 and 16 are not on the list. They are covered by the delegation design or they
+genuinely belong to 2 separate documents.
+
+## What was not done in this PR
+
+Nothing was extracted. Deleting the MP4CAT hand copies today would break `?engine=play` and every run
+that starts before `vendor/njs-engine.js` arrives. The guard and this map ship first, so the number
+is measured and cannot grow while the decision is pending.
diff --git a/scripts/check-twin-drift-cases.mjs b/scripts/check-twin-drift-cases.mjs
new file mode 100644
index 0000000..5b31f62
--- /dev/null
+++ b/scripts/check-twin-drift-cases.mjs
@@ -0,0 +1,329 @@
+#!/usr/bin/env node
+// The SANDBOX MATRIX for scripts/check-twin-drift.mjs: 16 mutations of the 2 engine surfaces, each
+// with the verdict the guard must return. It copies index.html, play.html, the guard and the
+// baseline into a scratch directory, mutates the copies, runs the guard there, and compares its exit
+// code and its per-rule counts against this file. Nothing here touches the working tree.
+//
+// WHY IT EXISTS. This guard has 2 failure directions and they pull against each other:
+//   it must FAIL a 2-sided DIVERGENT edit (each surface keeps its own version of one twin), and
+//   it must PASS a 2-sided mirrored DELETION (both surfaces drop the same twins — an extraction).
+// A change that fixes one direction can silently break the other. The first divergence rule did
+// exactly that: it failed 4 of the 9 extractions docs/twin-drift.md itself plans, including row 1,
+// where sig = deletes = 25 and the deletion is perfectly mirrored. Both directions are in the table
+// below, so neither can regress unnoticed.
+//
+// HOW A MUTATION IS WRITTEN. Line ranges are 1-based and inclusive, on the file as committed. The
+// deletions are the block ranges of the work list in docs/twin-drift.md, so this matrix also proves
+// that the ranges that document publishes really are mirrored pairs. Three of them were not, and the
+// guard is what found it — see the row notes.
+//
+// Offline. No network, no API spend, no writes outside the scratch directory.
+//   node scripts/check-twin-drift-cases.mjs
+
+import { readFileSync, writeFileSync, mkdirSync, mkdtempSync, rmSync, copyFileSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { resolve, dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { tmpdir } from "node:os";
+
+const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+
+// A case is { name, why, idx, play, edits, expect }.
+//   idx / play  line ranges to DELETE from that surface, [from, to] inclusive, 1-based.
+//   edits       [{ file, line, from, to }] — an exact-text replacement, so a shifted line fails loud
+//               instead of editing the wrong code.
+//   expect      { exit, divergence, drift, oneSided, occurrence, growth } — every rule's count. A
+//               missing key means 0.
+const CASES = [
+  {
+    name: "clean tree",
+    why: "no mutation at all: the committed tree must be silent",
+    expect: { exit: 0 },
+  },
+
+  // ---- the 9 planned extractions of docs/twin-drift.md, deleted from BOTH surfaces ----------
+  {
+    name: "extract row 1 — resize and crop geometry",
+    why: "sig = deletes = 25, the plainest mirrored removal in the plan",
+    idx: [[6928, 6988]],
+    play: [[7342, 7377], [8822, 8836]],
+    expect: { exit: 0 },
+  },
+  {
+    name: "extract row 2 — maskToSource",
+    why: "5 twins, already exported from browser.mjs",
+    idx: [[7211, 7229]],
+    play: [[7320, 7338]],
+    expect: { exit: 0 },
+  },
+  {
+    name: "extract row 3 — encodeWavMono + mediaFetchError",
+    why: "index.html range ends at 9195, not 9181: play.html:6516-6633 carries the twins of " +
+      "trimAudioToWavUrl and extractAudioToWavUrl too, and the shorter range left them one-sided",
+    idx: [[9120, 9195]],
+    play: [[6516, 6633]],
+    expect: { exit: 0 },
+  },
+  {
+    name: "extract row 4 — prompt-cap helpers",
+    why: "9 twins, library copy already in the bundle",
+    idx: [[4203, 4253]],
+    play: [[7880, 7929]],
+    expect: { exit: 0 },
+  },
+  {
+    name: "extract row 5 — pricing resolver",
+    why: "68 twins, and 1 of them is a line index.html carries twice",
+    idx: [[5571, 5715]],
+    play: [[5929, 6058]],
+    expect: { exit: 0 },
+  },
+  {
+    name: "extract row 6 — MP4CAT",
+    why: "123 twins leave at once — the largest single mirrored deletion in the plan",
+    idx: [[9210, 9487]],
+    play: [[6676, 6953]],
+    expect: { exit: 0 },
+  },
+  {
+    name: "extract row 7 — local media recorder path",
+    why: "play.html ranges corrected to 6635-6640 / 6668-6675 / 6954-7167. The old 6635-6679 " +
+      "swallowed toLocalMediaUrl, seekVideo and MP4CAT's first 4 lines, and the old 6979-7169 " +
+      "started AFTER prepClip and recordClip, whose index.html twins are inside 9489-9741",
+    idx: [[9489, 9741]],
+    play: [[6635, 6640], [6668, 6675], [6954, 7167]],
+    expect: { exit: 0 },
+  },
+  {
+    name: "extract row 8 — share packer, card and shorteners",
+    why: "the one planned extraction that cannot be silent, and the guard is right. 5 twins have " +
+      "their OTHER copy in unrelated code on one surface only, so deleting the 2 share blocks " +
+      "leaves each of them live on exactly 1 surface:\n" +
+      "        index.html:10825,10827 inline play.html's explicitLang() (play.html:11381-11394)\n" +
+      "        index.html:10742,10747 twin play.html:9764,9771, a thumbnail helper outside the block\n" +
+      "        play.html:13075 twins index.html:7983,8064, the canvas fit bounds\n" +
+      "      Plus 1 occurrence drift: index.html carries the noodle_lang read twice (3793 and 10826)\n" +
+      "      and play.html twice, and only index.html's second copy is inside the block.\n" +
+      "      Whoever does row 8 refreshes the baseline as part of it — deliberately, which is what\n" +
+      "      the guard's own remedy line asks for",
+    idx: [[10725, 11041]],
+    play: [[12823, 13142]],
+    expect: { exit: 1, oneSided: 5, occurrence: 1 },
+  },
+  {
+    name: "extract row 9 — share-menu wiring",
+    why: "play.html ranges corrected to 13281 / 13363-13415 / 13519. The old 13281-13519 swallowed " +
+      "the whole agent-pill popover (13283-13362) and the model-picker search, which index.html " +
+      "keeps at 11694-11710 and 10480",
+    idx: [[11154, 11194]],
+    play: [[13281, 13281], [13363, 13415], [13519, 13519]],
+    expect: { exit: 0 },
+  },
+
+  // ---- the drift the guard exists to catch ---------------------------------------------------
+  {
+    name: "2-sided DIVERGENT edit",
+    why: "each surface keeps its OWN version of one twin. The twin leaves both surfaces, exactly " +
+      "like an extraction, and only the NEW text on each side separates the 2 cases",
+    edits: [
+      {
+        file: "index.html",
+        line: 9403,
+        from: "    const totalTicks = t.samples.reduce((a,s)=>a+s.dur, 0);",
+        to: "    const totalTicks = t.samples.reduce((a,s)=>a+s.durIDX, 0);",
+      },
+      {
+        file: "play.html",
+        line: 6869,
+        from: "    const totalTicks = t.samples.reduce((a,s)=>a+s.dur, 0);",
+        to: "    const totalTicks = t.samples.reduce((a,s)=>a+s.durPLAY, 0);",
+      },
+    ],
+    expect: { exit: 1, divergence: 1 },
+  },
+  {
+    name: "1-sided edit",
+    why: "the original case: index.html moves, play.html does not",
+    edits: [
+      {
+        file: "index.html",
+        line: 9403,
+        from: "    const totalTicks = t.samples.reduce((a,s)=>a+s.dur, 0);",
+        to: "    const totalTicks = t.samples.reduce((a,s)=>a+s.durIDX, 0);",
+      },
+    ],
+    expect: { exit: 1, drift: 1 },
+  },
+  {
+    name: "1-sided deletion",
+    why: "play.html stops doing the work, index.html still does it, and nothing replaced it",
+    play: [[6869, 6869]],
+    expect: { exit: 1, oneSided: 1 },
+  },
+  {
+    name: "correctly MIRRORED edit",
+    why: "both surfaces move to the SAME new text: the count holds, so the guard only asks for a " +
+      "baseline refresh",
+    edits: [
+      {
+        file: "index.html",
+        line: 9403,
+        from: "    const totalTicks = t.samples.reduce((a,s)=>a+s.dur, 0);",
+        to: "    const totalTicks = t.samples.reduce((a,s)=>a+s.durTicks, 0);",
+      },
+      {
+        file: "play.html",
+        line: 6869,
+        from: "    const totalTicks = t.samples.reduce((a,s)=>a+s.dur, 0);",
+        to: "    const totalTicks = t.samples.reduce((a,s)=>a+s.durTicks, 0);",
+      },
+    ],
+    expect: { exit: 0 },
+  },
+  {
+    // Pins the NAMING CEILING docs/twin-drift.md quotes. A departure lands under 1 of 3 headings,
+    // and each heading prints its first 12 lines, so at MAX_CLASSIFY the guard can name 36 lines,
+    // not 24. 24 assumed that only 2 of the 3 headings could fire at once. They can all fire.
+    name: "all 3 departure headings at once",
+    why: "one divergent 2-sided edit, one 1-sided edit and one 1-sided deletion in the same tree. " +
+      "The guard must report all 3 separately, which is why the ceiling names up to 12 x 3 = 36",
+    play: [[7349, 7349]], // twin of index.html:6958 — one-sided deletion
+    edits: [
+      {
+        file: "index.html",
+        line: 9403,
+        from: "    const totalTicks = t.samples.reduce((a,s)=>a+s.dur, 0);",
+        to: "    const totalTicks = t.samples.reduce((a,s)=>a+s.durIDX, 0);",
+      },
+      {
+        file: "play.html",
+        line: 6869,
+        from: "    const totalTicks = t.samples.reduce((a,s)=>a+s.dur, 0);",
+        to: "    const totalTicks = t.samples.reduce((a,s)=>a+s.durPLAY, 0);",
+      },
+      {
+        file: "play.html",
+        line: 12717,
+        from: "    const usd = parseFloat((await r.json()).usd_balance);",
+        to: "    const usd = parseFloat((await r.json()).usdBalance);",
+      },
+    ],
+    expect: { exit: 1, divergence: 1, drift: 1, oneSided: 1 },
+  },
+  {
+    name: "new duplication",
+    why: "a line that lives only in index.html is pasted into play.html as well — the ratchet",
+    edits: [
+      {
+        file: "play.html",
+        line: 6869,
+        from: "    const totalTicks = t.samples.reduce((a,s)=>a+s.dur, 0);",
+        to: "    const totalTicks = t.samples.reduce((a,s)=>a+s.dur, 0);\n" +
+          "    // Seek a <video> to a time and resolve once that frame is decoded and drawable. Falls back",
+      },
+    ],
+    expect: { exit: 1, growth: 1 },
+  },
+];
+
+// Every rule the guard can fail on, and the heading it prints. The counts are read back out of the
+// guard's own output, so a renamed heading fails this matrix instead of quietly matching nothing.
+const RULES = [
+  ["divergence", /TWIN DIVERGENCE — (\d+) line/],
+  ["drift", /TWIN DRIFT — (\d+) line/],
+  ["oneSided", /ONE-SIDED DELETION — (\d+) line/],
+  ["occurrence", /TWIN DRIFT \(occurrence count\) — (\d+) shared line/],
+  ["growth", /duplication went UP/],
+];
+
+const SURFACES = ["index.html", "play.html"];
+const GUARD = "check-twin-drift.mjs";
+const BASE = "twin-drift-baseline.json";
+
+function build(dir, c) {
+  mkdirSync(join(dir, "scripts"), { recursive: true });
+  for (const f of [GUARD, BASE]) copyFileSync(join(ROOT, "scripts", f), join(dir, "scripts", f));
+  const lines = {};
+  for (const f of SURFACES) lines[f] = readFileSync(join(ROOT, f), "utf8").split("\n");
+  for (const e of c.edits || []) {
+    const at = lines[e.file][e.line - 1];
+    if (at !== e.from) {
+      throw new Error(
+        `${c.name}: ${e.file}:${e.line} is not the line this case edits.\n` +
+          `  expected: ${e.from}\n  found:    ${at}\n` +
+          `  The file moved. Re-anchor the case on the line it means to edit.`
+      );
+    }
+    lines[e.file][e.line - 1] = e.to;
+  }
+  for (const [f, ranges] of [["index.html", c.idx], ["play.html", c.play]]) {
+    if (!ranges) continue;
+    const kill = new Set();
+    for (const [a, b] of ranges) for (let n = a; n <= b; n++) kill.add(n);
+    lines[f] = lines[f].filter((_, i) => !kill.has(i + 1));
+  }
+  for (const f of SURFACES) writeFileSync(join(dir, f), lines[f].join("\n"));
+}
+
+function runGuard(dir) {
+  try {
+    const out = execFileSync("node", [join(dir, "scripts", GUARD)], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    return { exit: 0, out };
+  } catch (e) {
+    if (e.status === undefined) throw e;
+    return { exit: e.status, out: (e.stdout || "") + (e.stderr || "") };
+  }
+}
+
+let failed = 0;
+const t0 = Date.now();
+for (const c of CASES) {
+  const dir = mkdtempSync(join(tmpdir(), "twin-drift-case-"));
+  let got;
+  try {
+    build(dir, c);
+    got = runGuard(dir);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+  const want = c.expect;
+  const bad = [];
+  if (got.exit !== want.exit) bad.push(`exit ${got.exit}, expected ${want.exit}`);
+  for (const [key, re] of RULES) {
+    const m = re.exec(got.out);
+    const n = m ? (m[1] === undefined ? 1 : Number(m[1])) : 0;
+    if (n !== (want[key] || 0)) bad.push(`${key} ${n}, expected ${want[key] || 0}`);
+  }
+  if (bad.length) {
+    failed++;
+    console.error(`✗ ${c.name}\n    ${bad.join("\n    ")}\n    why this case exists: ${c.why}`);
+    console.error(
+      got.out
+        .split("\n")
+        .map((l) => "    | " + l)
+        .join("\n")
+    );
+  } else {
+    const shape = [`exit ${want.exit}`]
+      .concat(RULES.filter(([k]) => want[k]).map(([k]) => `${k} ${want[k]}`))
+      .join(", ");
+    console.log(`✓ ${c.name.padEnd(46)} ${shape}`);
+  }
+}
+
+const secs = ((Date.now() - t0) / 1000).toFixed(1);
+if (failed) {
+  console.error(
+    `\n✗ check-twin-drift-cases: ${failed} of ${CASES.length} case(s) returned the wrong verdict ` +
+      `(${secs}s).\n` +
+      `  A case that now FAILS where it used to pass means the guard cries wolf on correct work,\n` +
+      `  which is how a guard gets bypassed. A case that now PASSES where it used to fail means the\n` +
+      `  guard has a hole. Fix the guard, not the table — or state in docs/twin-drift.md why the\n` +
+      `  verdict changed.\n`
+  );
+  process.exit(1);
+}
+console.log(`✓ twin-drift cases: ${CASES.length} verdicts, all as expected (${secs}s)`);
diff --git a/scripts/check-twin-drift.mjs b/scripts/check-twin-drift.mjs
new file mode 100644
index 0000000..478aff0
--- /dev/null
+++ b/scripts/check-twin-drift.mjs
@@ -0,0 +1,899 @@
+#!/usr/bin/env node
+// Offline guard against TWIN DRIFT between the two engine surfaces: index.html (the editor) and
+// play.html (the app player + the self-contained .html export).
+//
+// WHY THIS EXISTS
+// The two files are 26,000 lines together and they share a large body of character-for-character
+// identical, HAND-MAINTAINED code — identical after a leading/trailing whitespace strip, because
+// play.html nests it deeper (pricing resolver, Combine/MP4CAT remux, resize geometry, audio helpers,
+// the balance cache, the njs delegation shim). Every engine change is therefore a 2-surface edit.
+// Dual-engine drift is the dominant historical bug class in this repo (PRs #64, #74, #88 and the
+// whole node audit).
+//
+// The repo already pins SPECIFIC twins: check-resize-plan, check-pricing, check-combine,
+// check-cost-accrue and friends each lift one named function out of both files. check-js-parity and
+// check-njs-*-delegation pin each surface against the sibling nanoodle-js bundle. NOTHING compared
+// index.html against play.html as whole files. A one-sided edit to any line those targeted guards do
+// not name shipped silently. This guard closes that hole.
+//
+// WHAT IT MEASURES
+// The SHARED SET: every distinct line that appears in both files IDENTICALLY AFTER LEADING AND
+// TRAILING WHITESPACE IS STRIPPED, and that is longer than 40 characters once stripped. The strip
+// is load-bearing, not cosmetic: play.html nests the same code one or two levels deeper than
+// index.html, so most twins are NOT byte-identical in the files — only after the trim. Generated
+// regions are blanked first, so the generated nanoodle-js bundle and the probe-written prompt-cap
+// table never count as hand-maintained duplication.
+// scripts/twin-drift-baseline.json stores four things per line: the hash, the per-surface
+// OCCURRENCE COUNT (a line that appears twice in one surface can be edited in one place and still
+// be "present"), THE STRIPPED TEXT ITSELF, and the per-surface LOOK-ALIKE SET — the hash of every
+// OTHER line already on that surface that scores DRIFT_SIMILARITY or more against this one. The text
+// is what makes section 4b able to ask whether the two surfaces still agree about a line that left
+// both of them. The look-alike set is what makes that answer correct: without it the guard reads a
+// coincidental line that was ALREADY THERE as a "replacement", and fails a plain mirrored deletion.
+//
+// WHAT IT FAILS ON  (see section 4 for the exact rules)
+//   DRIFT      — a baseline line left the shared set, or lost an occurrence on one surface only,
+//                because ONE surface edited it and the other did not. The edited replacement is
+//                still sitting in the file that moved. The guard names both file:line positions.
+//   DELETION   — a baseline line is gone from one surface and still LIVE on the other. Nothing
+//                replaced it. The code did not move; one engine simply stopped doing it.
+//   DIVERGENCE — a baseline line left BOTH surfaces, and each surface now carries its OWN, NEW,
+//                DIFFERENT near-identical replacement. Both engines still do the work; they now do
+//                it differently. Leaving both surfaces is not proof of extraction.
+//   GROWTH     — the shared-line COUNT went up, or a shared line gained an occurrence.
+// THE ONE EXEMPTION, stated exactly. A departure that left BOTH surfaces prints a note instead of
+// failing UNLESS all 3 of these hold: index.html carries a NEW near-identical replacement,
+// play.html carries one too, and those 2 replacements are near-identical to each other. So the
+// exemption covers every departure from both surfaces where at most ONE surface grew a look-alike
+// line. That includes the case where 1 engine edited the line and the other dropped it outright:
+// the guard cannot fail that, and section 4b says why (a real extraction control produced exactly
+// that shape by coincidence). On the tree as it stands the exemption covers 0 lines, because
+// nothing departs; it is a rule about future departures, not a list of excused twins.
+// NEW is the word that carries the rule, and it is why the baseline stores a look-alike set per
+// line. Deleting a twin block from both surfaces and editing a twin divergently on both surfaces
+// differ in exactly ONE observable way: the divergent edit ADDS text that was not in the tree
+// before. Nothing else separates them, because coincidental look-alikes of a twin are already
+// sitting in both files (798 stored hashes over the 893 baseline lines, on 219 of them). Matching a
+// departed line against whatever survives, with no memory of what was there before, reads a MIRRORED
+// DELETION as divergence: section 4b names the 4 documented extractions that failed that way.
+// A line still live on one surface always fails, even when the generated bundle happens to carry
+// the same text (see section 4b). It does NOT fail on a correctly MIRRORED edit either (both
+// surfaces changed together, to the SAME new text): membership moves, the count holds, the new twin
+// is in the shared set, and the guard only asks for a baseline refresh.
+//
+// REFRESH (deliberate, same shape as the CSP golden in check-deploy-config.mjs):
+//   TWIN_DRIFT_UPDATE=1 node scripts/check-twin-drift.mjs
+//
+// STATS (every figure docs/twin-drift.md quotes about the shared set, printed):
+//   TWIN_DRIFT_STATS=1 node scripts/check-twin-drift.mjs
+//
+// RUNTIME. No network, no API spend. The cost that matters is the drift classifier: it scores every
+// DEPARTING line against every candidate line of the surface that moved, so the worst case is a
+// refactor that moves many twins at once, not a normal commit. A departure that left BOTH surfaces
+// is the dearest kind, because it is scored against BOTH surfaces. MAX_CLASSIFY caps the work at
+// 200 departures; 201 reports totals instead.
+// TIMINGS VARY BY MACHINE AND BY LOAD, and on this evidence the LOAD MATTERS MORE THAN THE CODE.
+// Every range below is scoped to the load band it was measured in. Outside that band it says
+// nothing, and none of it is a promise about your machine. Measure your own.
+// From scripts/twin-drift-bench.mjs on 2026-07-29, after origin/main was merged into this branch, on
+// ONE shared 18-core box, 30 samples of each case (6 runs of 5), with the 1-minute load average
+// between 3.19 and 5.68 across the runs. Each range is the FULL spread of the 30; the low end of
+// every row came from the lightest-loaded runs and the high end from the busiest:
+//   clean tree, nothing departs          0.14-0.18 s wall  (0.16-0.20 s CPU)
+//   200 departures, gone from both       1.99-3.19 s wall  (2.08-3.39 s CPU)
+//   200 departures, gone from 1 surface  0.91-1.64 s wall  (0.94-1.72 s CPU)
+// CPU beats wall on the clean row because Node starts on more than 1 thread.
+// TWIN_DRIFT_UPDATE is far dearer — 9.50-11.83 s wall over 6 samples on the same box at a load
+// average of 3.63 to 4.17 — because it scores all 893 shared lines against every line of both
+// surfaces to build the look-alike sets. It runs only when someone asks for it.
+// The sandbox matrix takes 10.38-13.13 s wall over 6 samples at a load average of 3.18 to 5.19.
+// How little of any of this is the code: every range here was re-measured after that merge and every
+// one came in FASTER and NARROWER than the same commands gave before it, on identical guard code —
+// the clean tree from a 0.13-0.57 s spread at a load average of 2.6-12.1 down to 0.14-0.18 s at
+// 3.19-5.68. Nothing got faster; the box got quieter. An earlier 15-case run of the matrix, made
+// while an unrelated Rust build held the box at a load average of 23.5 and 6 GB into swap, took
+// 65.9 s — same verdicts, roughly 5 times today's slowest sample. That is why every figure here
+// carries a load band, and why you should quote your own numbers and not these.
+// An earlier round measured the same 200-departure ceiling at 23-30 s, before bestMatch got its
+// candidate index — it rebuilt every candidate's bigram profile on every call. Those runs are not
+// comparable to the numbers above: different code, and a load average of 25 to 34.
+//
+// CASES. scripts/check-twin-drift-cases.mjs runs this guard over 16 mutated copies of the 2
+// surfaces and checks the verdict of each, so neither direction of the rule can regress alone.
+//
+// index.html and play.html carry committed NUL bytes; Node readFileSync(...,"utf8") reads them fine
+// (shell grep would need -a). ROOT resolves relative to THIS file so the check relocates into a
+// sandbox copy.
+
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { resolve, dirname, join, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const BASELINE = join(ROOT, "scripts", "twin-drift-baseline.json");
+
+// "Stripped" everywhere in this file means String.prototype.trim(): leading and trailing whitespace
+// only. Nothing inside the line is normalised, so a changed space between two tokens is still drift.
+//
+// A line must be longer than this (after strip) to enter the shared set. Short lines ("});",
+// "return out;", a lone brace) collide between unrelated code and would make the guard cry wolf.
+const MIN_LEN = 40;
+
+// How similar a surviving twin and a candidate replacement must be before we call it an edit and
+// not a coincidence. Dice coefficient over character bigrams. A one-token edit scores ~0.9; two
+// unrelated 60-character lines of the same house style score ~0.3-0.5.
+const DRIFT_SIMILARITY = 0.72;
+
+// If the baseline is this far out of date, per-line classification is noise. Report the totals and
+// send the developer to the refresh instead.
+const MAX_CLASSIFY = 200;
+
+const failures = [];
+const notes = [];
+const fail = (msg) => failures.push(msg);
+
+// Caches for bestMatch(), declared here because the top-level comparison in section 4 runs before
+// the helpers section and `const` does not hoist. See the helpers for what they hold.
+const CAND_INDEX = new Map(); // surface.file -> candidate lines, sorted by length, bigrams prebuilt
+const ALL_INDEX = new Map(); // surface.file -> EVERY line of the surface, same shape. Refresh only.
+const MATCH_MEMO = new Map(); // "<file> <baseline hash> <text>" -> the bestMatch result for that ask
+
+// ---------------------------------------------------------------------------
+// 1. read both surfaces and blank the GENERATED regions
+// ---------------------------------------------------------------------------
+// Blanking keeps line numbering true: each match becomes the same number of newlines, so every
+// file:line the guard prints is the real line number in the real file.
+//
+// The generated lines are NOT thrown away. They go into GEN_LINES, which is used for ONE thing: to
+// word the note when a line leaves BOTH surfaces and the library already carries the same text.
+// GEN_LINES never suppresses a failure — see section 4b for why that was wrong.
+
+const GEN_LINES = new Set(); // hashes of every line inside a generated region, either file
+
+// Marker-delimited generated regions. Every one of these markers is written by a script and appears
+// at most once per file, so a plain regex is safe here.
+const MARKED = [
+  // both files — the prompt-cap table written into BOTH by scripts/probe-prompt-caps.mjs. It is
+  // generated identically into the two surfaces, so a one-sided edit is not reachable by hand.
+  { name: "PROMPT-CAPS table", re: /\/\* === PROMPT-CAPS-BEGIN === \*\/[\s\S]*?\/\* === PROMPT-CAPS-END === \*\//g },
+  // index.html — generated i18n maps (scripts/translate-updates.mjs + gen-lang-pages.mjs feed them).
+  { name: "I18N-MAPS", re: /\/\* === I18N-MAPS-BEGIN[\s\S]*?\/\* === I18N-MAPS-END === \*\//g },
+  // index.html — the Runware AIR table written by scripts/update-runware-airs.mjs.
+  { name: "RUNWARE-AIRS", re: /\/\* === RUNWARE-AIRS-BEGIN === \*\/[\s\S]*?\/\* === RUNWARE-AIRS-END === \*\//g },
+];
+
+// play.html — the whole nanoodle-js bundle written by scripts/gen-js-engine.mjs. It carries the
+// LIBRARY's copy of resizePlan / MP4CAT / prompt caps. Counting it would book the library as hand
+// duplication.
+//
+// The block is identified by its data-hash, NOT by a lazy `<script ...>...</script>` match. play.html
+// also contains the STRING LITERAL that the export builder uses to re-emit the tag:
+//   const engTag = engText ? '<script id="njs-engine">\n' + ...
+// Every `</script` inside RUNTIME_JS is written escaped as `<\/script`, so a lazy match that starts
+// on that literal does not close until the LAST real `</script>` in the file. That blanked 2,398
+// lines of hand-written player code — boot(), the export builder, the balance cache, the
+// __appready__ handoff, the model picker — and made a one-sided edit anywhere in them invisible.
+//
+// scripts/gen-js-engine.mjs:165 writes data-hash = sha256(bundle).slice(0,16). We re-derive it. A
+// quoted string inside RUNTIME_JS cannot forge a body whose sha256 matches its own declared hash.
+const NJS_BLOCK = /<script id="njs-engine" data-hash="([0-9a-f]{16})">\n([\s\S]*?)\n<\/script>/g;
+
+const blanks = (m) => "\n".repeat((m.match(/\n/g) || []).length);
+
+function collectGenerated(text) {
+  for (const line of text.split("\n")) {
+    const t = line.trim();
+    if (t.length > MIN_LEN) GEN_LINES.add(hash(t));
+  }
+}
+
+function blankGenerated(src, file) {
+  let out = src.replace(NJS_BLOCK, (m, declared, body) => {
+    const actual = hash16(body);
+    if (actual !== declared) {
+      fail(
+        `${file}: the generated njs-engine block does not match its own data-hash ` +
+          `(declared ${declared}, content hashes to ${actual}).\n` +
+          `      That block is generated — it must not be hand edited. Regenerate it:\n` +
+          `        node scripts/gen-js-engine.mjs`
+      );
+      return m; // leave it in place; the guard is failing anyway
+    }
+    collectGenerated(body);
+    return blanks(m);
+  });
+  for (const g of MARKED) {
+    out = out.replace(g.re, (m) => {
+      collectGenerated(m);
+      return blanks(m);
+    });
+  }
+  return out;
+}
+
+function loadSurface(file) {
+  const path = join(ROOT, file);
+  if (!existsSync(path)) {
+    fail(`${file} is missing — cannot measure twin drift`);
+    return null;
+  }
+  const raw = readFileSync(path, "utf8");
+  const lines = blankGenerated(raw, file).split("\n");
+  // hash -> { text, at: [1-based line numbers], raw: Set of the UNSTRIPPED text of each occurrence }
+  // at.length IS the occurrence count. `raw` is for the STATS block only: it is what lets the stats
+  // say how many twins are identical WITH their indentation and how many are identical only after
+  // the strip.
+  const sig = new Map();
+  lines.forEach((line, i) => {
+    const t = line.trim();
+    if (t.length <= MIN_LEN) return;
+    const h = hash(t);
+    const e = sig.get(h);
+    if (e) { e.at.push(i + 1); e.raw.add(line); }
+    else sig.set(h, { text: t, at: [i + 1], raw: new Set([line]) });
+  });
+  return { file, lines, sig };
+}
+
+function hash(s) {
+  return createHash("sha256").update(s, "utf8").digest("hex").slice(0, 16);
+}
+const hash16 = hash;
+
+const IDX = loadSurface("index.html");
+const PLAY = loadSurface("play.html");
+if (failures.length) report();
+
+// ---------------------------------------------------------------------------
+// 2. the shared set
+// ---------------------------------------------------------------------------
+const sharedNow = [];
+for (const h of IDX.sig.keys()) if (PLAY.sig.has(h)) sharedNow.push(h);
+sharedNow.sort();
+const sharedNowSet = new Set(sharedNow);
+
+const nIdx = (h) => IDX.sig.get(h).at.length;
+const nPlay = (h) => PLAY.sig.get(h).at.length;
+
+const occIdx = sharedNow.reduce((n, h) => n + nIdx(h), 0);
+const occPlay = sharedNow.reduce((n, h) => n + nPlay(h), 0);
+
+// A baseline entry is
+//   "<hash> <occ in index.html> <occ in play.html> <look-alikes in index.html> <look-alikes in
+//    play.html> <the stripped line>",
+// each look-alike field being "-" or a comma-separated list of hashes.
+// Encoding the counts, the look-alikes and the text INTO the line list means the stored digest
+// covers them too, and the hash is a checksum of the text: the reader re-hashes the text and refuses
+// an entry whose hash does not describe it, so the stored text cannot be hand-swapped for a
+// friendlier line.
+//
+// THE LOOK-ALIKE SET is every OTHER line already on that surface that scores DRIFT_SIMILARITY or
+// more against this line. It is the guard's memory of what the tree looked like when the baseline
+// was written, and section 4b needs it: a "replacement" that was already there replaces nothing.
+// It is written at refresh only, because it costs a full scan of both surfaces per baseline line.
+const lookOf = (h, surface) => {
+  const out = lookAlikes(IDX.sig.get(h).text, h, surface);
+  return out.length ? out.join(",") : "-";
+};
+const entryOf = (h) =>
+  `${h} ${nIdx(h)} ${nPlay(h)} ${lookOf(h, IDX)} ${lookOf(h, PLAY)} ${IDX.sig.get(h).text}`;
+
+// Every figure docs/twin-drift.md quotes about the shared set is printed here, so the document can
+// be re-verified with one command instead of trusted:
+//   TWIN_DRIFT_STATS=1 node scripts/check-twin-drift.mjs
+// This only prints. It never changes what the guard fails on.
+if (process.env.TWIN_DRIFT_STATS) {
+  const multiIdx = sharedNow.filter((h) => nIdx(h) > 1).length;
+  const multiPlay = sharedNow.filter((h) => nPlay(h) > 1).length;
+  const multiEither = sharedNow.filter((h) => nIdx(h) > 1 || nPlay(h) > 1).length;
+  const alsoInBundle = sharedNow.filter((h) => GEN_LINES.has(h)).length;
+  const sameRaw = sharedNow.filter((h) => {
+    const b = PLAY.sig.get(h).raw;
+    for (const r of IDX.sig.get(h).raw) if (b.has(r)) return true;
+    return false;
+  }).length;
+  console.log(
+    `  stats: ${sharedNow.length} distinct shared lines, ${occIdx} occurrences in index.html, ` +
+      `${occPlay} in play.html\n` +
+      `  stats: ${multiEither} appear more than once inside a surface ` +
+      `(${multiIdx} in index.html, ${multiPlay} in play.html)\n` +
+      `  stats: ${sameRaw} are identical WITH their indentation; the other ${sharedNow.length - sameRaw}\n` +
+      `         match only after the leading/trailing whitespace strip, because play.html nests the\n` +
+      `         same code deeper\n` +
+      `  stats: ${alsoInBundle} are ALSO carried by the generated njs-engine bundle while both hand\n` +
+      `         copies stay live — that is why bundle text presence is not proof of extraction`
+  );
+}
+
+// ---------------------------------------------------------------------------
+// 3. refresh mode
+// ---------------------------------------------------------------------------
+if (process.env.TWIN_DRIFT_UPDATE) {
+  const nowEntries = sharedNow.map(entryOf);
+  const digest = createHash("sha256").update(nowEntries.join("\n")).digest("hex").slice(0, 32);
+  const next = {
+    _comment: [
+      "Baseline for scripts/check-twin-drift.mjs — the hand-maintained duplication between",
+      "index.html and play.html. `count` is a RATCHET: extraction may lower it freely, new",
+      "duplication may not raise it silently. Each `lines` entry is `<hash> <n in index.html>",
+      "<n in play.html> <look-alikes in index.html> <look-alikes in play.html> <the line>`, where the",
+      "hash is a 16-hex sha256 of the stripped line and the guard re-hashes the text to prove the two",
+      "agree. The per-surface counts matter: a line that appears twice in one file can be edited in",
+      "one place and still be present. The text matters: without it the guard cannot tell a real",
+      "extraction from a line that both surfaces replaced with DIFFERENT text. The look-alike sets",
+      "matter: they are the hashes of the lines that ALREADY resembled this one when the baseline was",
+      "written, and without them the guard reads one of those as a `replacement` and fails a plain",
+      "mirrored deletion. `-` means none. Do not hand edit this file.",
+      "Refresh deliberately with: TWIN_DRIFT_UPDATE=1 node scripts/check-twin-drift.mjs",
+      "Ranked extraction plan: docs/twin-drift.md",
+    ].join(" "),
+    count: sharedNow.length,
+    occurrencesIndexHtml: occIdx,
+    occurrencesPlayHtml: occPlay,
+    digest,
+    lines: nowEntries,
+  };
+  writeFileSync(BASELINE, JSON.stringify(next, null, 2) + "\n");
+  console.log(
+    `✓ twin-drift baseline written → ${relative(ROOT, BASELINE)}\n` +
+      `  ${sharedNow.length} distinct shared lines (${occIdx} in index.html, ${occPlay} in play.html), digest ${digest}`
+  );
+  process.exit(0);
+}
+
+if (!existsSync(BASELINE)) {
+  fail(
+    `baseline missing (${relative(ROOT, BASELINE)}) — create it deliberately:\n` +
+      `      TWIN_DRIFT_UPDATE=1 node scripts/check-twin-drift.mjs`
+  );
+  report();
+}
+
+let baseline;
+try {
+  baseline = JSON.parse(readFileSync(BASELINE, "utf8"));
+} catch (e) {
+  fail(`baseline is not valid JSON (${relative(ROOT, BASELINE)}) — ${e.message}`);
+  report();
+}
+const baseLines = Array.isArray(baseline.lines) ? baseline.lines : [];
+if (!baseLines.length) {
+  fail(
+    `baseline has no "lines" array (${relative(ROOT, BASELINE)}) — regenerate it:\n` +
+      `      TWIN_DRIFT_UPDATE=1 node scripts/check-twin-drift.mjs`
+  );
+  report();
+}
+// hash -> [occurrences in index.html, occurrences in play.html]
+const baseCount = new Map();
+// hash -> the stripped text of that line, as it stood when the baseline was written. Section 4b
+// needs it: a line gone from BOTH surfaces has no text left in either file to compare against.
+const baseText = new Map();
+// hash -> { "index.html": Set of hashes, "play.html": Set of hashes } — the lines that already
+// looked like this one when the baseline was written. Section 4b subtracts them from the candidate
+// replacements, which is the whole difference between a mirrored deletion and a divergent edit.
+const baseLook = new Map();
+const HASHES = "(?:-|[0-9a-f]{16}(?:,[0-9a-f]{16})*)";
+const ENTRY = new RegExp(`^([0-9a-f]{16}) ([1-9][0-9]*) ([1-9][0-9]*) (${HASHES}) (${HASHES}) (.+)$`);
+const hashSet = (field) => new Set(field === "-" ? [] : field.split(","));
+let mismatched = 0;
+for (const raw of baseLines) {
+  const m = ENTRY.exec(String(raw).trimEnd());
+  if (!m) continue;
+  // The hash is the checksum of the text. An entry whose text does not hash to its own hash was
+  // hand edited, and every rule below would then be measuring the wrong line.
+  if (hash(m[6]) !== m[1]) { mismatched++; continue; }
+  baseCount.set(m[1], [Number(m[2]), Number(m[3])]);
+  baseText.set(m[1], m[6]);
+  baseLook.set(m[1], { "index.html": hashSet(m[4]), "play.html": hashSet(m[5]) });
+}
+if (baseCount.size !== baseLines.length) {
+  fail(
+    `baseline has ${baseLines.length - baseCount.size} unusable "lines" entries ` +
+      `(${relative(ROOT, BASELINE)}), ${mismatched} of them because the stored text does not hash\n` +
+      `      to the stored hash. Each entry must be "<16-hex hash> <n index> <n play>\n` +
+      `      <look-alikes in index.html> <look-alikes in play.html> <the line>".\n` +
+      `      Regenerate: TWIN_DRIFT_UPDATE=1 node scripts/check-twin-drift.mjs`
+  );
+  report();
+}
+const baseSet = new Set(baseCount.keys());
+
+// The ratchet number is DERIVED from the `lines` array. It is never read from the file.
+// The stored digest hashes `lines` only, so a hand-raised `count:` field would otherwise lift the
+// ratchet with no digest mismatch at all — and the count is the one number this guard advertises as
+// a ratchet. Deriving it means the file cannot disagree with itself. The `count`,
+// `occurrencesIndexHtml` and `occurrencesPlayHtml` fields stay in the JSON for a human reader, and
+// the guard fails if any of them stops describing `lines`.
+const baseTotal = baseSet.size;
+const baseOccIdx = [...baseCount.values()].reduce((n, c) => n + c[0], 0);
+const baseOccPlay = [...baseCount.values()].reduce((n, c) => n + c[1], 0);
+for (const [field, stored, derived] of [
+  ["count", baseline.count, baseTotal],
+  ["occurrencesIndexHtml", baseline.occurrencesIndexHtml, baseOccIdx],
+  ["occurrencesPlayHtml", baseline.occurrencesPlayHtml, baseOccPlay],
+]) {
+  if (stored === undefined) continue;
+  if (Number(stored) !== derived) {
+    fail(
+      `baseline "${field}" says ${stored}, but its own "lines" array says ${derived} ` +
+        `(${relative(ROOT, BASELINE)}) — hand edited?\n` +
+        `      The guard uses the derived number, so this edit did not move the ratchet.\n` +
+        `      Regenerate: TWIN_DRIFT_UPDATE=1 node scripts/check-twin-drift.mjs`
+    );
+    report();
+  }
+}
+
+// ---------------------------------------------------------------------------
+// 4. compare
+// ---------------------------------------------------------------------------
+const left = [...baseSet].filter((h) => !sharedNowSet.has(h)).sort();
+const entered = sharedNow.filter((h) => !baseSet.has(h));
+
+// --- 4a. GROWTH: the ratchet only turns one way. ---------------------------
+// The ratchet is on the COUNT, not on set membership. That is deliberate. When a developer does the
+// RIGHT thing and mirrors an edit into both surfaces, the old line leaves the set and the new line
+// enters it: membership changes, the count does not. Failing that case would punish the exact
+// behaviour this guard asks for, and a guard that cries wolf gets bypassed. So membership changes
+// only print a note; a HIGHER count fails.
+const enteredList = (n) =>
+  entered.slice(0, n).map((h) => {
+    const a = IDX.sig.get(h), b = PLAY.sig.get(h);
+    return `        index.html:${a.at[0]} / play.html:${b.at[0]}  ${clip(a.text)}`;
+  });
+
+if (sharedNow.length > baseTotal) {
+  const shown = enteredList(12);
+  fail(
+    `duplication went UP: ${baseTotal} → ${sharedNow.length} shared lines ` +
+      `(${entered.length} entered, ${left.length} left).\n` +
+      `      Every new shared line is a line some future edit must change in two places.\n` +
+      `      Put the code in ONE surface, or route it through the nanoodle-js bundle\n` +
+      `      (scripts/gen-js-engine.mjs — see docs/twin-drift.md for what is already extractable).\n` +
+      `      If the duplication is deliberate, raise the ratchet on purpose:\n` +
+      `        TWIN_DRIFT_UPDATE=1 node scripts/check-twin-drift.mjs\n` +
+      shown.join("\n") +
+      (entered.length > shown.length ? `\n        … and ${entered.length - shown.length} more` : "")
+  );
+} else if (entered.length) {
+  const shown = enteredList(6);
+  notes.push(
+    `${entered.length} line(s) entered the shared set while the count held at ` +
+      `${sharedNow.length} (${baseTotal} before) — this is what a correctly MIRRORED edit\n` +
+      `    looks like. Refresh the baseline so the new twins are tracked:\n` +
+      `      TWIN_DRIFT_UPDATE=1 node scripts/check-twin-drift.mjs\n` +
+      shown.join("\n") +
+      (entered.length > shown.length ? `\n        … and ${entered.length - shown.length} more` : "")
+  );
+}
+
+// --- 4b. departures: DRIFT / one-sided DELETION / DIVERGENCE (fail) vs EXTRACTION (allowed) ---
+// A baseline line can leave the shared set four ways.
+//   DRIFT       the line is still on both surfaces, but one side EDITED it. The keeper still carries
+//               the original; the mover carries a NEW near-identical variant.
+//   DELETION    the line is gone from one surface and still LIVE on the other, and no NEW
+//               near-identical line replaced it. The code did not move — one engine stopped doing it
+//               and the other did not. Calling that "deduplication" was a lie: it IS drift.
+//   DIVERGENCE  the line is gone from BOTH surfaces, and EACH surface now carries its own NEW
+//               near-identical replacement, and the 2 replacements look like each other as well.
+//               Two replacements that survive that test are always DIFFERENT from each other:
+//               identical replacements would be in the shared set, and candidatesOf() excludes every
+//               shared line. So both engines still do the work, and they now do it differently. This
+//               is the drift the guard exists to catch and it must fail. It reaches here through no
+//               fault of its own — a divergent 2-sided edit does remove the twin from both files,
+//               and "left both surfaces" alone cannot tell it from real extraction.
+//   EXTRACTION  every other departure from both surfaces. Allowed, note only. This reading also
+//               covers the old half of a correctly mirrored edit, because the new twin is shared and
+//               is therefore not a candidate replacement — the note names both readings instead of
+//               guessing between them.
+//
+// THE RULE. Leaving both surfaces is NOT what makes a departure an extraction. Leaving both
+// surfaces WHILE THE TWO SURFACES STILL AGREE is. "Agree" is decided by the same near-identical
+// match the DRIFT rule already uses (bestMatch, Dice over character bigrams, DRIFT_SIMILARITY), run
+// once against each surface, PLUS the same test between the 2 replacements themselves. The baseline
+// therefore has to store the departed line's TEXT: nothing in either file carries it any more.
+//
+// NEW IS PART OF THE RULE, and leaving it out is what made the guard fail correct work. A candidate
+// replacement only counts if its text was NOT already on that surface when the baseline was
+// written — that is what baseLook holds. Deleting a twin block from both surfaces and editing a twin
+// divergently on both surfaces produce trees that differ in exactly one way: the divergent edit ADDS
+// text. Every other signal is shared between them. Without the look-alike sets the guard matched a
+// departing twin against whatever coincidentally survived, and coincidences are not rare in a
+// 26,000-line house style: the baseline stores 798 look-alike hashes over the 893 lines, and 219 of
+// those lines have at least 1 look-alike before anything is edited at all. Deleting the block ranges
+// docs/twin-drift.md itself recommends, from BOTH surfaces, then failed 4 of its own 9 planned
+// extractions —
+//   row 1 "Resize and crop geometry" 2 false divergences, row 3 one, row 7 one, row 8 two.
+// (Measured by running this guard with baseLook switched off, which is what the first rule was,
+// against the ranges the work list publishes TODAY. An earlier note said row 7 raised three. That
+// figure belongs to row 7's OLD ranges, play.html:6635-6679 + 6979-7169, which the work list no
+// longer publishes; the corrected ranges raise 1. Either way the headline is 4 of the 9 rows.)
+// Row 1 is the plainest case there is (sig = deletes = 25, a pure mirrored removal), and the guard
+// called it divergence, naming as the "replacements" 2 canvas lines that had been sitting at
+// index.html:7130 and play.html:9763 all along. scripts/check-twin-drift-cases.mjs holds all 9. With
+// the look-alike sets those 4 rows report NOTHING, the divergent-edit case still exits 1, and 8 of
+// the 9 rows are silent. Row 8 still exits 1, and correctly: it is not divergence (that count is 0
+// on all 9 rows) but 5 ONE-SIDED DELETIONS plus 1 occurrence drift, because 5 twins inside the 2
+// share blocks keep their other copy in unrelated code on 1 surface only. No range change can mirror
+// that row — index.html inlines play.html's explicitLang() body, and play.html's thumbnail helper
+// re-uses 2 of the packer's canvas lines. Row 8 is a deliberate baseline refresh, not a guard bug.
+//
+// WHAT THAT RULE STILL LETS THROUGH, and why. The 3-way test is deliberately narrow. A departure
+// where only ONE surface keeps a near-identical line does NOT fail. It looks like divergence in
+// principle — 1 engine edited the work, the other stopped doing it — and an earlier draft of this
+// rule failed it. Measured against a real extraction control (delete the whole MP4CAT block,
+// index.html:9210-9487 and play.html:6676-6953, 123 shared lines gone from both surfaces at once),
+// that draft raised a FALSE failure on 1 of the 123: the banner comment
+//   /* ---- Lossless in-browser mp4 concatenation (Combine node) -------------------------------
+// scored 0.840 against the unrelated surviving banner at index.html:9197
+//   /* ---- in-browser video concatenation (the Combine node) ---------------------------------
+// because a run of dashes carries the bigram profile and the 2 banners share their opening words.
+// A guard that fails a correct extraction is a guard that gets bypassed. So a
+// single-sided match alone is not enough; the 2 replacements must also look like each other, which
+// is what makes them 2 versions of ONE line instead of 2 coincidences. The blind spot is real and
+// docs/twin-drift.md states it. Note that the look-alike sets close that particular case as well —
+// both banners are in each other's set — but condition 3 stays, because it is the cheaper guarantee
+// and it does not depend on the baseline being fresh.
+//
+// GEN_LINES IS NOT AN EXEMPTION FROM ANYTHING. Presence of the same text inside the generated
+// bundle is a property of the tree TODAY, not evidence that anything moved: 131 of the 893 baseline
+// lines are identical to a line already inside the bundle while BOTH hand copies are still live
+// (MP4CAT, the pricing resolver, resize geometry — the library ships them too). Treating that text
+// presence as "extracted" exited 0 on a one-sided deletion of live MP4CAT code, and — one level
+// down — on a 2-sided DIVERGENT edit of the same line. The bundle now only sharpens the wording of
+// the note on a departure that is already classified as extraction; it never suppresses a failure.
+const drifted = [];
+const removed = [];
+const diverged = [];
+let extracted = 0;
+let vanished = 0;
+
+if (left.length > MAX_CLASSIFY) {
+  fail(
+    `${left.length} baseline lines left the shared set (baseline count ${baseTotal}, now ${sharedNow.length}).\n` +
+      `      That is too large a move to attribute line by line. Review the diff, then refresh:\n` +
+      `        TWIN_DRIFT_UPDATE=1 node scripts/check-twin-drift.mjs`
+  );
+} else {
+  for (const h of left) {
+    const inIdx = IDX.sig.get(h);
+    const inPlay = PLAY.sig.get(h);
+    if (inIdx && inPlay) continue; // still shared — cannot happen, guard anyway
+    if (!inIdx && !inPlay) {
+      // Gone from BOTH hand-maintained surfaces. Extraction ONLY IF the surfaces still agree.
+      const was = baseText.get(h);
+      const repIdx = bestMatch(was, IDX, h);
+      const repPlay = bestMatch(was, PLAY, h);
+      if (repIdx && repPlay) {
+        const pair = dice(bigrams(repIdx.text), bigrams(repPlay.text));
+        if (pair >= DRIFT_SIMILARITY) { diverged.push({ was, repIdx, repPlay, pair }); continue; }
+      }
+      if (GEN_LINES.has(h)) extracted++;
+      else vanished++;
+      continue;
+    }
+    const keeper = inIdx ? IDX : PLAY;
+    const mover = inIdx ? PLAY : IDX;
+    const text = (inIdx || inPlay).text;
+    const at = (inIdx || inPlay).at[0];
+    const cand = bestMatch(text, mover, h);
+    if (cand) { drifted.push({ keeper, mover, text, at, cand }); continue; }
+    removed.push({ keeper, mover, text, at });
+  }
+}
+
+// --- 4c. OCCURRENCE counts: a line can stay "present" and still drift ------
+// Membership by presence is not enough. 75 of the 893 shared lines appear more than once inside a
+// surface (28 in index.html, 65 in play.html).
+// Editing 1 of 2 identical copies in index.html leaves the hash present, so nothing leaves the
+// shared set — and the pricing resolver's per_duration branch is one of those lines. Counts may only
+// go DOWN, and only on both surfaces together.
+const dropped = [];
+const rose = [];
+for (const h of sharedNow) {
+  const was = baseCount.get(h);
+  if (!was) continue; // entered the set — handled by 4a
+  const dI = nIdx(h) - was[0];
+  const dP = nPlay(h) - was[1];
+  if (dI === 0 && dP === 0) continue;
+  if (dI > 0 || dP > 0) { rose.push({ h, was, now: [nIdx(h), nPlay(h)] }); continue; }
+  if (dI < 0 && dP < 0) continue; // both surfaces lost a copy together — mirrored, allowed
+  const mover = dI < 0 ? IDX : PLAY;
+  const keeper = dI < 0 ? PLAY : IDX;
+  dropped.push({ h, was, now: [nIdx(h), nPlay(h)], mover, keeper, text: IDX.sig.get(h).text });
+}
+
+// --- 4d. emit ---------------------------------------------------------------
+if (extracted || vanished) {
+  const bits = [];
+  if (vanished) bits.push(`${vanished} left both surfaces (extraction, or the old half of a mirrored edit)`);
+  if (extracted) bits.push(`${extracted} left both surfaces and are carried by the generated bundle`);
+  notes.push(
+    `${bits.join(", ")} — none of them left a near-identical\n` +
+      `    replacement on BOTH surfaces, so the surfaces still agree. The ratchet allows this. Lower\n` +
+      `    the baseline when convenient:\n` +
+      `    TWIN_DRIFT_UPDATE=1 node scripts/check-twin-drift.mjs`
+  );
+}
+
+if (diverged.length) {
+  const shown = diverged.slice(0, 12).map((d, i) => {
+    const pad = Math.max(`index.html:${d.repIdx.line}`.length, `play.html:${d.repPlay.line}`.length);
+    return (
+      `      ${i + 1}. both surfaces dropped:  ${clip(d.was)}\n` +
+      `         ${`index.html:${d.repIdx.line}`.padEnd(pad)}  ${clip(d.repIdx.text)}\n` +
+      `         ${`play.html:${d.repPlay.line}`.padEnd(pad)}  ${clip(d.repPlay.text)}`
+    );
+  });
+  fail(
+    `TWIN DIVERGENCE — ${diverged.length} line(s) left BOTH surfaces, but the surfaces no longer\n` +
+      `      AGREE: each one replaced the line with its OWN different version. Leaving both surfaces\n` +
+      `      is only extraction when the 2 surfaces still agree afterwards. Both engines still run\n` +
+      `      this code, and they now run it differently. Mirror the edit, or delete the twin on both\n` +
+      `      surfaces.\n` +
+      shown.join("\n") +
+      (diverged.length > shown.length ? `\n      … and ${diverged.length - shown.length} more` : "") +
+      `\n      If the two surfaces are MEANT to diverge here, say so deliberately:\n` +
+      `        TWIN_DRIFT_UPDATE=1 node scripts/check-twin-drift.mjs`
+  );
+}
+
+if (drifted.length) {
+  const shown = drifted.slice(0, 12).map((d, i) => {
+    const keptAt = `${d.keeper.file}:${d.at}`;
+    const movedAt = `${d.mover.file}:${d.cand.line}`;
+    const pad = Math.max(keptAt.length, movedAt.length);
+    return (
+      `      ${i + 1}. ${keptAt.padEnd(pad)}  ${clip(d.text)}\n` +
+      `         ${movedAt.padEnd(pad)}  ${clip(d.cand.text)}`
+    );
+  });
+  fail(
+    `TWIN DRIFT — ${drifted.length} line(s) that both engines carried identically now differ.\n` +
+      `      One surface was edited and the other was not. Mirror the edit, or delete the twin.\n` +
+      shown.join("\n") +
+      (drifted.length > shown.length ? `\n      … and ${drifted.length - shown.length} more` : "") +
+      `\n      If the two surfaces are MEANT to diverge here, say so deliberately:\n` +
+      `        TWIN_DRIFT_UPDATE=1 node scripts/check-twin-drift.mjs`
+  );
+}
+
+if (removed.length) {
+  const shown = removed.slice(0, 12).map((d, i) => {
+    return (
+      `      ${i + 1}. gone from ${d.mover.file}, still live at ${d.keeper.file}:${d.at}\n` +
+      `         ${clip(d.text)}`
+    );
+  });
+  fail(
+    `ONE-SIDED DELETION — ${removed.length} line(s) left one surface and are still live on the other.\n` +
+      `      Nothing near-identical replaced them, so this is not extraction: 1 engine stopped doing\n` +
+      `      the work and the other still does it. Delete the twin too, or put the line back.\n` +
+      shown.join("\n") +
+      (removed.length > shown.length ? `\n      … and ${removed.length - shown.length} more` : "") +
+      `\n      If the two surfaces are MEANT to diverge here, say so deliberately:\n` +
+      `        TWIN_DRIFT_UPDATE=1 node scripts/check-twin-drift.mjs`
+  );
+}
+
+if (dropped.length) {
+  const shown = dropped.slice(0, 12).map((d, i) => {
+    const cand = bestMatch(d.text, d.mover, d.h);
+    const where = d.mover.sig.get(d.h).at.join(", ");
+    return (
+      `      ${i + 1}. ${d.mover.file} went from ${d.was[d.mover === IDX ? 0 : 1]} to ` +
+      `${d.now[d.mover === IDX ? 0 : 1]} copies; ${d.keeper.file} still has ` +
+      `${d.now[d.keeper === IDX ? 0 : 1]}\n` +
+      `         kept at ${d.mover.file}:${where}  ${clip(d.text)}\n` +
+      (cand ? `         edited to ${d.mover.file}:${cand.line}  ${clip(cand.text)}\n` : "")
+    ).trimEnd();
+  });
+  fail(
+    `TWIN DRIFT (occurrence count) — ${dropped.length} shared line(s) lost a copy on 1 surface only.\n` +
+      `      The line is still present, so the shared set did not change — but 1 of its call sites\n` +
+      `      was edited or deleted and the other engine kept all of its own. Mirror it.\n` +
+      shown.join("\n") +
+      (dropped.length > shown.length ? `\n      … and ${dropped.length - shown.length} more` : "") +
+      `\n      If the two surfaces are MEANT to diverge here, say so deliberately:\n` +
+      `        TWIN_DRIFT_UPDATE=1 node scripts/check-twin-drift.mjs`
+  );
+}
+
+if (rose.length) {
+  const shown = rose.slice(0, 12).map((d, i) => {
+    const a = IDX.sig.get(d.h);
+    return (
+      `      ${i + 1}. index.html ${d.was[0]}→${d.now[0]}, play.html ${d.was[1]}→${d.now[1]}` +
+      `  ${clip(a.text)}`
+    );
+  });
+  fail(
+    `duplication went UP: ${rose.length} shared line(s) gained a copy.\n` +
+      `      The distinct count held, so the ratchet in 4a did not see it. A second copy of a line\n` +
+      `      that already lives on both surfaces is a third place a future edit must reach.\n` +
+      shown.join("\n") +
+      (rose.length > shown.length ? `\n      … and ${rose.length - shown.length} more` : "") +
+      `\n      If the duplication is deliberate, raise the ratchet on purpose:\n` +
+      `        TWIN_DRIFT_UPDATE=1 node scripts/check-twin-drift.mjs`
+  );
+}
+
+// --- 4e. cheap sanity: the stored digest must describe the stored lines ----
+// The digest is REQUIRED, not optional. `if (baseline.digest && …)` made deleting the field a way to
+// switch the whole check off, which is the same hand-edit escape the derived `count` closes: inflate
+// a line's stored occurrence counts, move `occurrencesIndexHtml` and `occurrencesPlayHtml` to match,
+// drop `digest`, and the ratchet rises on a clean tree with exit 0. A missing digest is an error.
+const baseDigest = createHash("sha256").update([...baseLines].sort().join("\n")).digest("hex").slice(0, 32);
+if (typeof baseline.digest !== "string" || !/^[0-9a-f]{32}$/.test(baseline.digest)) {
+  fail(
+    `baseline has no usable "digest" field (${relative(ROOT, BASELINE)}) — it is required, because it\n` +
+      `      is the only thing that pins the per-line occurrence counts and the stored text.\n` +
+      `      Regenerate: TWIN_DRIFT_UPDATE=1 node scripts/check-twin-drift.mjs`
+  );
+} else if (baseline.digest !== baseDigest) {
+  fail(
+    `baseline digest does not match its own "lines" array (${relative(ROOT, BASELINE)}) — hand edited?\n` +
+      `      Regenerate: TWIN_DRIFT_UPDATE=1 node scripts/check-twin-drift.mjs`
+  );
+}
+
+report();
+
+// ---------------------------------------------------------------------------
+// helpers
+// ---------------------------------------------------------------------------
+
+// Dice coefficient over character bigrams. Deterministic, dependency-free.
+//
+// A bigram is packed into 1 integer (first char << 16 | second char) and the profile of a line is
+// 2 sorted typed arrays: the bigram keys, and how many times each occurs. Sorted keys let dice()
+// intersect 2 profiles with a plain merge over integers. The earlier Map-of-2-character-strings
+// version paid a string hash per lookup, and this is the inner loop of the whole guard.
+function bigrams(s) {
+  const counts = new Map();
+  for (let i = 0; i < s.length - 1; i++) {
+    const g = (s.charCodeAt(i) << 16) | s.charCodeAt(i + 1);
+    counts.set(g, (counts.get(g) || 0) + 1);
+  }
+  const keys = Int32Array.from(counts.keys()).sort();
+  const mult = new Int32Array(keys.length);
+  let size = 0;
+  for (let i = 0; i < keys.length; i++) {
+    mult[i] = counts.get(keys[i]);
+    size += mult[i];
+  }
+  return { keys, mult, size };
+}
+function dice(a, b) {
+  if (a.size === 0 || b.size === 0) return 0;
+  const ak = a.keys, bk = b.keys, an = ak.length, bn = bk.length;
+  let i = 0, j = 0, hits = 0;
+  while (i < an && j < bn) {
+    const x = ak[i], y = bk[j];
+    if (x === y) {
+      const m = a.mult[i], n = b.mult[j];
+      hits += m < n ? m : n;
+      i++; j++;
+    } else if (x < y) i++;
+    else j++;
+  }
+  return (2 * hits) / (a.size + b.size);
+}
+
+// Candidate index, built ONCE per surface.
+//
+// bestMatch used to rebuild the bigram map of every candidate line on every call, so the cost was
+// O(departures x lines-in-the-mover x line-length). A clean tree never sees it, because nothing
+// departs. A big mirrored-but-not-quite refactor does: at the MAX_CLASSIFY ceiling of 200
+// departures the guard took 23-30 s while the header promised "well under 2 seconds". It was
+// bounded, not hung, but that is the wrong surprise to hand a developer mid-refactor.
+// Building each candidate's bigram profile once, and sorting the candidates by length so the length
+// band becomes a binary-searched slice, took the same case to seconds instead of half a minute. The
+// classification output is byte-identical before and after. RUNTIME in the header has the numbers
+// this branch measured.
+function candidatesOf(mover) {
+  let list = CAND_INDEX.get(mover.file);
+  if (list) return list;
+  list = [];
+  for (const [h, e] of mover.sig) {
+    // A shared line is a twin in its own right, not the replacement we are hunting.
+    if (sharedNowSet.has(h)) continue;
+    list.push({ h, text: e.text, line: e.at[0], len: e.text.length, grams: bigrams(e.text) });
+  }
+  list.sort((x, y) => x.len - y.len || x.line - y.line);
+  CAND_INDEX.set(mover.file, list);
+  return list;
+}
+
+// EVERY line of a surface, in the same shape. Refresh mode only: the look-alike set has to remember
+// the shared lines too, because a line that is shared today can stop being shared tomorrow and would
+// then become a candidate replacement for a departing twin.
+function allOf(surface) {
+  let list = ALL_INDEX.get(surface.file);
+  if (list) return list;
+  list = [];
+  for (const [h, e] of surface.sig) {
+    list.push({ h, text: e.text, line: e.at[0], len: e.text.length, grams: bigrams(e.text) });
+  }
+  list.sort((x, y) => x.len - y.len || x.line - y.line);
+  ALL_INDEX.set(surface.file, list);
+  return list;
+}
+
+// Every OTHER line on `surface` that already scores DRIFT_SIMILARITY or more against `text`.
+// Written into the baseline at refresh; read by section 4b as "these are not replacements, they
+// were here first". Sorted, so the baseline entry is stable between runs.
+function lookAlikes(text, selfHash, surface) {
+  const aGrams = bigrams(text);
+  const list = allOf(surface);
+  const hi = text.length * 1.7;
+  const out = [];
+  for (let i = lowerBound(list, text.length * 0.6); i < list.length && list[i].len <= hi; i++) {
+    if (list[i].h === selfHash) continue;
+    if (dice(aGrams, list[i].grams) >= DRIFT_SIMILARITY) out.push(list[i].h);
+  }
+  return out.sort();
+}
+
+// First index in the length-sorted list whose len >= target.
+function lowerBound(list, target) {
+  let lo = 0, hi = list.length;
+  while (lo < hi) {
+    const mid = (lo + hi) >> 1;
+    if (list[mid].len < target) lo = mid + 1;
+    else hi = mid;
+  }
+  return lo;
+}
+
+// Find the line in `mover` that looks like an edited copy of the baseline line `baseHash`, whose
+// stored text is `text`. A candidate must not itself be in the shared set, must be within a
+// plausible length band of the original, and must be NEW: a line that already looked like this one
+// when the baseline was written replaces nothing, it was there first. Results are memoised per
+// (surface, baseline line), because the occurrence-drift report asks for the same match again.
+function bestMatch(text, mover, baseHash) {
+  const key = mover.file + "\u0000" + baseHash + "\u0000" + text;
+  if (MATCH_MEMO.has(key)) return MATCH_MEMO.get(key);
+  // The look-alike set the baseline stored for THIS line on THIS surface: text that was already
+  // here when the baseline was written, and that therefore replaced nothing.
+  const already = (baseLook.get(baseHash) || {})[mover.file] || new Set();
+  const aGrams = bigrams(text);
+  const list = candidatesOf(mover);
+  const hi = text.length * 1.7;
+  let best = null;
+  for (let i = lowerBound(list, text.length * 0.6); i < list.length && list[i].len <= hi; i++) {
+    const c = list[i];
+    if (already.has(c.h)) continue;
+    const r = dice(aGrams, c.grams);
+    if (r < DRIFT_SIMILARITY) continue;
+    if (!best || r > best.ratio || (r === best.ratio && c.line < best.line)) {
+      best = { ratio: r, text: c.text, line: c.line };
+    }
+  }
+  MATCH_MEMO.set(key, best);
+  return best;
+}
+
+function clip(s) {
+  return s.length > 110 ? s.slice(0, 107) + "..." : s;
+}
+
+function report() {
+  for (const n of notes) console.log(`  note: ${n}`);
+  if (failures.length) {
+    console.error("\n✗ check-twin-drift failed:\n");
+    for (const f of failures) console.error(`  - ${f}\n`);
+    console.error(
+      `  index.html ↔ play.html duplication is tracked in ${relative(ROOT, BASELINE)}.\n` +
+        `  The ranked extraction plan is docs/twin-drift.md.\n`
+    );
+    process.exit(1);
+  }
+  console.log(
+    `✓ twin drift: ${sharedNow.length} shared lines${notes.length ? " (baseline stale — see notes)" : ", unchanged"} ` +
+      `(${occIdx} in index.html, ${occPlay} in play.html)`
+  );
+  process.exit(0);
+}
diff --git a/scripts/twin-drift-baseline.json b/scripts/twin-drift-baseline.json
new file mode 100644
index 0000000..5e2bd78
--- /dev/null
+++ b/scripts/twin-drift-baseline.json
@@ -0,0 +1,902 @@
+{
+  "_comment": "Baseline for scripts/check-twin-drift.mjs — the hand-maintained duplication between index.html and play.html. `count` is a RATCHET: extraction may lower it freely, new duplication may not raise it silently. Each `lines` entry is `<hash> <n in index.html> <n in play.html> <look-alikes in index.html> <look-alikes in play.html> <the line>`, where the hash is a 16-hex sha256 of the stripped line and the guard re-hashes the text to prove the two agree. The per-surface counts matter: a line that appears twice in one file can be edited in one place and still be present. The text matters: without it the guard cannot tell a real extraction from a line that both surfaces replaced with DIFFERENT text. The look-alike sets matter: they are the hashes of the lines that ALREADY resembled this one when the baseline was written, and without them the guard reads one of those as a `replacement` and fails a plain mirrored deletion. `-` means none. Do not hand edit this file. Refresh deliberately with: TWIN_DRIFT_UPDATE=1 node scripts/check-twin-drift.mjs Ranked extraction plan: docs/twin-drift.md",
+  "count": 893,
+  "occurrencesIndexHtml": 958,
+  "occurrencesPlayHtml": 1011,
+  "digest": "e160a17b39b786e49005c7a2126fc56b",
+  "lines": [
+    "002720750bb5da1d 1 1 - - Emphasized (bright accent ring + ✓) but still clearly a button in the row, not a filled tag. */",
+    "00a12dd8e0743550 1 1 - - const all = (Array.isArray(samples) ? samples : []).filter(s=> s && typeof s.v===\"string\");",
+    "01aae5325995f19c 1 1 422f7d6384a2929c,904e610149650be4,a7c1c8a59680286d 422f7d6384a2929c,904e610149650be4 <button id=\"agentcopy\" class=\"sm-copy\">Copy</button>",
+    "01c52dcaac5f4b4b 1 1 - - const card = await shareCardB64(longUrl);   // best-effort per-link og:image; null is fine",
+    "01ff4ba6a39c842b 1 1 - - // excluding clip-specific sample-entry boxes (btrt etc) that differ by content.",
+    "0284a7e89d704317 1 1 - - if(!url && (j.runId || j.id)) url = await pollAudio(model, j, onProgress, runKey, bodySig);   // async model → poll (resume-aware)",
+    "02e7ca1b19df827f 1 1 - - return URL.createObjectURL(new Blob([blob], { type: AUDIO_MIME[fmt] || \"audio/mpeg\" }));",
+    "0336d4ec58a1863e 1 1 - - const p = pricing || {}, c = chars ?? EST.ttsChars;",
+    "03acf78b0f805d33 1 1 - - for(const k of [\"textToVideoWithReferenceVideoPricesPerSecond\",\"standardTextToVideoWithReferenceVideoPricesPerSecond\",\"turboTextToVideoWithReferenceVideoPricesPerSecond\",",
+    "03d00fa44495b32d 1 1 f086b86053e2a392 f086b86053e2a392 function videoBaseUsd(pricing, fields, audioOn, refOn){",
+    "044ee4003c0af86c 1 1 - - // (live-confirmed 2026-07-17: kimi-k3 cut at ~4.8k output despite a 1M ceiling) — an",
+    "0471ccad0592f6c1 1 1 3e1707f592fc159a 3e1707f592fc159a return /^https?:/.test(url) ? { audioUrl:url } : { audioDataUrl: await urlToDataUrl(url) };",
+    "04d7d57c1f1128e9 2 1 - - if(ac.state === \"suspended\"){ await Promise.race([ Promise.resolve(ac.resume()).catch(()=>{}), new Promise(r=> setTimeout(r, 1500)) ]); }",
+    "0519ff33454a8997 1 1 - - if(p.duration_overrides && p.duration_overrides[dk]){ v=rp(p.duration_overrides[dk]); if(v!=null) return v; }",
+    "0603a1620dd6d318 1 1 - - if(anyCts){ const cttsRuns = rle(t.samples.map(s=>s.cts)); children.push(fullbox(\"ctts\", 0, 0, u32(cttsRuns.length), ...cttsRuns.map(r=>concat([u32(r[0]), u32(r[1]>>>0)])))); }",
+    "06aefd7d2befb475 1 2 - - const p=n.parentElement; if(!p) return NodeFilter.FILTER_REJECT;",
+    "06ce66d907de9e59 1 1 - 22ff9397f0ec793c <button id=\"signout\" class=\"link\" style=\"display:none\">sign out</button>",
+    "06d34a40890283f4 1 1 83dd58a7ee977a8d 83dd58a7ee977a8d if(txt==null) throw new Error(\"no transcription in response\");",
+    "07032545666a1930 1 1 - - var rows = nodeLoras(n).filter(function(r){ return r && (r.url||\"\").trim(); });",
+    "0733a7ba115a7795 1 1 2c118d407207b74b 2c118d407207b74b for(const l of graph.links) if(ids.has(l.from.node) && ids.has(l.to.node)){ adj[l.from.node].push(l.to.node); indeg[l.to.node]++; }",
+    "074e7f16aa65158c 1 1 - - const social = document.querySelector(\"#sharemenu .sm-social\");",
+    "07b422ca9b7fd16c 1 1 176d7b01c86bb16b,851d91a6aaca1148 176d7b01c86bb16b,851d91a6aaca1148 if(opts.audioDataUrl) body.audioDataUrl = opts.audioDataUrl;",
+    "08900228090e73be 2 2 - - return URL.createObjectURL(new Blob(chunks, { type: mime.split(\";\")[0] }));",
+    "0925f74dc9bd99c7 1 1 - - const opts = (f.modelOpts && typeof f.modelOpts===\"object\") ? f.modelOpts : {};",
+    "0963f391dc43b8ef 1 1 - - if(/klein/i.test(m)) return \"flux2klein\";",
+    "09a15bef941623cc 1 1 - - const out = MP4CAT.concatMp4(bufs, { dedup:false });",
+    "09a33a123c992e8c 1 1 - - sessionStorage.setItem(\"pkce\",JSON.stringify({verifier,state,id}));",
+    "09b0161db96cd8d6 1 1 - - // apps, and messengers reliably cut multi-kB URLs — so packShareFit keeps trimming the share",
+    "0a2688d30ac222ce 1 1 - bb3b3ff1ef459aca : \"#a=u\"+bytesToB64url(new TextEncoder().encode(json))); // 'u' = uncompressed fallback",
+    "0a866628d91d2356 1 1 - - ? box(\"vmhd\", Uint8Array.from([0,0,0,1]), new Uint8Array(8))",
+    "0abc47b739b86d4b 1 1 - - tracks.push({ kind, timescale, stsdRaw, codecCfg, samples, width, height, channels, sampleRate });",
+    "0abd4945907c81db 1 2 - - const tw=document.createTreeWalker(root, NodeFilter.SHOW_TEXT, { acceptNode(n){",
+    "0abfd56c0db3b0f0 1 1 1891c2b05109f609 1891c2b05109f609 const base = sig(ps[0]); if(!base) return false;",
+    "0b20afea6ca20b43 1 1 - 9c6030cac633481d const take = Math.max(0.05, Math.min(len>0 ? len : (dur - s), dur - s));",
+    "0b211b7b67b4f7f4 1 1 - - const req = t.match(/[\"']?([a-z_]+)[\"']?\\s+(?:is\\s+)?required|missing[^a-z]+[\"']?([a-z_]+)/i);",
+    "0b52eb85ebcd50c3 1 1 - - ? { role:\"user\", content:[{type:\"text\", text:prompt}, ...imgs.map(url=>({type:\"image_url\", image_url:{url}})), ...(aud?[aud]:[])] }",
+    "0bbd741853af1b2f 1 1 - - if(mid && vid) return \"civitai:\"+mid[1]+\"@\"+vid[1];",
+    "0bfb539d2660a313 1 1 - - const USAGE = { inTok:0, outTok:0, cost:0, exact:true };",
+    "0c33b6edf8065791 1 1 - - if(cap && /INVALID_AUDIO_DURATION|audio.{0,15}duration/i.test(msg))",
+    "0c9dd83cb3f84514 1 1 - - // Parse one mp4 into { moovTimescale, tracks:[{kind, timescale, stsdRaw, samples:[{offset,size,dur,cts,sync}], width,height}] }",
+    "0db0bcd217e46d2c 1 1 - - const st = String(s.status||\"\").toLowerCase();",
+    "0dca4edd2389a128 1 1 - - headers:{ \"Content-Type\":\"application/json\" }, body:JSON.stringify(card ? { url: longUrl, card } : { url: longUrl }),",
+    "0dd77fd79124ba97 1 1 - - const CARD_TYPE_META = { text:[\"📝\",\"Text\"], upload:[\"📷\",\"Image input\"], aupload:[\"🎤\",\"Audio input\"], vupload:[\"📹\",\"Video input\"], choice:[\"🔘\",\"Choice\"], join:[\"🔗\",\"Join\"], llm:[\"🧠\",\"LLM\"], image:[\"🖼\",\"Image\"], edit:[\"✂️\",\"Edit\"], inpaint:[\"🩹\",\"Inpaint\"], resize:[\"📐\",\"Resize / crop\"], vision:[\"👁\",\"Vision\"], tvideo:[\"🎬\",\"Text→Video\"], ivideo:[\"📽️\",\"Image→Video\"], vedit:[\"🎞️\",\"Video edit\"], vframes:[\"🎞\",\"Video → frames\"], combine:[\"🎬\",\"Combine videos\"], soundtrack:[\"🎚\",\"Soundtrack\"], lipsync:[\"🎭\",\"Avatar / lipsync\"], music:[\"🎵\",\"Music\"], remix:[\"🎛\",\"Remix audio\"], tts:[\"🗣️\",\"Speech\"], trim:[\"✂️\",\"Trim audio\"], extractaudio:[\"🔊\",\"Extract audio\"], transcribe:[\"🎙️\",\"Transcribe\"], comment:[\"💬\",\"Comment\"] };",
+    "0dedad9d18490c6f 1 1 - - // full-length link in the popover always works, so ANY failure just falls back to it.",
+    "0e77e3b00c48b5e1 1 1 - - if(opts.resolution) body.resolution = opts.resolution;",
+    "0ec5402e3b4143ae 1 1 - - if(SEED_FIELD[n.type]) return n.fields.seed;",
+    "0f3ecbe5c6624a23 1 1 - - while(q.length){ const n=q.shift(); order.push(n); for(const m of adj[n]) if(--indeg[m]===0) q.push(m); }",
+    "0fa42968079f4f8f 1 1 - - // 5s timeout) just falls back to the full-length link, which always works.",
+    "0fe3885d49c0c304 1 1 - - avoids the canvas-captureStream + audio-track path that mangled the picture. Used when every clip",
+    "101ebb687a445a38 1 1 - - if(max && longUrl.length > max) throw new Error(`link is ${(longUrl.length/1024).toFixed(0)} kB — past the ~${Math.round(max/1024)} kB ${svc===\"dagd\" ? \"da.gd serves reliably\" : \"nanolink can store\"}`);",
+    "10484b8d400ee5af 2 1 e7181a4bfa300cad b7ed1d1569549245,e7181a4bfa300cad const url = await ctx.genVideo(mdl(n), prompt, opts, null,",
+    "1050a0665582b707 1 1 - - const hdlrName = enc(t.kind===\"video\" ? \"VideoHandler\\0\" : \"SoundHandler\\0\");",
+    "106a1415f030be00 1 1 - - return [{ url:n.fields.loraUrl||\"\", strength:n.fields.loraStrength||\"\" }];",
+    "106ff7178b87b72f 1 1 - - function box(type, ...payload){ const body = concat(payload); return concat([u32(body.length + 8), enc(type), body]); }",
+    "10e3cd8184b90598 1 1 e012ed6708d8a65b,e5729e5ac8962096,ec82ef2566300245 e012ed6708d8a65b,e5729e5ac8962096,ec82ef2566300245 async function trimAudioToWavUrl(url, start, len, rate){",
+    "114e3cb9a9cb433b 1 1 - - while(i<values.length){ let j=i+1; while(j<values.length && values[j]===values[i]) j++; runs.push([j-i, values[i]]); i=j; }",
+    "115c7f356c30ae31 1 1 - - if(tn && (tn.type===\"music\"||tn.type===\"tts\") && l.to.port===\"text\") l.to.port=\"prompt\";",
+    "120708ce63f59d99 1 1 - - const out = { url: fitT.url, hasSample: fitT.s.length>0, stripped: fitT.stripped };",
+    "124a0780bc80e800 1 1 - - if((n.fields.system||\"\").trim()) messages.push({role:\"system\", content:n.fields.system.trim()});",
+    "129ad099e535c596 2 2 07ca7f99652b7e11,15b0a0cbe80654d7,3fbf5a580887b572,59157d58bc5429b4,5e9a1295e4a341ea,cd6ddef521f8337d,ddfde38f2d488e38 15b0a0cbe80654d7,59157d58bc5429b4,5e9a1295e4a341ea,68450a46e72a884c,7d5be815c172d016,a0278e8b26e1d5e9,cd6ddef521f8337d const vid = document.createElement(\"video\");",
+    "12fa383aaf1e5f1b 1 1 - - const ct = r.headers.get(\"content-type\") || \"\";",
+    "1302480ce5af2bfd 1 1 - - if(!/^https?:\\/\\/\\S+$/.test(txt)) throw new Error(txt.startsWith(\"<\") ? \"HTTP \"+r.status : (txt.slice(0,80) || \"no link returned\"));",
+    "131772d60e79e918 1 1 - - if(p.per_duration){ const k=Object.keys(p.per_duration)[0]; if(k && isFinite(+k)) return +k; }",
+    "136c2ba28a3514e5 1 1 - - shrunk.push(v === s.v ? s : { ...s, v });",
+    "13a55953e270c416 1 1 - - const tiers = [{ s:all, stripped:null }];",
+    "13bf56b401845707 2 1 - - async genVideo(model, prompt, opts, imageDataUrl, onProgress){",
+    "14353c8a9ec6cdb3 1 2 - - const rand = (n)=>b64url(crypto.getRandomValues(new Uint8Array(n)));",
+    "146a7f7524cfee31 1 1 - - if(p.per_generation!=null) return _num(p.per_generation);",
+    "149e340bf7697a50 1 1 - - throw new Error(\"CivitAI links can't be fetched directly — download the .safetensors and re-host it (e.g. on HuggingFace), then paste that URL.\");",
+    "14e65713ad7cca46 1 1 a422d441f505e75a a422d441f505e75a initMask(img.naturalWidth, img.naturalHeight);",
+    "14fe927fb440ee1c 1 1 7b030edeeee8d651 7b030edeeee8d651,9b17fdd7842f4ecc if((v=rp(p.per_second_by_resolution))!=null) return v*dur;",
+    "1504a5e2313a1e3a 1 1 - - const totalTicks = t.samples.reduce((a,s)=>a+s.dur, 0);",
+    "150a9b7efafc0e87 1 1 - - <link rel=\"apple-touch-icon\" href=\"/apple-touch-icon.png\" />",
+    "151af693a68d76d2 1 1 cf0b418e2f566399 cf0b418e2f566399 <meta property=\"og:image:alt\" content=\"Neon noodles rising from a ramen bowl into glowing workflow cables, with the nanoodle logo\" />",
+    "152e68877437e00e 1 1 - - const minf = box(\"minf\", mediaHeader, dinf, stbl);",
+    "153424380fd6448b 1 1 - - const secs = (seconds!=null && isFinite(seconds)) ? seconds : EST.audioSeconds;   // per_second models meter off the node's duration when it sets one",
+    "15b0a0cbe80654d7 1 3 07ca7f99652b7e11,129ad099e535c596,3fbf5a580887b572,59157d58bc5429b4,5e9a1295e4a341ea,cd6ddef521f8337d,ddfde38f2d488e38 129ad099e535c596,59157d58bc5429b4,5e9a1295e4a341ea,68450a46e72a884c,7d5be815c172d016,a0278e8b26e1d5e9,cd6ddef521f8337d const b = document.createElement(\"button\");",
+    "15bb5fccbefbf5e5 1 2 - - history.replaceState({},\"\",REDIRECT_URI);",
+    "15cdd27fae0c4bdb 1 1 - - const tempLocked = id => TEMP_LOCKED.test(String(id||\"\"));",
+    "16023637b0fa827f 1 1 521b78dfa387925c 521b78dfa387925c if(mode===\"exact\") return { cw:bw, ch:bh, dx:0, dy:0, dw:bw, dh:bh };",
+    "1692c942a432583e 1 1 9f39bfc54b20dfce,af882b199644f235 9f39bfc54b20dfce,af882b199644f235 if(t.refInputs && REF_PORT_RE.test(l.to.port)) continue;     // ref-image ports aren't text-field overrides",
+    "169b28c2b3e60bff 1 1 - - if(p.base_price_per_second!=null){ const m = p.resolution_multipliers ? (rp(p.resolution_multipliers) ?? 1) : 1; v=_num(p.base_price_per_second); if(v!=null) return v*dur*m; }",
+    "17243f7dce68b215 1 1 - - // unfurls as a picture of itself instead of the generic ramen card. Best-effort everywhere:",
+    "1734565700623b4c 1 1 8559753e4a0d28c2 8559753e4a0d28c2 const urls = await ctx.genImage(prompt, mdl(n), n.fields.size||SIZES[0][0], undefined, undefined, imgExtra(n), {n:want, multi:true});",
+    "17400e4575f2cdcc 1 1 - - var fam = loraFamily(model), sc = function(v){ return isNaN(v) ? 1 : v; };",
+    "176d7b01c86bb16b 1 1 07b422ca9b7fd16c,38f5de12b6bcdb12 07b422ca9b7fd16c,38f5de12b6bcdb12 if(opts.videoDataUrl) body.videoDataUrl = opts.videoDataUrl;",
+    "17af98145dd64047 1 1 - - const q = (n.fields.q||\"Describe this image.\").trim();",
+    "18698cd97778a0e1 1 1 - - const val = (sel!=null && opts.indexOf(sel)>=0) ? sel : (opts[0]||\"\");",
+    "1891c2b05109f609 1 1 0abfd56c0db3b0f0 0abfd56c0db3b0f0 const s = sig(ps[i]); if(!s) return false;",
+    "1899bbdf29d0cf0c 1 1 2de8cc80528c04d5,c4dc43d08e336bf0 2de8cc80528c04d5,c4dc43d08e336bf0 if(raw[k]){ const inner=pickObjByRes(raw[k], res, defRes); if(inner){ const dk=String(Math.round(dur)); v=_num(inner[dk]) ?? pickByRes(inner); if(v!=null) return v; } }",
+    "18e517a9d9cbde20 1 1 - - if(size === 1){ size = Number(dv.getBigUint64(p+8)); hs = 16; }",
+    "1900825a6d8e7246 1 1 - 750384b30138ef54 try{ localStorage.setItem(LEARNED_CAPS_KEY, JSON.stringify(learnedCaps)); }catch(e){}",
+    "191d92197f24a293 1 1 - - return kind===\"video\" ? true : imageTakesLora(id);",
+    "19587ffbabae2a2e 1 1 - - document.querySelectorAll(\"#sharemenu .sm-social a\").forEach(a => a.href = soc[a.dataset.soc]);",
+    "19a9e27942960008 3 3 10ac7e47b96c32d5 - const packed = await gzip(json).catch(()=>null);",
+    "1a6c8cb0ec526e72 1 2 - - const b64url = (b)=>btoa(String.fromCharCode(...new Uint8Array(b))).replace(/\\+/g,\"-\").replace(/\\//g,\"_\").replace(/=+$/,\"\");",
+    "1ae527c4ee87cd5f 1 1 - - ws(36,\"data\"); dv.setUint32(40,dataLen,true);",
+    "1ae9ed4d322b1e10 1 1 dd323e7e77e03e8a dd323e7e77e03e8a <link rel=\"icon\" type=\"image/png\" sizes=\"16x16\" href=\"/favicon-16.png\" />",
+    "1aedc8f694409f39 1 1 - - // Flat fills only: a gradient here balloons the PNG ~10x past nanolink's card cap.",
+    "1afec9ed09812679 1 1 - - c2d.drawImage(vid, 0, 0, canvas.width, canvas.height);",
+    "1b9b3611077acc62 1 1 - - .map(o=> [String(o.value), o.label!=null?String(o.label):String(o.value)]);",
+    "1c5f3c2f5867f2eb 1 1 - - if(win){ try{ win.opener = null; }catch(_){} }",
+    "1c8f5fba210392a3 1 1 - - if(s!=null && String(s).trim()!==\"\" && !isNaN(Number(s))) e.seed = Number(s);",
+    "1cb0dd49fec0a836 1 2 - - if(!r.ok) throw new Error(\"token: \"+(await r.text()));",
+    "1e59d050d7380e81 1 1 - - // nobody anything: past the SHARE_FIT_MAX budget messengers cut the raw link and the social",
+    "1e6ae0d8e06f9077 1 1 - - if(!r.ok) throw new Error((d && d.error) ? d.error : \"HTTP \"+r.status);",
+    "1ee34d57035d4c6d 1 1 - - #agentpop summary{ list-style:none; cursor:pointer; font-size:.75rem; color:var(--dim); line-height:1.45;",
+    "1f59b6c140427087 1 1 - - dv.setUint32(28, sampleRate*2, true); dv.setUint16(32,2,true); dv.setUint16(34,16,true);",
+    "1f75cb51f3567ee1 1 1 - - .filter(n => n && typeof n.x===\"number\" && typeof n.y===\"number\" && typeof n.type===\"string\");",
+    "1f90c8ee9ff39119 1 1 - - <link rel=\"icon\" href=\"/favicon.ico\" sizes=\"any\" />",
+    "1fcbe0ad9328dedf 1 1 - - const ws = (o,s)=>{ for(let i=0;i<s.length;i++) dv.setUint8(o+i, s.charCodeAt(i)); };",
+    "1fe716a76694e41c 1 1 - - const p = at.get(n.id), meta = CARD_TYPE_META[n.type] || [\"·\", n.type];",
+    "1fe83cbcc2ec254a 1 1 - - const max = SHORTEN_CEILING[svc];   // fail fast (and cheap) on links the service is known to reject",
+    "205005fc873a36f5 1 1 - - font-weight:700; box-shadow:inset 0 0 0 1px var(--accent); }",
+    "209ac06071d9ecae 1 1 - - const t = parsed[ci].tracks.find((x,i)=> x.kind===kind && (kind!==\"video\" || true) );",
+    "20bfb4fcb6bb36ec 1 2 - - c.getContext(\"2d\").drawImage(img, 0, 0, w, h);",
+    "210f2da9630570c0 1 1 - - // Some providers hand back the audio with a blank/generic content-type. An",
+    "219994a2dd235c05 1 1 - - const src = buffers[s.bufIdx].subarray(s.offset, s.offset + s.size);",
+    "219df3cf48d77c30 1 1 - - return canvasHasAlpha(ctx, w, h) ? c.toDataURL(\"image/png\") : c.toDataURL(\"image/jpeg\", 0.9);",
+    "21f87bc339d32d14 1 2 - - u.search=new URLSearchParams({response_type:\"code\",client_id:id,redirect_uri:REDIRECT_URI,scope:\"api.use models.read\",state,code_challenge:await sha256url(verifier),code_challenge_method:\"S256\",invitation_code:\"W3x83yU3\"}).toString();",
+    "22070034343b3f04 1 1 - - let cursor = ftyp.length + 8; // 8 = mdat header",
+    "227e3b1e5563f321 1 1 - - const stsdRaw = u8.slice(stsd.start, stsd.end); // whole stsd box, copied verbatim into output",
+    "22fbd2fd19c34e80 1 1 - - const a = l&&l.from&&at.get(l.from.node), b = l&&l.to&&at.get(l.to.node);",
+    "23d9d71ad7da2d69 1 1 - - u32(0x00010000), u16(0x0100), u16(0), new Uint8Array(8),",
+    "241c86811b0927fe 2 2 - - if(!map || typeof map!==\"object\") return null;",
+    "242f05787ac04042 1 1 - - for(const u of urls) handles.push(await toLocalMediaUrl(u));",
+    "242fddbb19f7d203 1 1 - - try{ await navigator.clipboard.writeText(t); return true; }catch{}",
+    "2548887d87466798 1 1 - - const ftyp = box(\"ftyp\", enc(\"isom\"), u32(0x200), enc(\"isomiso2avc1mp41\"));",
+    "26277cf0a060c2af 1 1 - - if(!url) throw new Error(\"completed but no video url\");",
+    "2641b670736bae81 1 1 - - // fails fast and the popover keeps offering the full-length link — which always works.",
+    "2691a3b54dea4f8b 1 1 - - $(\"agentbtn\").onclick = ()=> setAgentPop($(\"agentpop\").hidden);",
+    "26cc895265832ac1 1 1 - db6028f651e411e9 ? \"Still generating audio after 5 min — the job is likely still running on NanoGPT's side. Run this node again to pick up the finished track (you won't be charged twice).\"",
+    "26f4054932486088 1 1 - - if(syncIdx.length && syncIdx.length !== t.samples.length) children.push(fullbox(\"stss\", 0, 0, u32(syncIdx.length), ...syncIdx.map(u32)));",
+    "26f817da1cdd1e40 1 1 - - chat: (messages, model, opts)=> client.chat((opts && opts.response_format) ? messages : withLocale(messages), model, opts, io),",
+    "277293ac1da11013 1 1 - - const enc = (s) => Uint8Array.from(s, c => c.charCodeAt(0));",
+    "27dc79a4d3f0df23 1 1 - - // Combine dispatcher: try lossless mp4 remux first (exact, no re-encode, and it dodges the",
+    "28515112984e23c4 2 2 - - concat([u32(0x00010000),u32(0),u32(0),u32(0),u32(0x00010000),u32(0),u32(0),u32(0),u32(0x40000000)]),",
+    "2852d2ff58d3dc87 1 1 - - <button data-svc=\"dagd\" title=\"Third-party alternative — handles links up to ~9 kB\">da.gd</button>",
+    "293c7fa2d3433b8d 1 1 1630951ad125c543,c745bbc904f9573c - const l = graph.links.find(x=> x.to.node===id && x.to.port===port.name);",
+    "296280a4e0d9ab2f 1 1 - - const durs = new Array(sampleCount); let si = 0;",
+    "29f9d9652774064f 1 1 db9b4a022820f23f - const stream = new Blob([new TextEncoder().encode(str)]).stream().pipeThrough(new CompressionStream(\"gzip\"));",
+    "2a3915b1a86a15eb 1 1 - - \"standardReferenceVideoPricesPerSecond\",\"fastReferenceVideoPricesPerSecond\"]){",
+    "2a4ab385e921fe59 1 1 - - function loraKind(type){ return (type===\"image\"||type===\"edit\"||type===\"inpaint\") ? \"image\" : \"video\"; }",
+    "2a96417b6387d69d 1 1 a0b408d4b33ea384 a0b408d4b33ea384 if(defRes!=null && map[defRes] && typeof map[defRes]===\"object\") return map[defRes];",
+    "2b3c8fcc5c540445 1 1 6b348b45fd8c9e54 6b348b45fd8c9e54 const fitT = packed.find(p=> p.url.length <= SHARE_FIT_MAX) || packed[0];",
+    "2b414cba60da6750 1 1 - - const BAL_CACHE_KEY = \"ngpt_balance_usd\";",
+    "2b879980d0cae690 1 1 - - // Failure bodies are often whole HTML error pages — report the status, not tag soup.",
+    "2c118d407207b74b 1 1 0733a7ba115a7795,edfef3b215d4a652 0733a7ba115a7795,edfef3b215d4a652 for(const l of graph.links) if(l.to.node===id && ids.has(l.from.node)) s.add(l.from.node);",
+    "2c375fefa7fabd57 1 1 - - function pickObjByRes(map, reqRes, defRes){",
+    "2c4bbc36aeb040fe 1 1 - - // da.gd keeps its old ~9k ceiling: its redirect DOES echo the full target as a Location",
+    "2c57632952c25eaf 1 1 - - const stsc = fullbox(\"stsc\", 0, 0, u32(1), concat([u32(1), u32(1), u32(1)]));",
+    "2ceb9d35fbd07076 1 1 - - const UPLOAD_FIELD = { upload:\"image\", aupload:\"audio\", vupload:\"video\" };",
+    "2d3a9b77b2fc8d7f 1 1 - - // x_nanogpt_pricing (costUsd|cost|amount — Anthropic routes send only {amount,currency})",
+    "2d5ff886191d8922 1 1 - - if(tkhd && kind === \"video\"){ width = dv.getUint16(tkhd.end - 8) ; height = dv.getUint16(tkhd.end - 4); }",
+    "2d9f04c1feb90de1 1 1 - - // an stsd for the match gate — the surrounding sample entry can carry clip-specific boxes like btrt).",
+    "2de8cc80528c04d5 1 1 1899bbdf29d0cf0c,c4dc43d08e336bf0 1899bbdf29d0cf0c,c4dc43d08e336bf0 if(raw.referenceToVideoPrices){ const inner=pickObjByRes(raw.referenceToVideoPrices, res, defRes); if(inner){ const dk=String(Math.round(dur)); v=_num(inner[dk]) ?? pickByRes(inner); if(v!=null) return v; } }",
+    "2e241769cc5f56d3 1 1 - - Copies the compressed H.264+AAC samples from each clip onto one timeline and writes a single mp4:",
+    "2e39d1f30bc77aa2 1 1 a687e7b0aec22faf,e6757853f11f1e92,edec12afc74be9d6 a687e7b0aec22faf,e6757853f11f1e92,edec12afc74be9d6 if(b64.startsWith(\"R0lG\"))  return \"image/gif\";",
+    "2e517e578836f496 1 1 - - const o = btn.textContent; btn.textContent = \"…\";",
+    "2e945c681f402703 1 1 - - for(const k of [\"pricesPerSecond\",\"textToVideoPricesPerSecond\",\"withoutAudioPricesPerSecond\",",
+    "2ec0eed7523c7387 1 1 - - if(p.per_minute!=null) return _num(p.per_minute)*EST.sttMinutes;",
+    "2efe479e52de7fdb 1 1 0caddde7bca218a4,0cb248569f083b7a,1a6160d189e5f21e,21f44abe653a4445,2217e07ec079d623,279e8eec65de2560,4574d9ed1029493f,51a557b33abea28a,52cb7e26c84906e8,7ad48daadfc0b288,85eabf925f00506d,87fec2241e38d45f,8a4578677897488c,8cdb65a6754983f0,90bc5c617dcdcbb4,955efff1a5bb355f,9de134e184479136,a0f00cba3bc00975,bcf755614262ab11,c04e7b195a467b0c,c9c6ad076e85db33,e3750ada7641da1c,e66ce681898a93b6,efdec351263ecf0d 2562f5ffb46ddbfa,2bf75eb52aa43d7a,36ac5c4f00c2c9d4,375bd6ecddd366ac,3e8917ecd398e5e4,43b107cac12d1f16,66996f5ba428c756,87e0ae98ede59aac,88807fa60fda186c,955efff1a5bb355f,c6cf75d4487395c0,d322b3f1a54cab3c,ff673e2ae8ac8709 background:var(--panel2); border:1px solid var(--line); border-radius:.45rem; padding:.4rem .5rem; }",
+    "2f85d506e04551c4 1 1 - - const done = ()=>{ if(settled) return; settled = true; clearTimeout(to); vid.removeEventListener(\"seeked\", done); res(); };",
+    "2fa875b006d1cfce 1 1 - - if(social){ social.hidden = over; if(social.previousElementSibling) social.previousElementSibling.hidden = over; }",
+    "300da12c8940fb25 1 1 - - {type:\"image_url\", image_url:{url:inp.image}}",
+    "30d2ae3842af1c53 1 1 - - else out.unshift({ role:\"system\", content:dir });",
+    "3134f1cd2a76d26e 1 1 - - if(stszSampleSize === 0){ for(let i=0;i<sampleCount;i++) sizes[i] = dv.getUint32(stsz.body + 12 + i*4); }",
+    "313795b29600e265 1 1 - - reddit:   `https://www.reddit.com/submit?url=${eu}&title=${ti}`,",
+    "31f9e1c230b7f4f6 1 1 - - if(j.isApiRequest!=null) qs.set(\"isApiRequest\", j.isApiRequest);",
+    "31fc131ab2f1d550 1 2 f1d0769ffca62726 f1d0769ffca62726 const OAC = window.OfflineAudioContext || window.webkitOfflineAudioContext;",
+    "32261f208f3892f1 1 1 - - if(win){ win.location.replace(href); return; }",
+    "326d9a5c9577d1aa 1 1 6aaa55a236e6d1ae - if(!modelTakesLora(loraKind(n.type), n.fields.model)) return {};",
+    "32dfcccbd69257a9 2 2 - - const start = parseFloat(n.fields.start) || 0;",
+    "32ec7f09d4b7b5e9 1 1 - - // Pack full samples → samples with inlined media re-encoded smaller (via the",
+    "33be53cde28f19fe 1 1 - - // 401/403 are auth's territory (flagAuth already owns them) — don't let a body that happens to say",
+    "3496f18dc8740920 1 1 - - if(v!=null) fieldOverrides[l.to.port] = v;",
+    "35331e82f59cedc3 1 1 - - if(pend && pend.sig===bodySig && pend.job){",
+    "3556f3475f96af10 1 1 - - <input id=\"mpicksearch\" placeholder=\"filter the full list, or type an exact id + Enter…\" autocomplete=\"off\" />",
+    "3557b037f80e68bd 1 1 - - transcribe: (model, audioUrl, language)=> client.transcribe(model, audioUrl, language, io),",
+    "35cf21c875e92d6e 1 1 - - if(size >= 8 && p + size <= u8.length) return u8.slice(p, p+size);",
+    "366d0d5301142009 2 2 - - const chunks = []; rec.ondataavailable = e=>{ if(e.data && e.data.size) chunks.push(e.data); };",
+    "36a782a6e329fbb8 1 1 - - const at = new Map(nodes.map(n=>[n.id,{x:px(n),y:py(n)}]));",
+    "37647418516a67d9 1 1 - - // Concatenate. buffers: array of Uint8Array (whole mp4 files). opts.dedup drops each later clip's first video sample.",
+    "378faab801d4bbf7 1 1 - - if(usd!=null && isFinite(usd) && audioOn && p.audio_multiplier!=null) return usd * (_num(p.audio_multiplier) ?? 1);",
+    "37eaf4087eee2b5b 1 1 - a7520ccdf996c76e const prefs=(navigator.languages&&navigator.languages.length)?navigator.languages:[navigator.language||\"en\"];",
+    "388c0056a79f8587 1 1 - - try{ const ta=document.createElement(\"textarea\"); ta.value=t; ta.style.cssText=\"position:fixed;opacity:0\";",
+    "38f5de12b6bcdb12 1 1 176d7b01c86bb16b 176d7b01c86bb16b if(opts.videoUrl) body.videoUrl = opts.videoUrl;",
+    "392fe534d7608704 1 1 - - cx.drawImage(img, p.dx, p.dy, p.dw, p.dh);",
+    "397e0888b9ca597b 1 1 - - // Generated music/video come back as URLs on the provider's media CDN, which serves them for",
+    "39cb2e3ae4cb4c07 1 1 - - const w = (t.width||0), h = (t.height||0);",
+    "3a3b774fe8b62700 1 1 - - if(samples.length !== sampleCount) throw new Error(\"sample count mismatch \" + samples.length + \"/\" + sampleCount);",
+    "3a484fb6dcd5a60b 1 1 - e9f3bdc96952684b [\"placeholder\",\"title\",\"aria-label\"].forEach(a=>{ if(!el.hasAttribute(a)) return; const hit=i18nLookup(el.getAttribute(a)); if(hit!=null) el.setAttribute(a,hit); });",
+    "3abfd9a108d73197 1 1 - - const reader = r.body.getReader(), dec = new TextDecoder();",
+    "3af87b7cfe0ca564 1 1 - - const fourcc = (dv, p) => String.fromCharCode(dv.getUint8(p), dv.getUint8(p+1), dv.getUint8(p+2), dv.getUint8(p+3));",
+    "3af8e23fbb02cf44 1 1 - - rec.stop(); await stopped; vtrack.stop();",
+    "3b77a142b8c362fd 1 1 - - if(v.length > 2500 && v.slice(0,11) === \"data:image/\"){",
+    "3b8a7854120e5bc0 1 1 - - const mdia = box(\"mdia\", mdhd, hdlr, minf);",
+    "3ba19bcdbff8ead9 1 1 - - if(p.per_second!=null) return Math.max(_num(p.per_second)*secs, _num(p.minimum)||0);",
+    "3c248ed499cfe583 1 1 - 646da6e17bb085ea if(p.closest(I18N_SKIP)) return NodeFilter.FILTER_REJECT;",
+    "3c4f98dbbd667800 1 1 b60fa92bb9d36205 b60fa92bb9d36205 const auds = p.tracks.filter(t=>t.kind===\"audio\");",
+    "3c572796edd315d7 1 1 - - return (stored && SUP[stored]) ? stored : \"\";",
+    "3c67f833251e4307 1 1 - - canvas.width = vid.videoWidth || 1280; canvas.height = vid.videoHeight || 720;",
+    "3c871950a01c2743 1 1 - - const sent = Math.max(head.lastIndexOf(\". \"), head.lastIndexOf(\"! \"), head.lastIndexOf(\"? \"), head.lastIndexOf(\"\\n\"));",
+    "3d61a032fa48b94c 1 2 6e161c29ddfe09fd,d2b28a98b4b1d0a0 d2b28a98b4b1d0a0 const cached = JSON.parse(localStorage.getItem(\"ngpt_client\")||\"null\");",
+    "3e1707f592fc159a 1 1 0471ccad0592f6c1 0471ccad0592f6c1 return /^https?:/.test(url) ? { videoUrl:url } : { videoDataUrl: await urlToDataUrl(url) };",
+    "3ef934f25a5e2d9c 1 1 - - const others = [...document.querySelectorAll(\"#sharemenu .sm-svc button\")];",
+    "3fadbfa16ffdeb7a 1 1 - ed6d082609606e0b return Object.keys(inp).filter(k=> VID_PORT_RE.test(k)).sort((a,b)=> +a.slice(3) - +b.slice(3))",
+    "3fdd3d5397a9d664 1 1 - - if(tw>0 && th>0) scale = Math.min(tw/sw, th/sh);",
+    "3fe19efc766ddeef 1 1 - - // Decode the graph out of the link being shortened (not live editor state) so the card always",
+    "3fe41065ea56778b 1 1 - - for(let e=stscEntries.length-1;e>=0;e--){ if((c+1) >= stscEntries[e].first){ spc = stscEntries[e].spc; break; } }",
+    "3feb9c88a6e2139a 1 1 - - var b = {}; items.forEach(function(it,i){ b[\"lora_url_\"+(i+1)]=it.url; b[\"lora_scale_\"+(i+1)]=sc(it.scale); }); return b;",
+    "4038212c7a6debdf 1 1 - - return client.audio(model, input, extra, io2).then(",
+    "41222f4930b751a5 1 2 - - const s = Math.max(0, Math.min(start||0, Math.max(0, dur-0.05)));",
+    "412e56c82ab88a4d 1 1 - - } else if(airModelTakesNegative(n.fields.model)){",
+    "415bd09bf1992114 1 1 - - if(!id || loraFamily(id)==null) return false;",
+    "41c8fd6547b19719 1 1 - - if(opts.duration) body.duration = opts.duration;",
+    "41e0c41c37a02524 1 2 - - return URL.createObjectURL(encodeWavMono(rendered.getChannelData(0), rate));",
+    "420197d42afb7f0f 1 1 - - return new Error(\"couldn’t download that generated clip to edit it — the provider’s media CDN blocks in-browser downloads (CORS). Shorten it at the source node instead (e.g. lower the Music node’s length), or use a 🗣️ Speech node, whose audio nanoodle can trim. (\" + (e.message||e) + \")\");",
+    "422ad8306e7bee7c 1 1 - - if(opts.max_tokens) body.max_tokens = +opts.max_tokens;",
+    "422f7d6384a2929c 1 1 01aae5325995f19c,904e610149650be4,a7c1c8a59680286d 01aae5325995f19c,904e610149650be4 <button id=\"agentmcpcopy\" class=\"sm-copy\">Copy</button>",
+    "426f3f0bfcfdfe95 1 1 fa5b8b2427d76ddb fa5b8b2427d76ddb if(p.per_second!=null){ v=_num(p.per_second); if(v!=null) return v*dur; }",
+    "4352768f58786a8e 1 1 - 74e2c05627f508d2 if(k1!==k0 || !keySendable(k1)) setKey(k1 && keySendable(k1) ? k1 : null); } }catch(_){}",
+    "43a5b91fb7837512 1 1 - - const tkhd = fullbox(\"tkhd\", 0, 7, tkhdBody);",
+    "43dac26b7eb288d5 1 1 63b3c9a2241c70c0,8d003471a549d8d0,aad0d5470e64a9bc 63b3c9a2241c70c0,8d003471a549d8d0,aad0d5470e64a9bc const stszSampleSize = dv.getUint32(stsz.body + 4);",
+    "43f7d3eb09b45360 1 1 fb7f00b4021d6747 fb7f00b4021d6747 onProgress && onProgress(s.queuePosition, Date.now()-t0);",
+    "4406a72bd8888f6a 1 1 5fe565ccafb5a3f8,a7dac7f471b9312c 03ceb15d371b47ba,7f8230bc730ceed3,87a42466c9007a97,9feb47c4df29f895,a7dac7f471b9312c,e529f95124898847,ff59a49c4f172342 .sm-urlrow{ display:flex; gap:.4rem; align-items:center; }",
+    "4413ed9b6e17c557 1 1 - - return Math.min(hi!=null?hi:d, Math.max(lo!=null?lo:d, d));",
+    "443a3c3b30cafa98 1 1 - - let buf=\"\", content=\"\", reasoning=\"\", pricing=null, lastPaint=0, streamErr=null, finish=null;",
+    "4464f5113d892247 1 1 - - if(!/^https?:\\/\\/\\S+$/.test(t)) throw new Error(\"no link returned\");",
+    "44cee28cc87688b0 1 1 6d4feeddb813a5d6 6d4feeddb813a5d6 const py = n => PAD+BH/2 + (cy(n)-y0)*s + (ih-(y1-y0)*s)/2;",
+    "44f1da4388d5d6c4 1 1 - - .catch(()=>{ try{ if(win) win.close(); }catch(_){} toast(\"couldn't shorten the link for the post, and the full one is too long to post raw — copy it from Share instead\", \"err\"); });",
+    "450453aae125309a 1 1 - - if(i>=0) out[i] = Object.assign({}, out[i], { content: out[i].content + \"\\n\\n\" + dir });",
+    "451cc582852c800b 1 1 - - // 0:00, dead play button) even though the bytes download/open fine — so pin",
+    "458e9f835fa0b5e5 1 1 - - const client = new E.NanoClient({ apiKey: getKey(), baseUrl: NANOGPT, fetch: (u,o)=> fetch(u,o) });",
+    "45bb2d4005e78b6c 1 1 - - const minf = find(mb, \"minf\"); const minfB = walk(dv, minf.body, minf.end);",
+    "45da063f1b6ccd5e 1 1 - - (check-html-js). Everything is scoped in this IIFE so its short helper names can't collide. */",
+    "463f05755802e67f 1 1 - - $(\"sm-url\").onclick = ()=> $(\"sm-url\").select();",
+    "465c81fc82abf7ab 1 1 - - #agentpop summary::after{ content:\"›\"; margin-left:auto; flex:none; color:var(--accent);",
+    "4665ef555dc7df31 1 1 - - const SIZES = [[\"1024x1024\",\"square\"],[\"1024x1536\",\"portrait\"],[\"1536x1024\",\"landscape\"],[\"auto\",\"auto\"]];",
+    "46ea8e85cac5b72e 1 1 - - const mb = walk(dv, mdia.body, mdia.end);",
+    "478a20114ff9da5e 1 1 - - // Timeout: the job stays in PENDING_AUDIO (registered above) so an unchanged re-run polls the same runId (no second charge).",
+    "47a1c2105bcefb6a 1 1 - - return /^(civitai:\\d+@\\d+|persona:\\d+@\\d+|runware:[^\\s@]+@[^\\s@]+)$/i.test(air);",
+    "47a4933975821ae8 1 1 - - // Library-shaped ctx bridging to THIS runtime's auth, abort signal, pending-job",
+    "47c106d7e8b5daf1 1 2 985d9694cdae5f21 985d9694cdae5f21 <meta property=\"og:image:height\" content=\"630\" />",
+    "48443b0738320d9f 1 1 4b2556b17d211035 4b2556b17d211035 const stsz = fullbox(\"stsz\", 0, 0, u32(0), u32(t.samples.length), ...t.samples.map(s=>u32(s.size)));",
+    "4870932771d06d60 1 1 - - for(const k in opts){ if(/audio/i.test(k) && !/^(no|disable|without|mute)/i.test(k)){ const val=opts[k]; if(val===true||val===\"true\"||val===1||val===\"1\"||val===\"on\"||val===\"yes\"){ audioOn=true; break; } } }",
+    "488deae3b8179162 1 1 - - throw new Error(\"LoRA must be a direct https URL to a .safetensors file (HuggingFace or any host).\");",
+    "488ed236a1dd9905 1 1 56ad6c332c9941d2 - if(!prompt) throw new Error(\"no prompt — say what to paint into the brushed area\");",
+    "48a2762809cc2428 1 1 - - if(/^civitai:\\d+@\\d+/i.test(s)) return s.replace(/^civitai:/i, \"civitai:\");",
+    "48b64f163787aa57 1 1 7f8cbc2c5d8093fb - /* ---- Lossless in-browser mp4 concatenation (Combine node) --------------------------------------",
+    "4928686608cbbb92 1 2 - - try{ src = await dec.decodeAudioData(arr); }",
+    "4965390c4963cac7 1 1 - - return urlPrefix + (packed ? \"#a=\"+bytesToB64url(packed)",
+    "497426b21c8c1325 1 1 efdec351263ecf0d - #agentpop details{ margin:.55rem .15rem .1rem; border:1px solid var(--line); border-radius:.55rem;",
+    "4981c5cb162b5497 1 1 - - throw new Error(\"This avatar model needs two separate audio tracks (multi-speaker). Pick a single-speaker avatar model in the model dropdown.\");",
+    "4a136a1e0bc61911 1 1 - - \"standardPricesPerSecond\",\"standardTextToVideoPricesPerSecond\",\"outputPricesPerSecond\",\"fastPricesPerSecond\"]){",
+    "4a45808167751a51 1 1 - - const stepSec = Number.isFinite(gapRaw) ? Math.max(0, gapRaw) : 0.5;   // seconds between captured frames",
+    "4a492ee84c7de708 1 1 e7181a4bfa300cad e7181a4bfa300cad return { video: await ctx.genVideo(mdl(n), prompt, opts, inp.image, prog) };",
+    "4a65223f871d3940 1 1 - - return loraBodyFor(n.fields.model, items);",
+    "4a7ef81e51f25c06 1 1 - - if(dedup && kind===\"video\" && ci>0) list = list.slice(1);",
+    "4ac2c05d79d4b817 1 1 - - const mp = _num(raw.megapixelsByResolution[res]) ?? _num(raw.megapixelsByResolution[defRes]) ?? pickByRes(raw.megapixelsByResolution);",
+    "4acb57b8d04cc7f8 1 1 - - // Social intents need a short link, and past the nanolink ceiling no shortener can make one — the",
+    "4ae7df0545e4e5c6 1 1 - - // v0: [ver/flags 4][ctime 4][mtime 4][timescale 4]; v1: [ver/flags 4][ctime 8][mtime 8][timescale 4]",
+    "4b2556b17d211035 1 1 48443b0738320d9f 48443b0738320d9f const stco = fullbox(\"stco\", 0, 0, u32(t.samples.length), ...t.samples.map(s=>u32(s.newOffset)));",
+    "4b61719f1bc81ca0 1 1 - c44782b360db502d document.body.appendChild(t); t.click(); t.remove();",
+    "4b7089a830741b9d 1 1 - - for(const n of nodes){ x0=Math.min(x0,cx(n)); x1=Math.max(x1,cx(n)); y0=Math.min(y0,cy(n)); y1=Math.max(y1,cy(n)); }",
+    "4b8da7ca6d2467a9 1 1 - - if(st===\"COMPLETED\" || st===\"SUCCEEDED\"){",
+    "4badb1682e49a898 1 1 95bda37e898817a1,e14d69fc530a827d 95bda37e898817a1 body.temperature = (opts.temperature!=null && opts.temperature!==\"\") ? +opts.temperature : 0.8;",
+    "4c318abc0e87b74f 1 1 - - document.querySelectorAll(\"#sharemenu .sm-svc button\").forEach(b=> b.disabled = len > (SHORTEN_CEILING[b.dataset.svc] || Infinity));",
+    "4c5530f4ae080e35 1 1 f75191ee80c062f6 f75191ee80c062f6 async function concatVideos(urls, dedup, onProgress){",
+    "4c751f0b1ba37f2e 1 1 - - const label = (typeof n.name===\"string\" && n.name.trim()) ? n.name.trim() : meta[1];",
+    "4c95bc677b65d14a 1 1 ba9449101f021537 006d96caa71f21b9,ba9449101f021537 const vh = await toLocalMediaUrl(videoUrl);",
+    "4d6090d601f78d6b 1 1 - - const refOn = !!refWired || /reference/i.test(String(opts.mode||\"\"));",
+    "4d63b53607286b0c 1 1 - - if(/^(number_of_songs|n|num_songs|song_count|generation_count|generation_count_parameter)$/i.test(k)",
+    "4d6e64a76ef6661f 1 1 3cb2dfbe51560a8f c32ca788c2fdf651 throw new Error(\"audio clip is too large to inline (~4 MB send limit) — shorten it with the ✂️ Trim node first\");",
+    "4d7960dd7a2dc9d0 1 1 - - t = Math.max(0, Math.min(Math.max(0, dur - EPS), t));",
+    "4d8f970f0ad6c2fe 1 1 - - function bytesEqual(a, b){ if(!a || !b || a.length !== b.length) return false; for(let i=0;i<a.length;i++) if(a[i]!==b[i]) return false; return true; }",
+    "4db6de3d362e7f0b 1 1 - - if(mp!=null) return _num(raw.pricePerMegapixel)*mp*nf;",
+    "4edc41ffa2c4e46b 1 1 - - function fullbox(type, version, flags, ...payload){ return box(type, Uint8Array.from([version, (flags>>16)&255, (flags>>8)&255, flags&255]), ...payload); }",
+    "4f52cab9e1153254 1 1 - - // it once at slug creation and serves it as the short link's og:image, so a shared noodle",
+    "4f8a018627e54991 1 1 - - if(typeof sm === \"string\" && sm.length < v.length){ v = sm; changed = true; }",
+    "4f932e672751569b 1 1 - - const EST = { llmInTokens:1000, llmOutTokens:500, ttsChars:600, audioSeconds:30, sttMinutes:1, videoFps:30 };",
+    "4fc5caa38688d636 1 1 - - samples.push({ offset: off, size: sizes[sIdx], dur: durs[sIdx], cts: cts[sIdx], sync: syncSet ? syncSet.has(sIdx+1) : true });",
+    "50912c3eb01ebea6 1 1 - - if(!E || !E.RUNNERS || !E.RUNNERS[type]) return null;",
+    "509507dad4f111f5 1 1 560e47c304b7b50c 560e47c304b7b50c if(!(skipFirst && seen===1)){ c2d.drawImage(vid, 0, 0, W, H); track.requestFrame(); }",
+    "50fedbc86ec26bb2 1 1 - - toast(longUrl.length > SHORTEN_CEILING.nanolink",
+    "5136b2acaca9f4ec 1 1 893dc59ed6543918 5bda10d289e46b1f,893dc59ed6543918,ceeee510b171e38a const r=await fetch(`${NANOGPT}/oauth/token`,{method:\"POST\",headers:{\"Content-Type\":\"application/x-www-form-urlencoded\"},",
+    "5137dd75ec7f6b43 1 1 - - // \"Deploy for nanoodle.com\" quickstart). If it isn't deployed or reachable, shortenWith",
+    "5198a61ae0c3a44b 2 1 - - const stream = canvas.captureStream(0);            // 0 fps = we drive every frame by hand",
+    "51d89a1366e49448 1 1 - - const LEARNED_CAPS_KEY = \"nn_prompt_caps\";",
+    "51f5a1239eef3aca 1 1 - - buf += dec.decode(value, { stream:true });",
+    "521b78dfa387925c 1 1 16023637b0fa827f 16023637b0fa827f return { cw:w, ch:h, dx:0, dy:0, dw:w, dh:h };",
+    "526bd44afcfa2c32 1 1 - - if(imageDataUrl) body.imageDataUrl = imageDataUrl;   // present → image edit (img2img)",
+    "5276c58ab7b6bdc7 1 1 - - for(let e=0;e<stscN;e++) stscEntries.push({ first: dv.getUint32(stsc.body + 8 + e*12), spc: dv.getUint32(stsc.body + 12 + e*12) });",
+    "52e7c16c6ab75d31 2 2 a8cb22b954de6907,b5d419871e8d7580,d36c7d6d21532c83,f4dff16f458d3ffa 7491fd87c8a97620,a8cb22b954de6907,b5d419871e8d7580,d36c7d6d21532c83,f4dff16f458d3ffa const canvas = document.createElement(\"canvas\"); canvas.width = W; canvas.height = H;",
+    "531625e1db036fd9 1 1 551ab72de3311ec6 551ab72de3311ec6 const head = comma>=0 ? url.slice(0,comma) : \"\";",
+    "531be8c462fb4534 1 1 - - // uploaded clip rides as data: and is rejected for free at submit. Point at the chained path.",
+    "535b4ad0c3fe904a 1 1 - - const s = Math.min(iw/Math.max(1,x1-x0), ih/Math.max(1,y1-y0));",
+    "53a465b862ca823b 1 1 - - return (b64 && b64.length*0.75 <= 190*1024) ? b64 : null;",
+    "53a6622d1d363a10 1 1 - - if(/(^|\\/\\/|\\.)huggingface\\.co\\//i.test(u)){",
+    "53b42b2a29794358 1 1 - - const vals = Object.values(map).map(_num).filter(v=>v!=null);",
+    "53e7ea573fc44ea1 1 1 - - return localStorage.getItem(\"njs_engine\")!==\"0\";   // default ON — njs_engine=\"0\" (or ?engine=play) opts back into the built-in runners",
+    "543afd78d19be212 1 1 - - const nodes = (graph && Array.isArray(graph.nodes) ? graph.nodes : [])",
+    "546ac1be243caee2 1 1 - - // can try a leaner preview before dropping it entirely. null on any failure/timeout: the caller",
+    "5475c477ebb8e86c 2 2 69fe17da2941fe18,dceae1b7c8800866 69fe17da2941fe18,dceae1b7c8800866 const atrack = dest.stream.getAudioTracks()[0];",
+    "54cde18a53343c55 1 1 - - if(opts.reasoning_effort) body.reasoning_effort = opts.reasoning_effort;",
+    "551ab72de3311ec6 1 1 531625e1db036fd9 531625e1db036fd9 const data = comma>=0 ? url.slice(comma+1) : url;",
+    "553015162904e270 1 1 f6adaf8668dc5d6f 42ef971ac097f77c,f6adaf8668dc5d6f if(!urls.length) throw new Error(\"no image in response\");",
+    "556c8f20f62b465d 1 1 - - const fmt = (extra && extra.response_format) || \"mp3\";",
+    "55f4d42091c62a73 1 1 - 54b0faa6caed44c8 const getKey = ()=> localStorage.getItem(\"ngpt_key\");",
+    "560da21b688284ce 1 1 - - if(typeof o===\"object\") for(const k of Object.keys(o)) walk(o[k], k);",
+    "560e47c304b7b50c 1 1 509507dad4f111f5 509507dad4f111f5 c2d.drawImage(vid, 0, 0, W, H); vtrack.requestFrame();",
+    "56159cf41c50e548 1 1 - - || nat.get(famSig(a.id)) - nat.get(famSig(b.id))",
+    "5662356a10f6ccc3 1 1 - - const m = PROMPT_TOO_LONG_RE.exec(String(msg||\"\"));",
+    "56f266c91910f8f9 1 1 - - const base=rp(p.base_prices_by_resolution);",
+    "57d876f2f848973a 1 1 - - if(l.to.node!==id || t.inputs.some(p=>p.name===l.to.port)) continue;",
+    "581e0f71484c848f 1 1 - - // dynamic image ports (llm: img1,img2,…  edit: image,image2,…) → collected by run() via collectImageInputs()",
+    "582b404a86d4a7ad 1 2 - - throw new Error(\"the start point (\" + (Math.round((start||0)*10)/10) + \"s) is past the end of this clip, which is only \" + dur.toFixed(1) + \"s long — pick an earlier start\");",
+    "58b733c42993dae7 1 1 - - if(p.per_thousand_chars!=null){ let cost=_num(p.per_thousand_chars)*(c/1000); if(p.per_generation!=null) cost+=_num(p.per_generation); return Math.max(cost, _num(p.minimum)||0); }",
+    "59157d58bc5429b4 1 1 07ca7f99652b7e11,129ad099e535c596,15b0a0cbe80654d7,3fbf5a580887b572,5e9a1295e4a341ea,a8cb22b954de6907,cd6ddef521f8337d,ddfde38f2d488e38,f4dff16f458d3ffa 129ad099e535c596,15b0a0cbe80654d7,5e9a1295e4a341ea,68450a46e72a884c,7d5be815c172d016,a0278e8b26e1d5e9,a8cb22b954de6907,cd6ddef521f8337d,f4dff16f458d3ffa const canvas = document.createElement(\"canvas\");",
+    "59858c3bb10e0921 1 1 fdc3d71dd89c7246 fdc3d71dd89c7246 g.font=\"28px system-ui, sans-serif\"; g.fillStyle=\"#ececf2\"; g.textAlign=\"left\";",
+    "5a4b10d96473ae6d 1 1 - - let usd=0, priced=0, unpriced=0, exact=true;",
+    "5a6e05c0afce9e64 1 1 8038adf488875b24 8038adf488875b24 const f = parseFloat(fields && fields.duration);",
+    "5a79e7469b13a38f 1 1 - - if((n.fields.loraUrl||\"\").trim() || (n.fields.loraStrength||\"\")!==\"\")",
+    "5b75c66b9694226e 1 1 - - const langs = Array.isArray(sp.supported_languages) ? sp.supported_languages.filter(x=>typeof x===\"string\") : [];",
+    "5c588d78c6f71050 1 1 - - // for the session — that would disable the library's billing clamps (max_output_images,",
+    "5c736661f310b0a3 1 1 - - for(const m of prefs) if(MediaRecorder.isTypeSupported(m)) return m;",
+    "5c914d6193759302 1 1 - - const syncIdx = []; t.samples.forEach((s,i)=>{ if(s.sync) syncIdx.push(i+1); });",
+    "5cf0ebc63ea347e9 1 2 f5581831083a0b6c f5581831083a0b6c <meta property=\"og:type\" content=\"website\" />",
+    "5d18640ea0c9487f 1 1 - - if(Array.isArray(p.supported_durations) && p.supported_durations.length) return +p.supported_durations[0];",
+    "5d636dc4ed9f182e 1 1 - - return /^(persona:|civitai:|runware:)/i.test(m) && airTakesNegative(m);",
+    "5d7e353967a74293 1 1 - - const c = drawShareCard(await shareCardGraph(longUrl));",
+    "5e32358c1c2b5339 1 1 - - // the type from the requested format when it's missing or generic.",
+    "5e9a1295e4a341ea 1 1 07ca7f99652b7e11,129ad099e535c596,15b0a0cbe80654d7,3fbf5a580887b572,59157d58bc5429b4,cd6ddef521f8337d,ddfde38f2d488e38 129ad099e535c596,15b0a0cbe80654d7,59157d58bc5429b4,68450a46e72a884c,7d5be815c172d016,a0278e8b26e1d5e9,cd6ddef521f8337d,ece68bb51d2aeba0 const v = document.createElement(\"video\");",
+    "5eb207ad55934b3a 1 1 1059128060bca931 424c6af2e16541de,862aea117c56bd3f,d3f73f24d6e9fcaa border-radius:.7rem; box-shadow:0 18px 50px rgba(0,0,0,.5); padding:.55rem .6rem; }",
+    "5eb93dfeb18ba509 1 1 - - if(p.base_price!=null && p.per_extra_second!=null){ const bd=_num(p.base_duration)||0; return _num(p.base_price) + Math.max(0,dur-bd)*_num(p.per_extra_second); }",
+    "5f0a4f79f56ed049 1 1 - - ? m.supported_parameters.resolutions.filter(x=> typeof x===\"string\" && x) : [];",
+    "5f77f019f591ff83 1 1 - - if(p.fixed_duration_seconds!=null) return _num(p.fixed_duration_seconds) || 5;",
+    "603e8b24fcbf3f4f 1 1 - - const mdhdV1 = dv.getUint8(mdhd.body) === 1;",
+    "603f73dc50598c84 1 1 - - const tb = walk(dv, trak.body, trak.end);",
+    "6113c2cfffecf0b2 1 1 - - if(f.default!=null && v===f.default) continue;       // e.g. response_format=mp3 → omit",
+    "6192ffaa50abbd01 1 1 - - if(p.per_duration){ const dk=String(Math.round(dur)); v=_num(p.per_duration[dk]) ?? _num(p.per_duration[String(dur)]) ?? pickByRes(p.per_duration); if(v!=null) return v; }",
+    "619fc62648e0615a 1 1 - - // Strict gate: every clip must have the same track shape and byte-identical codec config",
+    "61b4be7a5744741a 1 1 - - if(!atrack) throw new Error(\"this browser can’t capture an audio stream\");",
+    "62240a12bddede33 1 1 f75191ee80c062f6 f75191ee80c062f6 return concatViaRecorder(urls, dedup, onProgress);",
+    "62fe021164d20cdb 1 2 - - if (cached && cached.redirect===REDIRECT_URI) return cached.id;",
+    "63129ff9cb04958b 1 1 - - let j; try{ j = JSON.parse(data); }catch{ continue; }",
+    "63b3c9a2241c70c0 1 1 43dac26b7eb288d5,8d003471a549d8d0,aad0d5470e64a9bc 43dac26b7eb288d5,8d003471a549d8d0,aad0d5470e64a9bc const sampleCount = dv.getUint32(stsz.body + 8);",
+    "63bc299df6ba16e0 1 1 - - // dead ends. `stripped` = \"shrunk\" | \"media\" | \"all\" | null says what was compressed/cut, so",
+    "640a8e2bb8346533 1 1 - - function rle(values){ // -> [count,val] runs, returns entries array of Uint8Array pairs",
+    "6413baf7fb32036c 1 1 - - out.alt = { media: m.url, noMedia: sansMedia[0].url };",
+    "643e342964d6aab2 1 1 - - // mentions balance/funds/insufficient. Turn that into one actionable line (with the top-up link)",
+    "6456b0b1e8db61a6 1 1 - - if(n.type===\"music\" || n.type===\"remix\"){",
+    "64940212711dde4f 1 1 - - <script>if(\"serviceWorker\" in navigator){addEventListener(\"load\",()=>navigator.serviceWorker.register(\"/sw.js\").catch(()=>{}));}</script>",
+    "64ec20d158e524c1 1 1 - - return { url: normalizeLoraUrl(r.url), scale: (r.strength==null||r.strength===\"\") ? 1 : Number(r.strength) };",
+    "6552cb2e39aa8a3d 1 1 - - const n = samples.length, dataLen = n*2, ab = new ArrayBuffer(44+dataLen), dv = new DataView(ab);",
+    "65d35cc6f5cd7704 17 13 8a61b799060b3516,c5521b76b218c14a,e1893250b982420d 8a61b799060b3516,c5521b76b218c14a,e1893250b982420d /* ======================================================================",
+    "6630ac328cbea226 1 1 - - for(let i=0;i<n;i++){ const v = Math.max(-1, Math.min(1, samples[i])); dv.setInt16(off, v<0 ? v*0x8000 : v*0x7FFF, true); off += 2; }",
+    "665a83d65e71d0d5 1 1 - - if(extra) Object.assign(body, extra);                // LoRA (and any future per-model image params)",
+    "6682a0ef06cd9ced 1 1 - - const svc = btn.dataset.svc, label = btn.textContent.trim();",
+    "66bf50236f3b3f7d 1 1 - - // window is opened SYNCHRONOUSLY on click (so the async shorten doesn't trip the popup blocker),",
+    "66ceb1baf8690e9d 1 1 - - } else opts = await audioSourceOpts(inp.audio);",
+    "66dffa238c59a080 1 1 - - // turn a blob:/data:/http url into a base64 data URL (for video/audio source payloads)",
+    "67405a8ece448bb3 1 2 de7ece55ee7084a5 de7ece55ee7084a5 const p=new URLSearchParams(location.search);",
+    "678386620763bafd 1 1 92391ef1c2fed3c2,de60b766ea347cb2,eb49569223879925 de60b766ea347cb2,eb49569223879925 img.onerror = ()=> rej(new Error(\"couldn’t read that image to resize\"));",
+    "67c3dca541f159ed 1 1 - - if(f.reasoningEffort && f.reasoningEffort!==\"default\") o.reasoning_effort = f.reasoningEffort;",
+    "67ddf1729306bc1c 1 1 - - // buttons can rebuild them against a freshly-shortened link at click time (see below).",
+    "67f344afa5ef0f66 1 1 - - function audioUnitUsd(pricing, chars, seconds){",
+    "68e31cdca7ce4479 1 1 - - if(prompt) body.prompt = prompt;                     // omit when blank — upscalers run with no instruction; every other path guarantees a non-empty prompt before reaching here",
+    "696fa37f0d59a1c8 1 1 - - if(p.per_target_megapixel_second!=null){ const mp=_num(p.default_target_megapixels)||1; v=_num(p.per_target_megapixel_second)*mp*dur; return Math.max(v, _num(p.minimum_price)||0); }",
+    "6982f55283b9e63f 1 1 - - <link rel=\"manifest\" href=\"/site.webmanifest\" />",
+    "69f32ca62ef39f92 1 1 - - // <audio> element won't play a blob whose MIME it can't recognise (shows",
+    "69fe17da2941fe18 1 1 5475c477ebb8e86c,dceae1b7c8800866 5475c477ebb8e86c,dceae1b7c8800866 const vtrack = stream.getVideoTracks()[0];",
+    "6a387537691fb3a0 1 1 - - if(Array.isArray(n.fields.loras)) return n.fields.loras;",
+    "6ac04546f69d0439 1 1 - - if(p.per_prompt_char_block!=null){ const bs=_num(p.prompt_char_block_size)||1; return Math.max(Math.ceil(c/bs)*_num(p.per_prompt_char_block), _num(p.minimum)||0); }",
+    "6ac710886a202d29 1 1 b1823bb159eefd27,b6f2444936aae78f b1823bb159eefd27,b6f2444936aae78f async run(n){ if(!n.fields.video){ if(optNode(n)) return { video:\"\" }; throw new Error(\"no video — upload a clip first\"); } return { video: n.fields.video }; }",
+    "6ad4b10df9b52501 1 1 - - const NANOLINK_ORIGIN = \"https://link.nanoodle.com\";",
+    "6b138725c931661a 1 1 - - // depicts exactly what the link opens. Returns null on anything unexpected.",
+    "6b348b45fd8c9e54 1 1 2b3c8fcc5c540445 2b3c8fcc5c540445 const m = withMedia.find(p=> p.url.length <= SHARE_FIT_MAX) || withMedia[0];",
+    "6b3ad72a668968d1 1 1 - - // Scan a byte range for a box of the given 4cc and return its bytes (used to pull avcC/esds out of",
+    "6b7b00b602405df8 1 1 - - if(/lyric/i.test(t)) throw new Error(\"This model needs lyrics — fill the Lyrics field (vocal models require them; leave empty / use a BGM model for instrumentals).\");",
+    "6ba52e53e3ef583f 1 1 - - const durMs = Math.round(totalTicks / t.timescale * mvTimescale);",
+    "6bb1f4d014e36129 1 1 - - if(typeof vid.requestVideoFrameCallback !== \"function\") return reject(new Error(\"this browser can’t read video frames (no requestVideoFrameCallback)\"));",
+    "6d4feeddb813a5d6 1 1 44cee28cc87688b0 44cee28cc87688b0 const px = n => PAD+BW/2 + (cx(n)-x0)*s + (iw-(x1-x0)*s)/2;",
+    "6d66939c43b15fe8 1 1 - - // lipsync's charged-aware retry ladder trims with THIS page's Web Audio decoder, so the",
+    "6db854a450674b6a 1 1 - - if(opts.response_format) body.response_format = opts.response_format;   // {type:\"json_object\"} for JSON mode",
+    "6e0a29ceef751316 1 1 - - throw new Error(\"this browser can’t record a supported video format\");",
+    "6e1910a4c7ac541e 1 1 - - // and say why — the long intent is a guaranteed reject at the social site, so \"falling back\" to it",
+    "6ec8de5c400eaaef 1 1 - - const stco = find(sb, \"stco\"), co64 = find(sb, \"co64\"), ctts = find(sb, \"ctts\"), stss = find(sb, \"stss\");",
+    "6eea74734ab0924f 1 1 - - el = new Audio(); el.crossOrigin = \"anonymous\"; el.loop = !!loop; el.preload = \"auto\"; el.src = ah.src;",
+    "6f0b355632f39d09 1 1 - cfff54a115006215 for(const tn of out){ const raw=tn.nodeValue, k=raw.trim(); if(!k) continue; const hit=i18nLookup(k); if(hit!=null) tn.nodeValue=raw.replace(k,()=>hit); }",
+    "6f18899e13495572 1 1 - - const r = await fetch(CHAT_ENDPOINT, { method:\"POST\",",
+    "6f5f8293a49dde72 1 1 - - if(p.without_audio!=null || p.with_audio!=null){ v = audioOn ? (_num(p.with_audio) ?? _num(p.without_audio)) : (_num(p.without_audio) ?? _num(p.with_audio)); if(v!=null) return v; }",
+    "6fe445db241d269a 1 1 3ce3214c0ae3111c,76b20b1ff7d18963,e2cfaa81921a7a6c,eb49569223879925 76b20b1ff7d18963,e2cfaa81921a7a6c,eb49569223879925 v.onerror = ()=> rej(new Error(\"could not read a clip\"));",
+    "7003e4742a5030e1 1 1 - - const body = { model, messages: opts.response_format ? messages : withLocale(messages) };",
+    "7165b4e5ff291ded 1 1 ac1a91aa5aa0b1b8 ac1a91aa5aa0b1b8 throw new Error(\"Link the .safetensors file on HuggingFace: open it and use Copy download link (…/resolve/main/your-lora.safetensors).\");",
+    "730c28f5ec8047e1 1 1 - - ws(0,\"RIFF\"); dv.setUint32(4, 36+dataLen, true); ws(8,\"WAVE\");",
+    "7370648fd145d410 1 1 - - fetchMedia: (url)=> client.fetchMediaDataUrl(url, io),",
+    "73a5400d1795a21a 1 1 - - // When shortening, we also render a 1200×630 PNG of the workflow's STRUCTURE — node cards and",
+    "7413827efadee033 1 1 - - const ext = (blob.type.split(\"/\")[1] || \"mp3\").split(\";\")[0];",
+    "7494cba4c1ba8bbe 1 1 d3a5ecf2d40bc60f d3a5ecf2d40bc60f return JSON.parse(m[1]===\"g\" ? await gunzip(bytes) : new TextDecoder().decode(bytes));",
+    "74a1c3a9ee149f70 1 1 8f45afe608ffcfb6 8f45afe608ffcfb6 throw new Error(\"This clip is a bit big to transcribe directly (~3 MB max) — nanoodle sends audio inline rather than uploading it (no S3 here). Use a shorter clip, or cut it down with the ✂️ Trim node.\");",
+    "74b11130c8f191f3 1 1 - - const verParts = (id)=> (id.match(VER_RE)||[]).join(\".\").split(\".\").map(Number);",
+    "74f5171f8ffe9e74 1 1 - - // (avcC / esds live in stsd). A false positive silently corrupts output, so default to NO on any doubt.",
+    "7582baba002a9dcc 1 1 - - <code id=\"agentmcpcmd\" class=\"ap-cmd\" aria-label=\"MCP install command\" data-no-i18n>claude mcp add nanoodle --env NANOGPT_API_KEY=<mark class=\"ap-key\">your-key</mark> -- npx -y nanoodle-mcp --graphs ~/noodles</code>",
+    "75a8aff06ca1593c 1 1 - - const usd = videoBaseUsd(p, f, audioOn, refOn);",
+    "766c46ff9398222e 1 1 - - if(kind === \"audio\"){ const mp4a = scanForBox(stsdRaw, \"mp4a\"); if(mp4a){ const adv = new DataView(mp4a.buffer, mp4a.byteOffset, mp4a.byteLength); channels = adv.getUint16(24); sampleRate = adv.getUint16(32); } }",
+    "768875c1f98f785f 1 1 - 2793fa1d71772f6b const finish = (v)=>{ if(done) return; done = true; resolve(v); };",
+    "768cdaab33e06011 1 1 - - out[\"frame\"+(i+1)] = canvas.toDataURL(\"image/jpeg\", 0.9);",
+    "76b20b1ff7d18963 1 1 6fe445db241d269a,9b405e1fc821d099,e2cfaa81921a7a6c 6fe445db241d269a,9b405e1fc821d099,e2cfaa81921a7a6c vid.onerror = ()=>{ cleanup(); reject(new Error(\"could not play a clip\")); };",
+    "772fc3d3b9d02a51 1 1 - - x:        `https://twitter.com/intent/tweet?text=${et}&url=${eu}`,",
+    "7759c763d29e867a 1 1 - - if(Math.abs(vid.currentTime - t) < 1e-3 && vid.readyState >= 2) requestAnimationFrame(done);",
+    "7774541c0626412d 1 1 - - return { concatMp4, isMp4, mp4ParamsMatch, parseMp4 };",
+    "77cffede97265eea 1 1 - - const t = (d && typeof d.shortUrl===\"string\") ? d.shortUrl.trim() : \"\";",
+    "77e4158cde426d6b 1 1 - - return { text: await ctx.transcribe(mdl(n), inp.audio, (n.fields.language||\"auto\").trim()) };",
+    "78587ff373373fca 1 1 - - let fmt = ((mt && mt[1] ? mt[1].split(\"/\")[1] : \"\") || \"wav\").toLowerCase();",
+    "7865fad47ff654d7 1 1 - - for(const l of (Array.isArray(graph.links)?graph.links:[])){",
+    "78b05ca56b45f99d 1 1 - - // cover-family models take only a HOSTED source (\"requires a valid http(s) audio URL\") — an",
+    "78f1205b02a9fb1b 1 1 - - async transcribe(model, audioUrl, language){",
+    "78f964000d3ae460 1 1 - - extra.audio = await remixSourceAudio(inp.audio);",
+    "79479e1da8d7fb36 1 1 - - is mp4 with matching codec params; concatVideos falls back to the recorder otherwise. No backticks",
+    "796dc9bd9bf75e92 1 1 3dbb18f3237a2fbb,772443d791681136,906c65b66625dd3c,a957ba62aae1c479,f3db5ad14c5818f1 - addEventListener(\"keydown\", e=>{ if(e.key===\"Escape\" && !$(\"agentpop\").hidden) setAgentPop(false); });",
+    "796f090e0bb22c4b 1 1 - - const png = /^data:image\\/png/i.test(dataUrl);",
+    "798c617c80a14eb3 1 1 - - if(!runId) throw new Error(\"no runId returned\");",
+    "79a76b1c7cd24775 1 1 - - const t = (blob.type||\"\").split(\";\")[0].trim().toLowerCase();",
+    "79b8268afdeba75d 1 1 - - const lo=_num(p.min_duration), hi=_num(p.max_duration);",
+    "7a3e3ab94c0c3135 1 1 - - // 200 HTML \"body bounce\" — the target URL rides in the response BODY — so the old da.gd",
+    "7a79f92ce75bd5f8 1 1 f9413c76ad7d95da 7f7b417e88552055,d33ab09faa1a9400,f10f3196d0ea82eb max-height:80vh; overflow:auto; background:var(--panel); border:1px solid var(--line);",
+    "7adfa5368a502f88 1 1 - - // whole \"Share to\" row is a guaranteed dead end (X/Reddit/Facebook reject multi-kB URLs, mail",
+    "7b030edeeee8d651 1 1 14fe927fb440ee1c 14fe927fb440ee1c if((v=rp(p.per_resolution))!=null) return v;",
+    "7bb33490c6d235fe 1 1 - - const mdhd = fullbox(\"mdhd\", 0, 0, u32(0), u32(0), u32(t.timescale), u32(totalTicks), Uint8Array.from([0x55,0xc4,0,0]));",
+    "7bf97c5fc7dd62c8 1 1 - - video: (model, prompt, opts, imageDataUrl)=>{",
+    "7c1dc48d5010fad6 1 1 - - // header, and CF's h3 edge stalls past ~10k — the binding limit is what recipients can load.",
+    "7c423a4d781e8362 1 1 - - }catch(e){ /* tainted/cross-origin canvas — assume opaque */ }",
+    "7cb4aae6e7561d28 1 1 - - if(!t || t===\"application/octet-stream\" || t===\"binary/octet-stream\"){",
+    "7ccad0e7eeae28fd 1 1 - - const scale = Math.max(bw/sw, bh/sh);                        // fill & crop: cover, centered",
+    "7cd1c96ba1424336 1 1 ffb342178dc06839 - throw new Error(\"reference images too large (~4 MB combined limit) — use fewer or smaller images\");",
+    "7d326f7a0967446d 1 1 - - function concat(arrs){ let len=0; for(const a of arrs) len += a.length; const out = new Uint8Array(len); let p=0; for(const a of arrs){ out.set(a, p); p += a.length; } return out; }",
+    "7d6f8d1a9f292869 1 1 - - // \"insufficient permissions\" masquerade as a funds problem and hand out conflicting guidance.",
+    "7d893d95cdc0139f 1 1 - - // samples in this chunk = spc from the applicable stsc entry",
+    "7ddcb7069cd2b423 1 1 - - // while a shorten is in flight, so its finally must restore through here too.",
+    "7e24bda9d7cb2dde 1 1 - - function airTakesNegative(air){ return !/^runware:(100|101|103|104|106|107|111|160|400)@/i.test(String(air||\"\")); }",
+    "7ee32d84416fc33b 1 1 - - // just moves the failure somewhere we can't explain it. If the link was already shortened",
+    "7f2365e08846d35a 1 2 - - if(/^(TypeError: )?(Failed to fetch|Load failed|NetworkError)/i.test(m.trim()))",
+    "7f26f04d7e7bf574 1 1 - - // Cloudflare Worker + KV. It replaced the third-party shorteners (da.gd/TinyURL), which saw",
+    "7f540857a9969e90 1 1 - - const saved=JSON.parse(sessionStorage.getItem(\"pkce\")||\"null\"); sessionStorage.removeItem(\"pkce\");",
+    "7f6b272eb59e4030 1 2 - - const sha256url = async (s)=>b64url(await crypto.subtle.digest(\"SHA-256\", new TextEncoder().encode(s)));",
+    "7f8a2fb67cf478d1 1 1 7fb234f159eacb09,871935013da574a1 6bbb92fe1baefd35,7fb234f159eacb09 vid.muted = true; vid.playsInline = true; vid.preload = \"auto\"; vid.crossOrigin = \"anonymous\";",
+    "7fb234f159eacb09 1 1 7f8a2fb67cf478d1,871935013da574a1 6bbb92fe1baefd35,7f8a2fb67cf478d1 vid = document.createElement(\"video\"); vid.muted = true; vid.playsInline = true; vid.crossOrigin = \"anonymous\"; vid.preload = \"auto\"; vid.src = vh.src;",
+    "80259350df8f965c 1 2 - - const out=[]; while(tw.nextNode()) out.push(tw.currentNode);",
+    "8038adf488875b24 1 1 5a6e05c0afce9e64 5a6e05c0afce9e64 const d = parseFloat(fields && fields.duration);",
+    "80ef396e2db3b466 1 1 - - const res = f.resolution, defRes = p.default_resolution ?? raw.defaultResolution;",
+    "813079d7d834fad6 1 1 - - // injected shrinkMedia, browser-canvas only — the offline guard runs this function without it)",
+    "8189c84497c9e0a8 1 1 - - const traks = moovBoxes.filter(b => b.type === \"trak\");",
+    "81ab3049d8f7e7cc 1 1 - - // Extract-audio node: fetch a video's container bytes and let decodeAudioData demux the audio track",
+    "825f1afa1cff7f73 1 2 - - root.querySelectorAll(\"[placeholder],[title],[aria-label]\").forEach(el=>{",
+    "82798f67376746d4 1 1 - - if(stss){ syncSet = new Set(); const n = dv.getUint32(stss.body + 4); for(let e=0;e<n;e++) syncSet.add(dv.getUint32(stss.body + 8 + e*4)); }",
+    "82d68a842cfcdd76 1 1 - - g.fillText(\"runs in your browser — bring your own key\", W-PAD+20, H-46);",
+    "82ecb5cb88145f42 1 1 - - const SHORTEN_CEILING = { nanolink: 131072, dagd: 9000 };",
+    "830c0bdca3fbb2e5 1 1 - - if(!isFinite(dur) || dur<=0) throw new Error(\"video has no readable duration\");",
+    "831209e03854a2aa 1 1 - - const finish = ()=>{ if(finished) return; finished = true; cleanup(); resolve(); };",
+    "83890d218eda6a91 1 1 - - (da.gd sits beside it, unemphasized, as the labeled third-party alternative).",
+    "83dd58a7ee977a8d 1 1 06d34a40890283f4,f6adaf8668dc5d6f 06d34a40890283f4,f6adaf8668dc5d6f if(txt==null) throw new Error(\"no text in response\");",
+    "841a29a87eca43f2 1 1 - - if(/\\b(civitai\\.com|civitai\\.red|civit\\.ai)\\b/i.test(u))",
+    "8475dc4182405ad7 1 2 - - localStorage.setItem(\"ngpt_client\",JSON.stringify({id,redirect:REDIRECT_URI}));",
+    "849629eeef0b6dec 1 1 - - // collect the LLM node's sampling/reasoning settings into a genChat options object (raw; genChat omits defaults)",
+    "84d144b33274ecbb 1 1 - - if(!/^data:image\\//i.test(src)) return resolve(null);",
+    "84e8f97f81537c79 1 1 - - const mdia = find(tb, \"mdia\"); if(!mdia) continue;",
+    "851d91a6aaca1148 1 1 07b422ca9b7fd16c 07b422ca9b7fd16c if(opts.audioUrl) body.audioUrl = opts.audioUrl;",
+    "8559753e4a0d28c2 1 1 1734565700623b4c,b463539f97c20158 1734565700623b4c,b463539f97c20158 return { image: await ctx.genImage(prompt, mdl(n), n.fields.size||SIZES[0][0], src, undefined, imgExtra(n)) };",
+    "8654288ab758585a 1 1 - - async function pollAudio(model, j, onProgress, runKey, bodySig){",
+    "86c010bb6ab09905 1 1 - - return { src:o, revoke:()=> URL.revokeObjectURL(o) };",
+    "86d1cda8cafa9144 1 1 - - async function packShareFit(base, samples, urlPrefix, shrinkMedia){",
+    "86fbb349791abb7f 1 1 - - if(scale>1) scale = 1;                                   // never upscale",
+    "87197408b37fcdc1 1 1 - - // any failure (or an implausibly large PNG) just means no card, and shortening proceeds.",
+    "87555b0d10fcd5f8 1 1 - - if(m.id===picker.current) b.className = \"sel\";",
+    "87a0707221325441 1 1 - - function encodeWavMono(samples, sampleRate){",
+    "88f834941720bc22 1 1 - - if(j.cost!=null) qs.set(\"cost\", j.cost);                 // these let the server auto-refund on failure",
+    "88fc87580289cd11 1 1 - - let t = fromEnd ? (dur - EPS - i*stepSec) : (i*stepSec);",
+    "893dc59ed6543918 1 1 5136b2acaca9f4ec 5136b2acaca9f4ec,5bda10d289e46b1f,ceeee510b171e38a const r = await fetch(`${NANOGPT}/oauth/register`,{method:\"POST\",headers:{\"Content-Type\":\"application/json\"},",
+    "897f79c320c9a255 1 1 - - if(vids.length !== 1) return null;                 // need exactly one video track",
+    "8a61b799060b3516 16 12 65d35cc6f5cd7704,c5521b76b218c14a,e1893250b982420d 65d35cc6f5cd7704,c5521b76b218c14a,e1893250b982420d ====================================================================== */",
+    "8b18e3dafdc4c4fe 1 1 - - facebook: `https://www.facebook.com/sharer/sharer.php?u=${eu}`,",
+    "8b41d92e8542155f 1 1 - - return new Error(\"could not read media (\" + (e.message||e) + \")\");",
+    "8b6a21a84b3c154d 1 1 - c7aa8a991388d57f const $ = (id) => document.getElementById(id);",
+    "8bca111c0612bd5b 1 1 f48f74ca1120b4a6 f48f74ca1120b4a6 try{ return await urlToDataUrl(tmp); } finally { URL.revokeObjectURL(tmp); }",
+    "8bd56179b7f262d3 1 1 - - if(np && airTakesNegative(air)) e.negative_prompt = np;",
+    "8bdedba39302322a 1 1 - - if(language) fd.append(\"language\", language);",
+    "8c7ecf5a7c41e7c3 1 1 - - if(!bytesEqual(s.v.codecCfg, base.v.codecCfg)) return false;   // same video SPS/PPS (avcC)",
+    "8d003471a549d8d0 1 1 43dac26b7eb288d5,63b3c9a2241c70c0,aad0d5470e64a9bc 43dac26b7eb288d5,63b3c9a2241c70c0,aad0d5470e64a9bc const sttsN = dv.getUint32(stts.body + 4);",
+    "8da7a1becbcb46bd 1 1 - - const songs = Math.max(1, parseInt(extra && (extra.number_of_songs||extra.n), 10)||1);",
+    "8ddd71ef184daf61 1 1 - - const hdlr = fullbox(\"hdlr\", 0, 0, u32(0), enc(t.kind===\"video\"?\"vide\":\"soun\"), new Uint8Array(12), hdlrName);",
+    "8e26a947bb81cfd9 1 1 - - const q = $(\"mpicksearch\").value.trim().toLowerCase();",
+    "8e964e9535fa85b4 1 1 - - let out = typeof txt===\"string\" ? txt : txt.map(p=>p.text||\"\").join(\"\");",
+    "8eff3babcc37f054 1 1 - - const opts = [\"auto\", ...langs.filter(l=>l!==\"auto\")];",
+    "8f2323e9315046f4 1 1 - - const handler = fourcc(dv, hdlr.body + 8); // after ver/flags(4)+pre_defined(4)",
+    "8f45afe608ffcfb6 1 1 74a1c3a9ee149f70 74a1c3a9ee149f70 throw new Error(\"This audio/video is a bit large (~4 MB max). nanoodle sends media inline rather than uploading it (no S3 here), so NanoGPT's edge won't accept it. Use a shorter clip — the ✂️ Trim node can cut audio down to size.\");",
+    "8f59978490027627 1 1 - - || scanForBox(stsdRaw, \"hvcC\") || scanForBox(stsdRaw, \"vpcC\") || scanForBox(stsdRaw, \"av1C\");",
+    "904e610149650be4 1 1 01aae5325995f19c,422f7d6384a2929c,a7c1c8a59680286d 01aae5325995f19c,422f7d6384a2929c <button id=\"sm-copy\" class=\"sm-copy\">Copy</button>",
+    "905bf1f45dc2fe0e 1 1 - - // Emoji/labels mirror NODE_TYPES (kept inline: play.html's registry lives inside RUNTIME_JS).",
+    "907e48087159049d 1 1 - - // deliberately locale-less), except in JSON/structured mode where it corrupts the output.",
+    "910bc9f9e945e822 1 1 - - // clients cut multi-kB bodies). Blank the row (and its heading) rather than dangle broken buttons.",
+    "915154dbe7cd3e1a 1 1 d7a90bddd4e50b6e d7a90bddd4e50b6e const w = Math.max(0, parseInt(n.fields.width,10)  || 0);",
+    "91d9f51a5b9d9cea 1 1 - - const anyCts = t.samples.some(s=>s.cts!==0);",
+    "92068a479add3145 1 2 1d0d9b68f95b69e4,e97a1e5b3f0d508e 6eb73fc9fd81e667,e97a1e5b3f0d508e <meta property=\"og:image\" content=\"https://nanoodle.com/og-card.png\" />",
+    "9250d7c7c04b1784 1 1 - - return status===402 || (status!==401 && status!==403 && /insufficient|balance|funds|not enough|payment required/i.test(String(body||\"\")));",
+    "927b790414bda39c 1 1 dfc94b1e755f6480 dfc94b1e755f6480 if(ctts){ const n = dv.getUint32(ctts.body + 4); let ci = 0; for(let e=0;e<n;e++){ const cnt = dv.getUint32(ctts.body + 8 + e*8); const off = dv.getInt32(ctts.body + 12 + e*8); for(let k=0;k<cnt && ci<sampleCount;k++) cts[ci++] = off; } }",
+    "92e0dcde1976f01c 1 1 - - const cx = c.getContext(\"2d\"); cx.imageSmoothingEnabled = true; cx.imageSmoothingQuality = \"high\";",
+    "9309e2d79408f879 1 1 - - const d = ctx.getImageData(0, 0, w, h).data;",
+    "9391d08371843aad 1 1 - - const stbl = find(minfB, \"stbl\"); const sb = walk(dv, stbl.body, stbl.end);",
+    "939e42188da426b4 1 1 d4393b80f8f8b718 d4393b80f8f8b718 for(const k of [\"text_to_video_per_second\",\"text_image_without_audio_per_second\",\"image_to_video_without_audio_per_second\"]){",
+    "93a1811b8d8e2499 1 1 c256a3d44fbdbf6e c256a3d44fbdbf6e document.querySelectorAll('#sharemenu .sm-social a:not([data-soc=\"email\"])').forEach(a=> a.onclick = (e)=>{",
+    "93e9a2e7c86d722c 1 1 efc41ac685fb0943 4f39e25541d804e5,c87b00bc6c09d0a3,efc41ac685fb0943 if(t.audioInput) for(const l of graph.links){",
+    "940286cba1a54799 1 1 - - const stts = find(sb, \"stts\"), stsc = find(sb, \"stsc\"), stsz = find(sb, \"stsz\");",
+    "9522e02bfadad822 1 1 - - // A pending entry must SURVIVE Stop and the poll timeout — the job is already submitted and",
+    "9528ab15e484aa87 1 1 - - let d = null; try{ d = await r.json(); }catch(_){}",
+    "9535478d5be94215 1 1 - - if(type===\"image\" && (parseInt(rn.fields.variations,10)||1) > 1) return null;",
+    "955efff1a5bb355f 1 1 0caddde7bca218a4,0cb248569f083b7a,1a6160d189e5f21e,21f44abe653a4445,2217e07ec079d623,279e8eec65de2560,2efe479e52de7fdb,4574d9ed1029493f,51a557b33abea28a,7ad48daadfc0b288,85eabf925f00506d,87fec2241e38d45f,8cdb65a6754983f0,90bc5c617dcdcbb4,a0f00cba3bc00975,bcf755614262ab11,c04e7b195a467b0c,c9c6ad076e85db33,e3750ada7641da1c,e66ce681898a93b6,efdec351263ecf0d 2562f5ffb46ddbfa,2bf75eb52aa43d7a,2efe479e52de7fdb,36ac5c4f00c2c9d4,375bd6ecddd366ac,3e8917ecd398e5e4,43b107cac12d1f16,66996f5ba428c756,87e0ae98ede59aac,88807fa60fda186c,c6cf75d4487395c0,d322b3f1a54cab3c,ff673e2ae8ac8709 background:var(--panel2); border:1px solid var(--line); border-radius:.45rem; padding:.4rem .5rem;",
+    "95bda37e898817a1 1 1 4badb1682e49a898,e14d69fc530a827d 4badb1682e49a898 if(f.temperature!=null && f.temperature!==\"\") o.temperature = +f.temperature;",
+    "95e6aa7d7020bff9 1 1 - - const v = m ? +m[1].replace(/,/g,\"\") : 0;",
+    "96066322af3461c5 1 2 - - if(p.get(\"error\")) throw new Error(p.get(\"error\"));",
+    "96312a87a45475d2 1 1 - - .sm-svc button.sm-primary::before{ content:\"✓\"; color:var(--accent); font-weight:700; }",
+    "970c360c358ebb13 1 1 efba54d5339fbd53 efba54d5339fbd53 if(!w && !h) throw new Error(\"set a width or height to resize to\");",
+    "97c2b2bd94a7365f 1 1 - - || /generation_count|num_?songs|song_?count/i.test(k)) delete body[k];",
+    "985d9694cdae5f21 1 2 47c106d7e8b5daf1 47c106d7e8b5daf1 <meta property=\"og:image:width\" content=\"1200\" />",
+    "98b0ff5595d27ba9 1 1 - - <input id=\"sm-url\" class=\"sm-url\" readonly />",
+    "98b51c440bec828c 1 1 - - if(imageDataUrl) body.imageDataUrl = imageDataUrl;",
+    "98bda6c1eda6f203 2 1 - - async genImage(prompt, model, size, imageDataUrl, maskDataUrl, extra, opts){",
+    "98fe3c4654d63aff 1 1 - - else if(/left.{0,6}audio|right.{0,6}audio|left and right/i.test(msg))",
+    "998d26515ae4f345 1 1 - - const mdat = concat([u32(mdatData.length + 8), enc(\"mdat\"), mdatData]);",
+    "999a06f362dc63d9 1 1 - - await new Promise((res, rej)=>{ el.oncanplaythrough = res; el.oncanplay = res; el.onerror = ()=> rej(new Error(\"could not load the audio clip\")); el.load(); });",
+    "9a0bd1adb9f8037d 1 1 - - if(st===\"completed\" || st===\"succeeded\"){",
+    "9a38bd00941bff51 1 1 4a8090ce43fabf3d,7f8dcd1a85d5bf7f - const v = per[size] ?? per.square ?? per.square_hd ?? Object.values(per)[0];",
+    "9a551ad64c6a72e7 1 1 - - if(finish===\"length\") throw new Error(content.trim()",
+    "9a7b121f6ac40024 1 2 - - const keySendable = (k)=> /^[\\x21-\\x7E]+$/.test(k);   // printable ASCII — anything else can't ride in an HTTP header",
+    "9acc093356545ee1 1 1 - - return { order, cyclic:[...ids].filter(id=>!order.includes(id)) };",
+    "9ae8a27ff0221d68 1 1 - - <p id=\"sm-toolong\" class=\"sm-warn\" hidden></p>",
+    "9b1ab88379d8af97 3 1 - - let x0=Infinity,y0=Infinity,x1=-Infinity,y1=-Infinity;",
+    "9b405e1fc821d099 1 1 3ce3214c0ae3111c,76b20b1ff7d18963,e2cfaa81921a7a6c,eb49569223879925 76b20b1ff7d18963,e2cfaa81921a7a6c,eb49569223879925 vid.onerror = ()=> reject(new Error(\"could not play the video\"));",
+    "9bbd786f981943b2 1 1 - - for(const t of tiers) packed.push({ ...t, url: await pack(t.s.length ? { ...base, samples:t.s } : base) });",
+    "9c6a96508a5a72d4 1 1 189b51a540d14c68 - : \"swap your-key for your NanoGPT API key — or sign in here first and it's filled in for you\");",
+    "9d59d37983779a67 1 1 c9866ef418032989 28a37fd9699015a3 if(p[k]!=null){ v = (typeof p[k]===\"object\") ? rp(p[k]) : _num(p[k]); if(v!=null) return v*dur; }",
+    "9d8de6ed9958c2af 1 1 - - const body = { model, size, n: opts.n||1, response_format:\"b64_json\" };",
+    "9e032bb099bd508b 1 1 - - <p class=\"ap-agents\"><span>works in</span> <b data-no-i18n>Claude Code, Grok build, Cursor, Gemini CLI</b> <a href=\"https://agentskills.io\" target=\"_blank\" rel=\"noopener\">&amp; more</a></p>",
+    "9e0e76f169ab54cc 1 1 - - $(\"mpicksearch\").addEventListener(\"input\", renderPicker);",
+    "9e2176a3f5904730 1 1 - - onProgress && onProgress(\"combining clips…\");",
+    "9e24910193a0e5e2 1 1 - - const body = Object.assign({ model, input }, extra||{});",
+    "9ee015abd157f281 1 1 - - // Samples are the recipient's pre-sign-in preview, but a link the pipeline can't carry shows",
+    "9ef3149ca0ef001a 1 1 - - g.textBaseline=\"alphabetic\"; g.textAlign=\"left\";",
+    "9f0b67e8171d6210 1 1 - - // the single audio port on audio-input chat models → read by run() as inp.audio",
+    "9f11878d4a76bf53 3 1 - - return { id:m.id, name:m.name||m.id, created:m.created,",
+    "9f39bfc54b20dfce 1 1 1692c942a432583e,af882b199644f235 1692c942a432583e,af882b199644f235 if(imgRe && imgRe.test(l.to.port)) continue;   // image ports aren't text-field overrides",
+    "9f58723bd236c95a 1 1 - - out.push({ type, start: p, end: p+size, body: p+hs });",
+    "9f91981f58416980 1 1 - - vh.revoke && vh.revoke(); ah.revoke && ah.revoke();",
+    "9f931f2c744450d8 1 1 - - if(inp2===inp) inp2 = Object.assign({}, inp);",
+    "9fd6cb9bd15551b8 1 1 - - // Build mdat first so chunk offsets are known. Layout: ftyp + mdat + moov.",
+    "9fdab4fddba71331 1 1 - - if(!dir || !Array.isArray(messages)) return messages;",
+    "a01ce8ef1ecd7494 1 1 - - g.font=\"600 34px system-ui, sans-serif\"; g.fillStyle=\"#f4f4f8\";",
+    "a0482a1a507dcd80 1 1 - - // Upscalers just enlarge — they need no instruction. Every other edit model requires one.",
+    "a088986990f77a34 1 1 - - const MEDIA_INLINE_MAX = 4.4*1024*1024;   // edge (Vercel) rejects request bodies over ~4.5 MB; guard inlined base64 media",
+    "a0b408d4b33ea384 1 1 2a96417b6387d69d 2a96417b6387d69d if(reqRes!=null && map[reqRes] && typeof map[reqRes]===\"object\") return map[reqRes];",
+    "a10f88e04c1feca8 1 1 - - // ceiling the button greys out with a note instead of round-tripping into a guaranteed 4xx.",
+    "a18fa5fa3cbafbca 1 1 - - else if(p.duration_multipliers) mult=_num(p.duration_multipliers[dk]) ?? pickByRes(p.duration_multipliers) ?? 1;",
+    "a2c36df296a728a7 1 1 - - // Build the share-to-<service> intent URLs for a given link. Factored out so the social",
+    "a422d441f505e75a 1 1 14e65713ad7cca46 14e65713ad7cca46,670d56e94e455504 let w = img.naturalWidth, h = img.naturalHeight;",
+    "a44fe30f40122259 1 1 - - // assemble mdat data, recording each sample's absolute offset",
+    "a4828dda7a8beb7d 1 1 - - if(/^(data:|blob:)/.test(url)) return { src:url, revoke:null };",
+    "a4a630e5bffe7e27 1 1 - - const merged = { kind, timescale: outTs, stsdRaw: base.tracks[ti].stsdRaw, width: base.tracks[ti].width, height: base.tracks[ti].height, samples: [] };",
+    "a4ab1beb137fcaa2 1 1 - - else if(/\\blarge\\b|MEDIA_INLINE|~4 MB|inline/i.test(msg))",
+    "a4dbefcdef36c616 1 1 - - const objs = Object.values(map).filter(v=>v && typeof v===\"object\");",
+    "a5f1128a96646deb 1 1 - - : `${label} couldn't shorten it (${e.message}) — share the full link instead, it always works`, \"err\");",
+    "a60cf909940d7478 1 1 - - /* nanolink — nanoodle's own first-party shortener — is the primary shorten button",
+    "a62a65f6b5b88594 1 1 - - // stss -> sync set (1-based). absent => all sync",
+    "a687e7b0aec22faf 1 1 2e39d1f30bc77aa2,e6757853f11f1e92,edec12afc74be9d6 2e39d1f30bc77aa2,e6757853f11f1e92,edec12afc74be9d6 if(b64.startsWith(\"iVBOR\")) return \"image/png\";",
+    "a6a36c95a68e8554 1 1 - - res(c.toDataURL(png ? \"image/png\" : \"image/jpeg\", png ? undefined : 0.92));",
+    "a79fb900455d9b25 2 2 - - if(typeof canvas.captureStream !== \"function\") throw new Error(\"this browser can’t capture a canvas stream\");",
+    "a7d5026ac32c85e6 1 1 - - case \"flux2klein\": case \"zimage\": case \"ltx\": return 3;",
+    "a7dac7f471b9312c 1 1 4406a72bd8888f6a,e0aa6102953350ad,e350e0485af6c06a 03ceb15d371b47ba,4406a72bd8888f6a,7cc8bfc13f47f1d1,7f8230bc730ceed3,9feb47c4df29f895,f5e6cfd2557b0e60,ff59a49c4f172342 display:inline-flex; align-items:center; gap:.3rem; }",
+    "a8155e40ee25ba45 1 1 - - for(let i=0; i<Math.max(va.length, vb.length); i++){",
+    "a8325228e8438605 1 1 - - // Prompt-length caps (see the PROMPT LENGTH CAPS block): a prompt over this model's cap is",
+    "a83cb22f9033ce5c 1 1 - - const keepPending = (e)=> !!(e && (e.code===\"timeout\" || e.code===\"aborted\" || e.name===\"AbortError\")) || !!(io.signal && io.signal.aborted);",
+    "a8cb22b954de6907 1 1 5102297269c5e0e9,52e7c16c6ab75d31,59157d58bc5429b4,b5d419871e8d7580,d36c7d6d21532c83,e38588dcf41ed840,f4dff16f458d3ffa 52e7c16c6ab75d31,59157d58bc5429b4,7491fd87c8a97620,b5d419871e8d7580,d36c7d6d21532c83,e38588dcf41ed840,f4dff16f458d3ffa const c = document.createElement(\"canvas\"); c.width=W; c.height=H;",
+    "a97827e0c705b0aa 1 1 - - if(f.type===\"number\"){ let num=Number(v); if(isNaN(num)) continue;",
+    "a9d6c33b90a0a86c 1 1 - - if(p.base_price!=null){ v=_num(p.base_price); if(v!=null) return v; }",
+    "aa4ee037f29e536b 1 2 - - try{ img.src = src; }catch(_){ finish(null); }",
+    "aa7fdd434f92eeea 1 1 25e34b8371a3c99b,4770a0aa6e609c54,bc6b940f16fb27d4 bc6b940f16fb27d4 .sm-url{ flex:1; min-width:0; font-size:.78rem; font-family:ui-monospace,monospace; color:var(--dim);",
+    "aad0d5470e64a9bc 1 1 43dac26b7eb288d5,63b3c9a2241c70c0,8d003471a549d8d0 43dac26b7eb288d5,63b3c9a2241c70c0,8d003471a549d8d0 const stscN = dv.getUint32(stsc.body + 4);",
+    "ab0001d52398d6bd 1 1 - - // Materialize page-local blob: media (Trim / Extract audio / Combine / Soundtrack outputs)",
+    "ab109445e7cca42c 1 2 - - body:new URLSearchParams({grant_type:\"authorization_code\",client_id:saved.id,redirect_uri:REDIRECT_URI,code:p.get(\"code\"),code_verifier:saved.verifier})});",
+    "ab75c6e8992a58cf 1 1 - - await new Promise((res, rej)=>{ vid.onloadeddata = ()=>{ if(typeof vid.requestVideoFrameCallback !== \"function\") rej(new Error(\"this browser can’t read video frames (no requestVideoFrameCallback)\")); else res(); }; vid.onerror = ()=> rej(new Error(\"could not load the video\")); });",
+    "ab993a9bd0ee0ee1 1 2 - - const REDIRECT_URI = location.origin + location.pathname;",
+    "ac1a91aa5aa0b1b8 1 1 7165b4e5ff291ded 7165b4e5ff291ded throw new Error(\"That looks like a HuggingFace repo id — open the .safetensors file and copy its download link (…/resolve/main/your-lora.safetensors).\");",
+    "ac285e56a4acbc9d 1 1 - - const messages = [{ role:\"user\", content:[",
+    "ac57ac573e2f540c 1 1 - - @media (prefers-reduced-motion: reduce){ *,*::before,*::after{ animation-duration:.001ms !important; animation-iteration-count:1 !important; transition-duration:.001ms !important } }",
+    "acc98c3b4f22b8b3 1 1 - - // ctts -> per-sample composition offset (may be signed in v1; treat as int32)",
+    "add89e502ce26fea 2 2 - - let stored=null; try{ stored=localStorage.getItem(\"noodle_lang\"); }catch(e){}",
+    "adedaf8f735176ac 1 1 - - for(let ti=0; ti<base.tracks.length; ti++){",
+    "ae4b8d3cdbfca761 1 1 - - if(opts.extra) Object.assign(body, opts.extra);      // per-model catalog options (preset/style/effect/…)",
+    "ae73ee0a0224059a 2 2 - - const rec = new MediaRecorder(stream, { mimeType:mime, videoBitsPerSecond: vbps });",
+    "aee23fed666dad5b 1 1 - - }finally{ btn.textContent = o; syncShortenButtons(); }",
+    "af0c64c9e3a62791 1 1 - - const kind = handler === \"vide\" ? \"video\" : handler === \"soun\" ? \"audio\" : handler;",
+    "af882b199644f235 1 1 1692c942a432583e,9f39bfc54b20dfce 1692c942a432583e,9f39bfc54b20dfce if(t.videoInputs && VID_PORT_RE.test(l.to.port)) continue;   // clip ports aren't text-field overrides",
+    "af8b5f100a69b05d 1 1 - - // audio rate/channels from the mp4a sample entry (esds carries clip-specific bitrate, so it's not",
+    "afa24722bf4c7c76 1 1 - - // NANOLINK_ORIGIN is the deployed worker (canonical host; see the nanolink repo's",
+    "b016e29254336daf 1 1 - - // remix shares audioBody's extraJson textarea and surfaces one URL too, so it needs the same clamp.",
+    "b0a2d671cf810e67 1 1 e8dcfdf107a748d6 e8dcfdf107a748d6 g.fillStyle=\"#16161d\"; g.fillRect(0,H-92,W,92);",
+    "b0b24d91a975a5f5 1 1 - - if(kind !== \"video\" && kind !== \"audio\") continue;",
+    "b0c9f3694cdc1453 1 2 - - <meta name=\"twitter:card\" content=\"summary_large_image\" />",
+    "b1823bb159eefd27 1 1 6ac710886a202d29,b6f2444936aae78f 6ac710886a202d29,b6f2444936aae78f async run(n){ if(!n.fields.image){ if(optNode(n)) return { image:\"\" }; throw new Error(\"no image — upload or capture one first\"); } return { image: n.fields.image }; }",
+    "b210151c4143fc92 1 1 - - const _num = (x)=> (x!=null && isFinite(+x)) ? +x : null;",
+    "b2754d6851671740 1 1 - - async run(n){ return { text: n.fields.text||\"\" }; }",
+    "b298f25eaace22ce 1 1 de87d681168a1874,e2cc702b7605072e de87d681168a1874,e2cc702b7605072e <a data-soc=\"x\" target=\"_blank\" rel=\"noopener\">𝕏</a>",
+    "b2c1e99f1e37f33d 1 1 - - return { type:\"input_audio\", input_audio:{ data, format:fmt } };",
+    "b2daff3ad06bb6e1 1 1 - - if(fmt===\"mpeg\" || fmt===\"mp3\") fmt = \"mp3\";",
+    "b2ec41f960e2a533 1 2 - - const SUP={ en:1, es:1, fr:1, de:1, pt:1, ja:1 };",
+    "b4025e0849f523ca 1 1 - - // runKey + bodySig: the job is stashed in PENDING_AUDIO so a re-run resumes without re-charging.",
+    "b407642be54c82f9 1 1 - - // hazard (Cloudflare's h3 edge stalling on >~10k Location headers) doesn't apply. Past the",
+    "b44a325727683b69 1 1 - - const cap = /up to\\s+(\\d+(?:\\.\\d+)?)\\s*second/i.exec(msg);",
+    "b463539f97c20158 1 1 8559753e4a0d28c2 8559753e4a0d28c2 return { image: await ctx.genImage(prompt, mdl(n), n.fields.size||SIZES[0][0], source, mask, imgExtra(n)) };",
+    "b4cb9a44c26bad70 1 1 - - if(f.maxTokens) o.max_tokens = +f.maxTokens;",
+    "b4e1bdfa3c2441f4 1 1 - - if(/^persona:\\d+@\\d+/i.test(s)) return s.replace(/^persona:/i, \"persona:\");",
+    "b556115c632ba3a2 1 1 - cec0877d7d141bb4 const r = await fetch(NANOLINK_ORIGIN + \"/api/links\", { method:\"POST\",",
+    "b597a15c68d47ac4 1 1 - - // POST /api/links → {slug, shortUrl}. A few-second timeout: shortening is a nicety and the",
+    "b5a7625714fe75db 1 1 - - const EPS = 0.04;   // back off from the exact end — seeking to =duration often yields no frame",
+    "b5d419871e8d7580 1 1 5102297269c5e0e9,52e7c16c6ab75d31,a8cb22b954de6907,d36c7d6d21532c83,e38588dcf41ed840,f4dff16f458d3ffa 52e7c16c6ab75d31,7491fd87c8a97620,a8cb22b954de6907,d36c7d6d21532c83,e38588dcf41ed840,f4dff16f458d3ffa const c = document.createElement(\"canvas\"); c.width = w; c.height = h;",
+    "b60fa92bb9d36205 1 1 3c4f98dbbd667800 3c4f98dbbd667800 const vids = p.tracks.filter(t=>t.kind===\"video\");",
+    "b6f2444936aae78f 1 1 6ac710886a202d29,b1823bb159eefd27 6ac710886a202d29,b1823bb159eefd27 async run(n){ if(!n.fields.audio){ if(optNode(n)) return { audio:\"\" }; throw new Error(\"no audio — upload a clip first\"); } return { audio: n.fields.audio }; }",
+    "b7d539045cb1cb70 1 1 - - return { text: [inp.a, inp.b].filter(v=>v!=null && v!==\"\").join(sep) };",
+    "b839f88fa6de17b4 1 1 - - const short = await shortenWith(svc, longUrl);",
+    "b852059a4a074969 1 1 - - if(fam===\"pimage\") return { lora_weights:items[0].url, lora_scale:sc(items[0].scale) };",
+    "b859cbe3ed422c29 1 1 - - no decode/re-encode, no MediaRecorder, no AudioContext. Duration is exact by construction and it",
+    "b8802e26f56f8bf6 1 1 - - const nf = _num(raw.defaultNumFrames) || (dur * (_num(raw.defaultFramesPerSecond)||24));",
+    "b954e92dd379cf51 1 1 - - const W=1200, H=630, PAD=80, BW=200, BH=64;",
+    "b98e0deeaf5a5c7c 1 1 - - document.querySelectorAll(\"#sharemenu .sm-svc button\").forEach(btn => btn.onclick = async ()=>{",
+    "b99ebc7b81444bc4 1 1 - - const iw = W-2*PAD-BW, ih = H-2*PAD-BH-40;",
+    "ba8f6a0a3026f7dd 1 1 - - if(s.na !== base.na) return false;                 // all-or-none audio",
+    "ba9449101f021537 1 1 4c95bc677b65d14a 4c95bc677b65d14a const ah = await toLocalMediaUrl(audioUrl);",
+    "badc1ee4f0a0d080 1 1 - - // Map a video node's stored dimension fields (resolution/aspect/duration) to the WIRE param names its",
+    "bb65a56372bb10bd 1 1 - - catalog: null,   // filled per run by njsRunFor (async prefetch, then cached)",
+    "bb690e9fa1db3b6c 1 1 - - if(base.a && (s.a.sampleRate !== base.a.sampleRate || s.a.channels !== base.a.channels)) return false; // audio concat-compatible",
+    "bbab76fca1c7e5b2 1 1 - - function resizeCropImage(dataUrl, mode, tw, th){",
+    "bc2853f66f3d737f 1 1 e6105fc038512f97 e6105fc038512f97 function u16(n){ const a = new Uint8Array(2); new DataView(a.buffer).setUint16(0, n & 0xffff); return a; }",
+    "bc6b940f16fb27d4 1 1 25e34b8371a3c99b,4770a0aa6e609c54,aa7fdd434f92eeea aa7fdd434f92eeea #agentpop .ap-cmd{ flex:1; min-width:0; font-size:.72rem; font-family:ui-monospace,monospace; color:var(--dim);",
+    "bc6e95266b7c1c55 1 1 - - if([\"error\",\"failed\",\"content_policy_violation\"].includes(st)){",
+    "bcc8f8f7938ce5a6 1 1 - - if (location.hostname === \"127.0.0.1\") location.hostname = \"localhost\";",
+    "bcd2c2c1c4828798 1 1 - - const cts = new Array(sampleCount).fill(0);",
+    "bd23dcfefad0bffb 1 2 fe408d98c5e61b13 fe408d98c5e61b13 if(!AC || !OAC) throw new Error(\"this browser can’t process audio (no Web Audio API)\");",
+    "bd27715620a7b8e1 1 1 - - const hasMedia = compact.length < all.length;",
+    "bd44967af02208e1 1 1 - - if(!keySendable(k)){ $(\"keyinput\").focus();",
+    "bdab3bbdb05ce620 1 1 - - const head = s.slice(0, cap), floor = Math.floor(cap*0.7);",
+    "bde3d7ecd5d6086b 1 1 - - // URL shortening — FIRST-PARTY via nanolink (github.com/nanoodlecom/nanolink), our own",
+    "bdf09c5643bdacf0 1 1 - - const find = (boxes, type) => boxes.find(b => b.type === type);",
+    "bedbdf08b7432ee4 1 1 5675e8341f9e0ecd 4263e1420b2edce8 return { text: await ctx.genChat(messages, mdl(n)) };",
+    "bf0a3aaa1d9e28f4 1 1 - - toast(ok ? `✓ Short link copied — via ${label}` : `Short link ready — copy it above`, ok?\"\":\"err\");",
+    "bfca14321e605a11 1 1 - - if(!t){ throw new Error(\"clip \"+ci+\" missing \"+kind+\" track\"); }",
+    "c0058284f1965f76 1 1 d7b4c33c53722b95 d7b4c33c53722b95 const length = parseFloat(n.fields.length);",
+    "c065d564d84c9f2f 1 1 - - const fromEnd = (n.fields.dir||\"end\")===\"end\";",
+    "c0aa9967e6ee15c6 1 1 - - // dynamic clip ports (vid1, vid2, …) on the Combine node → collected by run() via collectVideoInputs()",
+    "c0af4d705329fae8 1 1 - - const TEMP_LOCKED = /(^|\\/)(azure-)?o[134](-|$)|(^|\\/)gpt-5(?![.\\d-]*chat)|(^|\\/)gpt-latest$|-search-preview$/;",
+    "c0ddefb2979fea8c 1 1 - - // true only if some pixel is actually see-through — a fully-opaque PNG still encodes as JPEG.",
+    "c0e0a3c8a464923e 1 1 - - return { audio: await extractAudioToWavUrl(inp.video, start, length, 16000) };",
+    "c147289311595709 1 1 - - function needsCustomCivitai(model){ return model === \"custom-civitai\"; }",
+    "c1b68c9037ff312a 1 1 - - const isMediaTier = (p)=> p.stripped===null || p.stripped===\"shrunk\";",
+    "c1cb60ad89abf083 2 2 - - const stopped = new Promise((res, rej)=>{ rec.onstop = res; rec.onerror = e=> rej((e && e.error) || new Error(\"recording failed\")); });",
+    "c223e78f4579a83a 1 1 - - return { x:(e.clientX-r.left)*sx, y:(e.clientY-r.top)*sy, s:Math.max(sx,sy) }; };",
+    "c256a3d44fbdbf6e 1 1 93a1811b8d8e2499 93a1811b8d8e2499 document.querySelectorAll('#sharemenu .sm-social a[data-soc=\"email\"]').forEach(a=> a.onclick = ()=> closeShareMenu());",
+    "c34606b10fd162dd 1 1 - - // Re-encode one inlined preview image smaller (data: URLs only — no CORS taint) so packShareFit",
+    "c37180416bb25b69 1 1 - - if(opts.aspect_ratio) body.aspect_ratio = opts.aspect_ratio;",
+    "c3843441413e689b 1 1 - fe0c29e7be15e3ab .sm-svc button, .sm-social a{ font-size:.82rem; padding:.4rem .6rem; border-radius:.5rem; cursor:pointer;",
+    "c3f2369b2bf99510 1 1 eb5e1b2081b94fe0 a064f1d86a6d8221 return { audio: await ctx.genAudio(mdl(n), text, extra,",
+    "c41ead1ed9724da5 1 1 0ad57abf5b8efd5f,83935f5ec3c88713,a76297e21b97e9c5,bdc3952c44839249,d0e38c8a84541fd2,d98bbfbfb4210c1d 38d10bb7b35ad71f,7adc61040206e57c,815c64f1a3ada827,c0a2db176a45e276,ea4b0f075efc7aaf .sm-warn{ font-size:.74rem; color:var(--dim); margin:.15rem .15rem .35rem; line-height:1.45;",
+    "c42e96fd041c6a2c 1 1 - - const url = await pollAudio(model, pend.job, onProgress, runKey, bodySig);",
+    "c4c30d0ac9ee2330 1 1 - - if(clips.length < 2) throw new Error(\"wire at least two clips to combine\");",
+    "c4dc43d08e336bf0 1 1 1899bbdf29d0cf0c,2de8cc80528c04d5 1899bbdf29d0cf0c,2de8cc80528c04d5 if(raw.withAudioPrices){ const inner=pickObjByRes(raw.withAudioPrices, res, defRes); if(inner){ const dk=String(Math.round(dur)); v=_num(inner[dk]) ?? pickByRes(inner); if(v!=null) return v; } }",
+    "c4ec3391a9306e84 1 1 - - // payload toward this budget (the same ~9k figure the old shortener pipeline imposed).",
+    "c4fab1a8b633ce2e 1 1 - - const src = imgs.length>1 ? imgs : imgs[0];   // array → multi-image composite; string → single edit (unchanged)",
+    "c5521b76b218c14a 1 16 65d35cc6f5cd7704,8a61b799060b3516,e1893250b982420d 65d35cc6f5cd7704,8a61b799060b3516,e1893250b982420d /* =====================================================================",
+    "c566e138f0049f8e 1 1 - - if(p.per_frame_unit!=null){ const fpu=_num(p.frames_per_unit)||1; return (dur*EST.videoFps/fpu)*_num(p.per_frame_unit); }",
+    "c568917499376326 1 1 - - if(hasMedia && typeof shrinkMedia === \"function\"){",
+    "c62adffdeefb4a38 1 1 - - if(!kind || !id || !(cap>0) || learnedCaps[kind+\":\"+id]===cap) return false;",
+    "c66b1be188afa70c 1 1 - - const w = Math.max(1, Math.round(sw*scale)), h = Math.max(1, Math.round(sh*scale));",
+    "c69eba1fe7df9f79 1 1 - - // images/video/audio price top-level (j.cost); chat completions ride it in",
+    "c73835cd71bf70fb 1 1 - 3d12843e7b19b045 resume: (prev && prev.sig===sig) ? prev.runId : undefined,",
+    "c7ef4092f25f67af 1 1 - - return { audio: await trimAudioToWavUrl(inp.audio, start, Number.isFinite(length) ? length : 30, 16000) };",
+    "c80e1458392787ba 1 1 - - // plus a note when shortening can't help. The attempt handler blanket-disables the buttons",
+    "c855d95186377e8a 1 1 - - const t = document.createElement(\"a\"); t.href = href; t.target = \"_blank\"; t.rel = \"noopener\";   // popup blocked: best-effort new tab",
+    "c88a07fa8273cf26 1 1 - - <span class=\"dim\" style=\"flex-basis:100%;font-size:.72rem\">new to NanoGPT? <a href=\"https://nano-gpt.com/r/mgzwtqjw\" target=\"_blank\" rel=\"noopener\">create an account →</a> — pay-per-use, no subscription needed; your key stays in this browser.</span>",
+    "c89263b1f8975eeb 1 1 - - const co = stco || co64; const is64 = !!co64;",
+    "c89b1783989e2733 1 1 - - const va = verParts(a), vb = verParts(b);",
+    "c8dfa0ccba1a1ce7 1 1 - - // nanolink stores URLs up to 128 KiB (its MAX_URL_LENGTH) and answers GET /<slug> with a",
+    "c8e6fea7a6576553 1 1 - - return new Blob([ab], {type:\"audio/wav\"});",
+    "c8f2a73fb0190f2f 1 1 - - return { image: urls[sel], images: urls };",
+    "c93197157b59897c 1 1 - - .sm-svc, .sm-social:not([hidden]){ display:flex; gap:.4rem; flex-wrap:wrap; }   /* :not([hidden]) — a bare display rule would defeat the hidden attr when the social row is blanked */",
+    "c95121c12dd38a65 1 1 - - if(typeof inp[k]===\"string\" && inp[k].slice(0,5)===\"blob:\"){",
+    "c9ad96da23d96d9e 1 1 - 5292cbe9c00c5854 try{ const k0 = getKey(); if(k0){ const k1 = cleanKey(k0);",
+    "cacb22c2adfd746c 1 2 c1c79983a8e6f0d0 - const dest = ac.createMediaStreamDestination();",
+    "cae83d72d492954e 1 1 - 30679b3a81ceb032 function t(s){ if(s==null) return s; const hit=i18nLookup(s); return hit!=null ? String(s).replace(String(s).trim(),()=>hit) : s; }",
+    "cb030fc42bb4c3bc 1 1 - - // adds auth to API calls only, so media CDN downloads never see the key.",
+    "cb47f247abc621cc 1 1 - - function resizePlan(sw, sh, mode, tw, th){",
+    "cb9d6bc5ca2fcc32 1 1 - - if(withMedia.length && sansMedia.length){",
+    "cbb322cb4337cce9 1 1 - - const p = pricing || {}, raw = (p.raw && typeof p.raw===\"object\") ? p.raw : {};",
+    "cbc18dd69e34611f 1 1 - - // the caller can tell the creator instead of thinning their share silently. When the share has",
+    "cbcff69984e32aa5 1 1 - - g.fillStyle=\"#1e1e26\"; g.strokeStyle=\"#3c3c4a\"; g.lineWidth=2;",
+    "cd6ddef521f8337d 5 1 07ca7f99652b7e11,129ad099e535c596,15b0a0cbe80654d7,3fbf5a580887b572,59157d58bc5429b4,5e9a1295e4a341ea,ddfde38f2d488e38 0236b6ddb3bc2d62,129ad099e535c596,15b0a0cbe80654d7,59157d58bc5429b4,5e9a1295e4a341ea,68450a46e72a884c,7d5be815c172d016,a0278e8b26e1d5e9,ece68bb51d2aeba0 const row = document.createElement(\"div\");",
+    "cd9c6c2b700998de 1 1 - - .sm-svc button:disabled{ opacity:.5; cursor:progress; }",
+    "cda35efe7f944c4d 1 1 - 866cf5415236fbbf if(typeof url!==\"string\" || !url) throw new Error(\"no audio — wire a source track into the audio port\");",
+    "cdb15d49150d76a7 1 1 fc9025eef95a5f35 fc9025eef95a5f35 if(Math.max(w,h) > max){ const r = max/Math.max(w,h); w=Math.round(w*r); h=Math.round(h*r); }",
+    "ce9b989ba3d63038 1 1 - - if(f.format===\"JSON\") o.response_format = { type:\"json_object\" };",
+    "ceeae0c0fe5db984 1 1 - - // auto-shorten it before opening the intent — the social sites reject/truncate multi-KB URLs. The",
+    "cf0b418e2f566399 1 1 151af693a68d76d2 151af693a68d76d2 <meta name=\"twitter:image:alt\" content=\"Neon noodles rising from a ramen bowl into glowing workflow cables, with the nanoodle logo\" />",
+    "cfd59fe26e209ff4 1 1 - ec166f2b0f43b28d : (pUsd!=null && isFinite(Number(pUsd))) ? Number(pUsd)",
+    "d200a0e75852b20b 1 1 - - return client.video(model, prompt, opts, imageDataUrl, io2).then(",
+    "d28686193eed1cce 1 1 - - const AUDIO_MIME = { mp3:\"audio/mpeg\", opus:\"audio/ogg\", aac:\"audio/aac\", flac:\"audio/flac\", wav:\"audio/wav\", pcm:\"audio/wav\" };",
+    "d28931c7575e286f 1 1 - - async function shortenWith(svc, longUrl){",
+    "d2b28a98b4b1d0a0 1 1 3d61a032fa48b94c,6c98c41c732b5e34,6e161c29ddfe09fd 3d61a032fa48b94c,be87c3ce57eeb455,ccab5ae15209d788 const j = JSON.parse(localStorage.getItem(BAL_CACHE_KEY)||\"null\");",
+    "d2cb773851d79278 1 2 - - if((err instanceof TypeError) && /ISO-8859-1|invalid header|Invalid value/i.test(m)){",
+    "d30589f48aaf15b4 1 1 - - if(all.length) tiers.push({ s:[], stripped:\"all\" });",
+    "d36c7d6d21532c83 1 1 5102297269c5e0e9,52e7c16c6ab75d31,a8cb22b954de6907,b5d419871e8d7580,e38588dcf41ed840,f4dff16f458d3ffa 52e7c16c6ab75d31,7491fd87c8a97620,a8cb22b954de6907,b5d419871e8d7580,e38588dcf41ed840,f4dff16f458d3ffa const c = document.createElement(\"canvas\"); c.width=p.cw; c.height=p.ch;",
+    "d38c32a790149e55 1 1 - - const i = out.findIndex(m=> m && m.role===\"system\" && typeof m.content===\"string\");",
+    "d38f6671d7adafee 1 1 - - const d = (vb[i]||0) - (va[i]||0); if(d) return d;",
+    "d3a5ecf2d40bc60f 1 1 7494cba4c1ba8bbe 7494cba4c1ba8bbe const app = JSON.parse(m[1] ? new TextDecoder().decode(bytes) : await gunzip(bytes));",
+    "d434b112bdee1d89 1 1 - - for(const k of [\"withoutAudioPrices\",\"withAudioPrices\",\"referenceToVideoPrices\"]){",
+    "d4393b80f8f8b718 1 1 939e42188da426b4 939e42188da426b4 if(audioOn){ for(const k of [\"text_image_with_audio_per_second\",\"image_to_video_with_audio_per_second\",\"text_to_video_with_audio_per_second\"]){",
+    "d4aa9fd7f2bf9568 1 1 - - outTok = estTok(content)+estTok(reasoning);",
+    "d52e97ae7a4f420b 1 1 - - const dref = fullbox(\"dref\", 0, 0, u32(1), fullbox(\"url \", 0, 1));",
+    "d580189185b8662b 1 1 - - const usd = parseFloat((await r.json()).usd_balance);",
+    "d5cd3499d389b8eb 1 1 - - if(j.paymentSource) qs.set(\"paymentSource\", j.paymentSource);",
+    "d70a798967b218b8 1 1 - - v.onloadedmetadata = ()=> res({ w: v.videoWidth||1280, h: v.videoHeight||720, dur: v.duration });",
+    "d7278ff38680c31c 1 1 - - const soc = a.dataset.soc, win = window.open(\"about:blank\", \"_blank\");",
+    "d72d46e5e38cfe6a 1 1 - - const moov = box(\"moov\", mvhd, ...trakBoxes);",
+    "d7a90bddd4e50b6e 1 1 915154dbe7cd3e1a 915154dbe7cd3e1a const h = Math.max(0, parseInt(n.fields.height,10) || 0);",
+    "d7b4c33c53722b95 1 1 c0058284f1965f76 c0058284f1965f76 const lenRaw = parseFloat(n.fields.length);",
+    "d7d1ca142b7b5eb3 1 1 - df589621f8e6f06e,e32024b649802a9a onProgress && onProgress(\"adding soundtrack…\");",
+    "d7dbce01e96ad6da 1 1 - - const mvhd = fullbox(\"mvhd\", 0, 0, u32(0), u32(0), u32(mvTimescale), u32(maxDurMs),",
+    "d818d05d806a55e5 1 1 - 5bcd7ed10cf98852 document.addEventListener(\"keydown\", (e)=>{ if(e.key===\"Escape\" && !$(\"sharemenu\").hidden){ e.stopPropagation(); closeShareMenu(); } }, true);",
+    "d85658143e20004d 1 1 - - const frag = document.createDocumentFragment();",
+    "d904a13886ea7018 1 1 - - if(compact.length && hasMedia) tiers.push({ s:compact, stripped:\"media\" });",
+    "d938e61a9753de19 1 1 - - catch(e){ throw new Error(\"could not route the audio for muxing\"); }",
+    "d96a58c663afd2c0 1 1 - - if(/^runware:[^\\s@]+@[^\\s@]+$/i.test(s)) return s.replace(/^runware:/i, \"runware:\");",
+    "d99ae6721f966db1 1 1 - 90dadef5296205bb const setKey = (k)=>{ k ? localStorage.setItem(\"ngpt_key\",k) : localStorage.removeItem(\"ngpt_key\"); renderAuth();",
+    "d9d6f5a89d7fdfef 1 1 - - // NOTE for edits: no regex literals in this function body — check-share-link extracts it as text.",
+    "d9fbd2decf840124 1 1 - - const cx = n => n.x + (typeof n.w===\"number\" ? n.w : 220)/2, cy = n => n.y + 60;",
+    "da97fdc513a0298a 1 1 - - // Remember the job (with its request sig) the moment it exists, so EVERY early exit is recoverable",
+    "db22635fb854ba0b 1 1 - - // Play one already-decoded clip start→end, painting each presented frame onto the shared canvas and",
+    "db2f25b7ca2791c5 1 1 - - if(fam===\"flux2dev\" || fam===\"flux2klein\" || fam===\"zimage\" || fam===\"ltx\"){",
+    "db63a974c777a353 1 1 - - g.fillText(label.length>14 ? label.slice(0,13)+\"…\" : label, x+56, p.y, BW-70);",
+    "dbfba296fb6587ef 1 1 - - const rp = (m)=> pickByRes(m, res, defRes);",
+    "dc1a26c8adeec58b 1 1 - - if(raw.pricePerMegapixel!=null && raw.megapixelsByResolution){",
+    "dceae1b7c8800866 1 1 5475c477ebb8e86c,69fe17da2941fe18 5475c477ebb8e86c,69fe17da2941fe18 const track = stream.getVideoTracks()[0];",
+    "dd323e7e77e03e8a 1 1 1ae9ed4d322b1e10 1ae9ed4d322b1e10 <link rel=\"icon\" type=\"image/png\" sizes=\"32x32\" href=\"/favicon-32.png\" />",
+    "de60b766ea347cb2 1 1 678386620763bafd,eb49569223879925 678386620763bafd,eb49569223879925 src.onerror = ()=> reject(new Error(\"couldn’t read the source image\"));",
+    "de7ece55ee7084a5 1 1 67405a8ece448bb3 67405a8ece448bb3 const q = new URLSearchParams(location.search).get(\"engine\");",
+    "de87d681168a1874 1 1 b298f25eaace22ce,e2cc702b7605072e b298f25eaace22ce,e2cc702b7605072e <a data-soc=\"facebook\" target=\"_blank\" rel=\"noopener\">Facebook</a>",
+    "de8c3aa7753c8462 1 1 - - try{ ac.createMediaElementSource(el).connect(dest); }",
+    "debaf774faf364a7 1 1 - - if(typeof url!==\"string\" || !url) return null;",
+    "df368828f3ecc1a6 1 1 - - u32(0), u32(0), u32(trackId), u32(0), u32(durMs),",
+    "dfc94b1e755f6480 1 1 927b790414bda39c 927b790414bda39c for(let e=0;e<sttsN;e++){ const cnt = dv.getUint32(stts.body + 8 + e*8); const delta = dv.getUint32(stts.body + 12 + e*8); for(let k=0;k<cnt && si<sampleCount;k++) durs[si++] = delta; }",
+    "e0082dc9347d0b8c 1 1 - - if(typeof o===\"number\"){ if(o>0 && o<500){ if(/second|persec/i.test(key)) perSec=Math.min(perSec??Infinity,o); else flat=Math.min(flat??Infinity,o); } return; }",
+    "e012ed6708d8a65b 1 1 10e3cd8184b90598 10e3cd8184b90598 const tmp = await trimAudioToWavUrl(url, start, len, rate);",
+    "e03987363518d078 1 1 - - // Rebuilt per run (NOT memoized as a whole): a transient failure must not freeze empty catalogs",
+    "e03d2cc87b3f854b 1 2 - - const tag=p.tagName; if(tag===\"TEXTAREA\"||tag===\"INPUT\"||tag===\"SCRIPT\"||tag===\"STYLE\") return NodeFilter.FILTER_REJECT;",
+    "e0784fe8873a10c9 1 1 - - if(s.v.width !== base.v.width || s.v.height !== base.v.height) return false;",
+    "e0d08c2f10405020 1 2 - - const node = off.createBufferSource(); node.buffer = src; node.connect(off.destination);",
+    "e156d0db5b2a23e8 1 1 - - merged.samples.push({ bufIdx: ci, offset: s.offset, size: s.size, dur: Math.round(s.dur*scale), cts: Math.round(s.cts*scale), sync: s.sync });",
+    "e1646595b2844d82 1 1 - - const moovBoxes = walk(dv, moov.body, moov.end);",
+    "e18873a1164e98f3 1 1 - - if(raw.withAudioPricesPerSecond){ v=pickByRes(raw.withAudioPricesPerSecond, res, defRes); if(v!=null) return v*dur; }",
+    "e1893250b982420d 1 16 65d35cc6f5cd7704,8a61b799060b3516,c5521b76b218c14a 65d35cc6f5cd7704,8a61b799060b3516,c5521b76b218c14a ===================================================================== */",
+    "e1b10ee79ed9272c 1 1 - - if(changed) tiers.push({ s:shrunk, stripped:\"shrunk\" });",
+    "e1e59c16b9447354 1 1 - - throw new Error(\"resized image is still over the ~4 MB inline limit — pick smaller dimensions\");",
+    "e239cc1f9c280b39 1 1 eadc26cc1cc33ba7 eadc26cc1cc33ba7 if(defRes!=null && _num(map[defRes])!=null) return _num(map[defRes]);",
+    "e2422c3226a670e2 1 1 - - // A generation call can fail purely for lack of credit: NanoGPT signals it with 402, or a body that",
+    "e24fca0193826d2d 1 2 - - const rendered = await off.startRendering();",
+    "e26b1ae67579d694 1 1 - - resume: (pend && pend.sig===sig && pend.job) ? pend.job : undefined,",
+    "e28acacac77b3c5d 1 1 - - if(svc!==\"nanolink\") throw new Error(\"unknown service\");",
+    "e2aff9eadc851a1e 1 1 - - const b64 = c.toDataURL(\"image/png\").split(\",\")[1] || \"\";",
+    "e2cc702b7605072e 1 1 b298f25eaace22ce,de87d681168a1874 b298f25eaace22ce,de87d681168a1874 <a data-soc=\"reddit\" target=\"_blank\" rel=\"noopener\">Reddit</a>",
+    "e2cfaa81921a7a6c 1 1 3ce3214c0ae3111c,6fe445db241d269a,76b20b1ff7d18963,9b405e1fc821d099,eb49569223879925 6fe445db241d269a,76b20b1ff7d18963,9b405e1fc821d099,eb49569223879925 vid.onerror = ()=> reject(new Error(\"could not load a clip\"));",
+    "e32b1f8fd31c16cd 1 1 - - new Uint8Array(8), u16(0), u16(0), u16(t.kind===\"audio\"?0x0100:0), u16(0),",
+    "e34155712986424a 1 1 - - v.muted = true; v.preload = \"metadata\"; v.crossOrigin = \"anonymous\"; v.src = src;",
+    "e38588dcf41ed840 1 1 a8cb22b954de6907,b5d419871e8d7580,d36c7d6d21532c83,f4dff16f458d3ffa a8cb22b954de6907,b5d419871e8d7580,d36c7d6d21532c83,f4dff16f458d3ffa const c = document.createElement(\"canvas\"); c.width=src.naturalWidth; c.height=src.naturalHeight;",
+    "e3c44acc9ce4c51a 1 1 - - for(let e=0;e<coN;e++) chunkOffsets[e] = is64 ? Number(dv.getBigUint64(co.body + 8 + e*8)) : dv.getUint32(co.body + 8 + e*4);",
+    "e3cbcd95c281be3c 1 1 - - const out = await resizeCropImage(inp.image, mode, w, h);",
+    "e3e1ec7c254fae2d 1 1 - - // retry bytes are identical to the built-in runner's (the library's pure-JS/ffmpeg trimmer",
+    "e4637497b81c6e1a 1 1 - - const mark = document.createElement(\"mark\"); mark.className = \"ap-key\";",
+    "e56a44afb3f3a716 1 1 - - // — without this, LLM calls never bump spend.",
+    "e5729e5ac8962096 1 1 10e3cd8184b90598 10e3cd8184b90598 async function extractAudioToWavUrl(url, start, len, rate){",
+    "e5c6719e82bd4e9a 1 1 - - for(let i=3; i<d.length; i+=4) if(d[i] < 255) return true;",
+    "e6105fc038512f97 1 1 bc2853f66f3d737f bc2853f66f3d737f function u32(n){ const a = new Uint8Array(4); new DataView(a.buffer).setUint32(0, n>>>0); return a; }",
+    "e61a2a7243298a3f 1 1 - - // Map node centers into the safe area (footer strip reserved), preserving layout shape.",
+    "e6757853f11f1e92 1 1 2e39d1f30bc77aa2,a687e7b0aec22faf,edec12afc74be9d6 2e39d1f30bc77aa2,a687e7b0aec22faf,edec12afc74be9d6 if(b64.startsWith(\"UklG\"))  return \"image/webp\";",
+    "e69e59ecf27aaf77 1 1 - - if(v==null) v = _num(mm.text_to_video) ?? pickByRes(mm);",
+    "e7181a4bfa300cad 1 1 10484b8d400ee5af,4a492ee84c7de708 10484b8d400ee5af,4a492ee84c7de708,b7ed1d1569549245 const url = await ctx.genVideo(mdl(n), prompt, opts, inp.image,",
+    "e77ac50973edbc7e 1 1 - - ids.forEach(id=>{ indeg[id]=0; adj[id]=[]; });",
+    "e7f095948f41974e 1 1 - - async function muxSoundtrack(videoUrl, audioUrl, loop, onProgress){",
+    "e86ce8b3773a67fa 1 1 - - if(t.audioInput && l.to.port===\"audio\") continue;            // the audio port isn't a text-field override",
+    "e8dcfdf107a748d6 1 1 b0a2d671cf810e67 b0a2d671cf810e67 g.fillStyle=\"#111116\"; g.fillRect(0,0,W,H);",
+    "e8eb3bc1d98f4602 1 1 - - // intents reject it outright (nanolink could store far more — the RAW link is the constraint).",
+    "e8fe476f254dbf66 1 1 - - for(let k=0;k<spc && sIdx<sampleCount;k++){",
+    "e94a570a8f5d4231 1 1 - - headers:{ \"Content-Type\":\"application/x-www-form-urlencoded\" }, body:\"url=\"+encodeURIComponent(longUrl),",
+    "e960a1cfbe190598 1 1 - - // Reflect what the shortener can actually take for the CURRENT link: disable the button,",
+    "e97a1e5b3f0d508e 1 2 92068a479add3145 92068a479add3145 <meta name=\"twitter:image\" content=\"https://nanoodle.com/og-card.png\" />",
+    "e9909b33f6039e1e 1 1 - - const p = resizePlan(img.naturalWidth, img.naturalHeight, mode, tw, th);",
+    "e998c19eeb364a50 1 1 - - return (word>=floor ? head.slice(0, word) : head).trim();",
+    "e9cad1e47cb2e926 1 2 - - if(!saved||p.get(\"state\")!==saved.state) throw new Error(\"state mismatch\");",
+    "ea0b9843fb010f4d 1 1 - - const codecCfg = scanForBox(stsdRaw, kind===\"video\" ? \"avcC\" : \"esds\")",
+    "ea51c1d4cebeee75 1 1 - - // nanolink caps cards at 200 kB decoded; stay well clear (flat art is ~30–60 kB).",
+    "eadc26cc1cc33ba7 1 1 e239cc1f9c280b39 e239cc1f9c280b39 if(reqRes!=null && _num(map[reqRes])!=null) return _num(map[reqRes]);",
+    "eb3b90b21996194f 1 1 - - <link rel=\"stylesheet\" href=\"/vendor/righteous/righteous.css\" />",
+    "eb49569223879925 1 1 678386620763bafd,6fe445db241d269a,9b405e1fc821d099,de60b766ea347cb2,e2cfaa81921a7a6c 678386620763bafd,6fe445db241d269a,9b405e1fc821d099,de60b766ea347cb2,e2cfaa81921a7a6c m.onerror = ()=> reject(new Error(\"couldn’t read the mask\"));",
+    "eb532592d66edeb1 1 1 - - // inlined media at all, `alt` carries both endpoints — the best link WITH the preview image and",
+    "eb551143dcd476eb 1 1 22f118117f36bc7f,a4990935c751a221 7f0b7a578f1f2b15 const count = Math.max(1, Math.min(MAX_FRAMES, parseInt(n.fields.frames,10)||1));",
+    "ec194b3572afa7a9 1 1 - - const q=[...ids].filter(id=>indeg[id]===0), order=[];",
+    "ec2618d4f30553da 1 1 - - // The Moonshot route applies a TINY default output cap when a request carries no max_tokens",
+    "ec82ef2566300245 1 1 10e3cd8184b90598 10e3cd8184b90598 trimAudio: async (url, start, len, rate)=>{",
+    "ec934dea37b305bd 1 1 - - const compact = all.filter(s=> s.v.length <= 2500);",
+    "ecd288a3297e856f 1 1 - - if(sent>=floor) return head.slice(0, sent+1).trim();",
+    "ece9c746af53c7e5 1 1 - - ? \"your key is filled in (shortened on screen — Copy grabs the full command, ready to paste)\"",
+    "ed22b462dec5c0c2 1 1 - - return { cw:bw, ch:bh, dx:(bw-dw)/2, dy:(bh-dh)/2, dw, dh };",
+    "ed5c43c5a873feb5 1 1 - - if(bufs.length >= 2 && bufs.every(b=>MP4CAT.isMp4(b)) && MP4CAT.mp4ParamsMatch(bufs)){",
+    "ed7dbb537229efeb 1 1 - - const withMedia = packed.filter(isMediaTier), sansMedia = packed.filter(p=> !isMediaTier(p));",
+    "edec12afc74be9d6 1 1 2e39d1f30bc77aa2,a687e7b0aec22faf,e6757853f11f1e92 2e39d1f30bc77aa2,a687e7b0aec22faf,e6757853f11f1e92 if(b64.startsWith(\"/9j/\"))  return \"image/jpeg\";",
+    "edfef3b215d4a652 1 1 2c118d407207b74b,9937ec384c9be842 2c118d407207b74b for(const l of graph.links) if(l.to.node===n && !keep.has(l.from.node)){ keep.add(l.from.node); stack.push(l.from.node); }",
+    "ee1e7d9a1933f78f 1 1 - - // then pointed at the short intent once nanolink resolves. On shortener failure we CLOSE the window",
+    "ee62a09cf848b4d2 1 1 - 67c8d61fb286d50d #sharemenu[hidden], #shareback[hidden]{ display:none; }",
+    "ee792482a1299a95 1 1 - - return { v: vids[0], a: auds[0] || null, na: auds.length };",
+    "eec32ebef9ef2f8c 1 1 - - if(p.duration_multiplier!=null) mult=_num(p.duration_multiplier) ?? 1;",
+    "eee15737621d5ce7 1 1 - - if(f.showThinking===true || f.showThinking===\"true\") o.showThinking = true;",
+    "ef2be9c6189a6af4 1 1 - - if((pv && !pv.njs) || (pa && !pa.njs)) return null;",
+    "ef71091cfcb19361 1 1 - - // wires only, never field contents or media — and send it alongside the URL. nanolink stores",
+    "efba54d5339fbd53 1 1 970c360c358ebb13 970c360c358ebb13 if(!p){ rej(new Error(\"set a width or height to resize to\")); return; }",
+    "efc41ac685fb0943 1 1 93e9a2e7c86d722c 4f39e25541d804e5,93e9a2e7c86d722c,c87b00bc6c09d0a3 if(t.videoInputs) for(const l of graph.links){",
+    "efeadacd650bd229 1 1 - - // Even though nanolink can store ~128 kB, the RAW link is what most people paste into chat",
+    "f086b86053e2a392 1 1 03d00fa44495b32d 03d00fa44495b32d function videoUnitUsd(pricing, fields, refWired){",
+    "f08d165b6ff3844d 1 1 - - const sttsRuns = rle(t.samples.map(s=>s.dur));",
+    "f0e2fa2ac6551381 1 1 - - if(opts.lora) Object.assign(body, opts.lora);        // LoRA params (lora_url_1.. for LTX video)",
+    "f15508c0f3ce6208 1 2 - - if(!p.has(\"code\")&&!p.has(\"error\")) return;",
+    "f1d0769ffca62726 3 4 31fc131ab2f1d550 31fc131ab2f1d550 const AC = window.AudioContext || window.webkitAudioContext;",
+    "f21439d83788cf5e 1 1 - - const timescale = dv.getUint32(mdhd.body + (mdhdV1 ? 20 : 12));",
+    "f27760e0390cd32e 1 1 - - // sync audio (speech OR music): /api/v1/audio/speech → binary audio (or JSON with a url for some providers).",
+    "f278cda6beaba420 1 1 - - const g = c.getContext(\"2d\"); if(!g || typeof g.roundRect!==\"function\") return null;",
+    "f2a11776c87781a7 2 2 - - if(raw[k]){ v=pickByRes(raw[k], res, defRes); if(v!=null) return v*dur; }",
+    "f3753f27e4cc1a7d 1 1 - - else if(fmt===\"x-wav\" || fmt===\"wave\") fmt = \"wav\";",
+    "f3ad386ac884c309 1 1 - - const NJS_TYPES = { llm:1, vision:1, image:1, edit:1, inpaint:1, tvideo:1, ivideo:1, vedit:1, lipsync:1, music:1, tts:1, remix:1, transcribe:1 };",
+    "f41097131bdb8b86 1 2 b29365ebbbe290c1 - if(!r.ok) throw new Error(\"register \"+r.status);",
+    "f43f6f9b1275ef58 1 1 - - if(typeof MediaRecorder === \"undefined\") throw new Error(\"this browser can’t record video (no MediaRecorder)\");",
+    "f4410ede37897987 1 1 - - const r = await fetch(\"https://da.gd/shorten\", { method:\"POST\",",
+    "f48f74ca1120b4a6 1 1 8bca111c0612bd5b 8bca111c0612bd5b try{ opts = { audioDataUrl: await urlToDataUrl(tmp) }; } finally { URL.revokeObjectURL(tmp); }",
+    "f4dff16f458d3ffa 1 1 5102297269c5e0e9,52e7c16c6ab75d31,59157d58bc5429b4,a8cb22b954de6907,b5d419871e8d7580,d36c7d6d21532c83,e38588dcf41ed840 52e7c16c6ab75d31,59157d58bc5429b4,7491fd87c8a97620,a8cb22b954de6907,b5d419871e8d7580,d36c7d6d21532c83,e38588dcf41ed840 const c = document.createElement(\"canvas\"); c.width=w; c.height=h;",
+    "f51f4380fe981ec2 1 1 - - // async video: submit → poll /api/video/status until COMPLETED (up to 10 min)",
+    "f5200cb262efbe14 2 2 - - const dv = new DataView(u8.buffer, u8.byteOffset, u8.byteLength);",
+    "f5581831083a0b6c 1 2 5cf0ebc63ea347e9 5cf0ebc63ea347e9 <meta property=\"og:site_name\" content=\"nanoodle\" />",
+    "f6769c7e2f2ceb4c 1 1 - - <meta name=\"theme-color\" content=\"#0b0d12\" />",
+    "f6aaa303e7ababcd 1 1 - - if(p.per_second_by_mode){ const mm=p.per_second_by_mode;",
+    "f6adaf8668dc5d6f 2 2 553015162904e270,83dd58a7ee977a8d 553015162904e270,83dd58a7ee977a8d if(!url) throw new Error(\"no audio url in response\");",
+    "f6c2ab3e653ea99c 1 1 - - for(let i=0;i<bytes.length;i+=CH) bin += String.fromCharCode.apply(null, bytes.subarray(i,i+CH));",
+    "f71b34df843773bb 2 1 - - for(let attempt=0; attempt<2; attempt++){",
+    "f75191ee80c062f6 1 1 4c5530f4ae080e35,62240a12bddede33 4c5530f4ae080e35,62240a12bddede33 async function concatViaRecorder(urls, dedup, onProgress){",
+    "f7beb9f6fe1306bd 1 1 - - const prefs = [\"video/mp4;codecs=avc1.42E01E\",\"video/mp4\",\"video/webm;codecs=vp9\",\"video/webm;codecs=vp8\",\"video/webm\"];",
+    "f7e911bb06585446 1 1 - - // JSON output-format is only honored by structured_output models; on others response_format",
+    "f80bdad1da57cc33 1 1 - - if(audioOn){   // with-audio tier (wan flash per-second / per-clip) beats the without-audio table",
+    "f8409ee7d4b65211 1 1 - - const lines = buf.split(\"\\n\"); buf = lines.pop();",
+    "f8ee336bebb3e516 1 1 - - while(si < sampleCount) durs[si++] = durs[si-2] || 0;",
+    "f914ad041e5a615d 1 1 - - // Third-party POST — explicit-click only. Same stance as nanolink: any failure (or the",
+    "f92f1bf75f8773bf 1 1 - - // a stable equality signal — rate+channels is what decides concat compatibility).",
+    "fa2bd2cee4ef36cf 1 1 - - var items = rows.slice(0, loraCap(n.fields.model)).map(function(r){",
+    "fa5b8b2427d76ddb 1 1 426f3f0bfcfdfe95 426f3f0bfcfdfe95 if(p.per_video!=null){ v=_num(p.per_video); if(v!=null) return v; }",
+    "fa5cc61fda95b5ed 1 1 - 29e8bcfa03980f0e const bh = th>0 ? th : Math.max(1, Math.round(tw * sh/sw));",
+    "fb192aae08f32f6a 1 1 - - if(opts.dims) Object.assign(body, opts.dims);",
+    "fb7f00b4021d6747 1 1 43f7d3eb09b45360 43f7d3eb09b45360 onProgress && onProgress(st, Date.now()-t0);",
+    "fbc0d9e3f4eb0b67 1 1 - - const d = _num(p.default_duration) ?? _num(raw.defaultDuration);",
+    "fbc78cbd3325361d 1 1 - - function isMp4(u8){ if(u8.length<12) return false; const dv=new DataView(u8.buffer,u8.byteOffset,u8.byteLength); return fourcc(dv,4)===\"ftyp\"; }",
+    "fc0eb4d27bc18885 1 1 - - try{ tmp = await trimAudioToWavUrl(inp.audio, 0, trimSec, 24000); }",
+    "fc5624cd213c7427 1 1 - - if(!/\\/resolve\\/.+\\.safetensors(\\?|$)/i.test(u))",
+    "fc6d65a69154de90 1 1 - - const I18N_ENAME = { es:\"Spanish\", fr:\"French\", de:\"German\", pt:\"Portuguese\", ja:\"Japanese\" };",
+    "fc9025eef95a5f35 1 1 cdb15d49150d76a7 cdb15d49150d76a7,dc8334484ee43c32 if(w>max || h>max){ const sc = max/Math.max(w,h); w = Math.round(w*sc); h = Math.round(h*sc); }",
+    "fcbde32817df6804 1 1 - - // ---- share card (per-link og:image) --------------------------------------------------------",
+    "fd3334935fc62f54 1 1 - - // da.gd is back as a clearly-LABELED alternative button (the popover says it sees and stores",
+    "fd484ccfd66d0c06 1 1 - - // codec config only (SPS/PPS or audio decoder config) — the equality signal for the match gate,",
+    "fd5bf1590ebcfb24 1 1 - - g.bezierCurveTo(a.x+BW/2+dx,a.y, b.x-BW/2-dx,b.y, b.x-BW/2,b.y); g.stroke();",
+    "fdbfe385703b4b96 1 1 - - const sm = await Promise.resolve(shrinkMedia(v)).catch(()=>null);",
+    "fdc006339bdae92d 1 1 - - function maskToSource(maskUrl, sourceUrl){",
+    "fdc3d71dd89c7246 1 1 59858c3bb10e0921 59858c3bb10e0921 g.font=\"22px system-ui, sans-serif\"; g.fillStyle=\"#9a9aa8\"; g.textAlign=\"right\";",
+    "fdcb0a3039cb1be8 1 1 - - const stts = fullbox(\"stts\", 0, 0, u32(sttsRuns.length), ...sttsRuns.map(r=>concat([u32(r[0]), u32(r[1])])));",
+    "fdcc9e3603987672 1 1 - - g.beginPath(); g.roundRect(x,y,BW,BH,14); g.fill(); g.stroke();",
+    "fe2cce6f34862fce 1 1 - - maskToSource: (mask, source)=> maskToSource(mask, source),   // canvas compositor — handles JPEG/WebP sources",
+    "fe408d98c5e61b13 1 1 bd23dcfefad0bffb bd23dcfefad0bffb if(!AC) throw new Error(\"this browser can’t process audio (no Web Audio API)\");",
+    "fe5bf2c9e7909f3d 1 1 4d683e10fba6c1e8 - throw new Error(\"audio failed: \" + (s.error || s.message || st));",
+    "fe7173aceac20e2d 1 1 - - // async audio (music / some TTS): submit returns {status:\"pending\", runId} → poll /api/tts/status until completed.",
+    "fe764e4111cde170 1 1 - - ctx.fillStyle=\"#000\"; ctx.fillRect(0,0,c.width,c.height);   // black = keep",
+    "fefab5343c39319e 1 1 - - return URL.createObjectURL(new Blob([out], { type:\"video/mp4\" }));",
+    "ff95f3dedfe97e80 1 1 - - email:    `mailto:?subject=${ti}&body=${et}%0A%0A${eu}`,",
+    "ff9601592f311d6d 1 1 - - const PROMPT_TOO_LONG_RE = /(?:shorten (?:it )?to|keep it under|at most|maximum of|limit of)\\s*([\\d,]{2,})\\s*characters/i;",
+    "ff9cbe9df52f83ee 2 1 - ce7e4133cabaa6ba const keep = ac.createConstantSource(); keep.offset.value = 0; keep.connect(dest); keep.start();",
+    "ff9da164ae5801c5 1 1 4df74c231697ebe4,701cc0c09cc321be d47f6dda1839565b return await new Promise((res, rej)=>{ const fr=new FileReader(); fr.onload=()=>res(fr.result); fr.onerror=()=>rej(new Error(\"could not read media\")); fr.readAsDataURL(blob); });"
+  ]
+}
diff --git a/scripts/twin-drift-bench.mjs b/scripts/twin-drift-bench.mjs
new file mode 100644
index 0000000..8069717
--- /dev/null
+++ b/scripts/twin-drift-bench.mjs
@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+// Timing harness for scripts/check-twin-drift.mjs. It builds the 3 cases the RUNTIME tables quote —
+// a clean tree, 200 departures that left BOTH surfaces, and 200 departures that left 1 surface —
+// runs each 5 times in a scratch copy, and prints the wall and CPU range it measured, plus the load
+// average the machine held. Every runtime figure in the guard header, in .githooks/pre-commit and in
+// docs/twin-drift.md comes from this command.
+//
+// The 200 departures are the FIRST 200 baseline entries in hash order, so the case is the same on
+// every machine and on every run. Every occurrence of each of those lines is deleted, because the
+// guard counts occurrences, not just presence.
+//
+// Timings vary by machine and by load. Quote the range you measured, and say what the load average
+// was while you measured it.
+//
+// Offline. No network, no API spend, no writes outside the scratch directory.
+//   node scripts/twin-drift-bench.mjs [samples]
+
+import { readFileSync, writeFileSync, mkdirSync, mkdtempSync, rmSync, copyFileSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { resolve, dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { tmpdir, loadavg } from "node:os";
+import { createHash } from "node:crypto";
+
+const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const SAMPLES = Math.max(1, parseInt(process.argv[2] || "5", 10));
+const DEPARTURES = 200; // the guard's MAX_CLASSIFY ceiling — 201 reports totals instead
+
+const hash = (s) => createHash("sha256").update(s, "utf8").digest("hex").slice(0, 16);
+const baseline = JSON.parse(readFileSync(join(ROOT, "scripts", "twin-drift-baseline.json"), "utf8"));
+const doomed = new Set(
+  baseline.lines
+    .slice()
+    .sort()
+    .slice(0, DEPARTURES)
+    .map((l) => String(l).slice(0, 16))
+);
+
+// The generated regions are OFF LIMITS. A line deleted from inside the njs-engine block breaks that
+// block's own data-hash, and the guard then stops at that error in 0.08 s without classifying
+// anything — which is how a bench measures a "200-departure" case that never ran. The regions are
+// found the same way the guard finds them, and their lines are simply never deleted.
+const NJS_BLOCK = /<script id="njs-engine" data-hash="([0-9a-f]{16})">\n([\s\S]*?)\n<\/script>/g;
+const MARKED = [
+  /\/\* === PROMPT-CAPS-BEGIN === \*\/[\s\S]*?\/\* === PROMPT-CAPS-END === \*\//g,
+  /\/\* === I18N-MAPS-BEGIN[\s\S]*?\/\* === I18N-MAPS-END === \*\//g,
+  /\/\* === RUNWARE-AIRS-BEGIN === \*\/[\s\S]*?\/\* === RUNWARE-AIRS-END === \*\//g,
+];
+const blanks = (m) => "\n".repeat((m.match(/\n/g) || []).length);
+
+function surfaces(drop) {
+  const out = {};
+  for (const f of ["index.html", "play.html"]) {
+    const raw = readFileSync(join(ROOT, f), "utf8");
+    const lines = raw.split("\n");
+    if (!drop.includes(f)) { out[f] = lines; continue; }
+    let blanked = raw.replace(NJS_BLOCK, blanks);
+    for (const re of MARKED) blanked = blanked.replace(re, blanks);
+    const hand = blanked.split("\n");
+    out[f] = lines.filter((l, i) => {
+      const t = hand[i].trim();
+      return !(t.length > 40 && doomed.has(hash(t)));
+    });
+  }
+  return out;
+}
+
+function sandbox(drop) {
+  const dir = mkdtempSync(join(tmpdir(), "twin-drift-bench-"));
+  mkdirSync(join(dir, "scripts"), { recursive: true });
+  for (const f of ["check-twin-drift.mjs", "twin-drift-baseline.json"]) {
+    copyFileSync(join(ROOT, "scripts", f), join(dir, "scripts", f));
+  }
+  const s = surfaces(drop);
+  for (const f of Object.keys(s)) writeFileSync(join(dir, f), s[f].join("\n"));
+  // CPU time of a CHILD process is not in the parent's process.cpuUsage(), so the child reports its
+  // own: this wrapper imports the guard and writes its CPU total on the way out. The guard calls
+  // process.exit(), and an "exit" listener still runs on that path.
+  writeFileSync(
+    join(dir, "scripts", "cpu-wrapper.mjs"),
+    'import { writeFileSync } from "node:fs";\n' +
+      'process.on("exit", () => {\n' +
+      "  const c = process.cpuUsage();\n" +
+      '  try { writeFileSync(process.argv[2], String((c.user + c.system) / 1e6)); } catch (e) {}\n' +
+      "});\n" +
+      'await import("./check-twin-drift.mjs");\n'
+  );
+  return dir;
+}
+
+function run(dir) {
+  const cpuFile = join(dir, "cpu.txt");
+  const t0 = process.hrtime.bigint();
+  let code = 0;
+  try {
+    execFileSync("node", [join(dir, "scripts", "cpu-wrapper.mjs"), cpuFile], {
+      stdio: ["ignore", "ignore", "ignore"],
+    });
+  } catch (e) {
+    if (e.status === undefined) throw e;
+    code = e.status;
+  }
+  const wall = Number(process.hrtime.bigint() - t0) / 1e9;
+  return { wall, cpu: Number(readFileSync(cpuFile, "utf8")), code };
+}
+
+const CASES = [
+  { name: "clean tree, nothing departs", drop: [] },
+  { name: `${DEPARTURES} departures, gone from both`, drop: ["index.html", "play.html"] },
+  { name: `${DEPARTURES} departures, gone from 1 surface`, drop: ["play.html"] },
+];
+
+const fmt = (xs) => `${Math.min(...xs).toFixed(2)}-${Math.max(...xs).toFixed(2)} s`;
+console.log(`load average at start: ${loadavg().map((n) => n.toFixed(2)).join(" ")}`);
+for (const c of CASES) {
+  const dir = sandbox(c.drop);
+  const wall = [], cpu = [];
+  let code = null;
+  try {
+    for (let i = 0; i < SAMPLES; i++) {
+      const r = run(dir);
+      wall.push(r.wall);
+      cpu.push(r.cpu);
+      code = r.code;
+    }
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+  console.log(
+    `${c.name.padEnd(38)} ${fmt(wall).padEnd(14)} wall  ${fmt(cpu).padEnd(14)} CPU  ` +
+      `(${SAMPLES} samples, guard exit ${code})`
+  );
+}
+console.log(`load average at end:   ${loadavg().map((n) => n.toFixed(2)).join(" ")}`);
diff --git a/scripts/twin-drift-worklist.mjs b/scripts/twin-drift-worklist.mjs
new file mode 100644
index 0000000..87c640e
--- /dev/null
+++ b/scripts/twin-drift-worklist.mjs
@@ -0,0 +1,166 @@
+#!/usr/bin/env node
+// Recompute the "Ranked blocks" and "The work list, in order" tables in docs/twin-drift.md.
+//
+// WHY THIS IS A SCRIPT. The tables carry 3 different per-block numbers and they were hand written.
+// Hand arithmetic put 2 incompatible definitions in the same table: the prose defined the running
+// baseline as "893 minus the lines whose every occurrence, on both surfaces, sits inside the block",
+// while the column actually subtracted the `sig` number. The 2 rules disagree wherever a twin has an
+// occurrence outside the quoted ranges, which is 3 of the 9 rows. This script owns both columns now.
+//
+// THE DEFINITIONS, one each, and no other rule is used:
+//   sig             distinct shared lines with at least 1 occurrence inside the block's index.html
+//                   range AND at least 1 occurrence inside its play.html range. It measures how much
+//                   of the shared set the block TOUCHES. It is not a deletion count.
+//   deletes         distinct shared lines whose EVERY occurrence in index.html and EVERY occurrence
+//                   in play.html sits inside the block's ranges. Only these leave the shared set
+//                   when the block is deleted; a line with a copy outside the ranges survives.
+//   new             this row's `deletes` minus everything the rows above it already deleted.
+//   baseline after  the shared-line count minus the running union of `new`.
+//
+// The shared set itself comes from scripts/check-twin-drift.mjs's baseline, so this script and the
+// guard cannot drift apart: it reads the SAME per-line entries the guard pins, and it re-derives
+// every occurrence position from index.html and play.html with the same generated-region blanking.
+//
+// Offline. No network, no API spend.
+//   node scripts/twin-drift-worklist.mjs
+
+import { readFileSync, existsSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { resolve, dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const MIN_LEN = 40;
+const hash = (s) => createHash("sha256").update(s, "utf8").digest("hex").slice(0, 16);
+
+// Same blanking as the guard. Kept in step by the assertion at the bottom: the shared set this
+// script derives must equal the baseline the guard pins, line for line.
+const NJS_BLOCK = /<script id="njs-engine" data-hash="([0-9a-f]{16})">\n([\s\S]*?)\n<\/script>/g;
+const MARKED = [
+  /\/\* === PROMPT-CAPS-BEGIN === \*\/[\s\S]*?\/\* === PROMPT-CAPS-END === \*\//g,
+  /\/\* === I18N-MAPS-BEGIN[\s\S]*?\/\* === I18N-MAPS-END === \*\//g,
+  /\/\* === RUNWARE-AIRS-BEGIN === \*\/[\s\S]*?\/\* === RUNWARE-AIRS-END === \*\//g,
+];
+const blanks = (m) => "\n".repeat((m.match(/\n/g) || []).length);
+
+function surface(file) {
+  let src = readFileSync(join(ROOT, file), "utf8");
+  src = src.replace(NJS_BLOCK, (m) => blanks(m));
+  for (const re of MARKED) src = src.replace(re, (m) => blanks(m));
+  const at = new Map(); // hash -> [1-based line numbers]
+  src.split("\n").forEach((line, i) => {
+    const t = line.trim();
+    if (t.length <= MIN_LEN) return;
+    const h = hash(t);
+    if (at.has(h)) at.get(h).push(i + 1);
+    else at.set(h, [i + 1]);
+  });
+  return at;
+}
+
+const IDX = surface("index.html");
+const PLAY = surface("play.html");
+const shared = [...IDX.keys()].filter((h) => PLAY.has(h));
+
+// The contiguity figure the document opens with: how many of the shared lines sit in a run of 4 or
+// more, counted on index.html line numbers, with at most 1 non-shared line inside a run. Printed
+// here so that "reproduce every number" is true of that sentence too.
+{
+  const pos = [];
+  for (const h of shared) for (const n of IDX.get(h)) pos.push({ n, h });
+  pos.sort((a, b) => a.n - b.n);
+  const runs = [];
+  let cur = [pos[0]];
+  for (let i = 1; i < pos.length; i++) {
+    if (pos[i].n - pos[i - 1].n <= 2) cur.push(pos[i]);
+    else { runs.push(cur); cur = [pos[i]]; }
+  }
+  runs.push(cur);
+  const big = runs.filter((r) => r.length >= 4);
+  const inBig = new Set();
+  for (const r of big) for (const p of r) inBig.add(p.h);
+  console.log(
+    `contiguity: ${inBig.size} of the ${shared.length} shared lines sit in ${big.length} runs of 4 ` +
+      `or more\n            (index.html line numbers, at most 1 non-shared line inside a run); ` +
+      `${shared.length - inBig.size} are scattered\n`
+  );
+}
+
+// Line ranges are inclusive, from docs/twin-drift.md. A block may quote more than 1 range per file.
+const BLOCKS = [
+  { row: 1, name: "Resize and crop geometry", idx: [[6928, 6988]], play: [[7342, 7377], [8822, 8836]] },
+  // play.html's maskToSource is 7320-7338. docs/twin-drift.md used to quote 7296-7309 for it, which
+  // is audioInputPart — the block-6 range lists are not in the same order on the 2 surfaces, and the
+  // work list copied the wrong one. With the wrong range this row measured sig 0.
+  { row: 2, name: "`maskToSource`", idx: [[7211, 7229]], play: [[7320, 7338]] },
+  // index.html's range used to end at 9181. play.html:6516-6633 also carries the twins of
+  // trimAudioToWavUrl and extractAudioToWavUrl (index.html:9182-9195), so the short range deleted
+  // them from play.html only. scripts/check-twin-drift-cases.mjs holds the proof.
+  { row: 3, name: "`encodeWavMono` + `mediaFetchError`", idx: [[9120, 9195]], play: [[6516, 6633]] },
+  { row: 4, name: "Prompt-cap helpers", idx: [[4203, 4253]], play: [[7880, 7929]] },
+  { row: 5, name: "Pricing resolver", idx: [[5571, 5715]], play: [[5929, 6058]] },
+  { row: 6, name: "MP4CAT", idx: [[9210, 9487]], play: [[6676, 6953]] },
+  // play.html used to read 6635-6679 + 6979-7169. 6635-6679 swallowed toLocalMediaUrl, seekVideo and
+  // MP4CAT's opening 4 lines, none of which index.html:9489-9741 holds; 6979-7169 started AFTER
+  // prepClip and recordClip (6954-6994), which index.html:9489-9741 does hold.
+  { row: 7, name: "Local media recorder path", idx: [[9489, 9741]], play: [[6635, 6640], [6668, 6675], [6954, 7167]] },
+  { row: 8, name: "Share packer, card and shorteners", idx: [[10725, 11041]], play: [[12823, 13142]] },
+  // play.html used to read 13281-13519, which swallowed the whole agent-pill popover (13283-13362)
+  // and the model-picker search — code index.html keeps at 11694-11710 and 10480.
+  { row: 9, name: "Share-menu wiring", idx: [[11154, 11194]], play: [[13281, 13281], [13363, 13415], [13519, 13519]] },
+];
+
+const inside = (n, ranges) => ranges.some(([a, b]) => n >= a && n <= b);
+const anyInside = (list, ranges) => list.some((n) => inside(n, ranges));
+const allInside = (list, ranges) => list.every((n) => inside(n, ranges));
+
+for (const b of BLOCKS) {
+  b.sig = shared.filter((h) => anyInside(IDX.get(h), b.idx) && anyInside(PLAY.get(h), b.play)).length;
+  b.deletes = shared.filter((h) => allInside(IDX.get(h), b.idx) && allInside(PLAY.get(h), b.play));
+}
+
+const gone = new Set();
+let after = shared.length;
+const rows = [];
+for (const b of BLOCKS) {
+  const fresh = b.deletes.filter((h) => !gone.has(h));
+  for (const h of fresh) gone.add(h);
+  after -= fresh.length;
+  rows.push({ ...b, new: fresh.length, after, overlap: b.deletes.length - fresh.length });
+}
+
+console.log(`shared set: ${shared.length} distinct lines\n`);
+console.log("| # | Block | sig | deletes | new | Baseline after |");
+console.log("|---|-------|-----|---------|-----|----------------|");
+for (const r of rows) {
+  console.log(`| ${r.row} | ${r.name} | ${r.sig} | ${r.deletes.length} | ${r.new} | ${r.after} |`);
+}
+
+const rowsWhereSigDiffers = rows.filter((r) => r.sig !== r.deletes.length);
+console.log(
+  `\nrows where sig != deletes (a twin has a copy outside the quoted ranges): ` +
+    (rowsWhereSigDiffers.map((r) => `${r.row} (${r.sig} vs ${r.deletes.length})`).join(", ") || "none")
+);
+const overlapping = rows.filter((r) => r.overlap);
+console.log(
+  `rows that overlap an earlier row: ` +
+    (overlapping.map((r) => `${r.row} (${r.overlap} line(s) already deleted)`).join(", ") || "none")
+);
+const first6 = rows[5].after;
+console.log(
+  `rows 1-6 together: ${shared.length - first6} lines, ${shared.length} down to ${first6}`
+);
+
+// The shared set here must be the set the guard pins. If this ever prints a mismatch, one of the 2
+// blanking copies moved and the table below is measuring a different repo than the guard.
+const BASELINE = join(ROOT, "scripts", "twin-drift-baseline.json");
+if (existsSync(BASELINE)) {
+  const pinned = JSON.parse(readFileSync(BASELINE, "utf8")).lines.map((l) => String(l).slice(0, 16));
+  const a = new Set(shared), b = new Set(pinned);
+  const only = [...a].filter((h) => !b.has(h)).length + [...b].filter((h) => !a.has(h)).length;
+  console.log(
+    only
+      ? `\nWARNING: ${only} line(s) differ between this script and scripts/twin-drift-baseline.json`
+      : `\nagrees with scripts/twin-drift-baseline.json: ${pinned.length} lines, no difference`
+  );
+}