README.md

---
license: cc-by-4.0
language:
  - en
pretty_name: Industrial Storage Container Dimensions
size_categories:
  - n<1K
tags:
  - logistics
  - supply-chain
  - warehousing
  - packaging
  - reference
  - tabular
configs:
  - config_name: default
    data_files: containers.csv
  - config_name: listings
    data_files: listings.csv
dataset_info:
  - config_name: default
    features:
      - name: id
        dtype: string
      - name: type
        dtype: string
      - name: type_label
        dtype: string
      - name: common_names
        dtype: string
      - name: external_length_cm
        dtype: float64
      - name: external_width_cm
        dtype: float64
      - name: external_height_cm
        dtype: float64
      - name: external_length_in
        dtype: float64
      - name: external_width_in
        dtype: float64
      - name: external_height_in
        dtype: float64
      - name: external_volume_l
        dtype: float64
      - name: external_volume_gal
        dtype: float64
      - name: internal_length_cm
        dtype: float64
      - name: internal_width_cm
        dtype: float64
      - name: internal_height_cm
        dtype: float64
      - name: internal_length_in
        dtype: float64
      - name: internal_width_in
        dtype: float64
      - name: internal_height_in
        dtype: float64
      - name: internal_dims_basis
        dtype: string
      - name: internal_dims_vendors
        dtype: int64
      - name: typical_capacity_l
        dtype: float64
      - name: typical_capacity_gal
        dtype: float64
      - name: vendor_capacity_low_l
        dtype: float64
      - name: vendor_capacity_high_l
        dtype: float64
      - name: usable_ratio
        dtype: float64
      - name: capacity_basis
        dtype: string
      - name: lidded
        dtype: bool
      - name: lid_available_separately
        dtype: bool
      - name: nestable_when_empty
        dtype: bool
      - name: typical_nesting_ratio
        dtype: float64
      - name: standard_conformant
        dtype: bool
      - name: standard
        dtype: string
      - name: vda_4500_height
        dtype: bool
      - name: eur1_pallet_per_layer
        dtype: int64
      - name: listings_observed
        dtype: int64
      - name: notes
        dtype: string
    splits:
      - name: train
        num_examples: 48
  - config_name: listings
    features:
      - name: listing_id
        dtype: string
      - name: vendor
        dtype: string
      - name: vendor_country
        dtype: string
      - name: product_name
        dtype: string
      - name: sku
        dtype: string
      - name: url
        dtype: string
      - name: type
        dtype: string
      - name: native_unit
        dtype: string
      - name: external_length_cm
        dtype: float64
      - name: external_width_cm
        dtype: float64
      - name: external_height_cm
        dtype: float64
      - name: external_length_in
        dtype: float64
      - name: external_width_in
        dtype: float64
      - name: external_height_in
        dtype: float64
      - name: internal_length_cm
        dtype: float64
      - name: internal_width_cm
        dtype: float64
      - name: internal_height_cm
        dtype: float64
      - name: internal_length_in
        dtype: float64
      - name: internal_width_in
        dtype: float64
      - name: internal_height_in
        dtype: float64
      - name: stated_capacity_l
        dtype: float64
      - name: stated_capacity_gal
        dtype: float64
      - name: external_volume_l
        dtype: float64
      - name: external_volume_gal
        dtype: float64
      - name: usable_ratio
        dtype: float64
      - name: price
        dtype: float64
      - name: currency
        dtype: string
      - name: price_includes_vat
        dtype: bool
      - name: pack_quantity
        dtype: int64
      - name: unit_price
        dtype: float64
      - name: captured_date
        dtype: string
      - name: notes
        dtype: string
    splits:
      - name: train
        num_examples: 121
---

# Industrial Storage Container Dimensions

Planning-grade volumetric reference for the plastic containers that European and
North American warehouses actually run on: **Euroboxes** (Euro stacking containers),
**attached-lid containers (ALCs)**, and **VDA 4500 KLTs**.

Two tables:

| Config | Rows | What it is |
|---|---|---|
| `default` → `containers.csv` | 48 | One **typical** row per nominal size. External and internal dimensions, usable capacity, the spread of what vendors publish, lid and nesting behaviour, standards conformance |
| `listings` → `listings.csv` | 121 | The **individual vendor listings** the typical figures were generalised from. Real SKUs, real prices, the date each was captured |

