PUBLIC GALLERY EDITION / 15 October 2026

The original export notes below describe filenames in the research export bundle,
not a list of public download URLs. This site serves trajectories.json unchanged,
replay-manifest.json (original manifest.json), replay-verification.json (original
verification.json), replay-receipt.json (original replay_receipt.json), and this
annotated replay-readme.txt. Original exporter code, checkpoints, and gzip output
are not served here. Hashes in the original manifest refer to the original export
files; the original README hash does not describe this annotated text edition.
The raw trajectory bytes and source receipts have not been altered.

--- Original export notes ---
# Synthetic NCA replay gallery data

This is a local data export, not a trained model or a published site. The artwork is the owned procedural 16 × 16 `bud` target. Both checkpoints have exactly **1,000 optimizer updates**, with training seed **0**. The gallery shows evaluation case **0**, with one multihole damage example. It does not mix in the separate 1,500-update adaptation experiment.

## Files

- `trajectories.json`: self-contained playback data, raw numerical RGBA, target, mask, per-frame metrics, source/checkpoint hashes, and RNG provenance.
- `trajectories.json.gz`: identical JSON compressed with deterministic gzip.
- `manifest.json`: detailed schema, rendering convention, timepoints, limitations, reproduction command, and file hashes.
- `verification.json`: exact replay and JSON round-trip receipts.
- `export_replays.py`: replay/export only; no training or network activity.
- `replay_receipt.json`: compact results from the exporter.

Technical source paths inside the JSON are relative to `nca_pilot`. Output filenames are relative to this directory. All data are synthetic; no personal identifiers or private raw data are included.

## Layout and time

Each `raw_rgba.values` array contains **1,024 full-precision floating-point numbers**, representing shape `[16,16,4]`, with channels `[R,G,B,A]`. Flattening is row-major C order:

`index = ((y * 16 + x) * 4 + channel)`

The top row is y = 0; y increases downward and x increases to the right. Array hashes are computed over source-array bytes **before serialization**: C-contiguous, little-endian float64, with shape/dtype recorded separately. Damage masks use uint8; firing-mask hashes use NumPy boolean bytes.

Each method contains three series:

1. `growth_stability`: absolute steps **0, 8, 16, 32, 64, 128, 192, 256, 512, 1024**. Growth uses seed **100000** through 128. Stability starts a separate RNG with seed **300000** at 128.
2. `repair`: steps after damage **0, 8, 16, 32, 64, 128**, branching from the intact growth reference at absolute 128. Damage case **4** is `multihole`, requested target fraction **0.30**, mask seed **200004**. All 16 channels are erased where the mask is true.
3. `paired_undamaged_control`: the same post-branch steps, with **identical future firing masks** as repair, seeded **400004**. This control uses a different RNG from the stability branch; do not substitute one for the other.

The 30% damage severity is defined against target foreground cells, with rounding. It is not necessarily 30% of learned live cells or 30% of the grid; both actual counts are in the data. Label animation frames with their actual step, because spacing is unequal. Do not interpolate synthetic intermediate states.

## Display convention

Keep the raw arrays unchanged for calculations. Use the same **premultiplied-style display convention** as the reports, compositing over the chosen background color (or each checkerboard pixel):

`RGB_display = clip(raw_RGB + (1 - clip(raw_alpha, 0, 1)) * background_RGB, 0, 1)`

Convert each resulting RGB channel to a byte with `floor(255 * RGB_display + 0.5)`, and set output alpha to **255** in Canvas `ImageData`. Do not pass raw RGB as straight-alpha RGBA; that would apply an additional alpha multiplication and alter the edges. The binary target's RGB is premultiplied by its alpha. Treat the resulting RGB as sRGB for display; the network does not establish a calibrated color space or valid premultiplied output. Enlarge with nearest-neighbor scaling.

This lossy display transform must be labeled. Show each frame's **raw range, count of out-of-range values, and MSE** beside the image. No clipped copy is stored. Seed-only case 0 reaches raw RGBA maximum **103.9761** at step 1024; clipping that to white must not hide the divergence.

## What the selected case shows

At absolute step 1024:

- Pool, no damage: raw target MSE **0.00614398**, alpha IoU **0.985507**, raw RGBA range **[-0.069829, 1.555024]**.
- Seed only: raw target MSE **117.339995**, alpha IoU **0.306306**, raw RGBA range **[-0.133681, 103.976108]**.

Pooled shape retention is not proof of robust regeneration. **Neither selected damage/control endpoint qualifies as a valid repair-success comparison** under the preserved reference-relative rule. In the full original pilot, neither condition passed every sampled reference-relative stability checkpoint. The gallery is one target-specific illustration from one trained seed, not an independent-replication estimate or a new research result.

The full 16-channel dynamics are replayed, but only RGBA is exported. Full-state hashes are supplied. Playback needs only the JSON; recomputing dynamics needs the original hashed model code and checkpoints.

## Verification and reproduction

All **50 original full-batch saved arrays** match **bit-for-bit**, with maximum absolute error **0**. This covers growth 128, every saved 64-step stability checkpoint through 1024, and all saved repair/control horizons. The replay preserves the original 10-case growth/stability batches and 90-case damage plus 90-case control batch. Exporting extra frames changes neither the noise draws nor batch layout.

All **47 exported numerical arrays** (44 frames, target, and two damage masks) round-trip through JSON bit-for-bit. The gzip decompression matches the uncompressed JSON exactly. SHA-256 receipts are in `manifest.json` and `verification.json`.

From the directory containing `nca_pilot`, run:

```sh
OPENBLAS_NUM_THREADS=1 PYTHONDONTWRITEBYTECODE=1 python nca_pilot/gallery_export/export_replays.py > nca_pilot/gallery_export/replay_receipt.json
```

The verified runtime is Python **3.12.14**, NumPy **2.3.5**, one OpenBLAS thread. All writes stay in `gallery_export`; there is no training, installation, upload, account access or external publication. Reproduction intentionally fails on a saved-state mismatch instead of silently weakening precision requirements. Other NumPy/BLAS implementations may produce numerical differences.