Publish RGB realtime UI video x2 model and corrected evidence

.gitattributes

@@ -33,3 +33,7 @@ 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
+examples/product-demo-1-before-after.png filter=lfs diff=lfs merge=lfs -text
+examples/product-demo-2-before-after.png filter=lfs diff=lfs merge=lfs -text
+examples/product-demo-3-before-after.png filter=lfs diff=lfs merge=lfs -text
+examples/product-demo-before-after.png filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [2021] [SwinIR Authors]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -0,0 +1,94 @@
+---
+license: apache-2.0
+library_name: custom
+pipeline_tag: image-to-image
+tags:
+  - super-resolution
+  - video
+  - webgpu
+  - browser
+  - product-demo
+  - ui
+---
+
+# Clark Realtime UI Video Upscaler x2
+
+A 16.6 KiB RGB x2 super-resolution model for product-demo screenshots and video. It is designed for UI edges, small text, buttons, panels, and code—not portraits or generative detail.
+
+The browser artifact has 8,496 parameters and runs as three fused FP16 WebGPU residual blocks. BackdropKit uses it locally for eligible video previews and exports, with ordinary high-quality browser scaling as the automatic fallback when `shader-f16` WebGPU is unavailable.
+
+## Before and after
+
+![Actual low-resolution input, bicubic x2, and Clark realtime x2](examples/product-demo-before-after.png)
+
+The left column is the actual low-resolution source before either scaler is applied. The middle and right columns both start from that exact source. A held-out high-resolution frame is used only for PSNR measurement; it is not shown or mislabeled as the input.
+
+On three fixed frames from real Clark product-demo videos:
+
+| Measure | Bicubic x2 | Clark x2 | Gain |
+|---|---:|---:|---:|
+| RGB PSNR | 32.307 dB | 33.570 dB | +1.263 dB |
+| Edge PSNR | 30.476 dB | 31.666 dB | +1.191 dB |
+
+Frame timestamps and deterministic crop coordinates are in `technical/example-evaluation.json`. Crops are selected by reference edge density only, never by model score.
+
+## Model
+
+- Input: even-sized RGB image or video frame
+- Output: RGB at 2x width and height
+- Working grid: 2x RGB pixel-unshuffle
+- Body: 12 channels, 3 residual blocks, 2 convolutions per block
+- Output: 4x pixel-shuffle from the half-resolution working grid
+- Browser weights: FP16, 16,992 bytes
+- Browser SHA-256: `c6b4f22d8c38270225b809e97d233eb68d7a48eef17595ac17a60b4540c72dce`
+- Safetensors: 34,712 bytes
+
+Training used 206,232 product, UI, and multilingual text images, with 268 held-out images. The RGB refinement ran for 5,000 steps from an exactly equivalent luma initialization.
+
+## Measured browser performance
+
+On an Apple M5 in Chrome 150 WebGPU, 1920x1080 to 3840x2160:
+
+- Neural render: 8.9 ms median, 10.6 ms p95 over 120 measured frames
+- Neural render plus H.264 enqueue: 9.4 ms median, 11.0 ms p95
+- H.264: 120/120 output chunks, maximum queue 2, no encoder error
+
+These measurements show compute headroom; they are not a promise of 60 displayed or exported frames per second on every browser. Decode cadence, browser scheduling, GPU, thermals, encoder, and export composition remain platform-dependent. The full receipt is in `technical/runtime-receipt.json`.
+
+## Browser use
+
+Host `browser/model.bin`, `browser/realtimeVideoUpscaler.js`, and `browser/runtimeCapabilities.js` together. Then pass the hosted model URL explicitly:
+
+```js
+import {
+  createRealtimeVideoUpscaler,
+  REALTIME_VIDEO_MODEL,
+} from "./browser/realtimeVideoUpscaler.js";
+
+const runtime = await createRealtimeVideoUpscaler({
+  width: video.videoWidth,
+  height: video.videoHeight,
+  model: {
+    ...REALTIME_VIDEO_MODEL,
+    url: "./browser/model.bin",
+  },
+});
+
+const enhancedCanvas = await runtime?.enhance(video);
+// Draw enhancedCanvas into your composition or encoder.
+runtime?.destroy();
+```
+
+The fast neural path requires WebGPU plus `shader-f16`. Applications should preserve a standard canvas/video scaling path when those capabilities are absent.
+
+## Package contents
+
+- `browser/model.bin`: exact FP16 shader payload
+- `browser/model.json`: offsets, sizes, hash, and architecture ledger
+- `browser/realtimeVideoUpscaler.js`: fused browser runtime
+- `model.safetensors`: framework-friendly weights
+- `realtime_student.py`: PyTorch architecture
+- `examples/`: real product-demo comparisons
+- `technical/`: evaluation, runtime, and package receipts
+
+Built by Clark Labs for [BackdropKit](https://backdropkit.com/).

browser/model.bin

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

browser/model.json

@@ -0,0 +1,38 @@
+{
+  "format": "backdropkit-realtime-luma-student-f16-v1",
+  "channels": 12,
+  "blocks": 3,
+  "residual_scale": 1.0,
+  "color_mode": "rgb",
+  "parameters": 8496,
+  "bytes": 16992,
+  "tensors": {
+    "input_projection": {
+      "offset": 0,
+      "bytes": 288,
+      "elements": 144
+    },
+    "block_0": {
+      "offset": 288,
+      "bytes": 5184,
+      "elements": 2592
+    },
+    "block_1": {
+      "offset": 5472,
+      "bytes": 5184,
+      "elements": 2592
+    },
+    "block_2": {
+      "offset": 10656,
+      "bytes": 5184,
+      "elements": 2592
+    },
+    "output_projection": {
+      "offset": 15840,
+      "bytes": 1152,
+      "elements": 576
+    }
+  },
+  "sha256": "c6b4f22d8c38270225b809e97d233eb68d7a48eef17595ac17a60b4540c72dce",
+  "source_checkpoint_sha256": "3cbb8a3358bbeaa239c517f1171dbb7706c2d453c961d17a4e6166aefde8c692"
+}

browser/realtimeVideoUpscaler.js

@@ -0,0 +1,393 @@
+import { requestBestWebGpuAdapter } from "./runtimeCapabilities.js";
+
+export const REALTIME_VIDEO_MODEL = Object.freeze({
+  blocks: 3,
+  bytes: 16992,
+  channels: 12,
+  colorMode: "rgb",
+  id: "clark-realtime-ui-video-x2",
+  scale: 2,
+  sha256: "c6b4f22d8c38270225b809e97d233eb68d7a48eef17595ac17a60b4540c72dce",
+  url: "/models/clark-realtime-ui-video-x2/model.bin?v=c6b4f22d",
+});
+
+export function realtimeVideoIsEligible({ enabled = true, height, kind, width }) {
+  return Boolean(
+    enabled
+    && kind === "video"
+    && Number(width) >= 64
+    && Number(height) >= 64
+    && width <= 1920
+    && height <= 1080
+    && width % 2 === 0
+    && height % 2 === 0
+  );
+}
+
+async function digestHex(bytes) {
+  if (!globalThis.crypto?.subtle) return null;
+  const digest = await crypto.subtle.digest("SHA-256", bytes);
+  return [...new Uint8Array(digest)]
+    .map((value) => value.toString(16).padStart(2, "0"))
+    .join("");
+}
+
+async function loadModel(model) {
+  const response = await fetch(model.url, { cache: "force-cache" });
+  if (!response.ok) throw new Error("Realtime video model download failed");
+  const payload = await response.arrayBuffer();
+  if (payload.byteLength !== model.bytes) {
+    throw new Error("Realtime video model size check failed");
+  }
+  const hash = await digestHex(payload);
+  if (hash && hash !== model.sha256) {
+    throw new Error("Realtime video model identity check failed");
+  }
+  return payload;
+}
+
+function mappedBuffer(device, values, usage) {
+  const bytes = values instanceof ArrayBuffer
+    ? new Uint8Array(values)
+    : new Uint8Array(values.buffer, values.byteOffset, values.byteLength);
+  const buffer = device.createBuffer({
+    mappedAtCreation: true,
+    size: Math.ceil(bytes.byteLength / 4) * 4,
+    usage,
+  });
+  new Uint8Array(buffer.getMappedRange()).set(bytes);
+  buffer.unmap();
+  return buffer;
+}
+
+function modelBuffer(device, payload, offset, bytes) {
+  return mappedBuffer(
+    device,
+    new Uint8Array(payload, offset, bytes),
+    GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+  );
+}
+
+async function compiledModule(device, code) {
+  const module = device.createShaderModule({ code });
+  const compilation = await module.getCompilationInfo();
+  const errors = compilation.messages.filter((message) => message.type === "error");
+  if (errors.length) throw new Error(errors.map((message) => message.message).join("\n"));
+  return module;
+}
+
+function inputShader() {
+  return /* wgsl */ `
+    enable f16;
+    struct Dimensions { width: u32, height: u32, channels: u32, padding: u32 }
+    @group(0) @binding(0) var source: texture_external;
+    @group(0) @binding(1) var source_sampler: sampler;
+    @group(0) @binding(2) var<storage, read_write> output: array<f16>;
+    @group(0) @binding(3) var<storage, read> weights: array<f16>;
+    @group(0) @binding(4) var<uniform> dimensions: Dimensions;
+
+    @compute @workgroup_size(8, 8, 1)
+    fn main(@builtin(global_invocation_id) id: vec3<u32>) {
+      if (id.x >= dimensions.width || id.y >= dimensions.height) { return; }
+      let source_size = vec2<f32>(f32(dimensions.width * 2u), f32(dimensions.height * 2u));
+      let base = vec2<f32>(f32(id.x * 2u), f32(id.y * 2u));
+      let p0 = textureSampleBaseClampToEdge(source, source_sampler, (base + vec2<f32>(0.5, 0.5)) / source_size).rgb;
+      let p1 = textureSampleBaseClampToEdge(source, source_sampler, (base + vec2<f32>(1.5, 0.5)) / source_size).rgb;
+      let p2 = textureSampleBaseClampToEdge(source, source_sampler, (base + vec2<f32>(0.5, 1.5)) / source_size).rgb;
+      let p3 = textureSampleBaseClampToEdge(source, source_sampler, (base + vec2<f32>(1.5, 1.5)) / source_size).rgb;
+      let pixels = array<f32, 12>(
+        p0.r, p1.r, p2.r, p3.r,
+        p0.g, p1.g, p2.g, p3.g,
+        p0.b, p1.b, p2.b, p3.b,
+      );
+      for (var channel = 0u; channel < dimensions.channels; channel += 1u) {
+        let offset = channel * 12u;
+        var value = 0.0;
+        for (var input_channel = 0u; input_channel < 12u; input_channel += 1u) {
+          value += pixels[input_channel] * f32(weights[offset + input_channel]);
+        }
+        output[(id.y * dimensions.width + id.x) * dimensions.channels + channel] = f16(max(value, 0.0));
+      }
+    }
+  `;
+}
+
+function fusedShader(channels) {
+  const tile = 8;
+  const inputTile = tile + 4;
+  const intermediateTile = tile + 2;
+  const inputElements = inputTile * inputTile * channels;
+  const intermediateElements = intermediateTile * intermediateTile * channels;
+  const weightElements = 9 * channels * channels;
+  return /* wgsl */ `
+    enable f16;
+    struct Dimensions { width: u32, height: u32, channels: u32, padding: u32 }
+    @group(0) @binding(0) var<storage, read> input: array<f16>;
+    @group(0) @binding(1) var<storage, read> weights: array<f16>;
+    @group(0) @binding(2) var<storage, read_write> output: array<f16>;
+    @group(0) @binding(3) var<uniform> dimensions: Dimensions;
+    var<workgroup> input_tile: array<f16, ${inputElements}>;
+    var<workgroup> intermediate_tile: array<f16, ${intermediateElements}>;
+
+    fn input_index(x: u32, y: u32, channel: u32) -> u32 {
+      return (y * ${inputTile}u + x) * ${channels}u + channel;
+    }
+    fn intermediate_index(x: u32, y: u32, channel: u32) -> u32 {
+      return (y * ${intermediateTile}u + x) * ${channels}u + channel;
+    }
+    fn weight_index(output_channel: u32, kernel_x: u32, kernel_y: u32, input_channel: u32) -> u32 {
+      return ((output_channel * 3u + kernel_y) * 3u + kernel_x) * ${channels}u + input_channel;
+    }
+
+    @compute @workgroup_size(${tile}, ${tile}, 1)
+    fn main(
+      @builtin(workgroup_id) group: vec3<u32>,
+      @builtin(local_invocation_index) lane: u32,
+      @builtin(local_invocation_id) local: vec3<u32>,
+    ) {
+      let base_x = i32(group.x * ${tile}u);
+      let base_y = i32(group.y * ${tile}u);
+      for (var linear = lane; linear < ${inputElements}u; linear += ${tile * tile}u) {
+        let channel = linear % ${channels}u;
+        let pixel = linear / ${channels}u;
+        let tile_x = pixel % ${inputTile}u;
+        let tile_y = pixel / ${inputTile}u;
+        let source_x = base_x + i32(tile_x) - 2;
+        let source_y = base_y + i32(tile_y) - 2;
+        let inside = source_x >= 0 && source_y >= 0
+          && source_x < i32(dimensions.width) && source_y < i32(dimensions.height);
+        var value = 0.0h;
+        if (inside) {
+          value = input[(u32(source_y) * dimensions.width + u32(source_x)) * ${channels}u + channel];
+        }
+        input_tile[linear] = value;
+      }
+      workgroupBarrier();
+
+      for (var linear = lane; linear < ${intermediateElements}u; linear += ${tile * tile}u) {
+        let output_channel = linear % ${channels}u;
+        let pixel = linear / ${channels}u;
+        let tile_x = pixel % ${intermediateTile}u;
+        let tile_y = pixel / ${intermediateTile}u;
+        let output_x = base_x + i32(tile_x) - 1;
+        let output_y = base_y + i32(tile_y) - 1;
+        var sum = 0.0h;
+        if (output_x >= 0 && output_y >= 0
+          && output_x < i32(dimensions.width) && output_y < i32(dimensions.height)) {
+          for (var kernel_y = 0u; kernel_y < 3u; kernel_y += 1u) {
+            for (var kernel_x = 0u; kernel_x < 3u; kernel_x += 1u) {
+              for (var input_channel = 0u; input_channel < ${channels}u; input_channel += 1u) {
+                sum += input_tile[input_index(tile_x + kernel_x, tile_y + kernel_y, input_channel)]
+                  * weights[weight_index(output_channel, kernel_x, kernel_y, input_channel)];
+              }
+            }
+          }
+        }
+        intermediate_tile[linear] = max(sum, 0.0h);
+      }
+      workgroupBarrier();
+
+      let output_x = group.x * ${tile}u + local.x;
+      let output_y = group.y * ${tile}u + local.y;
+      if (output_x >= dimensions.width || output_y >= dimensions.height) { return; }
+      for (var output_channel = 0u; output_channel < ${channels}u; output_channel += 1u) {
+        var sum = 0.0h;
+        for (var kernel_y = 0u; kernel_y < 3u; kernel_y += 1u) {
+          for (var kernel_x = 0u; kernel_x < 3u; kernel_x += 1u) {
+            for (var input_channel = 0u; input_channel < ${channels}u; input_channel += 1u) {
+              sum += intermediate_tile[intermediate_index(local.x + kernel_x, local.y + kernel_y, input_channel)]
+                * weights[${weightElements}u + weight_index(output_channel, kernel_x, kernel_y, input_channel)];
+            }
+          }
+        }
+        let residual = input_tile[input_index(local.x + 2u, local.y + 2u, output_channel)];
+        output[(output_y * dimensions.width + output_x) * ${channels}u + output_channel] = max(sum + residual, 0.0h);
+      }
+    }
+  `;
+}
+
+function outputShader() {
+  return /* wgsl */ `
+    enable f16;
+    struct Dimensions { width: u32, height: u32, channels: u32, padding: u32 }
+    @group(0) @binding(0) var source: texture_external;
+    @group(0) @binding(1) var source_sampler: sampler;
+    @group(0) @binding(2) var<storage, read> features: array<f16>;
+    @group(0) @binding(3) var<storage, read> weights: array<f16>;
+    @group(0) @binding(4) var<uniform> dimensions: Dimensions;
+
+    @vertex
+    fn vertex_main(@builtin(vertex_index) index: u32) -> @builtin(position) vec4<f32> {
+      let position = array<vec2<f32>, 3>(
+        vec2<f32>(-1.0, -1.0), vec2<f32>(3.0, -1.0), vec2<f32>(-1.0, 3.0)
+      );
+      return vec4<f32>(position[index], 0.0, 1.0);
+    }
+
+    @fragment
+    fn fragment_main(@builtin(position) position: vec4<f32>) -> @location(0) vec4<f32> {
+      let output_pixel = vec2<u32>(position.xy);
+      let work_pixel = output_pixel / 4u;
+      let subpixel = (output_pixel.y % 4u) * 4u + output_pixel.x % 4u;
+      let feature_offset = (work_pixel.y * dimensions.width + work_pixel.x) * dimensions.channels;
+      var residual = vec3<f32>(0.0);
+      for (var color_channel = 0u; color_channel < 3u; color_channel += 1u) {
+        let weight_offset = (color_channel * 16u + subpixel) * dimensions.channels;
+        var correction = 0.0;
+        for (var channel = 0u; channel < dimensions.channels; channel += 1u) {
+          correction += f32(features[feature_offset + channel]) * f32(weights[weight_offset + channel]);
+        }
+        residual[color_channel] = correction;
+      }
+      let output_size = vec2<f32>(f32(dimensions.width * 4u), f32(dimensions.height * 4u));
+      let base = textureSampleBaseClampToEdge(source, source_sampler, position.xy / output_size).rgb;
+      return vec4<f32>(clamp(base + residual, vec3<f32>(0.0), vec3<f32>(1.0)), 1.0);
+    }
+  `;
+}
+
+export async function createRealtimeVideoUpscaler({
+  height,
+  model = REALTIME_VIDEO_MODEL,
+  width,
+}) {
+  if (!realtimeVideoIsEligible({ enabled: true, height, kind: "video", width })) return null;
+  const result = await requestBestWebGpuAdapter(globalThis.navigator?.gpu);
+  if (!result.adapter?.features?.has("shader-f16")) return null;
+  const device = await result.adapter.requestDevice({ requiredFeatures: ["shader-f16"] });
+  const contextCanvas = document.createElement("canvas");
+  contextCanvas.width = width * model.scale;
+  contextCanvas.height = height * model.scale;
+  const context = contextCanvas.getContext("webgpu");
+  if (!context) {
+    device.destroy?.();
+    return null;
+  }
+  const format = navigator.gpu.getPreferredCanvasFormat();
+  context.configure({ device, format, alphaMode: "opaque" });
+  const payload = await loadModel(model);
+  const workWidth = width / 2;
+  const workHeight = height / 2;
+  const channels = model.channels;
+  const featureBytes = workWidth * workHeight * channels * 2;
+  const featureUsage = GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST;
+  const first = device.createBuffer({ size: featureBytes, usage: featureUsage });
+  const second = device.createBuffer({ size: featureBytes, usage: featureUsage });
+  const dimensions = mappedBuffer(
+    device,
+    new Uint32Array([workWidth, workHeight, channels, 0]),
+    GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+  );
+  const inputWeights = modelBuffer(device, payload, 0, 288);
+  const blockWeights = [
+    modelBuffer(device, payload, 288, 5184),
+    modelBuffer(device, payload, 5472, 5184),
+    modelBuffer(device, payload, 10656, 5184),
+  ];
+  const outputWeights = modelBuffer(device, payload, 15840, 1152);
+  const [inputModule, convolutionModule, outputModule] = await Promise.all([
+    compiledModule(device, inputShader()),
+    compiledModule(device, fusedShader(channels)),
+    compiledModule(device, outputShader()),
+  ]);
+  const inputPipeline = await device.createComputePipelineAsync({
+    layout: "auto",
+    compute: { module: inputModule, entryPoint: "main" },
+  });
+  const convolutionPipeline = await device.createComputePipelineAsync({
+    layout: "auto",
+    compute: { module: convolutionModule, entryPoint: "main" },
+  });
+  const outputPipeline = await device.createRenderPipelineAsync({
+    layout: "auto",
+    vertex: { module: outputModule, entryPoint: "vertex_main" },
+    fragment: { module: outputModule, entryPoint: "fragment_main", targets: [{ format }] },
+    primitive: { topology: "triangle-list" },
+  });
+  const sampler = device.createSampler({ magFilter: "linear", minFilter: "linear" });
+  const convolutionGroups = blockWeights.map((weights, stage) => {
+    const source = stage & 1 ? second : first;
+    const target = stage & 1 ? first : second;
+    return device.createBindGroup({
+      layout: convolutionPipeline.getBindGroupLayout(0),
+      entries: [source, weights, target, dimensions].map((buffer, binding) => ({
+        binding,
+        resource: { buffer },
+      })),
+    });
+  });
+  let busy = false;
+  let destroyed = false;
+  let ready = false;
+  device.lost.then(() => { destroyed = true; }).catch(() => { destroyed = true; });
+
+  return {
+    backend: "webgpu-f16",
+    canvas: contextCanvas,
+    get ready() { return ready; },
+    destroy() {
+      destroyed = true;
+      for (const buffer of [first, second, dimensions, inputWeights, outputWeights, ...blockWeights]) {
+        buffer.destroy?.();
+      }
+      device.destroy?.();
+    },
+    async enhance(source) {
+      if (busy || destroyed || !source) return ready ? contextCanvas : null;
+      busy = true;
+      try {
+        const external = device.importExternalTexture({ source });
+        const inputGroup = device.createBindGroup({
+          layout: inputPipeline.getBindGroupLayout(0),
+          entries: [
+            { binding: 0, resource: external },
+            { binding: 1, resource: sampler },
+            { binding: 2, resource: { buffer: first } },
+            { binding: 3, resource: { buffer: inputWeights } },
+            { binding: 4, resource: { buffer: dimensions } },
+          ],
+        });
+        const outputGroup = device.createBindGroup({
+          layout: outputPipeline.getBindGroupLayout(0),
+          entries: [
+            { binding: 0, resource: external },
+            { binding: 1, resource: sampler },
+            { binding: 2, resource: { buffer: second } },
+            { binding: 3, resource: { buffer: outputWeights } },
+            { binding: 4, resource: { buffer: dimensions } },
+          ],
+        });
+        const command = device.createCommandEncoder();
+        const compute = command.beginComputePass();
+        compute.setPipeline(inputPipeline);
+        compute.setBindGroup(0, inputGroup);
+        compute.dispatchWorkgroups(Math.ceil(workWidth / 8), Math.ceil(workHeight / 8));
+        compute.setPipeline(convolutionPipeline);
+        for (const group of convolutionGroups) {
+          compute.setBindGroup(0, group);
+          compute.dispatchWorkgroups(Math.ceil(workWidth / 8), Math.ceil(workHeight / 8));
+        }
+        compute.end();
+        const render = command.beginRenderPass({
+          colorAttachments: [{
+            clearValue: { r: 0, g: 0, b: 0, a: 1 },
+            loadOp: "clear",
+            storeOp: "store",
+            view: context.getCurrentTexture().createView(),
+          }],
+        });
+        render.setPipeline(outputPipeline);
+        render.setBindGroup(0, outputGroup);
+        render.draw(3);
+        render.end();
+        device.queue.submit([command.finish()]);
+        await device.queue.onSubmittedWorkDone();
+        ready = true;
+        return contextCanvas;
+      } finally {
+        busy = false;
+      }
+    },
+  };
+}

browser/runtimeCapabilities.js

@@ -0,0 +1,106 @@
+const ADAPTER_ATTEMPTS = [
+  { mode: "default" },
+  { mode: "high-performance", options: { powerPreference: "high-performance" } },
+  { mode: "low-power", options: { powerPreference: "low-power" } },
+  { mode: "compatibility", options: { featureLevel: "compatibility" } },
+  {
+    mode: "compatibility-low-power",
+    options: { featureLevel: "compatibility", powerPreference: "low-power" },
+  },
+  {
+    mode: "software-fallback",
+    options: { featureLevel: "compatibility", forceFallbackAdapter: true },
+  },
+];
+
+let computeCapabilityPromise;
+
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+export async function requestBestWebGpuAdapter(gpu) {
+  if (typeof gpu?.requestAdapter !== "function") {
+    return { adapter: null, attempts: [], mode: null, reason: "api-unavailable" };
+  }
+
+  const attempts = [];
+  for (const attempt of ADAPTER_ATTEMPTS) {
+    let adapter;
+    try {
+      adapter = await gpu.requestAdapter(attempt.options);
+      if (!adapter) {
+        attempts.push({ mode: attempt.mode, result: "no-adapter" });
+        continue;
+      }
+      const device = await adapter.requestDevice();
+      device.destroy?.();
+      const readyAdapter = await gpu.requestAdapter(attempt.options);
+      if (!readyAdapter) {
+        attempts.push({ mode: attempt.mode, result: "adapter-refresh-failed" });
+        continue;
+      }
+      attempts.push({ mode: attempt.mode, result: "ready" });
+      return { adapter: readyAdapter, attempts, mode: attempt.mode, reason: "ready" };
+    } catch (error) {
+      attempts.push({
+        message: errorMessage(error),
+        mode: attempt.mode,
+        result: adapter ? "device-failed" : "adapter-failed",
+      });
+    }
+  }
+
+  const reason = attempts.some((attempt) => attempt.result === "device-failed")
+    ? "device-unavailable"
+    : "adapter-unavailable";
+  return { adapter: null, attempts, mode: null, reason };
+}
+
+export async function probeComputeCapability({
+  gpu = globalThis.navigator?.gpu,
+  secureContext = globalThis.isSecureContext,
+} = {}) {
+  if (secureContext === false) {
+    return {
+      backend: "wasm",
+      label: "CPU optimized",
+      mode: null,
+      reason: "insecure-context",
+      webGpu: false,
+    };
+  }
+
+  const result = await requestBestWebGpuAdapter(gpu);
+  return {
+    backend: result.adapter ? "webgpu" : "wasm",
+    label: result.adapter ? "GPU accelerated" : "CPU optimized",
+    mode: result.mode,
+    reason: result.reason,
+    webGpu: Boolean(result.adapter),
+  };
+}
+
+export function getComputeCapability() {
+  if (!computeCapabilityPromise) {
+    computeCapabilityPromise = probeComputeCapability().catch((error) => {
+      console.warn("Local GPU probe failed; continuing with browser CPU.", error);
+      return {
+        backend: "wasm",
+        label: "CPU optimized",
+        mode: null,
+        reason: "probe-error",
+        webGpu: false,
+      };
+    });
+  }
+  return computeCapabilityPromise;
+}
+
+export async function hasWebGpuAdapter() {
+  return (await getComputeCapability()).webGpu;
+}
+
+export function resetComputeCapability() {
+  computeCapabilityPromise = undefined;
+}

config.json

@@ -0,0 +1,13 @@
+{
+  "architectures": [
+    "RealtimeLumaStudent"
+  ],
+  "model_type": "clark_realtime_luma_x2",
+  "channels": 12,
+  "blocks": 3,
+  "color_mode": "rgb",
+  "scale": 2,
+  "parameters": 8496,
+  "browser_format": "backdropkit-realtime-luma-student-f16-v1",
+  "torch_dtype": "float32"
+}

model.safetensors

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

realtime_student.py

@@ -0,0 +1,170 @@
+"""Training and export contract for the BackdropKit realtime x2 video student."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+import numpy as np
+import torch
+from torch import nn
+from torch.nn import functional as F
+
+
+@dataclass(frozen=True)
+class RealtimeStudentConfig:
+    channels: int = 12
+    blocks: int = 3
+    residual_scale: float = 1.0
+    color_mode: str = "luma"
+
+    def validate(self) -> None:
+        if self.channels < 4:
+            raise ValueError("channels must be at least four")
+        if self.blocks < 1:
+            raise ValueError("blocks must be positive")
+        if self.color_mode not in {"luma", "rgb"}:
+            raise ValueError("color_mode must be luma or rgb")
+
+
+class ResidualBlock(nn.Module):
+    """Two bias-free convolutions matching one fused WGSL dispatch."""
+
+    def __init__(self, channels: int) -> None:
+        super().__init__()
+        self.first = nn.Conv2d(channels, channels, 3, padding=1, bias=False)
+        self.second = nn.Conv2d(channels, channels, 3, padding=1, bias=False)
+
+    def forward(self, values: torch.Tensor) -> torch.Tensor:
+        hidden = F.relu(self.first(values))
+        return F.relu(self.second(hidden) + values)
+
+
+class RealtimeLumaStudent(nn.Module):
+    """A roughly 8K-parameter luma residual model for browser 1080p to 4K."""
+
+    def __init__(self, config: RealtimeStudentConfig | None = None) -> None:
+        super().__init__()
+        self.config = config or RealtimeStudentConfig()
+        self.config.validate()
+        channels = self.config.channels
+        input_channels = 4 if self.config.color_mode == "luma" else 12
+        output_channels = 16 if self.config.color_mode == "luma" else 48
+        self.input_projection = nn.Conv2d(input_channels, channels, 1, bias=False)
+        self.blocks = nn.ModuleList(
+            ResidualBlock(channels) for _ in range(self.config.blocks)
+        )
+        self.output_projection = nn.Conv2d(channels, output_channels, 1, bias=False)
+        nn.init.zeros_(self.output_projection.weight)
+
+    @staticmethod
+    def luma(values: torch.Tensor) -> torch.Tensor:
+        coefficients = values.new_tensor((0.2126, 0.7152, 0.0722)).view(1, 3, 1, 1)
+        return (values * coefficients).sum(dim=1, keepdim=True)
+
+    def residual(self, low_resolution: torch.Tensor) -> torch.Tensor:
+        if low_resolution.ndim != 4 or low_resolution.shape[1] != 3:
+            raise ValueError("expected NCHW RGB input")
+        if low_resolution.shape[-2] % 2 or low_resolution.shape[-1] % 2:
+            raise ValueError("input height and width must be even")
+        inputs = self.luma(low_resolution) if self.config.color_mode == "luma" else low_resolution
+        features = F.pixel_unshuffle(inputs, 2)
+        features = F.relu(self.input_projection(features))
+        for block in self.blocks:
+            features = block(features)
+        return F.pixel_shuffle(self.output_projection(features), 4)
+
+    def forward(self, low_resolution: torch.Tensor) -> torch.Tensor:
+        baseline = F.interpolate(
+            low_resolution,
+            scale_factor=2,
+            mode="bilinear",
+            align_corners=False,
+        )
+        correction = self.residual(low_resolution) * self.config.residual_scale
+        return (baseline + correction).clamp(0.0, 1.0)
+
+    def parameter_count(self) -> int:
+        return sum(parameter.numel() for parameter in self.parameters())
+
+
+def wgsl_weight_arrays(model: RealtimeLumaStudent) -> dict[str, np.ndarray]:
+    """Return FP16 arrays in the exact storage order used by the fused shaders."""
+
+    arrays: dict[str, np.ndarray] = {}
+    arrays["input_projection"] = (
+        model.input_projection.weight.detach().cpu().numpy().reshape(
+            model.config.channels,
+            model.input_projection.in_channels,
+        ).astype(np.float16)
+    )
+    for index, block in enumerate(model.blocks):
+        first = block.first.weight.detach().cpu().permute(0, 2, 3, 1).numpy()
+        second = block.second.weight.detach().cpu().permute(0, 2, 3, 1).numpy()
+        arrays[f"block_{index}"] = np.concatenate(
+            (first.reshape(-1), second.reshape(-1))
+        ).astype(np.float16)
+    arrays["output_projection"] = (
+        model.output_projection.weight.detach().cpu().numpy().reshape(
+            model.output_projection.out_channels,
+            model.config.channels,
+        ).astype(np.float16)
+    )
+    return arrays
+
+
+def export_wgsl_weights(model: RealtimeLumaStudent, output: Path) -> dict:
+    """Write the tiny FP16 payload and a stable offset ledger."""
+
+    arrays = wgsl_weight_arrays(model)
+    output.parent.mkdir(parents=True, exist_ok=True)
+    offset = 0
+    ledger = {}
+    with output.open("wb") as destination:
+        for name, values in arrays.items():
+            payload = values.tobytes(order="C")
+            destination.write(payload)
+            ledger[name] = {
+                "offset": offset,
+                "bytes": len(payload),
+                "elements": values.size,
+            }
+            offset += len(payload)
+    return {
+        "format": "backdropkit-realtime-luma-student-f16-v1",
+        "channels": model.config.channels,
+        "blocks": model.config.blocks,
+        "residual_scale": model.config.residual_scale,
+        "color_mode": model.config.color_mode,
+        "parameters": model.parameter_count(),
+        "bytes": offset,
+        "tensors": ledger,
+    }
+
+
+def initialize_rgb_from_luma(
+    rgb: RealtimeLumaStudent,
+    luma_state: dict[str, torch.Tensor],
+) -> None:
+    """Make an RGB student initially reproduce a trained luma student exactly."""
+
+    if rgb.config.color_mode != "rgb":
+        raise ValueError("target student must use RGB residuals")
+    rgb_state = rgb.state_dict()
+    for name, value in luma_state.items():
+        if name.startswith("blocks."):
+            rgb_state[name].copy_(value)
+    coefficients = luma_state["input_projection.weight"].new_tensor(
+        (0.2126, 0.7152, 0.0722)
+    )
+    source_input = luma_state["input_projection.weight"]
+    for channel, coefficient in enumerate(coefficients):
+        start = channel * 4
+        rgb_state["input_projection.weight"][:, start:start + 4].copy_(
+            source_input * coefficient
+        )
+    source_output = luma_state["output_projection.weight"]
+    for channel in range(3):
+        start = channel * 16
+        rgb_state["output_projection.weight"][start:start + 16].copy_(source_output)
+    rgb.load_state_dict(rgb_state, strict=True)

technical/example-evaluation.json

@@ -0,0 +1,70 @@
+{
+  "format": "clark-realtime-ui-video-x2-example-evaluation-v1",
+  "selection": "fixed video fractions; detail crop chosen only by reference edge density",
+  "frames": [
+    {
+      "example": "product-demo-1-before-after.png",
+      "source": "clark-code-ad-direct-vs-claude-20s-16x9.mp4",
+      "timestamp_seconds": 4.402200000000001,
+      "reference_size": [
+        1280,
+        720
+      ],
+      "detail_crop": [
+        84,
+        240,
+        444,
+        460
+      ],
+      "bicubic_psnr_db": 30.1560115814209,
+      "model_psnr_db": 30.932720184326172,
+      "bicubic_edge_psnr_db": 27.85646629333496,
+      "model_edge_psnr_db": 28.66628646850586
+    },
+    {
+      "example": "product-demo-2-before-after.png",
+      "source": "clark-code-demo.mp4",
+      "timestamp_seconds": 13.93983408,
+      "reference_size": [
+        1280,
+        720
+      ],
+      "detail_crop": [
+        132,
+        0,
+        492,
+        220
+      ],
+      "bicubic_psnr_db": 33.195716857910156,
+      "model_psnr_db": 34.348419189453125,
+      "bicubic_edge_psnr_db": 31.850730895996094,
+      "model_edge_psnr_db": 32.78166961669922
+    },
+    {
+      "example": "product-demo-3-before-after.png",
+      "source": "clark-code-ad-direct-vs-claude-20s-16x9.mp4",
+      "timestamp_seconds": 15.807900000000002,
+      "reference_size": [
+        1280,
+        720
+      ],
+      "detail_crop": [
+        468,
+        276,
+        828,
+        496
+      ],
+      "bicubic_psnr_db": 33.5679931640625,
+      "model_psnr_db": 35.42755889892578,
+      "bicubic_edge_psnr_db": 31.71966552734375,
+      "model_edge_psnr_db": 33.55112838745117
+    }
+  ],
+  "mean": {
+    "bicubic_psnr_db": 32.30657386779785,
+    "model_psnr_db": 33.569566090901695,
+    "model_gain_db": 1.262992223103841,
+    "bicubic_edge_psnr_db": 30.47562090555827,
+    "model_edge_psnr_db": 31.666361490885418
+  }
+}

technical/package-ledger.json

@@ -0,0 +1,42 @@
+{
+  "format": "clark-realtime-ui-video-upscaler-x2-package-v1",
+  "checkpoint_sha256": "3cbb8a3358bbeaa239c517f1171dbb7706c2d453c961d17a4e6166aefde8c692",
+  "artifacts": {
+    "README.md": {
+      "bytes": 3867,
+      "sha256": "8b3831f2d9151b8f1bb97850b82ba061bb9a3c264f353ed1e4f88ac109446c7e"
+    },
+    "LICENSE": {
+      "bytes": 11348,
+      "sha256": "d66ccc11682c7458b19b376e1335e8665cbe412ff71f554bfec25f1791cddfa0"
+    },
+    "model.safetensors": {
+      "bytes": 34712,
+      "sha256": "40d0c8b9f0c28095e06261c56a4c464e0b93c55b845f2470de175e8fa710b6df"
+    },
+    "browser/model.bin": {
+      "bytes": 16992,
+      "sha256": "c6b4f22d8c38270225b809e97d233eb68d7a48eef17595ac17a60b4540c72dce"
+    },
+    "browser/model.json": {
+      "bytes": 841,
+      "sha256": "eba342bf8f54749490fecb9df43f399595c07b291d5188d67bb0f4448d38f09c"
+    },
+    "browser/realtimeVideoUpscaler.js": {
+      "bytes": 16319,
+      "sha256": "58dd6544858039b4f8ba7a6cf469a4ed22aadc8588c7483ca7b4af2901ac4742"
+    },
+    "browser/runtimeCapabilities.js": {
+      "bytes": 3145,
+      "sha256": "d78fe2ce0f0a4513364599854b363cddae8c1479de17d2cfca006bdd2de931c6"
+    },
+    "technical/runtime-receipt.json": {
+      "bytes": 2152,
+      "sha256": "ee1c83e21c13bb6e59264f0159768cb2afd003cdbfaea69c2063629ba6f19580"
+    },
+    "technical/example-evaluation.json": {
+      "bytes": 1875,
+      "sha256": "6060c4c1ba7668adb5173eb8bade52f2221b1f2d4733fd1d16bdbef5d35e2722"
+    }
+  }
+}

technical/runtime-receipt.json

@@ -0,0 +1,60 @@
+{
+  "format": "backdropkit-realtime-1080p-to-4k-receipt-v2",
+  "measured_at": "2026-08-01",
+  "device": "Apple M5",
+  "browser": "Chrome 150 WebGPU",
+  "input": { "width": 1920, "height": 1080, "nominal_fps": 60 },
+  "output": { "width": 3840, "height": 2160 },
+  "model": {
+    "profile": "rgb-ui-video-x2",
+    "channels": 12,
+    "blocks": 3,
+    "parameters": 8496,
+    "fp16_bytes": 16992,
+    "sha256": "c6b4f22d8c38270225b809e97d233eb68d7a48eef17595ac17a60b4540c72dce",
+    "gmac_per_frame": 4.4043264,
+    "resident_feature_bytes": 24883200
+  },
+  "kernel": {
+    "name": "RGB pixel-unshuffle plus three two-convolution workgroup-fused residual blocks",
+    "tile": [8, 8],
+    "precision": "fp16",
+    "measured_frames": 120,
+    "warmup_frames": 15,
+    "median_ms": 8.9,
+    "p95_ms": 10.6,
+    "maximum_ms": 12.3,
+    "frames_per_second_from_median": 112.36
+  },
+  "trained_end_to_end_with_h264": {
+    "measured_frames": 120,
+    "warmup_frames": 15,
+    "median_ms": 9.4,
+    "p95_ms": 11.0,
+    "maximum_ms": 11.5,
+    "encoded_chunks": 120,
+    "encoder_error": null,
+    "maximum_encode_queue": 2,
+    "remaining_encode_queue": 0,
+    "median_encode_latency_ms": 16.7,
+    "p95_encode_latency_ms": 28.1
+  },
+  "browser_cadence_observation": {
+    "note": "Compute and encoder latency have 60 fps headroom, but this interactive browser run skipped callbacks; it is not a claim of sustained 60 displayed fps on every browser.",
+    "kernel_only_presented_frames": 178,
+    "kernel_only_busy_callbacks": 44,
+    "encoded_presented_frames": 184,
+    "encoded_busy_callbacks": 49
+  },
+  "training": {
+    "steps": 5000,
+    "batch_size": 16,
+    "training_images": 206232,
+    "held_out_images": 268,
+    "baseline_product_weighted_ground_truth_psnr_db": 28.788123630892997,
+    "final_product_weighted_ground_truth_psnr_db": 29.243351974323687,
+    "ground_truth_gain_db": 0.4552283434306903,
+    "final_product_weighted_teacher_psnr_db": 32.163547360195835
+  },
+  "promotion_status": "Default local neural path for eligible BackdropKit video on shader-f16 WebGPU; high-quality browser scaling remains the automatic fallback elsewhere."
+}