```python
from datasets import load_dataset

typical  = load_dataset("danielrosehill/storage-container-dimensions", split="train")
listings = load_dataset("danielrosehill/storage-container-dimensions", "listings", split="train")
```

Two documents come with it, both generated from the CSVs so neither can drift:

| | |
|---|---|
| **[`datasheet/storage-container-dimensions-datasheet-v1.0.pdf`](datasheet/storage-container-dimensions-datasheet-v1.0.pdf)** | The **datasheet**, v1.0 — scope, composition, how every number was derived, known limitations, provenance, and the full data dictionary. Read this before using the data in anything that matters. |
| **[`docs/data-dictionary.md`](docs/data-dictionary.md)** · **[`data-dictionary.csv`](data-dictionary.csv)** | Every column in both tables with its type, unit and meaning — as a document and machine-readable. |

Prefer the sizes themselves on paper? The same data is rendered as an 8-page printable reference —
every size, its typical internal dimensions, its usable capacity and the vendor
spread, divided by family:
**[`reference/storage-container-reference.pdf`](reference/storage-container-reference.pdf)**.

The second table is there so you can audit the first. Every typical capacity is a
judgement call about a spread of real products; `listings.csv` is that spread, with
URLs and capture dates, so you can disagree with a number and see exactly what it
was averaged from.

Every dimension appears in **both centimetres and inches**, and every capacity in
**litres and US gallons** — the comparison this dataset exists for is cross-market, and
one of the four vendors here designs in inches. Which side is the vendor's own figure
and which is derived is recorded per listing in `native_unit`.

## Scope

**This dataset stops at the unit.** It describes the smallest standardised unit of
industrial storage — the tote — and nothing above it.

| In scope | Out of scope |
|---|---|
| External and internal dimensions, both unit systems | Pallet builds and load patterns |
| External volume and usable capacity | Container loads, TEU utilisation, stowage |
| Nesting and stacking behaviour | Shelving and racking layouts |
| Lid arrangement, standards conformance | Live pricing, availability, lead times |
| What the trade calls each family, per geography | Any one manufacturer's exact spec |

The one deliberate exception is `eur1_pallet_per_layer`, a convenience column giving
the footprint count on a 1200 × 800 deck. It is the last thing that is purely a
property of the box; anything past it depends on build height, pallet standard and
container choice, which are decisions rather than dimensions.

Prices in `listings.csv` are **captured observations with a date on them**, kept so a
capacity figure can be audited against what was really on sale. They are not a price
feed and will rot.

## What it is for

The point of a dimensional dataset is that the calculations downstream of it are
somebody else's. In practice these are:

- **Pallet load calculation** — how many units per layer and per pallet, and the
  build height that follows. The footprints tile a 1200 × 800 and a 1200 × 1000 deck
  exactly, which is the whole reason the module exists.
- **Shelving and racking calculation** — industrial racking, business storeroom or
  domestic shelf: how many boxes per bay, and which height variant uses a given shelf
  pitch without wasting the gap above it.
- **Consolidation and move planning** — how much of a shelf, room or shipment a given
  box count becomes, and how much less it becomes if the boxes nest.
- **Purchase comparison** — ranking products on cost per *usable* litre rather than on
  the nominal size printed on the listing.

## The point of it

If you are costing out a purchase or sizing a shipment, you need to know that a
60 × 40 × 23 cm Eurobox gives you about **42 litres**, not the 55.2 litres that
60 × 40 × 23 implies. Multiply external dimensions and you will overstate what you
are buying by roughly a quarter — and you will overstate a tapered ALC by more than
a straight-walled Eurobox, which quietly corrupts any comparison between the two.

That gap is the whole reason this dataset exists.

## Read this before using the numbers

**The footprint is standardised. The heights mostly are not. The insides are not at
all.**

ISO 3394 fixes the 600 × 400 mm module and its submultiples, which is why the metric
range tiles a Euro pallet exactly. Heights are a different matter: of the 18 distinct
600 × 400 heights in `containers.csv`, exactly **one** — 280 mm — is fixed by a
standard (VDA 4500). The rest are convention, and manufacturers ship one-off variants
inside it. Attached-lid heights are vendor convention throughout, to the point where
the same 80 L box is listed at both 400 and 420 mm.

