Optimize Baberu WebGPU decoder memory execution

Publish the exact Gather-before-DequantizeLinear decoder for both WebGPU tiers, plus reproducible worker-memory and rejected-candidate reports. Model architecture and generated outputs remain unchanged.

MEMORY_RESULTS.md

@@ -0,0 +1,28 @@
+# Measured memory result
+
+Measured on 2026-07-17 in the T3 Chromium WebGPU renderer on Apple unified
+memory. The control keeps both sessions resident and loads explicit model
+bytes. The optimized mode uses direct URL loading, lean CPU allocation options,
+and a dedicated vision worker that is terminated before decoder startup.
+
+| Tier | Runs (control / optimized) | Renderer peak delta | JS heap peak | OCR parity |
+| --- | ---: | ---: | ---: | --- |
+| WebGPU-121 | 2 / 3 | 722.8 -> 710.1 MiB (-1.8%) | 87.0 -> 44.6 MiB (-48.7%) | exact, all 13 crops |
+| WebGPU-242 | 3 / 3 | 937.5 -> 796.6 MiB (-15.0%) | 202.1 -> 44.6 MiB (-77.9%) | exact, all 13 crops |
+
+The 242 tier receives a material renderer-RSS reduction because terminating the
+vision worker returns its large FP16 model runtime before the decoder starts.
+For the 121 tier, renderer RSS improves only slightly: its smaller INT4 vision
+session is not the dominant renderer allocation. This means there is no honest
+runtime-only change here that dramatically reduces the 121 tier without
+changing its model representation.
+
+`performance.memory` measures the page's JavaScript heap, while renderer RSS
+also includes WebAssembly, browser internals, and other renderer allocations.
+The GPU process is shared by all T3 tabs, so its sampled delta is intentionally
+excluded from the comparison. Page staging also requires retaining all crop
+embeddings (about 0.5 MiB each) until decoding begins and adds a worker/session
+transition; it is best suited to known page-level crop batches.
+
+Run `python3 summarize_memory_results.py` after new benchmark runs. The summary
+fails if any optimized OCR output differs from its current tier control.

MODEL_EXECUTION_RESULTS.md

@@ -0,0 +1,55 @@
+# Model-execution optimization result
+
+Measured on 2026-07-17 with ONNX Runtime WebGPU 1.27.0 in the T3 Chromium
+renderer on Apple unified memory. Every candidate retains all six decoder
+layers, hidden size 512, two KV heads, vocabulary 14,630, and the 128-token
+generation limit.
+
+## Accepted exact rewrite
+
+`decoder=gather-opt` changes only the token embedding order:
+
+```text
+baseline:   INT8 table -> DequantizeLinear [14630,512] -> Gather one row
+optimized:  INT8 table -> Gather one row -> DequantizeLinear [1,1,512]
+```
+
+This removes a 29,962,240-byte (28.6 MiB) FP32 intermediate. ONNX Runtime CPU
+comparison is bit-exact for prefill, cache length 257, and maximum cache length
+383. Three full WebGPU runs per tier produced exactly the same 13 OCR strings
+as baseline.
+
+Renderer RSS does not show a repeatable whole-run reduction because WebGPU
+buffers, the vision high-water mark, and Chromium allocator retention dominate
+the process measurement:
+
+| Full staged suite | Baseline median peak | Gather median peak | Change |
+| --- | ---: | ---: | ---: |
+| WebGPU-121, 3 + 3 runs | 836.0 MiB | 839.2 MiB | +0.4% |
+| WebGPU-242, 3 + 3 runs | 1,160.2 MiB | 1,165.4 MiB | +0.4% |
+
+The rewrite is kept because it is mathematically exact and removes unnecessary
+work, but it must not be advertised as a dramatic measured RAM reduction.
+
+## Rejected candidates
+
+- Fixed-capacity KV I/O is CPU bit-exact and WebGPU output-exact, but standard
+  ONNX Runtime WebGPU does not alias past/present buffers. Creating fixed
+  outputs with Slice/Pad adds work and did not produce a stable peak reduction.
+- Static FP16 MatMul for layers 1–3 preserves the current CPU top-token checks
+  and both 13-image WebGPU outputs. Its isolated 128-token median peak changed
+  from 727.1 MiB to 755.5 MiB (+3.9%), although median execution improved from
+  964.4 ms to 886.3 ms. It is therefore rejected for the memory objective.
+- Converting all 42 internal MatMuls, or all 43 including the language head,
+  changed case 09 from `そうだクラスわけがあるんだった！！` to
+  `そうだクラスケはあるんだった！！`. Those variants fail the explicit
+  no-capability-regression gate.
+
+## Remaining dramatic path
+
+The decoder has 43 INT8-QDQ MatMul weights. Avoiding their runtime FP32
+dequantized buffers without FP16 rounding requires a fused per-channel INT8
+MatMul WebGPU kernel (or equivalent runtime operator). That is a custom runtime
+implementation, not a safe standard-ONNX graph rewrite. The current experiment
+does not claim that kernel exists.
+

README.md

@@ -30,8 +30,9 @@ server is required after the browser downloads the files.
 ## Latest recommended models
 
 The latest decoder uses one complete six-layer QDQ graph for both prefill and
-cached token steps. It accepts an INT32 token ID and uses a quantized embedding
-`Gather` instead of a 14,630-element one-hot embedding MatMul.
+cached token steps. It accepts an INT32 token ID, gathers the selected INT8
+embedding row first, and only then runs `DequantizeLinear`. This exact rewrite
+avoids materializing the full `[14630,512]` FP32 embedding table (28.6 MiB).
 
 | Folder | Vision encoder | Latest decoder | Latest ONNX download |
 | --- | --- | --- | ---: |
@@ -61,7 +62,8 @@ selection policy. A GPU ArgMax graph and fused GroupQueryAttention graph were
 tested locally but removed because both were slower on the tested runtime.
 
 The QDQ decoder stores INT8 weights and executes `DequantizeLinear` followed by
-FP32 `MatMul` on WebGPU. It contains neither `DynamicQuantizeLinear` nor
+FP32 `MatMul` on WebGPU. The token embedding is the exception: its INT8 Gather
+runs before dequantization. It contains neither `DynamicQuantizeLinear` nor
 `MatMulInteger`, which would leave the intended browser WebGPU path.
 
 ## 13 difficult showcase-image check
@@ -82,6 +84,11 @@ previous unified one-hot graph. The 242 Gather graph also retained the earlier
 242 WebGPU result of 11.76% nCER and 5/13 exact. Latency depends heavily on GPU,
 shader cache, browser, and system load; these numbers are not portable.
 
+The Gather-before-dequantize decoder is also bit-exact against the previous
+token-Gather decoder on ONNX Runtime CPU at prefill, cache length 257, and the
+maximum tested cache length 383. Three full WebGPU runs per vision tier retained
+all 13 previous output strings.
+
 In one same-process 121 comparison, the optimized graph sampled an 833 MB
 shared GPU-process peak and 577 MB renderer peak, versus 866 MB and 613 MB for
 the unified one-hot baseline. Those values must not be added as model-owned
@@ -135,6 +142,8 @@ when complete.
 - complete unified and token-ID Gather decoder exporters;
 - per-output-channel INT8-QDQ converter and CPU parity checks;
 - browser WebGPU end-to-end and decoder smoke harnesses;
+- exact Gather-before-dequantize and experimental execution optimizers;
+- staged vision-worker and decoder-only cold/warm memory harnesses;
 - native CPU and MangaOCR comparison harnesses;
 - isolated Python/npm dependencies and local server;
 - benchmark helpers and generated validation reports.

README_MEMORY_OPT.md

