diff --git a/README.md b/README.md
index fa43f03..e239871 100644
--- a/README.md
+++ b/README.md
@@ -36,6 +36,12 @@ print(data.n_frames, data.fs)       # e.g. 11500, 50.0
 print(data.pixels.shape)            # (11500, 32, 32)
 print(data.global_signal[:10])      # first 10 frames global EIT signal
 
+# Dräger .eit — raw transimpedances for pyEIT reconstruction
+data = load_data("patient01.eit")
+print(data.n_frames, data.fs)          # e.g. 11500, 50.0
+print(data.measurements.shape)        # (11500, 208) — 208 = 16 inj × 13 meas
+print(list(data.aux_signals.keys()))   # timestamp, I_real, V_diff, medibus, ...
+
 # Dräger .asc — continuous frame-by-frame signal export
 data = load_data("patient01.asc")
 print(data.n_frames, data.fs)       # e.g. 11500, 50.0
@@ -57,7 +63,7 @@ Pre-alpha. Data model and parsing layer implemented.
 |-------|---------|-------------|
 | `ReconstructedFrameData` | 32×32 pixel matrices + synchronized signals | `.bin`, `.txt` |
 | `ContinuousSignalData` | Signal table, one row per frame | `.asc` |
-| `RawImpedanceData` | Raw transimpedances for pyEIT | `.eit` (scaffold) |
+| `RawImpedanceData` | Calibrated transimpedances + aux signals for pyEIT | `.eit` |
 
 **Parsers** (`parsers/`):
 
@@ -65,16 +71,28 @@ Pre-alpha. Data model and parsing layer implemented.
 |--------|--------|---------|
 | `DragerBinParser` | Implemented | `.bin` — base frame (4358 b) and PressurePod frame (4382 b); registry-driven, new frame sizes require only a dtype + one entry |
 | `DragerAscParser` | Implemented | `.asc`, `.txt`, `.csv` — continuous waveform export |
-| `DragerEitParser` | Scaffold | `.eit` (Fase 2) |
+| `DragerEitParser` | Implemented | `.eit` — ASCII header + binary frames (5495 b/frame); 208 calibrated transimpedances + Medibus aux signals |
 | `TimpelTabularParser` | Implemented | `.csv`, `.txt` — reconstructed frame export |
 
 All parsers are accessible via the single entry point `load_data(path)`, which
 auto-detects vendor and format.
 
+`RawImpedanceData` from `.eit` files can be reconstructed to 32×32 pixel images via
+which is an example of pyEIT wrapping `reconstruct_greit()` (optional dependency: `pip install fasteit[pyeit]`; implements
+GREIT — Adler et al., *Physiol. Meas.* 2009, DOI: 10.1088/0967-3334/30/6/S03):
+
+```python
+from fasteit.parsers.draeger.eit.eit_pyeit_bridge import reconstruct_greit
+
+data = load_data("patient01.eit")
+images = reconstruct_greit(data.measurements)  # (N_frames, 32, 32)
+```
+
 ## Documentation
 
-- [`docs/data_model.md`](docs/data_model.md) — data containers and parsing flow per file type
-- [`docs/parsing_layer.md`](docs/parsing_layer.md) — how to extend: new frame sizes, new vendors, new formats
+- [`docs/data_model.md`](docs/data_model.md) — data container field specifications
+- [`docs/parsers.md`](docs/parsers.md) — parser reference: formats, calibration, GREIT bridge, loader utilities
+- [`docs/parsing_layer.md`](docs/parsing_layer.md) — architecture and extension recipes
 
 ## Contributing
 
diff --git a/docs/data_model.md b/docs/data_model.md
index 22c8450..cbab0a3 100644
--- a/docs/data_model.md
+++ b/docs/data_model.md
@@ -1,25 +1,14 @@
 # fastEIT — Data Model
 
-Specifications for all data containers. For parsing flow, detection logic, and
-extension recipes see [`parsing_layer.md`](parsing_layer.md).
-
----
-
-## 1. Overview
-
-| File | Vendor | Container | Content |
-|------|--------|-----------|---------|
-| `.bin` | Dräger | `ReconstructedFrameData` | 32×32 pixel matrices + Medibus signals |
-| `.csv` / `.txt` / `.asc` | Timpel | `ReconstructedFrameData` | 32×32 pixel matrices + 6 device signals |
-| `.asc` | Dräger | `ContinuousSignalData` | Frame-by-frame signal table, no matrices |
-| `.eit` | Dräger | `RawImpedanceData` | 208 raw transimpedances per frame |
-| `.x`   | Timpel | `RawImpedanceData` | 208 raw transimpedances per frame |
+Specifications for all data containers. For parser details, calibration
+constants, and loader utilities see [`parsers.md`](parsers.md). For architecture
+and extension recipes see [`parsing_layer.md`](parsing_layer.md).
 
 All containers inherit from `BaseData` (`models/base_data.py`).
 
 ---
 
-## 2. `BaseData` — common base
+## 1. `BaseData` — common base
 
 ```
 filename    str          Source file path
@@ -33,7 +22,7 @@ duration    float        n_frames / fs  (0.0 if fs is None)
 
 ---
 
-## 3. `ReconstructedFrameData`
+## 2. `ReconstructedFrameData`
 
 **File:** `models/reconstructed_data.py`
 **Produced by:** `DragerBinParser` (`.bin`), `TimpelTabularParser` (`.csv/.txt/.asc`)
@@ -80,7 +69,7 @@ is applied in the preprocessing layer.
 
 ---
 
-## 4. `ContinuousSignalData`
+## 3. `ContinuousSignalData`
 
 **File:** `models/continuous_data.py`
 **Produced by:** `DragerAscParser` (`.asc`)
@@ -97,16 +86,34 @@ table   pd.DataFrame   One row per EIT frame. Snake_case column names.
 
 ---
 
-## 5. `RawImpedanceData`
+## 4. `RawImpedanceData`
 
 **File:** `models/raw_impedance_data.py`
-**Produced by:** `DragerEitParser` (`.eit`), `TimpelRawParser` (`.x`) — both scaffold
+**Produced by:** `DragerEitParser` (`.eit`); `TimpelRawParser` (`.x`) — scaffold
 
 ```
 measurements   np.ndarray   shape (N_frames, 208)
+                            Calibrated transimpedances (not raw ADC counts, not
+                            yet image-reconstructed). For Dräger:
+                            vv = FT_A*trans_A - FT_B*trans_B (EIDORS, Adler 2016)
                             208 = 16 electrodes × 13 measurement pairs