**US vendors design in inches, and some of their totes land near the 600 × 400 module
without hitting it.** Hudson Exchange's 24 × 15 in "straight wall stacking tote" is
61.0 × 38.1 cm — one centimetre too long to put four on a Euro pallet, so the pattern
collapses to two. Full table of the near misses, and what `native_unit` is for:
**[`guidance/units-and-us-vendors.md`](guidance/units-and-us-vendors.md)**.

**The standards fix external dimensions. They do not fix internal ones.**

ISO 3394 defines the 600 × 400 mm packaging module. EN 13199 caps a small load
carrier at that footprint. VDA 4500 additionally fixes three external heights
(147.5, 213, 280 mm). None of them specifies wall thickness, draft angle, rib
design or base construction — those are the manufacturer's choice, and they are what
determine internal volume.

So every internal dimension and capacity here is a **typical figure averaged across
vendor catalogues**, not a specification. Ten vendors will give you ten different
numbers for the same nominal size, and the spread is not small: across the four
catalogues captured here, a 60 × 40 × 32 cm Eurobox is quoted internally at anything
from 60.4 to 66.4 litres. That is an 11 % range on a box every one of them calls
600 × 400 × 320. `vendor_capacity_low_l` and `vendor_capacity_high_l` give you the
range on every row rather than hiding it behind a single figure.

That is a limitation of the product category, not of this dataset. Chasing
manufacturer-exact figures is not achievable in a general reference, and would be
obsolete the moment a mould changed. **Use these for calculation, comparison and
planning. Check the specific supplier's own internal dimensions before committing to
a large order.**

## Fields

| Field | Type | Notes |
|---|---|---|
| `id` | string | Stable slug, e.g. `euro-600x400x230`, `alc-600x400x310`, `vda-rklt-6429` |
| `type` | string | `euro_stacking_container` · `attached_lid_container` · `vda_klt_container` |
| `type_label` | string | Human-readable form of `type` |
| `common_names` | string | Semicolon-separated search terms, ordered most standard to most colloquial, including regional ones (`Eurobehälter`, `bac gerbable`) and genericised vendor names (`Hudson box`). Search terms only — never discriminate families on them, see `guidance/naming.md` |
| `external_length_cm` | float64 (cm) | External length |
| `external_width_cm` | float64 (cm) | External width |
| `external_height_cm` | float64 (cm) | External height |
| `external_length_in` | float64 (in) | External length in inches. Always the derived side on this table — these nominal sizes are fixed in millimetres by the standards |
| `external_width_in` | float64 (in) | External width in inches, derived |
| `external_height_in` | float64 (in) | External height in inches, derived |
| `external_volume_l` | float64 (L) | L × W × H. **Not** what the box holds |
| `external_volume_gal` | float64 (US gal) | External volume in US liquid gallons |
| `internal_length_cm` | float64 (cm) | Typical internal length. Populated for every Euro row and for the two KLT sizes a vendor publishes; empty for ALCs, whose taper makes a single internal dimension meaningless |
| `internal_width_cm` | float64 (cm) | Typical internal width, same basis |
| `internal_height_cm` | float64 (cm) | Typical internal height, same basis |
| `internal_length_in` | float64 (in) | Typical internal length in inches, derived |
| `internal_width_in` | float64 (in) | Typical internal width in inches, derived |
| `internal_height_in` | float64 (in) | Typical internal height in inches, derived |
| `internal_dims_basis` | string | Where those internal figures came from: `vendor_average_rule`, `vendor_published`, `not_published`, `not_published_tapered_walls` |
| `internal_dims_vendors` | int64 | How many **vendors** publish internal dimensions for this footprint. Vendors, not listings — one mould in five colours is one opinion |
| `typical_capacity_l` | float64 (L) | **The usable number.** Always populated |
| `typical_capacity_gal` | float64 (US gal) | Usable capacity in US liquid gallons |
| `vendor_capacity_low_l` | float64 (L) | Capacity implied by the least generous vendor's own published internal dimensions for this footprint. Empty where no vendor publishes any |
| `vendor_capacity_high_l` | float64 (L) | As above, most generous vendor. See `guidance/internal-dimensions.md` |
| `usable_ratio` | float64 | `typical_capacity_l / external_volume_l` |
| `capacity_basis` | string | How the capacity was arrived at: `derived_from_internal_dims`, `vendor_nominal`, `published`, `derived_from_klt_ratio` |
| `lidded` | bool | True where a lid is integral to the product (ALCs) |
| `lid_available_separately` | bool | True where a lid exists but is a separate purchase |
| `nestable_when_empty` | bool | True for ALCs; straight-walled boxes stack but do not nest |
| `typical_nesting_ratio` | float64 | Fraction of its own height a nested empty box saves. 0.75 for ALCs, **0 for everything else** — that is a fact about a straight-walled box, not missing data |
| `standard_conformant` | bool | Whether the footprint conforms to a recognised module |
| `standard` | string | Which one, stated precisely |
| `vda_4500_height` | bool | Whether the external height is on the VDA KLT grid (147.5 / 213 / 280 mm) |
| `eur1_pallet_per_layer` | int64 | Boxes per layer on a 1200 × 800 Euro pallet, no overhang. The one column that reaches past the box itself — see Scope |
| `listings_observed` | int64 | How many rows in the `listings` table back this size — 0 means the row is a plausible interpolation, not something seen for sale |
| `notes` | string | Per-row caveats. Read these |