@@ -0,0 +1,82 @@
+# Baberu WebGPU capability-preserving memory experiment
+
+This experiment tests browser-memory reductions without pruning, narrowing,
+distilling, shortening, or changing either Baberu model tier. Both variants
+retain the complete six-layer decoder, hidden size 512, intermediate size
+1,536, eight attention heads, two KV heads, 14,630-token vocabulary, 128-token
+generation limit, published greedy/repetition policy, and their original INT4
+or FP16 vision encoder.
+
+Implemented runtime-only variables using the exact `onnxruntime-web/webgpu`
+entry that Baberu's browser harness uses:
+
+- `loader=url` passes the model URL directly to ONNX Runtime and avoids an
+  additional page-owned `ArrayBuffer`/`Uint8Array` load path;
+- `loader=bytes` keeps the previous explicit `fetch -> ArrayBuffer -> Uint8Array`
+  path as the control;
+- `memory=default` uses ONNX Runtime's default CPU arena and memory pattern;
+- `memory=lean` disables the CPU arena and memory pattern to limit reusable
+  CPU-side allocation pools while leaving all WebGPU operators and model
+  tensors unchanged;
+- `schedule=resident` keeps the vision and decoder sessions resident together;
+- `schedule=staged` runs the vision phase in a dedicated worker, encodes all
+  page crops to CPU embeddings, then releases the session and terminates the
+  worker before loading the decoder. Worker termination returns the vision
+  WebAssembly heap instead of leaving its high-water allocation in the main
+  runtime. The embeddings total about 0.5 MiB per crop and retain the complete
+  vision output, so model capability is unchanged.
+
+The exact runtime entry and its Asyncify WebGPU assets are copied under
+`.work/`; the installed package and production OCR implementation are not
+modified. A prior draft attempted to patch a JSEP buffer pool, but that is a
+different build path from `onnxruntime-web/webgpu` and is intentionally not
+part of this experiment.
+
+The decoder query exposes model-execution candidates separately:
+
+- `decoder=gather-opt` gathers the selected INT8 token-embedding row before
+  `DequantizeLinear`, avoiding a 28.6 MiB full FP32 embedding-table output.
+  It is bit-exact on CPU and output-exact on all 13 browser cases for both
+  vision tiers, so this is the accepted model-level rewrite.
+- `decoder=fixed-kv` also exposes fixed 384-slot KV inputs and outputs plus
+  `past_length`. This remains a rejected experiment: ONNX Runtime WebGPU does
+  not share the external buffers in place, so dynamic Slice/Pad work offsets
+  the theoretical allocation saving.
+- `decoder=fp16-matmul` executes the 21 MatMuls in decoder layers 1–3 with
+  static FP16 weights while retaining the other layers and language head in
+  their original INT8-QDQ form. It preserves the current browser corpus but is
+  retained as a rejected memory experiment because isolated peak RSS rose.
+  More aggressive 42/43-MatMul variants changed an OCR output.
+
+Prepare disposable assets and start the isolated server:
+
+```sh
+python3 prepare_memory_experiment.py
+uv venv .work/model-opt-venv
+uv pip install --python .work/model-opt-venv/bin/python -r requirements-model-opt.txt
+.work/model-opt-venv/bin/python optimize_decoder_execution.py
+.work/model-opt-venv/bin/python optimize_decoder_fp16_matmul.py
+python3 serve_memory_experiment.py
+```
+
+Example control and optimized URLs:
+
+```text
+http://127.0.0.1:8765/webgpu-memory-opt.html?tier=121&memory=default&loader=bytes&schedule=resident
+http://127.0.0.1:8765/webgpu-memory-opt.html?tier=121&memory=lean&loader=url&schedule=staged
+http://127.0.0.1:8765/webgpu-memory-opt.html?tier=242&memory=default&loader=bytes&schedule=resident
+http://127.0.0.1:8765/webgpu-memory-opt.html?tier=242&memory=lean&loader=url&schedule=staged
+http://127.0.0.1:8765/webgpu-memory-opt.html?tier=242&memory=lean&loader=url&schedule=staged&decoder=gather-opt
+http://127.0.0.1:8765/webgpu-memory-opt.html?tier=121&memory=lean&loader=url&schedule=staged&decoder=gather-opt&scope=decoder
+```
+
+Results are written to `.work/results/`. Each result includes OCR output,
+accuracy, latency, browser-reported heap samples, and sampled T3 renderer/GPU
+process RSS. Process maxima remain engineering observations rather than exact
+model-owned RAM, especially on unified-memory Apple hardware. `scope=decoder`
+skips the vision model and forces the complete 128-token cache path for a
+separate cold session-load and warm execution observation.
+
+See `MEMORY_RESULTS.md` for the repeated control/optimized comparison and run
+`python3 summarize_memory_results.py` to recompute it from local results.
+See `MODEL_EXECUTION_RESULTS.md` for the graph-level acceptance decision.

optimize_decoder_execution.py

