Add a data dictionary as the single source, and a v1.0 datasheet

dictionary.py now holds one definition per column for both tables — name, dtype,
unit, description — and build.py renders it four ways: data-dictionary.csv,
docs/data-dictionary.md, the card's Fields table, and the Hub's dtype frontmatter.
None of those is hand-written any more. The descriptions were previously prose in
the README and the dtypes a separate dict in build.py, so the two could disagree
about the same column and nothing would notice.

check() fails the build when a builder emits a column the dictionary does not
document, or documents one it does not emit, order included. Verified by removing
a column from the dictionary and confirming build.py exits 1 rather than writing a
dataset whose documentation is wrong.

datasheet/datasheet.typ is a datasheet for the dataset rather than a reference to
the sizes: scope in and out, composition of both tables, how each family's numbers
were derived and why ALCs have no internal dimensions, known limitations, capture
provenance, and the full dictionary. It reads data-dictionary.csv, containers.csv
and listings.csv at compile time, so the counts, the vendor table and the schema
cannot drift from the data. The only value passed in is the version, via
version.json.

The dictionary carries a schema version, 1.0, stamped into the datasheet filename
and footer. Minor bump for a column added or a description materially changed,
major for a column removed or redefined under an unchanged name; row additions and
capacity revisions do not move it.

This leaves two PDF toolchains in the repo on purpose, now noted in the card: the
dimensional reference stays on reportlab, which is laying out long generated tables
of sizes, and the datasheet is Typst, being a document that happens to read data.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

README.md

@@ -186,7 +186,14 @@ typical  = load_dataset("danielrosehill/storage-container-dimensions", split="tr
 listings = load_dataset("danielrosehill/storage-container-dimensions", "listings", split="train")
 ```
 
-Prefer it on paper? The same data is rendered as an 8-page printable reference —
+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)**.
@@ -291,35 +298,44 @@ a large order.**
 
 ## Fields
 
-| Field | Notes |
-|---|---|
-| `id` | Stable slug, e.g. `euro-600x400x230`, `alc-600x400x310`, `vda-rklt-6429` |
-| `type` | `euro_stacking_container` · `attached_lid_container` · `vda_klt_container` |
-| `type_label` | Human-readable form of `type` |
-| `common_names` | 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`](guidance/naming.md) |
-| `external_length_cm` / `external_width_cm` / `external_height_cm` | External, in cm |
-| `external_length_in` / `external_width_in` / `external_height_in` | The same, in inches. Always the derived side on this table — these nominal sizes are fixed in millimetres by the standards |
-| `external_volume_l` | L × W × H. **Not** what the box holds |
-| `external_volume_gal` | The same, in US liquid gallons |
-| `internal_length_cm` / `internal_width_cm` / `internal_height_cm` | Typical internal, in cm. Populated for every Euro row and for the two KLT sizes a vendor publishes; empty for ALCs — see below |
-| `internal_length_in` / `internal_width_in` / `internal_height_in` | The same, in inches |
-| `internal_dims_basis` | Where those internal figures came from: `vendor_average_rule`, `vendor_published`, `not_published`, `not_published_tapered_walls` |
-| `internal_dims_vendors` | How many **vendors** publish internal dimensions for this footprint. Vendors, not listings — one mould in five colours is one opinion |
-| `typical_capacity_l` | **The usable number.** Always populated |
-| `typical_capacity_gal` | The same, in US liquid gallons |
-| `vendor_capacity_low_l` / `vendor_capacity_high_l` | Capacity implied by the least and the most generous vendor's own published internal dimensions for this footprint. Empty where no vendor publishes any. See [`guidance/internal-dimensions.md`](guidance/internal-dimensions.md) |
-| `usable_ratio` | `typical_capacity_l / external_volume_l` |
-| `capacity_basis` | How the capacity was arrived at — see below |
-| `lidded` | True where a lid is integral to the product (ALCs) |
-| `lid_available_separately` | True where a lid exists but is a separate purchase |
-| `nestable_when_empty` | True for ALCs; straight-walled boxes stack but do not nest |
-| `typical_nesting_ratio` | 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` | Whether the footprint conforms to a recognised module |
-| `standard` | Which one, stated precisely |
-| `vda_4500_height` | Whether the external height is on the VDA KLT grid |
-| `eur1_pallet_per_layer` | Boxes per layer on a 1200 × 800 Euro pallet, no overhang. The one column that reaches past the box itself — see [Scope](#scope) |
-| `listings_observed` | How many rows in the `listings` table back this size — 0 means the row is a plausible interpolation, not something seen for sale |
-| `notes` | Per-row caveats. Read these |
+| 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
 
@@ -510,6 +526,15 @@ Longer notes that did not fit the card:
   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
@@ -517,7 +542,8 @@ produced by `build.py`, which holds the internal-dimension rules in one place so
 rule change cannot leave them disagreeing. Edit the rules there, not the CSV.
 
 ```bash