### Height coverage

The Euro series carries the heights actually observed for sale across the
captured vendors, near-duplicates merged to the round figure (315 → 310 mm,
365/370 → 365 mm, 415/420 → 420 mm):

| Footprint | Heights (cm) |
|---|---|
| 60 × 40 | 12, 15, 17, 17.5, 20, 22, 23, 24, 27, 28, 30, 31, 32, 34, 36.5, 40, 42, 46.5 |
| 40 × 30 | 12, 15, 17, 20, 22, 23, 24, 27, 32 |
| 30 × 20 | 12, 15, 17, 22 |
| 80 × 60 | 22, 32, 42 |

Unlike the VDA grid, **no standard defines the consumer Euro height series** —
it is whatever manufacturers converged on, which is why it is irregular and why
"common" here means "seen on sale" rather than "specified". Check
`listings_observed` before treating any single row as a size you can definitely
buy; a handful (60 × 40 × 30 and × 46.5, 40 × 30 × 20 and × 24, most of the
30 × 20 range) are interpolations into gaps in the captured evidence.

### `capacity_basis` values

- **`derived_from_internal_dims`** — computed from the typical internal footprint
  for that module (600 × 400 boxes are internally ~550 × 355 mm, 400 × 300 are
  ~350 × 250 mm, 300 × 200 are ~260 × 160 mm, 800 × 600 are ~750 × 550 mm, with
  internal height 10–20 mm under external). These are the **conservative** end of
  what vendors publish, not the middle of it; `vendor_capacity_low_l` and
  `vendor_capacity_high_l` on the same row show what the market quotes.
- **`vendor_nominal`** — the manufacturer's published capacity. Used for all ALCs.
- **`published`** — a directly published internal figure (VDA R-KLT 6429).
- **`derived_from_klt_ratio`** — scaled from the 6429 anchor at its 71.4 % usable
  ratio. VDA KLTs are thicker-walled than consumer euroboxes, so the euro rule does
  not apply to them.

### Vendors disagree about the inside of the same box

By 11 % in litres, at 600 × 400. Salesbridges publishes 570 × 370 mm internal where
Plastic Box Shop publishes 555 × 355 and Yosibox 550 × 360 — the first is the top
opening, the others are close to the base, and a euro crate is slightly tapered, so
all three are honest. `vendor_capacity_low_l` and `vendor_capacity_high_l` carry that
spread on every row; `typical_capacity_l` sits at or just below the conservative end
on purpose, because a planning figure that overstates capacity fails silently.

The full evidence, per vendor and per footprint, is in
[`guidance/internal-dimensions.md`](guidance/internal-dimensions.md).

### Why ALC rows still have no internal dimensions

**ALCs taper.** The walls slope inward towards the base so the containers nest when
empty. A single internal L × W × H would be wrong wherever you chose to measure it —
right at the top opening, badly overstated at the base. Rather than invent a number,
those rows carry the vendor's nominal capacity, which already accounts for the taper
and is the figure you should actually plan against.

**KLTs** now carry vendor-published internals at the two sizes a captured vendor
publishes them for (`vda-rklt-6429`, `vda-rklt-4329`). The other five heights are
still empty: nobody in `listings.csv` sells them with a spec sheet attached.

## The `listings` table

121 individual vendor listings across four markets, each with the date it was
captured. Same dimensional columns as the main table — in both unit systems — plus
`vendor`, `vendor_country`, `url`, `sku`, `native_unit`, `price`, `currency`,
`price_includes_vat`, `pack_quantity`, `unit_price` and `captured_date`.