@@ -0,0 +1,345 @@
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+from collections import Counter, defaultdict
+from pathlib import Path
+
+import numpy as np
+import onnx
+import onnxruntime as ort
+from onnx import TensorProto, helper, numpy_helper
+
+
+ROOT = Path(__file__).resolve().parent
+DEFAULT_SOURCE = ROOT / ".work/models/shared/decoder_unified_gather_qdq_int8.onnx"
+DEFAULT_DESTINATION = ROOT / ".work/models/model-opt/decoder_gather_before_dq_int8.onnx"
+DEFAULT_FIXED_KV_DESTINATION = ROOT / ".work/models/model-opt/decoder_gather_dq_fixed_kv_int8.onnx"
+DEFAULT_REPORT = ROOT / ".work/reports/model-execution-optimization.json"
+NUM_LAYERS = 6
+VISION_TOKENS = 256
+MAX_NEW_TOKENS = 128
+# Prefill produces 257 cache entries. The runtime stops before running a decode
+# step for token 128, so the largest present cache produced is length 384.
+MAX_CACHE_LENGTH = VISION_TOKENS + MAX_NEW_TOKENS
+CACHE_NAMES = [f"{kind}_{axis}{layer}" for kind in ("past", "present") for axis in ("k", "v") for layer in range(NUM_LAYERS)]
+
+
+def sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as source:
+        for chunk in iter(lambda: source.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def set_shape(value_info: onnx.ValueInfoProto, shape: list[int | str]) -> None:
+    dimensions = value_info.type.tensor_type.shape.dim
+    del dimensions[:]
+    for value in shape:
+        dimension = dimensions.add()
+        if isinstance(value, int):
+            dimension.dim_value = value
+        else:
+            dimension.dim_param = value
+
+
+def rewrite_embedding_gather(model: onnx.ModelProto) -> dict:
+    graph = model.graph
+    initializers = {value.name: value for value in graph.initializer}
+    consumers: dict[str, list[onnx.NodeProto]] = defaultdict(list)
+    for node in graph.node:
+        for name in node.input:
+            consumers[name].append(node)
+
+    embedding_dq = None
+    embedding_gather = None
+    for node in graph.node:
+        if node.op_type != "DequantizeLinear" or len(node.input) < 3:
+            continue
+        quantized = initializers.get(node.input[0])
+        if not quantized or list(quantized.dims) != [14630, 512]:
+            continue
+        matches = [consumer for consumer in consumers[node.output[0]] if consumer.op_type == "Gather"]
+        if len(matches) != 1:
+            raise RuntimeError(f"Embedding DQ expected one Gather consumer, found {len(matches)}")
+        embedding_dq = node
+        embedding_gather = matches[0]
+        break
+    if embedding_dq is None or embedding_gather is None:
+        raise RuntimeError("Could not locate quantized 14630x512 embedding Gather")
+
+    original_output = embedding_gather.output[0]
+    quantized_output = f"{original_output}_int8"
+    embedding_gather.input[0] = embedding_dq.input[0]
+    embedding_gather.output[0] = quantized_output
+    gathered_dq = helper.make_node(
+        "DequantizeLinear",
+        [quantized_output, embedding_dq.input[1], embedding_dq.input[2]],
+        [original_output],
+        name=f"{embedding_dq.name}_after_gather",
+        # Gather axis 0 with token_ids rank 2 moves hidden axis 1 to axis 2.
+        axis=2,
+    )
+
+    rewritten = []
+    for node in graph.node:
+        if node is embedding_dq:
+            continue
+        rewritten.append(node)
+        if node is embedding_gather:
+            rewritten.append(gathered_dq)
+    del graph.node[:]
+    graph.node.extend(rewritten)
+    return {
+        "quantized_elements_selected": 14630 * 512,
+        "fp32_bytes_avoided_before_gather": 14630 * 512 * 4,
+        "gather_output": original_output,
+    }
+
+
+def rewrite_fixed_kv_io(model: onnx.ModelProto) -> dict:
+    graph = model.graph
+    input_by_name = {value.name: value for value in graph.input}
+    output_by_name = {value.name: value for value in graph.output}
+    past_names = [f"past_{axis}{layer}" for axis in ("k", "v") for layer in range(NUM_LAYERS)]
+    present_names = [f"present_{axis}{layer}" for axis in ("k", "v") for layer in range(NUM_LAYERS)]
+
+    for name in past_names:
+        if name not in input_by_name:
+            raise RuntimeError(f"Missing cache input {name}")
+        set_shape(input_by_name[name], [1, 2, MAX_CACHE_LENGTH, 64])
+    for name in present_names:
+        if name not in output_by_name:
+            raise RuntimeError(f"Missing cache output {name}")
+        set_shape(output_by_name[name], [1, 2, MAX_CACHE_LENGTH, 64])
+
+    graph.input.append(helper.make_tensor_value_info("past_length", TensorProto.INT64, [1]))
+    graph.initializer.extend(
+        [
+            numpy_helper.from_array(np.array([0], dtype=np.int64), "fixed_kv_slice_starts"),
+            numpy_helper.from_array(np.array([2], dtype=np.int64), "fixed_kv_slice_axes"),
+            numpy_helper.from_array(np.array([1], dtype=np.int64), "fixed_kv_slice_steps"),
+            numpy_helper.from_array(np.zeros(4, dtype=np.int64), "fixed_kv_pad_begin"),
+            numpy_helper.from_array(np.zeros(2, dtype=np.int64), "fixed_kv_pad_end_prefix"),
+            numpy_helper.from_array(np.zeros(1, dtype=np.int64), "fixed_kv_pad_end_suffix"),
+            numpy_helper.from_array(np.array([MAX_CACHE_LENGTH], dtype=np.int64), "fixed_kv_max_length"),
+            numpy_helper.from_array(np.array([2], dtype=np.int64), "fixed_kv_shape_axis"),
+        ]
+    )
+
+    slice_nodes = []
+    sliced_names: dict[str, str] = {}
+    for name in past_names:
+        sliced_name = f"{name}_valid"
+        sliced_names[name] = sliced_name
+        slice_nodes.append(
+            helper.make_node(
+                "Slice",
+                [name, "fixed_kv_slice_starts", "past_length", "fixed_kv_slice_axes", "fixed_kv_slice_steps"],
+                [sliced_name],
+                name=f"fixed_kv_slice_{name}",
+            )
+        )
+
+    original_nodes = list(graph.node)
+    for node in original_nodes:
+        for index, name in enumerate(node.input):
+            if name in sliced_names:
+                node.input[index] = sliced_names[name]
+
+    pad_nodes = []
+    for name in present_names:
+        producer = next((node for node in original_nodes if name in node.output), None)
+        if producer is None:
+            raise RuntimeError(f"Missing producer for {name}")
+        valid_name = f"{name}_valid"
+        producer.output[list(producer.output).index(name)] = valid_name
+        for consumer in original_nodes:
+            for input_index, input_name in enumerate(consumer.input):
+                if input_name == name:
+                    consumer.input[input_index] = valid_name
+        shape_name = f"{name}_shape"
+        length_name = f"{name}_length"
+        padding_name = f"{name}_padding"
+        pads_name = f"{name}_pads"
+        pad_nodes.extend(
+            [
+                helper.make_node("Shape", [valid_name], [shape_name], name=f"fixed_kv_shape_{name}"),
+                helper.make_node(
+                    "Gather",
+                    [shape_name, "fixed_kv_shape_axis"],
+                    [length_name],
+                    name=f"fixed_kv_length_{name}",
+                    axis=0,
+                ),
+                helper.make_node(
+                    "Sub",
+                    ["fixed_kv_max_length", length_name],
+                    [padding_name],
+                    name=f"fixed_kv_padding_{name}",
+                ),
+                helper.make_node(
+                    "Concat",
+                    ["fixed_kv_pad_begin", "fixed_kv_pad_end_prefix", padding_name, "fixed_kv_pad_end_suffix"],
+                    [pads_name],
+                    name=f"fixed_kv_pads_{name}",
+                    axis=0,
+                ),
+                helper.make_node("Pad", [valid_name, pads_name], [name], name=f"fixed_kv_pad_{name}"),
+            ]
+        )
+
+    del graph.node[:]
+    graph.node.extend(slice_nodes)
+    graph.node.extend(original_nodes)
+    graph.node.extend(pad_nodes)
+    return {
+        "max_cache_length": MAX_CACHE_LENGTH,
+        "fixed_live_cache_bytes": NUM_LAYERS * 2 * 2 * MAX_CACHE_LENGTH * 64 * 4,
+        "dynamic_present_allocation_bytes_across_max_decode": sum(
+            NUM_LAYERS * 2 * 2 * length * 64 * 4
+            for length in range(VISION_TOKENS + 1, MAX_CACHE_LENGTH + 1)
+        ),
+    }
+
+
+def operator_counts(model: onnx.ModelProto) -> dict[str, int]:
+    return dict(sorted(Counter(node.op_type for node in model.graph.node).items()))
+
+
+def source_feeds(session: ort.InferenceSession, past_length: int, *, prefill: bool) -> dict[str, np.ndarray]:
+    rng = np.random.default_rng(20260717 + past_length)
+    feeds: dict[str, np.ndarray] = {}
+    for value in session.get_inputs():
+        if value.name == "vision_embeds":
+            length = VISION_TOKENS if prefill else 0
+            feeds[value.name] = rng.normal(0, 0.2, [1, length, 512]).astype(np.float32)
+        elif value.name == "token_ids":
+            feeds[value.name] = np.array([[1 if prefill else 4]], dtype=np.int32)
+        elif value.name == "position_ids":
+            feeds[value.name] = (
+                np.arange(VISION_TOKENS + 1, dtype=np.int32)[None, :]
+                if prefill
+                else np.array([[past_length]], dtype=np.int32)
+            )
+        else:
+            feeds[value.name] = rng.normal(0, 0.02, [1, 2, past_length, 64]).astype(np.float32)
+    return feeds
+
+
+def candidate_feeds(source: dict[str, np.ndarray], past_length: int) -> dict[str, np.ndarray]:
+    feeds: dict[str, np.ndarray] = {}
+    for name, value in source.items():
+        if name.startswith("past_"):
+            fixed = np.zeros([1, 2, MAX_CACHE_LENGTH, 64], dtype=np.float32)
+            fixed[:, :, :past_length, :] = value
+            feeds[name] = fixed
+        else:
+            feeds[name] = value
+    feeds["past_length"] = np.array([past_length], dtype=np.int64)
+    return feeds
+
+
+def validate_cpu(source: Path, candidate: Path, *, fixed_kv: bool) -> dict:
+    source_session = ort.InferenceSession(str(source), providers=["CPUExecutionProvider"])
+    candidate_session = ort.InferenceSession(str(candidate), providers=["CPUExecutionProvider"])
+    checks = {}
+    for label, past_length, prefill in (("prefill", 0, True), ("step_257", 257, False), ("step_383", 383, False)):
+        source_input = source_feeds(source_session, past_length, prefill=prefill)
+        expected = source_session.run(None, source_input)
+        actual = candidate_session.run(
+            None,
+            candidate_feeds(source_input, past_length) if fixed_kv else source_input,
+        )
+        active_length = (VISION_TOKENS + 1) if prefill else past_length + 1
+        differences = [float(np.max(np.abs(expected[0] - actual[0])))]
+        padding_nonzero = 0
+        for expected_cache, actual_cache in zip(expected[1:], actual[1:]):
+            actual_valid = actual_cache[:, :, :active_length, :] if fixed_kv else actual_cache
+            differences.append(float(np.max(np.abs(expected_cache - actual_valid))))
+            if fixed_kv:
+                padding_nonzero += int(np.count_nonzero(actual_cache[:, :, active_length:, :]))
+        checks[label] = {
+            "max_abs": max(differences),
+            "logits_max_abs": differences[0],
+            "top_token_source": int(expected[0][0, -1].argmax()),
+            "top_token_candidate": int(actual[0][0, -1].argmax()),
+            "padding_nonzero": padding_nonzero,
+        }
+        if checks[label]["max_abs"] != 0 or padding_nonzero != 0:
+            raise RuntimeError(f"CPU parity failed for {label}: {checks[label]}")
+    return checks
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--source", type=Path, default=DEFAULT_SOURCE)
+    parser.add_argument("--destination", type=Path, default=DEFAULT_DESTINATION)
+    parser.add_argument("--fixed-kv-destination", type=Path, default=DEFAULT_FIXED_KV_DESTINATION)
+    parser.add_argument("--report", type=Path, default=DEFAULT_REPORT)
+    arguments = parser.parse_args()
+    arguments.destination.parent.mkdir(parents=True, exist_ok=True)
+    arguments.fixed_kv_destination.parent.mkdir(parents=True, exist_ok=True)
+    arguments.report.parent.mkdir(parents=True, exist_ok=True)
+
+    model = onnx.load(arguments.source)
+    before = operator_counts(model)
+    embedding = rewrite_embedding_gather(model)
+    model.producer_name = "vibe-manga-baberu-webgpu-model-execution-opt"
+    model.producer_version = "1"
+    onnx.checker.check_model(model)
+    onnx.save(model, arguments.destination)
+    gather_parity = validate_cpu(arguments.source, arguments.destination, fixed_kv=False)
+
+    fixed_kv_model = onnx.load(arguments.destination)
+    fixed_kv = rewrite_fixed_kv_io(fixed_kv_model)
+    fixed_kv_model.producer_version = "1-fixed-kv-experiment"
+    onnx.checker.check_model(fixed_kv_model)
+    onnx.save(fixed_kv_model, arguments.fixed_kv_destination)
+    fixed_kv_parity = validate_cpu(
+        arguments.source,
+        arguments.fixed_kv_destination,
+        fixed_kv=True,
+    )
+    report = {
+        "source": {
+            "path": str(arguments.source.relative_to(ROOT)),
+            "bytes": arguments.source.stat().st_size,
+            "sha256": sha256(arguments.source),
+            "operators": before,
+        },
+        "gather_optimized": {
+            "path": str(arguments.destination.relative_to(ROOT)),
+            "bytes": arguments.destination.stat().st_size,
+            "sha256": sha256(arguments.destination),
+            "operators": operator_counts(model),
+        },
+        "fixed_kv_experiment": {
+            "path": str(arguments.fixed_kv_destination.relative_to(ROOT)),
+            "bytes": arguments.fixed_kv_destination.stat().st_size,
+            "sha256": sha256(arguments.fixed_kv_destination),
+            "operators": operator_counts(fixed_kv_model),
+        },
+        "capability": {
+            "layers": 6,
+            "hidden_size": 512,
+            "kv_heads": 2,
+            "vocabulary": 14630,
+            "max_new_tokens": MAX_NEW_TOKENS,
+            "weights_requantized": False,
+        },
+        "embedding_gather_before_dequantize": embedding,
+        "fixed_kv_io": fixed_kv,
+        "cpu_parity": {
+            "gather_optimized": gather_parity,
+            "fixed_kv_experiment": fixed_kv_parity,
+        },
+    }
+    arguments.report.write_text(json.dumps(report, indent=2) + "\n", encoding="utf-8")
+    print(json.dumps(report, indent=2))
+
+
+if __name__ == "__main__":
+    main()

optimize_decoder_fp16_matmul.py

@@ -0,0 +1,242 @@
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import re
+from collections import defaultdict
+from pathlib import Path
+
+import numpy as np
+import onnx
+import onnxruntime as ort
+from onnx import TensorProto, helper, numpy_helper
+
+
+ROOT = Path(__file__).resolve().parent
+BASELINE = ROOT / ".work/models/shared/decoder_unified_gather_qdq_int8.onnx"
+DEFAULT_SOURCE = ROOT / ".work/models/model-opt/decoder_gather_before_dq_int8.onnx"
+DEFAULT_DESTINATION = ROOT / ".work/models/model-opt/decoder_static_fp16_matmul.onnx"
+DEFAULT_REPORT = ROOT / ".work/reports/model-fp16-matmul-optimization.json"
+VISION_TOKENS = 256
+KEEP_QDQ_MATMUL_NAMES = {"/lm_head/MatMul"}
+
+
+def sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as source:
+        for chunk in iter(lambda: source.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def dequantize_to_fp16(
+    quantized: onnx.TensorProto,
+    scale: onnx.TensorProto,
+    zero_point: onnx.TensorProto,
+    axis: int,
+) -> np.ndarray:
+    values = numpy_helper.to_array(quantized).astype(np.float32)
+    scales = numpy_helper.to_array(scale).astype(np.float32)
+    zeros = numpy_helper.to_array(zero_point).astype(np.float32)
+    broadcast_shape = [1] * values.ndim
+    broadcast_shape[axis] = scales.size
+    return ((values - zeros.reshape(broadcast_shape)) * scales.reshape(broadcast_shape)).astype(np.float16)
+
+
+def rewrite_matmul_weights(model: onnx.ModelProto, selected_layers: set[int]) -> dict:
+    graph = model.graph
+    initializers = {value.name: value for value in graph.initializer}
+    consumers: dict[str, list[onnx.NodeProto]] = defaultdict(list)
+    for node in graph.node:
+        for name in node.input:
+            consumers[name].append(node)
+
+    dq_by_matmul_name: dict[str, onnx.NodeProto] = {}
+    fp16_initializers: list[onnx.TensorProto] = []
+    removable_initializers: set[str] = set()
+    quantized_elements = 0
+    for node in graph.node:
+        if node.op_type != "DequantizeLinear" or len(node.input) < 3:
+            continue
+        quantized = initializers.get(node.input[0])
+        scale = initializers.get(node.input[1])
+        zero_point = initializers.get(node.input[2])
+        if quantized is None or scale is None or zero_point is None:
+            continue
+        matches = [consumer for consumer in consumers[node.output[0]] if consumer.op_type == "MatMul"]
+        if not matches:
+            continue
+        if len(matches) != 1:
+            raise RuntimeError(f"Expected one MatMul consumer for {node.name}, found {len(matches)}")
+        matmul = matches[0]
+        if matmul.name in KEEP_QDQ_MATMUL_NAMES:
+            continue
+        layer_match = re.search(r"/decoder/layers\.(\d+)/", matmul.name)
+        if layer_match is None:
+            raise RuntimeError(f"Unexpected non-layer MatMul {matmul.name}")
+        if int(layer_match.group(1)) not in selected_layers:
+            continue
+        if matmul.input[1] != node.output[0]:
+            raise RuntimeError(f"Quantized weight is not RHS input for {matmul.name}")
+        axis = next((attribute.i for attribute in node.attribute if attribute.name == "axis"), 1)
+        fp16_name = f"{quantized.name}_static_fp16"
+        fp16 = dequantize_to_fp16(quantized, scale, zero_point, axis)
+        fp16_initializers.append(numpy_helper.from_array(fp16, fp16_name))
+        matmul.input[1] = fp16_name
+        dq_by_matmul_name[matmul.name] = node
+        removable_initializers.update(node.input[:3])
+        quantized_elements += fp16.size
+
+    expected_matmuls = 7 * len(selected_layers)
+    if len(dq_by_matmul_name) != expected_matmuls:
+        raise RuntimeError(f"Expected {expected_matmuls} selected MatMuls, found {len(dq_by_matmul_name)}")
+
+    rewritten: list[onnx.NodeProto] = []
+    removed_dq_names = {node.name for node in dq_by_matmul_name.values()}
+    for node in graph.node:
+        if node.name in removed_dq_names:
+            continue
+        if node.name not in dq_by_matmul_name:
+            rewritten.append(node)
+            continue
+        input_fp16 = f"{node.input[0]}__for_{node.name.replace('/', '_')}_fp16"
+        output_float = node.output[0]
+        output_fp16 = f"{output_float}__fp16"
+        rewritten.append(
+            helper.make_node(
+                "Cast",
+                [node.input[0]],
+                [input_fp16],
+                name=f"{node.name}/CastInputToFp16",
+                to=TensorProto.FLOAT16,
+            )
+        )
+        node.input[0] = input_fp16
+        node.output[0] = output_fp16
+        rewritten.append(node)
+        rewritten.append(
+            helper.make_node(
+                "Cast",
+                [output_fp16],
+                [output_float],
+                name=f"{node.name}/CastOutputToFp32",
+                to=TensorProto.FLOAT,
+            )
+        )
+
+    retained = [value for value in graph.initializer if value.name not in removable_initializers]
+    del graph.initializer[:]
+    graph.initializer.extend(retained)
+    graph.initializer.extend(fp16_initializers)
+    del graph.node[:]
+    graph.node.extend(rewritten)
+    return {
+        "matmuls_rewritten": len(dq_by_matmul_name),
+        "layers_rewritten": sorted(selected_layers),
+        "matmuls_kept_qdq": sorted(KEEP_QDQ_MATMUL_NAMES),
+        "weight_elements": quantized_elements,
+        "runtime_fp32_weight_bytes_avoided": quantized_elements * 4,
+        "static_fp16_weight_bytes": quantized_elements * 2,
+        "source_int8_weight_bytes_removed": quantized_elements,
+        "estimated_live_weight_bytes_avoided": quantized_elements * 3,
+    }
+
+
+def feeds(session: ort.InferenceSession, past_length: int, *, prefill: bool) -> dict[str, np.ndarray]:
+    rng = np.random.default_rng(20260717 + past_length)
+    result: dict[str, np.ndarray] = {}
+    for value in session.get_inputs():
+        if value.name == "vision_embeds":
+            length = VISION_TOKENS if prefill else 0
+            result[value.name] = rng.normal(0, 0.2, [1, length, 512]).astype(np.float32)
+        elif value.name == "token_ids":
+            result[value.name] = np.array([[1 if prefill else 4]], dtype=np.int32)
+        elif value.name == "position_ids":
+            result[value.name] = (
+                np.arange(VISION_TOKENS + 1, dtype=np.int32)[None, :]
+                if prefill
+                else np.array([[past_length]], dtype=np.int32)
+            )
+        else:
+            result[value.name] = rng.normal(0, 0.02, [1, 2, past_length, 64]).astype(np.float32)
+    return result
+
+
+def validate_cpu(baseline: Path, candidate: Path) -> dict:
+    baseline_session = ort.InferenceSession(str(baseline), providers=["CPUExecutionProvider"])
+    candidate_session = ort.InferenceSession(str(candidate), providers=["CPUExecutionProvider"])
+    checks = {}
+    for label, past_length, prefill in (
+        ("prefill", 0, True),
+        ("step_257", 257, False),
+        ("step_383", 383, False),
+    ):
+        model_feeds = feeds(baseline_session, past_length, prefill=prefill)
+        expected = baseline_session.run(None, model_feeds)
+        actual = candidate_session.run(None, model_feeds)
+        max_abs = [float(np.max(np.abs(left - right))) for left, right in zip(expected, actual)]
+        checks[label] = {
+            "logits_max_abs": max_abs[0],
+            "all_outputs_max_abs": max(max_abs),
+            "top_token_baseline": int(expected[0][0, -1].argmax()),
+            "top_token_candidate": int(actual[0][0, -1].argmax()),
+        }
+        if checks[label]["top_token_baseline"] != checks[label]["top_token_candidate"]:
+            raise RuntimeError(f"CPU top-token parity failed for {label}: {checks[label]}")
+    return checks
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--baseline", type=Path, default=BASELINE)
+    parser.add_argument("--source", type=Path, default=DEFAULT_SOURCE)
+    parser.add_argument("--destination", type=Path, default=DEFAULT_DESTINATION)
+    parser.add_argument("--report", type=Path, default=DEFAULT_REPORT)
+    parser.add_argument(
+        "--layers",
+        default="1,2,3",
+        help="Comma-separated decoder layers whose seven MatMuls execute in FP16",
+    )
+    arguments = parser.parse_args()
+    arguments.destination.parent.mkdir(parents=True, exist_ok=True)
+    arguments.report.parent.mkdir(parents=True, exist_ok=True)
+
+    selected_layers = {int(value) for value in arguments.layers.split(",") if value != ""}
+    if not selected_layers.issubset(set(range(6))):
+        raise ValueError(f"Invalid decoder layers {sorted(selected_layers)}")
+    model = onnx.load(arguments.source)
+    optimization = rewrite_matmul_weights(model, selected_layers)
+    model.producer_name = "vibe-manga-baberu-webgpu-static-fp16-matmul"
+    model.producer_version = "1"
+    onnx.checker.check_model(model)
+    onnx.save(model, arguments.destination)
+    parity = validate_cpu(arguments.baseline, arguments.destination)
+    report = {
+        "source": {
+            "path": str(arguments.source.relative_to(ROOT)),
+            "bytes": arguments.source.stat().st_size,
+            "sha256": sha256(arguments.source),
+        },
+        "optimized": {
+            "path": str(arguments.destination.relative_to(ROOT)),
+            "bytes": arguments.destination.stat().st_size,
+            "sha256": sha256(arguments.destination),
+        },
+        "capability": {
+            "layers": 6,
+            "hidden_size": 512,
+            "kv_heads": 2,
+            "vocabulary": 14630,
+            "max_new_tokens": 128,
+            "architecture_changed": False,
+        },
+        "static_fp16_matmul": optimization,
+        "cpu_validation": parity,
+    }
+    arguments.report.write_text(json.dumps(report, indent=2) + "\n", encoding="utf-8")
+    print(json.dumps(report, indent=2))
+
+
+if __name__ == "__main__":
+    main()

reports/model-execution-report.json

@@ -0,0 +1,37 @@
+{
+  "date": "2026-07-17",
+  "runtime": "onnxruntime-web/webgpu 1.27.0",
+  "source": {
+    "bytes": 34647907,
+    "sha256": "3612d5787ffb1026ae09bfd4a16b3379ea75fe0dd803484f7bb41645be6b6239"
+  },
+  "gather_optimized": {
+    "bytes": 34647902,
+    "sha256": "53778e5b50d78ee55c8674d3d19f53de14da808bd1c231a9d4cebd5d44d3ad93",
+    "fp32_intermediate_bytes_avoided": 29962240,
+    "cpu_bit_exact": true,
+    "webgpu_output_exact_tier_121": true,
+    "webgpu_output_exact_tier_242": true,
+    "accepted": true
+  },
+  "fixed_kv": {
+    "bytes": 34656423,
+    "sha256": "6e3ae602fdebebe85f379ece1b24804ded32498ff94c950f7f1dda88423700f8",
+    "cpu_bit_exact": true,
+    "webgpu_output_exact": true,
+    "accepted": false,
+    "reason": "No in-place past-present buffer sharing in standard ONNX Runtime WebGPU; Slice and Pad offset the allocation benefit."
+  },
+  "fp16_matmul_layers_1_2_3": {
+    "bytes": 43622628,
+    "sha256": "eef947f0eeb23c843f02d26c6abf6bc69d4cdde396b43846ca4802ec4810f9dc",
+    "matmuls_rewritten": 21,
+    "estimated_live_weight_bytes_avoided": 27131904,
+    "webgpu_output_exact_tier_121": true,
+    "webgpu_output_exact_tier_242": true,
+    "isolated_peak_mib_baseline": 727.1,
+    "isolated_peak_mib_candidate": 755.5,
+    "accepted": false,
+    "reason": "Measured isolated peak RSS regressed by 3.9 percent."
+  }
+}

requirements-model-opt.txt

@@ -0,0 +1,3 @@
+numpy==2.5.1
+onnx==1.22.0
+onnxruntime==1.27.0

serve_memory_experiment.py

@@ -0,0 +1,188 @@
+from __future__ import annotations
+
+import json
+import subprocess
+import threading
+import time
+from http.server import SimpleHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parent
+RESULTS = ROOT / ".work" / "results"
+
+
+def process_rss() -> dict[str, dict[int, int]]:
+    output = subprocess.run(
+        ["ps", "-axo", "pid=,rss=,command="],
+        check=True,
+        capture_output=True,
+        text=True,
+    ).stdout
+    result: dict[str, dict[int, int]] = {"renderer": {}, "gpu": {}}
+    for line in output.splitlines():
+        pieces = line.strip().split(maxsplit=2)
+        if len(pieces) != 3:
+            continue
+        pid_text, rss_text, command = pieces
+        if "T3 Code (Alpha)" not in command:
+            continue
+        if "--type=renderer" in command and "Helper (Renderer)" in command:
+            result["renderer"][int(pid_text)] = int(rss_text) * 1024
+        elif "--type=gpu-process" in command and "user-data-dir=/Users/admin/Library/Application Support/t3code" in command:
+            result["gpu"][int(pid_text)] = int(rss_text) * 1024
+    return result
+
+
+class ProcessSampler:
+    def __init__(self, run_id: str) -> None:
+        self.run_id = run_id
+        self.started_at = time.time()
+        self.phase = "startup"
+        self.samples: list[dict] = []
+        self.stop_event = threading.Event()
+        self.thread = threading.Thread(target=self._run, daemon=True)
+        self.thread.start()
+
+    def _run(self) -> None:
+        while not self.stop_event.is_set():
+            try:
+                self.samples.append(
+                    {"time": time.time(), "phase": self.phase, **process_rss()}
+                )
+            except Exception as error:  # diagnostic sampling must not break OCR
+                self.samples.append({"time": time.time(), "error": str(error)})
+            self.stop_event.wait(0.05)
+
+    def mark(self, phase: str) -> None:
+        self.phase = phase
+
+    def finish(self) -> dict:
+        self.stop_event.set()
+        self.thread.join(timeout=2)
+        usable = [sample for sample in self.samples if "renderer" in sample]
+        if not usable:
+            return {"samples": len(self.samples), "error": "no usable process samples"}
+        baseline = usable[0]
+
+        def summarize(kind: str) -> dict:
+            baseline_by_pid = baseline[kind]
+            peak_by_pid: dict[int, int] = {}
+            first_by_pid: dict[int, int] = dict(baseline_by_pid)
+            for sample in usable:
+                for pid, rss in sample[kind].items():
+                    first_by_pid.setdefault(pid, rss)
+                    peak_by_pid[pid] = max(peak_by_pid.get(pid, 0), rss)
+            deltas = {
+                pid: peak - first_by_pid.get(pid, peak)
+                for pid, peak in peak_by_pid.items()
+            }
+            selected_pid = max(deltas, key=deltas.get) if deltas else None
+            phases: dict[str, dict[str, int]] = {}
+            if selected_pid:
+                for sample in usable:
+                    rss = sample[kind].get(selected_pid)
+                    if rss is None:
+                        continue
+                    phase = sample.get("phase", "unknown")
+                    phase_summary = phases.setdefault(
+                        phase,
+                        {"startBytes": rss, "endBytes": rss, "peakBytes": rss},
+                    )
+                    phase_summary["endBytes"] = rss
+                    phase_summary["peakBytes"] = max(phase_summary["peakBytes"], rss)
+                for phase_summary in phases.values():
+                    phase_summary["peakDeltaBytes"] = (
+                        phase_summary["peakBytes"] - phase_summary["startBytes"]
+                    )
+            return {
+                "selectedPid": selected_pid,
+                "baselineBytes": first_by_pid.get(selected_pid, 0) if selected_pid else 0,
+                "peakBytes": peak_by_pid.get(selected_pid, 0) if selected_pid else 0,
+                "peakDeltaBytes": deltas.get(selected_pid, 0) if selected_pid else 0,
+                "allPeakDeltas": deltas,
+                "phases": phases,
+            }
+
+        return {
+            "scope": "T3 renderer with largest RSS delta plus shared T3 GPU process",
+            "samples": len(usable),
+            "durationSeconds": time.time() - self.started_at,
+            "renderer": summarize("renderer"),
+            "gpu": summarize("gpu"),
+        }
+
+
+active_sampler: ProcessSampler | None = None
+sampler_lock = threading.Lock()
+
+
+class Handler(SimpleHTTPRequestHandler):
+    def do_POST(self) -> None:
+        global active_sampler
+        length = int(self.headers.get("Content-Length", "0"))
+        if length <= 0 or length > 2_000_000:
+            self.send_error(400, "invalid request size")
+            return
+        payload = json.loads(self.rfile.read(length))
+        if self.path == "/benchmark-start":
+            run_id = str(payload.get("runId", ""))
+            if not run_id or "/" in run_id or ".." in run_id:
+                self.send_error(400, "invalid run id")
+                return
+            with sampler_lock:
+                if active_sampler:
+                    active_sampler.finish()
+                active_sampler = ProcessSampler(run_id)
+            self.send_response(204)
+            self.end_headers()
+            return
+        if self.path == "/benchmark-mark":
+            run_id = str(payload.get("runId", ""))
+            phase = str(payload.get("phase", ""))
+            if not phase or len(phase) > 80:
+                self.send_error(400, "invalid benchmark phase")
+                return
+            with sampler_lock:
+                sampler = active_sampler
+                if not sampler or sampler.run_id != run_id:
+                    self.send_error(409, "benchmark sampler mismatch")
+                    return
+                sampler.mark(phase)
+            self.send_response(204)
+            self.end_headers()
+            return
+        if self.path == "/benchmark-result":
+            run_id = str(payload.get("runId", ""))
+            with sampler_lock:
+                sampler = active_sampler
+                active_sampler = None
+            if not sampler or sampler.run_id != run_id:
+                self.send_error(409, "benchmark sampler mismatch")
+                return
+            payload["processMemory"] = sampler.finish()
+            RESULTS.mkdir(parents=True, exist_ok=True)
+            destination = RESULTS / f"{run_id}.json"
+            destination.write_text(
+                json.dumps(payload, ensure_ascii=False, indent=2) + "\n",
+                encoding="utf-8",
+            )
+            response = json.dumps(payload["processMemory"]).encode()
+            self.send_response(200)
+            self.send_header("Content-Type", "application/json")
+            self.send_header("Content-Length", str(len(response)))
+            self.end_headers()
+            self.wfile.write(response)
+            return
+        self.send_error(404)
+
+    def end_headers(self) -> None:
+        self.send_header("Cross-Origin-Opener-Policy", "same-origin")
+        self.send_header("Cross-Origin-Embedder-Policy", "require-corp")
+        self.send_header("Cross-Origin-Resource-Policy", "same-origin")
+        self.send_header("Cache-Control", "no-store")
+        super().end_headers()
+
+
+if __name__ == "__main__":
+    ThreadingHTTPServer(("127.0.0.1", 8765), Handler).serve_forever()

summarize_memory_results.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+import json
+import statistics
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parent
+RESULTS = ROOT / ".work" / "results"
+MIB = 1024 * 1024
+
+
+def is_worker_staged(result: dict) -> bool:
+    return (
+        # Model-execution A/B runs use their own phase-level report. Keep this
+        # runtime-only summary on the original fixed cohort without a decoder
+        # query so later candidate measurements cannot silently change it.
+        result.get("decoderMode") is None
+        and result.get("benchmarkScope") in (None, "full")
+        and any(
+            sample.get("label") == "vision-worker-session-ready"
+            for sample in result.get("memorySamples", [])
+        )
+    )
+
+
+def is_resident_control(result: dict) -> bool:
+    return (
+        result.get("memoryMode") == "default"
+        and result.get("loaderMode") == "bytes"
+        and not is_worker_staged(result)
+        and result.get("scheduleMode", "resident") == "resident"
+    )
+
+
+def median(rows: list[dict], value) -> float:
+    return statistics.median(value(row) for row in rows)
+
+
+def main() -> None:
+    loaded = [json.loads(path.read_text(encoding="utf-8")) for path in RESULTS.glob("*.json")]
+    for tier in ("121", "242"):
+        controls = [row for row in loaded if row.get("tier") == tier and is_resident_control(row)]
+        staged = [row for row in loaded if row.get("tier") == tier and is_worker_staged(row)]
+        if not controls or not staged:
+            print(f"tier {tier}: missing control or worker-staged results")
+            continue
+        control_outputs = [item["actual"] for item in controls[0]["results"]]
+        if any([item["actual"] for item in row["results"]] != control_outputs for row in staged):
+            raise RuntimeError(f"tier {tier}: optimized OCR output differs from control")
+
+        control_renderer = median(
+            controls, lambda row: row["processMemory"]["renderer"]["peakDeltaBytes"] / MIB
+        )
+        staged_renderer = median(
+            staged, lambda row: row["processMemory"]["renderer"]["peakDeltaBytes"] / MIB
+        )
+        control_heap = median(
+            controls,
+            lambda row: max(sample.get("usedJSHeapSize", 0) for sample in row["memorySamples"]) / MIB,
+        )
+        staged_heap = median(
+            staged,
+            lambda row: max(sample.get("usedJSHeapSize", 0) for sample in row["memorySamples"]) / MIB,
+        )
+        print(
+            f"tier {tier}: parity=PASS controls={len(controls)} staged={len(staged)} "
+            f"renderer={control_renderer:.1f}->{staged_renderer:.1f} MiB "
+            f"({(staged_renderer / control_renderer - 1) * 100:+.1f}%), "
+            f"js_heap={control_heap:.1f}->{staged_heap:.1f} MiB "
+            f"({(staged_heap / control_heap - 1) * 100:+.1f}%)"
+        )
+
+
+if __name__ == "__main__":
+    main()

variants/webgpu-121/decoder_unified_gather_qdq_int8.onnx

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:3612d5787ffb1026ae09bfd4a16b3379ea75fe0dd803484f7bb41645be6b6239
-size 34647907
+oid sha256:53778e5b50d78ee55c8674d3d19f53de14da808bd1c231a9d4cebd5d44d3ad93
+size 34647902

variants/webgpu-242/decoder_unified_gather_qdq_int8.onnx

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:3612d5787ffb1026ae09bfd4a16b3379ea75fe0dd803484f7bb41645be6b6239
-size 34647907
+oid sha256:53778e5b50d78ee55c8674d3d19f53de14da808bd1c231a9d4cebd5d44d3ad93
+size 34647902

vision-worker.mjs

@@ -0,0 +1,57 @@
+import * as ort from "./.work/ort/ort-webgpu.mjs";
+
+let session = null;
+let device = null;
+
+const reply = (requestId, payload, transfer = []) => postMessage({ requestId, payload }, transfer);
+const fail = (requestId, error) => postMessage({ requestId, error: error?.stack ?? String(error) });
+
+self.onmessage = async ({ data }) => {
+	const { requestId, type, payload } = data;
+	try {
+		if (type === "init") {
+			ort.env.wasm.numThreads = 1;
+			ort.env.wasm.wasmPaths = payload.wasmPaths;
+			const adapter = await navigator.gpu.requestAdapter({ powerPreference: "high-performance" });
+			if (!adapter) throw new Error("No WebGPU adapter is available in the vision worker");
+			device = await adapter.requestDevice();
+			ort.env.webgpu.device = device;
+			const options = {
+				executionProviders: ["webgpu"],
+				preferredOutputLocation: { vision_embeds: "cpu" },
+				logSeverityLevel: 3,
+				...(payload.lean ? { enableCpuMemArena: false, enableMemPattern: false } : {}),
+			};
+			session = await ort.InferenceSession.create(payload.modelPath, options);
+			if (JSON.stringify(session.inputNames) !== JSON.stringify(["pixel_values"])) {
+				throw new Error(`Unexpected vision inputs ${session.inputNames}`);
+			}
+			reply(requestId, { ready: true });
+			return;
+		}
+		if (type === "encode") {
+			if (!session) throw new Error("Vision worker is not initialized");
+			const pixels = new ort.Tensor("float32", payload.pixels, [1, 3, 224, 224]);
+			const started = performance.now();
+			const result = await session.run({ pixel_values: pixels });
+			const visionMs = performance.now() - started;
+			pixels.dispose();
+			const values = new Float32Array(result.vision_embeds.data);
+			const dims = [...result.vision_embeds.dims];
+			result.vision_embeds.dispose();
+			reply(requestId, { values, dims, visionMs }, [values.buffer]);
+			return;
+		}
+		if (type === "close") {
+			if (session) await session.release();
+			session = null;
+			if (device) device.destroy();
+			device = null;
+			reply(requestId, { closed: true });
+			return;
+		}
+		throw new Error(`Unknown worker operation ${type}`);
+	} catch (error) {
+		fail(requestId, error);
+	}
+};

webgpu-memory-opt.html

@@ -0,0 +1,446 @@
+<!doctype html>
+<meta charset="utf-8" />
+<title>Baberu capability-preserving WebGPU memory experiment</title>
+<style>
+	body { background: #111; color: #eee; font: 14px/1.45 ui-monospace, monospace; margin: 24px; }
+	pre { white-space: pre-wrap; }
+</style>
+<h1>Baberu capability-preserving WebGPU memory experiment</h1>
+<pre id="log">Starting…</pre>
+<canvas id="canvas" width="224" height="224" hidden></canvas>
+<script type="module">
+	const parameters = new URLSearchParams(location.search);
+	const tier = parameters.get("tier") ?? "121";
+	const memoryMode = parameters.get("memory") ?? "lean";
+	const loaderMode = parameters.get("loader") ?? "url";
+	const scheduleMode = parameters.get("schedule") ?? "staged";
+	const decoderMode = parameters.get("decoder") ?? "baseline";
+	const benchmarkScope = parameters.get("scope") ?? "full";
+	const decoderOnly = benchmarkScope === "decoder";
+	const maxTokens = 128;
+	if (!new Set(["121", "242"]).has(tier)) throw new Error(`Unknown tier ${tier}`);
+	if (!new Set(["default", "lean"]).has(memoryMode)) throw new Error(`Unknown memory mode ${memoryMode}`);
+	if (!new Set(["url", "bytes"]).has(loaderMode)) throw new Error(`Unknown loader ${loaderMode}`);
+	if (!new Set(["resident", "staged"]).has(scheduleMode)) throw new Error(`Unknown schedule ${scheduleMode}`);
+	if (!new Set(["baseline", "gather-opt", "fp16-matmul", "fixed-kv"]).has(decoderMode)) throw new Error(`Unknown decoder ${decoderMode}`);
+	if (!new Set(["full", "decoder"]).has(benchmarkScope)) throw new Error(`Unknown scope ${benchmarkScope}`);
+	const ort = await import("./.work/ort/ort-webgpu.mjs");
+	const output = document.querySelector("#log");
+	const canvas = document.querySelector("#canvas");
+	const context = canvas.getContext("2d", { willReadFrequently: true });
+	const logLines = [];
+	const memorySamples = [];
+	const log = (message) => {
+		logLines.push(`${new Date().toISOString()} ${message}`);
+		output.textContent = logLines.join("\n");
+		console.log(message);
+	};
+	window.addEventListener("error", (event) => log(`FAIL ${event.error?.stack ?? event.message}`));
+	window.addEventListener("unhandledrejection", (event) => log(`FAIL ${event.reason?.stack ?? event.reason}`));
+	const sampleMemory = async (label) => {
+		const sample = { label, atMs: performance.now() };
+		if (performance.memory) {
+			sample.jsHeapSizeLimit = performance.memory.jsHeapSizeLimit;
+			sample.totalJSHeapSize = performance.memory.totalJSHeapSize;
+			sample.usedJSHeapSize = performance.memory.usedJSHeapSize;
+		}
+		if (typeof performance.measureUserAgentSpecificMemory === "function") {
+			try {
+				sample.userAgentBytes = (await performance.measureUserAgentSpecificMemory()).bytes;
+			} catch (error) {
+				sample.userAgentMemoryError = String(error);
+			}
+		}
+		memorySamples.push(sample);
+		log(`MEMORY ${JSON.stringify(sample)}`);
+		return sample;
+	};
+	const runId = `tier-${tier}-${memoryMode}-${loaderMode}-${scheduleMode}-${decoderMode}-${benchmarkScope}-${Date.now()}`;
+	await fetch("/benchmark-start", {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({ runId }),
+	});
+	const markPhase = async (phase) => {
+		const response = await fetch("/benchmark-mark", {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ runId, phase }),
+		});
+		if (!response.ok) throw new Error(`Failed marking ${phase}: HTTP ${response.status}`);
+	};
+	await markPhase("baseline");
+	await sampleMemory("baseline");
+
+	ort.env.wasm.numThreads = 1;
+	ort.env.wasm.wasmPaths = "/.work/ort/";
+	if (!navigator.gpu) throw new Error("WebGPU is unavailable");
+	let gpuDevice = null;
+	const ensureMainDevice = async () => {
+		if (gpuDevice) return;
+		const adapter = await navigator.gpu.requestAdapter({ powerPreference: "high-performance" });
+		if (!adapter) throw new Error("No WebGPU adapter is available");
+		gpuDevice = await adapter.requestDevice();
+		ort.env.webgpu.device = gpuDevice;
+	};
+	const cacheNames = [
+		...Array.from({ length: 6 }, (_, index) => `present_k${index}`),
+		...Array.from({ length: 6 }, (_, index) => `present_v${index}`),
+	];
+	const createSession = async (path, preferredOutputLocation) => {
+		await ensureMainDevice();
+		const options = {
+			executionProviders: ["webgpu"],
+			preferredOutputLocation,
+			logSeverityLevel: 3,
+			...(memoryMode === "lean" ? { enableCpuMemArena: false, enableMemPattern: false } : {}),
+		};
+		const started = performance.now();
+		const session = loaderMode === "url"
+			? await ort.InferenceSession.create(path, options)
+			: await fetch(path).then(async (response) => {
+				if (!response.ok) throw new Error(`${path}: HTTP ${response.status}`);
+				return ort.InferenceSession.create(new Uint8Array(await response.arrayBuffer()), options);
+			});
+		log(`SESSION ${path} ${(performance.now() - started).toFixed(1)} ms`);
+		return session;
+	};
+	const visionPath = tier === "121"
+		? "./.work/models/webgpu-121/vision_int4.onnx"
+		: "./.work/models/webgpu-242/vision_fp16.onnx";
+	const fixedKv = decoderMode === "fixed-kv";
+	const decoderPath = ({
+		baseline: "./.work/models/shared/decoder_unified_gather_qdq_int8.onnx",
+		"gather-opt": "./.work/models/model-opt/decoder_gather_before_dq_int8.onnx",
+		"fp16-matmul": "./.work/models/model-opt/decoder_static_fp16_matmul.onnx",
+		"fixed-kv": "./.work/models/model-opt/decoder_gather_dq_fixed_kv_int8.onnx",
+	})[decoderMode];
+	let vision = null;
+	let decoder = null;
+	const createVision = async () => {
+		vision = await createSession(visionPath, scheduleMode === "staged" ? { vision_embeds: "cpu" } : { vision_embeds: "gpu-buffer" });
+		if (JSON.stringify(vision.inputNames) !== JSON.stringify(["pixel_values"])) {
+			throw new Error(`Unexpected vision inputs ${vision.inputNames}`);
+		}
+		await sampleMemory("vision-session-ready");
+	};
+	const createDecoder = async () => {
+		decoder = await createSession(decoderPath, Object.fromEntries([
+			["logits", "cpu"],
+			...cacheNames.map((name) => [name, "gpu-buffer"]),
+		]));
+		for (const required of ["vision_embeds", "token_ids", "position_ids", "past_k0", "past_v5"]) {
+			if (!decoder.inputNames.includes(required)) throw new Error(`Decoder input missing ${required}`);
+		}
+		if (fixedKv !== decoder.inputNames.includes("past_length")) {
+			throw new Error(`Decoder past_length contract mismatch for ${decoderMode}`);
+		}
+		if (!decoder.outputNames.includes("logits") || !decoder.outputNames.includes("present_v5")) {
+			throw new Error("Decoder capability outputs are incomplete");
+		}
+		await sampleMemory("decoder-session-ready");
+	};
+	if (scheduleMode === "resident" && !decoderOnly) {
+		await markPhase("vision-load");
+		await createVision();
+		await markPhase("decoder-load");
+		await createDecoder();
+	}
+	if (decoderOnly) {
+		await markPhase("decoder-load");
+		await createDecoder();
+	}
+
+	const charset = await (await fetch("./tokenizer/vocab.json")).json();
+	const idToCharacter = ["", "", "", "", ...charset];
+	if (idToCharacter.length !== 14630) throw new Error(`Unexpected vocabulary ${idToCharacter.length}`);
+	const contentIds = new Set();
+	for (let index = 0; index < charset.length; index += 1) {
+		const character = charset[index];
+		if (character.length === 1 && !"ーｰ〜~".includes(character) && /[\p{Letter}\p{Number}]/u.test(character)) {
+			contentIds.add(index + 4);
+		}
+	}
+	const loadImage = async (path) => createImageBitmap(await (await fetch(path)).blob());
+	const preprocess = (image) => {
+		context.imageSmoothingEnabled = true;
+		context.imageSmoothingQuality = "high";
+		context.clearRect(0, 0, 224, 224);
+		context.drawImage(image, 0, 0, image.width, image.height, 0, 0, 224, 224);
+		const rgba = context.getImageData(0, 0, 224, 224).data;
+		const values = new Float32Array(3 * 224 * 224);
+		const mean = [0.485, 0.456, 0.406];
+		const std = [0.229, 0.224, 0.225];
+		for (let pixel = 0; pixel < 224 * 224; pixel += 1) {
+			for (let channel = 0; channel < 3; channel += 1) {
+				values[channel * 224 * 224 + pixel] = (rgba[pixel * 4 + channel] / 255 - mean[channel]) / std[channel];
+			}
+		}
+		return values;
+	};
+	const tokenId = (token) => new ort.Tensor("int32", Int32Array.of(token), [1, 1]);
+	const emptyVision = () => new ort.Tensor("float32", new Float32Array(0), [1, 0, 512]);
+	const emptyCache = () => fixedKv
+		? new ort.Tensor("float32", new Float32Array(1 * 2 * 384 * 64), [1, 2, 384, 64])
+		: new ort.Tensor("float32", new Float32Array(0), [1, 2, 0, 64]);
+	const pastLength = (length) => new ort.Tensor("int64", BigInt64Array.of(BigInt(length)), [1]);
+	const positions = () => new ort.Tensor("int32", Int32Array.from({ length: 257 }, (_, index) => index), [1, 257]);
+	const disposeResult = (result) => {
+		result.logits?.dispose();
+		for (const name of cacheNames) result[name]?.dispose();
+	};
+	const chooseToken = (source, sequence, tokens) => {
+		const seen = new Set(sequence);
+		let blocked = -1;
+		const last = tokens.at(-1);
+		if (last !== undefined && contentIds.has(last)) {
+			let run = 0;
+			for (let index = tokens.length - 1; index >= 0 && tokens[index] === last; index -= 1) run += 1;
+			if (run >= 12) blocked = last;
+		}
+		const adjusted = (index) => {
+			if (index === blocked) return Number.NEGATIVE_INFINITY;
+			const value = source[index];
+			if (!seen.has(index)) return value;
+			return value < 0 ? value * 1.2 : value / 1.2;
+		};
+		let bestToken = 0;
+		let bestValue = adjusted(0);
+		for (let token = 1; token < 14630; token += 1) {
+			const value = adjusted(token);
+			if (value > bestValue) {
+				bestToken = token;
+				bestValue = value;
+			}
+		}
+		return bestToken;
+	};
+	const encode = async (image) => {
+		const pixels = new ort.Tensor("float32", preprocess(image), [1, 3, 224, 224]);
+		const visionStarted = performance.now();
+		const visionResult = await vision.run({ pixel_values: pixels });
+		const visionMs = performance.now() - visionStarted;
+		pixels.dispose();
+		return { visionEmbeds: visionResult.vision_embeds, visionMs };
+	};
+	const decode = async (visionEmbeds, visionMs) => {
+		const started = performance.now();
+		const prefillFeeds = {
+			vision_embeds: visionEmbeds,
+			token_ids: tokenId(1),
+			position_ids: positions(),
+			...Object.fromEntries(cacheNames.map((name) => [name.replace("present_", "past_"), emptyCache()])),
+		};
+		if (fixedKv) prefillFeeds.past_length = pastLength(0);
+		const prefillStarted = performance.now();
+		let cacheResult = await decoder.run(prefillFeeds);
+		const prefillMs = performance.now() - prefillStarted;
+		visionEmbeds.dispose();
+		for (const [name, tensor] of Object.entries(prefillFeeds)) if (name !== "vision_embeds") tensor.dispose();
+		const sequence = [1];
+		const tokens = [];
+		const decodeStarted = performance.now();
+		for (let iteration = 0; iteration < maxTokens; iteration += 1) {
+			// Decoder-only memory runs force a stable non-EOS token so every graph
+			// executes the complete 128-token cache path.
+			const next = decoderOnly ? 4 : chooseToken(cacheResult.logits.data, sequence, tokens);
+			if (next === 2) break;
+			tokens.push(next);
+			sequence.push(next);
+			if (tokens.length >= maxTokens) break;
+			const feeds = {
+				vision_embeds: emptyVision(),
+				token_ids: tokenId(next),
+				position_ids: new ort.Tensor("int32", Int32Array.of(257 + iteration), [1, 1]),
+			};
+			if (fixedKv) feeds.past_length = pastLength(257 + iteration);
+			for (let layer = 0; layer < 6; layer += 1) {
+				feeds[`past_k${layer}`] = cacheResult[`present_k${layer}`];
+				feeds[`past_v${layer}`] = cacheResult[`present_v${layer}`];
+			}
+			const nextResult = await decoder.run(feeds);
+			disposeResult(cacheResult);
+			feeds.vision_embeds.dispose();
+			feeds.token_ids.dispose();
+			feeds.position_ids.dispose();
+			feeds.past_length?.dispose();
+			cacheResult = nextResult;
+		}
+		const decodeMs = performance.now() - decodeStarted;
+		disposeResult(cacheResult);
+		return {
+			text: tokens.map((token) => idToCharacter[token] ?? "").join(""),
+			tokens: tokens.length,
+			visionMs,
+			prefillMs,
+			decodeMs,
+			totalMs: visionMs + performance.now() - started,
+		};
+	};
+	const recognize = async (image) => {
+		const encoded = await encode(image);
+		return decode(encoded.visionEmbeds, encoded.visionMs);
+	};
+	const expected = [
+		["01", "知らない世界で見つけたイメージを"],
+		["02", "カナデトモスソラ（Ｋａｎａｄｅｔｏｍｏｓｕｓｏｒａ）"],
+		["03", "建設会社社員行方"],
+		["04", "だとしてもこのレベルがウロつくなんて．．．おそらく２級の呪い"],
+		["05", "パチパチパチパチ"],
+		["06", "バビュン"],
+		["07", "僕の過去とか未来とか"],
+		["08", "くらべられっ子"],
+		["09", "そうだクラス分けがあるんだった！！"],
+		["10", "脇役よ、主役を超えよ！"],
+		["11", "Ｅｈ～Ｉｄｏｎ＇ｔｒｅａｌｌｙｗａｎｔｔｏ～"],
+		["12", "「Ｓｏｒｒｙｆｏｒｔｈｅｗａｉｔ～！Ｄｉｄｙｏｕｗａｉｔｌｏｎｇ？」"],
+		["13", "ＹａｍａｔｅＡｒｅａＮｅｗｒｅｓｉｄｅｎｔｉａｌｄｉｓｔｒｉｃｔｆｏｒｆｏｒｅｉｇｎｅｒｓ"],
+	];
+	const normalize = (text) => text.normalize("NFKC").replace(/\s+/g, "");
+	const editDistance = (left, right) => {
+		let previous = Array.from({ length: right.length + 1 }, (_, index) => index);
+		for (let leftIndex = 1; leftIndex <= left.length; leftIndex += 1) {
+			const current = [leftIndex];
+			for (let rightIndex = 1; rightIndex <= right.length; rightIndex += 1) {
+				current.push(Math.min(
+					current[rightIndex - 1] + 1,
+					previous[rightIndex] + 1,
+					previous[rightIndex - 1] + (left[leftIndex - 1] === right[rightIndex - 1] ? 0 : 1),
+				));
+			}
+			previous = current;
+		}
+		return previous.at(-1);
+	};
+	const stagedInputs = [];
+	if (scheduleMode === "staged" && !decoderOnly) {
+		await markPhase("vision-load");
+		const visionWorker = new Worker("./vision-worker.mjs", { type: "module" });
+		let workerRequestId = 0;
+		const workerCalls = new Map();
+		visionWorker.onmessage = ({ data }) => {
+			const call = workerCalls.get(data.requestId);
+			if (!call) return;
+			workerCalls.delete(data.requestId);
+			if (data.error) call.reject(new Error(data.error));
+			else call.resolve(data.payload);
+		};
+		visionWorker.onerror = (event) => {
+			for (const call of workerCalls.values()) call.reject(event.error ?? new Error(event.message));
+			workerCalls.clear();
+		};
+		const callWorker = (type, payload, transfer = []) => new Promise((resolve, reject) => {
+			const requestId = ++workerRequestId;
+			workerCalls.set(requestId, { resolve, reject });
+			visionWorker.postMessage({ requestId, type, payload }, transfer);
+		});
+		await callWorker("init", {
+			modelPath: new URL(visionPath, location.href).href,
+			wasmPaths: new URL("./.work/ort/", location.href).href,
+			lean: memoryMode === "lean",
+		});
+		await sampleMemory("vision-worker-session-ready");
+		await markPhase("vision-encode");
+		for (const [id, expectedText] of expected) {
+			log(`ENCODE ${id}/13`);
+			const image = await loadImage(`./.work/hayai13/${id}.png`);
+			const pixels = preprocess(image);
+			image.close();
+			const encoded = await callWorker("encode", { pixels }, [pixels.buffer]);
+			stagedInputs.push({ id, expectedText, ...encoded });
+		}
+		await sampleMemory("all-vision-embeddings-ready");
+		await markPhase("vision-release");
+		await callWorker("close", {});
+		visionWorker.terminate();
+		await new Promise((resolve) => setTimeout(resolve, 100));
+		await sampleMemory("vision-worker-terminated");
+		await markPhase("decoder-load");
+		await createDecoder();
+	}
+	const benchmarkCases = decoderOnly ? [["synthetic", ""]] : expected;
+	const results = [];
+	await markPhase("decoder-run");
+	for (let caseIndex = 0; caseIndex < benchmarkCases.length; caseIndex += 1) {
+		const [id, expectedText] = benchmarkCases[caseIndex];
+		log(`CASE ${id}/${benchmarkCases.length}`);
+		let result;
+		if (decoderOnly) {
+			const visionEmbeds = new ort.Tensor("float32", new Float32Array(256 * 512), [1, 256, 512]);
+			result = await decode(visionEmbeds, 0);
+		} else if (scheduleMode === "staged") {
+			const staged = stagedInputs[caseIndex];
+			const visionEmbeds = new ort.Tensor("float32", staged.values, staged.dims);
+			result = await decode(visionEmbeds, staged.visionMs);
+		} else {
+			const image = await loadImage(`./.work/hayai13/${id}.png`);
+			result = await recognize(image);
+			image.close();
+		}
+		const normalizedExpected = normalize(expectedText);
+		const normalizedActual = normalize(result.text);
+		results.push({
+			id,
+			expected: expectedText,
+			actual: result.text,
+			distance: editDistance(normalizedExpected, normalizedActual),
+			characters: normalizedExpected.length,
+			exact: normalizedExpected === normalizedActual,
+			...result,
+		});
+		await sampleMemory(`after-case-${id}`);
+	}
+	const distance = results.reduce((sum, result) => sum + result.distance, 0);
+	const characters = results.reduce((sum, result) => sum + result.characters, 0);
+	const sortedTimes = results.map((result) => result.totalMs).sort((left, right) => left - right);
+	await markPhase("release");
+	if (vision) await vision.release();
+	if (decoder) await decoder.release();
+	if (gpuDevice) gpuDevice.destroy();
+	await new Promise((resolve) => setTimeout(resolve, 250));
+	await sampleMemory("released");
+	const summary = {
+		runId,
+		tier,
+		memoryMode,
+		loaderMode,
+		scheduleMode,
+		decoderMode,
+		benchmarkScope,
+		capability: {
+			layers: 6,
+			hiddenSize: 512,
+			intermediateSize: 1536,
+			attentionHeads: 8,
+			kvHeads: 2,
+			vocabulary: 14630,
+			maxTokens,
+			vision: tier === "121" ? "upstream INT4" : "upstream FP16",
+			decoder: ({
+				baseline: "complete INT8-QDQ unified Gather",
+				"gather-opt": "complete INT8-QDQ Gather-before-DQ",
+				"fp16-matmul": "layers 1-3 static FP16 MatMul with Gather-before-DQ embedding",
+				"fixed-kv": "complete INT8-QDQ Gather-before-DQ with fixed 384-slot KV I/O",
+			})[decoderMode],
+		},
+		cases: results.length,
+		nCER: characters ? distance / characters : null,
+		distance,
+		characters,
+		exact: results.filter((result) => result.exact).length,
+		medianMs: sortedTimes[Math.floor(sortedTimes.length / 2)],
+		peakCaseMs: sortedTimes.at(-1),
+		memorySamples,
+		results,
+	};
+	const response = await fetch("/benchmark-result", {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify(summary),
+	});
+	if (!response.ok) throw new Error(`Failed persisting result: HTTP ${response.status}`);
+	summary.processMemory = await response.json();
+	window.__benchmarkResult = summary;
+	window.__benchmarkDone = true;
+	log(`SUITE_RESULT ${JSON.stringify(summary)}`);
+</script>