-python3 build.py                         # listings.csv, containers.*, this frontmatter
+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/
 ```
@@ -527,6 +553,16 @@ and listings behind them. Only `scripts/capture_salesbridges.py` touches the net
 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.

build.py

@@ -10,6 +10,7 @@ Run: python3 build.py
 
 import csv
 import json
+import re
 import subprocess
 import sys
 from pathlib import Path
@@ -18,6 +19,7 @@ HERE = Path(__file__).parent
 
 sys.path.insert(0, str(HERE))
 import container_stats  # noqa: E402  (needs HERE on the path)
+import dictionary  # noqa: E402
 
 # ---------------------------------------------------------------------------
 # Internal-dimension rules.
@@ -325,22 +327,59 @@ with (HERE / "containers.jsonl").open("w", encoding="utf-8") as f:
 # `load_dataset` for anyone reading that field. Writing the frontmatter from the
 # same run that writes the data is the only way to keep the two in step.
 
-DTYPES = {
-    **{k: "int64" for k in ("eur1_pallet_per_layer", "pack_quantity", "listings_observed",
-                            "internal_dims_vendors")},
-    **{k: "bool" for k in (
-        "lidded", "lid_available_separately", "nestable_when_empty",
-        "standard_conformant", "vda_4500_height", "price_includes_vat")},
-    **{k: "float64" for k in (
-        "external_length_cm", "external_width_cm", "external_height_cm",
-        "external_volume_l", "internal_length_cm", "internal_width_cm",
-        "internal_height_cm", "typical_capacity_l", "vendor_capacity_low_l",
-        "vendor_capacity_high_l", "usable_ratio",
-        "typical_nesting_ratio", "stated_capacity_l", "price", "unit_price",
-        "external_length_in", "external_width_in", "external_height_in",
-        "internal_length_in", "internal_width_in", "internal_height_in",
-        "external_volume_gal", "typical_capacity_gal", "stated_capacity_gal")},
-}
+DTYPES = dictionary.DTYPES
+
+
+def write_dictionary():
+    """Render the dictionary as a CSV and a document, and verify it matches."""
+    dictionary.check("containers", FIELDS)
+    with (HERE / "listings.csv").open(encoding="utf-8") as f:
+        dictionary.check("listings", next(csv.reader(f)))
+
+    rows = [
+        {"table": table, "file": fname, "column": name, "dtype": dtype,
+         "unit": unit, "description": desc}
+        for table, (fname, cols) in dictionary.TABLES.items()
+        for name, dtype, unit, desc in cols
+    ]
+    with (HERE / "data-dictionary.csv").open("w", newline="", encoding="utf-8") as f:
+        w = csv.DictWriter(f, fieldnames=list(rows[0]))
+        w.writeheader()
+        w.writerows(rows)
+
+    doc = [
+        "# Data dictionary\n\n",
+        f"Version {dictionary.VERSION}. Generated by `build.py` from `dictionary.py` "
+        "— do not hand-edit.\n\n",
+        "Every column in both tables, with its type, unit and meaning. The machine-"
+        "readable form of this file is [`data-dictionary.csv`](../data-dictionary.csv); "
+        "the same definitions render the dataset card's field table and the Hub's "
+        "dtype declarations, so the three cannot disagree.\n",
+    ]
+    for table, (fname, cols) in dictionary.TABLES.items():
+        doc.append(f"\n## `{table}` → `{fname}`\n")
+        doc.append(f"{len(cols)} columns.\n\n")
+        doc.append("| Column | Type | Unit | Description |\n|---|---|---|---|\n")
+        for name, dtype, unit, desc in cols:
+            doc.append(f"| `{name}` | {dtype} | {unit or '—'} | {desc} |\n")
+    (HERE / "docs").mkdir(exist_ok=True)
+    (HERE / "docs" / "data-dictionary.md").write_text("".join(doc), encoding="utf-8")
+
+    # The datasheet is a Typst document that reads the CSVs at compile time; the
+    # one thing it cannot get from them is the dictionary's version.
+    (HERE / "datasheet").mkdir(exist_ok=True)
+    (HERE / "datasheet" / "version.json").write_text(
+        json.dumps({"version": dictionary.VERSION}) + "\n", encoding="utf-8")
+    return rows
+
+
+def fields_table():
+    """The dataset card's Fields section, rendered from the dictionary."""
+    out = ["| Field | Type | Notes |", "|---|---|---|"]
+    for name, dtype, unit, desc in dictionary.CONTAINERS:
+        u = f" ({unit})" if unit else ""
+        out.append(f"| `{name}` | {dtype}{u} | {desc} |")
+    return "\n".join(out)
 
 
 def features(names, indent="    "):
@@ -392,14 +431,23 @@ dataset_info:
 ---"""
 
 
+DICT_ROWS = write_dictionary()
+
 readme = HERE / "README.md"
 if readme.exists():
     body = readme.read_text(encoding="utf-8")
     if body.startswith("---"):
         body = body.split("---", 2)[2].lstrip("\n")
+    # The Fields table is rendered from dictionary.py, so replace whatever is
+    # between the heading and the next one rather than trusting it to be current.
+    body = re.sub(
+        r"(## Fields\n\n).*?(\n### )",
+        lambda m: m.group(1) + fields_table() + "\n" + m.group(2),
+        body, count=1, flags=re.S)
     readme.write_text(frontmatter() + "\n\n" + body, encoding="utf-8")
 
 print(f"{len(ROWS)} rows -> containers.csv, containers.jsonl, README.md frontmatter")
+print(f"{len(DICT_ROWS)} columns -> data-dictionary.csv, docs/data-dictionary.md")
 for kind in TYPE_LABELS:
     n = sum(1 for r in ROWS if r["type"] == kind)
     print(f"  {kind}: {n}")

data-dictionary.csv

@@ -0,0 +1,69 @@
+table,file,column,dtype,unit,description
+containers,containers.csv,id,string,,"Stable slug, e.g. `euro-600x400x230`, `alc-600x400x310`, `vda-rklt-6429`"
+containers,containers.csv,type,string,,`euro_stacking_container` · `attached_lid_container` · `vda_klt_container`
+containers,containers.csv,type_label,string,,Human-readable form of `type`
+containers,containers.csv,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`"
+containers,containers.csv,external_length_cm,float64,cm,External length
+containers,containers.csv,external_width_cm,float64,cm,External width
+containers,containers.csv,external_height_cm,float64,cm,External height
+containers,containers.csv,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
+containers,containers.csv,external_width_in,float64,in,"External width in inches, derived"
+containers,containers.csv,external_height_in,float64,in,"External height in inches, derived"
+containers,containers.csv,external_volume_l,float64,L,L × W × H. **Not** what the box holds
+containers,containers.csv,external_volume_gal,float64,US gal,External volume in US liquid gallons
+containers,containers.csv,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"
+containers,containers.csv,internal_width_cm,float64,cm,"Typical internal width, same basis"
+containers,containers.csv,internal_height_cm,float64,cm,"Typical internal height, same basis"
+containers,containers.csv,internal_length_in,float64,in,"Typical internal length in inches, derived"
+containers,containers.csv,internal_width_in,float64,in,"Typical internal width in inches, derived"
+containers,containers.csv,internal_height_in,float64,in,"Typical internal height in inches, derived"
+containers,containers.csv,internal_dims_basis,string,,"Where those internal figures came from: `vendor_average_rule`, `vendor_published`, `not_published`, `not_published_tapered_walls`"
+containers,containers.csv,internal_dims_vendors,int64,,"How many **vendors** publish internal dimensions for this footprint. Vendors, not listings — one mould in five colours is one opinion"
+containers,containers.csv,typical_capacity_l,float64,L,**The usable number.** Always populated
+containers,containers.csv,typical_capacity_gal,float64,US gal,Usable capacity in US liquid gallons
+containers,containers.csv,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
+containers,containers.csv,vendor_capacity_high_l,float64,L,"As above, most generous vendor. See `guidance/internal-dimensions.md`"
+containers,containers.csv,usable_ratio,float64,,`typical_capacity_l / external_volume_l`
+containers,containers.csv,capacity_basis,string,,"How the capacity was arrived at: `derived_from_internal_dims`, `vendor_nominal`, `published`, `derived_from_klt_ratio`"
+containers,containers.csv,lidded,bool,,True where a lid is integral to the product (ALCs)
+containers,containers.csv,lid_available_separately,bool,,True where a lid exists but is a separate purchase
+containers,containers.csv,nestable_when_empty,bool,,True for ALCs; straight-walled boxes stack but do not nest
+containers,containers.csv,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"
+containers,containers.csv,standard_conformant,bool,,Whether the footprint conforms to a recognised module
+containers,containers.csv,standard,string,,"Which one, stated precisely"
+containers,containers.csv,vda_4500_height,bool,,Whether the external height is on the VDA KLT grid (147.5 / 213 / 280 mm)
+containers,containers.csv,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"
+containers,containers.csv,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"
+containers,containers.csv,notes,string,,Per-row caveats. Read these
+listings,listings.csv,listing_id,string,,"Stable slug, `<vendor>-<sku or handle>`"
+listings,listings.csv,vendor,string,,Salesbridges · Plastic Box Shop · Yosibox · Hudson Exchange
+listings,listings.csv,vendor_country,string,,ISO 3166-1 alpha-2 of the vendor's market
+listings,listings.csv,product_name,string,,"The vendor's own product title, verbatim"
+listings,listings.csv,sku,string,,"Vendor SKU where published, else empty"
+listings,listings.csv,url,string,,"The listing, as captured on `captured_date`"
+listings,listings.csv,type,string,,"Family, assigned by this project — not the vendor's word"
+listings,listings.csv,native_unit,string,,"`metric` or `imperial`: which unit the vendor's own catalogue publishes in, and therefore which dimension columns are the figure and which are the conversion. See `guidance/units-and-us-vendors.md`"
+listings,listings.csv,external_length_cm,float64,cm,External length as listed or converted
+listings,listings.csv,external_width_cm,float64,cm,External width as listed or converted
+listings,listings.csv,external_height_cm,float64,cm,External height as listed or converted
+listings,listings.csv,external_length_in,float64,in,External length; the vendor's own figure where `native_unit` is `imperial`
+listings,listings.csv,external_width_in,float64,in,"External width, same basis"
+listings,listings.csv,external_height_in,float64,in,"External height, same basis"
+listings,listings.csv,internal_length_cm,float64,cm,"Internal length **as the vendor publishes it**, empty where they do not. 95 of 121 rows carry these; vendors measure at different heights on a tapered box, which is why the typical table's figures are conservative"
+listings,listings.csv,internal_width_cm,float64,cm,Internal width as published
+listings,listings.csv,internal_height_cm,float64,cm,Internal height as published
+listings,listings.csv,internal_length_in,float64,in,Internal length in inches
+listings,listings.csv,internal_width_in,float64,in,Internal width in inches
+listings,listings.csv,internal_height_in,float64,in,Internal height in inches
+listings,listings.csv,stated_capacity_l,float64,L,The vendor's own capacity claim. Not recomputed — the point of this table is what they say
+listings,listings.csv,stated_capacity_gal,float64,US gal,The same in US gallons; the vendor's own figure for Hudson Exchange
+listings,listings.csv,external_volume_l,float64,L,"L × W × H, computed here"
+listings,listings.csv,external_volume_gal,float64,US gal,The same in US gallons
+listings,listings.csv,usable_ratio,float64,,"`stated_capacity_l / external_volume_l` — what **this** vendor claims, not what the typical table concluded"
+listings,listings.csv,price,float64,,"As captured, in `currency`. An observation with a date on it, not a price feed"
+listings,listings.csv,currency,string,,ISO 4217
+listings,listings.csv,price_includes_vat,bool,,"Whether the captured price is VAT-inclusive. Differs by market — UK and NL retail inclusive, US exclusive"
+listings,listings.csv,pack_quantity,int64,,Units in the pack the price refers to. Multipacks and pallet deals are common
+listings,listings.csv,unit_price,float64,,`price / pack_quantity`
+listings,listings.csv,captured_date,string,,ISO 8601 date the listing was read
+listings,listings.csv,notes,string,,"Per-row caveats, including non-conforming footprints"

