Adds parquet files.

CLAUDE.md

@@ -1,49 +1,295 @@
 # CLAUDE.md
 
-Context for continuing work on this dataset. Captures the design decisions and conventions worked out so far.
+Context for continuing work on this dataset. Captures the design decisions, conventions, and operational details worked out so far. Read this before touching the ETL or schema.
 
 ## What this dataset is
 
-`Inova-Mk1-Telemetry` is the **tick-anchored printer-state dataset**: one row per 10 Hz recorder tick, with the full sensor snapshot (~64 columns: temperatures, position, power, lights) on every row, the nearest camera frame paths attached when one fell in the prior 100 ms window, and 1 kHz `position_hf` events from that window collected as a per-tick list.
+`Inova-Mk1-Telemetry` is the **tick-anchored printer-state dataset**: one row per 10 Hz recorder tick, with the full sensor snapshot (~64 columns: temperatures, position, power, lights) on every row, the nearest camera frame bytes embedded inline when one fell in the prior 100 ms window, and 1 kHz `position_hf` events from that window collected as a per-tick list.
 
 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 the sibling recorder repo (`Agentic-Additive-Manufacturing-Process-Optimization`). 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 a sibling Git repo (`Agentic-Additive-Manufacturing-Process-Optimization`, "the recorder"). The ETL here reshapes those flat exports into one parquet file per build.
 
-## Ecosystem
+## Data lineage — printer to row
 
