diff --git a/agents/anyplot/data/parse.py b/agents/anyplot/data/parse.py
index 6c26b7c9c7b..daa13ed8adc 100644
--- a/agents/anyplot/data/parse.py
+++ b/agents/anyplot/data/parse.py
@@ -23,7 +23,16 @@
    (`json_pairs`: the columns `category` and `value`, one row per entry, in the
    pasted order; the keys stay text, the values are typed); nesting depth at
    most 2; `null`, `NaN` and `Infinity` are missing; a key repeated in an object
-   keeps its last value, with a warning. Text that starts with a bare `(` and is
+   keeps its last value, with a warning. A JSON-stat 2.0 dataset (`json_stat`,
+   since 2026-10-14: what the statistics offices' APIs return, BFS PxWeb,
+   Eurostat, Statistik Austria, Statistics Norway), or a JSON-stat 1.x bundle
+   of one dataset, is the one shape nested deeper than 2 (dimension, category,
+   index: about five levels): it is checked strictly and flattened into a long
+   table, one column per dimension with more than one category (named by its
+   label, the category labels as cells, kept text), then `value`, in the order of
+   `value`; see `_json_stat`. Its one-category dimensions, label, source and
+   notes become `context_lines`. The `MAX_NESTING` bracket count below applies
+   to it as to everything else. Text that starts with a bare `(` and is
    neither JSON nor a Python literal (a header such as `(in %) Land`, or prose
    in parentheses) is delimited text instead, like everything that starts
    otherwise, see `sniff_delimiter`.
@@ -83,6 +92,7 @@
 from collections.abc import Collection, Iterable, Mapping, Sequence
 from dataclasses import dataclass, field, replace
 from datetime import datetime