`native_unit` is `imperial` or `metric`: which unit the vendor's own catalogue
publishes in, and therefore which column is the figure and which is the conversion.
Hudson Exchange is the imperial one. It matters because inch-designed totes land near
the 600 × 400 module without hitting it — their 24 × 15 in tote is 61.0 × 38.1 cm,
one centimetre too long to put four on a Euro pallet. See
[`guidance/units-and-us-vendors.md`](guidance/units-and-us-vendors.md).

| Vendor | Market | Listings | Publishes internals | Captured |
|---|---|---|---|---|
| Salesbridges | Netherlands | 69 | almost all | 2026-07-27 |
| Plastic Box Shop | UK | 31 | most | 2026-07-27 |
| Yosibox | Israel | 12 | 3 | 2026-07-23 |
| Hudson Exchange | US | 9 | none | 2026-07-27 |

`usable_ratio` on this table is computed from each listing's **own** stated capacity
and external dimensions — so it shows what each vendor claims, not what the typical
table concluded. The spread is the useful part:

| | n | min | median | max |
|---|---|---|---|---|
| Attached-lid containers | 16 | 52 % | **71 %** | 81 % |
| Euro stacking containers | 101 | 56 % | **78 %** | 99 % |
| VDA KLTs | 3 | 66 % | **70 %** | 70 % |

Three things fall out of that, all of which shaped the main table:

- **The ~6-point gap between tapered and straight-walled is real** and consistent
  across three independent markets. It is the single most important number here.
- **Vendor nominal litres run optimistic.** Several UK Euro listings claim 83 % of
  external volume, which the published internal dimensions on the same page do not
  support. This is why `containers.csv` derives Euro capacities from internal
  dimensions rather than trusting the marketed litre figure.
- **The extremes are shape, method, and occasionally a typo.** The 52 % is a small
  tote where walls are a large fraction of the volume. The Euro maximum of 99 % is a
  single Salesbridges listing whose stated litres contradict the internal dimensions
  printed beside them; the rest of their high ratios are real but computed
  geometrically from the top opening rather than measured. All are kept in — the
  point of this table is to show what vendors say, not to launder it.

Note that the Hudson Exchange sizes are **US-market footprints** (21.9 × 15.2 in ≈
55.6 × 38.6 cm), not 600 × 400 Euro modules. They are included because they are the
same product class and corroborate the ALC ratio independently of the European
supply chain — not because they are interchangeable with a Eurobox.

Raw captures are in [`raw/`](raw/), trimmed to the fields used. Re-fetching those is
the only way to refresh the table; the build script never touches the network, so a
rebuild always reproduces the same rows.

## Quick start

```python
from datasets import load_dataset

ds = load_dataset("danielrosehill/storage-container-dimensions", split="train")

# What does a 60x40x23 Eurobox actually hold?
box = next(r for r in ds if r["id"] == "euro-600x400x230")
print(box["typical_capacity_l"], "L usable vs", box["external_volume_l"], "L external")
# 42.0 L usable vs 55.2 L external

# Straight-walled vs tapered, same footprint
for r in ds:
    if r["external_length_cm"] == 60 and r["external_width_cm"] == 40:
        print(f'{r["id"]:22} {r["usable_ratio"]:.0%} usable')
```

```python
# What did the 42 L figure get generalised from?
obs = load_dataset("danielrosehill/storage-container-dimensions", "listings", split="train")
for r in obs:
    if r["external_length_cm"] == 60 and r["external_height_cm"] == 23:
        print(r["vendor"], r["stated_capacity_l"], "L", r["captured_date"], r["url"])
```

Or just `pandas.read_csv` the files — 48 and 121 rows.

## Sources

Assembled from vendor catalogues and standards documentation, verified **27 July
2026**:

- **salesbridges.eu** (NL/EU retail) — the widest published set of internal
  dimensions of any vendor here: 70 of 98 listings in their plastic-crates category,
  measured at the top opening. Prices in EUR ex-VAT. Their storefront runs on
  Lightspeed eCom, which serves any category or product page as JSON if you append
  `?format=json` — see `scripts/capture_salesbridges.py`.
- **plasticboxshop.co.uk** (UK retail) — Euro and ALC ranges with published internal
  dimensions and nominal capacities. Their Shopify storefront exposes the full
  catalogue at `/collections/{handle}/products.json`.
