Preview 002 and 003 (512 px), version selector, Show thinker, AI-output marking

- Model selector (003 default for a first visit, last choice remembered per browser); 003 at 512 or 256 px
with its prompt pipeline (normaliser, spelled-out quoted text, count code, "no X" -> negative) and SD3 shift.
- The ONNX files now load from each release's model repo (Logolabs/agate-preview-00X, webgpu/); the graphs
also output the thinker plan. models/ (the original 001 build) stays for ?models=./models/.
- Show thinker (default on, ~2-4% per step): the 16 x 16 plan (PCA colours, as the ComfyUI live preview) and
the expected image x1 at every step.
- Every image is marked: invisible-watermark dwtDctSvd (payload AGATE + release, bit-identical JS port), PNG
provenance text chunks on save (no prompt), and a visible "AI-generated" note.
- Parity fixtures for 002 and 003, and a 38-prompt golden test of the prompt pipeline (?golden=1).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018EtDckYfNgMbkwqVmTsdha

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.weights filter=lfs diff=lfs merge=lfs -text

README.md

@@ -12,42 +12,86 @@ custom_headers:
   cross-origin-opener-policy: same-origin
   cross-origin-resource-policy: cross-origin
 models:
+- Logolabs/agate-preview-003
+- Logolabs/agate-preview-002
 - Logolabs/agate-preview-001
 ---
 
 # Agate WebGPU
 
-Agate Preview 001, LogoLabs' 0.26B text-to-image model (a 191M flow generator with a 68M text encoder),
-running as a static page. The tokenizer, text encoder, 50-step flow sampler with classifier-free guidance
-and the TAESD decoder all run on your own GPU through WebGPU (onnxruntime-web).
+LogoLabs' Agate text-to-image models (a ~0.19B flow generator with a 68M text encoder) running as a static page.
+The tokenizer, text encoder, 50-step flow sampler with classifier-free guidance and the TAESD decoder all run
+on your own GPU through WebGPU (onnxruntime-web).
 
 **Runs entirely in your browser — prompts never leave your machine.** There is no server and no API call.
 