datasheet/build.sh

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+# Build the datasheet PDF. Run build.py first — the datasheet reads the CSVs and
+# version.json at compile time, so a stale build produces a stale datasheet.
+set -euo pipefail
+cd "$(dirname "$0")/.."
+python3 build.py >/dev/null
+V=$(python3 -c "import json;print(json.load(open('datasheet/version.json'))['version'])")
+OUT="datasheet/storage-container-dimensions-datasheet-v${V}.pdf"
+typst compile --root . datasheet/datasheet.typ "$OUT"
+echo "$OUT"

datasheet/datasheet.typ

@@ -0,0 +1,276 @@
+// Datasheet for the storage-container-dimensions dataset.
+//
+// Reads data-dictionary.csv, containers.csv and listings.csv at compile time, so
+// the schema, the counts and the vendor table cannot drift from the data. The only
+// thing passed in is the dictionary version, in version.json, written by build.py.
+//
+// Compile with the repo as the root:
+//   ./datasheet/build.sh
+//   typst compile --root . datasheet/datasheet.typ datasheet/...-datasheet-v1.0.pdf
+
+#let version = json("/datasheet/version.json").version
+#let dict = csv("/data-dictionary.csv", row-type: dictionary)
+#let containers = csv("/containers.csv", row-type: dictionary)
+#let listings = csv("/listings.csv", row-type: dictionary)
+
+#let ink = rgb("#16191d")
+#let accent = rgb("#245c8c")
+#let soft = rgb("#f1f4f7")
+#let rule = rgb("#c7cdd4")
+
+#set document(
+  title: "Industrial Storage Container Dimensions — datasheet v" + version,
+  author: "Daniel Rosehill",
+)
+#set page(
+  paper: "a4",
+  margin: (x: 19mm, top: 20mm, bottom: 18mm),
+  footer: context [
+    #set text(8pt, fill: gray)
+    #grid(
+      columns: (1fr, auto, 1fr),
+      align: (left, center, right),
+      [danielrosehill/storage-container-dimensions],
+      [datasheet v#version],
+      [#counter(page).display("1 / 1", both: true)],
+    )
+  ],
+)
+#set text(font: "IBM Plex Sans", size: 9.5pt, fill: ink,
+          number-type: "lining", number-width: "tabular")
+#set par(justify: false, leading: 0.62em)
+#show heading: set text(fill: accent)
+#show heading.where(level: 1): it => block(above: 1.5em, below: 0.75em)[
+  #set text(14pt, weight: 600)
+  #it.body
+  #v(-0.45em)
+  #line(length: 100%, stroke: 0.6pt + rule)
+]
+#show heading.where(level: 2): set text(10.5pt, weight: 600)
+#show link: set text(fill: accent)
+#show table.cell.where(y: 0): set text(weight: 600, size: 8pt)
+#set table(
+  stroke: (x, y) => (
+    bottom: if y == 0 { 0.7pt + rule } else { 0.3pt + rule.lighten(35%) },
+  ),
+  fill: (x, y) => if y == 0 { soft },
+  inset: (x: 5pt, y: 4pt),
+)
+
+#let count(rows, pred) = rows.filter(pred).len()
+#let uniq(rows, key) = {
+  let seen = ()
+  for r in rows { if not seen.contains(r.at(key)) { seen.push(r.at(key)) } }
+  seen
+}
+
+// --- cover -------------------------------------------------------------------
+
+#block[
+  #text(8.5pt, fill: gray, weight: 600, tracking: 0.08em)[DATASET DATASHEET]
+  #v(0.35em)
+  #text(21pt, weight: 600, fill: accent)[Industrial Storage \ Container Dimensions]
+  #v(0.5em)
+  #text(10.5pt, fill: gray)[
+    Planning-grade volumetric reference for Euroboxes, attached-lid containers and
+    VDA 4500 KLTs — the plastic totes European and North American warehouses run on.
+  ]
+]
+
+#v(0.8em)
+#grid(
+  columns: (auto, 1fr),
+  gutter: 8pt,
+  row-gutter: 3pt,
+  text(fill: gray)[Version], [*#version*],
+  text(fill: gray)[Compiled], [#datetime.today().display("[day] [month repr:long] [year]")],
+  text(fill: gray)[Canonical], link("https://huggingface.co/datasets/danielrosehill/storage-container-dimensions")[huggingface.co/datasets/danielrosehill/storage-container-dimensions],
+  text(fill: gray)[Licence], [CC BY 4.0],
+  text(fill: gray)[Tables], [`containers.csv` — #containers.len() rows, #count(dict, r => r.table == "containers") columns · `listings.csv` — #listings.len() rows, #count(dict, r => r.table == "listings") columns],
+)
+
+#v(0.7em)
+#block(fill: soft, inset: 9pt, radius: 3pt, width: 100%)[
+  *The one thing to take from this document.* The standards fix the *footprint*. They
+  do not fix internal dimensions, and they barely fix heights. Every internal
+  dimension and capacity here is a typical figure averaged across vendor catalogues,
+  good to roughly ±1 L on a 600 × 400 box — a planning number, not a specification.
+  Check the specific supplier's own figures before committing to a large order.
+]
+
+= What it is for
+
+The dataset stops at the unit: it describes the smallest standardised unit of
+industrial storage and nothing above it. The calculations downstream are the
+reader's, and in practice they are pallet load patterns, shelving and racking
+layouts, consolidation and move planning, and ranking purchases on cost per
+*usable* litre rather than on the nominal size printed on a listing.
+
+#v(0.3em)
+#table(
+  columns: (1fr, 1fr),
+  table.header[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],
+)
+
+#v(0.3em)
+The single deliberate exception is `eur1_pallet_per_layer`, the footprint count on a
+1200 × 800 deck. It is the last figure 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.
+
+= Composition
+
+== `containers.csv` — one typical row per nominal size
+
+#let fam(t) = containers.filter(r => r.type == t)
+#let heights(rows) = {
+  let h = uniq(rows, "external_height_cm").map(x => float(x)).sorted()
+  str(calc.min(..h)) + "–" + str(calc.max(..h)) + " cm, " + str(h.len()) + " values"
+}
+#table(
+  columns: (auto, auto, 1fr, auto),
+  align: (left, right, left, left),
+  table.header[Family][Rows][Footprints (cm)][External heights],
+  ..(("euro_stacking_container", "Euro stacking container"),
+     ("attached_lid_container", "Attached-lid container"),
+     ("vda_klt_container", "VDA 4500 KLT")).map(((key, label)) => {
+    let rows = fam(key)
+    (
+      [#label], [#rows.len()],
+      [#uniq(rows.map(r => (v: r.external_length_cm + " × " + r.external_width_cm)), "v").join(", ")],
+      [#heights(rows)],
+    )
+  }).flatten(),
+)
+
+Rows are nominal sizes, not products. A row exists where a size is either sold by a
+captured vendor or is a defensible interpolation within a family's grid;
+`listings_observed` says which, and a `0` there means nobody in `listings.csv` was
+selling it.
+
+== `listings.csv` — the observations behind them
+
+#table(
+  columns: (1fr, auto, auto, auto, auto, auto),
+  align: (left, left, right, right, right, left),
+  table.header[Vendor][Market][Listings][Publishes internals][Native unit][Captured],
+  ..uniq(listings, "vendor").sorted().map(v => {
+    let rows = listings.filter(r => r.vendor == v)
+    (
+      [#v], [#rows.at(0).vendor_country], [#rows.len()],
+      [#count(rows, r => r.internal_length_cm != "")],
+      [#rows.at(0).native_unit],
+      [#uniq(rows, "captured_date").map(d => d.slice(0, 10)).join(", ")],
+    )
+  }).flatten(),
+)
+
+This table exists so the first one can be audited. Every typical capacity is a
+judgement about a spread of real products; these are the products, with URLs and
+capture dates, so a reader who disagrees with a figure can see what it was
+generalised from. Prices are captured observations with a date on them — kept to make
+a capacity auditable against what was really on sale, not a price feed, and they rot.
+
+= How the numbers were derived
+
+*Straight-walled boxes.* Internal dimensions follow a per-footprint rule averaged
+across vendor catalogues — for 600 × 400, internally 550 × 355 mm with the height less
+15 mm — and capacity is computed from those. The rule sits deliberately at the
+conservative end of the published range.
+
+*Attached-lid containers.* The taper means no single internal L × W × H is right
+wherever you measure it, and no captured vendor publishes one for a 600 × 400 or
+400 × 300 ALC. Capacity is the manufacturer's nominal figure, which is the only
+honest number available; `internal_*` is empty and `internal_dims_basis` says
+`not_published_tapered_walls`.
+
+*VDA KLTs.* Thicker-walled than consumer Euroboxes, so the straight-wall rule does not
+transfer. Where a vendor publishes internals for the exact size they are used;
+elsewhere capacity is derived from the one published pair (R-KLT 6429, 600 × 400 × 280
+external = 67.2 L, 48 L internal) and `capacity_basis` says so.
+
+*Both unit systems, on every row.* Dimensions in centimetres and inches, capacity in
+litres and US gallons. On `listings.csv`, `native_unit` records which side is the
+vendor's own figure and which is the conversion — the derived side is rounded, so a
+US vendor's own 19.6 in read back from a 1 dp centimetre value becomes 19.61.
+
+= Known limitations
+
+/ Internal dimensions are not standardised: Wall thickness, draft angle and rib design
+  are the manufacturer's choice. Across the four captured catalogues a
+  60 × 40 × 32 cm Eurobox is quoted internally at anything from 60.4 to 66.4 L — an
+  11 % range on a box all of them call 600 × 400 × 320. `vendor_capacity_low_l` and
+  `vendor_capacity_high_l` carry that range on every row rather than hiding it.
+
+/ Heights are convention, not standard: Of the #count(containers, r => r.type == "euro_stacking_container" and r.external_length_cm == "60.0" and r.external_width_cm == "40.0") distinct
+  600 × 400 heights here, exactly one — 280 mm — is fixed by a standard (VDA 4500).
+  The rest are what manufacturers happen to make, and one-off variants exist.
+
+/ Inch-designed totes near-miss the module: US vendors design to inches and land close
+  to 600 × 400 without hitting it. Hudson Exchange's 24 × 15 in straight-wall tote is
+  61.0 × 38.1 cm — one centimetre too long to put four on a Euro pallet, so the layer
+  pattern collapses from 4 to 2. Filter on the footprint in millimetres, never on a
+  product being called an industrial tote.
+
+/ The 800 × 600 rows are the weakest: They are formula-derived, and the only vendor
+  publishing internals for that footprint implies 8–9 % more capacity than the rule
+  gives. Treat them as conservative.
+
+/ Four vendors, three markets, one capture window: NL, GB, IL and US, captured July
+  2026. This is not a census of the market, and Asian manufacturers are absent.
+
+= Provenance and reproducibility
+
+Vendor catalogues were captured from the storefronts' own JSON endpoints — Shopify
+`/products.json` for the UK and US vendors, Lightspeed `?format=json` for the Dutch
+one — and the trimmed captures are committed under `raw/`. The builders never touch
+the network, so a rebuild reproduces the same tables from the same snapshots.
+
+#v(0.3em)
+#table(
+  columns: (auto, 1fr),
+  align: (left, left),
+  table.header[Step][Command],
+  [Listings from the snapshots], [`python3 build_listings.py`],
+  [Typical rows, dictionary, card], [`python3 build.py`],
+  [Printable dimensional reference], [`python3 scripts/build_reference_pdf.py`],
+  [This datasheet], [`./datasheet/build.sh`],
+)
+
+#v(0.3em)
+`build.py` renders the data dictionary four ways — `data-dictionary.csv`,
+`docs/data-dictionary.md`, the dataset card's field table and the Hub's dtype
+frontmatter — and fails if a builder emits a column the dictionary does not document.
+The schema and its documentation cannot drift apart.
+
+#pagebreak()
+
+= Data dictionary
+
+Version #version. Every column in both tables. Rendered from `data-dictionary.csv`,
+which is itself generated from `dictionary.py`.
+
+#set text(8.5pt)
+// `tbl`, not `table` — a loop variable named `table` shadows the built-in table
+// function and every table.header below it stops resolving.
+#for (tbl, fname) in (("containers", "containers.csv"), ("listings", "listings.csv")) [
+  == #raw(tbl) → #raw(fname)   // backticks would make #tbl a literal raw span
+
+  #let cols = dict.filter(r => r.table == tbl)
+  #table(
+    columns: (auto, auto, auto, 1fr),
+    align: (left, left, left, left),
+    table.header[Column][Type][Unit][Description],
+    ..cols.map(c => (
+      raw(c.column), [#c.dtype], [#if c.unit == "" { "—" } else { c.unit }],
+      // Descriptions are authored as markdown for the card and the .md doc, where
+      // bold is **x**; Typst markup uses *x* and renders ** as empty stars.
+      eval(c.description.replace("**", "*"), mode: "markup"),
+    )).flatten(),
+  )
+]

datasheet/version.json

@@ -0,0 +1 @@
+{"version": "1.0"}

dictionary.py

@@ -0,0 +1,163 @@
+#!/usr/bin/env python3
+"""The data dictionary — one definition per column, for both tables.
+
+Authoritative. build.py renders it four ways and none of them is hand-written:
+
+    data-dictionary.csv          machine-readable, one row per column
+    docs/data-dictionary.md      the same as a document
+    README.md "Fields" table     the dataset card
+    README.md frontmatter        the Hub's dtype declarations
+
+Adding a column to a builder without adding it here fails the build, which is the
+point: the schema and its documentation cannot drift apart.
+
+`unit` is the physical unit or "" for dimensionless and categorical columns.
+`example` is illustrative, not drawn from the data.
+"""
+
+VERSION = "1.0"
+
+# (name, dtype, unit, description)
+CONTAINERS = [
+    ("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"),
+]
+
+LISTINGS = [
+    ("listing_id", "string", "", "Stable slug, `<vendor>-<sku or handle>`"),
+    ("vendor", "string", "",
+     "Salesbridges · Plastic Box Shop · Yosibox · Hudson Exchange"),
+    ("vendor_country", "string", "", "ISO 3166-1 alpha-2 of the vendor's market"),
+    ("product_name", "string", "", "The vendor's own product title, verbatim"),
+    ("sku", "string", "", "Vendor SKU where published, else empty"),
+    ("url", "string", "", "The listing, as captured on `captured_date`"),
+    ("type", "string", "", "Family, assigned by this project — not the vendor's word"),
+    ("native_unit", "string", "",
+     "`metric` or `imperial`: which unit the vendor's own catalogue publishes in, and "
+     "therefore which dimension columns are the figure and which are the conversion. "
+     "See `guidance/units-and-us-vendors.md`"),
+    ("external_length_cm", "float64", "cm", "External length as listed or converted"),
+    ("external_width_cm", "float64", "cm", "External width as listed or converted"),
+    ("external_height_cm", "float64", "cm", "External height as listed or converted"),
+    ("external_length_in", "float64", "in", "External length; the vendor's own figure where `native_unit` is `imperial`"),
+    ("external_width_in", "float64", "in", "External width, same basis"),
+    ("external_height_in", "float64", "in", "External height, same basis"),
+    ("internal_length_cm", "float64", "cm",
+     "Internal length **as the vendor publishes it**, empty where they do not. 95 of "
+     "121 rows carry these; vendors measure at different heights on a tapered box, "
+     "which is why the typical table's figures are conservative"),
+    ("internal_width_cm", "float64", "cm", "Internal width as published"),
+    ("internal_height_cm", "float64", "cm", "Internal height as published"),
+    ("internal_length_in", "float64", "in", "Internal length in inches"),
+    ("internal_width_in", "float64", "in", "Internal width in inches"),
+    ("internal_height_in", "float64", "in", "Internal height in inches"),
+    ("stated_capacity_l", "float64", "L",
+     "The vendor's own capacity claim. Not recomputed — the point of this table is "
+     "what they say"),
+    ("stated_capacity_gal", "float64", "US gal",
+     "The same in US gallons; the vendor's own figure for Hudson Exchange"),
+    ("external_volume_l", "float64", "L", "L × W × H, computed here"),
+    ("external_volume_gal", "float64", "US gal", "The same in US gallons"),
+    ("usable_ratio", "float64", "",
+     "`stated_capacity_l / external_volume_l` — what **this** vendor claims, not what "
+     "the typical table concluded"),
+    ("price", "float64", "",
+     "As captured, in `currency`. An observation with a date on it, not a price feed"),
+    ("currency", "string", "", "ISO 4217"),
+    ("price_includes_vat", "bool", "",
+     "Whether the captured price is VAT-inclusive. Differs by market — UK and NL "
+     "retail inclusive, US exclusive"),
+    ("pack_quantity", "int64", "",
+     "Units in the pack the price refers to. Multipacks and pallet deals are common"),
+    ("unit_price", "float64", "", "`price / pack_quantity`"),
+    ("captured_date", "string", "", "ISO 8601 date the listing was read"),
+    ("notes", "string", "", "Per-row caveats, including non-conforming footprints"),
+]
+
+TABLES = {
+    "containers": ("containers.csv", CONTAINERS),
+    "listings": ("listings.csv", LISTINGS),
+}
+
+DTYPES = {name: dtype for _, cols in TABLES.values() for name, dtype, _, _ in cols}
+
+
+def check(table: str, fields: list[str]) -> None:
+    """Fail the build if a builder's columns and this dictionary disagree."""
+    _, cols = TABLES[table]
+    documented = [c[0] for c in cols]
+    if documented != list(fields):
+        missing = [f for f in fields if f not in documented]
+        extra = [f for f in documented if f not in fields]
+        raise SystemExit(
+            f"{table}: dictionary and CSV columns disagree.\n"
+            f"  undocumented in dictionary.py: {missing or 'none'}\n"
+            f"  documented but not emitted:    {extra or 'none'}\n"
+            f"  (order matters too — CSV order is {list(fields)})"
+        )

docs/data-dictionary.md

@@ -0,0 +1,85 @@
+# Data dictionary
+
+Version 1.0. Generated by `build.py` from `dictionary.py` — do not hand-edit.
+
+Every column in both tables, with its type, unit and meaning. The machine-readable form of this file is [`data-dictionary.csv`](../data-dictionary.csv); the same definitions render the dataset card's field table and the Hub's dtype declarations, so the three cannot disagree.
+
+## `containers` → `containers.csv`
+36 columns.
+
+| Column | Type | Unit | Description |
+|---|---|---|---|
+| `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 |
+
+## `listings` → `listings.csv`
+32 columns.
+
+| Column | Type | Unit | Description |
+|---|---|---|---|
+| `listing_id` | string | — | Stable slug, `<vendor>-<sku or handle>` |
+| `vendor` | string | — | Salesbridges · Plastic Box Shop · Yosibox · Hudson Exchange |
+| `vendor_country` | string | — | ISO 3166-1 alpha-2 of the vendor's market |
+| `product_name` | string | — | The vendor's own product title, verbatim |
+| `sku` | string | — | Vendor SKU where published, else empty |
+| `url` | string | — | The listing, as captured on `captured_date` |
+| `type` | string | — | Family, assigned by this project — not the vendor's word |
+| `native_unit` | string | — | `metric` or `imperial`: which unit the vendor's own catalogue publishes in, and therefore which dimension columns are the figure and which are the conversion. See `guidance/units-and-us-vendors.md` |
+| `external_length_cm` | float64 | cm | External length as listed or converted |
+| `external_width_cm` | float64 | cm | External width as listed or converted |
+| `external_height_cm` | float64 | cm | External height as listed or converted |
+| `external_length_in` | float64 | in | External length; the vendor's own figure where `native_unit` is `imperial` |
+| `external_width_in` | float64 | in | External width, same basis |
+| `external_height_in` | float64 | in | External height, same basis |
+| `internal_length_cm` | float64 | cm | Internal length **as the vendor publishes it**, empty where they do not. 95 of 121 rows carry these; vendors measure at different heights on a tapered box, which is why the typical table's figures are conservative |
+| `internal_width_cm` | float64 | cm | Internal width as published |
+| `internal_height_cm` | float64 | cm | Internal height as published |
+| `internal_length_in` | float64 | in | Internal length in inches |
+| `internal_width_in` | float64 | in | Internal width in inches |
+| `internal_height_in` | float64 | in | Internal height in inches |
+| `stated_capacity_l` | float64 | L | The vendor's own capacity claim. Not recomputed — the point of this table is what they say |
+| `stated_capacity_gal` | float64 | US gal | The same in US gallons; the vendor's own figure for Hudson Exchange |
+| `external_volume_l` | float64 | L | L × W × H, computed here |
+| `external_volume_gal` | float64 | US gal | The same in US gallons |
+| `usable_ratio` | float64 | — | `stated_capacity_l / external_volume_l` — what **this** vendor claims, not what the typical table concluded |
+| `price` | float64 | — | As captured, in `currency`. An observation with a date on it, not a price feed |
+| `currency` | string | — | ISO 4217 |
+| `price_includes_vat` | bool | — | Whether the captured price is VAT-inclusive. Differs by market — UK and NL retail inclusive, US exclusive |
+| `pack_quantity` | int64 | — | Units in the pack the price refers to. Multipacks and pallet deals are common |
+| `unit_price` | float64 | — | `price / pack_quantity` |
+| `captured_date` | string | — | ISO 8601 date the listing was read |
+| `notes` | string | — | Per-row caveats, including non-conforming footprints |