Adds rerun and reformatted parquet files.

CLAUDE.md

@@ -8,7 +8,7 @@ Context for continuing work on this dataset. Captures the design decisions, conv
 
 It is the **third leaf** in the Inova Mk1 dataset ecosystem alongside `Inova-Mk1-Database` (canonical printer entities) and `Inova-Mk1-ASTM` (mechanical-test specimens).
 
-Unlike the other two, this dataset has **no local `source/` directory** — its raw inputs are the flat exports written by a sibling Git repo (`Agentic-Additive-Manufacturing-Process-Optimization`, "the recorder"). The ETL here reshapes those flat exports into one parquet file per build.
+Unlike the other two, this dataset has **no local `source/` directory** — its raw inputs are the flat exports written by the recorder repo (`Agentic-Additive-Manufacturing-Process-Optimization`), which contains this dataset as a submodule at `datasets/Inova-Mk1-Telemetry`. The ETL here reshapes those flat exports into one parquet file per build.
 
 ## Data lineage — printer to row
 
@@ -69,11 +69,11 @@ End-to-end, before this dataset's ETL touches anything:
 ┌────────────────────────────┐
 │  This dataset              │  Per-build wide parquet, one row per 10 Hz tick.
 │  data/ticks/{NNN}.parquet  │  Embedded image bytes, denormalized build
-│                            │  context, ~78 columns including position burst.
+│                            │  context, ~79 columns including position burst.
 └────────────────────────────┘
 ```
 
-The two **sidecar CSVs** at the recorder layer (`build_to_inova_session.csv`, `sensors.csv`) are hand-annotated by a human, not generated. They're checked into the recorder repo and read by this dataset's ETL via the sibling-folder path.
+The two **sidecar CSVs** at the recorder layer (`build_to_inova_session.csv`, `sensors.csv`) are hand-annotated by a human, not generated. They're checked into the recorder repo and read by this dataset's ETL via the containing-repo path.
 
 ## How the data is captured
 
@@ -91,10 +91,12 @@ The recorder also pins **`sls4all/SLS4All.Compact`** as a submodule at tag `publ
 Submodule layout inside the recorder repo:
 ```
 sls4all/
-  Inova-API-Plugin/       # the C# plugin (our code; editable)
-  SLS4All.Compact/        # firmware (vendor; pinned)
+  Inova-API-Plugin/            # the C# plugin (our code; editable)
+  SLS4All.Compact/             # firmware (vendor; pinned)
+  Inova-Defect-Detection-Model/# layer-wise defect detection model
 datasets/
-  Agentic-SLS/            # legacy submodule, predates the HF dataset layout
+  Agentic-SLS/                 # legacy submodule, predates the HF dataset layout
+  Inova-Mk1-Telemetry/         # THIS repo (update=none — never blanket --recurse-submodules; 566 GB)
 ```
 
 ### How the recorder runs