+from itertools import product
 from typing import Any, Literal
 
 from ..schemas import (
@@ -186,6 +196,7 @@
 _DECIMAL_COMMA = re.compile(r"[+-]?(?:[1-9][0-9]{0,2}(?:\.[0-9]{3})+|[0-9]+)(?:,[0-9]+)?")
 _THOUSANDS_DOT = re.compile(r"[+-]?(?:[1-9][0-9]{0,2}(?:\.[0-9]{3})+|[0-9]+)")
 _AMBIGUOUS_COMMA = re.compile(r"[+-]?[0-9]{1,3},[0-9]{3}")
+_INTEGER_INDEX = re.compile(r"0|[1-9][0-9]{0,8}")  # a position key of a sparse JSON-stat `value` object
 
 # A number with one unit. The number part only has to look like one here: the rules above
 # then type it. A trailing unit (`65 %`, `15,6 h`, `20°C`, `3 Std.`, `100 m²`, `12 CHF`,
@@ -265,7 +276,8 @@ class ParsedDataset:
     context_lines: list[str] = field(default_factory=list)
     """The lines `find_table` left out above and below the table (a title, an export's metadata, a source
     line, a note), each as one cleaned text line, at most `MAX_CONTEXT_CHARS` in all: the user's notes about
-    the data. Summary rows are not among them. Empty for a literal and for `find_table=False`."""
+    the data. Summary rows are not among them. Empty for `find_table=False` and for a literal, except a
+    JSON-stat dataset, whose label, source, notes and one-category dimensions are its lines (`_json_stat`)."""
 
 
 def without_context(parsed: ParsedDataset, warning: str) -> ParsedDataset:
@@ -297,7 +309,7 @@ class _Column:
     source: list[str]  # cleaned cells, as pasted
     cells: list[str]  # canonical cells for data.csv, set by the typing step
     invisible: bool = False
-    text_only: bool = False  # the `category` column of `json_pairs`: keys are names, never typed
+    text_only: bool = False  # `json_pairs` category, `json_stat` dimension: keys are names, never typed
     dtype: ColumnDtype = "text"
     unit: str | None = None  # the unit every cell carried, now part of the name
     bare: list[str] = field(default_factory=list)  # the cells the number typing read: `source`, or the number parts
@@ -336,7 +348,7 @@ def parse_dataset(text: str, *, text_columns: Collection[str] = (), find_table:
     literal = _LITERAL_START.match(stripped)
     if literal:
         assignment, body = literal.group(), stripped[literal.end() :]
-        table = _read_literal(body, warnings)
+        table = _read_literal(body, warnings, context)
         if table is None and (assignment or not body.startswith("(")):
             raise ParseError("unparseable", "the data starts like JSON or a Python literal but is neither")
         # A bare `(` that neither reader accepts is delimited text: `(in %) Land;Wert`, prose in parentheses.
@@ -615,8 +627,14 @@ def _context_lines(records: Iterable[Sequence[str]], delimiter: str | None) -> t
     return lines, False
 
 
-def _read_literal(text: str, warnings: list[str]) -> tuple[list[str], list[list[str]], SourceFormat] | None:
-    """JSON, or a Python literal when the JSON reader refuses the text, tabulated alike; None when it is neither."""
+def _read_literal(
+    text: str, warnings: list[str], context: list[str]
+) -> tuple[list[str], list[list[str]], SourceFormat] | None:
+    """JSON, or a Python literal when the JSON reader refuses the text, tabulated alike; None when it is neither.
+
+    A JSON-stat dataset (`_json_stat`) is flattened instead, its title, source, notes and
+    one-category dimensions going to `context`.
+    """
     if _too_deep(text):
         raise ParseError("unparseable", f"the data is nested more than {MAX_NESTING} levels deep")
     decoded = _decode_literal(text)
@@ -625,6 +643,9 @@ def _read_literal(text: str, warnings: list[str]) -> tuple[list[str], list[list[
     data, repeated = decoded
     if repeated:
         warnings.append(f"{_count(repeated, 'key')} repeated; only the last value of a repeated key is kept")
+    dataset = _json_stat_dataset(data)
+    if dataset is not None:
+        return _json_stat(dataset, warnings, context)
     return _tabulate(data, warnings)
 
 
@@ -805,6 +826,212 @@ def _json_cell(value: object, position: int) -> str:
     )
 
 
+# --- JSON-stat ---------------------------------------------------------------------------
+
+
+def _json_stat_dataset(data: Any) -> dict[Any, Any] | None:
+    """The JSON-stat dataset in `data`, None when `data` is no JSON-stat document.
+
+    A JSON-stat 2.0 dataset is an object with a `dimension` object and a `value`, marked by
+    `"class": "dataset"` or, as in some 1.x-style responses, by a top-level `id`. A JSON-stat 1.x
+    bundle (`{"<name>": {"dimension": ..., "value": ...}}`) yields its dataset when it holds one.
+    A 2.0 collection or dimension, or a bundle of several datasets, holds no single table:
+    `unparseable`. Anything else (`{"class": "a"}` is an object of values) is None and goes to
+    `_tabulate` as before.
+    """
+    if not isinstance(data, dict) or not data:
+        return None
+    kind = data.get("class")
+    if isinstance(data.get("dimension"), dict) and "value" in data and (kind == "dataset" or "id" in data):
+        return data
+    if kind == "collection" and isinstance(data.get("link"), dict):
+        raise ParseError("unparseable", "a JSON-stat collection lists datasets but holds no values; paste one dataset")
+    if kind == "dimension" and isinstance(data.get("category"), dict):
+        raise ParseError("unparseable", "a JSON-stat dimension holds no values; paste a dataset")
+    if all(
+        isinstance(entry, dict) and isinstance(entry.get("dimension"), dict) and "value" in entry
+        for entry in data.values()
+    ):
+        if len(data) > 1:
+            raise ParseError(
+                "unparseable", f"the JSON-stat bundle holds {len(data)} datasets; paste one dataset at a time"
+            )
+        (only,) = data.values()
+        return dict(only)
+    return None
+
+
+def _json_stat_refusal(reason: str) -> ParseError:
+    return ParseError("unparseable", f"the JSON-stat dataset is inconsistent: {reason}")
+
+
+def _json_stat(
+    dataset: Mapping[Any, Any], warnings: list[str], context: list[str]
+) -> tuple[list[str], list[list[str]], SourceFormat]:
+    """A JSON-stat dataset as a long table: one column per dimension with more than one category, then `value`.
+
+    Every check comes before the rows are built: `id` and `size` name the dimensions in the
+    same order (a 1.x dataset keeps both inside `dimension`), the product of the sizes is at
+    most `MAX_ROWS` and equals the number of values (`value` as an array, or as a sparse
+    object of positions whose missing ones are empty), and every dimension lists as many
+    categories as its size (`category.index` as an array of codes or an object of code to
+    position; a dimension of one category may give only `category.label`).
+
+    A dimension's column is named by its `label` (else its id), its cells are the category
+    labels (else the codes), cleaned like the keys of `json_pairs` and kept text: `NA`
+    (Namibia) or `2024` is a name, never a missing cell or a number, and only `value` is
+    typed. A label shared by two categories in that cleaned form gets its code in
+    parentheses, with a warning. The rows run row-major over `id`, the order of `value`.
+    The value column is `value` whatever the dataset's units, and a dimension named
+    `value` in any case is renamed `<label> (dimension)` so the measure keeps the name: a measure dimension (`metric`, or a
+    component such as births and deaths) stays a column of the long table, which
+    `prepare_data` can pivot later. A dimension of one category is the same in every row,
+    so it is no column: `<label>: <category>` joins the dataset's `label`, `source` and
+    `note` lines in `context`, the notes the user pasted with the data, which the route
+    screens before any model reads them; the warning gives only their count. `status`
+    symbols are ignored, with one warning.
+    """
+    dimension = dataset["dimension"]
+    ids = dataset["id"] if "id" in dataset else dimension.get("id")
+    sizes = dataset["size"] if "size" in dataset else dimension.get("size")
+    if not isinstance(ids, (list, tuple)) or not ids or not all(isinstance(name, str) for name in ids):
+        raise _json_stat_refusal("`id` must be a list of dimension names")
+    if len(set(ids)) != len(ids):
+        raise _json_stat_refusal("`id` names a dimension twice")
+    if len(ids) > MAX_COLUMNS:
+        raise ParseError(
+            "too_many_columns", f"the dataset has {len(ids)} dimensions; at most {MAX_COLUMNS} are supported"
+        )
+    if not isinstance(sizes, (list, tuple)) or len(sizes) != len(ids):
+        raise _json_stat_refusal("`size` must give one size per dimension in `id`")
+    if not all(type(size) is int and size >= 1 for size in sizes):
+        raise _json_stat_refusal("every size must be a whole number of at least 1")
+    total = 1
+    for size in sizes:
+        total *= size
+        if total > MAX_ROWS:
+            raise ParseError("too_many_rows", f"the data has more than {MAX_ROWS:,} rows")
+
+    headers: list[str] = []
+    categories: list[list[str]] = []
+    constants: list[str] = []
+    for position, (name, size) in enumerate(zip(ids, sizes, strict=True), start=1):
+        header, cells, relabelled = _json_stat_dimension(dimension.get(name), name, size, position)
+        if size == 1:
+            constants.append(f"{header}: {cells[0]}")
+            continue
+        if (cleaned := _key_form(_clean_header(header)[0])).casefold() == PAIR_HEADERS[1]:
+            # `value` is the measure's name: a dimension labelled so would take it, or sit
+            # next to it as `Value`, and the measure would become `value_2` or lose its binding.
+            header = f"{cleaned} (dimension)"
+            warnings.append(f"column '{header}': a dimension named like the value column renamed")
+        headers.append(header)
+        categories.append(cells)
+        if relabelled:
+            warnings.append(
+                f"column '{_clip(header, MAX_COLUMN_NAME_CHARS)}': labels shared by two categories carry their codes"
+            )
+    headers.append(PAIR_HEADERS[1])
+    values = _json_stat_values(dataset.get("value"), total, len(headers) - 1)
+
+    if dataset.get("status"):
+        warnings.append("the dataset's status symbols (such as provisional or estimated) are ignored")
+    if constants:
+        warnings.append(
+            f"{_count(len(constants), 'dimension')} with a single category left out of the columns; "
+            "the notes name each one with its category"
+        )
+    notes: list[str] = []
+    for key, what in (("label", "the dataset's label"), ("source", "the dataset's source")):
+        if isinstance(dataset.get(key), str) and dataset[key].strip():
+            text = _json_text(dataset[key], what)
+            notes.append(text if key == "label" else f"Source: {text}")
+    note = dataset.get("note")
+    for line in note if isinstance(note, (list, tuple)) else [note]:
+        if isinstance(line, str) and line.strip():
+            notes.append(_json_text(line, "a note of the dataset"))
+    notes.extend(constants)
+    lines, cut = _context_lines([[line] for line in notes], None)
+    context.extend(lines)
+    if cut:
+        warnings.append(f"the dataset's notes were cut at {MAX_CONTEXT_CHARS:,} characters")
+
+    rows = [[*combination, value] for combination, value in zip(product(*categories), values, strict=True)]
+    return headers, rows, "json_stat"
+
+
+def _json_stat_dimension(entry: Any, name: str, size: int, position: int) -> tuple[str, list[str], bool]:
+    """A dimension's column name and its category labels in index order; whether codes were added to labels."""
+    where = f"dimension {position} of `id`"
+    if not isinstance(entry, dict) or not isinstance(entry.get("category"), dict):
+        raise _json_stat_refusal(f"{where} has no `category` object")
+    category = entry["category"]
+    index, labels = category.get("index"), category.get("label")
+    if labels is not None and not isinstance(labels, dict):
+        raise _json_stat_refusal(f"the `category.label` of {where} must be an object")
+    codes: list[Any]
+    if index is None:
+        if size != 1 or not isinstance(labels, dict) or len(labels) != 1:
+            raise _json_stat_refusal(f"{where} has no `category.index`")
+        codes = list(labels)
+    elif isinstance(index, (list, tuple)):
+        codes = list(index)
+    elif isinstance(index, dict):
+        positions = list(index.values())
+        if not all(type(at) is int for at in positions) or sorted(positions) != list(range(len(positions))):
+            raise _json_stat_refusal(f"the `category.index` of {where} must number its categories from 0")
+        codes = sorted(index, key=index.__getitem__)
+    else:
+        raise _json_stat_refusal(f"the `category.index` of {where} must be a list or an object")
+    if not all(isinstance(code, str) for code in codes) or len(set(codes)) != len(codes):
+        raise _json_stat_refusal(f"the categories of {where} must be distinct text codes")
+    if len(codes) != size:
+        raise _json_stat_refusal(f"{where} has {len(codes)} categories where `size` gives {size}")
+    cells: list[str] = []
+    for code in codes:
+        label = labels.get(code) if labels else None
+        if label is not None and not isinstance(label, str):
+            raise _json_stat_refusal(f"a category label of {where} is not text")
+        cells.append(_key_form(_json_text(code if label is None else label, f"a category of {where}")))
+    # Compared in the form `_build` writes (`_clean_key`, NFC), so `Other` and `Other` behind a
+    # zero-width space, which would be one category in `data.csv`, count as shared too.
+    relabelled = len(set(cells)) != len(cells)
+    if relabelled:
+        cells = [f"{cell} ({code})" for cell, code in zip(cells, codes, strict=True)]
+    title = entry.get("label")
+    header = title if isinstance(title, str) and title.strip() else name
+    return _json_text(header, f"the name of {where}"), cells, relabelled
+
+
+def _key_form(text: str) -> str:
+    """A category or a dimension name as `data.csv` holds it: cleaned like a key (`_clean_key`), in NFC."""
+    return unicodedata.normalize("NFC", _clean_key(text)[0])
+
+
+def _json_stat_values(raw: Any, total: int, position: int) -> list[str]:
+    """The cells of the value column: an array of `total` values, or a sparse object of positions to values."""
+    if isinstance(raw, (list, tuple)):
+        if len(raw) != total:
+            raise _json_stat_refusal(f"`value` holds {len(raw):,} values where `size` gives {total:,}")
+        pairs: Iterable[tuple[int, Any]] = enumerate(raw)
+    elif isinstance(raw, dict):
+        located: list[tuple[int, Any]] = []
+        for key, value in raw.items():
+            at = int(key) if isinstance(key, str) and _INTEGER_INDEX.fullmatch(key) else key
+            if type(at) is not int or not 0 <= at < total:
+                raise _json_stat_refusal("a key of the `value` object is no position within `size`")
+            located.append((at, value))
+        pairs = located
+    else:
+        raise _json_stat_refusal("`value` must be an array or an object of positions")
+    cells = [""] * total
+    for at, value in pairs:
+        if not _scalar(value):
+            raise _json_stat_refusal("a value is nested; only text, numbers and null are supported")
+        cells[at] = _json_cell(value, position)
+    return cells
+
+
 # --- Cleaning and headers ----------------------------------------------------------------
 
 
@@ -929,8 +1156,9 @@ def _type_column(column: _Column) -> None:
        that all cells share (`65 %`, `15,6 h`, `€ 5`, see `_split_units`), and the
        number parts pass rules 3 and 4 (so `007 kg` keeps its text). The cells keep
        the number; the unit goes into the column name, see `canonical_headers`.
-    6. **text**: everything else, every column without a non-missing cell, and the
-       `category` column of `json_pairs`, whose cells are the keys (`text_only`).
+    6. **text**: everything else, every column without a non-missing cell, the
+       `category` column of `json_pairs`, whose cells are the keys, and every dimension
+       column of `json_stat`, whose cells are category labels or codes (`text_only`).
     """
     column.cells = list(column.source)
     column.bare = column.source
@@ -1114,7 +1342,11 @@ def _build(
     renamed_by_breaks: list[int] = []
     for position, raw in enumerate(raw_headers):
         header, invisible, broken = _clean_header(raw)
-        text_only = source_format == "json_pairs" and position == 0  # the keys of an object are names
+        # The keys of an object of values are names, and so are JSON-stat categories (every column but
+        # the last, the measure): `NA` (Namibia), `-` or `2024` stay text, untyped and never missing.
+        text_only = (source_format == "json_pairs" and position == 0) or (
+            source_format == "json_stat" and position < len(raw_headers) - 1
+        )
         cells: list[str] = []
         for row in raw_rows:
             cell, cell_invisible = (_clean_key if text_only else _clean_cell)(row[position])
diff --git a/agents/anyplot/schemas.py b/agents/anyplot/schemas.py
index 42d4761634c..36c8f177168 100644
--- a/agents/anyplot/schemas.py
+++ b/agents/anyplot/schemas.py
@@ -79,7 +79,7 @@
 DefectText = Annotated[str, Field(min_length=1, max_length=MAX_DEFECT_TEXT_CHARS)]
 
 ColumnDtype = Literal["integer", "number", "datetime", "boolean", "text"]
-SourceFormat = Literal["csv", "tsv", "semicolon", "pipe", "json_records", "json_columns", "json_pairs"]
+SourceFormat = Literal["csv", "tsv", "semicolon", "pipe", "json_records", "json_columns", "json_pairs", "json_stat"]
 
 # The reviewer's reduced checklist: the rubric criteria it scores plus AR-09 for clipping.
 DefectId = Literal["VQ-01", "VQ-02", "VQ-03", "VQ-06", "VQ-07", "SC-01", "SC-03", "DQ-03", "AR-09"]
diff --git a/changelog.d/parser-json-stat.md b/changelog.d/parser-json-stat.md
new file mode 100644
index 00000000000..b3c9013d390
--- /dev/null
+++ b/changelog.d/parser-json-stat.md
@@ -0,0 +1,14 @@
+### Added
+
+- **The data field reads JSON-stat datasets from statistics offices.** A
+  JSON-stat 2.0 dataset as the Swiss BFS PxWeb API, Eurostat, Statistik Austria
+  or Statistics Norway answer it (and a JSON-stat 1.x bundle of one dataset) is
+  no longer refused as `unparseable`: the parser checks its sizes, categories and
+  values strictly and flattens it into one long table, a column per dimension
+  with more than one category, named by its label and holding the category
+  labels as text, then `value`, the only typed column, in the dataset's own
+  order (source format `json_stat`). The dataset's title, source and notes and
+  its dimensions of one category become the notes pasted with the data,
+  screened like any other note before the assistant reads them, so the table
+  stays long and tidy; the status symbols, the update date, the roles and the
+  extensions are not carried. (#12173)
diff --git a/docs/concepts/agent-network.md b/docs/concepts/agent-network.md
index f48b2392679..9b483a26dd8 100644
--- a/docs/concepts/agent-network.md
+++ b/docs/concepts/agent-network.md
@@ -241,7 +241,7 @@ Schemas live in `agents/anyplot/schemas.py`: `ColumnProfile{name≤64, dtype, mi
 
 ### Parse
 
-`agents/anyplot/data/parse.py` has no ADK import. Limits: UTF-8 at most 200 KB, 50 columns, 20,000 rows and 200 characters per cell. It rejects NUL and control characters, strips the BOM, applies NFC, and strips zero-width and bidi control characters. Headers are canonicalised (NFC, control characters stripped, names over 64 characters renamed, duplicates suffixed, empty names become `column_N`, each rename a warning), and the canonical names are written into `data.csv`, which is the single source of column names. Formats: JSON records, a column map, an object of values or an array of `[category, value]` pairs (the last two become the columns `category`, the keys kept as text, and `value`, source format `json_pairs`; nesting depth at most 2; a repeated key keeps its last value, with a warning), or delimited text with the delimiter sniffed from `, ; \t |`. Pasted text is rarely a bare table, so since 2026-10-14 (owner rule) the delimited reader first finds the table among the lines (`table_block`): its data rows are the lines of the most common field count with numbers or dates in the same columns, the header is the line right above the first data row, and a title, an export's metadata (Open-Meteo writes two such lines above its header) or a sentence that explains the columns above it, a source line or a note below the last data row, and up to three summary rows at the end (`Total`, `Summe`, `Mittelwert`…) are left out, each kind with one warning in the preview; the delimiter is sniffed from the first 50 lines the same way, by the table with the most values. A table without a number or date column keeps every line, as before. The lines left out above and below the table are not thrown away (owner rule of 2026-10-14): they are the user's notes about the data, kept as `ParsedDataset.context_lines`. Each left-out record becomes one text line, its fields cleaned like cells (invisible characters removed, whitespace and line breaks collapsed to one space), the empty ones dropped and the rest joined with the delimiter's display form (`, ` for a comma, `; ` for a semicolon, ` | ` for a pipe, a space for a tab), so a sentence that its commas split reads as it was pasted. Summary rows are data and never notes. All lines together hold at most 2,000 characters, the chat message cap (`MAX_MESSAGE_CHARS`), with a warning when the cap cut them. The profile and `data.csv` stay as they were; a JSON or literal paste and every re-parse of the service's own CSV (`find_table=False`) have no notes. A Python literal (`[`, `{` or `(`, also behind an assignment such as `cat_day = {...}`, which is stripped) is read like JSON with `ast.literal_eval`, which evaluates literals only; a name or a call is refused, and a bracket count that skips quoted strings and comments refuses more than 50 nesting levels before anything is evaluated. Text that starts with a bare `(` and is neither JSON nor a literal (a header such as `(in %) Land`, prose in parentheses) is delimited text as before. Everything is read as text first, then dates with explicit formats (an ambiguous day/month order is a warning), then numbers; a decimal comma is accepted only with a date guard. A column whose every cell carries the same unit (`65 %`, `15,6 h`, `€ 5`, `CHF 1.200`, also with a no-break space between number and unit) is read as numbers, the unit moving into the column name (`Anteil (%)`) through the canonical-header path, with a warning, unless the header already names the unit; a column where only some cells carry a unit, or two units, stays text, as does one whose "unit" is a month, a boolean or an ordinal suffix (`5 Jan`, `1st`). The output is a canonical `data.csv` (comma, dot decimal, ISO dates) in a session-scoped dataset store (in memory, tied to the session's lifetime, the idle sweeper and the DELETE route; never a `user:` artifact, which would outlive the session and be listable by the model), plus the profile and default bindings (role dtype match, then name similarity, each column once; roles without typed bullets stay empty and the UI asks; a role that needs values of 0 or more never takes a column with a negative value, see `agents/anyplot/data/signs.py`: role names that are magnitudes in every spec, such as `radius`, `size`, `count`, `std`, `weight`, and `value` only in part-of-whole, area and flow plots such as pie, donut, treemap, sunburst, icicle, waffle, marimekko, sankey, rose and the basic funnel, never in signed ones such as waterfall or diverging bars; a binding of one by hand stays valid and becomes a warning in the session block, the `set_bindings` result, the PUT route's `warnings` and at the page's dropdown, through the role's `non_negative` flag). `bindings.apply(session, bindings, source)` validates roles against the snapshot's data roles and columns against the profile; the PUT route (through `session_service.append_event` with a `state_delta`) and the `set_bindings` tool both call it, and both answer `409` while a run is active.
+`agents/anyplot/data/parse.py` has no ADK import. Limits: UTF-8 at most 200 KB, 50 columns, 20,000 rows and 200 characters per cell. It rejects NUL and control characters, strips the BOM, applies NFC, and strips zero-width and bidi control characters. Headers are canonicalised (NFC, control characters stripped, names over 64 characters renamed, duplicates suffixed, empty names become `column_N`, each rename a warning), and the canonical names are written into `data.csv`, which is the single source of column names. Formats: JSON records, a column map, an object of values or an array of `[category, value]` pairs (the last two become the columns `category`, the keys kept as text, and `value`, source format `json_pairs`; nesting depth at most 2; a repeated key keeps its last value, with a warning), a JSON-stat 2.0 dataset (since 2026-10-14, source format `json_stat`; see below), or delimited text with the delimiter sniffed from `, ; \t |`. JSON-stat is what statistics offices' APIs answer (the Swiss BFS PxWeb API, Eurostat, Statistik Austria, Statistics Norway): an object with `"class": "dataset"`, `id`, `size`, `dimension` and `value`; a JSON-stat 1.x bundle of one dataset is read too, a bundle of several, a collection or a lone dimension is `unparseable`. It is the one shape nested deeper than 2 (about five levels), and the 50-level bracket count still applies. The parser checks it strictly before it builds a row (as many sizes as dimensions, the product of the sizes at most 20,000 and equal to the number of values, `value` as an array or as a sparse object of positions, every dimension with as many categories as its size, `category.index` as an array or an object of positions), and refuses any mismatch as `unparseable` with a message that names no data. It flattens the dataset into a long table (owner rule: long format, no wide pivot; `prepare_data` can pivot later): one column per dimension with more than one category, named by the dimension's label (else its id), its cells the category labels (else the codes) kept as text, never typed and never missing (`NA` for Namibia stays `NA`, a year code stays text; a label two categories share gets each one's code in parentheses), then one column `value`, the only typed column, whatever the dataset's unit (a dimension named `value` in any case becomes `<label> (dimension)`, so the measure keeps the name), in the row-major order of `value`; a missing value stays empty, and `status` symbols are ignored with one warning. A dimension of one category is the same in every row, so it is no column: `<dimension>: <category>` goes into the notes (`context_lines`), after the dataset's `label`, its `source` and its `note` lines, so the pre-filter and the scope judge screen them like any pasted note; the warning only counts the dimensions left out. Pasted text is rarely a bare table, so since 2026-10-14 (owner rule) the delimited reader first finds the table among the lines (`table_block`): its data rows are the lines of the most common field count with numbers or dates in the same columns, the header is the line right above the first data row, and a title, an export's metadata (Open-Meteo writes two such lines above its header) or a sentence that explains the columns above it, a source line or a note below the last data row, and up to three summary rows at the end (`Total`, `Summe`, `Mittelwert`…) are left out, each kind with one warning in the preview; the delimiter is sniffed from the first 50 lines the same way, by the table with the most values. A table without a number or date column keeps every line, as before. The lines left out above and below the table are not thrown away (owner rule of 2026-10-14): they are the user's notes about the data, kept as `ParsedDataset.context_lines`. Each left-out record becomes one text line, its fields cleaned like cells (invisible characters removed, whitespace and line breaks collapsed to one space), the empty ones dropped and the rest joined with the delimiter's display form (`, ` for a comma, `; ` for a semicolon, ` | ` for a pipe, a space for a tab), so a sentence that its commas split reads as it was pasted. Summary rows are data and never notes. All lines together hold at most 2,000 characters, the chat message cap (`MAX_MESSAGE_CHARS`), with a warning when the cap cut them. The profile and `data.csv` stay as they were; a JSON or literal paste (except JSON-stat) and every re-parse of the service's own CSV (`find_table=False`) have no notes. A Python literal (`[`, `{` or `(`, also behind an assignment such as `cat_day = {...}`, which is stripped) is read like JSON with `ast.literal_eval`, which evaluates literals only; a name or a call is refused, and a bracket count that skips quoted strings and comments refuses more than 50 nesting levels before anything is evaluated. Text that starts with a bare `(` and is neither JSON nor a literal (a header such as `(in %) Land`, prose in parentheses) is delimited text as before. Everything is read as text first, then dates with explicit formats (an ambiguous day/month order is a warning), then numbers; a decimal comma is accepted only with a date guard. A column whose every cell carries the same unit (`65 %`, `15,6 h`, `€ 5`, `CHF 1.200`, also with a no-break space between number and unit) is read as numbers, the unit moving into the column name (`Anteil (%)`) through the canonical-header path, with a warning, unless the header already names the unit; a column where only some cells carry a unit, or two units, stays text, as does one whose "unit" is a month, a boolean or an ordinal suffix (`5 Jan`, `1st`). The output is a canonical `data.csv` (comma, dot decimal, ISO dates) in a session-scoped dataset store (in memory, tied to the session's lifetime, the idle sweeper and the DELETE route; never a `user:` artifact, which would outlive the session and be listable by the model), plus the profile and default bindings (role dtype match, then name similarity, each column once; roles without typed bullets stay empty and the UI asks; a role that needs values of 0 or more never takes a column with a negative value, see `agents/anyplot/data/signs.py`: role names that are magnitudes in every spec, such as `radius`, `size`, `count`, `std`, `weight`, and `value` only in part-of-whole, area and flow plots such as pie, donut, treemap, sunburst, icicle, waffle, marimekko, sankey, rose and the basic funnel, never in signed ones such as waterfall or diverging bars; a binding of one by hand stays valid and becomes a warning in the session block, the `set_bindings` result, the PUT route's `warnings` and at the page's dropdown, through the role's `non_negative` flag). `bindings.apply(session, bindings, source)` validates roles against the snapshot's data roles and columns against the profile; the PUT route (through `session_service.append_event` with a `state_delta`) and the `set_bindings` tool both call it, and both answer `409` while a run is active.
 
 ### Adapt and validate
 
diff --git a/docs/reference/api.md b/docs/reference/api.md
index 9f5fe76b9ff..94fe98dc063 100644
--- a/docs/reference/api.md
+++ b/docs/reference/api.md
@@ -486,7 +486,7 @@ The routes mirror the agents service's `/v1` API. All paths below start with
 | `GET /eligibility?spec=&library=` | Spec id and library id | The agents service's answer, passed through |
 | `POST /sessions` | `{spec_id, library, locale}` | `{session_id, eligibility}`; `404 not_found` when the spec has no implementation for the library |
 | `POST /sessions/{sid}/library` | `{spec_id, library}` | Switches the library; the dataset and bindings stay |
-| `POST /sessions/{sid}/dataset` | `{text, confirmed?}`, at most 200 KB (204,800 bytes) of UTF-8 | `{preview, profile, bindings, warnings, context_lines, roles, suggestion, version, language}` for a table, stored as version 1 of the data (an earlier paste's undo history is dropped; `suggestion` is the wide-table offer or `null`, see [Data changes](#data-changes); `language` is the session language as `{language, source}` after the paste, see [Session language](#session-language)): CSV, TSV, semicolon or pipe text; JSON as an array of records, an object of column lists, an object of values or an array of `[category, value]` pairs (the last two become the columns `category`, the keys kept as text, and `value`; a repeated key keeps its last value with a warning); the same shapes as a Python literal, also behind an assignment such as `cat_day = {...}`, with single quotes, trailing commas and tuples (text that starts with a bare `(` and is no literal is read as delimited text); a column whose every cell carries the same unit (`65 %`, `15,6 h`, `€ 5`, also with a no-break space) is read as numbers and named `<name> (<unit>)` with a warning, unless the header already names the unit. For text that is no table (prose, a list typed one value per line) of at most 4,000 characters, `{transcribed: true, text, preview, profile, warnings, note}`, the table the judge model read, with its CSV in `text` and nothing stored: the page shows it for confirmation, and confirming posts that CSV through this route again with `confirmed: true`, which skips the free-text fallback (a one-column table would otherwise be read again) and keeps every row (no line is left out as a note or a total), never the parse, the pre-filter, the judge or the store. A pasted table may carry other lines: a title, metadata or notes above it, a source line or notes below it, and up to three summary rows at the end (`Total`, `Summe`…) are left out, each kind with one entry in `warnings`. The lines left out above and below the table (not the summary rows) come back in `context_lines`, one text line each and at most 2,000 characters in all: the notes the assistant reads with the data. They pass the same pre-filter as the cells and then the scope judge; when either refuses them, or the judge does not answer, `context_lines` is empty and `warnings` starts with the reason, while the table is stored all the same and no strike is counted. `413 too_long` above the limit, `422 unparseable` when neither the parser nor the model finds a table, `422 formula` when the text asks for a formula such as `sin(x) von -pi bis pi` or `y = x**2` (no model reads it; ask for the formula in the chat, where the assistant computes the table, see [Data changes](#data-changes)), `403 data_refused` when a header, a cell or the raw text addresses an AI (personal data such as names, addresses, e-mail addresses, phone numbers and web addresses is allowed), `503 guard_unavailable` when the judge model does not answer |
+| `POST /sessions/{sid}/dataset` | `{text, confirmed?}`, at most 200 KB (204,800 bytes) of UTF-8 | `{preview, profile, bindings, warnings, context_lines, roles, suggestion, version, language}` for a table, stored as version 1 of the data (an earlier paste's undo history is dropped; `suggestion` is the wide-table offer or `null`, see [Data changes](#data-changes); `language` is the session language as `{language, source}` after the paste, see [Session language](#session-language)): CSV, TSV, semicolon or pipe text; JSON as an array of records, an object of column lists, an object of values or an array of `[category, value]` pairs (the last two become the columns `category`, the keys kept as text, and `value`; a repeated key keeps its last value with a warning); a JSON-stat 2.0 dataset, as statistics offices' APIs answer it (or a JSON-stat 1.x bundle of one dataset), flattened into a long table with one column per dimension of more than one category, named by its label and holding the category labels as text, and a typed `value` column, the one-category dimensions and the dataset's label, source and notes coming back in `context_lines` (source format `json_stat`; an inconsistent dataset is `422 unparseable`); the same shapes as a Python literal, also behind an assignment such as `cat_day = {...}`, with single quotes, trailing commas and tuples (text that starts with a bare `(` and is no literal is read as delimited text); a column whose every cell carries the same unit (`65 %`, `15,6 h`, `€ 5`, also with a no-break space) is read as numbers and named `<name> (<unit>)` with a warning, unless the header already names the unit. For text that is no table (prose, a list typed one value per line) of at most 4,000 characters, `{transcribed: true, text, preview, profile, warnings, note}`, the table the judge model read, with its CSV in `text` and nothing stored: the page shows it for confirmation, and confirming posts that CSV through this route again with `confirmed: true`, which skips the free-text fallback (a one-column table would otherwise be read again) and keeps every row (no line is left out as a note or a total), never the parse, the pre-filter, the judge or the store. A pasted table may carry other lines: a title, metadata or notes above it, a source line or notes below it, and up to three summary rows at the end (`Total`, `Summe`…) are left out, each kind with one entry in `warnings`. The lines left out above and below the table (not the summary rows) come back in `context_lines`, one text line each and at most 2,000 characters in all: the notes the assistant reads with the data. They pass the same pre-filter as the cells and then the scope judge; when either refuses them, or the judge does not answer, `context_lines` is empty and `warnings` starts with the reason, while the table is stored all the same and no strike is counted. `413 too_long` above the limit, `422 unparseable` when neither the parser nor the model finds a table, `422 formula` when the text asks for a formula such as `sin(x) von -pi bis pi` or `y = x**2` (no model reads it; ask for the formula in the chat, where the assistant computes the table, see [Data changes](#data-changes)), `403 data_refused` when a header, a cell or the raw text addresses an AI (personal data such as names, addresses, e-mail addresses, phone numbers and web addresses is allowed), `503 guard_unavailable` when the judge model does not answer |
 | `PUT /sessions/{sid}/bindings` | `[{role, column}]`, at most 50 | The agents service's `{bindings, complete, missing_roles, warnings}`; `422 no_dataset` before a parse, `422 invalid` with the check's `errors` lines for a binding the spec roles or the columns refuse, `409 run_active` while a turn or a render is in flight. A change of the bindings drops the data confirmation below |
 | `PUT /sessions/{sid}/language` | `{language}`: a short language name or code such as `de`, `Deutsch` or `Swedish`, 1 to 40 characters that match `^[A-Za-z][A-Za-z -]{0,39}$` | The agents service's `{language, source}`, the stored form (`English` comes back as `en`, `Swedish` as typed) with the source now `chosen`: the replies and the plot text of the next version follow it, and the language a typed message implies never replaces it (see [Session language](#session-language)). Versions made before keep their text. `422` for a value outside the pattern, `409 run_active` while a turn or a render is in flight |
 | `POST /sessions/{sid}/dataset/confirm` | none | Step 1 of two: you confirm that the stored dataset and its bindings fit; `{confirmed: true, rows, columns}`. The plot pipeline runs only on confirmed data (`create_plot` before it answers `plot{status: "not_ready", reason: "data_unconfirmed"}`); a new paste, a transcription's `.use()`, a binding change, a change of the data by the assistant or an undo drops the confirmation, a library switch keeps it. `422 no_dataset` before a parse, `409 run_active` while a turn or a render is in flight |
diff --git a/tests/unit/agents/data/test_parse.py b/tests/unit/agents/data/test_parse.py
index 86d83f25e45..f59f7bb670e 100644
--- a/tests/unit/agents/data/test_parse.py
+++ b/tests/unit/agents/data/test_parse.py
@@ -10,6 +10,7 @@
 import pandas as pd
 import pytest
 
+from agents.anyplot.data.bindings import default_bindings
 from agents.anyplot.data.parse import (
     MAX_CONTEXT_CHARS,
     MAX_INPUT_BYTES,
@@ -24,6 +25,7 @@
     sniff_delimiter,
     without_context,
 )
+from agents.anyplot.data.roles import DataRole
 from agents.anyplot.schemas import (
     MAX_CELL_CHARS,
     MAX_COLUMN_NAME_CHARS,
@@ -1248,3 +1250,225 @@ def test_a_duplicate_suffix_never_cuts_into_the_unit(self) -> None:
 
         same = canonical_headers(["Anteil", "Anteil"], ["%", "%"])[0]
         assert same == ["Anteil (%)", "Anteil_2 (%)"]
+
+
+def bfs_births() -> dict[str, Any]:
+    """The BFS PxWeb answer of 2026-10-14 (births and deaths by canton, json-stat2), trimmed to three cantons."""
+    total = {"extension": {"show": "value"}}
+    return {
+        "class": "dataset",
+        "label": "Demografische Bilanz nach Kanton nach Jahr, Kanton, Staatsangehörigkeit (Kategorie), Geschlecht "
+        "und Demografische Komponente",
+        "source": "BFS - ESPOP, STATPOP - © BFS",
+        "updated": "2010-12-20T09:58:00Z",
+        "id": ["Jahr", "Kanton", "Staatsangehörigkeit (Kategorie)", "Geschlecht", "Demografische Komponente"],
+        "size": [1, 3, 1, 1, 2],
+        "dimension": {
+            "Jahr": {**total, "label": "Jahr", "category": {"index": {"2024": 0}, "label": {"2024": "2024"}}},
+            "Kanton": {
+                **total,
+                "label": "Kanton",
+                "category": {
+                    "index": {"1": 0, "2": 1, "18": 2},
+                    "label": {"1": "Zürich", "2": "Bern / Berne", "18": "Graubünden / Grigioni / Grischun"},
+                },
+            },
+            "Staatsangehörigkeit (Kategorie)": {
+                **total,
+                "label": "Staatsangehörigkeit (Kategorie)",
+                "category": {"index": {"0": 0}, "label": {"0": "Staatsangehörigkeit (Kategorie) - Total"}},
+            },
+            "Geschlecht": {
+                **total,
+                "label": "Geschlecht",
+                "category": {"index": {"0": 0}, "label": {"0": "Geschlecht - Total"}},
+            },
+            "Demografische Komponente": {
+                **total,
+                "label": "Demografische Komponente",
+                "category": {"index": {"1": 0, "2": 1}, "label": {"1": "Lebendgeburt", "2": "Todesfall"}},
+            },
+        },
+        "value": [14949, 11813, 8727, 9872, 1772, 2082],
+        "role": {"time": ["Jahr"]},
+        "version": "2.0",
+        "extension": {"px": {"decimals": 0}},
+    }
+
+
+def json_stat(ids: list[str], sizes: list[int], dimensions: dict[str, Any], value: Any, **extra: Any) -> str:
+    return json.dumps({"class": "dataset", "id": ids, "size": sizes, "dimension": dimensions, "value": value, **extra})
+
+
+def categories(*codes: str, labels: dict[str, str] | None = None) -> dict[str, Any]:
+    category: dict[str, Any] = {"index": {code: at for at, code in enumerate(codes)}}
+    if labels is not None:
+        category["label"] = labels
+    return {"category": category}
+
+
+class TestJsonStat:
+    def test_the_bfs_answer_is_a_long_table_with_its_constants_as_notes(self) -> None:
+        parsed = parse_dataset(json.dumps(bfs_births(), ensure_ascii=False))
+
+        assert parsed.profile.source_format == "json_stat"
+        assert parsed.column_dtypes == {"Kanton": "text", "Demografische Komponente": "text", "value": "integer"}
+        assert parsed.csv.splitlines() == [
+            "Kanton,Demografische Komponente,value",
+            "Zürich,Lebendgeburt,14949",
+            "Zürich,Todesfall,11813",
+            "Bern / Berne,Lebendgeburt,8727",
+            "Bern / Berne,Todesfall,9872",
+            "Graubünden / Grigioni / Grischun,Lebendgeburt,1772",
+            "Graubünden / Grigioni / Grischun,Todesfall,2082",
+        ]
+        assert parsed.context_lines == [
+            "Demografische Bilanz nach Kanton nach Jahr, Kanton, Staatsangehörigkeit (Kategorie), Geschlecht und "
+            "Demografische Komponente",
+            "Source: BFS - ESPOP, STATPOP - © BFS",
+            "Jahr: 2024",
+            "Staatsangehörigkeit (Kategorie): Staatsangehörigkeit (Kategorie) - Total",
+            "Geschlecht: Geschlecht - Total",
+        ]
+        assert warned(parsed, "3 dimensions with a single category left out of the columns")
+        assert not any("2024" in warning or "Total" in warning for warning in parsed.warnings)  # values only as notes
+
+    def test_a_header_with_special_characters_takes_the_canonical_path(self) -> None:
+        data = bfs_births()
+        data["size"] = [1, 3, 2, 1, 1]
+        data["dimension"]["Staatsangehörigkeit (Kategorie)"]["category"] = {
+            "index": ["1", "2"],
+            "label": {"1": "Schweiz", "2": "Ausland"},
+        }
+        data["dimension"]["Demografische Komponente"]["category"] = {"index": {"1": 0}, "label": {"1": "Lebendgeburt"}}
+        parsed = parse_dataset(json.dumps(data))
+
+        assert parsed.csv.splitlines()[:3] == [
+            "Kanton,Staatsangehörigkeit (Kategorie),value",
+            "Zürich,Schweiz,14949",
+            "Zürich,Ausland,11813",
+        ]
+        assert "Demografische Komponente: Lebendgeburt" in parsed.context_lines
+
+    def test_a_sparse_value_object_leaves_the_missing_positions_empty(self) -> None:
+        text = json_stat(
+            ["Land", "Jahr"],
+            [2, 2],
+            {"Land": categories("AT", "CH"), "Jahr": categories("2023", "2024")},
+            {"0": 1.5, "3": 4},
+        )
+        parsed = parse_dataset(text)
+
+        assert parsed.csv == "Land,Jahr,value\nAT,2023,1.5\nAT,2024,\nCH,2023,\nCH,2024,4.0\n"
+        assert column(parsed, "value").missing == 2
+
+    def test_an_index_array_without_labels_keeps_the_codes(self) -> None:
+        dimensions = {"geo": {"label": "Region", "category": {"index": ["AT", "DE"]}}, "unit": categories("PC")}
+        parsed = parse_dataset(json_stat(["geo", "unit"], [2, 1], dimensions, [None, 2.5]))
+
+        assert parsed.csv == "Region,value\nAT,\nDE,2.5\n"
+        assert parsed.context_lines == ["unit: PC"]
+
+    def test_a_dimension_without_a_label_is_named_by_its_id(self) -> None:
+        parsed = parse_dataset(json_stat(["sex"], [2], {"sex": categories("F", "M", labels={"F": "Frauen"})}, [1, 2]))
+
+        assert parsed.csv == "sex,value\nFrauen,1\nM,2\n"
+
+    def test_a_one_category_dimension_may_omit_its_index(self) -> None:
+        dimensions = {"t": {"category": {"label": {"2024": "2024"}}}, "g": categories("a", "b")}
+        parsed = parse_dataset(json_stat(["t", "g"], [1, 2], dimensions, [1, 2]))
+
+        assert parsed.csv == "g,value\na,1\nb,2\n" and parsed.context_lines == ["t: 2024"]
+
+    def test_every_dimension_of_one_category_leaves_one_value_row(self) -> None:
+        parsed = parse_dataset(json_stat(["t"], [1], {"t": categories("2024")}, [7]))
+
+        assert parsed.csv == "value\n7\n" and parsed.context_lines == ["t: 2024"]
+
+    def test_a_shared_label_gets_its_code_and_status_symbols_a_warning(self) -> None:
+        dimensions = {"c": categories("1", "2", labels={"1": "Other", "2": "Other"})}
+        parsed = parse_dataset(json_stat(["c"], [2], dimensions, [1, 2], status={"1": "p"}))
+
+        assert parsed.csv == "c,value\nOther (1),1\nOther (2),2\n"
+        assert warned(parsed, "labels shared by two categories carry their codes")
+        assert warned(parsed, "status symbols")
+
+    def test_a_label_shared_after_cleaning_gets_its_code(self) -> None:
+        dimensions = {"c": categories("1", "2", labels={"1": "Other", "2": f"Other{ZWSP} "})}
+        parsed = parse_dataset(json_stat(["c"], [2], dimensions, [1, 2]))
+
+        assert parsed.csv == "c,value\nOther (1),1\nOther (2),2\n"
+
+    def test_categories_stay_text_and_only_the_value_is_typed(self) -> None:
+        dimensions = {"geo": categories("NA", "-", "CH"), "year": categories("2023", "2024")}
+        parsed = parse_dataset(json_stat(["geo", "year"], [3, 2], dimensions, [1, 2, 3, 4, 5, None]))
+
+        assert parsed.column_dtypes == {"geo": "text", "year": "text", "value": "integer"}
+        assert parsed.csv.splitlines()[1:3] == ["NA,2023,1", "NA,2024,2"]
+        assert column(parsed, "geo").missing == 0 and column(parsed, "value").missing == 1
+        assert column(parsed, "geo").top == ["NA", "-", "CH"]
+
+    @pytest.mark.parametrize("label", ["value", "Value", " VALUE "])
+    def test_a_dimension_named_value_leaves_the_name_to_the_measure(self, label: str) -> None:
+        dimensions = {"v": {"label": label, **categories("1", "2")}}
+        parsed = parse_dataset(json_stat(["v"], [2], dimensions, [10, 20]))
+
+        assert list(parsed.column_dtypes) == [f"{label.strip()} (dimension)", "value"]
+        assert parsed.column_dtypes["value"] == "integer"
+        assert warned(parsed, "a dimension named like the value column renamed")
+        roles = [DataRole(name="value", kinds=("numeric",), required=True, variadic=False, description="")]
+        assert [binding.column for binding in default_bindings(roles, parsed.profile)] == ["value"]
+
+    def test_a_json_stat_1_bundle_of_one_dataset_is_read(self) -> None:
+        bundle = {"births": {"dimension": {"id": ["g"], "size": [2], "g": categories("a", "b")}, "value": [3, 4]}}
+        parsed = parse_dataset(json.dumps(bundle))
+
+        assert parsed.profile.source_format == "json_stat" and parsed.csv == "g,value\na,3\nb,4\n"
+
+    @pytest.mark.parametrize(
+        ("document", "fragment"),
+        [
+            (json_stat(["g"], [3], {"g": categories("a", "b")}, [1, 2, 3]), "has 2 categories where `size` gives 3"),
+            (json_stat(["g"], [2], {"g": categories("a", "b")}, [1, 2, 3]), "`value` holds 3 values"),
+            (json_stat(["g", "h"], [2], {"g": categories("a", "b")}, [1, 2]), "one size per dimension"),
+            (json_stat(["g"], [2], {}, [1, 2]), "has no `category` object"),
+            (json_stat(["g"], [2], {"g": categories("a", "b")}, {"2": 1}), "no position within `size`"),
+            (json_stat(["g"], [2], {"g": {"category": {"index": {"a": 0, "b": 2}}}}, [1, 2]), "number its categories"),
+            (json_stat(["g"], [0], {"g": categories()}, []), "at least 1"),
+            (json_stat(["g"], [2], {"g": categories("a", "b")}, [1, [2]]), "a value is nested"),
+            (json.dumps({"a": {"dimension": {}, "value": []}, "b": {"dimension": {}, "value": []}}), "2 datasets"),
+            (json.dumps({"class": "collection", "link": {"item": []}}), "collection"),
+        ],
+    )
+    def test_an_inconsistent_document_is_unparseable_without_quoting_it(self, document: str, fragment: str) -> None:
+        with pytest.raises(ParseError) as refused:
+            parse_dataset(document)
+
+        assert refused.value.code == "unparseable" and fragment in refused.value.message
+        assert '"a"' not in refused.value.message
+
+    def test_too_many_rows_are_refused_before_the_values_are_read(self) -> None:
+        width = MAX_ROWS // 100
+        dimensions = {"x": categories(*(str(n) for n in range(width))), "y": categories(*(str(n) for n in range(100)))}
+
+        assert parse_dataset(json_stat(["x", "y"], [width, 100], dimensions, [1] * MAX_ROWS)).profile.rows == MAX_ROWS
+        wider = {**dimensions, "x": categories(*(str(n) for n in range(width + 1)))}
+        assert error_code(json_stat(["x", "y"], [width + 1, 100], wider, [1] * (MAX_ROWS + 100))) == "too_many_rows"
+        assert error_code(json_stat(["x", "y"], [MAX_ROWS, 2], {}, [])) == "too_many_rows"  # before any dimension
+
+    def test_other_objects_with_a_class_key_keep_their_shape(self) -> None:
+        assert parse_dataset('{"class": "dataset", "rest": 3}').profile.source_format == "json_pairs"
+        assert parse_dataset('{"id": [1, 2], "value": [3, 4]}').profile.source_format == "json_columns"
+
+    def test_the_nesting_limit_is_unchanged_for_other_input(self) -> None:
+        assert error_code('{"a": ' + "[" * 60 + "]" * 60 + "}") == "unparseable"
+        nested = json.loads(json.dumps(bfs_births()))  # a normal JSON-stat document nests five levels
+        assert parse_dataset(json.dumps(nested)).profile.rows == 6
+
+    def test_the_loader_reads_the_table_back(self) -> None:
+        frame = read_back(parse_dataset(json.dumps(bfs_births())))
+
+        assert list(frame.columns) == ["Kanton", "Demografische Komponente", "value"]
+        assert (
+            str(frame["value"].dtype) == "Int64" and frame["value"].sum() == 14949 + 11813 + 8727 + 9872 + 1772 + 2082
+        )