- **hudsonex.com** (US retail, Hudson Exchange) — attached-lid totes on US-market
  footprints, dimensions in inches and capacity in US gallons. Also Shopify. The
  product copy confirms the tapered-wall / nesting behaviour but publishes no
  internal dimensions.
- **yosibox.com** (Israeli retail) — G- and T-series industrial boxes with published
  internal dimensions; the primary cross-check on the 600 × 400 internal rule.
- **IPL Schoeller** (`iplschoeller.com`) — the Kaiman ALC height grid. Their product
  pages publish external dimensions only.
- **VDA 4500 v3.1** (December 2025) — KLT footprints, the three system heights, the
  15 mm insertion depth, and the R-KLT 6429 figures.
- **ISO 3394 / EN 13199** — the packaging module and the small-load-carrier cap,
  via secondary summaries; both are paid publications.

## Related

- [`eurobox-calculator`](https://github.com/danielrosehill/storage-container-calculator) — the
  calculator this data was built for: usable capacity, pallet and 20 ft container
  loads, and cost per usable litre across both families.
- [`storage-box-3d-models`](https://github.com/danielrosehill/storage-box-3d-models)
  — true-scale GLB models of several of these units, CC BY 4.0.
- [`eurobox-standard`](https://github.com/danielrosehill/eurobox-standard) — VDA 4500
  itself plus a human-readable digest.

Longer notes that did not fit the card:

- [`guidance/internal-dimensions.md`](guidance/internal-dimensions.md) — why vendors
  disagree about the inside of the same box, with the per-vendor evidence.
- [`guidance/naming.md`](guidance/naming.md) — what these boxes are called in each
  market, which of those names are evidenced here, and the two that mislead.
- [`guidance/eurobox-vs-alc-same-size.md`](guidance/eurobox-vs-alc-same-size.md) —
  what the ALC taper actually costs you, worked through.
- [`guidance/units-and-us-vendors.md`](guidance/units-and-us-vendors.md) — both unit
  systems, what `native_unit` is for, the US near-miss footprints, and precisely what
  is standardised and what is only convention.

## Versioning

The data dictionary carries a version — currently **1.0** — set in `dictionary.py` and
stamped into the datasheet filename and its footer. It describes the *schema*: bump
the minor version when a column is added or a description changes materially, the
major when a column is removed or its meaning changes under an unchanged name. Row
additions and capacity revisions do not move it; those are visible in the git history
and in `captured_date`.

## Regenerating

`containers.csv`, `containers.jsonl` **and this card's YAML frontmatter** are all
produced by `build.py`, which holds the internal-dimension rules in one place so a
rule change cannot leave them disagreeing. Edit the rules there, not the CSV.

```bash
python3 build.py                         # listings.csv, containers.*, dictionary, frontmatter
./datasheet/build.sh                     # datasheet/...-datasheet-v1.0.pdf  (needs typst)
python3 scripts/build_reference_pdf.py   # reference/storage-container-reference.pdf
python3 scripts/capture_salesbridges.py  # only if you want to re-fetch raw/
```

`build.py` runs `build_listings.py` first, so the typical rows can count the vendors
and listings behind them. Only `scripts/capture_salesbridges.py` touches the network.
The PDF needs reportlab (`pip install -r scripts/requirements.txt`); rerun it after
`build.py`, since it renders the CSVs rather than recomputing anything.

The data dictionary lives in `dictionary.py` and is rendered four ways —
`data-dictionary.csv`, `docs/data-dictionary.md`, this card's Fields table and the
frontmatter dtypes. `build.py` fails if a builder emits a column the dictionary does
not document, or documents one it does not emit, so the schema and its documentation
cannot drift apart. Add a column in both places or the build stops.

Two PDF toolchains, deliberately: the reference is reportlab (it lays out long
generated tables of sizes), the datasheet is Typst (it is a document that happens to
read data). Both take their numbers from the CSVs at build time.

`container_stats.py` holds the per-vendor internal-dimension statistics that both
`build.py` and the PDF report as fact, so the two cannot disagree about what a
vendor publishes.

The frontmatter declares the column schema explicitly. Left to infer types from the
CSV, the Hub reads a mostly-blank column such as `notes` as all-null, which breaks
`load_dataset` for anyone reading that field — so the schema is written by the same
run that writes the data.

## Licence

CC BY 4.0. Dimensional facts are not themselves copyrightable; the licence covers the
compilation, the derived figures and the documentation.