-                            Adjacent drive pattern (Dräger and Timpel)
+                            (adjacent drive, standard Dräger pattern)
+
+aux_signals    dict|None    Named per-frame arrays. Populated by DragerEitParser:
+                              "timestamp"          float64 (N,)    fraction of day
+                              "trans_A"            float64 (N,208) raw ADC — primary
+                              "trans_B"            float64 (N,208) raw ADC — reference
+                              "injection_current"  float64 (N,16)  raw ADC counts
+                              "I_real"             float64 (N,16)  injected current [A]
+                              "voltage_A"          float64 (N,16)  raw ADC counts
+                              "voltage_B"          float64 (N,16)  raw ADC counts
+                              "V_diff"             float64 (N,16)  differential voltage [V]
+                              "frame_counter"      uint16  (N,)
+                              "medibus"            float32 (N,67)  ventilator channels
+                            None if the source file carries no auxiliary signals.
 ```
 
-Intended consumer: **pyEIT** or any reconstruction library.
-fastEIT does not perform image reconstruction — it ingests vendor-reconstructed files.
+Intended consumer: `reconstruct_greit()` (in `fasteit.parsers.draeger.eit.eit_pyeit_bridge`,
+requires optional `pyeit` dependency) or any external reconstruction library.
+For `.bin` and Timpel `.csv` files, fastEIT ingests vendor-reconstructed images
+and does not re-reconstruct them.
diff --git a/docs/parsers.md b/docs/parsers.md
new file mode 100644
index 0000000..3347e3d
--- /dev/null
+++ b/docs/parsers.md
@@ -0,0 +1,281 @@
+# fastEIT — Parser Reference
+
+Specifications for all parsers: input formats, output containers, calibration
+details, and the pyEIT reconstruction bridge.
+
+For **data container field specifications** see [`data_model.md`](data_model.md).
+For **architecture and extension recipes** see [`parsing_layer.md`](parsing_layer.md).
+
+---
+
+## 1. Overview
+
+| File | Vendor | Parser | Container |
+|------|--------|--------|-----------|
+| `.bin` | Dräger | `DragerBinParser` | `ReconstructedFrameData` |
+| `.asc` / `.txt` / `.csv` | Dräger | `DragerAscParser` | `ContinuousSignalData` |
+| `.eit` | Dräger | `DragerEitParser` | `RawImpedanceData` |
+| `.csv` / `.txt` / `.asc` | Timpel | `TimpelTabularParser` | `ReconstructedFrameData` |
+| `.x` | Timpel | `TimpelRawParser` *(scaffold)* | `RawImpedanceData` |
+
+All parsers inherit from `BaseParser` and are accessible via `load_data(path)`.
+
+---
+
+## 2. `DragerBinParser` — `.bin`
+
+**File:** `parsers/draeger/bin/bin_parser.py`
+
+Reads vendor-reconstructed 32×32 pixel frames exported by the PulmoVista 500.
+Two frame formats are registered; detection is size-based (no header).
+
+### Frame formats
+
+| Name | Frame size | Medibus channels | Notes |
+|------|-----------|-----------------|-------|
+| `Draeger_base_4358` | 4358 bytes | 52 | Standard export |
+| `Draeger_ext_4382` | 4382 bytes | 58 | PressurePod: adds esophageal + transpulmonary pressure |
+
+### Binary frame layout (base format)
+
+| Field | Type | Size | Content |
+|-------|------|------|---------|
+| `ts` | float64 | 8 B | Wall-clock timestamp (fraction of day × 86400 → seconds) |
+| `dummy` | float32 | 4 B | Unknown — ignored |
+| `pixels` | float32 × 1024 | 4096 B | Reconstructed 32×32 image (C-order) |
+| `min_max_flag` | int32 | 4 B | +1 = inspiratory peak, −1 = expiratory trough, 0 = none |
+| `event_marker` | int32 | 4 B | Event counter |
+| `event_text` | S30 | 30 B | ASCII event label, space-padded |
+| `timing_error` | int32 | 4 B | 0 = frame timing OK |
+| `medibus_data` | float32 × 52 | 208 B | Ventilator Medibus channels; sentinel −3.4×10³⁸ = disconnected |
+
+PressurePod format (`Draeger_ext_4382`) adds 6 extra Medibus channels (indices 52–57):
+esophageal pressure (Pes), airway pressure (Paw), transpulmonary pressure (Ptp),
+and three auxiliary pressure waveforms from the Pod hardware.
+
+### Sentinel handling
+
+Medibus channels disconnected from the ventilator carry the sentinel value
+`−3.4×10³⁸` (IEEE 754 bit pattern `0xFF7FC99E`). The parser replaces these
+with `NaN` so downstream code can use `np.isnan()` to detect disconnected channels.
+
+### Sampling frequency
+
+Not stored in the binary. Estimated from consecutive timestamp differences:
+`fs = 1 / median(diff(ts))`, rounded to the nearest integer Hz.
+
+---
+
+## 3. `DragerEitParser` — `.eit`
+
+**File:** `parsers/draeger/eit/eit_parser.py`
+
+Reads raw transimpedance measurements from the PulmoVista 500 proprietary
+binary format. This is the **only open-source Python parser for this format**.
+
+### File structure
+
+```
+Bytes 0–11          : preamble — 3 × int32 LE
+                        [0:4]  format_version (always 51)
+                        [4:8]  sep_offset      (file-specific, variable)
+                        [8:12] unknown_int
+Bytes 12–sep_offset : ASCII header ("key: value\r\n" lines, latin-1)
+Bytes sep_offset–+7 : separator b'**\r\n\r\n\r\n' (8 bytes)
+Bytes sep_offset+8… : binary frames, 5495 bytes each
+```
+
+### ASCII header fields
+
+| Header key | Metadata key | Type | Notes |
+|-----------|-------------|------|-------|
+| `Framerate [Hz]` | `fs` | float | Acquisition rate (typically 50.0 Hz) |
+| `Date` | `date` | str | DD.MM.YYYY |
+| `Time` | `time` | str | HH:MM:SS.mmm |
+| `Frequency [kHz]` | `frequency_khz` | float | Excitation frequency (≈101.5 kHz) |
+| `Amplitude [uA]` | `amplitude_ua` | float | Injection current amplitude (≈9100 µA) |
+| `Gain` | `gain` | int | Hardware amplifier gain |
+| `Samples` | `samples_per_period` | int | ADC samples per excitation period |
+| `Periods` | `periods` | int | Excitation periods per measurement |
+
+### Binary frame layout (5495 bytes)
+
+| Field | Type | Size | Content |
+|-------|------|------|---------|
+| `timestamp` | float64 | 8 B | Fraction of day |
+| `unknown_f8` | float64 | 8 B | Unknown |
+| `trans_A` | float64 × 208 | 1664 B | Primary transimpedance set (ADC counts) |
+| `unknown_16a` | float64 × 16 | 128 B | Unknown |
+| `injection_current` | float64 × 16 | 128 B | Injected current per drive pattern (ADC counts) |
+| `unknown_16b` | float64 × 16 | 128 B | Unknown |
+| `voltage_A` | float64 × 16 | 128 B | Electrode voltage A (ADC counts) |
+| `unknown_50` | float64 × 50 | 400 B | Unknown |
+| `trans_B` | float64 × 208 | 1664 B | Reference transimpedance set (ADC counts) |
+| `unknown_48` | float64 × 48 | 384 B | Unknown |
+| `voltage_B` | float64 × 16 | 128 B | Electrode voltage B (ADC counts) |
+| `unknown_6` | float64 × 6 | 48 B | Unknown |
+| `gugus` | float64 × 44 | 352 B | Ignored (EIDORS terminology) |
+| `unknown_byte` | uint8 | 1 B | Unknown |
+| `medibus` | float32 × 67 | 268 B | Ventilator Medibus channels (67 in `.eit`, 52 in `.bin`) |
+| `event_text` | S30 | 30 B | ASCII event label |
+| `mixed` | uint8 × 24 | 24 B | Mixed content |
+| `frame_counter` | uint16 | 2 B | Rolling frame counter |
+| `padding` | uint8 × 2 | 2 B | Alignment padding |
+
+### Calibration pipeline
+
+Empirical constants from EIDORS `read_draeger_file.m` (A. Adler, estimated 2016-04-07).
+These are not present in the `.eit` header — they are hardware-specific and hardcoded.
+
+| Constant | Value | Role |
+|----------|-------|------|
+| `FT_A` | 0.00098242 | Transimpedance scaling — primary channel |
+| `FT_B` | 0.00019607 | Transimpedance scaling — reference channel |
+| `FC_CURRENT` | 194326.3536 | ADC counts → Ampere |
+| `FV_VOLTAGE` | 0.11771 | ADC counts → Volt |
+
+```python
+vv      = FT_A * trans_A - FT_B * trans_B   # (N_frames, 208) calibrated transimpedance [Ω]
+I_real  = injection_current / FC_CURRENT     # (N_frames, 16)  injected current [A]
+V_diff  = (voltage_A - voltage_B) / FV_VOLTAGE  # (N_frames, 16) differential voltage [V]
+```
+
+### Measurement protocol
+
+208 measurements per frame = 16 electrodes × 13 measurement pairs.
+Adjacent current injection (drive distance = 1 electrode), adjacent voltage
+measurement (step = 1 electrode), 3 pairs excluded per drive pattern
+(those sharing a voltage electrode with the current-injection pair).
+
+The ordering of the 208 values within each frame follows the **`fmmu`** (rotating)
+protocol: for each drive pattern the voltage sweep starts from the electrode
+immediately adjacent to the current sink and rotates around the ring.
+Confirmed from the PulmoVista 500 IFU SW 1.3n p. 144 measurement diagram.
+
+---
+
+## 4. `DragerAscParser` — `.asc`
+
+**File:** `parsers/draeger/asc/asc_parser.py`
+
+Reads the PulmoVista 500 continuous waveform export (tab-separated text).
+Returns `ContinuousSignalData` with one row per EIT frame.
+
+Detection: looks for `"Dräger"` or `"Draeger"` keyword in the first 40 lines.
+Sampling frequency estimated from the `time` column if present.
+
+Typical columns: `image`, `time`, `global`, `local_1_x_16_y_29` … `local_4_x_16_y_05`,
+`minmax`, `event`, `eventtext`, `timing_error`, plus Medibus channel columns when
+the ventilator is connected via Medibus.
+
+---
+
+## 5. `TimpelTabularParser` — `.csv` / `.txt` / `.asc`
+
+**File:** `parsers/timpel/timpel_parser.py`
+
+Reads Timpel EIT device tabular exports. Each row is one EIT frame;
+columns 0–1023 are the 32×32 pixel values (C-order); columns 1024–1029
+are auxiliary signals (airway_pressure, flow, volume, min_flag, max_flag, qrs_flag).
+
+Returns `ReconstructedFrameData`. Sampling frequency defaults to 50 Hz if a
+`first_frame` column is present but timing cannot be derived otherwise.
+
+Detection: looks for `"Timpel"` keyword in the first 40 lines.
+
+---
+
+## 6. GREIT reconstruction bridge
+
+**File:** `parsers/draeger/eit/eit_pyeit_bridge.py`
+**Optional dependency:** `pip install fasteit[pyeit]`
+
+Converts `RawImpedanceData.measurements` (N_frames, 208) to reconstructed
+32×32 images (N_frames, 32, 32) using the GREIT algorithm.
+
+Reference: Adler A et al., "GREIT: a unified approach to 2D linear EIT
+reconstruction of lung images." *Physiol. Meas.* 30 (2009) S35–S55.
+DOI: [10.1088/0967-3334/30/6/S03](https://doi.org/10.1088/0967-3334/30/6/S03)
+
+### `build_greit(n_el, h0, p, lamb, n) → (solver, protocol)`
+
+Builds a pyEIT GREIT solver on a circular unit-disk mesh.
+
+| Parameter | Default | Meaning |
+|-----------|---------|---------|
+| `n_el` | 16 | Number of electrodes |
+| `h0` | 0.1 | Mesh density |
+| `p` | 0.2 | GREIT noise figure (Adler 2009 recommendation) |
+| `lamb` | 1e-2 | Tikhonov regularisation |
+| `n` | 32 | Output image side length in pixels |
+
+### `reconstruct_greit(measurements, ref_frame, …) → ndarray`
+
+| `ref_frame` value | Behaviour |
+|-------------------|-----------|
+| `None` | Mean of all frames in this recording (default) |
+| `int` | Single frame index |
+| `(start, end)` | Mean of `measurements[start:end]` |
+| `np.ndarray (208,)` | External reference — for cross-recording EELI comparison |
+
+**Sign convention**: GREIT outputs conductivity change (Δσ); the function negates
+it to match the Dräger impedance convention (air → impedance rises → positive peak).
+
+**Image orientation** — three steps applied inside `reconstruct_greit()`, all
+sourced from PulmoVista 500 IFU SW 1.3n:
+1. **Negate** (sign flip): impedance convention — see above.
+2. **`rot90(k=1)`** (90° CCW): electrode 1 sits at 12 o'clock on the PulmoVista
+   belt (anterior/ventral wall); pyEIT places electrode 0 at 3 o'clock. Rotation
+   moves the anterior region to the top of the image. Source: IFU p. 144.
+3. **`fliplr`** (horizontal mirror): Dräger displays images in caudal-cranial
+   projection (CT convention viewed from feet): left side of image = right side
+   of patient. pyEIT produces the anatomical mirror; `fliplr` corrects this.
+   Source: IFU p. 146.
+
+**Spatial quality note**: a generic circular mesh does not replicate Dräger's
+proprietary reconstruction. Both algorithms produce correct relative distributions,
+but the vendor `.bin` uses a device-specific mesh and matrix. A data-driven
+reconstruction that learns the Dräger mapping from paired `.eit`/`.bin` recordings
+is provided in `fasteit.reconstruction` (see `feat/ml-reconstruction`).
+
+---
+
+## 7. Loader utilities
+
+**File:** `parsers/loader.py`
+
+### `load_data(path) → BaseData`
+
+Single entry point. Auto-detects vendor and format, selects the right parser,
+returns the appropriate container. Raises `ValueError` on unknown format.
+
+```python
+from fasteit.parsers.loader import load_data
+
+data = load_data("patient01.bin")   # → ReconstructedFrameData
+data = load_data("patient01.eit")   # → RawImpedanceData
+data = load_data("patient01.asc")   # → ContinuousSignalData
+```
+
+### `load_many(paths) → list[BaseData]`
+
+Parses an explicit list of paths in order. Formats can be mixed.
+
+```python
+from fasteit.parsers.loader import load_many
+
+recordings = load_many(["patient01.bin", "patient02.bin", "patient01.asc"])
+```
+
+### `load_folder(folder, pattern="*") → list[BaseData]`
+
+Scans a directory, parses every file with a registered parser.
+Files that raise any error are silently skipped (warning to stderr).
+
+```python
+from fasteit.parsers.loader import load_folder
+
+all_bin  = load_folder("/data/session01/", pattern="*.bin")
+all_data = load_folder("/data/session01/")          # mixed formats
+recursive = load_folder("/data/", pattern="**/*.bin")
+```
diff --git a/docs/parsing_layer.md b/docs/parsing_layer.md
index 9ac1d32..e7ab498 100644
--- a/docs/parsing_layer.md
+++ b/docs/parsing_layer.md
@@ -42,7 +42,7 @@ The strategy depends on the extension:
 | Extension | Strategy | How it works |
 |-----------|----------|--------------|
 | `.bin` | size-based | `file_size % frame_size == 0` for each registered `FormatSpec` |
-| `.eit` | header-based | reads first bytes, looks for ASCII magic string |
+| `.eit` | header-based | reads first bytes, looks for ASCII magic string for each registered `HeaderFormatSpec` |
 | `.asc` `.txt` `.csv` | content-based | reads first 40 lines, looks for vendor keyword |
 
 `.bin` is special: there is no header. The only way to identify the format is
@@ -105,7 +105,6 @@ load_data("patient01.bin")
     │   ├─ validate() → file exists, size divisible by known frame size → True
     │   └─ parse()
     │       ├─ np.memmap with spec.dtype
-    │       ├─ sentinel → NaN substitution
     │       ├─ fs estimation from timestamps
     │       └─ ReconstructedFrameData(frames, aux_signals, fs, ...)
     │
@@ -256,38 +255,81 @@ parameters (TV, RR, PEEP, compliance) in the same file.
 
 ### Step 1 — Detection
 
-File: `src/fasteit/parsers/detection.py`
+Detection works the same way for all three file families: **register a spec, the
+generic function finds it automatically**. You rarely need to touch `detection.py`.
 
-How detection works depends on the file type:
+---
+
+**`.eit`-style (header + binary frames, same `.eit` extension, new vendor)**
+
+File: `src/fasteit/parsers/header_formats.py`
+
+Just add a `HeaderFormatSpec` and append it to `HEADER_FORMAT_SPECS`.
+`detect_vendor_from_eit_header()` iterates the list and returns the first match —
+no changes to `detection.py` needed.
+
+```python
+CAREFUSION_EIT_SPEC = HeaderFormatSpec(
+    name="Carefusion_EIT_v1",
+    vendor="carefusion",
+    magic_string="CareFusion",      # ASCII substring in first magic_search_bytes bytes
+    magic_search_bytes=256,
+    encoding="utf-8",
+    frame_size_bytes=5120,          # byte-exact frame size for this firmware
+    n_electrodes=16,
+    n_measurements=208,
+)
+
+HEADER_FORMAT_SPECS: tuple[HeaderFormatSpec, ...] = (
+    DRAEGER_EIT_HEADER_SPEC,
+    CAREFUSION_EIT_SPEC,            # ← add here; detection is automatic
+)
+```
+
+`HeaderFormatSpec` fields:
+
+| Field | Purpose |
+|-------|---------|
+| `magic_string` | ASCII substring searched in the first `magic_search_bytes` |
+| `magic_search_bytes` | How many bytes to read for detection (keep it small) |
+| `encoding` | Header text encoding (usually `"latin-1"` or `"utf-8"`) |
+| `frame_size_bytes` | Byte-exact size of one binary frame — used by the parser |
+| `n_electrodes` / `n_measurements` | Protocol geometry metadata |
 
-**Binary with a recognisable header** — add a branch in `detect_vendor_and_format()`
-and a helper that reads the magic bytes:
+---
+
+**`.eit`-style but with a new extension (e.g. `.acm`)**
+
+Add one branch in `detect_vendor_and_format()` that calls the same generic
+`detect_vendor_from_eit_header()` (if the magic-string approach works for this format):
 
 ```python