+## Models
+
+Pick a model at the top of the page. A first visit gets Preview 003; the page remembers your last choice in
+this browser.
+
+| model | resolution | notes | download |
+|---|---|---|---|
+| [Preview 003](https://huggingface.co/Logolabs/agate-preview-003) | 512 px (or 256) | multi-resolution model; prompt pipeline: normaliser, quoted text spelled out, object counts coded, "no X" moved to the negative prompt; SD3 timestep shift 2 at 512 | 531 MB (both resolutions share one weights file) |
+| [Preview 002](https://huggingface.co/Logolabs/agate-preview-002) | 256 px | same network as 001, trained longer | 530 MB |
+| [Preview 001](https://huggingface.co/Logolabs/agate-preview-001) | 256 px | the first preview | 530 MB |
+
+Each model is downloaded once and kept in the browser's Cache Storage. The files live in each release's model repo
+under `webgpu/` (e.g. [Logolabs/agate-preview-003/webgpu](https://huggingface.co/Logolabs/agate-preview-003/tree/main/webgpu)),
+with a `manifest.json` holding sizes and sha256s (the cache keys). `models/` in this Space is the original 001 build
+(without the plan output), kept for `?models=./models/`.
+
+## Show thinker
+
+Agate's thinker lays the picture out on a 16 × 16 grid (the plan) that steers the renderer. With **Show thinker**
+(on by default; it costs about 2-4% per step) the page shows, at every step, the plan of the conditional branch as
+colours and the image the model currently expects (x₁ = z + (1 − t)·v, with the SD latent→RGB approximation) —
+the same live preview as the [ComfyUI nodes](https://github.com/logolabs/agate-comfyui): the plan's cells are
+projected on its top three principal components, fitted at the first step with the 2% / 98% quantiles fixed then,
+so a colour keeps its meaning while the plan evolves.
+
 ## Requirements
 
-- A browser with WebGPU: a recent Chrome or Edge (113+). Safari and Firefox may lack WebGPU or need it
-  enabled in their settings; without it the page offers a WebAssembly (CPU) path that works but takes
-  minutes per image.
-- First load downloads about **530 MB** of weights (generator 385 MB, text encoder 137 MB, decoder 5 MB,
-  tokenizer 4 MB). They are kept in the browser's Cache Storage, so later visits load from disk.
+A browser with WebGPU: a recent Chrome or Edge (113+). Safari and Firefox may lack WebGPU or need it enabled in
+their settings; without it the page offers a WebAssembly (CPU) path that works but takes minutes per image.
+
+## Speed and accuracy (RTX 4060 laptop, Edge, WebGPU, warm)
+
+| model | per step (CFG batch of 2) | 50-step image | model setup per visit |
+|---|---|---|---|
+| 003 at 512 px | ~275 ms | ~14 s | ~15 s |
+| 003 at 256 px | ~120 ms | ~6 s | ~15 s |
+| 002 / 001 | ~105 ms | ~5.3 s | ~14 s |
+
+With identical initial noise, the browser output matches the PyTorch packages (TAESD decoder): 001 within
+5/255 per pixel, 002 within 14/255 (PSNR 52.8 dB), 003 within 29/255 at 512 px (PSNR 54.8 dB) and 47/255 at
+256 px (PSNR 48.9 dB), on a few pixels only (mean difference 0.1-0.2/255). The difference comes from storing the
+weights as fp16 to halve the download; an fp32 build matches to 1/255. Run the self-test with `?parity=1`.
+Seeds use a JavaScript PRNG, so a seed gives the same image in every browser, but not the same image as the
+PyTorch pipeline with that seed. The Python packages decode with the full SD-VAE by default; this page uses TAESD.
+
+## AI-generated content marking
+
+Every image the page makes is marked as AI-generated (EU AI Act Art. 50(2)), with the same marks as the Python
+packages:
 
-## Speed and accuracy
+- an invisible watermark in the pixels: [invisible-watermark](https://github.com/ShieldMnt/invisible-watermark)'s
+  `dwtDctSvd` method, ported to JavaScript bit for bit, with the 64-bit payload `AGATE` + release
+  (`AGATE003`, ...). `agate.detect_watermark(img)` from the model packages reads it;
+- in the saved PNG: text fields `ai_generated`, `generator`, `model` and `watermark`. The prompt is not written;
+- a visible "AI-generated" note next to each result.
 
-- About 6–7 s per 50-step 256×256 image on an RTX 4060, after roughly 10 s of one-time model
-  setup per visit.
-- With identical initial noise, the browser output matches the PyTorch reference pipeline within 5/255
-  per pixel (run the self-test with `?parity=1`).
-- Seeds use a JavaScript PRNG, so a seed gives the same image in every browser but not the same image as
-  the PyTorch pipeline with that seed.
+Neither mark is tamper-proof: screenshots and re-encodes drop the metadata, and heavy edits can remove the
+watermark. If you publish images made here, label them as AI-generated.
 
-Query parameters: `?autoload=1` loads the model immediately, `?ep=wasm` forces the CPU backend,
-`?parity=1` runs the parity self-test.
+Query parameters: `?v=001|002|003` picks a model, `?res=256` picks 003's resolution, `?autoload=1` loads the
+model immediately, `?ep=wasm` forces the CPU backend, `?parity=1` runs the parity self-test, `?golden=1` checks
+003's prompt pipeline against the Python package's output (38 prompts).
 
 ## Links
 
 - [logolabs.org](https://logolabs.org)
 - [huggingface.co/Logolabs](https://huggingface.co/Logolabs)
-- Model card: [Logolabs/agate-preview-001](https://huggingface.co/Logolabs/agate-preview-001)
 
 Licence: MIT.
 

css/style.css

@@ -95,3 +95,38 @@ input[type=range] { width: 100%; margin-top: 16px; accent-color: var(--red); }
   .mast-meta .label.dim { display: none; }
   .progress-text { flex-wrap: wrap; }
 }
+
+/* version selector, resolution, AI-generated note (2026-09-29) */
+.versions { margin-top: 24px; }
+.seg { display: flex; flex-wrap: wrap; gap: 0; margin-top: 8px; }
+.seg button { font: 600 13px/1 var(--mono); letter-spacing: .1em; text-transform: uppercase; background: var(--paper); color: var(--ink);
+  border: var(--hair); margin-left: -1.5px; padding: 11px 16px; cursor: pointer; border-radius: 0; display: inline-flex; flex-direction: column; align-items: flex-start; gap: 5px; }
+.seg button:first-child { margin-left: 0; }
+.seg button small { font: 400 11px/1 var(--mono); letter-spacing: .06em; text-transform: none; color: var(--mute); }
+.seg button[aria-checked="true"] { background: var(--ink); color: var(--paper); }
+.seg button[aria-checked="true"] small { color: #c9c6bf; }
+.seg button:hover:not([aria-checked="true"]):not(:disabled) { background: #fff; color: var(--red); }
+.seg button:disabled { opacity: .45; cursor: default; }
+.seg.small button { padding: 9px 12px; font-size: 12px; }
+.ver-note { margin: 10px 0 0; max-width: 70ch; color: #2a2824; font-size: 15px; }
+input[type=text] { width: 100%; font: 15px/1.45 var(--sans); color: var(--ink); background: #fff; border: var(--hair); border-radius: 0; padding: 8px 12px; margin: 8px 0 18px; }
+.label .dim { color: var(--mute); text-transform: none; letter-spacing: .02em; }
+.res-row { grid-template-columns: 1fr; }
+.prepared { font: 12px/1.5 var(--mono); color: var(--mute); margin: 12px 0 0; overflow-wrap: anywhere; }
+.ai-note { display: flex; gap: 10px; align-items: baseline; margin: 10px 0 0; font-size: 14px; line-height: 1.45; border-left: 3px solid var(--red); padding: 6px 0 6px 10px; background: #fff; }
+.ai-note .sq { position: relative; top: 1px; }
+.small-print { font-size: 13.5px; color: #2a2824; max-width: 90ch; }
+.small-print code { font: 12.5px var(--mono); }
+@media (max-width: 520px) {
+  #versions { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); }
+  #versions button { padding: 10px 8px; font-size: 12px; letter-spacing: .06em; }
+}
+
+/* thinker preview (plan + expected image), 2026-09-29 */
+.toggles { display: inline-flex; gap: 14px; flex-wrap: wrap; justify-content: flex-end; }
+.thinker { display: grid; grid-template-columns: 1fr 1fr; gap: 12px; margin-top: 12px; }
+.thinker figure { margin: 0; }
+.thinker canvas { width: 100%; aspect-ratio: 1 / 1; display: block; border: var(--hair); image-rendering: pixelated; background: #fff; }
+.thinker #pred-canvas { image-rendering: auto; }
+.thinker figcaption { margin-top: 6px; }
+.thinker-note { grid-column: 1 / -1; margin: 0; font-size: 13px; color: var(--mute); }

index.html

@@ -3,8 +3,8 @@
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1">
-<title>Agate Preview 001 — in your browser</title>
-<meta name="description" content="Agate Preview 001, LogoLabs' 0.26B text-to-image model, running entirely in your browser on WebGPU.">
+<title>Agate — in your browser</title>
+<meta name="description" content="Agate Preview 001, 002 and 003, LogoLabs' 0.26B text-to-image models, running entirely in your browser on WebGPU.">
 <link rel="icon" href="assets/agate-a.svg" type="image/svg+xml">
 <link rel="preconnect" href="https://fonts.googleapis.com">
 <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
@@ -17,8 +17,8 @@
     <div class="mast-left">
       <img class="lockup" src="assets/agate-lockup.svg" alt="Agate">
       <div class="mast-meta">
-        <span class="label"><i class="sq"></i>Preview 001</span>
-        <span class="label dim">0.26B · text-to-image · 256 px</span>
+        <span class="label"><i class="sq"></i><span id="mast-version">Preview 003</span></span>
+        <span class="label dim" id="mast-spec">0.26B · text-to-image · 512 px</span>
       </div>
     </div>
     <a class="imprint" href="https://logolabs.org" target="_blank" rel="noopener">
@@ -30,8 +30,14 @@
 
   <section class="intro">
     <h1>Agate, in your browser.</h1>
-    <p>A 191M-parameter flow model with a 68M text encoder, running on your own GPU through WebGPU.
-      The first visit downloads the weights once (<span id="dl-size">530 MB</span>); after that they load from the browser cache.</p>
+    <p>A 0.19B-parameter flow model with a 68M text encoder, running on your own GPU through WebGPU.
+      The first visit downloads the chosen model once (<span id="dl-size">about 530 MB</span>); after that it loads from the browser cache.</p>
+  </section>
+
+  <section class="versions" aria-labelledby="ver-label">
+    <span class="label" id="ver-label">Model</span>
+    <div class="seg" role="radiogroup" aria-labelledby="ver-label" id="versions"></div>
+    <p class="ver-note" id="ver-note"></p>
   </section>
 
   <div id="nogpu" class="notice" hidden>
@@ -39,7 +45,7 @@
     <p id="nogpu-why"></p>
     <p>Agate needs WebGPU for usable speed: use a recent Chrome or Edge (113+) on Windows, macOS or ChromeOS,
       or Chrome on Android 121+; on Linux and in Firefox/Safari WebGPU may have to be enabled in the browser's flags.
-      You can still run it on the CPU (WebAssembly) — correct, but several minutes per image.</p>
+      You can still run it on the CPU (WebAssembly) — correct, but several minutes per image (far longer at 512 px).</p>
     <button id="use-wasm" class="btn ghost">Run on CPU instead</button>
   </div>
 
@@ -50,6 +56,8 @@
       <div class="examples" id="examples">
         <span class="label dim">Try</span>
       </div>
+      <label class="label" for="negative">Avoid <span class="dim" id="neg-hint">(optional negative prompt)</span></label>
+      <input id="negative" type="text" spellcheck="false" placeholder="e.g. text, blur">
 
       <div class="row">
         <div class="field">
@@ -68,6 +76,12 @@
           <input id="cfg" type="range" min="1" max="8" step="0.5" value="3">
         </div>
       </div>
+      <div class="row res-row" id="res-row" hidden>
+        <div class="field">
+          <span class="label">Resolution</span>
+          <div class="seg small" role="radiogroup" id="res"></div>
+        </div>
+      </div>
 
       <button id="go" class="btn primary" disabled>Load model</button>
 
@@ -75,19 +89,34 @@
         <div class="bar"><div id="bar-fill"></div></div>
         <div class="progress-text"><span id="status" class="label">Idle</span><span id="status-r" class="label dim"></span></div>
       </div>
+      <p class="prepared" id="prepared" hidden></p>
     </section>
 
     <section class="panel output">
       <div class="out-head">
-        <span class="label"><i class="sq"></i>Output · 256 × 256</span>
-        <label class="label toggle"><input type="checkbox" id="crisp"> Crisp pixels</label>
+        <span class="label"><i class="sq"></i><span id="out-label">Output · 512 × 512</span></span>
+        <span class="toggles">
+          <label class="label toggle" title="Show the thinker's 16 x 16 plan and the expected final image at every step"><input type="checkbox" id="show-thinker" checked> Show thinker</label>
+          <label class="label toggle"><input type="checkbox" id="crisp"> Crisp pixels</label>
+        </span>
       </div>
       <div class="frame" id="frame">
-        <canvas id="canvas" width="256" height="256"></canvas>
+        <canvas id="canvas" width="512" height="512"></canvas>
         <div class="placeholder" id="placeholder">
           <img src="assets/agate-a.svg" alt="">
         </div>
       </div>
+      <div class="thinker" id="thinker" hidden>
+        <figure><canvas id="plan-canvas" width="16" height="16"></canvas>
+          <figcaption class="label dim">Thinker plan · 16 × 16</figcaption></figure>
+        <figure><canvas id="pred-canvas" width="32" height="32"></canvas>
+          <figcaption class="label dim">Expected · <span id="thinker-step">0 / 0</span></figcaption></figure>
+        <p class="thinker-note">The thinker lays the picture out on a 16 × 16 grid before the renderer paints it.
+          Colours are the plan's three main directions (fixed at the first step, as in the ComfyUI nodes); the
+          expected image is x₁ = z + (1 − t)·v, shown with the SD latent→RGB approximation.</p>
+      </div>
+      <p class="ai-note" id="ai-note" hidden><i class="sq red"></i><span><b>AI-generated image.</b>
+        Made by <span id="ai-model">Agate Preview 003</span>; it carries an invisible watermark and, when saved, PNG provenance metadata (no prompt).</span></p>
       <div class="out-foot">
         <dl class="timings" id="timings"></dl>
         <a id="save" class="btn ghost small" download="agate.png" hidden>Save PNG</a>
@@ -100,6 +129,9 @@
   <hr class="rule">
   <footer class="foot">
     <p class="strong">Runs entirely in your browser on WebGPU — nothing leaves your machine.</p>
+    <p class="small-print">Every image made here is marked as AI-generated (EU AI Act Art. 50): an invisible watermark in the
+      pixels (invisible-watermark “dwtDctSvd”, payload AGATE + release) and, in the saved PNG, text fields
+      <code>ai_generated</code>, <code>generator</code>, <code>model</code>. Neither survives every edit; please label AI images you publish.</p>
     <p class="label dim">
       <a href="https://logolabs.org" target="_blank" rel="noopener">logolabs.org</a> ·
       <a href="https://huggingface.co/Logolabs" target="_blank" rel="noopener">huggingface.co/Logolabs</a> ·

js/agate.js

@@ -1,16 +1,28 @@
-// Agate Preview 001 in the browser: tokenizer (tokenizers.js) + three ONNX graphs run by
-// onnxruntime-web (WebGPU, WASM fallback) + a 50-step Euler flow sampler with CFG.
-// Mirrors agate/pipeline.py (AgatePipeline) of Logolabs/agate-preview-001.
+// Agate in the browser: tokenizer (tokenizers.js) + ONNX graphs run by onnxruntime-web (WebGPU, WASM
+// fallback) + an Euler flow sampler with CFG. Mirrors agate/pipeline.py (AgatePipeline) of
+// Logolabs/agate-preview-001 / -002 (fcdm_t2, 256 px) and Logolabs/agate-preview-003 (fcdm_t2mr: 512 or 256 px,
+// SD3 timestep shift, prompt pipeline + count code, see prompt.js). Every image is marked (marking.js).
 
 import * as ort from "https://cdn.jsdelivr.net/npm/onnxruntime-web@1.30.0/dist/ort.webgpu.bundle.min.mjs";
 import { Tokenizer } from "https://cdn.jsdelivr.net/npm/@huggingface/tokenizers@0.2.0/dist/tokenizers.mjs";
+import { prepare, countVector } from "./prompt.js";
+import { embedWatermark, marks } from "./marking.js";
 
 export { ort };
 
-const BUCKETS = [64, 128, 256, 512];
-const CACHE_NAME = "agate-preview-001-web";
-const COUNT_URL = "https://huggingface.co/Logolabs/agate-preview-001/resolve/main/config.json";
-const MODEL_FILES = ["tokenizer.json", "tokenizer_config.json", "text_encoder.onnx", "generator.onnx", "taesd_decoder.onnx"];
+// The releases this page runs. remote: where the files live -- each release's model repo, under webgpu/ (the
+// Space repo has a 1 GB storage limit; the graphs there also output the thinker plan). The Space's old models/
+// (001 without the plan output) is used only through ?models=. dir: the layout under a local
+// models base (?models=<url> or window.AGATE_MODEL_BASE given explicitly, e.g. for local testing). cache: Cache
+// Storage name (001 keeps the name it always had, so returning visitors do not download it again).
+const HUB = (v) => `https://huggingface.co/Logolabs/agate-preview-${v}/resolve/main/webgpu/`;
+export const VERSIONS = {
+  "003": { remote: HUB("003"), dir: "003/", cache: "agate-preview-003-web", res: [512, 256], note: "Multi-resolution model, 512 px (or 256). Quoted text is spelled out, counts are coded, “no X” becomes a negative prompt." },
+  "002": { remote: HUB("002"), dir: "002/", cache: "agate-preview-002-web", res: [256], note: "Same network as 001, trained 38,710 steps longer before the same anneal. 256 px, plain prompts." },
+  "001": { remote: HUB("001"), dir: "", cache: "agate-preview-001-web", res: [256], note: "The first preview (2026-09-25). 256 px, plain prompts." },
+};
+const countUrl = (v) => `https://huggingface.co/Logolabs/agate-preview-${v}/resolve/main/config.json`;
+const FILES_T2 = ["tokenizer.json", "tokenizer_config.json", "text_encoder.onnx", "generator.onnx", "taesd_decoder.onnx"];
 
 export async function webgpuStatus() {
   if (!("gpu" in navigator)) return { ok: false, why: "This browser does not expose WebGPU (navigator.gpu is missing)." };
@@ -26,12 +38,12 @@ export async function webgpuStatus() {
 }
 
 // ---- downloads with progress + Cache Storage ---------------------------------------------------
-async function openCache() {
-  try { return await caches.open(CACHE_NAME); } catch { return null; }   // file://, private mode, ...
+async function openCache(name) {
+  try { return await caches.open(name); } catch { return null; }   // file://, private mode, ...
 }
 
-async function fetchCached(url, key, expectBytes, onBytes) {
-  const cache = await openCache();
+async function fetchCached(cacheName, url, key, expectBytes, onBytes) {
+  const cache = await openCache(cacheName);
   if (cache) {
     const hit = await cache.match(key);
     if (hit) { const buf = new Uint8Array(await hit.arrayBuffer()); onBytes(buf.byteLength, true); return { buf, cached: true }; }
@@ -56,49 +68,70 @@ async function fetchCached(url, key, expectBytes, onBytes) {
   return { buf, cached: false };
 }
 
-export async function hasCachedModel() {
-  try { const c = await caches.open(CACHE_NAME); return (await c.keys()).length >= MODEL_FILES.length; } catch { return false; }
+export async function hasCachedModel(version = "001") {
+  try { const c = await caches.open(VERSIONS[version].cache); return (await c.keys()).length >= 5; } catch { return false; }
 }
 
-export async function clearCache() { try { return await caches.delete(CACHE_NAME); } catch { return false; } }
+export async function clearCache() {
+  let ok = true;
+  for (const v of Object.values(VERSIONS)) { try { ok = (await caches.delete(v.cache)) && ok; } catch { ok = false; } }
+  return ok;
+}
 
 // The Hub counts a model download only on a request for the model repo's root config.json; the ONNX files
-// come from this Space, so every model load reads it once -- the same per-load count a Python
-// from_pretrained() produces, cached weights or not.
-function countLoad() { fetch(COUNT_URL, { cache: "no-store" }).catch(() => {}); }
+// come from this Space, so every model load reads the loaded release's config.json once -- the same per-load
+// count a Python from_pretrained() produces, cached weights or not.
+function countLoad(version) { fetch(countUrl(version), { cache: "no-store" }).catch(() => {}); }
 
 // ---- the model ---------------------------------------------------------------------------------
 export class Agate {
-  constructor({ base = "./models/", ep = "webgpu", variant = null, optLevel = "all" } = {}) {
+  // base: the page's models folder (001); override: an explicit models base for every version (local layout)
+  constructor({ base = "./models/", override = null, version = "003", ep = "webgpu", variant = null, optLevel = "all" } = {}) {
     this.optLevel = optLevel;
-    this.base = base.endsWith("/") ? base : base + "/";
+    const slash = (u) => (u.endsWith("/") ? u : u + "/");
+    this.version = version;
+    this.spec = VERSIONS[version];
+    this.base = override ? slash(override) + this.spec.dir : (this.spec.remote || slash(base) + this.spec.dir);
     this.ep = ep;
-    this.variant = variant;          // e.g. "full16": fp16-compute generator (experimental)
+    this.variant = variant;          // e.g. "full16": fp16-compute generator (experimental, 001 only)
+    this.marks = marks(version);
+  }
+
+  get mr() { return this.manifest?.arch === "fcdm_t2mr"; }
+
+  fileKey(f) { return new Request(`${this.base}${f}?sha256=${this.manifest.files[f].sha256}`); }
+
+  async getFile(f, onBytes = () => {}) {
+    const meta = this.manifest.files[f];
+    return (await fetchCached(this.spec.cache, this.base + f, this.fileKey(f), meta.bytes, onBytes)).buf;
   }
 
-  // onProgress({loaded, total, file, phase})
-  async load(onProgress = () => {}) {
+  // onProgress({loaded, total, file, phase}); resolution: 003 only (512 default, or 256)
+  async load(onProgress = () => {}, resolution = null) {
     const manifest = await (await fetch(this.base + "manifest.json", { cache: "no-cache" })).json();
     this.manifest = manifest;
     const swap = (this.variant && manifest.variants?.[this.variant]) || {};
     const real = (f) => swap[f] || f;
-    const total = MODEL_FILES.reduce((s, f) => s + manifest.files[real(f)].bytes, 0);
+    this.resolution = this.mr ? Number(resolution || manifest.resolution) : 256;
+    // 003: download everything (the two graphs are ~1 MB each and share one weights file), so a resolution
+    // switch needs no network
+    const need = this.mr ? Object.keys(manifest.files) : FILES_T2;
+    const total = need.reduce((s, f) => s + manifest.files[real(f)].bytes, 0);
     let loaded = 0, fromCache = 0;
     const bufs = {};
     const t0 = performance.now();
-    for (const f of MODEL_FILES) {
+    for (const f of need) {
       const meta = manifest.files[real(f)];
-      const key = new Request(`${this.base}${real(f)}?sha256=${meta.sha256}`);
-      const { buf, cached } = await fetchCached(this.base + real(f), key, meta.bytes, (b, c) => {
+      const { buf } = await fetchCached(this.spec.cache, this.base + real(f), this.fileKey(real(f)), meta.bytes, (b, c) => {
         loaded += b; if (c) fromCache += b; onProgress({ phase: "download", file: f, loaded, total });
       });
       bufs[f] = buf;
     }
     this.stats = { downloadMB: total / 1e6, fromCacheMB: fromCache / 1e6, downloadMs: performance.now() - t0 };
-    countLoad();
-    // drop cached files of older model versions (keys carry the sha256)
+    countLoad(this.version);
+    // drop cached files of older builds of this release (keys carry the sha256)
     try {
-      const cache = await openCache(), keep = new Set(MODEL_FILES.map((f) => new URL(`${this.base}${real(f)}?sha256=${manifest.files[real(f)].sha256}`, location.href).href));
+      const cache = await openCache(this.spec.cache), keep = new Set(need.map((f) => new URL(this.fileKey(real(f)).url, location.href).href));
       if (cache) for (const req of await cache.keys()) if (!keep.has(req.url)) await cache.delete(req);
     } catch (e) { console.warn("cache cleanup", e); }
     const dec = new TextDecoder();
@@ -107,20 +140,53 @@ export class Agate {
     if (this.ep === "wasm") {
       ort.env.wasm.numThreads = self.crossOriginIsolated ? Math.min(8, navigator.hardwareConcurrency || 4) : 1;
     }
-    const opts = { executionProviders: [this.ep], graphOptimizationLevel: this.optLevel };
     const t1 = performance.now();
     this.sessions = {};
-    for (const [name, f] of [["text", "text_encoder.onnx"], ["gen", "generator.onnx"], ["vae", "taesd_decoder.onnx"]]) {
+    for (const [name, f] of [["text", "text_encoder.onnx"], ["vae", "taesd_decoder.onnx"]]) {
       onProgress({ phase: "init", file: f, loaded: total, total });
       const ts = performance.now();
-      this.sessions[name] = await ort.InferenceSession.create(bufs[f], opts);
+      this.sessions[name] = await ort.InferenceSession.create(bufs[f], this.sessionOptions());
       this.stats[`${name}SessionMs`] = performance.now() - ts;
       bufs[f] = null;
     }
+    onProgress({ phase: "init", file: "generator", loaded: total, total });
+    const ts = performance.now();
+    if (this.mr) {
+      this.weights = bufs["generator.weights"];              // kept for a resolution switch (no re-read)
+      await this.createGenerator(this.resolution, bufs);
+    } else {
+      this.sessions.gen = await ort.InferenceSession.create(bufs["generator.onnx"], this.sessionOptions());
+    }
+    this.stats.genSessionMs = performance.now() - ts;
     this.stats.sessionMs = performance.now() - t1;
     return this.stats;
   }
 
+  sessionOptions(extra = {}) { return { executionProviders: [this.ep], graphOptimizationLevel: this.optLevel, ...extra }; }
+
+  // 003: the generator graph for one resolution; the weights file is shared by both graphs.
+  async createGenerator(res, bufs = {}) {
+    const r = this.manifest.resolutions[String(res)];
+    if (!r) throw new Error(`resolution ${res} not available`);
+    const graph = bufs[r.graph] || await this.getFile(r.graph);
+    const weights = this.weights || await this.getFile(r.external_data);
+    if (this.sessions.gen) { try { await this.sessions.gen.release(); } catch { /* */ } this.sessions.gen = null; }
+    this.sessions.gen = await ort.InferenceSession.create(graph, this.sessionOptions({ externalData: [{ path: r.external_data, data: weights }] }));
+    this.resolution = Number(res);
+  }
+
+  async setResolution(res) {
+    if (!this.mr || Number(res) === this.resolution) return 0;
+    const t0 = performance.now();
+    await this.createGenerator(res);
+    return performance.now() - t0;
+  }
+
+  async release() {
+    for (const s of Object.values(this.sessions || {})) { try { await s?.release(); } catch { /* */ } }
+    this.sessions = null; this.weights = null;
+  }
+
   tokenize(text) {
     const max = this.manifest.text_max_len;
     let ids = this.tok.encode(text).ids;                 // [CLS] ... [SEP], as the HF tokenizer
@@ -139,7 +205,15 @@ export class Agate {
     const h = out.last_hidden_state;
     const data = h.data.slice();                          // (1, n, 512) fp32
     h.dispose?.();
-    return { data, n };
+    return { data, n, ids };
+  }
+
+  // The prompt as the model sees it: 003 runs its prompt pipeline (prompt.js), 001/002 use the prompt as typed.
+  prepare(prompt, negative = "") {
+    const pp = this.manifest.prompt_pipeline;
+    if (!pp) return { text: prompt, negative };
+    const [text, neg] = prepare(prompt, negative, pp.normalize, pp.spell);
+    return { text, negative: neg };
   }
 
   static gaussianNoise(seed, count) {
@@ -156,38 +230,67 @@ export class Agate {
     return out;
   }
 
-  // -> { rgba: Uint8ClampedArray (256*256*4), latent: Float32Array, timings }
-  async generate({ prompt, negative = "", seed = 0, steps = 50, cfg = 3.0, noise = null, onStep = () => {}, shouldStop = () => false }) {
-    const hw = this.manifest.latent_hw, C = this.manifest.latent_ch, D = this.manifest.ctx_dim;
+  // SD3's resolution shift in Agate's convention (t = 0 noise), as agate/pipeline.py shift_t
+  static shiftT(t, shift) {
+    if (shift === 1) return t;
+    const s = 1 - t;
+    return 1 - shift * s / (1 + (shift - 1) * s);
+  }
+
+  // -> { rgba (watermarked unless watermark=false), width, height, latent, timings, prepared }
+  get hasPlan() { return !!this.sessions?.gen?.outputNames?.includes("plan"); }
+
+  // onPreview({ step, steps, plan, x1, hw }) after every step, when given and the graph outputs the plan: plan =
+  // the thinker output for the conditional branch (Float32Array 640 x 16 x 16), x1 = z + (1 - t) v (guided).
+  async generate({ prompt, negative = "", seed = 0, steps = 50, cfg = 3.0, noise = null, watermark = true, onStep = () => {}, onPreview = null, shouldStop = () => false }) {
+    const C = this.manifest.latent_ch, D = this.manifest.ctx_dim;
+    const rc = this.mr ? this.manifest.resolutions[String(this.resolution)] : { latent_hw: this.manifest.latent_hw, shift: 1 };
+    const hw = rc.latent_hw, shift = Number(rc.shift || 1);
     const per = C * hw * hw;
     const T = { };
     let t0 = performance.now();
-    const c = await this.encode(prompt), u = await this.encode(negative);
+    const prep = this.prepare(prompt, negative);
+    const c = await this.encode(prep.text), u = await this.encode(prep.negative);
     T.textMs = performance.now() - t0;
+    const BUCKETS = this.manifest.buckets;
     const need = Math.max(c.n, u.n);
     const L = BUCKETS.find((b) => b >= need) ?? BUCKETS[BUCKETS.length - 1];
     const ctx = new Float32Array(2 * L * D), mask = new Float32Array(2 * L);
     ctx.set(c.data, 0); ctx.set(u.data, L * D);           // zero padding, as F.pad in the pipeline
     mask.fill(1, 0, c.n); mask.fill(1, L, L + u.n);
-    const ctxT = new ort.Tensor("float32", ctx, [2, L, D]), maskT = new ort.Tensor("float32", mask, [2, L]);
+    const feeds = { ctx: new ort.Tensor("float32", ctx, [2, L, D]), mask: new ort.Tensor("float32", mask, [2, L]) };
+    let countsNonzero = 0;
+    if (this.mr) {                                        // count code: conditional half only
+      const cnt = new Float32Array(2 * L);
+      if (this.manifest.prompt_pipeline?.count_code) cnt.set(countVector(this.tok, prep.text, c.ids, Math.min(L, c.n)), 0);
+      countsNonzero = cnt.reduce((s, v) => s + (v > 0), 0);
+      feeds.counts = new ort.Tensor("float32", cnt, [2, L]);
+    }
 
     let z = noise ? Float32Array.from(noise) : Agate.gaussianNoise(seed, per);
     const zz = new Float32Array(2 * per), tt = new Float32Array(2);
-    const dt = 1 / steps;
+    const grid = Array.from({ length: steps + 1 }, (_, i) => Agate.shiftT(i / steps, shift));
     t0 = performance.now();
     const stepMs = [];
     for (let i = 0; i < steps; i++) {
       if (shouldStop()) throw new Error("stopped");
       const ts = performance.now();
       zz.set(z, 0); zz.set(z, per);
-      tt[0] = tt[1] = i * dt;
-      const out = await this.sessions.gen.run({
-        z: new ort.Tensor("float32", zz, [2, C, hw, hw]), t: new ort.Tensor("float32", tt, [2]), ctx: ctxT, mask: maskT,
-      });
+      tt[0] = tt[1] = grid[i];
+      const want = onPreview && this.hasPlan ? ["v", "plan"] : ["v"];
+      const out = await this.sessions.gen.run({ z: new ort.Tensor("float32", zz, [2, C, hw, hw]), t: new ort.Tensor("float32", tt, [2]), ...feeds }, want);
       const v = out.v.data;
+      const dt = grid[i + 1] - grid[i];
       const zn = new Float32Array(per);
-      for (let k = 0; k < per; k++) { const vc = v[k], vu = v[per + k]; zn[k] = z[k] + dt * (vu + cfg * (vc - vu)); }
+      let x1 = null;
+      if (out.plan) x1 = new Float32Array(per);
+      for (let k = 0; k < per; k++) {
+        const vc = v[k], vu = v[per + k], g = vu + cfg * (vc - vu);
+        zn[k] = z[k] + dt * g;
+        if (x1) x1[k] = z[k] + (1 - grid[i]) * g;
+      }
       out.v.dispose?.();
+      if (out.plan) { const plan = out.plan.data.slice(); out.plan.dispose?.(); onPreview({ step: i + 1, steps, plan, x1, hw }); }
       z = zn;
       stepMs.push(performance.now() - ts);
       onStep(i + 1, steps, z);
@@ -209,8 +312,11 @@ export class Agate {
       rgba[p * 4 + 3] = 255;
     }
     T.decodeMs = performance.now() - t0;
-    T.totalMs = T.textMs + T.samplerMs + T.decodeMs;
+    t0 = performance.now();
+    if (watermark) embedWatermark(rgba, W, H, this.marks.payload);
+    T.markMs = performance.now() - t0;
+    T.totalMs = T.textMs + T.samplerMs + T.decodeMs + T.markMs;
     T.bucket = L;
-    return { rgba, width: W, height: H, latent: z, timings: T };
+    return { rgba, width: W, height: H, latent: z, timings: T, prepared: { ...prep, countsNonzero }, watermarked: watermark };
   }
 }

js/app.js

@@ -1,163 +1,326 @@
-import { Agate, webgpuStatus, clearCache, hasCachedModel } from "./agate.js";
-
-// Model location: ?models=<url> overrides; otherwise window.AGATE_MODEL_BASE (js/config.js); default ./models/
-const params = new URLSearchParams(location.search);
-const BASE = params.get("models") || window.AGATE_MODEL_BASE || "./models/";
-const FORCE_EP = params.get("ep");            // "wasm" forces the CPU path
-const PARITY = params.has("parity");
-const VARIANT = params.get("variant");      // "full16": experimental fp16-compute generator
-
-const EXAMPLES = [
-  "a green teapot and a red cup on a table",
-  "a minimalist logo of a fox head, orange, flat design, white background",
-  "a dog sitting to the left of a cat",
-  "a geometric mountain logo in blue and white",
-  "a red cube on top of a blue sphere",
-];
-
-const $ = (id) => document.getElementById(id);
-const ui = {
-  prompt: $("prompt"), seed: $("seed"), steps: $("steps"), cfg: $("cfg"), go: $("go"), dice: $("dice"),
-  fill: $("bar-fill"), status: $("status"), statusR: $("status-r"), canvas: $("canvas"), frame: $("frame"),
-  placeholder: $("placeholder"), timings: $("timings"), save: $("save"), crisp: $("crisp"), backend: $("backend"),
-};
-
-let agate = null, ep = FORCE_EP || "webgpu", busy = false, stop = false;
-window.__agate = { state: "idle" };           // read by the automated browser test
-
-for (const p of EXAMPLES) {
-  const b = document.createElement("button");
-  b.className = "chip"; b.textContent = p; b.type = "button";
-  b.onclick = () => { ui.prompt.value = p; };
-  $("examples").appendChild(b);
-}
-ui.steps.oninput = () => { $("steps-v").textContent = ui.steps.value; };
-ui.cfg.oninput = () => { $("cfg-v").textContent = Number(ui.cfg.value).toFixed(1); };
-ui.dice.onclick = () => { ui.seed.value = Math.floor(Math.random() * 2 ** 31); };
-try { ui.crisp.checked = localStorage.getItem("agate-crisp") === "1"; } catch { /* storage blocked */ }
-const applyCrisp = () => { ui.frame.classList.toggle("crisp", ui.crisp.checked); try { localStorage.setItem("agate-crisp", ui.crisp.checked ? "1" : "0"); } catch { /* */ } };
-ui.crisp.onchange = applyCrisp; applyCrisp();
-
-const mb = (b) => (b / 1e6).toFixed(0);
-function setProgress(frac, left, right = "") {
-  ui.fill.style.width = `${Math.max(0, Math.min(1, frac)) * 100}%`;
-  ui.status.textContent = left; ui.statusR.textContent = right;
-}
-function showTimings(rows) {
-  ui.timings.innerHTML = rows.map(([k, v]) => `<dt>${k}</dt><dd>${v}</dd>`).join("");
-}
-
-async function load() {
-  busy = true; ui.go.disabled = true;
-  window.__agate.state = "loading";
-  agate = new Agate({ base: BASE, ep, variant: VARIANT, optLevel: params.get("opt") || "all" });
-  try {
-    const t0 = performance.now();
-    const st = await agate.load(({ phase, file, loaded, total }) => {
-      if (phase === "download") setProgress(loaded / total, `Downloading ${file}`, `${mb(loaded)} / ${mb(total)} MB`);
-      else setProgress(1, `Preparing ${file} on ${ep === "webgpu" ? "WebGPU" : "CPU"}`, `${mb(total)} MB`);
-    });
-    const loadMs = performance.now() - t0;
-    $("dl-size").textContent = `${st.downloadMB.toFixed(0)} MB`;
-    ui.backend.textContent = `backend: ${ep === "webgpu" ? "WebGPU" : "WebAssembly (CPU)"}`;
-    const src = st.fromCacheMB > st.downloadMB * 0.99 ? "from browser cache" : "downloaded";
-    setProgress(0, "Ready", `${st.downloadMB.toFixed(0)} MB ${src} · ${(loadMs / 1000).toFixed(1)} s`);
-    window.__agate = { state: "ready", load: { ...st, loadMs, ep } };
-    ui.go.textContent = "Generate"; ui.go.disabled = false;
-  } catch (e) {
-    console.error(e);
-    setProgress(0, "Load failed", String(e.message || e));
-    window.__agate = { state: "error", error: String(e.message || e) };
-    ui.go.textContent = "Retry load"; ui.go.disabled = false; agate = null;
-  }
-  busy = false;
-}
-
-async function generate(opts = {}) {
-  busy = true; stop = false;
-  ui.go.textContent = "Stop"; ui.frame.classList.add("busy");
-  window.__agate.state = "generating";
-  const steps = opts.steps ?? Number(ui.steps.value);
-  try {
-    setProgress(0, "Encoding prompt", "");
-    const r = await agate.generate({
-      prompt: opts.prompt ?? ui.prompt.value.trim(), seed: Number(ui.seed.value) >>> 0, steps,
-      cfg: opts.cfg ?? Number(ui.cfg.value), noise: opts.noise ?? null,
-      onStep: (i, n) => setProgress(i / n, `Step ${i} / ${n}`, ""),
-      shouldStop: () => stop,
-    });
-    const ctx = ui.canvas.getContext("2d");
-    ui.canvas.width = r.width; ui.canvas.height = r.height;
-    ctx.putImageData(new ImageData(r.rgba, r.width, r.height), 0, 0);
-    ui.placeholder.hidden = true;
-    const T = r.timings;
-    setProgress(1, "Done", `${(T.totalMs / 1000).toFixed(1)} s`);
-    showTimings([
-      ["text encode", `${T.textMs.toFixed(0)} ms (bucket ${T.bucket})`],
-      ["per step", `${T.stepMs.toFixed(0)} ms × ${steps} (first ${T.firstStepMs.toFixed(0)} ms)`],
-      ["decode", `${T.decodeMs.toFixed(0)} ms`],
-      ["total", `${(T.totalMs / 1000).toFixed(2)} s`],
-    ]);
-    ui.save.href = ui.canvas.toDataURL("image/png"); ui.save.hidden = false;
-    window.__agate = { ...window.__agate, state: "done", timings: T };
-    return r;
-  } catch (e) {
-    if (String(e.message) === "stopped") setProgress(0, "Stopped", "");
-    else { console.error(e); setProgress(0, "Error", String(e.message || e)); window.__agate.error = String(e.message || e); }
-    window.__agate.state = "done";
-  } finally {
-    busy = false; ui.go.textContent = "Generate"; ui.frame.classList.remove("busy");
-  }
-}
-
-ui.go.onclick = async () => {
-  if (busy && agate?.sessions) { stop = true; return; }
-  if (busy) return;
-  if (!agate) return load();
-  return generate();
-};
-ui.prompt.addEventListener("keydown", (e) => { if (e.key === "Enter" && (e.ctrlKey || e.metaKey) && agate && !busy) generate(); });
-
-// Parity self-test: index.html?parity=1 runs the fixture exported by export/parity_full.py
-async function parity() {
-  const fx = await (await fetch("test/parity.json")).json();
-  const bin = async (f) => new Uint8Array(await (await fetch(`test/${f}`)).arrayBuffer());
-  const noise = new Float32Array((await bin("parity_noise.bin")).buffer);
-  const refZ = new Float32Array((await bin("parity_latent.bin")).buffer);
-  const refImg = await bin("parity_image.bin");     // HWC uint8
-  ui.prompt.value = fx.prompt; ui.steps.value = fx.steps; ui.cfg.value = fx.cfg;
-  const r = await generate({ prompt: fx.prompt, steps: fx.steps, cfg: fx.cfg, noise });
-  let dz = 0, dzs = 0, di = 0, dis = 0;
-  for (let k = 0; k < refZ.length; k++) { const d = Math.abs(r.latent[k] - refZ[k]); dz = Math.max(dz, d); dzs += d; }
-  for (let p = 0; p < refImg.length / 3; p++) for (let c = 0; c < 3; c++) {
-    const d = Math.abs(r.rgba[p * 4 + c] - refImg[p * 3 + c]); di = Math.max(di, d); dis += d;
-  }
-  const res = { latentMaxAbs: dz, latentMeanAbs: dzs / refZ.length, imageMaxAbs: di, imageMeanAbs: dis / refImg.length, ep, timings: r.timings };
-  const el = $("parity"); el.hidden = false;
-  el.innerHTML = `<span class="label"><i class="sq red"></i>Parity vs PyTorch pipeline (${ep})</span>
-    <p>final latent max |Δ| ${dz.toFixed(4)} (mean ${res.latentMeanAbs.toFixed(5)}) · image max |Δ| ${di}/255 (mean ${res.imageMeanAbs.toFixed(3)})</p>`;
-  window.__agate = { ...window.__agate, parity: res, state: "parity-done" };
-}
-
-(async () => {
-  if (!FORCE_EP) {
-    const s = await webgpuStatus();
-    if (!s.ok) {
-      ep = "wasm";
-      $("nogpu").hidden = false; $("nogpu-why").textContent = s.why;
-      ui.go.disabled = true; ui.go.textContent = "WebGPU required";
-      window.__agate = { state: "no-webgpu", why: s.why };
-      $("use-wasm").onclick = () => { $("nogpu").hidden = true; ui.go.textContent = "Load model (CPU)"; ui.go.disabled = false; };
-      return;
-    }
-    ui.backend.textContent = `backend: WebGPU${s.adapter ? " · " + s.adapter : ""}`;
-  }
-  ui.go.disabled = false;
-  ui.go.textContent = "Load model";
-  if (params.has("autoload") || PARITY || await hasCachedModel()) {   // second visit: load straight from cache
-    await load();
-    if (PARITY && agate) await parity();
-  }
-})();
-
-window.agateClearCache = clearCache;
+import { Agate, VERSIONS, webgpuStatus, clearCache, hasCachedModel } from "./agate.js";
+import { addPngText, readWatermark } from "./marking.js";
+import { prepare as preparePrompt, countVector } from "./prompt.js";
+import { ThinkerView } from "./thinker.js";
+
+// Model location: 001 from window.AGATE_MODEL_BASE (js/config.js, default ./models/), 002 / 003 from their model
+// repos (agate.js VERSIONS); ?models=<url> serves every version from one local-layout base instead.
+const params = new URLSearchParams(location.search);
+const BASE = window.AGATE_MODEL_BASE || "./models/";   // 001's files (002 / 003 come from their model repos)
+const MODELS_OVERRIDE = params.get("models");           // every version from <url>/{,002/,003/} (local testing)
+const FORCE_EP = params.get("ep");            // "wasm" forces the CPU path
+const PARITY = params.has("parity");
+const GOLDEN = params.has("golden");        // prompt-pipeline golden test (003)
+const VARIANT = params.get("variant");      // "full16": experimental fp16-compute generator (001)
+
+const store = {
+  get(k) { try { return localStorage.getItem(k); } catch { return null; } },
+  set(k, v) { try { localStorage.setItem(k, v); } catch { /* storage blocked */ } },
+};
+const DEFAULT_VERSION = "003";
+let version = [params.get("v"), store.get("agate-version"), DEFAULT_VERSION].find((v) => v && VERSIONS[v]);
+let resolution = Number(params.get("res") || store.get("agate-res-003") || 512);
+if (!VERSIONS["003"].res.includes(resolution)) resolution = 512;
+
+const EXAMPLES = {
+  common: [
+    "a green teapot and a red cup on a table",
+    "a minimalist logo of a fox head, orange, flat design, white background",
+    "a dog sitting to the left of a cat",
+    "a red cube on top of a blue sphere",
+  ],
+  "003": [
+    'a shop sign that says "OPEN", three red apples, no people',
+    "a portrait of an old fisherman at golden hour, detailed",
+    'a coffee cup with the text "Good Morning" on it',
+  ],
+};
+
+const $ = (id) => document.getElementById(id);
+const ui = {
+  prompt: $("prompt"), negative: $("negative"), seed: $("seed"), steps: $("steps"), cfg: $("cfg"), go: $("go"), dice: $("dice"),
+  fill: $("bar-fill"), status: $("status"), statusR: $("status-r"), canvas: $("canvas"), frame: $("frame"),
+  placeholder: $("placeholder"), timings: $("timings"), save: $("save"), crisp: $("crisp"), backend: $("backend"),
+  versions: $("versions"), res: $("res"), resRow: $("res-row"), prepared: $("prepared"), aiNote: $("ai-note"),
+  showThinker: $("show-thinker"), thinker: $("thinker"), thinkerStep: $("thinker-step"),
+};
+const thinkerView = new ThinkerView($("plan-canvas"), $("pred-canvas"));
+ui.showThinker.checked = store.get("agate-thinker") !== "0";
+ui.showThinker.onchange = () => { store.set("agate-thinker", ui.showThinker.checked ? "1" : "0"); if (!ui.showThinker.checked) ui.thinker.hidden = true; };
+
+let agate = null, ep = FORCE_EP || "webgpu", busy = false, stop = false, gpuOk = true, last = null;
+window.__agate = { state: "idle", version };           // read by the automated browser test
+
+const res = () => (version === "003" ? resolution : 256);
+
+function renderExamples() {
+  const box = $("examples");
+  box.querySelectorAll(".chip").forEach((c) => c.remove());
+  for (const p of [...(EXAMPLES[version] || []), ...EXAMPLES.common].slice(0, 6)) {
+    const b = document.createElement("button");
+    b.className = "chip"; b.textContent = p; b.type = "button";
+    b.onclick = () => { ui.prompt.value = p; };
+    box.appendChild(b);
+  }
+}
+
+function seg(el, items, current, onPick) {
+  el.innerHTML = "";
+  for (const it of items) {
+    const b = document.createElement("button");
+    b.type = "button"; b.setAttribute("role", "radio"); b.setAttribute("aria-checked", String(it.value === current));
+    b.dataset.value = it.value;
+    b.innerHTML = `${it.label}${it.sub ? `<small>${it.sub}</small>` : ""}`;
+    b.onclick = () => { if (!busy && it.value !== current) onPick(it.value); };
+    el.appendChild(b);
+  }
+}
+
+function renderVersion() {
+  const spec = VERSIONS[version];
+  seg(ui.versions, Object.keys(VERSIONS).map((v) => ({ value: v, label: `Preview ${v}`, sub: `${Math.max(...VERSIONS[v].res)} px${v === DEFAULT_VERSION ? " · newest" : ""}` })),
+    version, pickVersion);
+  $("ver-note").textContent = spec.note;
+  $("mast-version").textContent = `Preview ${version}`;
+  $("mast-spec").textContent = `0.26B · text-to-image · ${spec.res.join(" / ")} px`;
+  $("ai-model").textContent = `Agate Preview ${version}`;
+  $("neg-hint").textContent = version === "003" ? "(optional; “no X” in the prompt is added automatically)" : "(optional negative prompt)";
+  ui.resRow.hidden = spec.res.length < 2;
+  if (spec.res.length > 1) seg(ui.res, spec.res.map((r) => ({ value: r, label: `${r} × ${r}`, sub: r === 512 ? "native" : "faster" })), resolution, pickRes);
+  $("out-label").textContent = `Output · ${res()} × ${res()}`;
+  renderExamples();
+  document.title = `Agate Preview ${version} — in your browser`;
+}
+
+async function pickVersion(v) {
+  version = v; store.set("agate-version", v);
+  window.__agate.version = v;
+  if (agate) { await agate.release(); agate = null; }
+  clearOutput();
+  renderVersion();
+  if (!gpuOk && !FORCE_EP) return;
+  ui.go.textContent = "Load model"; ui.go.disabled = false;
+  setProgress(0, "Idle", "");
+  if (await hasCachedModel(v)) await load();
+}
+
+async function pickRes(r) {
+  resolution = r; store.set("agate-res-003", String(r));
+  renderVersion();
+  if (agate?.sessions && agate.mr) {
+    busy = true; ui.go.disabled = true;
+    setProgress(1, `Preparing the ${r} px generator`, "");
+    try { const ms = await agate.setResolution(r); setProgress(0, "Ready", `${r} px · ${(ms / 1000).toFixed(1)} s`); }
+    catch (e) { console.error(e); setProgress(0, "Switch failed", String(e.message || e)); }
+    busy = false; ui.go.disabled = false;
+  }
+}
+
+ui.steps.oninput = () => { $("steps-v").textContent = ui.steps.value; };
+ui.cfg.oninput = () => { $("cfg-v").textContent = Number(ui.cfg.value).toFixed(1); };
+ui.dice.onclick = () => { ui.seed.value = Math.floor(Math.random() * 2 ** 31); };
+ui.crisp.checked = store.get("agate-crisp") === "1";
+const applyCrisp = () => { ui.frame.classList.toggle("crisp", ui.crisp.checked); store.set("agate-crisp", ui.crisp.checked ? "1" : "0"); };
+ui.crisp.onchange = applyCrisp; applyCrisp();
+
+const mb = (b) => (b / 1e6).toFixed(0);
+function setProgress(frac, left, right = "") {
+  ui.fill.style.width = `${Math.max(0, Math.min(1, frac)) * 100}%`;
+  ui.status.textContent = left; ui.statusR.textContent = right;
+}
+function showTimings(rows) {
+  ui.timings.innerHTML = rows.map(([k, v]) => `<dt>${k}</dt><dd>${v}</dd>`).join("");
+}
+function clearOutput() {
+  ui.placeholder.hidden = false; ui.aiNote.hidden = true; ui.thinker.hidden = true; ui.save.hidden = true; ui.prepared.hidden = true;
+  showTimings([]); last = null;
+  if (ui.save.href?.startsWith("blob:")) URL.revokeObjectURL(ui.save.href);
+}
+
+async function load() {
+  busy = true; ui.go.disabled = true;
+  window.__agate.state = "loading";
+  agate = new Agate({ base: BASE, override: MODELS_OVERRIDE, version, ep, variant: VARIANT, optLevel: params.get("opt") || "all" });
+  try {
+    const t0 = performance.now();
+    const st = await agate.load(({ phase, file, loaded, total }) => {
+      if (phase === "download") setProgress(loaded / total, `Downloading ${file}`, `${mb(loaded)} / ${mb(total)} MB`);
+      else setProgress(1, `Preparing ${file} on ${ep === "webgpu" ? "WebGPU" : "CPU"}`, `${mb(total)} MB`);
+    }, res());
+    const loadMs = performance.now() - t0;
+    $("dl-size").textContent = `${st.downloadMB.toFixed(0)} MB`;
+    ui.backend.textContent = `backend: ${ep === "webgpu" ? "WebGPU" : "WebAssembly (CPU)"}`;
+    const src = st.fromCacheMB > st.downloadMB * 0.99 ? "from browser cache" : "downloaded";
+    setProgress(0, "Ready", `Preview ${version} · ${st.downloadMB.toFixed(0)} MB ${src} · ${(loadMs / 1000).toFixed(1)} s`);
+    window.__agate = { state: "ready", version, load: { ...st, loadMs, ep } };
+    ui.go.textContent = "Generate"; ui.go.disabled = false;
+  } catch (e) {
+    console.error(e);
+    setProgress(0, "Load failed", String(e.message || e));
+    window.__agate = { state: "error", version, error: String(e.message || e) };
+    ui.go.textContent = "Retry load"; ui.go.disabled = false; agate = null;
+  }
+  busy = false;
+}
+
+async function pngWithMetadata() {
+  const blob = await new Promise((r) => ui.canvas.toBlob(r, "image/png"));
+  const bytes = addPngText(new Uint8Array(await blob.arrayBuffer()), agate.marks.info);
+  return new Blob([bytes], { type: "image/png" });
+}
+
+function previewFn() {
+  thinkerView.reset();
+  let planMs = 0, n = 0;
+  window.__agate.thinker = { steps: 0, planMs: 0 };
+  return ({ step, steps, plan, x1, hw }) => {
+    const t0 = performance.now();
+    ui.thinker.hidden = false;
+    thinkerView.drawPlan(plan);
+    thinkerView.drawPrediction(x1, hw);
+    ui.thinkerStep.textContent = `${step} / ${steps}`;
+    planMs += performance.now() - t0; n++;
+    window.__agate.thinker = { steps: n, drawMsMean: planMs / n };
+  };
+}
+
+async function generate(opts = {}) {
+  busy = true; stop = false;
+  ui.go.textContent = "Stop"; ui.frame.classList.add("busy");
+  window.__agate.state = "generating";
+  const steps = opts.steps ?? Number(ui.steps.value);
+  try {
+    setProgress(0, "Encoding prompt", "");
+    const r = await agate.generate({
+      prompt: opts.prompt ?? ui.prompt.value.trim(), negative: opts.negative ?? ui.negative.value.trim(),
+      seed: Number(ui.seed.value) >>> 0, steps, cfg: opts.cfg ?? Number(ui.cfg.value), noise: opts.noise ?? null,
+      watermark: opts.watermark ?? true,
+      onStep: (i, n) => setProgress(i / n, `Step ${i} / ${n}`, ""),
+      onPreview: (opts.thinker ?? ui.showThinker.checked) ? previewFn() : null,
+      shouldStop: () => stop,
+    });
+    const ctx = ui.canvas.getContext("2d");
+    ui.canvas.width = r.width; ui.canvas.height = r.height;
+    ctx.putImageData(new ImageData(r.rgba, r.width, r.height), 0, 0);
+    ui.placeholder.hidden = true;
+    ui.aiNote.hidden = false;
+    const T = r.timings;
+    setProgress(1, "Done", `${(T.totalMs / 1000).toFixed(1)} s`);
+    showTimings([
+      ["text encode", `${T.textMs.toFixed(0)} ms (bucket ${T.bucket})`],
+      ["per step", `${T.stepMs.toFixed(0)} ms × ${steps} (first ${T.firstStepMs.toFixed(0)} ms)`],
+      ["decode + mark", `${T.decodeMs.toFixed(0)} + ${T.markMs.toFixed(0)} ms`],
+      ["total", `${(T.totalMs / 1000).toFixed(2)} s`],
+    ]);
+    const p = r.prepared;
+    const changed = agate.mr && (p.text !== (opts.prompt ?? ui.prompt.value.trim()) || p.negative || p.countsNonzero);
+    ui.prepared.hidden = !changed;
+    if (changed) ui.prepared.textContent = `Model sees: ${p.text}${p.negative ? ` · avoid: ${p.negative}` : ""}${p.countsNonzero ? ` · count code on ${p.countsNonzero} token(s)` : ""}`;
+    if (ui.save.href?.startsWith("blob:")) URL.revokeObjectURL(ui.save.href);
+    ui.save.href = URL.createObjectURL(await pngWithMetadata());
+    ui.save.download = `agate-${version}-${r.width}px-seed${Number(ui.seed.value) >>> 0}.png`;
+    ui.save.hidden = false;
+    last = r;
+    window.__agate = { ...window.__agate, state: "done", timings: T, prepared: p, size: [r.width, r.height], watermarked: r.watermarked,
+      thinkerShown: !ui.thinker.hidden };
+    return r;
+  } catch (e) {
+    if (String(e.message) === "stopped") setProgress(0, "Stopped", "");
+    else { console.error(e); setProgress(0, "Error", String(e.message || e)); window.__agate.error = String(e.message || e); }
+    window.__agate.state = "done";
+  } finally {
+    busy = false; ui.go.textContent = "Generate"; ui.frame.classList.remove("busy");
+  }
+}
+
+ui.go.onclick = async () => {
+  if (busy && agate?.sessions) { stop = true; return; }
+  if (busy) return;
+  if (!agate) return load();
+  return generate();
+};
+ui.prompt.addEventListener("keydown", (e) => { if (e.key === "Enter" && (e.ctrlKey || e.metaKey) && agate && !busy) generate(); });
+
+// Parity self-test: ?parity=1 runs the chosen version's fixture (export/parity_full*.py): same initial noise as the
+// PyTorch package, watermark off (the fixture holds unmarked pixels); then checks the mark on the marked image.
+async function parity() {
+  const dir = version === "001" ? "test/" : version === "002" ? "test/002/" : `test/003_${res()}/`;
+  const fx = await (await fetch(`${dir}parity.json`)).json();
+  const bin = async (f) => new Uint8Array(await (await fetch(`${dir}${f}`)).arrayBuffer());
+  const noise = new Float32Array((await bin("parity_noise.bin")).buffer);
+  const refZ = new Float32Array((await bin("parity_latent.bin")).buffer);
+  const refImg = await bin("parity_image.bin");     // HWC uint8
+  ui.prompt.value = fx.prompt; ui.steps.value = fx.steps; ui.cfg.value = fx.cfg; ui.negative.value = "";
+  const r = await generate({ prompt: fx.prompt, negative: "", steps: fx.steps, cfg: fx.cfg, noise, watermark: false });
+  let dz = 0, dzs = 0, di = 0, dis = 0, se = 0;
+  for (let k = 0; k < refZ.length; k++) { const d = Math.abs(r.latent[k] - refZ[k]); dz = Math.max(dz, d); dzs += d; }
+  for (let p = 0; p < refImg.length / 3; p++) for (let c = 0; c < 3; c++) {
+    const d = Math.abs(r.rgba[p * 4 + c] - refImg[p * 3 + c]); di = Math.max(di, d); dis += d; se += d * d;
+  }
+  const psnr = 10 * Math.log10(255 * 255 / Math.max(1e-9, se / refImg.length));
+  const prepOk = fx.prepared === undefined || (r.prepared.text === fx.prepared && r.prepared.negative === fx.negative);
+  // the same image marked, read back in the page
+  const { embedWatermark } = await import("./marking.js");
+  const marked = Uint8ClampedArray.from(r.rgba);
+  embedWatermark(marked, r.width, r.height, agate.marks.payload);
+  const rb = readWatermark(marked, r.width, r.height, agate.marks.payload);
+  const res_ = { version, resolution: res(), latentMaxAbs: dz, latentMeanAbs: dzs / refZ.length, imageMaxAbs: di, imageMeanAbs: dis / refImg.length,
+    psnr, preparedMatchesPython: prepOk, watermarkReadback: rb.text, watermarkBitAcc: rb.bitAccuracy, ep, timings: r.timings };
+  const el = $("parity"); el.hidden = false;
+  el.innerHTML = `<span class="label"><i class="sq red"></i>Parity vs PyTorch package · Preview ${version} · ${res()} px (${ep})</span>
+    <p>final latent max |Δ| ${dz.toFixed(4)} (mean ${res_.latentMeanAbs.toFixed(5)}) · image max |Δ| ${di}/255 (mean ${res_.imageMeanAbs.toFixed(3)}, PSNR ${psnr.toFixed(1)} dB)
+    · prompt pipeline ${prepOk ? "identical" : "DIFFERENT"} · watermark read back: ${rb.text} (${(rb.bitAccuracy * 100).toFixed(0)}% bits)</p>`;
+  window.__agate = { ...window.__agate, parity: res_, state: "parity-done" };
+}
+
+// Golden test of the prompt pipeline in this browser (tokenizers.js + prompt.js) against the Python package.
+async function golden() {
+  const G = await (await fetch("test/prompt_golden.json")).json();
+  const tok = agate.tok, fails = [];
+  const enc = (s) => agate.tokenize(s).map(Number);
+  for (const c of G.cases) {
+    const [text, neg] = preparePrompt(c.prompt);
+    const ids = enc(text);
+    const cv = countVector(tok, text, ids, ids.length), counts = {};
+    cv.forEach((v, j) => { if (v) counts[String(j)] = v; });
+    const ok = text === c.prepared && neg === c.negative && JSON.stringify(ids) === JSON.stringify(c.ids)
+      && JSON.stringify(enc(neg)) === JSON.stringify(c.neg_ids) && JSON.stringify(counts) === JSON.stringify(c.counts);
+    if (!ok) fails.push(c.prompt);
+  }
+  const res_ = { cases: G.cases.length, identical: G.cases.length - fails.length, fails };
+  const el = $("parity"); el.hidden = false;
+  el.innerHTML += `<span class="label"><i class="sq red"></i>Prompt pipeline golden test</span><p>${res_.identical} / ${res_.cases} prompts identical to the Python package (prompt, negative, token ids, count code)</p>`;
+  window.__agate = { ...window.__agate, golden: res_ };
+}
+
+// For the automated test: the PNG exactly as "Save PNG" gives it, base64
+window.__agateSavedPng = async () => {
+  const b = new Uint8Array(await (await pngWithMetadata()).arrayBuffer());
+  let s = ""; for (let i = 0; i < b.length; i += 0x8000) s += String.fromCharCode(...b.subarray(i, i + 0x8000));
+  return btoa(s);
+};
+window.agateClearCache = clearCache;
+
+(async () => {
+  renderVersion();
+  if (!FORCE_EP) {
+    const s = await webgpuStatus();
+    if (!s.ok) {
+      gpuOk = false; ep = "wasm";
+      $("nogpu").hidden = false; $("nogpu-why").textContent = s.why;
+      ui.go.disabled = true; ui.go.textContent = "WebGPU required";
+      window.__agate = { state: "no-webgpu", why: s.why, version };
+      $("use-wasm").onclick = () => { $("nogpu").hidden = true; gpuOk = true; ui.go.textContent = "Load model (CPU)"; ui.go.disabled = false; };
+      return;
+    }
+    ui.backend.textContent = `backend: WebGPU${s.adapter ? " · " + s.adapter : ""}`;
+  }
+  ui.go.disabled = false;
+  ui.go.textContent = "Load model";
+  if (params.has("autoload") || PARITY || GOLDEN || await hasCachedModel(version)) {   // second visit: load straight from cache
+    await load();
+    if (GOLDEN && agate && version === "003") await golden();
+    if (PARITY && agate) await parity();
+    if (GOLDEN && !PARITY) window.__agate.state = "golden-done";
+  }
+})();

js/marking.js

@@ -0,0 +1,186 @@
+// AI-generated content marking for the images this page makes (EU AI Act Art. 50(2)), the same marks as the
+// Python packages (agate/marking.py of Logolabs/agate-preview-002 / -003):
+//  * an invisible watermark in the pixels: invisible-watermark's (MIT) 'dwtDctSvd' method, fixed 64-bit payload
+//    "AGATE" + release ("AGATE001" / "AGATE002" / "AGATE003"), ported from the library with its exact conventions
+//    (OpenCV 8-bit YUV, U channel only, Haar LL band, 4x4 DCT + SVD, s0 quantised to 36, the library's swapped
+//    detail order in the inverse DWT, numpy's truncating uint8 cast). agate.detect_watermark() in Python reads it.
+//  * provenance text chunks (tEXt) in the downloaded PNG: ai_generated, generator, model, watermark -- the keys
+//    and values the Python packages write. The prompt is NOT written.
+// Neither mark is tamper-proof; see the model cards.
+
+export const METHOD = "dwtDctSvd";
+const SCALE = 36, BLOCK = 4;
+const S2 = 0.7071067811865476;                      // PyWavelets' Haar tap, 1/sqrt(2)
+
+export function marks(release) {
+  const payload = "AGATE" + release;               // 8 ASCII bytes = 64 bits
+  return {
+    payload,
+    info: {
+      ai_generated: "true",
+      generator: `Agate Preview ${release} (LogoLabs)`,
+      model: `Logolabs/agate-preview-${release}`,
+      watermark: `invisible-watermark ${METHOD}, payload ${payload}`,
+    },
+  };
+}
+
+const desc = (x) => (x + 8192) >> 14;               // OpenCV CV_DESCALE(x, 14)
+const sat = (x) => (x < 0 ? 0 : x > 255 ? 255 : x);
+const u8unsafe = (x) => { const t = Math.trunc(x) % 256; return t < 0 ? t + 256 : t; };   // numpy float -> uint8
+
+// orthonormal 4-point DCT-II matrix (cv2.dct on a 4x4 block = C X C^T)
+const C = [];
+for (let k = 0; k < BLOCK; k++) {
+  C.push([]);
+  for (let n = 0; n < BLOCK; n++) C[k].push(Math.sqrt(k === 0 ? 1 / BLOCK : 2 / BLOCK) * Math.cos(Math.PI * (2 * n + 1) * k / (2 * BLOCK)));
+}
+function mul(A, B) { const R = [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]; for (let i = 0; i < 4; i++) for (let j = 0; j < 4; j++) { let s = 0; for (let k = 0; k < 4; k++) s += A[i][k] * B[k][j]; R[i][j] = s; } return R; }
+const T = (A) => A[0].map((_, j) => A.map((r) => r[j]));
+const CT = T(C);
+
+// largest singular value of a 4x4 matrix and its singular vectors (Jacobi on D^T D)
+function topSVD(D) {
+  const M = mul(T(D), D);
+  const V = [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]];
+  for (let sweep = 0; sweep < 30; sweep++) {
+    let off = 0;
+    for (let p = 0; p < 4; p++) for (let q = p + 1; q < 4; q++) off += M[p][q] * M[p][q];
+    if (off < 1e-30) break;
+    for (let p = 0; p < 4; p++) for (let q = p + 1; q < 4; q++) {
+      if (Math.abs(M[p][q]) < 1e-300) continue;
+      const th = (M[q][q] - M[p][p]) / (2 * M[p][q]);
+      const t = Math.sign(th || 1) / (Math.abs(th) + Math.sqrt(th * th + 1));
+      const c = 1 / Math.sqrt(t * t + 1), s = t * c;
+      for (let k = 0; k < 4; k++) { const a = M[k][p], b = M[k][q]; M[k][p] = c * a - s * b; M[k][q] = s * a + c * b; }
+      for (let k = 0; k < 4; k++) { const a = M[p][k], b = M[q][k]; M[p][k] = c * a - s * b; M[q][k] = s * a + c * b; }
+      for (let k = 0; k < 4; k++) { const a = V[k][p], b = V[k][q]; V[k][p] = c * a - s * b; V[k][q] = s * a + c * b; }
+    }
+  }
+  let best = 0;
+  for (let i = 1; i < 4; i++) if (M[i][i] > M[best][best]) best = i;
+  const s0 = Math.sqrt(Math.max(0, M[best][best]));
+  let v = V.map((r) => r[best]), u;
+  if (s0 < 1e-12) { u = [1, 0, 0, 0]; v = [1, 0, 0, 0]; }
+  else u = D.map((r) => (r[0] * v[0] + r[1] * v[1] + r[2] * v[2] + r[3] * v[3]) / s0);
+  return { s0, u, v };
+}
+
+function payloadBits(payload) {
+  const bytes = new TextEncoder().encode(payload), bits = [];
+  for (const b of bytes) for (let k = 7; k >= 0; k--) bits.push((b >> k) & 1);
+  return bits;
+}
+
+// U channel (OpenCV BGR2YUV, 8 bit) of an RGBA buffer -> Int32Array(W*H), plus Y and V for the inverse
+function toYUV(rgba, W, H) {
+  const Y = new Int32Array(W * H), U = new Int32Array(W * H), V = new Int32Array(W * H);
+  for (let p = 0; p < W * H; p++) {
+    const r = rgba[4 * p], g = rgba[4 * p + 1], b = rgba[4 * p + 2];
+    const y = desc(b * 1868 + g * 9617 + r * 4899);
+    Y[p] = y; U[p] = sat(desc((b - y) * 8061 + (128 << 14))); V[p] = sat(desc((r - y) * 14369 + (128 << 14)));
+  }
+  return { Y, U, V };
+}
+
+// LL band of the Haar DWT of U over the (H//4*4, W//4*4) region; -> {ca, ch, cv, cd} as Float64Array (h2 x w2)
+function haar(U, W, R, Cc) {
+  const h2 = R / 2, w2 = Cc / 2, n = h2 * w2;
+  const ca = new Float64Array(n), ch = new Float64Array(n), cv = new Float64Array(n), cd = new Float64Array(n);
+  for (let i = 0; i < h2; i++) for (let j = 0; j < w2; j++) {
+    const a = U[(2 * i) * W + 2 * j], b = U[(2 * i) * W + 2 * j + 1], c = U[(2 * i + 1) * W + 2 * j], d = U[(2 * i + 1) * W + 2 * j + 1];
+    const k = i * w2 + j;
+    // PyWavelets' exact float order: pairs along rows first (a|c, b|d), then along columns
+    const l0 = a * S2 + c * S2, l1 = b * S2 + d * S2, h0 = a * S2 - c * S2, h1 = b * S2 - d * S2;
+    ca[k] = l0 * S2 + l1 * S2; cv[k] = l0 * S2 - l1 * S2; ch[k] = h0 * S2 + h1 * S2; cd[k] = h0 * S2 - h1 * S2;
+  }
+  return { ca, ch, cv, cd, h2, w2 };
+}
+
+function blockAt(ca, w2, bi, bj) { const B = []; for (let r = 0; r < 4; r++) { B.push([]); for (let c = 0; c < 4; c++) B[r].push(ca[(bi * 4 + r) * w2 + bj * 4 + c]); } return B; }
+
+// Embed `payload` in place into rgba (Uint8ClampedArray / Uint8Array, W*H*4). Needs W*H >= 256*256.
+export function embedWatermark(rgba, W, H, payload) {
+  if (W * H < 256 * 256) throw new Error("watermark: image too small (needs at least 256 x 256)");
+  const bits = payloadBits(payload);
+  const { Y, U, V } = toYUV(rgba, W, H);
+  const R = Math.floor(H / 4) * 4, Cc = Math.floor(W / 4) * 4;
+  const { ca, ch, cv, cd, h2, w2 } = haar(U, W, R, Cc);
+  const nbi = Math.floor(h2 / 4), nbj = Math.floor(w2 / 4);
+  let num = 0;
+  for (let bi = 0; bi < nbi; bi++) for (let bj = 0; bj < nbj; bj++, num++) {
+    const D = mul(mul(C, blockAt(ca, w2, bi, bj)), CT);
+    const { s0, u, v } = topSVD(D);
+    const s1 = (Math.floor(s0 / SCALE) + 0.25 + 0.5 * bits[num % bits.length]) * SCALE;
+    const Dn = D.map((row, i) => row.map((x, j) => x + (s1 - s0) * u[i] * v[j]));
+    const Bn = mul(mul(CT, Dn), C);
+    for (let r = 0; r < 4; r++) for (let c = 0; c < 4; c++) ca[(bi * 4 + r) * w2 + bj * 4 + c] = Bn[r][c];
+  }
+  // inverse Haar with the library's swapped details (cv as H, ch as V), truncating uint8 cast
+  for (let i = 0; i < h2; i++) for (let j = 0; j < w2; j++) {
+    // pywt.idwt2((ca, (cv, ch, cd))): the library's swapped details; PyWavelets' float order (columns, then rows)
+    const k = i * w2 + j, A = ca[k], hIn = cv[k], vIn = ch[k], d = cd[k];
+    const L0 = A * S2 + vIn * S2, L1 = A * S2 - vIn * S2, H0 = hIn * S2 + d * S2, H1 = hIn * S2 - d * S2;
+    U[(2 * i) * W + 2 * j] = u8unsafe(L0 * S2 + H0 * S2);
+    U[(2 * i) * W + 2 * j + 1] = u8unsafe(L1 * S2 + H1 * S2);
+    U[(2 * i + 1) * W + 2 * j] = u8unsafe(L0 * S2 - H0 * S2);
+    U[(2 * i + 1) * W + 2 * j + 1] = u8unsafe(L1 * S2 - H1 * S2);
+  }
+  for (let p = 0; p < W * H; p++) {                  // OpenCV YUV2BGR, 8 bit
+    const y = Y[p], uu = U[p] - 128, vq = V[p] - 128;
+    rgba[4 * p + 2] = sat(y + desc(uu * 33292));
+    rgba[4 * p + 1] = sat(y + desc(uu * -6472 + vq * -9519));
+    rgba[4 * p] = sat(y + desc(vq * 18678));
+  }
+  return rgba;
+}
+
+// -> {bits, text, bitAccuracy} against `payload` (a self-check; the reference detector is the Python one)
+export function readWatermark(rgba, W, H, payload) {
+  const want = payloadBits(payload), n = want.length;
+  const { U } = toYUV(rgba, W, H);
+  const R = Math.floor(H / 4) * 4, Cc = Math.floor(W / 4) * 4;
+  const { ca, h2, w2 } = haar(U, W, R, Cc);
+  const nbi = Math.floor(h2 / 4), nbj = Math.floor(w2 / 4);
+  const sum = new Float64Array(n), cnt = new Float64Array(n);
+  let num = 0;
+  for (let bi = 0; bi < nbi; bi++) for (let bj = 0; bj < nbj; bj++, num++) {
+    const { s0 } = topSVD(mul(mul(C, blockAt(ca, w2, bi, bj)), CT));
+    sum[num % n] += (s0 % SCALE) > SCALE * 0.5 ? 1 : 0; cnt[num % n] += 1;
+  }
+  const bits = Array.from(sum, (s, k) => (s / cnt[k]) * 255 > 127 ? 1 : 0);
+  let same = 0; bits.forEach((b, k) => { if (b === want[k]) same++; });
+  const bytes = []; for (let k = 0; k < n; k += 8) { let b = 0; for (let q = 0; q < 8; q++) b = (b << 1) | bits[k + q]; bytes.push(b); }
+  return { bits, text: String.fromCharCode(...bytes), bitAccuracy: same / n };
+}
+
+// ---- PNG tEXt chunks ---------------------------------------------------------------------------
+let CRC_TABLE = null;
+function crc32(bytes) {
+  if (!CRC_TABLE) { CRC_TABLE = new Uint32Array(256); for (let n = 0; n < 256; n++) { let c = n; for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1; CRC_TABLE[n] = c >>> 0; } }
+  let c = 0xffffffff;
+  for (const b of bytes) c = CRC_TABLE[(c ^ b) & 0xff] ^ (c >>> 8);
+  return (c ^ 0xffffffff) >>> 0;
+}
+
+// PNG bytes -> PNG bytes with one tEXt chunk per entry of `info` (Latin-1 keys/values), inserted before IEND.
+export function addPngText(png, info) {
+  const latin1 = (s) => Uint8Array.from(s, (ch) => { const c = ch.charCodeAt(0); return c < 256 ? c : 63; });
+  const chunks = [];
+  for (const [k, v] of Object.entries(info)) {
+    const data = new Uint8Array([...latin1(k), 0, ...latin1(String(v))]);
+    const typeData = new Uint8Array([116, 69, 88, 116, ...data]);          // "tEXt"
+    const out = new Uint8Array(12 + data.length), dv = new DataView(out.buffer);
+    dv.setUint32(0, data.length); out.set(typeData, 4); dv.setUint32(8 + data.length, crc32(typeData));
+    chunks.push(out);
+  }
+  // find IEND (the last chunk): 12 bytes from the end in every well-formed PNG
+  const iend = png.length - 12;
+  const extra = chunks.reduce((s, c) => s + c.length, 0);
+  const res = new Uint8Array(png.length + extra);
+  res.set(png.subarray(0, iend), 0);
+  let o = iend;
+  for (const c of chunks) { res.set(c, o); o += c.length; }
+  res.set(png.subarray(iend), o);
+  return res;
+}

js/prompt.js

@@ -0,0 +1,249 @@
+// Agate Preview 003 prompt pipeline, a line-by-line port of agate/prompt_norm.py (+ AgatePipeline.prepare
+// and prompt_norm.count_tensor) of Logolabs/agate-preview-003. Checked against the Python package by
+// test/prompt_golden.json (tools: export/prompt_golden.py writes it, test/prompt_golden.mjs or ?golden=1 checks it).
+//
+// Python-compatibility notes (the reason for the helpers below):
+//  * Python's \s, \d, \b and str.isalnum/isspace are Unicode-aware; JS's are ASCII. PY_WS, \p{Nd} and the
+//    Unicode word-boundary WB mirror Python's definitions (\w = letters, numbers, underscore).
+//  * Python counts code points; JS strings count UTF-16 units. Lengths that gate behaviour use cpLen().
+//  * Token offsets come from the HF fast tokenizer in Python; here they are rebuilt from the byte-level BPE
+//    tokens (tokenOffsets), in UTF-16 units, which gives the same overlaps as Python's code-point offsets.
+
+const PY_WS = "\\t\\n\\x0b\\x0c\\r\\x1c-\\x20\\x85\\xa0\\u1680\\u2000-\\u200a\\u2028\\u2029\\u202f\\u205f\\u3000";
+const S = `[${PY_WS}]`;                         // Python's \s
+const NS = `[^${PY_WS}]`;                       // Python's \S
+const W = "[\\p{L}\\p{N}_]";                    // Python's \w (str patterns)
+const WB = `(?:(?<=${W})(?!${W})|(?<!${W})(?=${W}))`;   // Python's \b
+const D = "\\p{Nd}";                            // Python's \d
+const re = (src, flags = "") => new RegExp(src, flags.includes("u") ? flags : flags + "u");
+
+const NUM_LIST = "zero one two three four five six seven eight nine ten eleven twelve thirteen fourteen fifteen sixteen seventeen eighteen nineteen twenty".split(" ");
+const NUM_WORDS = new Map(NUM_LIST.map((w, i) => [w, i]));
+NUM_WORDS.set("dozen", 12);
+const WORD_OF = new Map(NUM_LIST.map((w, i) => [i, w]));
+const NOT_COUNT_NEXT = new Set(["pm", "am", "o'clock", "percent", "%", "years", "year", "hours", "hour", "minutes", "minute",
+  "seconds", "second", "times", "px", "cm", "mm", "m", "km", "kg", "g", "inch", "inches", "feet",
+  "degrees", "x", "d", "k", "th", "st", "nd", "rd", "of", "o"]);
+const ONE_PRONOUN_PREV = new Set(["the", "this", "that", "no", "each", "every", "any", "some", "which", "another", "someone",
+  "everyone", "anyone", "only"]);
+export const SPELL_SEP = " || spell: ";
+const SPELL_MAX_FRAC = 0.6, SPELL_MAX_CHARS = 40, SPELL_MAX_WORDS = 6, SPELL_MAX_SPANS = 3;
+
+const QUOTE_SRC = '"[^"]*"|“[^”]*”';
+const cpLen = (s) => { let n = 0; for (const _ of s) n++; return n; };     // len() in Python
+const isSpace = (ch) => re(`^${S}$`).test(ch);
+const pyStrip = (s, chars = null) => {
+  const f = chars === null ? isSpace : (c) => chars.includes(c);
+  let a = 0, b = s.length;
+  while (a < b && f(s[a])) a++;
+  while (b > a && f(s[b - 1])) b--;
+  return s.slice(a, b);
+};
+const pySplit = (s) => s.split(re(`${S}+`)).filter((x) => x.length > 0);   // str.split()
+const isAlnum = (ch) => /^[\p{L}\p{N}]$/u.test(ch);
+const isAlpha = (w) => w.length > 0 && /^\p{L}+$/u.test(w);
+const isUpper = (w) => w !== w.toLowerCase() && w === w.toUpperCase();     // ASCII words only reach these
+const isLower = (w) => w !== w.toUpperCase() && w === w.toLowerCase();
+const isDigits = (w) => /^\p{Nd}+$/u.test(w);
+
+function digitValue(cp) {              // value of one \p{Nd} code point: Nd code points come in runs of ten
+  let start = cp;
+  while (/\p{Nd}/u.test(String.fromCodePoint(start - 1))) start--;
+  return (cp - start) % 10;
+}
+function pyInt(w) {                    // int() of a \p{Nd}+ string
+  let n = 0;
+  for (const ch of w) n = n * 10 + digitValue(ch.codePointAt(0));
+  return n;
+}
+
+function outsideQuotes(text) {
+  const spans = [];
+  let last = 0;
+  for (const m of text.matchAll(re(QUOTE_SRC, "g"))) { spans.push([last, m.index]); last = m.index + m[0].length; }
+  spans.push([last, text.length]);
+  return spans.filter(([a, b]) => b > a);
+}
+
+function mapOutside(text, fn) {
+  let out = "", last = 0;
+  for (const [a, b] of outsideQuotes(text)) { out += text.slice(last, a) + fn(text.slice(a, b)); last = b; }
+  return out + text.slice(last);
+}
+
+function fixCase(words) {
+  const long2 = words.filter((w) => cpLen(w) >= 2 && isAlpha(w));
+  if (long2.length && long2.filter(isUpper).length / long2.length >= 0.6) return "shout";
+  const long3 = words.filter((w) => cpLen(w) >= 3 && isAlpha(w));
+  if (long3.length >= 3) {
+    const t = long3.filter((w) => { const c = [...w]; return isUpper(c[0]) && isLower(c.slice(1).join("")); }).length;
+    if (t / long3.length >= 0.7) return "title";
+  }
+  return null;
+}
+
+export function isJsonCaption(text) {
+  const s = pyStrip(text.split(SPELL_SEP)[0]);
+  if (!(s.startsWith("{") && s.endsWith("}"))) return false;
+  try { const v = JSON.parse(s); return v !== null && typeof v === "object" && !Array.isArray(v); } catch { return false; }
+}
+
+function isCountContext(seg, end) {
+  const nxt = re(`^${S}*([A-Za-z%']+)`).exec(seg.slice(end));
+  return !!nxt && !NOT_COUNT_NEXT.has(nxt[1].toLowerCase());
+}
+
+function canonNumbers(seg) {
+  return seg.replace(re(`${WB}[A-Za-z]+${WB}|${WB}${D}+${WB}`, "g"), (w, off) => {
+    const lw = w.toLowerCase();
+    if (NUM_WORDS.has(lw)) return lw;
+    if (isDigits(w)) { const n = pyInt(w); if (n >= 1 && n <= 20 && isCountContext(seg, off + w.length)) return WORD_OF.get(n); }
+    return w;
+  });
+}
+
+export function normalize(text) {
+  if (isJsonCaption(text)) return text;
+  text = pyStrip(text.replace(re(`${S}+`, "g"), " "));
+  const words = [];
+  for (const [a, b] of outsideQuotes(text)) for (const m of text.slice(a, b).matchAll(re(`[A-Za-z][A-Za-z'\\-]*|${D}+`, "g"))) words.push(m[0]);
+  const mode = fixCase(words);
+  if (mode === "shout") text = mapOutside(text, (s) => s.toLowerCase());
+  else if (mode === "title") {
+    const first = re(`^${S}*${NS}+`).exec(text);
+    const head = first ? first[0].length : 0;
+    text = text.slice(0, head) + mapOutside(text.slice(head), (s) => s.replace(re(`${WB}[A-Z][a-z]*${WB}`, "g"), (m) => m.toLowerCase()));
+  }
+  return mapOutside(text, canonNumbers);
+}
+
+export function findCounts(text) {
+  const out = [];
+  if (isJsonCaption(text)) return out;
+  text = text.split(SPELL_SEP)[0];
+  for (const [a, b] of outsideQuotes(text)) {
+    const seg = text.slice(a, b);
+    const pat = re(`${WB}(?:a${S}+)?(dozen|pair(?=${S}+of${WB}))${WB}|${WB}([A-Za-z]+|${D}+)${WB}`, "gd");
+    for (const m of seg.matchAll(pat)) {
+      if (m[1] !== undefined) {
+        const [s1, e1] = m.indices[1];
+        out.push([a + s1, a + e1, m[1].toLowerCase() === "dozen" ? 12 : 2]);
+        continue;
+      }
+      const w = m[2], lw = w.toLowerCase();
+      const [s2, e2] = m.indices[2];
+      let n;
+      if (isDigits(lw)) { n = pyInt(lw); if (!(n >= 1 && n <= 99)) continue; }
+      else if (NUM_WORDS.has(lw) && lw !== "zero" && lw !== "dozen") n = NUM_WORDS.get(lw);
+      else continue;
+      if (!isCountContext(seg, m.index + m[0].length)) continue;
+      const prev = seg.slice(0, m.index).match(/[A-Za-z]+/g) || [];
+      if (lw === "one" && prev.length && ONE_PRONOUN_PREV.has(prev[prev.length - 1].toLowerCase())) continue;
+      out.push([a + s2, a + e2, n]);
+    }
+  }
+  return out;
+}
+
+export function textSpans(text) {
+  const body = text.split(SPELL_SEP)[0];
+  const out = [];
+  for (const m of body.matchAll(re(QUOTE_SRC, "g"))) {
+    const c = pyStrip(m[0].slice(1, -1));
+    if (c && [...c].some(isAlnum) && cpLen(c) <= SPELL_MAX_FRAC * cpLen(body) && cpLen(c) <= SPELL_MAX_CHARS && pySplit(c).length <= SPELL_MAX_WORDS) out.push(c);
+  }
+  return out.slice(0, SPELL_MAX_SPANS);
+}
+
+export function spell(content) {
+  const words = pySplit(content).map((w) => [...w].filter((ch) => isAlnum(ch) || "&!?'-".includes(ch)));
+  return words.filter((w) => w.length).map((w) => w.join(" ")).join(" / ");
+}
+
+export function addSpelling(text) {
+  if (text.includes(SPELL_SEP) || isJsonCaption(text)) return text;
+  const spans = textSpans(text);
+  if (!spans.length) return text;
+  return text + SPELL_SEP + spans.map(spell).join(" ; ");
+}
+
+export function splitNegatives(text) {
+  const negs = [];
+  if (isJsonCaption(text)) return [text, negs];
+  const pat = re(`${S}*,?${S}*${WB}(?:with${S}+)?(?:without|no)${S}+(?:any${S}+)?(?:a${S}+|an${S}+|the${S}+)?([^,.;"“]+?)(?=${S}+and${S}+|[,.;]|$)`, "gi");
+  const cut = (seg) => seg.replace(pat, (...g) => { negs.push(pyStrip(g[1])); return ""; });
+  let pos = mapOutside(text, cut);
+  pos = pyStrip(pos.replace(re(`${S}+([,.;])`, "g"), "$1").replace(re(`${S}+`, "g"), " "), " ,;");
+  return [pos, negs];
+}
+
+// AgatePipeline.prepare: -> [prompt as the text encoder sees it, negative prompt]
+export function prepare(prompt, negativePrompt = "", normalizeOn = true, spellOn = true) {
+  let negs = [];
+  if (normalizeOn) [prompt, negs] = splitNegatives(normalize(prompt));
+  if (spellOn) prompt = addSpelling(prompt);
+  const negative = [pyStrip(negativePrompt), ...negs].filter((n) => n).join(", ");
+  return [prompt, negative];
+}
+
+// ---- token offsets for a byte-level BPE tokenizer (tokenizers.js has no offset mapping) -----------
+let BYTE_OF = null;                       // GPT-2 bytes_to_unicode, inverted: char -> byte
+function byteDecoder() {
+  if (BYTE_OF) return BYTE_OF;
+  const bs = [];
+  for (let b = 33; b <= 126; b++) bs.push(b);
+  for (let b = 161; b <= 172; b++) bs.push(b);
+  for (let b = 174; b <= 255; b++) bs.push(b);
+  const cs = bs.slice();
+  let n = 0;
+  for (let b = 0; b < 256; b++) if (!bs.includes(b)) { bs.push(b); cs.push(256 + n); n++; }
+  BYTE_OF = new Map(bs.map((b, i) => [String.fromCodePoint(cs[i]), b]));
+  return BYTE_OF;
+}
+
+// ids: the token ids of `text` ([CLS] ... [SEP]). -> [[start, end], ...] in UTF-16 units of text, [0, 0] for
+// special tokens: Python's offset_mapping (code points) mapped to JS string indices.
+export function tokenOffsets(tok, text, ids) {
+  const dec = byteDecoder();
+  const nfc = text.normalize("NFC");
+  const enc = new TextEncoder();
+  // byte index -> [UTF-16 start, UTF-16 end] of the character that byte belongs to
+  const charOfByte = [];
+  let u = 0;
+  for (const ch of nfc) { const nb = enc.encode(ch).length; for (let k = 0; k < nb; k++) charOfByte.push([u, u + ch.length]); u += ch.length; }
+  const added = tok.get_added_tokens_decoder?.() ?? new Map();
+  const out = [];
+  let pos = 0;
+  for (const id of ids) {
+    const at = added.get(Number(id));
+    let nbytes;
+    if (at && at.special) { out.push([0, 0]); continue; }
+    if (at) nbytes = enc.encode(at.content).length;
+    else {
+      const s = tok.id_to_token(Number(id));
+      nbytes = 0;
+      for (const ch of s) nbytes += dec.has(ch) ? 1 : enc.encode(ch).length;
+    }
+    if (nbytes === 0 || pos >= charOfByte.length) { out.push([0, 0]); continue; }
+    const a = charOfByte[pos][0], b = charOfByte[Math.min(pos + nbytes, charOfByte.length) - 1][1];
+    out.push([a, b]);
+    pos += nbytes;
+  }
+  // text that NFC changed: offsets refer to the NFC string; the count spans are found in the NFC string too
+  return out;
+}
+
+// prompt_norm.count_tensor for one prompt: Float32Array(length), the count value at the tokens that spell one.
+export function countVector(tok, text, ids, length) {
+  const out = new Float32Array(length);
+  const nfc = text.normalize("NFC");
+  const spans = findCounts(nfc);
+  if (!spans.length) return out;
+  const offs = tokenOffsets(tok, nfc, ids);
+  for (let j = 0; j < Math.min(length, offs.length); j++) {
+    const [a, b] = offs[j];
+    if (b <= a) continue;
+    for (const [s, e, n] of spans) if (a < e && b > s) out[j] = n;
+  }
+  return out;
+}

js/thinker.js

@@ -0,0 +1,116 @@
+// "Show thinker": the live previews of the ComfyUI nodes (agate-comfyui nodes.py, _progress, live_preview
+// "side_by_side"), computed the same way so the two frontends show the same thing:
+//  * the plan: the thinker's output for the conditional branch, 640 channels on a 16 x 16 grid. Its cells are
+//    projected on the top 3 principal components (fitted once, at the first step, centred over the cells; each
+//    component's sign fixed so its largest-magnitude loading is positive) and mapped to RGB with that step's 2% /
+//    98% quantiles -- a fixed basis, so a colour keeps its meaning while the plan evolves;
+//  * the image the model expects at the end, x1 = z + (1 - t) v (guided velocity), shown with ComfyUI's SD 1.5
+//    latent -> RGB factors (its "latent2rgb" preview).
+
+const RGB_FACTORS = [[0.3512, 0.2297, 0.3227], [0.3250, 0.4974, 0.2350], [-0.2829, 0.1762, 0.2721], [-0.2120, -0.2616, -0.7177]];
+
+// top-k eigenvectors of the (d x d) Gram matrix X^T X of centred X (n x d), as torch.linalg.eigh gives them (sign
+// aside), via the smaller (n x n) X X^T: block (subspace) iteration with a 12-vector block + Rayleigh-Ritz, which
+// separates near-equal eigenvalues that plain power iteration mixes; then v = X^T u / |X^T u|.
+function jacobiEig(A, m) {                     // symmetric m x m (Float64Array) -> {vals, vecs (column-major rows)}
+  const a = Float64Array.from(A), V = new Float64Array(m * m);
+  for (let i = 0; i < m; i++) V[i * m + i] = 1;
+  for (let sweep = 0; sweep < 60; sweep++) {
+    let off = 0;
+    for (let p = 0; p < m; p++) for (let q = p + 1; q < m; q++) off += a[p * m + q] ** 2;
+    if (off < 1e-24) break;
+    for (let p = 0; p < m; p++) for (let q = p + 1; q < m; q++) {
+      const apq = a[p * m + q];
+      if (Math.abs(apq) < 1e-300) continue;
+      const th = (a[q * m + q] - a[p * m + p]) / (2 * apq);
+      const t = Math.sign(th || 1) / (Math.abs(th) + Math.sqrt(th * th + 1)), c = 1 / Math.sqrt(t * t + 1), s = t * c;
+      for (let k = 0; k < m; k++) { const x = a[k * m + p], y = a[k * m + q]; a[k * m + p] = c * x - s * y; a[k * m + q] = s * x + c * y; }
+      for (let k = 0; k < m; k++) { const x = a[p * m + k], y = a[q * m + k]; a[p * m + k] = c * x - s * y; a[q * m + k] = s * x + c * y; }
+      for (let k = 0; k < m; k++) { const x = V[k * m + p], y = V[k * m + q]; V[k * m + p] = c * x - s * y; V[k * m + q] = s * x + c * y; }
+    }
+  }
+  return { vals: Array.from({ length: m }, (_, i) => a[i * m + i]), V };
+}
+
+function topComponents(X, n, d, k = 3, iters = 60, block = 12) {
+  const G = new Float64Array(n * n);
+  for (let i = 0; i < n; i++) for (let j = i; j < n; j++) {
+    let s = 0; const ri = i * d, rj = j * d;
+    for (let a = 0; a < d; a++) s += X[ri + a] * X[rj + a];
+    G[i * n + j] = G[j * n + i] = s;
+  }
+  const m = Math.min(block, n);
+  let Q = Array.from({ length: m }, (_, c) => Float64Array.from({ length: n }, (_, i) => Math.sin(1.7 * i + 0.9 * c + 1) + 0.01 * c));
+  const orth = (B) => {                        // modified Gram-Schmidt, in place
+    for (let c = 0; c < B.length; c++) {
+      for (let e = 0; e < c; e++) { let p = 0; for (let i = 0; i < n; i++) p += B[c][i] * B[e][i]; for (let i = 0; i < n; i++) B[c][i] -= p * B[e][i]; }
+      let nrm = 0; for (let i = 0; i < n; i++) nrm += B[c][i] ** 2; nrm = Math.sqrt(nrm) || 1;
+      for (let i = 0; i < n; i++) B[c][i] /= nrm;
+    }
+    return B;
+  };
+  const mul = (q) => { const w = new Float64Array(n); for (let i = 0; i < n; i++) { let s = 0; const gi = i * n; for (let j = 0; j < n; j++) s += G[gi + j] * q[j]; w[i] = s; } return w; };
+  orth(Q);
+  for (let it = 0; it < iters; it++) Q = orth(Q.map(mul));
+  const GQ = Q.map(mul), T = new Float64Array(m * m);           // Rayleigh-Ritz on the block
+  for (let a = 0; a < m; a++) for (let b = 0; b < m; b++) { let s = 0; for (let i = 0; i < n; i++) s += Q[a][i] * GQ[b][i]; T[a * m + b] = s; }
+  for (let a = 0; a < m; a++) for (let b = 0; b < a; b++) T[a * m + b] = T[b * m + a] = (T[a * m + b] + T[b * m + a]) / 2;
+  const { vals, V } = jacobiEig(T, m);
+  const order = vals.map((v, i) => [v, i]).sort((x, y) => y[0] - x[0]).slice(0, k).map((x) => x[1]);
+  return order.map((col) => {
+    const u = new Float64Array(n);
+    for (let a = 0; a < m; a++) { const w = V[a * m + col]; for (let i = 0; i < n; i++) u[i] += w * Q[a][i]; }
+    const v = new Float64Array(d);
+    for (let i = 0; i < n; i++) { const ui = u[i], ri = i * d; if (ui) for (let a = 0; a < d; a++) v[a] += ui * X[ri + a]; }
+    let nrm = 0; for (let a = 0; a < d; a++) nrm += v[a] * v[a]; nrm = Math.sqrt(nrm) || 1;
+    let piv = 0;
+    for (let a = 0; a < d; a++) { v[a] /= nrm; if (Math.abs(v[a]) > Math.abs(v[piv])) piv = a; }
+    if (v[piv] < 0) for (let a = 0; a < d; a++) v[a] = -v[a];
+    return v;
+  });
+}
+
+function quantile(sorted, q) {                 // torch.quantile, linear interpolation
+  const pos = (sorted.length - 1) * q, lo = Math.floor(pos), hi = Math.ceil(pos);
+  return sorted[lo] + (sorted[hi] - sorted[lo]) * (pos - lo);
+}
+
+export class ThinkerView {
+  constructor(planCanvas, predCanvas) { this.planCanvas = planCanvas; this.predCanvas = predCanvas; this.reset(); }
+
+  reset() { this.basis = null; this.lo = null; this.hi = null; }
+
+  // plan: Float32Array (C * g * g), channel-major (1, C, g, g)
+  drawPlan(plan, C = 640, g = 16) {
+    const n = g * g, X = new Float64Array(n * C);
+    for (let c = 0; c < C; c++) for (let p = 0; p < n; p++) X[p * C + c] = plan[c * n + p];
+    for (let c = 0; c < C; c++) { let m = 0; for (let p = 0; p < n; p++) m += X[p * C + c]; m /= n; for (let p = 0; p < n; p++) X[p * C + c] -= m; }
+    if (!this.basis) this.basis = topComponents(X, n, C);
+    const Y = this.basis.map((v) => { const y = new Float64Array(n); for (let p = 0; p < n; p++) { let s = 0; const r = p * C; for (let c = 0; c < C; c++) s += X[r + c] * v[c]; y[p] = s; } return y; });
+    if (!this.lo) {
+      this.lo = Y.map((y) => quantile(Float64Array.from(y).sort(), 0.02));
+      this.hi = Y.map((y) => quantile(Float64Array.from(y).sort(), 0.98));
+    }
+    const img = new ImageData(g, g);
+    for (let p = 0; p < n; p++) {
+      for (let k = 0; k < 3; k++) img.data[p * 4 + k] = Math.round(Math.min(1, Math.max(0, (Y[k][p] - this.lo[k]) / (this.hi[k] - this.lo[k] + 1e-8))) * 255);
+      img.data[p * 4 + 3] = 255;
+    }
+    const cv = this.planCanvas; cv.width = g; cv.height = g;
+    cv.getContext("2d").putImageData(img, 0, 0);
+  }
+
+  // x1: Float32Array (4 * hw * hw) in the model's (scaled SD-VAE) latent space
+  drawPrediction(x1, hw) {
+    const n = hw * hw, img = new ImageData(hw, hw);
+    for (let p = 0; p < n; p++) {
+      for (let k = 0; k < 3; k++) {
+        let s = 0; for (let c = 0; c < 4; c++) s += x1[c * n + p] * RGB_FACTORS[c][k];
+        img.data[p * 4 + k] = Math.floor(Math.min(1, Math.max(0, (s + 1) / 2)) * 255);
+      }
+      img.data[p * 4 + 3] = 255;
+    }
+    const cv = this.predCanvas; cv.width = hw; cv.height = hw;
+    cv.getContext("2d").putImageData(img, 0, 0);
+  }
+}

test/002/parity.json

@@ -0,0 +1,9 @@
+{
+  "prompt": "a green teapot and a red cup on a table",
+  "steps": 50,
+  "cfg": 3.0,
+  "seed": 0,
+  "source": "release AgatePipeline, CPU fp32, fast_vae (TAESD), torch.randn replaced by parity_noise.bin",
+  "onnx_cpu_latent_max_abs": 0.10324227809906006,
+  "onnx_cpu_image_max_abs": 14
+}

test/002/parity_image.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:91cbf77d3ba00b0a6517adc736296ebefbd5fd69070d76ddacfedff32d461b1b
+size 196608

test/002/parity_latent.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:de43bcd6e7416d9bcb997b22da8c19d5401a07c0fa651185ec6d49372dba5f89
+size 16384

test/002/parity_noise.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3deff7f51dd573fad149014c76a44c4b6f6251fbaaa9b8e78b794e805871773f
+size 16384

test/003_256/parity.json

@@ -0,0 +1,18 @@
+{
+  "prompt": "a shop sign that says \"OPEN\", three red apples, no people",
+  "prepared": "a shop sign that says \"OPEN\", three red apples || spell: O P E N",
+  "negative": "people",
+  "counts_nonzero": {
+    "9": 3.0
+  },
+  "resolution": 256,
+  "steps": 50,
+  "cfg": 3.0,
+  "seed": 0,
+  "shift": 1.0,
+  "source": "release AgatePipeline (003), CPU fp32, fast_vae (TAESD), watermark off, torch.randn replaced by parity_noise.bin",
+  "onnx_cpu_latent_max_abs": 0.1917351484298706,
+  "onnx_cpu_image_max_abs": 47,
+  "onnx_cpu_image_mean_abs": 0.21456400553385416,
+  "onnx_cpu_psnr_db": 48.9241802774759
+}

test/003_256/parity_image.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ded558a14b1d2af78f387ec7c8f807dfaa0b82bc298c6519f4976e4f1a406260
+size 196608

test/003_256/parity_latent.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3d68c5f46abf7b82ca9bcabd397a0765c52ae28c2e3443583c78ee115005d2bb
+size 16384

test/003_256/parity_noise.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3deff7f51dd573fad149014c76a44c4b6f6251fbaaa9b8e78b794e805871773f
+size 16384

test/003_512/parity.json

@@ -0,0 +1,18 @@
+{
+  "prompt": "a shop sign that says \"OPEN\", three red apples, no people",
+  "prepared": "a shop sign that says \"OPEN\", three red apples || spell: O P E N",
+  "negative": "people",
+  "counts_nonzero": {
+    "9": 3.0
+  },
+  "resolution": 512,
+  "steps": 50,
+  "cfg": 3.0,
+  "seed": 0,
+  "shift": 2.0,
+  "source": "release AgatePipeline (003), CPU fp32, fast_vae (TAESD), watermark off, torch.randn replaced by parity_noise.bin",
+  "onnx_cpu_latent_max_abs": 0.11000287532806396,
+  "onnx_cpu_image_max_abs": 28,
+  "onnx_cpu_image_mean_abs": 0.11280314127604167,
+  "onnx_cpu_psnr_db": 54.79136477697858
+}

test/003_512/parity_image.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fafe740a618a3a4343bfe8ddf9819f353f9064004b8dd06c9676bd70f05c1621
+size 786432

test/003_512/parity_latent.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9627da8e372d20fd5d2f60166d61eebc6ad104a29f17dd2d96aae6a0c917a204
+size 65536

test/003_512/parity_noise.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b60eb3b5b14ff459a5517d7921ec74e7f82a23caaf9d5894e5e4a3f16ee9fd40
+size 65536

test/prompt_golden.json

@@ -0,0 +1,1251 @@
+{
+ "source": "agate-preview-003/agate (prompt_norm.py, AgatePipeline.prepare)",
+ "cases": [
+  {
+   "prompt": "a red cube on top of a blue sphere",
+   "prepared": "a red cube on top of a blue sphere",
+   "negative": "",
+   "ids": [
+    50281,
+    66,
+    2502,
+    23636,
+    327,
+    1755,
+    273,
+    247,
+    4797,
+    15269,
+    50282
+   ],
+   "neg_ids": [
+    50281,
+    50282
+   ],
+   "counts": {},
+   "find_counts": []
+  },
+  {
+   "prompt": "a green teapot and a red cup on a table",
+   "prepared": "a green teapot and a red cup on a table",
+   "negative": "",
+   "ids": [
+    50281,
+    66,
+    4759,
+    716,
+    522,
+    302,
+    285,
+    247,
+    2502,
+    5500,
+    327,
+    247,
+    2829,
+    50282
+   ],
+   "neg_ids": [
+    50281,
+    50282
+   ],
+   "counts": {},
+   "find_counts": []
+  },
+  {
+   "prompt": "three cats sitting on a sofa",
+   "prepared": "three cats sitting on a sofa",
+   "negative": "",
+   "ids": [
+    50281,
+    13524,
+    16581,
+    7063,
+    327,
+    247,
+    30929,
+    50282
+   ],
+   "neg_ids": [
+    50281,
+    50282
+   ],
+   "counts": {
+    "1": 3.0
+   },
+   "find_counts": [
+    [
+     0,
+     5,
+     3
+    ]
+   ]
+  },
+  {
+   "prompt": "3 dogs and 2 birds in a park",
+   "prepared": "three dogs and two birds in a park",
+   "negative": "",
+   "ids": [
+    50281,
+    13524,
+    9097,
+    285,
+    767,
+    11260,
+    275,
+    247,
+    5603,
+    50282
+   ],
+   "neg_ids": [
+    50281,
+    50282
+   ],
+   "counts": {
+    "1": 3.0,
+    "4": 2.0
+   },
+   "find_counts": [
+    [
+     0,
+     5,
+     3
+    ],
+    [
+     15,
+     18,
+     2
+    ]
+   ]
+  },
+  {
+   "prompt": "A PHOTO OF THREE RED APPLES ON A WOODEN TABLE",
+   "prepared": "a photo of three red apples on a wooden table",
+   "negative": "",
+   "ids": [
+    50281,
+    66,
+    7512,
+    273,
+    1264,
+    2502,
+    28580,
+    327,
+    247,
+    14872,
+    2829,
+    50282
+   ],
+   "neg_ids": [
+    50281,
+    50282
+   ],
+   "counts": {
+    "4": 3.0
+   },
+   "find_counts": [
+    [
+     11,
+     16,
+     3
+    ]
+   ]
+  },
+  {
+   "prompt": "A Photo Of Two Cats Sleeping On A Bed",
+   "prepared": "A photo of two cats sleeping on a bed",
+   "negative": "",
+   "ids": [
+    50281,
+    34,
+    7512,
+    273,
+    767,
+    16581,
+    14343,
+    327,
+    247,
+    3722,
+    50282
+   ],
+   "neg_ids": [
+    50281,
+    50282
+   ],
+   "counts": {
+    "4": 2.0
+   },
+   "find_counts": [
+    [
+     11,
+     14,
+     2
+    ]
+   ]
+  },
+  {
+   "prompt": "Paris at night, the Eiffel Tower lit up",
+   "prepared": "Paris at night, the Eiffel Tower lit up",
+   "negative": "",
+   "ids": [
+    50281,
+    36062,
+    387,
+    2360,
+    13,
+    253,
+    444,
+    1648,
+    293,
+    20610,
+    6195,
+    598,
+    50282
+   ],
+   "neg_ids": [
+    50281,
+    50282
+   ],
+   "counts": {},
+   "find_counts": []
+  },
+  {
+   "prompt": "a shop sign that says \"OPEN\", three red apples, no people",
+   "prepared": "a shop sign that says \"OPEN\", three red apples || spell: O P E N",
+   "negative": "people",
+   "ids": [
+    50281,
+    66,
+    8979,
+    861,
+    326,
+    2296,
+    346,
+    28652,
+    995,
+    1264,
+    2502,
+    28580,
+    2785,
+    15368,
+    27,
+    473,
+    367,
+    444,
+    427,
+    50282
+   ],
+   "neg_ids": [
+    50281,
+    13174,
+    50282
+   ],
+   "counts": {
+    "9": 3.0
+   },
+   "find_counts": [
+    [
+     30,
+     35,
+     3
+    ]
+   ]
+  },
+  {
+   "prompt": "a coffee cup with the text \"Good Morning\" on it",
+   "prepared": "a coffee cup with the text \"Good Morning\" on it || spell: G o o d / M o r n i n g",
+   "negative": "",
+   "ids": [
+    50281,
+    66,
+    8574,
+    5500,
+    342,
+    253,
+    2505,
+    346,
+    8620,
+    25565,
+    3,
+    327,
+    352,
+    2785,
+    15368,
+    27,
+    443,
+    258,
+    258,
+    277,
+    1227,
+    353,
+    258,
+    391,
+    295,
+    891,
+    295,
+    305,
+    50282
+   ],
+   "neg_ids": [
+    50281,
+    50282
+   ],
+   "counts": {},
+   "find_counts": []
+  },
+  {
+   "prompt": "a poster reading \"SALE 50% OFF\" in bold letters",
+   "prepared": "a poster reading \"SALE 50% OFF\" in bold letters || spell: S A L E / 5 0 / O F F",
+   "negative": "",
+   "ids": [
+    50281,
+    66,
+    20731,
+    4361,
+    346,
+    52,
+    23502,
+    2456,
+    6,
+    21890,
+    3,
+    275,
+    13433,
+    4876,
+    2785,
+    15368,
+    27,
+    322,
+    329,
+    418,
+    444,
+    1227,
+    608,
+    470,
+    1227,
+    473,
+    401,
+    401,
+    50282
+   ],
+   "neg_ids": [
+    50281,
+    50282
+   ],
+   "counts": {},
+   "find_counts": []
+  },
+  {
+   "prompt": "a neon sign “Luma Studio” on a brick wall",
+   "prepared": "a neon sign “Luma Studio” on a brick wall || spell: L u m a / S t u d i o",
+   "negative": "",
+   "ids": [
+    50281,
+    66,
+    16772,
+    861,
+    773,
+    45,
+    9307,
+    17203,
+    668,
+    327,
+    247,
+    20098,
+    3402,
+    2785,
+    15368,
+    27,
+    418,
+    1484,
+    278,
+    247,
+    1227,
+    322,
+    246,
+    1484,
+    277,
+    891,
+    258,
+    50282
+   ],
+   "neg_ids": [
+    50281,
+    50282
+   ],
+   "counts": {},
+   "find_counts": []
+  },
+  {
+   "prompt": "a book cover titled \"The Old Man and the Sea\"",
+   "prepared": "a book cover titled \"The Old Man and the Sea\" || spell: T h e / O l d / M a n / a n d / t h e / S e a",
+   "negative": "",
+   "ids": [
+    50281,
+    66,
+    1984,
+    3835,
+    18879,
+    346,
+    510,
+    8937,
+    3083,
+    285,
+    253,
+    11936,
+    3,
+    2785,
+    15368,
+    27,
+    308,
+    288,
+    299,
+    1227,
+    473,
+    298,
+    277,
+    1227,
+    353,
+    247,
+    295,
+    1227,
+    247,
+    295,
+    277,
+    1227,
+    246,
+    288,
+    299,
+    1227,
+    322,
+    299,
+    247,
+    50282
+   ],
+   "neg_ids": [
+    50281,
+    50282
+   ],
+   "counts": {},
+   "find_counts": []
+  },
+  {
+   "prompt": "a logo for \"Q&A Labs!\" with a fox, without text shadow",
+   "prepared": "a logo for \"Q&A Labs!\" with a fox || spell: Q & A / L a b s !",
+   "negative": "text shadow",
+   "ids": [
+    50281,
+    66,
+    18479,
+    323,
+    346,
+    50,
+    7,
+    34,
+    40840,
+    1476,
+    342,
+    247,
+    30013,
+    2785,
+    15368,
+    27,
+    1165,
+    708,
+    329,
+    1227,
+    418,
+    247,
+    270,
+    256,
+    2195,
+    50282
+   ],
+   "neg_ids": [
+    50281,
+    1156,
+    12195,
+    50282
+   ],
+   "counts": {},
+   "find_counts": []
+  },
+  {
+   "prompt": "a landscape without any people and no buildings",
+   "prepared": "a landscape and",
+   "negative": "people, buildings",
+   "ids": [
+    50281,
+    66,
+    13016,
+    285,
+    50282
+   ],
+   "neg_ids": [
+    50281,
+    13174,
+    13,
+    9195,
+    50282
+   ],
+   "counts": {},
+   "find_counts": []
+  },
+  {
+   "prompt": "a bowl of fruit with no bananas",
+   "prepared": "a bowl of fruit",
+   "negative": "bananas",
+   "ids": [
+    50281,
+    66,
+    11636,
+    273,
+    9279,
+    50282
+   ],
+   "neg_ids": [
+    50281,
+    5568,
+    24288,
+    50282
+   ],
+   "counts": {},
+   "find_counts": []
+  },
+  {
+   "prompt": "a cat, no dog, and a mouse",
+   "prepared": "a cat, and a mouse",
+   "negative": "dog",
+   "ids": [
+    50281,
+    66,
+    5798,
+    13,
+    285,
+    247,
+    6521,
+    50282
+   ],
+   "neg_ids": [
+    50281,
+    21428,
+    50282
+   ],
+   "counts": {},
+   "find_counts": []
+  },
+  {
+   "prompt": "the one and only unicorn",
+   "prepared": "the one and only unicorn",
+   "negative": "",
+   "ids": [
+    50281,
+    783,
+    581,
+    285,
+    760,
+    440,
+    41257,
+    50282
+   ],
+   "neg_ids": [
+    50281,
+    50282
+   ],
+   "counts": {},
+   "find_counts": []
+  },
+  {
+   "prompt": "no one is here, an empty street",
+   "prepared": "an empty street",
+   "negative": "one is here",
+   "ids": [
+    50281,
+    266,
+    6325,
+    6406,
+    50282
+   ],
+   "neg_ids": [
+    50281,
+    531,
+    310,
+    1060,
+    50282
+   ],
+   "counts": {},
+   "find_counts": []
+  },
+  {
+   "prompt": "a dozen eggs in a carton",
+   "prepared": "a dozen eggs in a carton",
+   "negative": "",
+   "ids": [
+    50281,
+    66,
+    13365,
+    11624,
+    275,
+    247,
+    7281,
+    251,
+    50282
+   ],
+   "neg_ids": [
+    50281,
+    50282
+   ],
+   "counts": {
+    "2": 12.0
+   },
+   "find_counts": [
+    [
+     2,
+     7,
+     12
+    ]
+   ]
+  },
+  {
+   "prompt": "a pair of shoes on the floor",
+   "prepared": "a pair of shoes on the floor",
+   "negative": "",
+   "ids": [
+    50281,
+    66,
+    4667,
+    273,
+    12682,
+    327,
+    253,
+    5254,
+    50282
+   ],
+   "neg_ids": [
+    50281,
+    50282
+   ],
+   "counts": {
+    "2": 2.0
+   },
+   "find_counts": [
+    [
+     2,
+     6,
+     2
+    ]
+   ]
+  },
+  {
+   "prompt": "a clock showing 3 pm on a wall",
+   "prepared": "a clock showing 3 pm on a wall",
+   "negative": "",
+   "ids": [
+    50281,
+    66,
+    8886,
+    4645,
+    495,
+    12920,
+    327,
+    247,
+    3402,
+    50282
+   ],
+   "neg_ids": [
+    50281,
+    50282
+   ],
+   "counts": {},
+   "find_counts": []
+  },
+  {
+   "prompt": "24 hours of rain over 5 houses",
+   "prepared": "24 hours of rain over five houses",
+   "negative": "",
+   "ids": [
+    50281,
+    1348,
+    3038,
+    273,
+    9313,
+    689,
+    2620,
+    9910,
+    50282
+   ],
+   "neg_ids": [
+    50281,
+    50282
+   ],
+   "counts": {
+    "6": 5.0
+   },
+   "find_counts": [
+    [
+     22,
+     26,
+     5
+    ]
+   ]
+  },
+  {
+   "prompt": "twelve  roses   in a\tvase\n",
+   "prepared": "twelve roses in a vase",
+   "negative": "",
+   "ids": [
+    50281,
+    7553,
+    11071,
+    38910,
+    275,
+    247,
+    362,
+    511,
+    50282
+   ],
+   "neg_ids": [
+    50281,
+    50282
+   ],
+   "counts": {
+    "1": 12.0,
+    "2": 12.0
+   },
+   "find_counts": [
+    [
+     0,
+     6,
+     12
+    ]
+   ]
+  },
+  {
+   "prompt": "a cake with 7 candles and 21 balloons",
+   "prepared": "a cake with seven candles and 21 balloons",
+   "negative": "",
+   "ids": [
+    50281,
+    66,
+    15221,
+    342,
+    5093,
+    36555,
+    285,
+    3127,
+    50210,
+    50282
+   ],
+   "neg_ids": [
+    50281,
+    50282
+   ],
+   "counts": {
+    "4": 7.0,
+    "7": 21.0
+   },
+   "find_counts": [
+    [
+     12,
+     17,
+     7
+    ],
+    [
+     30,
+     32,
+     21
+    ]
+   ]
+  },
+  {
+   "prompt": "one apple, two pears and four plums",
+   "prepared": "one apple, two pears and four plums",
+   "negative": "",
+   "ids": [
+    50281,
+    531,
+    19126,
+    13,
+    767,
+    268,
+    6364,
+    285,
+    1740,
+    499,
+    7640,
+    50282
+   ],
+   "neg_ids": [
+    50281,
+    50282
+   ],
+   "counts": {
+    "1": 1.0,
+    "4": 2.0,
+    "8": 4.0
+   },
+   "find_counts": [
+    [
+     0,
+     3,
+     1
+    ],
+    [
+     11,
+     14,
+     2
+    ],
+    [
+     25,
+     29,
+     4
+    ]
+   ]
+  },
+  {
+   "prompt": "   leading and trailing spaces   ",
+   "prepared": "leading and trailing spaces",
+   "negative": "",
+   "ids": [
+    50281,
+    16378,
+    285,
+    28417,
+    8470,
+    50282
+   ],
+   "neg_ids": [
+    50281,
+    50282
+   ],
+   "counts": {},
+   "find_counts": []
+  },
+  {
+   "prompt": "{\"high_level_description\": \"a flat logo\", \"text\": \"no cast shadow\"}",
+   "prepared": "{\"high_level_description\": \"a flat logo\", \"text\": \"no cast shadow\"}",
+   "negative": "",
+   "ids": [
+    50281,
+    9819,
+    8656,
+    64,
+    5251,
+    64,
+    10008,
+    1381,
+    346,
+    66,
+    6507,
+    18479,
+    995,
+    346,
+    1156,
+    1381,
+    346,
+    2369,
+    5248,
+    12195,
+    986,
+    50282
+   ],
+   "neg_ids": [
+    50281,
+    50282
+   ],
+   "counts": {},
+   "find_counts": []
+  },
+  {
+   "prompt": "a sign \"unclosed quote with three words",
+   "prepared": "a sign \"unclosed quote with three words",
+   "negative": "",
+   "ids": [
+    50281,
+    66,
+    861,
+    346,
+    328,
+    13784,
+    14430,
+    342,
+    1264,
+    3000,
+    50282
+   ],
+   "neg_ids": [
+    50281,
+    50282
+   ],
+   "counts": {
+    "8": 3.0
+   },
+   "find_counts": [
+    [
+     28,
+     33,
+     3
+    ]
+   ]
+  },
+  {
+   "prompt": "a sticker that says \"hi\" and a sticker that says \"bye\" and one that says \"ok\" and \"four\"",
+   "prepared": "a sticker that says \"hi\" and a sticker that says \"bye\" and one that says \"ok\" and \"four\" || spell: h i ; b y e ; o k",
+   "negative": "",
+   "ids": [
+    50281,
+    66,
+    7356,
+    254,
+    326,
+    2296,
+    346,
+    5801,
+    3,
+    285,
+    247,
+    7356,
+    254,
+    326,
+    2296,
+    346,
+    17034,
+    3,
+    285,
+    581,
+    326,
+    2296,
+    346,
+    536,
+    3,
+    285,
+    346,
+    12496,
+    3,
+    2785,
+    15368,
+    27,
+    288,
+    891,
+    3706,
+    270,
+    340,
+    299,
+    3706,
+    258,
+    465,
+    50282
+   ],
+   "neg_ids": [
+    50281,
+    50282
+   ],
+   "counts": {
+    "19": 1.0
+   },
+   "find_counts": [
+    [
+     59,
+     62,
+     1
+    ]
+   ]
+  },
+  {
+   "prompt": "a café in Zürich with 2 bicycles",
+   "prepared": "a café in Zürich with two bicycles",
+   "negative": "",
+   "ids": [
+    50281,
+    66,
+    36241,
+    275,
+    1503,
+    3090,
+    5969,
+    342,
+    767,
+    19151,
+    5005,
+    50282
+   ],
+   "neg_ids": [
+    50281,
+    50282
+   ],
+   "counts": {
+    "8": 2.0
+   },
+   "find_counts": [
+    [
+     22,
+     25,
+     2
+    ]
+   ]
+  },
+  {
+   "prompt": "an emoji-style icon of a rocket 🚀 with three stars",
+   "prepared": "an emoji-style icon of a rocket 🚀 with three stars",
+   "negative": "",
+   "ids": [
+    50281,
+    266,
+    802,
+    80,
+    8020,
+    14,
+    4826,
+    10651,
+    273,
+    247,
+    21912,
+    22692,
+    237,
+    211,
+    342,
+    1264,
+    6114,
+    50282
+   ],
+   "neg_ids": [
+    50281,
+    50282
+   ],
+   "counts": {
+    "15": 3.0
+   },
+   "find_counts": [
+    [
+     39,
+     44,
+     3
+    ]
+   ]
+  },
+  {
+   "prompt": "a banner \"Ünïcödé Tëxt\" above five flags",
+   "prepared": "a banner \"Ünïcödé Tëxt\" above five flags || spell: Ü n ï c ö d é / T ë x t",
+   "negative": "",
+   "ids": [
+    50281,
+    66,
+    29751,
+    346,
+    127,
+    239,
+    79,
+    12589,
+    68,
+    25873,
+    860,
+    308,
+    10093,
+    633,
+    3,
+    1840,
+    2620,
+    12201,
+    2785,
+    15368,
+    27,
+    37995,
+    295,
+    1325,
+    109,
+    260,
+    16919,
+    277,
+    3974,
+    1227,
+    308,
+    41254,
+    1269,
+    246,
+    50282
+   ],
+   "neg_ids": [
+    50281,
+    50282
+   ],
+   "counts": {
+    "16": 5.0
+   },
+   "find_counts": [
+    [
+     30,
+     34,
+     5
+    ]
+   ]
+  },
+  {
+   "prompt": "ten ten ten",
+   "prepared": "ten ten ten",
+   "negative": "",
+   "ids": [
+    50281,
+    1866,
+    3578,
+    3578,
+    50282
+   ],
+   "neg_ids": [
+    50281,
+    50282
+   ],
+   "counts": {
+    "1": 10.0,
+    "2": 10.0
+   },
+   "find_counts": [
+    [
+     0,
+     3,
+     10
+    ],
+    [
+     4,
+     7,
+     10
+    ]
+   ]
+  },
+  {
+   "prompt": "Two Red Apples And A Green Pear On A Plate",
+   "prepared": "two red apples and a green pear on a plate",
+   "negative": "",
+   "ids": [
+    50281,
+    9389,
+    2502,
+    28580,
+    285,
+    247,
+    4759,
+    27887,
+    327,
+    247,
+    5340,
+    50282
+   ],
+   "neg_ids": [
+    50281,
+    50282
+   ],
+   "counts": {
+    "1": 2.0
+   },
+   "find_counts": [
+    [
+     0,
+     3,
+     2
+    ]
+   ]
+  },
+  {
+   "prompt": "a cat without a hat",
+   "prepared": "a cat",
+   "negative": "hat",
+   "ids": [
+    50281,
+    66,
+    5798,
+    50282
+   ],
+   "neg_ids": [
+    50281,
+    700,
+    50282
+   ],
+   "counts": {},
+   "find_counts": []
+  },
+  {
+   "prompt": "",
+   "prepared": "",
+   "negative": "",
+   "ids": [
+    50281,
+    50282
+   ],
+   "neg_ids": [
+    50281,
+    50282
+   ],
+   "counts": {},
+   "find_counts": []
+  },
+  {
+   "prompt": "a portrait of a woman, no glasses. soft light",
+   "prepared": "a portrait of a woman. soft light",
+   "negative": "glasses",
+   "ids": [
+    50281,
+    66,
+    22946,
+    273,
+    247,
+    3416,
+    15,
+    2602,
+    1708,
+    50282
+   ],
+   "neg_ids": [
+    50281,
+    25483,
+    265,
+    50282
+   ],
+   "counts": {},
+   "find_counts": []
+  },
+  {
+   "prompt": "the word \"Agate\" in red serif letters, 2 lines",
+   "prepared": "the word \"Agate\" in red serif letters, two lines || spell: A g a t e",
+   "negative": "",
+   "ids": [
+    50281,
+    783,
+    3159,
+    346,
+    8903,
+    366,
+    3,
+    275,
+    2502,
+    1151,
+    338,
+    4876,
+    13,
+    767,
+    3104,
+    2785,
+    15368,
+    27,
+    329,
+    305,
+    247,
+    246,
+    299,
+    50282
+   ],
+   "neg_ids": [
+    50281,
+    50282
+   ],
+   "counts": {
+    "13": 2.0
+   },
+   "find_counts": [
+    [
+     39,
+     42,
+     2
+    ]
+   ]
+  }
+ ]
+}