-- **Upstream recorder repo**: `Agentic-Additive-Manufacturing-Process-Optimization` — a TypeScript + Python project that polls the Inova plugin's REST API and WS streams and writes to a local Postgres + image files on disk. Its `scripts/export.py` dumps the tables to flat files under `data/exports/`.
-  - Authoritative source for sensor semantics: `sls4all/Inova-API-Plugin/InovaApiPlugin.cs` (the `/state/snapshot` endpoint) and `server/src/recorder/telemetry.ts` (the `expand()` function that explodes one snapshot into the deterministic ~64 telemetry rows).
-- **Upstream graph dataset**: `ppak10/Inova-Mk1-Database` — print jobs, sessions, profiles, objects. Used here only as a join target via `print_profile_id`.
-- **Sibling domain dataset**: `ppak10/Inova-Mk1-ASTM` — mechanical-test specimens. No direct relationship.
+End-to-end, before this dataset's ETL touches anything:
+
+```
+┌────────────────────────────┐
+│  Inova Mk1 SLS printer     │  firmware events: position, temp, power, lights;
+│  (SLS4All.Compact)         │  camera frames (chamber, galvo, thermal);
+│  on 192.168.1.146          │  high-rate position events (~1 kHz, native).
+└──────────────┬─────────────┘
+               │  HTTP (port 5001) + WebSocket
+               ▼
+┌────────────────────────────┐
+│  Inova-API-Plugin          │  C# plugin running inside the printer firmware.
+│  (sls4all/Inova-API-Plugin)│  Authoritative source for sensor semantics:
+│                            │    • InovaApiPlugin.cs  → defines /state/snapshot
+│                            │    • exposes /movement/position/stream (~1 kHz WS)
+│                            │    • exposes /temperature/bedmatrix/stream (~2 Hz WS)
+│                            │    • exposes /plotter/commands/stream (per slicer cmd)
+└──────────────┬─────────────┘
+               │  REST polling + WS streams
+               ▼
+┌────────────────────────────┐
+│  Recorder repo             │  TypeScript/Fastify server runs as a long-lived
+│  (Agentic-Additive-…-Opt)  │  background process; writes to Postgres + image
+│                            │  files on disk.
+│                            │    server/src/recorder/telemetry.ts
+│                            │      • polls /state/snapshot @ 10 Hz
+│                            │      • expand() explodes each frame into the
+│                            │        deterministic ~64 (sensor_id, kind) rows
+│                            │        of the `telemetry` table
+│                            │    server/src/recorder/positionStream.ts
+│                            │      • subscribes WS /movement/position/stream
+│                            │      • writes `position_hf` rows on motion events
+│                            │    server/src/recorder/camera.ts
+│                            │      • polls firmware HTTP frame endpoints
+│                            │      • writes JPG/PNG/GIF to data/frames/{build}/
+│                            │      • writes one row per file in `frames` table
+└──────────────┬─────────────┘
+               │  scripts/export.py (in the recorder repo)
+               ▼
+┌────────────────────────────┐
+│  Flat exports              │  Idempotent dumps of the live Postgres + frame
+│  data/exports/             │  files. Contract surface between the recorder
+│  in the recorder repo      │  repo and this dataset.
+│                            │    builds.jsonl                       — 30 builds
+│                            │    events.jsonl                       — sparse
+│                            │    frames.jsonl                       — ~1.27 M
+│                            │    plotter_commands.jsonl             — 0 rows
+│                            │    telemetry/{build_id}.parquet       — ~10 files
+│                            │    position_hf/{build_id}.parquet     — sparse
+│                            │    build_to_inova_session.csv         — sidecar
+│                            │    sensors.csv                        — sidecar
+└──────────────┬─────────────┘
+               │  scripts/ticks/01_extract.py (here)
+               ▼
+┌────────────────────────────┐
+│  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.
+└────────────────────────────┘
+```
+
+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.
+
+## How the data is captured
+
+### The repos
+
+Two GitHub repos own the upstream data path. Both belong to the same user; neither is a fork.
+
+| Repo | URL | What it is |
+|---|---|---|
+| Recorder | https://github.com/ppak10/Agentic-Additive-Manufacturing-Process-Optimization | TypeScript/Fastify server + dockerized Postgres + Python tooling. Owns the live DB, the image files, and `scripts/export.py`. This dataset's ETL depends on its `data/exports/` tree. |
+| Inova plugin | https://github.com/ppak10/Inova-API-Plugin | C# plugin loaded by the SLS4All firmware on the printer. Exposes the REST + WebSocket endpoints the recorder polls. **Authoritative source for sensor semantics** (`InovaApiPlugin.cs`). |
+
+The recorder also pins **`sls4all/SLS4All.Compact`** as a submodule at tag `public/1.195.0` — that's the SLS4All firmware itself, kept as a read-only vendor reference. Don't touch it; it's there so the plugin can build against a known firmware ABI.
+
+Submodule layout inside the recorder repo:
+```
+sls4all/
+  Inova-API-Plugin/       # the C# plugin (our code; editable)
+  SLS4All.Compact/        # firmware (vendor; pinned)
+datasets/
+  Agentic-SLS/            # legacy submodule, predates the HF dataset layout
+```
+
+### How the recorder runs
+
+The recorder is a single Fastify Node process plus a Postgres container. `server/src/index.ts` starts the HTTP API and **five in-process recorder workers** in parallel:
+
+| Worker | File | What it does |
+|---|---|---|
+| `startTelemetryRecorder` | `server/src/recorder/telemetry.ts` | Subscribes to plugin WS `/state/stream` at `TELEMETRY_HZ`. Calls `expand()` on each frame, batches ~100 rows / 200 ms, writes into `telemetry` table. Source of truth for ~64 sensor columns per tick. |
+| `startCameraRecorder` | `server/src/recorder/camera.ts` | Polls firmware HTTP endpoints at `CAMERA_HZ` for chamber and galvo frames. Writes JPG/PNG bytes to `data/frames/{build_id}/{ts_ms}_{kind}.{ext}` and a row to the `frames` table. |
+| `startBedMatrixRecorder` | `server/src/recorder/bedmatrix.ts` | Polls thermal IR matrix at `THERMAL_HZ`. Writes GIFs (often animated) to disk and frame rows. |
+| `startPositionStreamRecorder` | `server/src/recorder/positionStream.ts` | Subscribes to plugin WS `/movement/position/stream` (~1 kHz native, event-driven). Writes to `position_hf` only on motion. Sparse during heating, bursts during raster. |
+| `startPlotterStreamRecorder` | `server/src/recorder/plotterStream.ts` | Subscribes to plugin WS `/plotter/commands/stream`. Writes one row per CodeCommand to `plotter_commands`. Newer than the historical builds — 0 rows currently. |
+| `startJobDetector` | `server/src/recorder/job.ts` | Watches firmware state to open/close `builds` rows (sets `started_at`, `phase`, `ended_at`). One build is created per print run. |
+
+All workers also write structured rows into `events` on state transitions.
+
+### Runtime configuration
+
+The recorder reads `.env` at startup (`.env.example` in the repo shows the keys, redacted). Key settings:
+
+```ini
+INOVA_API_BASE_URL=http://192.168.1.146:5001    # plugin REST/WS port
+INOVA_FIRMWARE_BASE_URL=http://192.168.1.146    # firmware HTTP port 80
+DATABASE_URL=postgres://inova:inova@localhost:5432/inova
+TELEMETRY_HZ=10
+CAMERA_HZ=5
+THERMAL_HZ=2
+FRAMES_DIR=../data/frames
+```
+
+The `INOVA_API_BASE_URL` is the on-network address of the **physical printer** running the firmware + plugin. If you're working remotely, the recorder can't talk to it; rely on the already-exported flat files in `data/exports/` instead. The Postgres container (`agentic-sls-postgres`) runs locally on the same host as the Fastify server, persisted to `data/postgres/` (root-owned, accessible only inside the container).
+
+### How to bring it up from scratch
+
+Only needed if you're rebuilding the recorder side — this dataset's ETL doesn't require any of it once `data/exports/` exists.
+
+```sh
+# In the recorder repo:
+git clone --recurse-submodules git@github.com:ppak10/Agentic-Additive-Manufacturing-Process-Optimization.git
+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
+```
+
+The recorder writes continuously while a build is live. When you want flat files, run `python scripts/export.py` in the recorder repo — that produces the JSONL/parquet/CSV tree under `data/exports/` that this dataset's ETL consumes.
+
+## Ecosystem (concrete paths)
+
+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/`. |
+| 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.
+
+If you move the repo out of `/mnt/storage2/HuggingFace/Datasets/`, 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.
+- `server/src/recorder/telemetry.ts` lines 25–50 — `expand()` is the only place that defines which `(sensor_id, kind)` rows get written. Every row in the `telemetry` table is one entry from this function. Read this file before assuming what a column means.
+- `server/src/db/schema.sql` — canonical DDL for all 6 Postgres tables.
+
+## Running the ETL
+
+### Prerequisites
+
+1. Sibling recorder repo at the expected path with a populated `data/exports/` directory. If it doesn't exist or is stale, run `scripts/export.py` there first. The recorder DB has to be reachable (Docker container `agentic-sls-postgres`) for the exporter to work.
+2. uv installed; `pyproject.toml` deps (`pyarrow`, `polars`) will be installed via `uv sync` or auto-resolved by `uv run`.
+
+This dataset has **no other repo dependencies** at ETL time. In particular, `Inova-Mk1-Database` is not required — `print_profile_name` is preserved as a string and consumers can resolve the UUID themselves if they want.
+
+### Commands
+
+```sh
+# All builds with telemetry (full rebuild — ~2 hours, ~30 GB output)
+uv run scripts/ticks/01_extract.py
+
+# One or more specific builds (smoke test or incremental)
+uv run scripts/ticks/01_extract.py 13          # ~2 min for build 13
+uv run scripts/ticks/01_extract.py 13 26 28    # build 26 is ~30 min on its own
+```
+
+The script **always overwrites** existing `data/ticks/{build_id:03d}.parquet` files — there's no skip-if-exists check. If you want incremental behavior, pass only the build IDs you want to refresh.
+
+### Expected wall-time and output sizes
+
+From the last full run (10 builds, 1.01 M ticks total, completed 2026-06-24):
+
+| build_id | ticks | size | notes |
+|---:|---:|---:|---|
+| 1 | 102,805 | 2.9 GB | "Hex Coasters" Init/BedPrep phase |
+| 2 | 68 | 2.4 MB | partial — recorder joined mid-run |
+| 12 | 201,660 | 4.6 GB | "Hex Coasters" Layers phase |
+| 13 | 13,811 | 527 MB | "D790 + D638 + Benchy" Heating |
+| 14 | 2 | 48 KB | failed heating attempt |
+| 16 | 14 | 788 KB | failed heating attempt |
+| 17 | 2 | 32 KB | failed heating attempt |
+| 25 | 24 | 1.2 MB | failed heating attempt |
+| 26 | 355,580 | 11 GB | longest run (9h54m) |
+| 28 | 340,162 | 11 GB | 2026-06-07 print, 9h28m |
+| **total** | **1.01 M** | **30 GB** | wall time: **2h 7m** |
+
+Wall time is dominated by IO — each non-null `frame_*` column triggers a disk read from `data/frames/{build_id}/{ts_ms}_{kind}.{ext}` in the recorder repo. CPU/RAM are unremarkable.
+
+### Verifying output
+
+```sh
+# Schema sanity
+uv run python -c "
+import pyarrow.parquet as pq
+pf = pq.ParquetFile('data/ticks/026.parquet')
+print(f'rows: {pf.metadata.num_rows:,}, row_groups: {pf.metadata.num_row_groups}')
+for f in pf.schema_arrow:
+    if f.name.startswith('frame_'):
+        print(f'  {f.name}: {f.type}')
+"
+# Expected: struct<bytes: binary, path: string> on all three frame_* columns.
+
+# Decode one embedded image to confirm bytes are valid
+uv run --with pillow python -c "
+import polars as pl, io
+from PIL import Image
+df = pl.read_parquet('data/ticks/026.parquet', columns=['frame_chamber'])
+row = df.filter(pl.col('frame_chamber').is_not_null()).head(1).row(0, named=True)
+img = Image.open(io.BytesIO(row['frame_chamber']['bytes']))
+print(img.format, img.size)
+"
+# Expected: JPEG (600, 650) or similar.
+
+# Frame-attached rates per build
+uv run python -c "
+import polars as pl
+df = pl.read_parquet('data/ticks/026.parquet',
+    columns=['frame_chamber','frame_galvo','frame_thermal'])
+for c in df.columns:
+    print(f'{c}: {df[c].is_not_null().sum():,} / {df.height:,}')
+"
+# Expected: chamber ~36%, galvo ~37%, thermal ~16%.
+```
+
+## Where humans must intervene
+
+Two pieces of context can't be derived; they live in the recorder repo and someone has to edit them by hand:
+
+- `Agentic-…-Optimization/data/exports/build_to_inova_session.csv` — maps `build_id` → `inova_session_id UUID`. Until filled in, `inova_session_id` is null in every row here and consumers fall back to name-based joining via `print_profile_name`. Recommended cadence: edit when you add a new build that maps to a known `PrintSession`.
+- `Agentic-…-Optimization/data/exports/sensors.csv` — `(sensor_id, kind, unit, description)`. The `unit` and `description` columns are blank by default. This dataset's card cites those values when describing column meanings. Until filled in, we hardcode firmware conventions (temps °C, power W, position microns) in this CLAUDE.md and in the README.
+
+Neither blocks the ETL. They improve dataset metadata.
 
 ## Architectural decisions
 
 - **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 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.
+- **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.
-- **Frames attach by nearest-before-tick within a 100 ms window.** 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. `frame_chamber`, `frame_galvo`, `frame_thermal` as separate nullable string columns.
+- **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.
 - **`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_id`, `print_profile_name`, `inova_session_id` repeat on every row. Parquet dictionary encoding makes this essentially free (~1 byte per row regardless of value).
-- **One parquet file per build.** `data/ticks/{build_id}.parquet`. HF globs `data/ticks/*.parquet` to load the full dataset. Builds without telemetry produce no file; consumers should expect missing build IDs.
+- **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."
+- **One parquet file per build.** `data/ticks/{build_id:03d}.parquet` (zero-padded to 3 digits so a lexical `ls` sorts numerically and the layout caps cleanly at 999 builds). HF globs `data/ticks/*.parquet` to load the full dataset. Builds without telemetry produce no file; consumers should expect missing build IDs.
 - **Polars for the pivot + asof joins.** ~22 M telemetry rows (build 26) pivot to ~355 K ticks in seconds. Polars' `pivot` and `join_asof(tolerance=100ms)` do the heavy lifting; the position_hf burst is a manual sorted-merge.
+- **Streaming chunked write for the embed step.** With image bytes inlined, build 26 alone is ~11 GB on disk. The writer is a `pyarrow.parquet.ParquetWriter` fed `CHUNK_ROWS=2000`-row slices; each slice does its own image-bytes read, so peak working set per chunk is bounded (~500 MB even for thermal-heavy builds). Polars handles the upstream pivot/join; pyarrow handles the streaming output.
 
 ## Directory layout
 
 ```
 .python-version                # 3.13
 pyproject.toml                 # pyarrow, polars
+.gitattributes                 # *.parquet → LFS
 
 scripts/
   _lib.py                      # sibling-repo paths, FK resolver
-  ticks/01_extract.py          # the single ETL — wide-pivot + asof + burst attach
+  ticks/01_extract.py          # the single ETL — wide-pivot + asof + burst + embed
 
 data/
-  ticks/{build_id}.parquet     # LFS (parquet pattern in .gitattributes)
+  ticks/{build_id:03d}.parquet # LFS; e.g. 001.parquet, 026.parquet
 ```
 
 There is no `source/` (raw data lives in the sibling 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
+
 ## Row shape
 
 ```python
@@ -55,7 +301,6 @@ There is no `source/` (raw data lives in the sibling recorder repo's `data/expor
   "job_name": "D790 and D638 and Benchy 2026_06_02",
   "started_at": "...", "ended_at": "...",
   "phase": "Heating",
-  "print_profile_id": "feafe2b0-...",
   "print_profile_name": "2026_05_30 20mJ/mm Formlabs PA12 GF",
   "inova_session_id": None,  # filled when upstream CSV is curated
 
@@ -81,9 +326,9 @@ There is no `source/` (raw data lives in the sibling recorder repo's `data/expor
   "quadrant1.temp.current": ..., "surfaceAvg.temp.average": ...,
   ...
 
-  # Frames (relative to upstream recorder repo's data/frames/)
-  "frame_chamber": "26/1780265532038_chamber.jpg",
-  "frame_galvo":   "26/1780265532040_galvo.png",
+  # 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
 
   # 1 kHz position-stream burst within (tick_ts - 100ms, tick_ts]
@@ -94,31 +339,53 @@ There is no `source/` (raw data lives in the sibling recorder repo's `data/expor
 }
 ```
 
+## Sensor groups (from `expand()` in the recorder)
+
+The ~64 sensor columns break down by group. All four come from a single `/state/snapshot` GET, so they share the tick timestamp exactly:
+
+| Group | Columns | Source |
+|---|---|---|
+| Position (10 Hz) | `positions.position.{x,y,z1,z2,r}` — 5 cols | `s.position[k]` for k in (x,y,z1,z2,r). Microns, firmware native. |
+| Lights | `lights.lights.{enabled,count}` — 2 cols | `s.lights.{isEnabled,lightCount}`. `enabled` is 0/1. |
+| Power (W) | `{e.id}.power` for each `s.power.entries` — typically `{laser,fanGalvo,buzzer,laserSafety,io-en,wd-en,wd-in}` — 7 cols, plus `powerman.power.{current,required,max}` — 3 cols | `s.power.entries[].id` is the per-device draw; `powerman.*` is the manager state. |
+| Temperature (°C) | `{e.id}.temp.{current,average,target}` for each `s.temperature.entries` — typically `{powderBed, printBed, powderChamber1..4, printChamber1..4, quadrant1..4, surface, surfaceAvg, surfaceMin, surfaceMax, testTemp1}` — ~51 cols total | `e.targetTemperature` is omitted when null, so `temp.target` columns can be null even when `current`/`average` are populated. |
+
+If `expand()` in the recorder ever changes, all of those column names change with it — no normalization here.
+
 ## Important gotchas
 
-- **`frame_*` paths are relative to the sibling recorder repo, not this dataset.** `frame_chamber = "26/1780265532038_chamber.jpg"` means `Agentic-Additive-Manufacturing-Process-Optimization/data/frames/26/1780265532038_chamber.jpg`. We don't ship the 81 GB of image bytes here; consumers who need them must clone the recorder repo too. Documented in README.
+- **`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.
 - **`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. The fuzzy `print_profile_id` fallback covers the common case meanwhile.
+- **`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.
 - **Sensor units are firmware-convention, not labeled in this dataset.** `*.temp.*` are °C, `*.power*` are W, `positions.position.*` are **microns** (firmware native; divide by 1000 for mm). Authoritative annotations live in the upstream `sensors.csv` glossary; when it's filled in, the dataset card will be updated.
 - **Builds without `telemetry/{build_id}.parquet` produce no file here.** `data/ticks/` will have gaps for failed-heating runs (typically 12–38 s with zero recorded telemetry).
 - **The 100 ms window is the recorder's tick interval.** Frame attachment is "the most recent frame within the prior tick interval"; this is a design choice (could be wider or interpolated). If a frame is more than 100 ms stale at tick time, it's null even if it's the closest existing frame. Consider widening the window if frame_kind null rates feel too high.
+- **The ETL always overwrites.** No skip-if-exists. If you only want incremental refresh, pass specific build IDs on the command line.
+- **`events` and `plotter_commands` upstream tables are not exposed here.** `events` (78 rows) is sparse; `plotter_commands` (0 rows) postdates the historical builds. Both stay upstream-only for v1.
+- **The recorder repo is a moving target.** It's actively developed; new sensors, new build records, schema changes can appear. Diff `server/src/db/schema.sql` and `server/src/recorder/telemetry.ts` against your last known state before relying on column names.
 
 ## Current state
 
-- `ticks` config: implemented. 10 parquet files (one per build with telemetry), ~24 MB total, ~1.01 M ticks combined. Build 26 (9h54m run): 355,580 ticks, 8.3 MB.
-- 28 of 30 builds have `print_profile_id` resolved; 2 unmatched because their `printProfileName` ("2026_06_09 24mJ/mm Formlabs PA12 GF") isn't in the current 5 Database PrintProfiles snapshot. Adding that profile to Database backfills them automatically on next re-extract.
-- `events` and `plotter_commands` upstream tables are not surfaced (no plans for v2).
+- `ticks` config: implemented with embedded frame bytes. 10 parquet files, 30 GB total, 1.01 M ticks across builds 1, 2, 12, 13, 14, 16, 17, 25, 26, 28.
+- `print_profile_name` is preserved on every row; the `print_profile_id` UUID is *not* materialized here (see the architectural decision above). The existing parquet files on disk were written before this change and still contain a `print_profile_id` column — they'll lose it on the next full regen.
+- `events` and `plotter_commands` not surfaced as configs.
+- **Forward-fill semantics deferred.** Current attach is "fresh frame within 100 ms of tick or null." Carrying the latest captured frame forward to fill null rows is left to consumers (one-line groupby + ffill); baking it into the dataset would destroy the fresh-vs-stale signal that's the whole point of keeping nulls.
+- Repo is not yet committed; data/ticks/ files are unstaged. LFS rules are configured but no LFS objects pushed yet.
 
 ## Adding a build — recipe
 
 1. New build runs in the recorder, produces telemetry / frames / position_hf in Postgres + on disk.
-2. Run `scripts/export.py` in the recorder repo to refresh `data/exports/`.
-3. Run `uv run scripts/ticks/01_extract.py` here — picks up the new `telemetry/{build_id}.parquet` automatically. Or pass specific build IDs as positional args to limit work.
-4. Commit the new `data/ticks/{build_id}.parquet` (LFS).
+2. Run `scripts/export.py` in the recorder repo to refresh `data/exports/`. Pass `--builds N` to scope to one build if you don't want to re-export everything.
+3. (Optional, but recommended) edit `Agentic-…-Optimization/data/exports/build_to_inova_session.csv` to fill in the `inova_session_id` UUID for the new build, then commit there.
+4. Run `uv run scripts/ticks/01_extract.py N` here to write `data/ticks/NNN.parquet` (zero-padded — e.g. build 7 → `007.parquet`, build 142 → `142.parquet`).
+5. `git add data/ticks/NNN.parquet` (LFS) and commit.
 
-## Regenerate
+## Regenerate everything
 
 ```sh
+rm -f data/ticks/*.parquet
 uv run scripts/ticks/01_extract.py
 ```
+
+Takes ~2 hours, produces ~30 GB. The IO is the bottleneck; the Polars pivot and asof joins are fast.

README.md

@@ -13,22 +13,34 @@ configs:
   - split: train
     path: data/ticks/*.parquet
   default: true
+dataset_info:
+  features:
+  - name: frame_chamber
+    dtype: image
+  - name: frame_galvo
+    dtype: image
+  - name: frame_thermal
+    dtype: image
 ---
 
 # Inova-Mk1-Telemetry
 
 Time-aligned printer-state recordings from Inova Mk1 SLS print runs. One row per 10 Hz **tick** of the recorder's `/state/snapshot` poll, with the full sensor state (~64 columns: temperatures, position, power, lights) on every row, the nearest camera frame paths attached when one fell in the prior 100 ms window, and any 1 kHz position-stream samples from that window collected as a nested list.
 
-Builds are denormalized into every row, so each parquet file is self-sufficient for ML — no joins needed for build context. A `print_profile_id` references [`ppak10/Inova-Mk1-Database`](https://huggingface.co/datasets/ppak10/Inova-Mk1-Database) when the build's `printProfileName` matches a known `PrintProfile.Name`.
+Builds are denormalized into every row, so each parquet file is self-sufficient for ML — no joins needed for build context. The `print_profile_name` string the printer was running is preserved on every row; consumers who want the matching UUID from [`ppak10/Inova-Mk1-Database`](https://huggingface.co/datasets/ppak10/Inova-Mk1-Database) can resolve it themselves (one-liner shown below) — this dataset deliberately doesn't bake that join in, so it has no cross-dataset dependency at load time.
 
 ```python
 from datasets import load_dataset
 ticks = load_dataset("ppak10/Inova-Mk1-Telemetry", split="train")
-# ticks now has rows like:
-#   {build_id, ts, job_name, ..., powderBed.temp.current, laser.power, ...,
-#    frame_chamber: "26/...jpg" | None, position_hf_burst: [...]}
+row = ticks[0]
+# row["frame_chamber"]   → PIL.Image.Image (or None)
+# row["frame_thermal"]   → PIL.Image.Image (or None)
+# row["powderBed.temp.current"] → float (°C)
+# row["position_hf_burst"]      → list of {ts_offset_ms, x, y, z1, z2, r, has_homed}
 ```
 
+The full image bytes ship inside each row — no separate frame download required. Filter to rows that have a particular frame kind with `ticks.filter(lambda r: r["frame_chamber"] is not None)`.
+
 ---
 
 ## Row shape
@@ -37,19 +49,19 @@ Each row is one moment in time (a single 10 Hz tick). 80+ columns:
 
 | Group | Columns | Notes |
 |---|---|---|
-| **Build context** (denormalized) | `build_id`, `job_name`, `started_at`, `ended_at`, `phase`, `print_profile_id`, `print_profile_name`, `inova_session_id` | Same value on every row in a given parquet file. `inova_session_id` is null until the upstream `build_to_inova_session.csv` is filled in by hand. |
+| **Build context** (denormalized) | `build_id`, `job_name`, `started_at`, `ended_at`, `phase`, `print_profile_name`, `inova_session_id` | Same value on every row in a given parquet file. `inova_session_id` is null until the upstream `build_to_inova_session.csv` is filled in by hand. |
 | **Tick timestamp** | `ts` (`timestamp[us, UTC]`) | The `respondedAt` field on the `/state/snapshot` frame. |
 | **Position (10 Hz)** | `positions.position.{x,y,z1,z2,r}` | Stage position at the tick, **microns** (firmware native; e.g. `z1 = 47272.79` is 47.27 mm). Always present. |
 | **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 power draw and the overall 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. All firmware temperatures in °C. |
-| **Frame paths** | `frame_chamber`, `frame_galvo`, `frame_thermal` | Nullable. Path is **relative to the upstream recorder repo's `data/frames/`** — this dataset does not ship the 81 GB of image bytes. Null when no frame of that kind was captured in the 100 ms window before the tick. |
+| **Frame images** | `frame_chamber`, `frame_galvo`, `frame_thermal` | Embedded image bytes per HF `Image` feature (struct of `{bytes, path}`). Null when no frame of that kind was captured in the 100 ms window before the tick. Loads as a `PIL.Image` via `datasets`. The `path` field inside the struct preserves the original filename for traceability. |
 | **Position burst** | `position_hf_burst` | A `list<struct<ts_offset_ms, x, y, z1, z2, r, has_homed>>`. Captures any 1 kHz position-stream events that fell in `(tick_ts - 100 ms, tick_ts]`. Empty list when no motion was happening. |
 
 ## Files
 
 ```
-data/ticks/{build_id}.parquet      # one file per build that had telemetry
+data/ticks/{build_id:03d}.parquet  # one file per build that had telemetry, zero-padded to 3 digits
 ```
 
 10 builds had recorded telemetry; very-short failed-heating builds (~12–38 s, no rows) produce no file. The HF glob `data/ticks/*.parquet` loads everything across builds.
@@ -64,9 +76,25 @@ This dataset is **tick-anchored**, not strict-outer-join. Compared to the upstre
 
 ## Joining back to Inova-Mk1-Database
 
-Each row carries `print_profile_id` resolved by matching the build's `printProfileName` (from `build_start` event payload) against `PrintProfile.Name` in [`Inova-Mk1-Database/source/PrintProfiles/`](https://huggingface.co/datasets/ppak10/Inova-Mk1-Database). If no match exists, `print_profile_id` is null and `print_profile_name` is preserved as a breadcrumb (typical when a new profile hasn't landed in `Inova-Mk1-Database` yet).
+Each row carries `print_profile_name` — the string the printer was running when the build started, taken straight from the `build_start` event payload. To recover the matching `PrintProfile.Id` UUID, join against the [`ppak10/Inova-Mk1-Database`](https://huggingface.co/datasets/ppak10/Inova-Mk1-Database) `PrintProfiles` entities:
+
+```python
+import json
+from pathlib import Path
+
+# Wherever you've cloned/snapshotted Inova-Mk1-Database
+profiles_dir = Path("Inova-Mk1-Database/source/PrintProfiles")
+name_to_id = {
+    json.load(p.open())["Name"]: json.load(p.open())["Id"]
+    for p in profiles_dir.glob("*.json")
+}
+
+ticks = ticks.map(lambda r: {**r, "print_profile_id": name_to_id.get(r["print_profile_name"])})
+```
+
+If `Inova-Mk1-Database` hasn't yet added the profile the build used, the lookup returns null and `print_profile_name` is still preserved as a breadcrumb.
 
-A planned authoritative `inova_session_id UUID` join will replace the fuzzy fallback once the upstream `Agentic-Additive-Manufacturing-Process-Optimization/data/exports/build_to_inova_session.csv` has been filled in.
+A planned authoritative `inova_session_id UUID` will replace the name-based fallback once the upstream `Agentic-Additive-Manufacturing-Process-Optimization/data/exports/build_to_inova_session.csv` has been filled in.
 
 ## Upstream
 

data/ticks/001.parquet

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

data/ticks/{1.parquet → 002.parquet}

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:5c89eb47b56cdd281b8aad4278d676eb48c45d9d2bb00f6f1af4c45badee1d14
-size 2408141
+oid sha256:56a9e8e9d263749b271bf8879737fa0aff761770ef4b6a854a3b1b594db4a474
+size 2509572

data/ticks/012.parquet

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

data/ticks/{14.parquet → 013.parquet}

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

data/ticks/{16.parquet → 014.parquet}

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

data/ticks/{13.parquet → 016.parquet}

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

data/ticks/{17.parquet → 017.parquet}

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

data/ticks/{12.parquet → 025.parquet}

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

data/ticks/026.parquet

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

data/ticks/028.parquet

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

data/ticks/2.parquet

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

data/ticks/25.parquet

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

data/ticks/26.parquet

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

data/ticks/28.parquet

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

scripts/_lib.py

@@ -1,4 +1,4 @@
-"""Shared paths and the Database FK resolver for the per-entity extract scripts.
+"""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
@@ -10,17 +10,13 @@ from pathlib import Path
 ROOT = Path(__file__).parent.parent
 DATA_DIR = ROOT / "data"
 
-# Sibling-repo locations. The Telemetry dataset has no local source/ tree;
+# Sibling-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"
 EXPORTS_DIR = AGENTIC_ROOT / "data" / "exports"
 
-# Used only by the `builds` extract to resolve print_profile_id.
-DATABASE_ROOT = ROOT.parent / "Inova-Mk1-Database"
-DATABASE_PROFILES_DIR = DATABASE_ROOT / "source" / "PrintProfiles"
-
 
 def iter_jsonl(path: Path):
     """Stream a JSONL file row-by-row. Skips blank lines."""
@@ -48,33 +44,3 @@ def load_build_to_profile_name() -> dict[int, str]:
         if name:
             out[ev["build_id"]] = name
     return out
-
-
-def load_profile_name_to_id() -> dict[str, str]:
-    """Read Inova-Mk1-Database PrintProfile JSONs, return {Name: Id}.
-
-    Matches on the in-app `Name` field exactly (slashes preserved); the
-    sibling event payload uses the same form (e.g.
-    "2026_05_30 20mJ/mm Formlabs PA12 GF").
-    """
-    out: dict[str, str] = {}
-    for p in DATABASE_PROFILES_DIR.glob("*.json"):
-        with p.open() as f:
-            blob = json.load(f)
-        if "Name" in blob and "Id" in blob:
-            out[blob["Name"]] = blob["Id"]
-    return out
-
-
-def build_id_to_profile_id() -> dict[int, tuple[str | None, str | None]]:
-    """Compose: {build_id: (print_profile_id, print_profile_name)}.
-
-    Unresolved profile_id (no Database match) is returned as None alongside
-    the still-useful name string.
-    """
-    b2name = load_build_to_profile_name()
-    n2id = load_profile_name_to_id()
-    return {
-        bid: (n2id.get(name), name)
-        for bid, name in b2name.items()
-    }

scripts/ticks/01_extract.py

@@ -4,10 +4,11 @@
 Reads upstream flat exports from the sibling 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}.parquet`:
+For each build with telemetry, emits `data/ticks/{build_id:03d}.parquet`
+(zero-padded so lexical sort matches numeric build_id):
   - One row per unique telemetry timestamp (the 10 Hz tick from /state/snapshot)
   - Wide-format sensor columns named "{sensor_id}.{kind}" (~64 columns)
-  - Denormalized build context (build_id, job_name, ..., print_profile_id)
+  - 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
   - position_hf_burst: list of {ts_offset_ms, x, y, z1, z2, r, has_homed}
@@ -22,14 +23,26 @@ from datetime import timedelta
 from pathlib import Path
 
 import polars as pl
+import pyarrow as pa
+import pyarrow.parquet as pq
 
 sys.path.insert(0, str(Path(__file__).parent.parent))
-from _lib import EXPORTS_DIR, DATA_DIR, iter_jsonl, build_id_to_profile_id
+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")
+# 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.
+IMAGE_STRUCT_TYPE = pa.struct([
+    pa.field("bytes", pa.binary()),
+    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
 
 
 def load_builds_index() -> dict[int, dict]:
@@ -122,25 +135,71 @@ def attach_position_hf(wide: pl.DataFrame, build_id: int) -> pl.DataFrame:
 
 
 def denormalize_build(wide: pl.DataFrame, build_row: dict,
-                      profile_lookup: dict[int, tuple[str | None, str | None]]) -> pl.DataFrame:
+                      profile_name_lookup: dict[int, str]) -> pl.DataFrame:
     """Prepend build-context columns to every row. Cheap in parquet thanks to
     dictionary encoding (every row in this file has the same value)."""
     bid = build_row["id"]
-    profile_id, profile_name = profile_lookup.get(bid, (None, None))
     return wide.with_columns(
         pl.lit(bid).alias("build_id"),
         pl.lit(build_row.get("job_name")).alias("job_name"),
         pl.lit(build_row.get("started_at")).alias("started_at"),
         pl.lit(build_row.get("ended_at")).alias("ended_at"),
         pl.lit(build_row.get("phase")).alias("phase"),
-        pl.lit(profile_id).alias("print_profile_id"),
-        pl.lit(profile_name).alias("print_profile_name"),
+        pl.lit(profile_name_lookup.get(bid)).alias("print_profile_name"),
         pl.lit(None, dtype=pl.String).alias("inova_session_id"),
     )
 
 
+def _embed_frame_column(paths: list[str | None]) -> pa.Array:
+    """For one chunk's worth of paths, read the image bytes from disk and
+    return a StructArray with HF Image shape. Missing path → null struct;
+    missing-on-disk → null struct (warn-and-continue)."""
+    raw_bytes: list[bytes | None] = []
+    for p in paths:
+        if p is None:
+            raw_bytes.append(None)
+            continue
+        try:
+            raw_bytes.append((FRAMES_DIR / p).read_bytes())
+        except FileNotFoundError:
+            raw_bytes.append(None)
+    bytes_array = pa.array(raw_bytes, type=pa.binary())
+    path_array  = pa.array(paths,     type=pa.string())
+    # Mask the whole struct as null when there is no path. Children stay null too.
+    mask = pa.array([p is None for p in paths], type=pa.bool_())
+    return pa.StructArray.from_arrays(
+        [bytes_array, path_array],
+        fields=[pa.field("bytes", pa.binary()), pa.field("path", pa.string())],
+        mask=mask,
+    )
+
+
+def _make_output_schema(wide_arrow_schema: pa.Schema) -> pa.Schema:
+    """Replace frame_* string fields with HF Image struct fields."""
+    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))
+        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."""
+    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))
+        else:
+            arrays.append(chunk[field.name].combine_chunks())
+    return pa.Table.from_arrays(arrays, schema=output_schema)
+
+
 def process_build(build_id: int, builds_index: dict[int, dict],
-                  profile_lookup: dict[int, tuple[str | None, str | None]]) -> Path | None:
+                  profile_name_lookup: dict[int, str]) -> Path | None:
     tel_path = EXPORTS_DIR / "telemetry" / f"{build_id}.parquet"
     if not tel_path.exists():
         return None
@@ -153,25 +212,32 @@ def process_build(build_id: int, builds_index: dict[int, dict],
     frames = load_frames_for_build(build_id)
     wide = attach_frames(wide, frames)
     wide = attach_position_hf(wide, build_id)
-    wide = denormalize_build(wide, builds_index[build_id], profile_lookup)
+    wide = denormalize_build(wide, builds_index[build_id], profile_name_lookup)
 
     # Put build context + ts first, then sensors, then frames + burst.
     leading = ["build_id", "ts", "job_name", "started_at", "ended_at", "phase",
-               "print_profile_id", "print_profile_name", "inova_session_id"]
+               "print_profile_name", "inova_session_id"]
     frame_cols = [f"frame_{k}" for k in FRAME_KINDS]
     trailing = frame_cols + ["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)
 
-    out_path = OUTPUT_DIR / f"{build_id}.parquet"
-    wide.write_parquet(out_path, compression="zstd")
+    # Stream-write: build target schema (with image structs), then iterate
+    # CHUNK_ROWS-sized slices, embedding bytes per chunk to bound memory.
+    base_table = wide.to_arrow()
+    output_schema = _make_output_schema(base_table.schema)
+    out_path = OUTPUT_DIR / f"{build_id:03d}.parquet"
+    with pq.ParquetWriter(out_path, output_schema, compression="zstd") as writer:
+        for i in range(0, base_table.num_rows, CHUNK_ROWS):
+            chunk = base_table.slice(i, CHUNK_ROWS)
+            writer.write_table(_embed_chunk(chunk, output_schema))
     return out_path
 
 
 def main():
     OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
     builds_index = load_builds_index()
-    profile_lookup = build_id_to_profile_id()
+    profile_name_lookup = load_build_to_profile_name()
 
     args = [int(a) for a in sys.argv[1:]]
     targets = args or sorted(int(p.stem) for p in (EXPORTS_DIR / "telemetry").glob("*.parquet"))
@@ -180,7 +246,7 @@ def main():
         if bid not in builds_index:
             print(f"build {bid}: not in builds.jsonl, skipping")
             continue
-        out = process_build(bid, builds_index, profile_lookup)
+        out = process_build(bid, builds_index, profile_name_lookup)
         if out is None:
             print(f"build {bid}: no telemetry parquet, skipping")
             continue