-# In detect_vendor_and_format():
+# In detect_vendor_and_format() — detection.py:
 if extension == ".acm":
-    vendor = _detect_vendor_from_acm_header(path)
+    vendor = detect_vendor_from_eit_header(path)  # reuses HEADER_FORMAT_SPECS
     return FileDetection(path=path, extension=extension, vendor=vendor)
-
-def _detect_vendor_from_acm_header(path: Path) -> str:
-    with path.open("rb") as f:
-        magic = f.read(8)
-    if magic == b"ACMEIT\x01\x00":
-        return "acmeit"
-    raise ValueError(f"Unrecognised .acm header in '{path}'.")
 ```
 
-**Binary without a header (size-based)** — add a `FormatSpec` to
-`BIN_FORMAT_SPECS` (see section 2). No detection function needed.
+Then add the `HeaderFormatSpec` to `HEADER_FORMAT_SPECS` as above.
 
-**Tabular** — extend `detect_vendor_from_tabular()` with a keyword found in the
-file header (first 40 lines):
+---
+
+**Binary without a header (size-based, `.bin`)**
+
+Add a `FormatSpec` to `BIN_FORMAT_SPECS` (see [section 2](#2-add-a-new-drger-bin-frame-size)).
+No changes to `detection.py` needed.
+
+---
+
+**Tabular (CSV / TXT / ASC)**
+
+File: `src/fasteit/parsers/detection.py` — extend `detect_vendor_from_tabular()`
+with a keyword found in the first 40 lines:
 
 ```python
 # In detect_vendor_from_tabular():
