datasheet/datasheet.typ

// 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(),
  )
]