@@ -134,7 +136,11 @@ Only needed if you're rebuilding the recorder side — this dataset's ETL doesn'
 
 ```sh
 # In the recorder repo:
-git clone --recurse-submodules git@github.com:ppak10/Agentic-Additive-Manufacturing-Process-Optimization.git
+# Don't use blanket --recurse-submodules: this dataset (566 GB) is itself a
+# submodule at datasets/Inova-Mk1-Telemetry (guarded by update=none). Init
+# the submodules you need explicitly instead.
+git clone git@github.com:ppak10/Agentic-Additive-Manufacturing-Process-Optimization.git
+git submodule update --init sls4all/Inova-API-Plugin sls4all/SLS4All.Compact
 cp .env.example .env       # then fill in printer IP
 docker compose up -d       # brings up Postgres
 cd server && npm install   # then run the Fastify server in dev/prod mode
@@ -148,15 +154,15 @@ Assuming you're working on this machine (`/mnt/storage2`):
 
 | Repo | Filesystem path | Role |
 |---|---|---|
-| This dataset | `/mnt/storage2/HuggingFace/Datasets/Inova-Mk1-Telemetry/` | Where you are now. ETL reads sibling exports; writes `data/ticks/`. |
-| Recorder repo | `/mnt/storage2/GitHub/Agentic-Additive-Manufacturing-Process-Optimization/` | Owns the live DB + export script. **The only sibling repo this dataset depends on.** This ETL reads `data/exports/`. |
+| This dataset | `/mnt/storage2/GitHub/Agentic-Additive-Manufacturing-Process-Optimization/datasets/Inova-Mk1-Telemetry/` | Where you are now. A submodule of the recorder repo. ETL reads the containing repo's exports; writes `data/ticks/`. |
+| Recorder repo | `/mnt/storage2/GitHub/Agentic-Additive-Manufacturing-Process-Optimization/` | Owns the live DB + export script and contains this dataset as a submodule. **The only repo this dataset depends on.** This ETL reads `data/exports/`. |
 | Sibling Database dataset | `/mnt/storage2/HuggingFace/Datasets/Inova-Mk1-Database/` | Informational only — *not* a dependency. Consumers can join `print_profile_name` against `source/PrintProfiles/*.json` themselves to recover the UUID; see "Joining back to Inova-Mk1-Database" in the README. |
 | Sibling ASTM dataset | `/mnt/storage2/HuggingFace/Datasets/Inova-Mk1-ASTM/` | Independent leaf; no direct dependency. |
 
 `scripts/_lib.py` resolves the recorder path relative to its own location: `ROOT` is the repo root (`_lib.py` → two `.parent`s up), and then:
-- **Recorder** (`AGENTIC_ROOT`): `ROOT.parent.parent.parent / "GitHub" / "Agentic-Additive-Manufacturing-Process-Optimization"` — three climbs from `ROOT` to reach `/mnt/storage2`, then descend.
+- **Recorder** (`AGENTIC_ROOT`): `ROOT.parent.parent` — two climbs from `ROOT` (`datasets/Inova-Mk1-Telemetry` → `datasets` → recorder root).
 
-If you move the repo out of `/mnt/storage2/HuggingFace/Datasets/`, that climb needs updating.
+If you move the repo out of the recorder's `datasets/` folder, that climb needs updating.
 
 **Authoritative references** for sensor semantics in the recorder repo:
 - `sls4all/Inova-API-Plugin/InovaApiPlugin.cs` — `/state/snapshot` returns `{ position, lights, power, temperature }`. Lines 85–213 are the endpoint definitions; lines 495–507 are the `CaptureSnapshot` shape.
@@ -254,9 +260,10 @@ Neither blocks the ETL. They improve dataset metadata.
 
 - **One config, not four.** Early iteration had separate `builds`, `telemetry`, `position_hf`, and `frames` configs. Replaced with a single `ticks` config because ML consumers almost always want the joined view: state + frame + position at one moment in time. The four-silo version pushed the join cost onto every downstream user.
 - **Anchor on the 10 Hz telemetry tick, not strict outer join.** The recorder's `/state/snapshot` poll fires at 10 Hz and `expand()` emits a deterministic ~64-row burst into the `telemetry` table — so a tick already represents a full state snapshot. Anchoring on ticks gives every row densely populated columns; frames and `position_hf` attach to the tick they're closest to. A strict outer join across all stream timestamps gave ~3M mostly-sparse rows for less ML value.
-- **Wide format, dotted column names matching upstream.** Sensor columns are named exactly `{sensor_id}.{kind}` — e.g. `powderBed.temp.current`, `laser.power`, `positions.position.x`. This matches the upstream `sensors.csv` glossary 1:1 so unit annotations land where consumers will look. ~64 sensor columns + build context + frame paths + position burst = 78 columns total.
+- **Wide format, dotted column names matching upstream.** Sensor columns are named exactly `{sensor_id}.{kind}` — e.g. `powderBed.temp.current`, `laser.power`, `positions.position.x`. This matches the upstream `sensors.csv` glossary 1:1 so unit annotations land where consumers will look. ~64 sensor columns + build context + frame paths + bedmatrix + position burst = 79 columns total.
 - **Frames attach by nearest-before-tick within a 100 ms window** and **the image bytes are embedded inline**. Frame timestamps don't align with telemetry ticks (chamber 5 Hz, thermal 2 Hz, galvo varies). For each tick we look back 100 ms and grab the most recent frame of each kind; nulls when nothing landed. Each `frame_*` column is a struct of `{bytes: binary, path: string}` matching HF's `Image` feature wire format — declared as `dtype: image` in the README so `datasets` decodes to `PIL.Image` on access. The `path` field inside the struct is the original relative filename (`"26/1780265532038_chamber.jpg"`) preserved for traceability back to the recorder repo.
 - **Null is preserved when no frame attaches** — we explicitly did **not** forward-fill the latest captured frame. Reason: shuffled training with forward-fill would pair the same image with widely varying telemetry rows (e.g. one chamber jpg stamped onto thousands of consecutive ticks during a 30-min heating phase), teaching the model spurious associations. Filtering null-frame rows at consume time is a one-liner; recovering "this image is stale" from a forward-filled column is impossible.
+- **`bedmatrix` is the IR temperature matrix as raw numbers, not a rendered image.** It attaches nearest-before-tick within the same 100 ms window as frames, but embeds as a numeric struct `{width: int32, height: int32, values: list<float32> (row-major °C), path: string}` — a 32×24 = 768-cell bed-surface temperature grid, null when nothing landed. **History:** through 2026-07-12 the same sensor was captured as a pre-rendered GIF heatmap under frame kind `thermal` (the source of `frame_thermal`, HTTP-polled from `/api/bedmatrix/image/`). Recorder commit `8d98e0c` dropped that poll; the dedicated `bedmatrix.ts` WS recorder (`/temperature/bedmatrix/stream`) now streams the raw matrix as JSON under kind `bedmatrix`. That JSON stream has actually run since build 13, so `bedmatrix` backfills across the whole dataset and is strictly richer than the old heatmap. Consequence: **`frame_thermal` is null for builds captured after 2026-07-12** (044 is the last with it; 046 has none) — use `bedmatrix` for thermal from there on. To recover a heatmap image, colormap `values` reshaped to `height × width`.
 - **`position_hf` preserved as per-tick bursts.** The firmware emits `PositionChangedHighFrequency` event-driven, not at fixed 1 kHz — so it bursts during motion and is empty during heating. We keep the full burst inside each tick's window as `position_hf_burst: list<struct<ts_offset_ms, x, y, z1, z2, r, has_homed>>`. Empty list when no motion. Lossless within the 100 ms window; the raw `position_hf/{build_id}.parquet` upstream is the fallback if you need motion data between ticks.
 - **Build context denormalized into every row.** `build_id`, `job_name`, `started_at`, `ended_at`, `phase`, `print_profile_name`, `inova_session_id` repeat on every row. Parquet dictionary encoding makes this essentially free (~1 byte per row regardless of value).
 - **`print_profile_name` only, no `print_profile_id`.** The recorder's `events.jsonl` carries the *name* a build started with; the UUID lives in `Inova-Mk1-Database/source/PrintProfiles/*.json`. Earlier versions of the ETL cached the name→UUID lookup into a `print_profile_id` column, but doing that turned `Inova-Mk1-Database` into an ETL-time dependency for a one-line consumer join. We dropped the column so this dataset stands on its own with only the recorder repo. Consumers who want the UUID can join externally — see the README section "Joining back to Inova-Mk1-Database."
@@ -272,7 +279,7 @@ pyproject.toml                 # pyarrow, polars, imageio[ffmpeg], pillow, numpy
 .gitattributes                 # *.parquet, *.mp4, *.gif → LFS
 
 scripts/
-  _lib.py                      # sibling-repo paths + JSONL streaming
+  _lib.py                      # recorder-repo paths + JSONL streaming
   ticks/
     00_recover_spool41.py      # one-off: recover build 41 from NVMe spool (DB was wiped)
     00_export_new_db.py        # one-off: export DB builds with ID remap (old_id:new_id; identity N:N since 2026-07-13)
@@ -296,21 +303,22 @@ previews/
     timelapse_composite.gif    # LFS; 1×3 panel GIF
 ```
 
-There is no `source/` (raw data lives in the sibling recorder repo's `data/exports/`).
+There is no `source/` (raw data lives in the containing recorder repo's `data/exports/`).
 
 `scripts/ticks/01_extract.py` is organized as:
 1. `load_builds_index()` / `load_frames_for_build()` — load upstream JSONL
 2. `pivot_telemetry()` — long-to-wide on `(sensor_id, kind)`
 3. `attach_frames()` — three `join_asof(strategy='backward', tolerance=100ms)` calls
-4. `attach_position_hf()` — manual sorted-merge to build the burst lists
-5. `denormalize_build()` — `pl.lit()` columns for build context
-6. `_embed_frame_column()` / `_embed_chunk()` / `process_build()` — chunked write with pyarrow `ParquetWriter`
-7. `main()` — iterate target build IDs, call `process_build()` per build
+4. `attach_bedmatrix()` — one more `join_asof` for the IR matrix JSON path
+5. `attach_position_hf()` — manual sorted-merge to build the burst lists
+6. `denormalize_build()` — `pl.lit()` columns for build context
+7. `_embed_frame_column()` / `_embed_bedmatrix_column()` / `_embed_chunk()` / `process_build()` — chunked write with pyarrow `ParquetWriter`
+8. `main()` — iterate target build IDs, call `process_build()` per build
 
 ## Row shape
 
 ```python
-# per row, ~78 columns:
+# per row, ~79 columns:
 {
   # Build context (denormalized; same on every row of a given file)
   "build_id": 26,
@@ -346,7 +354,12 @@ There is no `source/` (raw data lives in the sibling recorder repo's `data/expor
   # Frames — embedded HF Image structs (PIL.Image on load) or None
   "frame_chamber": {"bytes": b"\xff\xd8...", "path": "26/1780265532038_chamber.jpg"},
   "frame_galvo":   {"bytes": b"\x89PNG...", "path": "26/1780265532040_galvo.png"},
-  "frame_thermal": None,                              # nothing in window
+  "frame_thermal": None,             # legacy GIF heatmap; null for builds after 2026-07-12
+
+  # IR temperature matrix (raw numbers, replaces frame_thermal) — struct or None
+  "bedmatrix": {"width": 32, "height": 24,
+                "values": [97.3, 97.1, ...],          # 768 floats, row-major °C
+                "path": "26/1780433796515_bedmatrix.json"},
 
   # 1 kHz position-stream burst within (tick_ts - 100ms, tick_ts]
   "position_hf_burst": [
@@ -372,6 +385,7 @@ If `expand()` in the recorder ever changes, all of those column names change wit
 ## Important gotchas
 
 - **`frame_*` bytes are embedded; `path` inside the struct is recorder-relative.** Each non-null frame column carries the actual image bytes plus the original relative path (`"26/1780265532038_chamber.jpg"`, meaning `Agentic-Additive-Manufacturing-Process-Optimization/data/frames/...`). The path is for traceability only — consumers don't need the recorder repo to access the image. The unattached frames (~half of the 1.27 M captured) still live only in the recorder repo; this dataset only carries the per-tick attached subset.
+- **`frame_thermal` is legacy and null for builds captured after 2026-07-12; use `bedmatrix` instead.** The recorder stopped polling the pre-rendered IR heatmap GIF (commit `8d98e0c`) and now streams the raw 32×24 temperature matrix as JSON under kind `bedmatrix`. Build 044 is the last with `frame_thermal`; 046 onward has none. `bedmatrix` is a numeric struct (`{width, height, values: list<float32> row-major °C, path}`), backfilled across the whole dataset (the JSON stream has run since build 13), and strictly richer — colormap `values` reshaped to `height × width` to recover a heatmap. The preview renderers now do exactly this: `previews/*/thermal.mp4`, `composite.mp4`, `timelapse_thermal.gif`, and `timelapse_composite.gif` render the thermal panel from `bedmatrix` (inferno colormap over a fixed 20–200 °C range; see `scripts/previews/_thermal.py`), falling back to `frame_thermal` only for the three earliest builds (001/002/012) that predate the stream. So thermal previews exist for all builds, including post-2026-07-12 ones.
 - **`positions.position.*` columns are 10 Hz**, not 1 kHz. They come from the snapshot's `position` field. For 1 kHz fidelity during motion, read `position_hf_burst`.
 - **`inova_session_id` is always null** until someone curates `build_to_inova_session.csv` in the recorder repo. Consumers who need an entity-graph link can fall back to joining on `print_profile_name` against `Inova-Mk1-Database` meanwhile.
 - **`build_id` is a Postgres BIGSERIAL**, not a UUID. One Database `PrintSession` may have many `build_id`s (one per recorder restart / attempt). That's why session-id mapping must be hand-authored.

README.md

@@ -34,7 +34,7 @@ from datasets import load_dataset
 ds = load_dataset("ppak10/Inova-Mk1-Telemetry", split="train")
 row = ds[0]
 # row["frame_chamber"]            → PIL.Image.Image (or None)
-# row["frame_thermal"]            → PIL.Image.Image (or None)
+# row["bedmatrix"]                → {width, height, values (768 °C floats), path} (or None)
 # row["powderBed.temp.current"]   → float (°C)
 # row["positions.position.z2"]    → float (µm)
 # row["position_hf_burst"]        → list of {ts_offset_ms, x, y, z1, z2, r, has_homed}
@@ -72,7 +72,8 @@ Each row is one moment in time (a single 10 Hz tick). ~80 columns:
 | **Lights** | `lights.lights.{enabled,count}` | |
 | **Power (W)** | `{laser,fanGalvo,buzzer,laserSafety,io-en,wd-en,wd-in}.power`, `powerman.power.{current,required,max}` | Per-component draw and manager state. |
 | **Temperature (°C)** | `{powderBed,printBed}.temp.{current,average,target}`, `{powderChamber1..4,printChamber1..4}.temp.{current,average,target}`, `{quadrant1..4,surface,surfaceAvg,surfaceMin,surfaceMax,testTemp1}.temp.{current,average}` | ~51 columns. |
-| **Frame images** | `frame_chamber`, `frame_galvo`, `frame_thermal` | HF `Image` feature (struct of `{bytes, path}`). Null when no frame of that kind was captured in the 100 ms window. Loads as `PIL.Image` via `datasets`. `path` preserves the original filename for traceability. |
+| **Frame images** | `frame_chamber`, `frame_galvo`, `frame_thermal` | HF `Image` feature (struct of `{bytes, path}`). Null when no frame of that kind was captured in the 100 ms window. Loads as `PIL.Image` via `datasets`. `path` preserves the original filename for traceability. **`frame_thermal` is a legacy pre-rendered IR heatmap GIF and is null for builds recorded after 2026-07-12 — use `bedmatrix` for thermal from there on** (see below). |
+| **Bed temperature matrix** | `bedmatrix` | Struct `{width: int32, height: int32, values: list<float32>, path: string}`. The raw IR bed-surface temperature grid (32×24 = 768 cells, row-major, °C) attached nearest-before-tick in the same 100 ms window; null when none landed. Reshape `values` to `height × width` and colormap to render a heatmap. This supersedes `frame_thermal` and is available on all builds (the stream has run since build 013). |
 | **Position burst** | `position_hf_burst` | `list<struct<ts_offset_ms, x, y, z1, z2, r, has_homed>>`. 1 kHz position events that fell in `(tick_ts − 100 ms, tick_ts]`. Empty list during heating/idle. |
 
 ### Null frames
@@ -135,7 +136,7 @@ data/ticks/{build_id:03d}.parquet      # one file per build, zero-padded (001–
 
 previews/{build_id:03d}/
   chamber.mp4                          # optical — real-time 10 fps, forward-filled
-  thermal.mp4                          # IR matrix
+  thermal.mp4                          # IR bed heatmap (from bedmatrix; inferno, fixed 20–200 °C)
   galvo.mp4                            # scan-mirror trace
   composite.mp4                        # 1×3 panel: chamber | thermal | galvo
   timelapse_chamber.gif                # layer-by-layer, 25 fps, ≤ 12 s
@@ -163,7 +164,7 @@ Four animated GIFs per build sampled one frame per detected print layer:
 - **Playback**: 25 fps, capped at 300 frames (12 s max). Null-frame levels are forward-filled within the GIF.
 - **Canvas**: 240 px height (half the MP4 canvas) for web-friendly file sizes.
 
-Both previews are sourced from this dataset's own parquet (not the recorder's raw frame files), so they see only the per-tick-attached frame subset (~36% chamber, ~37% galvo, ~16% thermal attachment rate).
+Both previews are sourced from this dataset's own parquet (not the recorder's raw frame files), so they see only the per-tick-attached frame subset (~36% chamber, ~37% galvo attachment rate). The **thermal** panel is rendered from the numeric `bedmatrix` IR grid — inferno colormap over a fixed 20–200 °C range, so the same color means the same temperature across every build — rather than the legacy `frame_thermal` GIF. Builds 001/002/012 predate the bedmatrix stream and fall back to the old GIF.
 
 ---
 

data/ticks/001.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:f9218481ccf8ffa21212a3f2a1deb8400c2f1085fb2186c4fe2736a6040a916a
-size 3070050859
+oid sha256:5f7403410b9c4c4454ca2ad7996496f1f75d392436f3d35346f567d58e81a831
+size 3070064819

data/ticks/002.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:56a9e8e9d263749b271bf8879737fa0aff761770ef4b6a854a3b1b594db4a474
-size 2509572
+oid sha256:322538cc0188f75ffcfbbcec18bd24919e082a8ce016db2f8b6787b84845d7bf
+size 2510220

data/ticks/012.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:251d4d7eda86545e5b4411a577d337e5c1da27047dfd7ce93627e9df765c08c1
-size 4928937483
+oid sha256:9170527116296e16c09801bae09afd7daafa3cdf9a636cc068ee16f081895a88
+size 4928964220

data/ticks/013.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:9698cf8e091ac9a13d7650995e4c9873c177d113cdc449949ac9a61a0b7c6753
-size 551842848
+oid sha256:0d09d2578cd171bb9c6acf010a3bcde3536cb494db75bad51265c66399fd7bf2
+size 557525403

data/ticks/014.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:0c47665b6d90171a760ca5148a8975e5a8dd817172ea79de0913cb2475527c2d
-size 46213
+oid sha256:80a0b811c8a9b912c062eac4c1d598542f8f47d283aa72958ffe7deaac5380e6
+size 46831

data/ticks/016.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:907d7ac915aa74c995983b2b3292e95d3f507b9f7e047cf955fc62a707eecdab
-size 806791
+oid sha256:a6c0b6bad32633cfe8acd4b5ec4d08f66978765d7417c9c5e34cafa185386dc6
+size 811333

data/ticks/017.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:c377a97cb77161b89c9a7ae3f9a3ecf20724cccf59b322ecda2eca5af2a5375d
-size 29798
+oid sha256:b4e1bec1f4a9e0fb00ddae496856a298b14139c5cc2fbdc597e1c50c389323fd
+size 30416

data/ticks/025.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:100ae729c896b36fd1e42bb444d17990a1c3c87ec5cad350a32c26dee94e2e00
-size 1208604
+oid sha256:68bcc513234d93bad405b1e0e1015573985eb69f2f449cd236ada2df16709aae
+size 1216867

data/ticks/026.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:73954fc364fbd9557376b26f16b7ec082d443cd626cf799256025edb1e39593c
-size 11552611342
+oid sha256:58fb99fe240e3176ef29113dbaa9eaceadc0d70aa56743cfec022fd19a7ce126
+size 11667958845

data/ticks/028.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:44f6df8e1e1f67a4007da0b83314faf60a758e4994ff48274204f9bbcfc48762
-size 11436603086
+oid sha256:93fdf48a3ea3c4def04132e62b55429821f1eed5b9728e4e69c90f840839f4ed
+size 11549490145

data/ticks/029.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:7984c30bae143e2dbd661485a3bf3c00b64f8dcf5c788268931d58f4d0035967
-size 9743021465
+oid sha256:c88515ead6ae3985780c7151b6d3b1d17dc5d0944a43485ed6913759f46781c7
+size 9837883077

data/ticks/030.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:72fa46726514b3c98c4aa31eb255afb82469d5342d44f877a6c27b628395ad92
-size 7195639311
+oid sha256:5fe55e56eacc7909732ae3e701b480fb46f7277f0e1adb3390082e2de9ab80c5
+size 7271463144

data/ticks/031.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:790000dd8b5928eddcac9684f133d060e8a72eedf537bd613f10f133967698d9
-size 5245032189
+oid sha256:69469797ac695a0bb7df79ad63c002814cb42b8350c66f33ecb0acad8cbe0ed8
+size 5297605879

data/ticks/032.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:2fa685a426e8ee02940f32785b15503a5140dd53ded250536f1e4af68c7ca9df
-size 684999581
+oid sha256:ce5ba49e1fcf1954478d3ca5c826465c34861e46c6d974180d58cc12ac8e002e
+size 691454927

data/ticks/033.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:6011cf0ac654dc6dfa966426bfe5d31e334049304b8f9818742db4f00be0d958
-size 61512550
+oid sha256:b5eb26e407b43b9d65e7db5ec45b95b3827fe1344f0696543c765031692ddd9e
+size 62132491

data/ticks/034.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:ac5ba412a172eb64acb18994d5d9f6ee79c50a81bceb75a8cc5896556e0841b5
-size 676195678
+oid sha256:60bf42451327c0128a253e9ea8388d3fe446368ca170f7be89aac71a1f9f1f00
+size 683238238

data/ticks/035.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:7437eb161a729ed7cf3eda5b92e9acdc2e48ace0c11678514b1a1fffb0ed259e
-size 13537250980
+oid sha256:e85af5d97a95c5906f5db62363c55fdc46bd8774d539fca037cebb73e24f2d2d
+size 13674409754

data/ticks/036.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:dbd0a8bb72f28afec0a9b6b7f5a938ec2e3a758bf30fac205bf8e5ebae444af3
-size 23101901278
+oid sha256:1d592fa4682d13cee9e174856b3c4a2fe7937dba4375938f718bf162396c5056
+size 23337459002

data/ticks/037.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:9a4388c3c1ce6cef5349768b0210360824d37824c8e5cf45fe8e70eb48bc45e6
-size 25359402
+oid sha256:16fed17db954b8fca729be26e80f6cf10cd31e519cfe9c25d9732dfbfd1461c3
+size 25640340

data/ticks/038.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:ad5da92e26ed5ade9ba6b5430d534e9feceb23679efe0211ebc51e15e7779623
-size 307246351
+oid sha256:c30e56ee16f3b8285cd7bc2b2c2c63c0a24a697a2ae6ccab073635be4ee59778
+size 310532525

data/ticks/039.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:237f344a55b4bd3014c5502c177b07f8b4f4e463689b68df2bcf443d5fbed393
-size 10519582199
+oid sha256:8cc971e8f869f3af6d9ff6b2923f45a36159541662acee703e8cd1dc2121df69
+size 10630729356

data/ticks/040.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:574f079273d822fec27031f4d28d821b222398ded7ebbd4b937a902d62198702
-size 17473241885
+oid sha256:b8a29000eb5863a48f64c1a9b26ffce8799a4db05020ac928333475a029aa93c
+size 17614067314

data/ticks/041.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:282deff9e2448ef9af7aa5226fb8b0ed29949d8d44609697bdc4454ade065f28
-size 6500208522
+oid sha256:473fccdc7b8871ff5385b812439dd5887e85f5429624e49fe93f91eac7278b66
+size 6547243758

data/ticks/042.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:78ea5cc388362fa1b52bac6c704a0427aeccf5943fef57bc77ac4accbc077f8f
-size 7825522339
+oid sha256:b2d098902b863dece24dd62a96265783298d0e9b93d9e7654b5360a634918912
+size 7889765448

data/ticks/043.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:38d7090e54ce702c2d0d3d47406ad5467cfc3276fbd4bd92d43bcd3449256d56
-size 15964728527
+oid sha256:780c3bfab099e7833269f4c906440a143d262958c95e2c81f86171c4f7a37eed
+size 16087819174

data/ticks/044.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:99fbbd84b6865b68c91c65f4435eb620b35d34b9c4803a60e58abe909bf9caf4
-size 12351398426
+oid sha256:8f56132f2fc45c5bc318fde4aa9313386b01c1f525d91f48bdd7db5bd8a175f0
+size 7716259964

previews/013/thermal.mp4

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:84fb87117f04f930df5e8e308c56c372a72d45f27f62f3471ab5a90234719436
-size 55420929
+oid sha256:d394714e25951d74b837b619e856e2c44cd5c1495650483dd50c556e8ed73768
+size 9736266

scripts/_lib.py

@@ -1,8 +1,8 @@
 """Shared paths and helpers for the extract scripts.
 
-The raw data lives in a sibling Git repo (the recorder). This dataset has no
-local source files; every extract script reads from `EXPORTS_DIR` and writes
-to `DATA_DIR`.
+The raw data lives in the recorder repo, which contains this dataset as a
+submodule (`datasets/Inova-Mk1-Telemetry`). This dataset has no local source
+files; every extract script reads from `EXPORTS_DIR` and writes to `DATA_DIR`.
 """
 import json
 from pathlib import Path
@@ -10,11 +10,12 @@ from pathlib import Path
 ROOT = Path(__file__).parent.parent
 DATA_DIR = ROOT / "data"
 
-# Sibling-repo location. The Telemetry dataset has no local source/ tree;
+# Recorder-repo location. The Telemetry dataset has no local source/ tree;
 # its raw inputs are the flat exports written by
 # `Agentic-Additive-Manufacturing-Process-Optimization/scripts/export.py`.
-# /mnt/storage2/HuggingFace/Datasets/Inova-Mk1-Telemetry → up three to /mnt/storage2.
-AGENTIC_ROOT = ROOT.parent.parent.parent / "GitHub" / "Agentic-Additive-Manufacturing-Process-Optimization"
+# This repo is a submodule at `datasets/Inova-Mk1-Telemetry` inside the
+# recorder repo → two climbs from ROOT reach the recorder root.
+AGENTIC_ROOT = ROOT.parent.parent
 EXPORTS_DIR = AGENTIC_ROOT / "data" / "exports"
 
 

scripts/previews/01_render.py

@@ -16,6 +16,11 @@ Source is the dataset's own parquet — no recorder repo needed. The trade-off
 is that ~half of upstream-captured frames don't survive the per-tick attach,
 so motion looks chunkier than playing the raw recorder frames would.
 
+The thermal panel is rendered from the raw `bedmatrix` IR grid (inferno colormap
+over a fixed absolute °C range; see _thermal.py) whenever it's present — builds
+013+. The three earliest builds (001/002/012) predate the bedmatrix stream and
+fall back to the legacy pre-rendered `frame_thermal` GIF.
+
 Usage:
     uv run scripts/previews/01_render.py            # all builds in data/ticks/
     uv run scripts/previews/01_render.py 13 26      # specific build ids
@@ -35,12 +40,17 @@ import pyarrow.parquet as pq
 from PIL import Image
 
 sys.path.insert(0, str(Path(__file__).parent.parent))
+sys.path.insert(0, str(Path(__file__).parent))
 from _lib import DATA_DIR
+from _thermal import bedmatrix_to_image
 
 OUTPUT_DIR = DATA_DIR.parent / "previews"
 TICKS_DIR = DATA_DIR / "ticks"
 # Order here = left-to-right order in the composite panel.
 FRAME_KINDS = ("chamber", "thermal", "galvo")
+# The thermal panel is rendered from the raw `bedmatrix` IR grid when present
+# (builds 013+), falling back to the legacy `frame_thermal` GIF for the three
+# earliest builds (001/002/012) that predate the bedmatrix stream.
 # Per-kind rotation applied post-decode (degrees clockwise). The chamber camera
 # is mounted sideways on the printer, so its raw frames need a 90° CW correction
 # before rendering. Other kinds are captured already in display orientation.
@@ -78,6 +88,40 @@ def _decode_raw(frame_struct, kind: str) -> Image.Image | None:
     return img
 
 
+def _decode_cell(cell, kind: str) -> Image.Image | None:
+    """Decode one struct cell to a PIL RGB image, dispatching on struct shape:
+    a `bedmatrix` struct (has 'values') renders as an inferno heatmap; a frame
+    Image struct (has 'bytes') decodes + orientation-corrects. None when missing."""
+    if cell is None:
+        return None
+    if "values" in cell:
+        return bedmatrix_to_image(cell)
+    return _decode_raw(cell, kind)
+
+
+def _thermal_column(parquet_path: Path) -> str:
+    """Which column feeds the thermal panel for this build: 'bedmatrix' when the
+    raw IR matrix has any non-null cell, else the legacy 'frame_thermal'. The
+    bedmatrix stream started at build 013, so 001/002/012 fall back to the GIF."""
+    pf = pq.ParquetFile(parquet_path)
+    if "bedmatrix" not in {f.name for f in pf.schema_arrow}:
+        return "frame_thermal"
+    for batch in pf.iter_batches(columns=["bedmatrix"], batch_size=BATCH_ROWS):
+        for cell in batch.column("bedmatrix").to_pylist():
+            if cell is not None:
+                return "bedmatrix"
+    return "frame_thermal"
+
+
+def _columns_for_build(parquet_path: Path) -> dict[str, str]:
+    """Map each panel kind → the parquet column that feeds it for this build."""
+    return {
+        "chamber": "frame_chamber",
+        "thermal": _thermal_column(parquet_path),
+        "galvo":   "frame_galvo",
+    }
+
+
 def _fit_to_canvas(img: Image.Image, canvas_w: int) -> np.ndarray:
     """Letterbox `img` into a (canvas_w × PANEL_HEIGHT) gray canvas, preserving aspect.
     Locking on the canvas dims is required because some builds have frames whose
@@ -129,23 +173,22 @@ def _open_writer(out_path: Path):
     )
 
 
-def _probe_first_frame_width(parquet_path: Path, kind: str) -> int | None:
-    """Find the first non-null frame of `kind`, compute the locked canvas width
-    from its post-rotation aspect ratio (height = PANEL_HEIGHT). Returns None if
+def _probe_first_frame_width(parquet_path: Path, kind: str, col: str) -> int | None:
+    """Find the first non-null cell in `col`, compute the locked canvas width
+    from its post-decode aspect ratio (height = PANEL_HEIGHT). Returns None if
     no frame of that kind ever appears."""
-    for n_rows, cols in _iter_struct_batches(parquet_path, [f"frame_{kind}"]):
-        for struct in cols[f"frame_{kind}"]:
-            img = _decode_raw(struct, kind)
+    for n_rows, cols in _iter_struct_batches(parquet_path, [col]):
+        for struct in cols[col]:
+            img = _decode_cell(struct, kind)
             if img is not None:
                 sw, sh = img.size
                 return _even(max(2, round(sw * PANEL_HEIGHT / sh)))
     return None
 
 
-def render_per_kind(parquet_path: Path, kind: str, out_path: Path) -> int:
-    """Write one MP4 of a single frame kind, forward-filled. Returns frame count."""
-    col = f"frame_{kind}"
-    width = _probe_first_frame_width(parquet_path, kind)
+def render_per_kind(parquet_path: Path, kind: str, out_path: Path, col: str) -> int:
+    """Write one MP4 of a single panel kind, forward-filled. Returns frame count."""
+    width = _probe_first_frame_width(parquet_path, kind, col)
     if width is None:
         # No frames of this kind exist for this build; nothing meaningful to render.
         print(f"  {kind:8s}: no frames of this kind, skipping")
@@ -155,7 +198,7 @@ def render_per_kind(parquet_path: Path, kind: str, out_path: Path) -> int:
     with _open_writer(out_path) as writer:
         for n_rows, cols in _iter_struct_batches(parquet_path, [col]):
             for struct in cols[col]:
-                img = _decode_raw(struct, kind)
+                img = _decode_cell(struct, kind)
                 if img is not None:
                     last = _fit_to_canvas(img, width)
                 writer.append_data(last if last is not None else _placeholder(width))
@@ -163,19 +206,19 @@ def render_per_kind(parquet_path: Path, kind: str, out_path: Path) -> int:
     return frames_written
 
 
-def render_composite(parquet_path: Path, out_path: Path) -> int:
+def render_composite(parquet_path: Path, out_path: Path, cols_map: dict[str, str]) -> int:
     """Write the 1×3 composite. All three panels share the tick timeline."""
     # Lock canvas widths up front so all subsequent frames letterbox into a fixed shape.
-    widths = {k: (_probe_first_frame_width(parquet_path, k) or PANEL_HEIGHT)
+    widths = {k: (_probe_first_frame_width(parquet_path, k, cols_map[k]) or PANEL_HEIGHT)
               for k in FRAME_KINDS}
-    cols_to_read = [f"frame_{k}" for k in FRAME_KINDS]
+    cols_to_read = [cols_map[k] for k in FRAME_KINDS]
     last: dict[str, np.ndarray | None] = {k: None for k in FRAME_KINDS}
     frames_written = 0
     with _open_writer(out_path) as writer:
         for n_rows, cols in _iter_struct_batches(parquet_path, cols_to_read):
             for i in range(n_rows):
                 for k in FRAME_KINDS:
-                    img = _decode_raw(cols[f"frame_{k}"][i], k)
+                    img = _decode_cell(cols[cols_map[k]][i], k)
                     if img is not None:
                         last[k] = _fit_to_canvas(img, widths[k])
                 panels = [
@@ -194,18 +237,21 @@ def process_build(build_id: int, kinds: set[str]) -> None:
         return
     build_dir = OUTPUT_DIR / f"{build_id:03d}"
     print(f"build {build_id:03d}: rendering → {build_dir.relative_to(Path.cwd())}/")
+    cols_map = _columns_for_build(parquet_path)
+    if ("thermal" in kinds or "composite" in kinds):
+        print(f"  thermal source: {cols_map['thermal']}")
     for kind in FRAME_KINDS:
         if kind not in kinds:
             continue
         out = build_dir / f"{kind}.mp4"
-        n = render_per_kind(parquet_path, kind, out)
+        n = render_per_kind(parquet_path, kind, out, cols_map[kind])
         # render_per_kind skips writing entirely when no frames of this kind exist
         # (and prints its own "skipping" line). Guard stat to avoid FileNotFoundError.
         if out.exists():
             print(f"  {kind:8s}: {n:>7,} frames → {out.name} ({out.stat().st_size:,} bytes)")
     if "composite" in kinds:
         out = build_dir / "composite.mp4"
-        n = render_composite(parquet_path, out)
+        n = render_composite(parquet_path, out, cols_map)
         if out.exists():
             print(f"  composite: {n:>7,} frames → {out.name} ({out.stat().st_size:,} bytes)")
 

scripts/previews/02_timelapse.py

@@ -16,6 +16,11 @@ the most-recent view of the layer just before recoating begins.
 Null-frame levels are forward-filled from the most recent non-null level of the
 same kind, so the GIF never shows a blank panel mid-timelapse.
 
+The thermal panel is rendered from the raw `bedmatrix` IR grid (inferno colormap
+over a fixed absolute °C range; see _thermal.py) whenever it's present — builds
+013+. The three earliest builds (001/002/012) predate the bedmatrix stream and
+fall back to the legacy pre-rendered `frame_thermal` GIF.
+
 Subsampled to at most MAX_FRAMES (default 300). At GIF_FPS=25 that gives
 a max 12-second GIF. Builds with fewer detected layers are not padded.
 
@@ -35,13 +40,18 @@ import pyarrow.parquet as pq
 from PIL import Image, ImageStat
 
 sys.path.insert(0, str(Path(__file__).parent.parent))
+sys.path.insert(0, str(Path(__file__).parent))
 from _lib import DATA_DIR
+from _thermal import bedmatrix_to_image
 
 OUTPUT_DIR = DATA_DIR.parent / "previews"
 TICKS_DIR  = DATA_DIR / "ticks"
 
 FRAME_KINDS        = ("chamber", "thermal", "galvo")
 KIND_ROTATION_CW   = {"chamber": 90}  # degrees; see _decode_raw
+# The thermal panel renders from the raw `bedmatrix` IR grid when present
+# (builds 013+), falling back to the legacy `frame_thermal` GIF for the three
+# earliest builds (001/002/012) that predate the bedmatrix stream.
 
 GIF_FPS            = 25
 GIF_DURATION_MS    = int(1000 / GIF_FPS)   # 40 ms per frame
@@ -82,6 +92,49 @@ def _decode_raw(b: bytes, kind: str) -> Image.Image | None:
     return img
 
 
+def _decode_cell(cell, kind: str) -> Image.Image | None:
+    """Decode one struct cell to a PIL RGB image, dispatching on struct shape:
+    a `bedmatrix` struct (has 'values') renders as an inferno heatmap; a frame
+    Image struct (has 'bytes') decodes + orientation-corrects. None when missing."""
+    if cell is None:
+        return None
+    if "values" in cell:
+        return bedmatrix_to_image(cell)
+    return _decode_raw(cell.get("bytes"), kind)
+
+
+def _thermal_column(parquet_path: Path) -> str:
+    """Which column feeds the thermal panel for this build: 'bedmatrix' when the
+    raw IR matrix has any non-null cell, else the legacy 'frame_thermal'. The
+    bedmatrix stream started at build 013, so 001/002/012 fall back to the GIF."""
+    pf = pq.ParquetFile(parquet_path)
+    if "bedmatrix" not in {f.name for f in pf.schema_arrow}:
+        return "frame_thermal"
+    for batch in pf.iter_batches(columns=["bedmatrix"], batch_size=BATCH_ROWS):
+        for cell in batch.column("bedmatrix").to_pylist():
+            if cell is not None:
+                return "bedmatrix"
+    return "frame_thermal"
+
+
+def _columns_for_build(parquet_path: Path) -> dict[str, str]:
+    """Map each panel kind → the parquet column that feeds it for this build."""
+    return {
+        "chamber": "frame_chamber",
+        "thermal": _thermal_column(parquet_path),
+        "galvo":   "frame_galvo",
+    }
+
+
+def _canvas_width(cell, kind: str) -> int:
+    """Decode one cell to determine the locked canvas width for this kind."""
+    img = _decode_cell(cell, kind)
+    if img is None:
+        return GIF_PANEL_HEIGHT  # square fallback
+    sw, sh = img.size
+    return max(2, round(sw * GIF_PANEL_HEIGHT / sh))
+
+
 def _fit_to_canvas(img: Image.Image, canvas_w: int) -> Image.Image:
     """Letterbox img into (canvas_w × GIF_PANEL_HEIGHT) with dark-gray fill."""
     sw, sh = img.size
@@ -110,78 +163,63 @@ def _chamber_threshold(decoded_frames: list[Image.Image | None]) -> float:
     return max(brightnesses) * CHAMBER_BRIGHTNESS_RATIO if brightnesses else 0.0
 
 
-def _canvas_width_from_bytes(b: bytes, kind: str) -> int:
-    """Decode one frame to determine the locked canvas width for this kind."""
-    img = _decode_raw(b, kind)
-    if img is None:
-        return GIF_PANEL_HEIGHT  # square fallback
-    sw, sh = img.size
-    return max(2, round(sw * GIF_PANEL_HEIGHT / sh))
-
-
 # ---------------------------------------------------------------------------
 # Layer data collection
 # ---------------------------------------------------------------------------
 
-def collect_layer_bytes(parquet_path: Path, kind: str) -> dict[int, bytes]:
-    """Single-pass stream → {z2_level: last_non_null_bytes}.
+def collect_layer_cells(parquet_path: Path, kind: str, col: str) -> dict[int, dict]:
+    """Single-pass stream → {z2_level: last_non_null_struct}.
 
     Only z2 > 0 rows are included. The dict is keyed by int(z2 / LAYER_QUANTIZE_UM);
-    each entry holds the bytes of the *last* non-null frame seen at that level.
-    Reads only two parquet columns (z2 + one frame kind) for efficiency.
+    each entry holds the *last* non-null struct cell seen at that level (a frame
+    Image struct, or a bedmatrix struct for the thermal panel). Reads only two
+    parquet columns (z2 + the source column) for efficiency.
     """
-    frame_col = f"frame_{kind}"
-    z2_col    = "positions.position.z2"
-    pf        = pq.ParquetFile(parquet_path)
-    present   = {f.name for f in pf.schema_arrow}
-    if frame_col not in present or z2_col not in present:
+    z2_col  = "positions.position.z2"
+    pf      = pq.ParquetFile(parquet_path)
+    present = {f.name for f in pf.schema_arrow}
+    if col not in present or z2_col not in present:
         return {}
 
-    layer_data: dict[int, bytes] = {}
-    for batch in pf.iter_batches(columns=[z2_col, frame_col], batch_size=BATCH_ROWS):
-        z2_list    = batch.column(z2_col).to_pylist()
-        frame_list = batch.column(frame_col).to_pylist()
-        for z2, struct in zip(z2_list, frame_list):
+    layer_data: dict[int, dict] = {}
+    for batch in pf.iter_batches(columns=[z2_col, col], batch_size=BATCH_ROWS):
+        z2_list   = batch.column(z2_col).to_pylist()
+        cell_list = batch.column(col).to_pylist()
+        for z2, cell in zip(z2_list, cell_list):
             if z2 is None or z2 <= 0:
                 continue
-            level = int(z2 / LAYER_QUANTIZE_UM)
-            if struct is not None:
-                b = struct.get("bytes")
-                if b:
-                    layer_data[level] = b
+            if cell is not None:
+                layer_data[int(z2 / LAYER_QUANTIZE_UM)] = cell
     return layer_data
 
 
-def collect_all_kinds(parquet_path: Path) -> dict[str, dict[int, bytes]]:
+def collect_all_kinds(parquet_path: Path, cols_map: dict[str, str]) -> dict[str, dict[int, dict]]:
     """Single streaming pass collecting all three kinds simultaneously.
 
     Used by render_timelapse_composite so we don't make three separate passes
-    through (potentially 17+ GB) parquet files. Reads four columns: z2 + the
-    three frame columns. Each kind gets its own {z2_level: bytes} dict.
+    through (potentially 17+ GB) parquet files. Reads four columns: z2 + each
+    kind's source column. Each kind gets its own {z2_level: struct} dict.
     """
     z2_col    = "positions.position.z2"
     pf        = pq.ParquetFile(parquet_path)
     present   = {f.name for f in pf.schema_arrow}
-    read_cols = [c for c in ([z2_col] + [f"frame_{k}" for k in FRAME_KINDS]) if c in present]
+    read_cols = [c for c in ([z2_col] + [cols_map[k] for k in FRAME_KINDS]) if c in present]
     if z2_col not in read_cols:
         return {k: {} for k in FRAME_KINDS}
 
-    layer_data: dict[str, dict[int, bytes]] = {k: {} for k in FRAME_KINDS}
+    layer_data: dict[str, dict[int, dict]] = {k: {} for k in FRAME_KINDS}
     for batch in pf.iter_batches(columns=read_cols, batch_size=BATCH_ROWS):
         z2_list = batch.column(z2_col).to_pylist()
         for kind in FRAME_KINDS:
-            col = f"frame_{kind}"
+            col = cols_map[kind]
             if col not in read_cols:
                 continue
-            frame_list = batch.column(col).to_pylist()
-            for z2, struct in zip(z2_list, frame_list):
+            cell_list = batch.column(col).to_pylist()
+            for z2, cell in zip(z2_list, cell_list):
                 if z2 is None or z2 <= 0:
                     continue
-                level = int(z2 / LAYER_QUANTIZE_UM)
-                if struct is not None:
-                    b = struct.get("bytes")
-                    if b:
-                        layer_data[kind][level] = b
+                if cell is not None:
+                    layer_data[kind][int(z2 / LAYER_QUANTIZE_UM)] = cell
     return layer_data
 
 
@@ -238,25 +276,25 @@ def _write_gif(frames: list[Image.Image], out_path: Path) -> None:
 # Per-build renderers
 # ---------------------------------------------------------------------------
 
-def render_timelapse_kind(parquet_path: Path, kind: str, out_path: Path) -> int:
+def render_timelapse_kind(parquet_path: Path, kind: str, out_path: Path, col: str) -> int:
     """Write timelapse_{kind}.gif. Returns number of GIF frames written.
 
     Chamber only: dark frames (halogens off) are dropped entirely so the GIF
     shows only moments where the part is visible. Thermal and galvo are
     unaffected — they don't depend on halogen lighting.
     """
-    layer_bytes = collect_layer_bytes(parquet_path, kind)
-    if not layer_bytes:
+    layer_cells = collect_layer_cells(parquet_path, kind, col)
+    if not layer_cells:
         print(f"  {kind:8s}: no printing-phase frames (z2 > 0), skipping")
         return 0
 
-    sorted_levels = sorted(layer_bytes)
+    sorted_levels = sorted(layer_cells)
     target_levels = _subsample(sorted_levels)
-    fill_bytes    = _forward_fill(layer_bytes, target_levels)
-    canvas_w      = _canvas_width_from_bytes(next(b for b in fill_bytes if b), kind)
+    fill_cells    = _forward_fill(layer_cells, target_levels)
+    canvas_w      = _canvas_width(next(c for c in fill_cells if c), kind)
 
     # Decode all selected frames up front (needed for brightness scan on chamber).
-    decoded = [_decode_raw(b, kind) if b else None for b in fill_bytes]
+    decoded = [_decode_cell(c, kind) for c in fill_cells]
 
     if kind == "chamber":
         # Compute brightness once per decoded frame, then threshold and filter.
@@ -289,7 +327,8 @@ def render_timelapse_kind(parquet_path: Path, kind: str, out_path: Path) -> int:
     return len(pil_frames)
 
 
-def render_timelapse_composite(parquet_path: Path, out_path: Path) -> int:
+def render_timelapse_composite(parquet_path: Path, out_path: Path,
+                               cols_map: dict[str, str]) -> int:
     """Write timelapse_composite.gif (1×3 panel). Single parquet pass.
 
     Thermal and galvo show the actual frame for every layer (unaffected by
@@ -297,28 +336,27 @@ def render_timelapse_composite(parquet_path: Path, out_path: Path) -> int:
     when the current layer's chamber frame is dark — this keeps all three
     panels in layer-sync while never displaying a dark chamber view.
     """
-    all_bytes = collect_all_kinds(parquet_path)
+    all_cells = collect_all_kinds(parquet_path, cols_map)
 
-    all_levels = sorted(set().union(*(set(d) for d in all_bytes.values())))
+    all_levels = sorted(set().union(*(set(d) for d in all_cells.values())))
     if not all_levels:
         print("  composite: no printing-phase frames (z2 > 0), skipping")
         return 0
 
     target_levels = _subsample(all_levels)
-    fill_per_kind = {k: _forward_fill(all_bytes[k], target_levels) for k in FRAME_KINDS}
+    fill_per_kind = {k: _forward_fill(all_cells[k], target_levels) for k in FRAME_KINDS}
 
     canvas_widths: dict[str, int] = {}
     for kind in FRAME_KINDS:
-        first_b = next((b for b in fill_per_kind[kind] if b), None)
+        first_c = next((c for c in fill_per_kind[kind] if c), None)
         canvas_widths[kind] = (
-            _canvas_width_from_bytes(first_b, kind) if first_b else GIF_PANEL_HEIGHT
+            _canvas_width(first_c, kind) if first_c else GIF_PANEL_HEIGHT
         )
     total_w = sum(canvas_widths.values())
 
     # Pre-decode chamber frames once; compute adaptive brightness threshold.
     chamber_decoded = [
-        _decode_raw(b, "chamber") if b else None
-        for b in fill_per_kind["chamber"]
+        _decode_cell(c, "chamber") for c in fill_per_kind["chamber"]
     ]
     chamber_threshold = _chamber_threshold(chamber_decoded)
 
@@ -337,8 +375,7 @@ def render_timelapse_composite(parquet_path: Path, out_path: Path) -> int:
                 # the first bright frame arrives.
                 panel_img = last_bright_chamber
             else:
-                b = fill_per_kind[kind][i]
-                panel_img = _decode_raw(b, kind) if b else None
+                panel_img = _decode_cell(fill_per_kind[kind][i], kind)
 
             panel = (
                 _fit_to_canvas(panel_img, canvas_widths[kind])
@@ -360,19 +397,22 @@ def process_build(build_id: int, kinds: set[str]) -> None:
 
     build_dir = OUTPUT_DIR / f"{build_id:03d}"
     print(f"build {build_id:03d}: timelapse GIFs → {build_dir.relative_to(Path.cwd())}/")
+    cols_map = _columns_for_build(parquet_path)
+    if ("thermal" in kinds or "composite" in kinds):
+        print(f"  thermal source: {cols_map['thermal']}")
 
     for kind in FRAME_KINDS:
         if kind not in kinds:
             continue
         out = build_dir / f"timelapse_{kind}.gif"
-        n = render_timelapse_kind(parquet_path, kind, out)
+        n = render_timelapse_kind(parquet_path, kind, out, cols_map[kind])
         if out.exists():
             size = out.stat().st_size
             print(f"  {kind:8s}: {n:>4} frames → {out.name}  ({size:,} bytes)")
 
     if "composite" in kinds:
         out = build_dir / "timelapse_composite.gif"
-        n = render_timelapse_composite(parquet_path, out)
+        n = render_timelapse_composite(parquet_path, out, cols_map)
         if out.exists():
             size = out.stat().st_size
             print(f"  composite: {n:>4} frames → {out.name}  ({size:,} bytes)")

scripts/previews/_thermal.py

@@ -0,0 +1,82 @@
+"""Shared bedmatrix → thermal heatmap rendering for the preview scripts.
+
+The `bedmatrix` column is the raw 32×24 IR bed-surface temperature grid
+(row-major °C). We colormap it ourselves rather than reuse the legacy
+`frame_thermal` GIF because:
+
+  * `frame_thermal` was a firmware-rendered heatmap whose colormap and scale we
+    never controlled and can't reproduce for new builds — and it's null for
+    builds recorded after 2026-07-12 (see CLAUDE.md).
+  * Rendering from `bedmatrix` gives one consistent look across every build and
+    a temperature scale we choose, so the thermal panel reads as an honest
+    temperature: the same color means the same °C in every build.
+
+Colormap is an inferno approximation (11 anchor colors linearly interpolated to
+256 entries) — faithful enough for a preview without pulling in matplotlib.
+
+Temperature → color uses a FIXED absolute range (`THERMAL_VMIN`..`THERMAL_VMAX`,
+°C). The observed bedmatrix span across builds is ~51–191 °C during sintering;
+the default 20–200 °C covers ambient through peak sinter with headroom and uses
+the full colormap. Override via the THERMAL_VMIN / THERMAL_VMAX env vars.
+"""
+import os
+
+import numpy as np
+from PIL import Image
+
+THERMAL_VMIN = float(os.environ.get("THERMAL_VMIN", 20.0))
+THERMAL_VMAX = float(os.environ.get("THERMAL_VMAX", 200.0))
+
+# Inferno anchor colors at t = 0.0, 0.1, ... 1.0 (RGB 0–255). Sampled from
+# matplotlib's inferno; linearly interpolated per channel to a 256-entry LUT.
+_INFERNO_ANCHORS = np.array([
+    (0,   0,   4),
+    (20,  11,  52),
+    (57,  9,   98),
+    (100, 16,  108),
+    (143, 33,  102),
+    (186, 54,  85),
+    (221, 81,  58),
+    (243, 120, 25),
+    (252, 165, 10),
+    (246, 215, 70),
+    (252, 255, 164),
+], dtype=np.float64)
+
+_LUT: np.ndarray | None = None
+
+
+def _lut() -> np.ndarray:
+    """256×3 uint8 inferno LUT, built once."""
+    global _LUT
+    if _LUT is None:
+        xs = np.linspace(0.0, 1.0, len(_INFERNO_ANCHORS))
+        grid = np.linspace(0.0, 1.0, 256)
+        lut = np.empty((256, 3), dtype=np.uint8)
+        for c in range(3):
+            lut[:, c] = np.interp(grid, xs, _INFERNO_ANCHORS[:, c]).round().astype(np.uint8)
+        _LUT = lut
+    return _LUT
+
+
+def bedmatrix_to_image(bm) -> Image.Image | None:
+    """Render a `bedmatrix` struct → PIL RGB heatmap at native grid resolution.
+
+    `bm` is the struct dict {width, height, values (row-major °C), path} or None.
+    Returns a (height × width) RGB image; the caller upscales / letterboxes it.
+    None when the struct is missing or malformed.
+    """
+    if bm is None:
+        return None
+    vals = bm.get("values")
+    w = bm.get("width")
+    h = bm.get("height")
+    if not vals or not w or not h or len(vals) != w * h:
+        return None
+    a = np.asarray(vals, dtype=np.float32).reshape(int(h), int(w))
+    a = np.nan_to_num(a, nan=THERMAL_VMIN)
+    t = (a - THERMAL_VMIN) / (THERMAL_VMAX - THERMAL_VMIN)
+    idx = np.clip(t, 0.0, 1.0)
+    idx = (idx * 255.0).round().astype(np.uint8)
+    rgb = _lut()[idx]  # (h, w, 3)
+    return Image.fromarray(rgb, "RGB")

scripts/ticks/01_extract.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """Build the `ticks` config: one row per 10 Hz telemetry tick per build.
 
-Reads upstream flat exports from the sibling recorder repo:
+Reads upstream flat exports from the containing recorder repo:
   builds.jsonl, telemetry/{build_id}.parquet, frames.jsonl, position_hf/{build_id}.parquet
 
 For each build with telemetry, emits `data/ticks/{build_id:03d}.parquet`
@@ -11,6 +11,12 @@ For each build with telemetry, emits `data/ticks/{build_id:03d}.parquet`
   - Denormalized build context (build_id, job_name, ..., print_profile_name)
   - frame_chamber / frame_galvo / frame_thermal: nearest frame path in
     [tick_ts - 100ms, tick_ts], null when no frame fell in that window
+    (frame_thermal is the legacy bedmatrix GIF heatmap; recorder stopped
+    producing it after 2026-07-12, so it is null for builds captured since)
+  - bedmatrix: nearest IR temperature matrix in the same 100ms window, as a
+    struct {width, height, values (row-major °C), path}; null when none.
+    This is the raw 32x24 bed-surface temperature grid the recorder now streams
+    as JSON in place of the old rendered frame_thermal heatmap.
   - position_hf_burst: list of {ts_offset_ms, x, y, z1, z2, r, has_homed}
     for all position_hf events in the same 100ms window
 
@@ -18,6 +24,7 @@ Usage:
     uv run scripts/ticks/01_extract.py            # all builds with telemetry
     uv run scripts/ticks/01_extract.py 13 26      # specific build ids
 """
+import json
 import sys
 from datetime import timedelta
 from pathlib import Path
@@ -33,6 +40,10 @@ from _lib import EXPORTS_DIR, DATA_DIR, iter_jsonl, load_build_to_profile_name
 OUTPUT_DIR = DATA_DIR / "ticks"
 WINDOW = timedelta(milliseconds=100)  # 10 Hz tick interval
 FRAME_KINDS = ("chamber", "galvo", "thermal")
+# The IR temperature matrix. Same underlying sensor the legacy frame_thermal GIF
+# was rendered from, but streamed as a raw {width, height, values} JSON grid.
+# Attached like a frame (nearest-before-tick), embedded as a numeric struct.
+BEDMATRIX_KIND = "bedmatrix"
 # frame_* path strings are relative to this directory in the upstream recorder repo.
 FRAMES_DIR = EXPORTS_DIR.parent / "frames"
 # HF Image feature wire format. Both fields nullable; the struct itself is null when no frame.
@@ -40,6 +51,15 @@ IMAGE_STRUCT_TYPE = pa.struct([
     pa.field("bytes", pa.binary()),
     pa.field("path",  pa.string()),
 ])
+# Bedmatrix numeric struct. `values` is row-major, length width*height (32*24=768),
+# temperatures in °C as float32 (firmware sends ~0.01°C resolution; f32 is ample).
+# The whole struct is null when no matrix fell in the tick window.
+BEDMATRIX_STRUCT_TYPE = pa.struct([
+    pa.field("width",  pa.int32()),
+    pa.field("height", pa.int32()),
+    pa.field("values", pa.list_(pa.float32())),
+    pa.field("path",   pa.string()),
+])
 # Streaming chunk size in rows. Tuned so peak embedded payload per chunk stays
 # under ~1 GB (thermal frames dominate at ~315 KB each).
 CHUNK_ROWS = 2_000
@@ -93,6 +113,22 @@ def attach_frames(wide: pl.DataFrame, frames: pl.DataFrame) -> pl.DataFrame:
     return wide
 
 
+def attach_bedmatrix(wide: pl.DataFrame, frames: pl.DataFrame) -> pl.DataFrame:
+    """Attach the nearest bedmatrix path within WINDOW prior to tick_ts as a
+    string column `bedmatrix` (parsed into a numeric struct at write time,
+    exactly like the frame_* path columns)."""
+    f = (
+        frames.filter(pl.col("kind") == BEDMATRIX_KIND)
+        .select(pl.col("ts"), pl.col("path").alias("bedmatrix"))
+        .sort("ts")
+    )
+    if f.height == 0:
+        return wide.with_columns(pl.lit(None, dtype=pl.String).alias("bedmatrix"))
+    return wide.sort("ts").join_asof(
+        f, on="ts", strategy="backward", tolerance=WINDOW
+    )
+
+
 def attach_position_hf(wide: pl.DataFrame, build_id: int) -> pl.DataFrame:
     """Append a `position_hf_burst` column: list of structs of position_hf events
     in (tick_ts - WINDOW, tick_ts]. Empty list when no events in window or no parquet."""
@@ -174,25 +210,63 @@ def _embed_frame_column(paths: list[str | None]) -> pa.Array:
     )
 
 
+def _embed_bedmatrix_column(paths: list[str | None]) -> pa.Array:
+    """For one chunk's paths, read each bedmatrix JSON from disk and return a
+    StructArray of {width, height, values, path}. Missing path, missing-on-disk,
+    or unparseable JSON → null struct (warn-free continue, same as frames)."""
+    widths:  list[int | None]         = []
+    heights: list[int | None]         = []
+    values:  list[list[float] | None] = []
+    kept:    list[str | None]         = []
+    for p in paths:
+        if p is None:
+            widths.append(None); heights.append(None); values.append(None); kept.append(None)
+            continue
+        try:
+            d = json.loads((FRAMES_DIR / p).read_bytes())
+            widths.append(d.get("width"))
+            heights.append(d.get("height"))
+            values.append([float(v) for v in d["values"]])
+            kept.append(p)
+        except (FileNotFoundError, KeyError, ValueError, TypeError):
+            widths.append(None); heights.append(None); values.append(None); kept.append(None)
+    mask = pa.array([p is None for p in kept], type=pa.bool_())
+    return pa.StructArray.from_arrays(
+        [
+            pa.array(widths,  type=pa.int32()),
+            pa.array(heights, type=pa.int32()),
+            pa.array(values,  type=pa.list_(pa.float32())),
+            pa.array(kept,    type=pa.string()),
+        ],
+        fields=list(BEDMATRIX_STRUCT_TYPE),
+        mask=mask,
+    )
+
+
 def _make_output_schema(wide_arrow_schema: pa.Schema) -> pa.Schema:
-    """Replace frame_* string fields with HF Image struct fields."""
+    """Replace frame_* string fields with HF Image structs and the bedmatrix
+    path string with its numeric struct."""
     new_fields = []
     image_field_names = {f"frame_{k}" for k in FRAME_KINDS}
     for field in wide_arrow_schema:
         if field.name in image_field_names:
             new_fields.append(pa.field(field.name, IMAGE_STRUCT_TYPE))
+        elif field.name == "bedmatrix":
+            new_fields.append(pa.field("bedmatrix", BEDMATRIX_STRUCT_TYPE))
         else:
             new_fields.append(field)
     return pa.schema(new_fields)
 
 
 def _embed_chunk(chunk: pa.Table, output_schema: pa.Schema) -> pa.Table:
-    """Swap frame_* string columns for embedded image structs in this chunk."""
+    """Swap frame_* and bedmatrix string columns for embedded structs in this chunk."""
+    image_names = {f"frame_{k}" for k in FRAME_KINDS}
     arrays = []
     for field in output_schema:
-        if field.name in {f"frame_{k}" for k in FRAME_KINDS}:
-            paths = chunk[field.name].to_pylist()
-            arrays.append(_embed_frame_column(paths))
+        if field.name in image_names:
+            arrays.append(_embed_frame_column(chunk[field.name].to_pylist()))
+        elif field.name == "bedmatrix":
+            arrays.append(_embed_bedmatrix_column(chunk[field.name].to_pylist()))
         else:
             arrays.append(chunk[field.name].combine_chunks())
     return pa.Table.from_arrays(arrays, schema=output_schema)
@@ -211,14 +285,15 @@ def process_build(build_id: int, builds_index: dict[int, dict],
     wide = pivot_telemetry(tel)
     frames = load_frames_for_build(build_id)
     wide = attach_frames(wide, frames)
+    wide = attach_bedmatrix(wide, frames)
     wide = attach_position_hf(wide, build_id)
     wide = denormalize_build(wide, builds_index[build_id], profile_name_lookup)
 
-    # Put build context + ts first, then sensors, then frames + burst.
+    # Put build context + ts first, then sensors, then frames + bedmatrix + burst.
     leading = ["build_id", "ts", "job_name", "started_at", "ended_at", "phase",
                "print_profile_name", "inova_session_id"]
     frame_cols = [f"frame_{k}" for k in FRAME_KINDS]
-    trailing = frame_cols + ["position_hf_burst"]
+    trailing = frame_cols + ["bedmatrix", "position_hf_burst"]
     middle = [c for c in wide.columns if c not in leading and c not in trailing]
     wide = wide.select(leading + middle + trailing)