-for line in lines[:40]:
-    if "hamilton medical" in line.lower():
-        return "hamilton"
+if "hamilton medical" in normalized:
+    return "hamilton"
 ```
 
 ---
@@ -478,3 +520,45 @@ Minimal coverage for a tabular parser:
 
 ---
 
+## 5. File layout
+
+```
+src/fasteit/
+├── models/
+│   ├── base_data.py              BaseData — common fields for all containers
+│   ├── reconstructed_data.py     ReconstructedFrameData — 32×32 pixel frames
+│   ├── continuous_data.py        ContinuousSignalData — tabular signal export
+│   └── raw_impedance_data.py     RawImpedanceData — 208 transimpedances per frame
+│
+└── parsers/
+    ├── base.py                   BaseParser (validate / parse / parse_safe)
+    ├── bin_formats.py            BIN_FORMAT_SPECS — all known .bin frame sizes
+    ├── detection.py              detect_vendor_and_format() — routes any file
+    ├── errors.py                 AmbiguousFormatError, UnknownFormatError
+    ├── header_formats.py         EIT_HEADER_FORMATS — known .eit ASCII headers
+    ├── loader.py                 load_data / load_many / load_folder
+    │
+    ├── draeger/
+    │   ├── asc/
+    │   │   └── asc_parser.py     DragerAscParser — .asc continuous export
+    │   ├── bin/
+    │   │   ├── bin_parser.py     DragerBinParser — .bin reconstructed frames
+    │   │   ├── bin_utils.py      Sentinel → NaN, fs estimation helpers
+    │   │   └── draeger_dtypes.py FRAME_BASE_DTYPE, FRAME_EXT_DTYPE, MEDIBUS_* fields
+    │   └── eit/
+    │       ├── eit_parser.py     DragerEitParser — .eit raw transimpedances
+    │       ├── eit_dtypes.py     EIT_FRAME_DTYPE (5495-byte frame layout)
+    │       ├── eit_utils.py      Calibration constants FT_A/FT_B/FC_CURRENT/FV_VOLTAGE
+    │       └── eit_pyeit_bridge.py  build_greit() / reconstruct_greit() — pyEIT bridge
+    │
+    └── timpel/
+        ├── timpel_parser.py      TimpelTabularParser — .csv/.txt reconstructed frames
+        └── timpel_dtypes.py      TIMPEL_AUX_FIELDS — auxiliary signal columns
+```
+
+**Where to add a new vendor** — create `parsers/<vendor>/` mirroring the structure above:
+one `<vendor>_parser.py`, one `<vendor>_dtypes.py`, one `__init__.py`.
+Then follow steps 1–5 in [section 3](#3-add-a-new-parser).
+
+---
+
diff --git a/docs/reverse_eng/eit_format.ipynb b/docs/reverse_eng/eit_format.ipynb
index 8bbacda..cdbf1ce 100644
--- a/docs/reverse_eng/eit_format.ipynb
+++ b/docs/reverse_eng/eit_format.ipynb
@@ -971,7 +971,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "fasteit",
    "language": "python",
    "name": "python3"
   },
diff --git a/notebooks/01_real_data_verification.ipynb b/notebooks/01_real_data_verification.ipynb
index de65bce..843b891 100644
--- a/notebooks/01_real_data_verification.ipynb
+++ b/notebooks/01_real_data_verification.ipynb
@@ -9,7 +9,7 @@
     "\n",
     "Proof-of-concept of the parsing pipeline on real files from a Dräger PulmoVista 500.\n",
     "\n",
-    "**Purpose**: verify that the parsers correctly extract the data stored in real clinical\n",
+    "**Purpose**: verify that the `DragerBinParsers` correctly extract the data stored in real clinical\n",
     "files and that the output objects are reliable. This notebook does **not** apply any\n",
     "signal processing, no filters, no EIT reconstruction masks.\n",
     "Raw parsed values are plotted directly to confirm parser correctness.\n",
@@ -585,13 +585,13 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "fasteit",
    "language": "python",
    "name": "python3"
   },
   "language_info": {
    "name": "python",
-   "version": "3.11.0"
+   "version": "3.11.15"
   }
  },
  "nbformat": 4,
diff --git a/notebooks/02_benchmark_parsing.ipynb b/notebooks/02_benchmark_parsing.ipynb
index 08235a8..2241194 100644
--- a/notebooks/02_benchmark_parsing.ipynb
+++ b/notebooks/02_benchmark_parsing.ipynb
@@ -327,9 +327,9 @@
     "\n",
     "memmap is faster and uses less RAM across all file sizes tested.\n",
     "\n",
-    "**Why memmap is fast:** `np.memmap` sets up a virtual address space mapping. The OS loads file pages on demand. `parse_memmap()` returns a lazy view of the pixel field: no data is actually read from disk until accessed; the mapping is read-only.\n",
+    "**memmap is fast:** `np.memmap` sets up a virtual address space mapping. The OS loads file pages on demand. `parse_memmap()` returns a lazy view of the pixel field: no data is actually read from disk until accessed; the mapping is read-only.\n",
     "\n",
-    "**Why struct.unpack is slower:** `path.read_bytes()` loads the entire file into a Python `bytes` buffer in RAM before any parsing begins. Every frame then requires one `struct.unpack_from` call and one tuple allocation.\n",
+    "**struct.unpack is slower:** `path.read_bytes()` loads the entire file into a Python `bytes` buffer in RAM before any parsing begins. Every frame then requires one `struct.unpack_from` call and one tuple allocation.\n",
     "\n",
     "struct peak RAM grows linearly: one full `bytes` buffer + one pixel array.\n",
     "memmap peak RAM is near zero: only the virtual mapping is set up, no pixel array is allocated in RAM.\n",
@@ -340,15 +340,15 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "fasteit",
    "language": "python",
    "name": "python3"
   },
   "language_info": {
    "name": "python",
-   "version": "3.10.0"
+   "version": "3.11.15"
   }
  },
  "nbformat": 4,
  "nbformat_minor": 4
-}
\ No newline at end of file
+}
diff --git a/notebooks/03_eit_parser_validation.ipynb b/notebooks/03_eit_parser_validation.ipynb
new file mode 100644
index 0000000..8a45321
--- /dev/null
+++ b/notebooks/03_eit_parser_validation.ipynb
@@ -0,0 +1,433 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## EIT Parser Validation\n",
+    "\n",
+    "Validates that `DragerEitParser` reads `.eit` files correctly and that the\n",
+    "calibration pipeline produces physically plausible transimpedance values.\n",
+    "\n",
+    "Calibration pipeline (empirical constants from EIDORS, A. Adler 2016 — hardcoded, not in the header):\n",
+    "- `vv = FT_A * trans_A - FT_B * trans_B`  → calibrated transimpedance [Ω]\n",
+    "- `I_real = injection_current / FC_CURRENT` → actual injected current [A]\n",
+    "- `V_diff = (voltage_A - voltage_B) / FV_VOLTAGE` → differential voltage [V]\n",
+    "\n",
+    "Cross-validation against the corresponding `.bin` file (vendor-reconstructed 32×32 images).\n",
+    "\n",
+    "The goal of this notebook is far from providing a physically valid reconstruction pipeline.\n",
+    "The primary intent is simply to demonstrate the validity of `DragerEitParser`, the data\n",
+    "calibrated with the EIDORS constants, and to show the bridge toward Python EIT reconstruction\n",
+    "libraries such as pyEIT for those who wish to work with raw transimpedance signals.\n",
+    "\n",
+    "The planned next step is to reproduce with an ML model the deterministic process used by\n",
+    "Dräger in its internal transformation, using `.eit` frames as input and the corresponding\n",
+    "`.bin` frames as output. This should teach the model not only the spatial reconstruction\n",
+    "but also the various filters applied internally. This remains a planned future feature and\n",
+    "has not yet been implemented."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pathlib import Path\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from fasteit.parsers.draeger.eit.eit_parser import DragerEitParser\n",
+    "from fasteit.parsers.draeger.bin.bin_parser import DragerBinParser"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "EIT_FILE = Path(\"../src/fasteit/test_files/patient01.eit\")\n",
+    "BIN_FILE = Path(\"../src/fasteit/test_files/patient01.bin\")\n",
+    "\n",
+    "eit = DragerEitParser().parse(EIT_FILE)\n",
+    "bin_ = DragerBinParser().parse(BIN_FILE)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1. Parser output structure"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "=== .eit parser output ===\n",
+      "measurements (vv) shape : (11500, 208)\n",
+      "fs                      : 50.0 Hz\n",
+      "n_frames                : 11500\n",
+      "n_electrodes            : 16\n",
+      "n_measurements          : 208\n",
+      "detected_spec           : Draeger_EIT_v51\n",
+      "date / time             : 04.01.2024 18:10:54.015\n",
+      "frequency               : 101.501 kHz\n",
+      "amplitude               : 9100.0 µA\n",
+      "\n",
+      "calibration constants (EIDORS hardcoded, A. Adler 2016):\n",
+      "  FT_A=0.00098242, FT_B=0.00019607, FC_CURRENT=194326.3536, FV_VOLTAGE=0.11771\n",
+      "\n",
+      "aux_signals keys: ['timestamp', 'trans_A', 'trans_B', 'injection_current', 'I_real', 'voltage_A', 'voltage_B', 'V_diff', 'frame_counter', 'medibus']\n"
+     ]
+    }
+   ],
+   "source": [
+    "from fasteit.parsers.draeger.eit.eit_utils import FT_A, FT_B, FC_CURRENT, FV_VOLTAGE\n",
+    "\n",
+    "print(\"=== .eit parser output ===\")\n",
+    "print(f\"measurements (vv) shape : {eit.measurements.shape}\")\n",
+    "print(f\"fs                      : {eit.fs} Hz\")\n",
+    "print(f\"n_frames                : {eit.metadata['n_frames']}\")\n",
+    "print(f\"n_electrodes            : {eit.metadata['n_electrodes']}\")\n",
+    "print(f\"n_measurements          : {eit.metadata['n_measurements']}\")\n",
+    "print(f\"detected_spec           : {eit.metadata['detected_spec']}\")\n",
+    "print(f\"date / time             : {eit.metadata.get('date')} {eit.metadata.get('time')}\")\n",
+    "print(f\"frequency               : {eit.metadata.get('frequency_khz')} kHz\")\n",
+    "print(f\"amplitude               : {eit.metadata.get('amplitude_ua')} µA\")\n",
+    "print()\n",
+    "print(\"calibration constants (EIDORS hardcoded, A. Adler 2016):\")\n",
+    "print(f\"  FT_A={FT_A}, FT_B={FT_B}, FC_CURRENT={FC_CURRENT}, FV_VOLTAGE={FV_VOLTAGE}\")\n",
+    "print()\n",
+    "print(\"aux_signals keys:\", list(eit.aux_signals.keys()))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2. Sanity check: vv is non-zero and NaN-free"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "NaN count : 0\n",
+      "Zero rows : 0\n",
+      "min / max : -0.0000 / 0.1597\n",
+      "mean      : 0.0125\n"
+     ]
+    }
+   ],
+   "source": [
+    "vv = eit.measurements\n",
+    "\n",
+    "print(f\"NaN count : {np.isnan(vv).sum()}\")\n",
+    "print(f\"Zero rows : {(vv == 0).all(axis=1).sum()}\")\n",
+    "print(f\"min / max : {vv.min():.4f} / {vv.max():.4f}\")\n",
+    "print(f\"mean      : {vv.mean():.4f}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3. Timestamps are monotonically increasing"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Timestamp range : 0.757570 – 0.760232 (fraction of day)\n",
+      "Monotonically increasing: True\n",
+      "Duration approx : 3.8 min\n"
+     ]
+    }
+   ],
+   "source": [
+    "ts = eit.aux_signals[\"timestamp\"]\n",
+    "print(f\"Timestamp range : {ts.min():.6f} – {ts.max():.6f} (fraction of day)\")\n",
+    "print(f\"Monotonically increasing: {bool(np.all(np.diff(ts) >= 0))}\")\n",
+    "print(f\"Duration approx : {(ts.max() - ts.min()) * 24 * 60:.1f} min\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 4. Calibrated transimpedance waveform — measurement 0, first 500 frames"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x300 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots(figsize=(12, 3))\n",
+    "ax.plot(vv[:500, 0], lw=0.8)\n",
+    "ax.set_xlabel(\"Frame\")\n",
+    "ax.set_ylabel(\"vv [Ω]\")\n",
+    "ax.set_title(\"Calibrated transimpedance — measurement 0, first 500 frames\")\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 5. Frame count comparison: .eit vs .bin"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      ".eit n_frames : 11500\n",
+      ".bin n_frames : 11500\n",
+      ".eit fs       : 50.0 Hz\n",
+      ".bin fs       : 50.0 Hz\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(f\".eit n_frames : {eit.metadata['n_frames']}\")\n",
+    "print(f\".bin n_frames : {bin_.n_frames}\")\n",
+    "print(f\".eit fs       : {eit.fs} Hz\")\n",
+    "print(f\".bin fs       : {bin_.fs} Hz\")\n",
+    "\n",
+    "delta = abs(eit.metadata['n_frames'] - bin_.n_frames)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 6. GREIT reconstruction — transimpedances to 32×32 image\n",
+    "\n",
+    "`reconstruct_greit()` converts `vv` (N_frames, 208) to 32×32 images using the\n",
+    "GREIT algorithm (Adler et al., *Physiol. Meas.* 2009).\n",
+    "Reconstruction is differential: each pixel shows Δσ relative to a reference frame.\n",
+    "First 50 frames used as baseline (stable period before the respiratory cycle)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": "from fasteit.parsers.draeger.eit.eit_pyeit_bridge import reconstruct_greit\n\n# Use first 50 frames as baseline (stable reference period)\nimages = reconstruct_greit(vv, ref_frame=(0, 50))\n\nprint(f\"Input  : vv.shape = {vv.shape}\")\nprint(f\"Output : images.shape = {images.shape}\")\nprint(f\"NaN pixels per frame  : {np.isnan(images[0]).sum()} / {images[0].size} (outside electrode circle)\")"
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 6b. Sign correction\n",
+    "\n",
+    "The GREIT algorithm outputs conductivity change (Δσ): when air enters the lungs,\n",
+    "conductivity decreases → signal goes down.\n",
+    "Dräger uses the **impedance** convention: air enters → impedance rises → signal goes up.\n",
+    "\n",
+    "Negating the GREIT output brings it into the Dräger convention.\n",
+    "The correction is applied inside `reconstruct_greit()` so callers never need to\n",
+    "handle it manually."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1300x500 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Global EIT signal: sum of all pixels per frame\n",
+    "global_greit = np.nansum(images, axis=(1, 2))\n",
+    "time = np.arange(len(global_greit)) / eit.fs\n",
+    "\n",
+    "global_bin = bin_.global_signal\n",
+    "time_bin = np.arange(len(global_bin)) / bin_.fs\n",
+    "\n",
+    "def norm01(x):\n",
+    "    return (x - x.min()) / (x.max() - x.min())\n",
+    "\n",
+    "fig, axes = plt.subplots(2, 1, figsize=(13, 5), layout=\"constrained\", sharex=True)\n",
+    "\n",
+    "# Before correction: peaks were inverted relative to .bin\n",
+    "axes[0].plot(time, norm01(-global_greit), lw=0.9, color=\"C0\", label=\"GREIT (conductivity convention)\", alpha=0.85)\n",
+    "axes[0].plot(time_bin, norm01(global_bin), lw=0.9, color=\"C1\", label=\".bin (Dräger)\", alpha=0.85)\n",
+    "axes[0].set_ylabel(\"Normalized [0-1]\")\n",
+    "axes[0].set_title(\"Before correction — peaks inverted relative to .bin\")\n",
+    "axes[0].legend()\n",
+    "\n",
+    "# After correction: reconstruct_greit() negates internally\n",
+    "axes[1].plot(time, norm01(global_greit), lw=0.9, color=\"C0\", label=\"GREIT (impedance convention)\", alpha=0.85)\n",
+    "axes[1].plot(time_bin, norm01(global_bin), lw=0.9, color=\"C1\", label=\".bin (Dräger)\", alpha=0.85)\n",
+    "axes[1].set_xlabel(\"Time (s)\")\n",
+    "axes[1].set_ylabel(\"Normalized [0-1]\")\n",
+    "axes[1].set_title(\"After correction — same convention as .bin\")\n",
+    "axes[1].legend()\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 7. Image sequence over one respiratory cycle\n",
+    "\n",
+    "4 seconds of consecutive frames (~200 frames at 50 Hz) to observe how the\n",
+    "reconstructed image evolves through inspiration and expiration.\n",
+    "The high-intensity region on the left of the raw image is likely the cardiac signal.\n",
+    "The image does not appear correctly oriented.\n",
+    "\n",
+    "From the documentation, pyEIT places electrode 0 at 3 o'clock, while the Dräger\n",
+    "PulmoVista 500 belt places electrode 1 on the anterior chest wall. The images are\n",
+    "likely not correctly oriented without the rotation and flip transforms."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1400x220 with 10 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# 4 seconds of consecutive frames around the middle of the recording\n",
+    "t_start = len(images) // 2          # start at midpoint\n",
+    "n_sec = 4                            # seconds to show\n",
+    "n_frames_show = int(n_sec * eit.fs)  # ~200 frames\n",
+    "frame_idx = range(t_start, t_start + n_frames_show)\n",
+    "\n",
+    "# One frame every 0.4 s\n",
+    "step = int(0.4 * eit.fs)\n",
+    "selected = list(frame_idx)[::step]\n",
+    "\n",
+    "ncols = len(selected)\n",
+    "fig, axes = plt.subplots(1, ncols, figsize=(ncols * 1.4, 2.2), layout=\"constrained\")\n",
+    "vmax = np.nanpercentile(np.abs(images[list(frame_idx)]), 99)\n",
+    "\n",
+    "for ax, idx in zip(axes, selected):\n",
+    "    ax.imshow(images[idx], cmap=\"RdBu_r\", vmin=-vmax, vmax=vmax, origin=\"lower\")\n",
+    "    ax.set_title(f\"{(idx - t_start)/eit.fs:.1f}s\", fontsize=7)\n",
+    "    ax.axis(\"off\")\n",
+    "\n",
+    "fig.suptitle(\"GREIT — 4 consecutive seconds (one frame every 0.4 s)\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 9. Frame alignment: .eit vs .bin\n",
+    "\n",
+    "The PulmoVista 500 records **only the `.eit` file** (raw transimpedances).\n",
+    "The `.bin` is generated afterward by Dräger's software, which applies its\n",
+    "Newton-Raphson FEM reconstruction to each `.eit` frame in sequence.\n",
+    "\n",
+    "This means frame *k* in `.bin` is the reconstruction of frame *k* in `.eit`\n",
+    "**by construction**, a temporal offset is architecturally impossible.\n",
+    "\n",
+    "A lag of 0 also validates that the paired dataset for the data-driven\n",
+    "reconstruction model (ML branch) is perfectly aligned with zero noise from\n",
+    "frame misalignment."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Summary\n",
+    "\n",
+    "**Conclusion**: the `.eit` → `RawImpedanceData` → pyEIT bridge is functional for those\n",
+    "who wish to work with EIT reconstruction algorithms.\n",
+    "`DragerEitParser` correctly extracts 208 calibrated transimpedances per frame,\n",
+    "timestamps, and auxiliary signals. GREIT reconstruction is available as an optional\n",
+    "utility (`fasteit[pyeit]`).\n",
+    "\n",
+    "The spatial quality of GREIT images with a generic circular mesh does not match\n",
+    "the vendor-reconstructed `.bin` (Dräger uses a proprietary algorithm and mesh).\n",
+    "A data-driven reconstruction that learns the Dräger mapping directly from paired\n",
+    "`.eit`/`.bin` recordings will be implemented soon."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "fasteit",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.15"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
\ No newline at end of file
diff --git a/src/fasteit/models/raw_impedance_data.py b/src/fasteit/models/raw_impedance_data.py
index a002f4e..1de6103 100644
--- a/src/fasteit/models/raw_impedance_data.py
+++ b/src/fasteit/models/raw_impedance_data.py
@@ -21,9 +21,11 @@ class RawImpedanceData(BaseData):
     before any image reconstruction. The intended consumer is pyEIT.
 
     Attributes:
-        measurements: Raw transimpedance array, shape (N_frames, 208).
+        measurements: Calibrated transimpedance array, shape (N_frames, 208).
+                      Values are gain-corrected (e.g. ``vv = FT_A*trans_A - FT_B*trans_B``
+                      for Dräger), not raw ADC counts and not yet image-reconstructed.
                       208 = 16 electrodes × 13 measurement pairs
-                      (adjacent drive, standard Dräger/Timpel pattern).
+                      (adjacent drive, standard Dräger pattern).
         aux_signals:  Optional dict of auxiliary waveforms keyed by signal
                       name, e.g. ``{"timestamp": ..., "frame_counter": ...,
                       "medibus_Paw": ...}``. Each value is a 1-D array of
diff --git a/src/fasteit/parsers/__init__.py b/src/fasteit/parsers/__init__.py
index 3b017c2..71a15df 100644
--- a/src/fasteit/parsers/__init__.py
+++ b/src/fasteit/parsers/__init__.py
@@ -7,8 +7,11 @@
 - DragerAscParser   (.asc) — tabular PulmoVista signal export
 - TimpelTabularParser (.csv/.txt/.asc) — Timpel tabular recordings
 
-Scaffolds (not yet implemented):
-- DragerEitParser   (.eit) — raw electrode voltages (Task 2.x)
+- DragerEitParser   (.eit) — raw transimpedances (208/frame); calibration pipeline EIDORS/Adler 2016
+
+Reconstruction utilities (optional — requires pyeit):
+- reconstruct_greit / build_greit — GREIT image reconstruction from RawImpedanceData
+  Import: from fasteit.parsers.draeger.eit.eit_pyeit_bridge import reconstruct_greit
 
 Utilities:
 - detect_vendor_and_format — extension/vendor/format auto-detection
diff --git a/src/fasteit/parsers/draeger/eit/eit_parser.py b/src/fasteit/parsers/draeger/eit/eit_parser.py
index baec1de..2cb60d9 100644
--- a/src/fasteit/parsers/draeger/eit/eit_parser.py
+++ b/src/fasteit/parsers/draeger/eit/eit_parser.py
@@ -1,4 +1,4 @@
-"""Dräger `.eit` parser (Task 2.x).
+"""Dräger `.eit` parser.
 
 Format summary (reverse-engineered from PulmoVista 500 output,
 cross-referenced with EIDORS read_draeger_header/read_draeger_file):
@@ -14,6 +14,7 @@
 
 from __future__ import annotations
 
+import warnings
 from pathlib import Path
 
 import numpy as np
@@ -24,7 +25,7 @@
 from fasteit.parsers.header_formats import get_eit_specs
 
 from .eit_dtypes import FRAME_EIT_DTYPE, PREAMBLE_DTYPE, PREAMBLE_N_FIELDS
-from .eit_utils import FC_CURRENT, FV_VOLTAGE, SEPARATOR, parse_eit_header
+from .eit_utils import FC_CURRENT, FT_A, FT_B, FV_VOLTAGE, SEPARATOR, parse_eit_header
 
 
 class DragerEitParser(BaseParser):
@@ -69,7 +70,9 @@ def parse(self, path: Path) -> RawImpedanceData:
         if path.stat().st_size < preamble_size:
             raise ValueError(f"'{path}' is too small to be a valid .eit file.")
 
-        preamble = np.memmap(path, dtype=PREAMBLE_DTYPE, mode="r", shape=(PREAMBLE_N_FIELDS,))
+        preamble = np.memmap(
+            path, dtype=PREAMBLE_DTYPE, mode="r", shape=(PREAMBLE_N_FIELDS,)
+        )
         _, sep_offset, _ = int(preamble[0]), int(preamble[1]), int(preamble[2])
 
         with path.open("rb") as f:
@@ -79,8 +82,7 @@ def parse(self, path: Path) -> RawImpedanceData:
         binary_start = sep_offset + len(SEPARATOR)
         data_size = path.stat().st_size - binary_start
         candidates = [
-            s for s in get_eit_specs("draeger")
-            if data_size % s.frame_size_bytes == 0
+            s for s in get_eit_specs("draeger") if data_size % s.frame_size_bytes == 0
         ]
         if not candidates:
             known = [s.frame_size_bytes for s in get_eit_specs("draeger")]
@@ -111,38 +113,44 @@ def parse(self, path: Path) -> RawImpedanceData:
         )
 
         # ── 5. Extract fields and compute calibrated transimpedance ──────────
-        ft = metadata.get("calibration_factor")
-        if not isinstance(ft, list) or len(ft) != 2:
-            raise ValueError(
-                f"'Calibration Factor' in header must be two floats, got: {ft!r}"
-            )
-
         # Calibration pipeline — EIDORS read_draeger_file.m (GPL, understanding
-        # only, no code copied). Empirical constants estimated 2016-04-07 A. Adler.
-        trans_A    = np.array(frames["trans_A"])           # (n_frames, 208) ADC counts
-        trans_B    = np.array(frames["trans_B"])           # (n_frames, 208) ADC counts
-        inj_curr   = np.array(frames["injection_current"]) # (n_frames, 16)  ADC counts
-        voltage_A  = np.array(frames["voltage_A"])         # (n_frames, 16)  ADC counts
-        voltage_B  = np.array(frames["voltage_B"])         # (n_frames, 16)  ADC counts
-
-        vv     = ft[0] * trans_A - ft[1] * trans_B  # (n_frames, 208) calibrated transimpedance
-        I_real = inj_curr / FC_CURRENT               # (n_frames, 16)  actual injected current [A]
-        V_diff = (voltage_A - voltage_B) / FV_VOLTAGE  # (n_frames, 16)  differential voltage [V]
+        # only, no code copied). Empirical constants hardcoded in EIDORS by
+        # A. Adler, estimated 2016-04-07. Not present in the .eit header.
+        trans_A = np.array(frames["trans_A"])  # (n_frames, 208) ADC counts
+        trans_B = np.array(frames["trans_B"])  # (n_frames, 208) ADC counts
+        inj_curr = np.array(frames["injection_current"])  # (n_frames, 16)  ADC counts
+        voltage_A = np.array(frames["voltage_A"])  # (n_frames, 16)  ADC counts
+        voltage_B = np.array(frames["voltage_B"])  # (n_frames, 16)  ADC counts
+
+        vv = (
+            FT_A * trans_A - FT_B * trans_B
+        )  # (n_frames, 208) calibrated transimpedance
+        I_real = inj_curr / FC_CURRENT  # (n_frames, 16)  actual injected current [A]
+        V_diff = (
+            voltage_A - voltage_B
+        ) / FV_VOLTAGE  # (n_frames, 16)  differential voltage [V]
 
         aux_signals: dict[str, np.ndarray] = {
-            "timestamp":          np.array(frames["timestamp"]),  # fraction of day
-            "trans_A":            trans_A,                        # raw, for audit
-            "trans_B":            trans_B,                        # raw, for audit
-            "injection_current":  inj_curr,                       # raw ADC counts
-            "I_real":             I_real,                         # [A] actual injected current
-            "voltage_A":          voltage_A,                      # raw ADC counts
-            "voltage_B":          voltage_B,                      # raw ADC counts
-            "V_diff":             V_diff,                         # [V] differential voltage
-            "frame_counter":      np.array(frames["frame_counter"]),
-            "medibus":            np.array(frames["medibus"]),    # (n_frames, 67)
+            "timestamp": np.array(frames["timestamp"]),  # fraction of day
+            "trans_A": trans_A,  # raw, for audit
+            "trans_B": trans_B,  # raw, for audit
+            "injection_current": inj_curr,  # raw ADC counts
+            "I_real": I_real,  # [A] actual injected current
+            "voltage_A": voltage_A,  # raw ADC counts
+            "voltage_B": voltage_B,  # raw ADC counts
+            "V_diff": V_diff,  # [V] differential voltage
+            "frame_counter": np.array(frames["frame_counter"]),
+            "medibus": np.array(frames["medibus"]),  # (n_frames, 67)
         }
 
         # ── 6. Assemble result ────────────────────────────────────────────────
+        if "fs" not in metadata:
+            warnings.warn(
+                f"'Framerate [Hz]' not found in header of '{path}'. "
+                "Defaulting to fs=50.0 Hz.",
+                UserWarning,
+                stacklevel=2,
+            )
         fs: float = metadata.get("fs", 50.0)
         metadata["n_frames"] = n_frames
         metadata["frame_format"] = spec.name
diff --git a/src/fasteit/parsers/draeger/eit/eit_pyeit_bridge.py b/src/fasteit/parsers/draeger/eit/eit_pyeit_bridge.py
new file mode 100644
index 0000000..d2e8700
--- /dev/null
+++ b/src/fasteit/parsers/draeger/eit/eit_pyeit_bridge.py
@@ -0,0 +1,199 @@
+"""GREIT image reconstruction for Dräger `.eit` transimpedance data.
+
+Wraps pyEIT's GREIT implementation to convert ``RawImpedanceData.measurements``
+(shape ``(N_frames, 208)``) into reconstructed 32×32 pixel images
+(shape ``(N_frames, 32, 32)``).
+
+Algorithm reference:
+    Adler A, Arnold JH, Bayford R, et al.
+    "GREIT: a unified approach to 2D linear EIT reconstruction of lung images."
+    *Physiol. Meas.* 30 (2009) S35–S55.
+    DOI: 10.1088/0967-3334/30/6/S03
+
+Default parameters (p=0.2, lamb=1e-2, n=32) are those recommended in the
+GREIT paper for lung monitoring with 16-electrode adjacent-drive protocols.
+
+Measurement protocol: ``fmmu`` (rotating sweep starting from the electrode
+adjacent to the current sink), confirmed from the PulmoVista 500 IFU SW 1.3n
+p. 144 measurement diagram.
+
+Image convention: sign-negated (impedance), rotated 90° CCW (electrode 1 at
+12 o'clock = anterior), horizontally flipped (CT caudal-cranial convention:
+left of image = right of patient). Source: IFU p. 146.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+try:
+    import pyeit.eit.greit as greit_mod
+    import pyeit.eit.protocol as proto_mod
+    import pyeit.mesh
+
+    _PYEIT_AVAILABLE = True
+except ImportError:  # pragma: no cover
+    _PYEIT_AVAILABLE = False
+
+
+def _check_pyeit() -> None:
+    if not _PYEIT_AVAILABLE:
+        raise ImportError(
+            "pyEIT is required for image reconstruction. "
+            "Install it with: pip install pyeit"
+        )
+
+
+def build_greit(
+    n_el: int = 16,
+    h0: float = 0.1,
+    p: float = 0.2,
+    lamb: float = 1e-2,
+    n: int = 32,
+) -> tuple:
+    """Build and return a configured GREIT solver.
+
+    Creates a circular unit-disk mesh, an adjacent-drive protocol (dist_exc=1,
+    step_meas=1, parser_meas='fmmu'), and a GREIT solver ready for ``solve()``.
+
+    **Measurement ordering — why ``fmmu``:**
+    The PulmoVista 500 sweeps voltage measurements starting from the electrode
+    immediately adjacent to the current sink and rotates around the ring.
+    This matches pyEIT's ``fmmu`` (rotating) protocol, not ``std`` (absolute).
+    Source: Dräger PulmoVista 500 IFU SW 1.3n, p. 144 — measurement diagram
+    shows V1 at the pair adjacent to the sink electrode for each drive pattern.
+
+    Args:
+        n_el:  Number of electrodes. Default 16 (Dräger PulmoVista 500).
+        h0:    Mesh density parameter passed to ``pyeit.mesh.create``.
+               Default 0.1.
+        p:     GREIT noise figure (0–1).
+               Default 0.2 (Adler 2009 recommendation).
+        lamb:  Tikhonov regularisation parameter. Default 1e-2.
+        n:     Output image size (``n × n`` pixels). Default 32.
+
+    Returns:
+        Tuple ``(greit_solver, protocol)`` ready for reconstruction.
+
+    References:
+        Adler et al., *Physiol. Meas.* 30 (2009) S35–S55.
+        DOI: 10.1088/0967-3334/30/6/S03
+    """
+    _check_pyeit()
+    mesh_obj = pyeit.mesh.create(n_el=n_el, h0=h0)
+    protocol = proto_mod.create(n_el=n_el, dist_exc=1, step_meas=1, parser_meas="fmmu")
+    solver = greit_mod.GREIT(mesh_obj, protocol)
+    solver.setup(p=p, lamb=lamb, n=n)
+    return solver, protocol
+
+
+def reconstruct_greit(
+    measurements: np.ndarray,
+    ref_frame: np.ndarray | int | tuple[int, int] | None = None,
+    n_el: int = 16,
+    p: float = 0.2,
+    lamb: float = 1e-2,
+    n: int = 32,
+) -> np.ndarray:
+    """Reconstruct EIT images from transimpedance measurements using GREIT.
+
+    Converts ``RawImpedanceData.measurements`` (shape ``(N_frames, 208)``)
+    to reconstructed 32×32 pixel images via the GREIT algorithm.
+
+    **Baseline selection** — GREIT produces *differential* images relative to a
+    reference frame. The default (``ref_frame=None``, mean of all frames) is the
+    right choice for single-file analysis (tidal variation, regional distribution).
+
+    **EELI and cross-recording comparison** — End-Expiratory Lung Impedance (EELI)
+    is the only clinically meaningful *absolute* value in EIT: it reflects the
+    functional residual capacity (FRC). To compare EELI across recordings (e.g.
+    two NIV interfaces in the same patient), all files must share the same external
+    reference so that ``global_signal[end_exp]`` is on the same absolute scale::
+
+        # Record a stable baseline at the start of the session (before any
+        # intervention). Use its end-expiratory mean as the reference for all
+        # subsequent recordings in that session.
+        ref = data_baseline.measurements[:50].mean(axis=0)  # shape (208,)
+
+        images_niv1 = reconstruct_greit(data_niv1.measurements, ref_frame=ref)
+        images_niv2 = reconstruct_greit(data_niv2.measurements, ref_frame=ref)
+        # EELI_niv2 > EELI_niv1 → interface 2 maintains better FRC
+
+    **Limitation**: if the device recalibrates between recordings, the absolute
+    impedance baseline shifts and introduces an unrecoverable offset. Comparisons
+    remain valid as long as the clinical effect of interest is larger than the
+    calibration drift.
+
+    Args:
+        measurements: Calibrated transimpedance array, shape ``(N_frames, 208)``.
+                      Typically ``RawImpedanceData.measurements``.
+        ref_frame:    Reference (baseline) for differential reconstruction:
+                      - ``None``             → mean of all frames in this recording.
+                      - ``int``              → single frame index within this recording.
+                      - ``(start, end)``     → mean of ``measurements[start:end]``.
+                      - ``np.ndarray (208,)``→ external reference (from another
+                        recording, or a manually defined baseline). Use this to
+                        compare recordings taken at different times or after
+                        device recalibration.
+        n_el:         Number of electrodes. Default 16.
+        p:            GREIT noise figure. Default 0.2.
+        lamb:         Regularisation parameter. Default 1e-2.
+        n:            Output image side length in pixels. Default 32.
+
+    Returns:
+        Reconstructed images, shape ``(N_frames, n, n)``. Values are
+        differential conductivity change (Δσ), NaN outside the electrode circle.
+
+    Raises:
+        ImportError: If pyEIT is not installed.
+        ValueError:  If ``measurements`` does not have shape ``(N, 208)``.
+
+    References:
+        Adler et al., *Physiol. Meas.* 30 (2009) S35–S55.
+        DOI: 10.1088/0967-3334/30/6/S03
+    """
+    _check_pyeit()
+
+    if measurements.ndim != 2 or measurements.shape[1] != 208:
+        raise ValueError(
+            f"measurements must have shape (N_frames, 208), got {measurements.shape}"
+        )
+
+    # Resolve reference frame (v0)
+    if ref_frame is None:
+        v0 = measurements.mean(axis=0)  # mean over all frames
+    elif isinstance(ref_frame, int):
+        v0 = measurements[ref_frame]
+    elif isinstance(ref_frame, tuple):
+        start, end = ref_frame
+        v0 = measurements[start:end].mean(axis=0)  # mean over frame range
+    else:
+        v0 = np.asarray(ref_frame)
+        if v0.shape != (208,):
+            raise ValueError(f"ref_frame array must have shape (208,), got {v0.shape}")
+
+    solver, _ = build_greit(n_el=n_el, p=p, lamb=lamb, n=n)
+
+    n_frames, n_meas = measurements.shape  # (N_frames, 208)
+    images = np.full((n_frames, n, n), np.nan)  # output: (N_frames, n, n)
+
+    for i, v1 in enumerate(measurements):
+        # GREIT computes Δσ (conductivity change): decreases when air enters the lungs.
+        # Clinical EIT convention is the opposite (impedance increases with air).
+        # Negate so images match the .bin Dräger convention — peaks up during inspiration.
+        # Rotate 90° CCW (k=1) to match anatomical orientation: heart left-anterior,
+        # right lung on the right (same as a CT cross-section viewed from the feet).
+        ds = solver.solve(v1, v0)
+        # Post-processing to match Dräger PulmoVista 500 display convention
+        # (IFU SW 1.3n, p. 146):
+        #   1. Negate: GREIT outputs Δσ (conductivity); Dräger uses impedance
+        #      convention (air in → impedance up → positive peak).
+        #   2. rot90(k=1): electrode 1 is at 12 o'clock on the PulmoVista belt
+        #      (anterior/ventral); pyEIT places electrode 0 at 3 o'clock.
+        #      90° CCW rotation moves anterior to the top of the image.
+        #   3. fliplr: Dräger displays caudal-cranial (CT convention viewed from
+        #      feet): left side of image = right side of patient.  pyEIT produces
+        #      the mirror image; fliplr corrects this.
+        images[i] = np.fliplr(np.rot90(-ds.reshape(n, n), k=1))
+
+    return images
diff --git a/tests/models/__init__.py b/tests/models/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/tests/test_base_data.py b/tests/models/test_base_data.py
similarity index 100%
rename from tests/test_base_data.py
rename to tests/models/test_base_data.py
diff --git a/tests/test_reconstructed_data.py b/tests/models/test_reconstructed_data.py
similarity index 100%
rename from tests/test_reconstructed_data.py
rename to tests/models/test_reconstructed_data.py
diff --git a/tests/parsers/__init__.py b/tests/parsers/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/tests/parsers/draeger/__init__.py b/tests/parsers/draeger/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/tests/test_bin_parser.py b/tests/parsers/draeger/test_bin_parser.py
similarity index 100%
rename from tests/test_bin_parser.py
rename to tests/parsers/draeger/test_bin_parser.py
diff --git a/tests/test_bin_utils.py b/tests/parsers/draeger/test_bin_utils.py
similarity index 100%
rename from tests/test_bin_utils.py
rename to tests/parsers/draeger/test_bin_utils.py
diff --git a/tests/test_draeger_asc_parser.py b/tests/parsers/draeger/test_draeger_asc_parser.py
similarity index 100%
rename from tests/test_draeger_asc_parser.py
rename to tests/parsers/draeger/test_draeger_asc_parser.py
diff --git a/tests/test_draeger_bin_dtypes.py b/tests/parsers/draeger/test_draeger_bin_dtypes.py
similarity index 100%
rename from tests/test_draeger_bin_dtypes.py
rename to tests/parsers/draeger/test_draeger_bin_dtypes.py
diff --git a/tests/parsers/draeger/test_eit_dtypes.py b/tests/parsers/draeger/test_eit_dtypes.py
new file mode 100644
index 0000000..62acb56
--- /dev/null
+++ b/tests/parsers/draeger/test_eit_dtypes.py
@@ -0,0 +1,97 @@
+"""Tests for FRAME_EIT_DTYPE layout and field offsets."""
+
+import numpy as np
+
+from fasteit.parsers.draeger.eit.eit_dtypes import (
+    FRAME_EIT_DTYPE,
+    PREAMBLE_DTYPE,
+    PREAMBLE_N_FIELDS,
+)
+
+# ── itemsize ──────────────────────────────────────────────────────────────────
+
+
+def test_frame_eit_itemsize():
+    assert FRAME_EIT_DTYPE.itemsize == 5495
+
+
+def test_preamble_dtype_is_int32_le():
+    assert PREAMBLE_DTYPE == np.dtype("<i4")
+
+
+def test_preamble_n_fields():
+    assert PREAMBLE_N_FIELDS == 3
+
+
+# ── field types and shapes ────────────────────────────────────────────────────
+
+
+def test_timestamp_is_float64():
+    assert FRAME_EIT_DTYPE["timestamp"].base == np.dtype("<f8")
+
+
+def test_trans_a_shape():
+    assert FRAME_EIT_DTYPE["trans_A"].shape == (208,)
+    assert FRAME_EIT_DTYPE["trans_A"].base == np.dtype("<f8")
+
+
+def test_trans_b_shape():
+    assert FRAME_EIT_DTYPE["trans_B"].shape == (208,)
+    assert FRAME_EIT_DTYPE["trans_B"].base == np.dtype("<f8")
+
+
+def test_injection_current_shape():
+    assert FRAME_EIT_DTYPE["injection_current"].shape == (16,)
+
+
+def test_voltage_a_shape():
+    assert FRAME_EIT_DTYPE["voltage_A"].shape == (16,)
+
+
+def test_voltage_b_shape():
+    assert FRAME_EIT_DTYPE["voltage_B"].shape == (16,)
+
+
+def test_medibus_shape():
+    assert FRAME_EIT_DTYPE["medibus"].shape == (67,)
+    assert FRAME_EIT_DTYPE["medibus"].base == np.dtype("<f4")
+
+
+def test_frame_counter_is_uint16():
+    assert FRAME_EIT_DTYPE["frame_counter"].base == np.dtype("<u2")
+
+
+def test_event_text_length():
+    assert FRAME_EIT_DTYPE["event_text"].itemsize == 30
+
+
+# ── field offsets (documented in eit_dtypes.py module docstring) ──────────────
+
+
+def test_trans_a_offset():
+    """trans_A starts at byte 16: timestamp(8) + unknown_f8(8)."""
+    assert FRAME_EIT_DTYPE.fields["trans_A"][1] == 16
+
+
+def test_trans_b_offset():
+    """trans_B starts at byte 2592 per reverse-engineering."""
+    assert FRAME_EIT_DTYPE.fields["trans_B"][1] == 2592
+
+
+# ── round-trip with frombuffer ────────────────────────────────────────────────
+
+
+def test_frombuffer_single_frame():
+    buf = bytes(5495)
+    arr = np.frombuffer(buf, dtype=FRAME_EIT_DTYPE)
+    assert arr.shape == (1,)
+    assert arr["trans_A"].shape == (1, 208)
+    assert arr["trans_B"].shape == (1, 208)
+    assert arr["medibus"].shape == (1, 67)
+
+
+def test_frombuffer_multi_frame():
+    n = 5
+    buf = bytes(5495 * n)
+    arr = np.frombuffer(buf, dtype=FRAME_EIT_DTYPE)
+    assert arr.shape == (n,)
diff --git a/tests/parsers/draeger/test_eit_parser.py b/tests/parsers/draeger/test_eit_parser.py
new file mode 100644
index 0000000..7ab37e9
--- /dev/null
+++ b/tests/parsers/draeger/test_eit_parser.py
@@ -0,0 +1,313 @@
+"""Tests for DragerEitParser using synthetic and real .eit files."""
+
+import struct
+import warnings
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+from fasteit.models.raw_impedance_data import RawImpedanceData
+from fasteit.parsers.draeger.eit.eit_dtypes import FRAME_EIT_DTYPE
+from fasteit.parsers.draeger.eit.eit_parser import DragerEitParser
+from fasteit.parsers.draeger.eit.eit_utils import FT_A, FT_B, SEPARATOR
+
+# ── real test files (skipped on CI if absent) ─────────────────────────────────
+
+_EIT_REAL = (
+    Path(__file__).parent.parent.parent.parent / "src/fasteit/test_files/patient01.eit"
+)
+_real = pytest.mark.skipif(
+    not _EIT_REAL.exists(), reason="real .eit file not available"
+)
+
+
+# ── synthetic .eit file builder ───────────────────────────────────────────────
+
+
+def _write_eit(
+    tmp_path: Path,
+    n_frames: int = 5,
+    fs: float = 50.0,
+    trans_A_val: float = 1.0,
+    trans_B_val: float = 0.5,
+    magic: str = "Draeger EIT-Software",
+) -> Path:
+    """Write a minimal synthetic Dräger .eit file with known frame values."""
+    header_lines = [
+        magic,
+        f"Framerate [Hz]: {fs}",
+        "Date: 01.01.2024",
+        "Time: 12:00:00",
+        "Gain: 65",
+        "Frequency [kHz]: 101.5",
+    ]
+    header_text = "\r\n".join(header_lines) + "\r\n"
+    header_bytes = header_text.encode("latin-1")
+
+    preamble_size = 3 * 4
+    sep_offset = preamble_size + len(header_bytes)
+    preamble = struct.pack("<iii", 51, sep_offset, 0)
+
+    frames = np.zeros(n_frames, dtype=FRAME_EIT_DTYPE)
+    dt_day = 1.0 / (fs * 86400.0)
+    frames["timestamp"] = np.arange(n_frames) * dt_day
+    frames["trans_A"] = trans_A_val
+    frames["trans_B"] = trans_B_val
+    frames["frame_counter"] = np.arange(n_frames, dtype=np.uint16)
+
+    path = tmp_path / "synthetic.eit"
+    with path.open("wb") as f:
+        f.write(preamble)
+        f.write(header_bytes)
+        f.write(SEPARATOR)
+        frames.tofile(f)
+    return path
+
+
+# ── validate() ────────────────────────────────────────────────────────────────
+
+
+def test_validate_true_for_synthetic(tmp_path):
+    p = _write_eit(tmp_path)
+    assert DragerEitParser().validate(p)
+
+
+def test_validate_false_for_missing_file(tmp_path):
+    assert not DragerEitParser().validate(tmp_path / "ghost.eit")
+
+
+def test_validate_false_for_no_magic_string(tmp_path):
+    p = _write_eit(tmp_path, magic="SomeOtherVendor EIT")
+    assert not DragerEitParser().validate(p)
+
+
+def test_validate_false_for_too_small_file(tmp_path):
+    p = tmp_path / "tiny.eit"
+    p.write_bytes(b"\x00" * 4)
+    assert not DragerEitParser().validate(p)
+
+
+# ── parse() — return type and structure ──────────────────────────────────────
+
+
+def test_parse_returns_raw_impedance_data(tmp_path):
+    p = _write_eit(tmp_path)
+    data = DragerEitParser().parse(p)
+    assert isinstance(data, RawImpedanceData)
+
+
+def test_parse_measurements_shape(tmp_path):
+    p = _write_eit(tmp_path, n_frames=10)
+    data = DragerEitParser().parse(p)
+    assert data.measurements.shape == (10, 208)
+
+
+def test_parse_fs_from_header(tmp_path):
+    p = _write_eit(tmp_path, fs=25.0)
+    data = DragerEitParser().parse(p)
+    assert data.fs == pytest.approx(25.0)
+
+
+def test_parse_vendor_is_draeger(tmp_path):
+    p = _write_eit(tmp_path)
+    data = DragerEitParser().parse(p)
+    assert data.vendor == "draeger"
+
+
+def test_parse_file_format_is_eit(tmp_path):
+    p = _write_eit(tmp_path)
+    data = DragerEitParser().parse(p)
+    assert data.file_format == "eit"
+
+
+# ── parse() — metadata ────────────────────────────────────────────────────────
+
+
+def test_parse_metadata_n_frames(tmp_path):
+    p = _write_eit(tmp_path, n_frames=7)
+    data = DragerEitParser().parse(p)
+    assert data.metadata["n_frames"] == 7
+
+
+def test_parse_metadata_n_electrodes(tmp_path):
+    p = _write_eit(tmp_path)
+    data = DragerEitParser().parse(p)
+    assert data.metadata["n_electrodes"] == 16
+
+
+def test_parse_metadata_n_measurements(tmp_path):
+    p = _write_eit(tmp_path)
+    data = DragerEitParser().parse(p)
+    assert data.metadata["n_measurements"] == 208
+
+
+def test_parse_metadata_date(tmp_path):
+    p = _write_eit(tmp_path)
+    data = DragerEitParser().parse(p)
+    assert data.metadata["date"] == "01.01.2024"
+
+
+# ── parse() — calibration vv = FT_A*trans_A - FT_B*trans_B ──────────────────
+
+
+def test_parse_measurements_calibration(tmp_path):
+    """vv must equal FT_A*trans_A - FT_B*trans_B."""
+    p = _write_eit(tmp_path, trans_A_val=2.0, trans_B_val=1.0)
+    data = DragerEitParser().parse(p)
+    expected = FT_A * 2.0 - FT_B * 1.0
+    assert np.allclose(data.measurements, expected)
+
+
+def test_parse_measurements_no_nan(tmp_path):
+    p = _write_eit(tmp_path)
+    assert not np.isnan(DragerEitParser().parse(p).measurements).any()
+
+
+def test_parse_measurements_not_all_zero(tmp_path):
+    p = _write_eit(tmp_path, trans_A_val=1.0, trans_B_val=0.0)
+    data = DragerEitParser().parse(p)
+    assert not np.all(data.measurements == 0)
+
+
+# ── parse() — aux_signals ─────────────────────────────────────────────────────
+
+
+def test_parse_aux_signals_keys(tmp_path):
+    p = _write_eit(tmp_path)
+    data = DragerEitParser().parse(p)
+    expected_keys = {
+        "timestamp",
+        "trans_A",
+        "trans_B",
+        "injection_current",
+        "I_real",
+        "voltage_A",
+        "voltage_B",
+        "V_diff",
+        "frame_counter",
+        "medibus",
+    }
+    assert expected_keys.issubset(set(data.aux_signals.keys()))
+
+
+def test_parse_aux_signals_timestamp_monotonic(tmp_path):
+    p = _write_eit(tmp_path, n_frames=10)
+    data = DragerEitParser().parse(p)
+    ts = data.aux_signals["timestamp"]
+    assert np.all(np.diff(ts) >= 0)
+
+
+def test_parse_aux_signals_frame_counter(tmp_path):
+    p = _write_eit(tmp_path, n_frames=5)
+    data = DragerEitParser().parse(p)
+    fc = data.aux_signals["frame_counter"]
+    assert fc.shape == (5,)
+    np.testing.assert_array_equal(fc, np.arange(5, dtype=np.uint16))
+
+
+def test_parse_aux_signals_trans_a_raw(tmp_path):
+    """trans_A in aux_signals must be the raw values, not vv."""
+    p = _write_eit(tmp_path, trans_A_val=3.0)
+    data = DragerEitParser().parse(p)
+    assert np.allclose(data.aux_signals["trans_A"], 3.0)
+
+
+def test_parse_aux_signals_i_real_shape(tmp_path):
+    p = _write_eit(tmp_path, n_frames=5)
+    data = DragerEitParser().parse(p)
+    assert data.aux_signals["I_real"].shape == (5, 16)
+
+
+def test_parse_aux_signals_medibus_shape(tmp_path):
+    p = _write_eit(tmp_path, n_frames=5)
+    data = DragerEitParser().parse(p)
+    assert data.aux_signals["medibus"].shape == (5, 67)
+
+
+# ── parse() — fs fallback warning ─────────────────────────────────────────────
+
+
+def test_parse_warns_if_framerate_missing(tmp_path):
+    """If Framerate [Hz] is absent from header, a UserWarning must be raised."""
+    header_lines = ["Draeger EIT-Software", "Date: 01.01.2024"]
+    header_text = "\r\n".join(header_lines) + "\r\n"
+    header_bytes = header_text.encode("latin-1")
+    sep_offset = 12 + len(header_bytes)
+    preamble = struct.pack("<iii", 51, sep_offset, 0)
+
+    frames = np.zeros(3, dtype=FRAME_EIT_DTYPE)
+    frames["timestamp"] = np.arange(3) * (1.0 / (50.0 * 86400.0))
+
+    p = tmp_path / "no_framerate.eit"
+    with p.open("wb") as f:
+        f.write(preamble)
+        f.write(header_bytes)
+        f.write(SEPARATOR)
+        frames.tofile(f)
+
+    with warnings.catch_warnings(record=True) as caught:
+        warnings.simplefilter("always")
+        data = DragerEitParser().parse(p)
+
+    assert any(issubclass(w.category, UserWarning) for w in caught)
+    assert data.fs == pytest.approx(50.0)
+
+
+# ── parse() — error cases ─────────────────────────────────────────────────────
+
+
+def test_parse_raises_for_too_small_file(tmp_path):
+    p = tmp_path / "tiny.eit"
+    p.write_bytes(b"\x00" * 4)
+    with pytest.raises(ValueError):
+        DragerEitParser().parse(p)
+
+
+def test_parse_raises_for_truncated_binary(tmp_path):
+    """Binary section not divisible by frame size must raise ValueError."""
+    p = _write_eit(tmp_path, n_frames=3)
+    data = p.read_bytes()
+    p.write_bytes(data[:-100])  # truncate last 100 bytes
+    with pytest.raises(ValueError, match="frame size"):
+        DragerEitParser().parse(p)
+
+
+# ── real file tests (skipped if file absent) ──────────────────────────────────
+
+
+@_real
+def test_real_parse_shape():
+    data = DragerEitParser().parse(_EIT_REAL)
+    n, m = data.measurements.shape
+    assert n > 0
+    assert m == 208
+
+
+@_real
+def test_real_fs_is_50():
+    data = DragerEitParser().parse(_EIT_REAL)
+    assert data.fs == pytest.approx(50.0)
+
+
+@_real
+def test_real_measurements_no_nan():
+    data = DragerEitParser().parse(_EIT_REAL)
+    assert not np.isnan(data.measurements).any()
+
+
+@_real
+def test_real_timestamps_monotonic():
+    data = DragerEitParser().parse(_EIT_REAL)
+    ts = data.aux_signals["timestamp"]
+    assert np.all(np.diff(ts) >= 0)
+
+
+@_real
+def test_real_n_frames_coherent_with_duration():
+    """n_frames / fs must match timestamp duration within 1 second."""
+    data = DragerEitParser().parse(_EIT_REAL)
+    ts = data.aux_signals["timestamp"]
+    duration_ts = (ts[-1] - ts[0]) * 86400.0  # fraction-of-day → seconds
+    duration_frames = data.metadata["n_frames"] / data.fs
+    assert abs(duration_ts - duration_frames) < 1.0
diff --git a/tests/parsers/draeger/test_eit_utils.py b/tests/parsers/draeger/test_eit_utils.py
new file mode 100644
index 0000000..191a3f3
--- /dev/null
+++ b/tests/parsers/draeger/test_eit_utils.py
@@ -0,0 +1,188 @@
+"""Tests for parse_eit_header() and HEADER_FIELD_MAP."""
+
+import struct
+
+import pytest
+
+from fasteit.parsers.draeger.eit.eit_utils import (
+    FC_CURRENT,
+    FT_A,
+    FT_B,
+    FV_VOLTAGE,
+    HEADER_FIELD_MAP,
+    SEPARATOR,
+    parse_eit_header,
+)
+
+# ── helpers ───────────────────────────────────────────────────────────────────
+
+
+def _make_raw_header(fields: dict[str, str] | None = None) -> bytes:
+    """Build a minimal synthetic .eit header buffer.
+
+    Preamble: format_version=51, sep_offset=<computed>, unknown=0
+    ASCII header: key: value\\r\\n lines (latin-1)
+    Separator: b'**\\r\\n\\r\\n\\r\\n'
+    """
+    lines = []
+    if fields:
+        for k, v in fields.items():
+            lines.append(f"{k}: {v}")
+    header_text = "\r\n".join(lines) + "\r\n" if lines else "\r\n"
+    header_bytes = header_text.encode("latin-1")
+
+    preamble_size = 3 * 4  # 3 × int32 = 12 bytes
+    sep_offset = preamble_size + len(header_bytes)
+
+    preamble = struct.pack("<iii", 51, sep_offset, 0)
+    return preamble + header_bytes + SEPARATOR
+
+
+# ── SEPARATOR constant ────────────────────────────────────────────────────────
+
+
+def test_separator_value():
+    assert SEPARATOR == b"**\r\n\r\n\r\n"
+
+
+def test_separator_length():
+    assert len(SEPARATOR) == 8
+
+
+# ── calibration constants ─────────────────────────────────────────────────────
+
+
+def test_ft_a_value():
+    assert FT_A == pytest.approx(0.00098242)
+
+
+def test_ft_b_value():
+    assert FT_B == pytest.approx(0.00019607)
+
+
+def test_fc_current_value():
+    assert FC_CURRENT == pytest.approx(194326.3536)
+
+
+def test_fv_voltage_value():
+    assert FV_VOLTAGE == pytest.approx(0.11771)
+
+
+# ── HEADER_FIELD_MAP keys ─────────────────────────────────────────────────────
+
+
+def test_framerate_key_in_field_map():
+    assert "Framerate [Hz]" in HEADER_FIELD_MAP
+
+
+def test_frequency_key_in_field_map():
+    assert "Frequency [kHz]" in HEADER_FIELD_MAP
+
+
+def test_no_calibration_factor_key():
+    """Calibration Factor is not in the header — hardcoded from EIDORS."""
+    assert "Calibration Factor" not in HEADER_FIELD_MAP
+
+
+# ── parse_eit_header() — valid input ─────────────────────────────────────────
+
+
+def test_parse_returns_dict_and_int():
+    raw = _make_raw_header({"Framerate [Hz]": "50.0"})
+    meta, binary_start = parse_eit_header(raw)
+    assert isinstance(meta, dict)
+    assert isinstance(binary_start, int)
+
+
+def test_parse_binary_start_after_separator():
+    raw = _make_raw_header()
+    _, binary_start = parse_eit_header(raw)
+    assert binary_start == len(raw)
+
+
+def test_parse_fs_from_framerate_field():
+    raw = _make_raw_header({"Framerate [Hz]": "25.6"})
+    meta, _ = parse_eit_header(raw)
+    assert meta["fs"] == pytest.approx(25.6)
+
+
+def test_parse_fs_is_float():
+    raw = _make_raw_header({"Framerate [Hz]": "50"})
+    meta, _ = parse_eit_header(raw)
+    assert isinstance(meta["fs"], float)
+
+
+def test_parse_date_and_time():
+    raw = _make_raw_header({"Date": "01.01.2024", "Time": "14:30:00"})
+    meta, _ = parse_eit_header(raw)
+    assert meta["date"] == "01.01.2024"
+    assert meta["time"] == "14:30:00"
+
+
+def test_parse_time_with_colon_in_value():
+    """Time field contains colons — partition(':') must use first colon only."""
+    raw = _make_raw_header({"Time": "14:30:00.123"})
+    meta, _ = parse_eit_header(raw)
+    assert meta["time"] == "14:30:00.123"
+
+
+def test_parse_gain_as_int():
+    raw = _make_raw_header({"Gain": "65"})
+    meta, _ = parse_eit_header(raw)
+    assert meta["gain"] == 65
+    assert isinstance(meta["gain"], int)
+
+
+def test_parse_frequency_khz():
+    raw = _make_raw_header({"Frequency [kHz]": "101.5"})
+    meta, _ = parse_eit_header(raw)
+    assert meta["frequency_khz"] == pytest.approx(101.5)
+
+
+def test_parse_format_version_in_metadata():
+    raw = _make_raw_header()
+    meta, _ = parse_eit_header(raw)
+    assert meta["format_version"] == 51
+
+
+def test_parse_binary_start_in_metadata():
+    raw = _make_raw_header()
+    meta, binary_start = parse_eit_header(raw)
+    assert meta["binary_start"] == binary_start
+
+
+def test_parse_raw_fields_present():
+    raw = _make_raw_header({"Date": "01.01.2024", "Gain": "65"})
+    meta, _ = parse_eit_header(raw)
+    assert "_raw_fields" in meta
+    assert meta["_raw_fields"]["Date"] == "01.01.2024"
+    assert meta["_raw_fields"]["Gain"] == "65"
+
+
+def test_parse_unknown_fields_kept_in_raw_fields():
+    raw = _make_raw_header({"SomeUnknownField": "value123"})
+    meta, _ = parse_eit_header(raw)
+    assert "SomeUnknownField" in meta["_raw_fields"]
+    assert "SomeUnknownField" not in meta  # not promoted to structured key
+
+
+def test_parse_conversion_failure_keeps_string():
+    """If a numeric field has a non-numeric value, it stays as string."""
+    raw = _make_raw_header({"Gain": "not_a_number"})
+    meta, _ = parse_eit_header(raw)
+    assert meta["gain"] == "not_a_number"
+
+
+# ── parse_eit_header() — error cases ─────────────────────────────────────────
+
+
+def test_parse_raises_if_buffer_too_small():
+    with pytest.raises(ValueError, match="too small"):
+        parse_eit_header(b"\x00" * 4)
+
+
+def test_parse_raises_if_sep_offset_out_of_range():
+    # sep_offset points beyond the buffer
+    bad_preamble = struct.pack("<iii", 51, 9999, 0)
+    with pytest.raises(ValueError, match="sep_offset"):
+        parse_eit_header(bad_preamble + b"\x00" * 20)
diff --git a/tests/test_base_parser.py b/tests/parsers/test_base_parser.py
similarity index 100%
rename from tests/test_base_parser.py
rename to tests/parsers/test_base_parser.py
diff --git a/tests/parsers/test_header_formats.py b/tests/parsers/test_header_formats.py
new file mode 100644
index 0000000..06fbddd
--- /dev/null
+++ b/tests/parsers/test_header_formats.py
@@ -0,0 +1,83 @@
+"""Tests for HeaderFormatSpec registry and get_eit_specs()."""
+
+import pytest
+
+from fasteit.parsers.header_formats import (
+    DRAEGER_EIT_HEADER_SPEC,
+    HEADER_FORMAT_SPECS,
+    HeaderFormatSpec,
+    get_eit_specs,
+)
+
+# ── Registry contents ─────────────────────────────────────────────────────────
+
+
+def test_draeger_spec_in_registry():
+    assert DRAEGER_EIT_HEADER_SPEC in HEADER_FORMAT_SPECS
+
+
+def test_registry_is_nonempty():
+    assert len(HEADER_FORMAT_SPECS) >= 1
+
+
+def test_all_entries_are_header_format_spec():
+    for spec in HEADER_FORMAT_SPECS:
+        assert isinstance(spec, HeaderFormatSpec)
+
+
+# ── DRAEGER_EIT_HEADER_SPEC field values ──────────────────────────────────────
+
+
+def test_draeger_spec_vendor():
+    assert DRAEGER_EIT_HEADER_SPEC.vendor == "draeger"
+
+
+def test_draeger_spec_frame_size():
+    assert DRAEGER_EIT_HEADER_SPEC.frame_size_bytes == 5495
+
+
+def test_draeger_spec_n_electrodes():
+    assert DRAEGER_EIT_HEADER_SPEC.n_electrodes == 16
+
+
+def test_draeger_spec_n_measurements():
+    assert DRAEGER_EIT_HEADER_SPEC.n_measurements == 208
+
+
+def test_draeger_spec_magic_string_present():
+    assert len(DRAEGER_EIT_HEADER_SPEC.magic_string) > 0
+
+
+def test_draeger_spec_is_frozen():
+    with pytest.raises((AttributeError, TypeError)):
+        DRAEGER_EIT_HEADER_SPEC.vendor = "other"  # type: ignore[misc]
+
+
+# ── get_eit_specs() ───────────────────────────────────────────────────────────
+
+
+def test_get_eit_specs_draeger_returns_list():
+    result = get_eit_specs("draeger")
+    assert isinstance(result, list)
+    assert len(result) >= 1
+
+
+def test_get_eit_specs_draeger_contains_known_spec():
+    result = get_eit_specs("draeger")
+    assert DRAEGER_EIT_HEADER_SPEC in result
+
+
+def test_get_eit_specs_unknown_vendor_raises():
+    with pytest.raises(ValueError, match="No HeaderFormatSpec registered"):
+        get_eit_specs("unknown_vendor_xyz")
+
+
+def test_get_eit_specs_all_draeger_results_have_correct_vendor():
+    for spec in get_eit_specs("draeger"):
+        assert spec.vendor == "draeger"
+
+
+def test_n_measurements_equals_16_times_13():
+    """208 = 16 injections × 13 adjacent measurements (adjacent drive)."""
+    spec = get_eit_specs("draeger")[0]
+    assert spec.n_measurements == spec.n_electrodes * 13
diff --git a/tests/test_parser_routing.py b/tests/parsers/test_parser_routing.py
similarity index 100%
rename from tests/test_parser_routing.py
rename to tests/parsers/test_parser_routing.py
diff --git a/tests/parsers/timpel/__init__.py b/tests/parsers/timpel/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/tests/test_timpel_dtypes.py b/tests/parsers/timpel/test_timpel_dtypes.py
similarity index 100%
rename from tests/test_timpel_dtypes.py
rename to tests/parsers/timpel/test_timpel_dtypes.py
diff --git a/tests/test_timpel_parser.py b/tests/parsers/timpel/test_timpel_parser.py
similarity index 100%
rename from tests/test_timpel_parser.py
rename to tests/parsers/timpel/test_timpel_parser.py