mostlyright-data 0.15.3__tar.gz → 0.16.1__tar.gz

{mostlyright_data-0.15.3 → mostlyright_data-0.16.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mostlyright-data
-Version: 0.15.3
+Version: 0.16.1
 Summary: Mostly Right CLI for reproducible, reviewed Parquet datasets
 Project-URL: Homepage, https://mostlyright.md/
 Project-URL: Documentation, https://mostlyright.md/docs/guides/cli/
@@ -208,21 +208,33 @@ mr-data --help
 
 ## Build a dataset
 
+Register a recipe document with the sources, table schema, transformations and checks:
+
 ```bash
-mr-data probe SOURCE_ID "does this feed carry city grain before 2021"
-mr-data recipe RECIPE.json
-mr-data run RECIPE_ID --sample --max-rows 50000
-mr-data checks RUN
-mr-data download RUN --output ./out
+mr-data recipe recipe.json --json
+mr-data run --recipe RECIPE_ID --digest RECIPE_DIGEST --full
+mr-data status RUN_ID
+mr-data checks RUN_ID
+mr-data download RUN_ID --output ./out
 ```
 
-`probe` asks one registered source one question; the session behind it is opened, reused and closed
-for you. `recipe` registers one document and prints the identifiers the server derived from it.
-`run` starts a run and `mr-data status RUN`, `mr-data runs`, and `mr-data watch RUN` report on it.
-The current Harness worker executes unwindowed `sample` and `full` runs. It refuses a stated run
-window, and it does not execute `refresh`, `backfill`, promotion catch-up, or scheduled warehouse
-continuation. `mr-data promote TABLE_ID` is still the human-gated publication request, but claim a
-table is live and current only when the deployed Studio and warehouse services return that evidence.
+Use the identifiers returned by registration and run submission. `mr-data dataset create`
+creates a dataset page before a recipe is ready. `mr-data watch RUN_ID` follows a submitted run.
+
+The hosted engine executes sample, full and refresh runs. A refresh uses each source's declared
+update behavior: bounded source windows merge with retained history; snapshot sources are
+revalidated or acquired again. The table's transformations and checks run over the resulting
+source relations. URL windows may use declared query parameters or path placeholders; a fixed
+date URL does not advance automatically. Configure a correction lookback where the publisher
+can revise earlier observations.
+
+A source exposing only its current snapshot cannot supply a historical delta. It remains a
+supported source, with snapshot comparison and recomputation rather than a claim that only new
+rows were fetched. Recorded streams use their registered capture and continuation semantics.
+
+See [Recipe documents](docs/RECIPE-DOCUMENT.md) for source-window and bootstrap contracts.
+`mr-data promote TABLE_ID` requests publication; claim a table is live and current only when
+Studio returns that evidence.
 
 ## There is no local execution
 
@@ -252,7 +264,9 @@ Use `mr-data --help` for the full command list and options. Commands that suppor
 
 - Weather Reader versions 1 and 2 accept one extracted GRIB2 record and refuse a multi-record GFS
   or HRRR file. Version 3 reads a bounded collection and selects exactly one sealed record.
-- Hosted credential-free acquisition supports one single-address public HTTPS object. Bounded collections have no hosted route, and the route they used to have was the deleted local one.
+- A single-address credential-free public HTTPS source uses the reviewed hosted route. Bounded
+  collections have no route at all; the retired local lane was their only route.
+- A recipe supports up to 256 declared sources. Source count is separate from bounded request concurrency and resource limits. Existing source adapters and Readers retain their own format, pagination, byte, row and credential contracts; a URL collection is not an implicit permission to crawl arbitrary links.
 - A keyed stream venue is named by a credential reference the backend holds, never by a value. No command flag takes a secret as an argument. Venues reached over an actual WebSocket are covered; a venue whose credential comes from an interactive human login, or that is not WebSocket at all, is not.
 
 ## Verification
@@ -267,7 +281,7 @@ before review or merge.
 ## Development
 
 ```bash
-uv sync --locked --extra dev
+uv sync --locked --extra dev --extra local-search-neural
 ```
 
 The test suite drives the execution engine in-process, and requires Linux for the worker-boundary

{mostlyright_data-0.15.3 → mostlyright_data-0.16.1}/README.md

@@ -45,21 +45,33 @@ mr-data --help
 
 ## Build a dataset
 
+Register a recipe document with the sources, table schema, transformations and checks:
+
 ```bash
-mr-data probe SOURCE_ID "does this feed carry city grain before 2021"
-mr-data recipe RECIPE.json
-mr-data run RECIPE_ID --sample --max-rows 50000
-mr-data checks RUN
-mr-data download RUN --output ./out
+mr-data recipe recipe.json --json
+mr-data run --recipe RECIPE_ID --digest RECIPE_DIGEST --full
+mr-data status RUN_ID
+mr-data checks RUN_ID
+mr-data download RUN_ID --output ./out
 ```
 
-`probe` asks one registered source one question; the session behind it is opened, reused and closed
-for you. `recipe` registers one document and prints the identifiers the server derived from it.
-`run` starts a run and `mr-data status RUN`, `mr-data runs`, and `mr-data watch RUN` report on it.
-The current Harness worker executes unwindowed `sample` and `full` runs. It refuses a stated run
-window, and it does not execute `refresh`, `backfill`, promotion catch-up, or scheduled warehouse
-continuation. `mr-data promote TABLE_ID` is still the human-gated publication request, but claim a
-table is live and current only when the deployed Studio and warehouse services return that evidence.
+Use the identifiers returned by registration and run submission. `mr-data dataset create`
+creates a dataset page before a recipe is ready. `mr-data watch RUN_ID` follows a submitted run.
+
+The hosted engine executes sample, full and refresh runs. A refresh uses each source's declared
+update behavior: bounded source windows merge with retained history; snapshot sources are
+revalidated or acquired again. The table's transformations and checks run over the resulting
+source relations. URL windows may use declared query parameters or path placeholders; a fixed
+date URL does not advance automatically. Configure a correction lookback where the publisher
+can revise earlier observations.
+
+A source exposing only its current snapshot cannot supply a historical delta. It remains a
+supported source, with snapshot comparison and recomputation rather than a claim that only new
+rows were fetched. Recorded streams use their registered capture and continuation semantics.
+
+See [Recipe documents](docs/RECIPE-DOCUMENT.md) for source-window and bootstrap contracts.
+`mr-data promote TABLE_ID` requests publication; claim a table is live and current only when
+Studio returns that evidence.
 
 ## There is no local execution
 
@@ -89,7 +101,9 @@ Use `mr-data --help` for the full command list and options. Commands that suppor
 
 - Weather Reader versions 1 and 2 accept one extracted GRIB2 record and refuse a multi-record GFS
   or HRRR file. Version 3 reads a bounded collection and selects exactly one sealed record.
-- Hosted credential-free acquisition supports one single-address public HTTPS object. Bounded collections have no hosted route, and the route they used to have was the deleted local one.
+- A single-address credential-free public HTTPS source uses the reviewed hosted route. Bounded
+  collections have no route at all; the retired local lane was their only route.
+- A recipe supports up to 256 declared sources. Source count is separate from bounded request concurrency and resource limits. Existing source adapters and Readers retain their own format, pagination, byte, row and credential contracts; a URL collection is not an implicit permission to crawl arbitrary links.
 - A keyed stream venue is named by a credential reference the backend holds, never by a value. No command flag takes a secret as an argument. Venues reached over an actual WebSocket are covered; a venue whose credential comes from an interactive human login, or that is not WebSocket at all, is not.
 
 ## Verification
@@ -104,7 +118,7 @@ before review or merge.
 ## Development
 
 ```bash
-uv sync --locked --extra dev
+uv sync --locked --extra dev --extra local-search-neural
 ```
 
 The test suite drives the execution engine in-process, and requires Linux for the worker-boundary

{mostlyright_data-0.15.3 → mostlyright_data-0.16.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mostlyright-data"
-version = "0.15.3"
+version = "0.16.1"
 description = "Mostly Right CLI for reproducible, reviewed Parquet datasets"
 readme = "README.md"
 requires-python = ">=3.13,<3.14"

{mostlyright_data-0.15.3 → mostlyright_data-0.16.1}/skills/mr-data-build/SKILL.md

@@ -115,7 +115,7 @@ gap rather than doing anything, and `export-hosted-candidate`, which is a backen
 | `mr-data dataset` | Bring the dataset page into existence before there is anything on it, then fill it in while somebody watches. `dataset create --name TEXT` mints it and prints the `dataset_id`; `dataset show ID` reads it back; `dataset set ID --name TEXT --description-file F` writes the title and the description under the version it was read at, retrying once if somebody else wrote first; `dataset note ID --heading H --blocks-file B` writes one cell of the decision record that OUTLIVES every run, and `--list` reads it back; `dataset watch ID` follows the page's own event stream; `dataset activity ID --phase P --message TEXT` says what is happening right now, silently, and is never a chat message and never a cell; `dataset archive ID --confirm-name TITLE` retires the page and frees its title, deleting nothing. |
 | `mr-data recipe` | Register one recipe document — dataset, question, table plan, sources, transform, checks and units — in one call, and print the identifiers the server derived. `mr-data recipe show ID` reads one back. |
 | `mr-data cover` | Generate and attach one branded 1200×630 dataset cover. Give it the dataset ID and what the image should depict; Studio fixes the model, single-color style, curated random palette, dimensions and storage. |
-| `mr-data run` | Start one run against a registered recipe, named as `--recipe RECIPE_ID --digest RECIPE_DIGEST` — both required, neither positional, and the digest is the bare hex the registration receipt printed. The command accepts `--sample`, `--full`, `--refresh`, `--backfill` and `--window`, and the worker executes `--sample`, `--full` and `--refresh` (a refresh re-acquires the declared addresses over the previous version and claims no window); `--backfill` and a `--window` on a sample or full are refused before acquisition. `--max-rows` and `--max-source-bytes` remain supported, and each bounds ONE SOURCE rather than the finished table. A large run is held for a spend confirmation, which `--confirm` settles; a sample-first held full requires Studio's interactive human approval instead. `--cancel RUN` stops one. |
+| `mr-data run` | Start one run against a registered recipe, named as `--recipe RECIPE_ID --digest RECIPE_DIGEST` — both required, neither positional, and the digest is the bare hex the registration receipt printed. The command accepts `--sample`, `--full`, `--refresh`, `--backfill` and `--window`, and the worker executes `--sample`, `--full` and `--refresh`. A refresh narrows each source that declares a supported address window and merges its returned relation into retained source state; unwindowed sources are conditionally revalidated or re-acquired whole, then the full declared transform runs. `--backfill` and a `--window` on a sample or full are refused before acquisition. `--max-rows` and `--max-source-bytes` remain supported, and each bounds ONE SOURCE rather than the finished table. A large run is held for a spend confirmation, which `--confirm` settles; a sample-first held full requires Studio's interactive human approval instead. `--cancel RUN` stops one. |
 | `mr-data status` | Report which of the seven states one run is in, what it delivered and whether a ceiling cut it short, and — on a failure — what failed and where. Exits non-zero on a failed run. |
 | `mr-data runs` | Report this workspace's own runs: identifier, mode, state and creation time, plus the failure triple of any that failed. `--status` and `--mode` narrow it and are refused for a word outside the seven or the four; `--limit` says how many, and pages are followed to reach it. |
 | `mr-data watch` | Stream one run's live progress under the durable event type of each stage, resuming across stream cuts. Exits non-zero when the run failed. |
@@ -745,10 +745,10 @@ which is the other reason the search belongs there.
 protocol, on `--sample`, `max_rows` and `window` truncate: the run succeeds at the clamp boundary
 and reports the coverage it actually delivered. `max_source_bytes` refuses in every mode, sample
 included, and on `full`, `refresh` and `backfill`, hitting any clamp is a refusal with
-`CLAMP_EXCEEDED`. The current worker admits `sample`, `full` and `refresh` (unwindowed in effect) and refuses `backfill` before applying
-those dispositions. Therefore an executable sample may truncate on `max_rows`; an executable full
-refuses a crossed row or byte ceiling; every stated window, refresh, and backfill is refused before
-a byte is fetched.
+`CLAMP_EXCEEDED`. The current worker admits `sample`, `full` and `refresh` and refuses `backfill` before applying
+those dispositions. A declared supported source window narrows that source's refresh request; it
+does not make every source or connector incremental. Therefore an executable sample may truncate
+on `max_rows`, and an executable full or refresh refuses a crossed row or byte ceiling.
 
 **A succeeded run carries `coverage`, and `truncated` is required on every entry.** That is how a
 complete acquired response is told from one cut at fifty thousand rows without opening the
@@ -760,11 +760,14 @@ the record — `mr-data run --recipe RECIPE_ID --digest RECIPE_DIGEST --full --c
 held answer prints back as `confirm_command`. Any authenticated surface of the paying workspace may
 settle it. `mr-data run --cancel RUN_ID` stops a run that is queued or running.
 
-Do not treat the accepted command vocabulary as execution evidence. A `refresh` restores the
-previous version, re-acquires the declared addresses in full and seals the next version, claiming
-no coverage window -- it is how an enabled table's catch-up and its scheduled refresh run. A
-`backfill` is defined by the exact window it covers, which this worker cannot narrow a source
-request to, and is refused before acquisition.
+Do not treat the accepted command vocabulary as execution evidence. Author a source window only
+when the publisher has a truthful bounded date endpoint: use query names by default or exact
+`{parameter}` markers in its path, retain a correction lookback, and keep historical sources
+revalidatable unless an explicit closure contract says they cannot change. A refresh merges each
+windowed source slice into retained source state and recomputes the complete transform; unrelated
+snapshot sources are conditionally revalidated or re-acquired as needed. Cursor, pagination and
+new-file discovery need their own supported source contract and must not be represented as a date
+window. A `backfill` remains refused before acquisition.
 
 ### 6. Interrogate — ask the run what it actually delivered
 
@@ -1276,12 +1279,12 @@ the source again. Do not lock a schedule on your own judgement — it is the sam
 promotion, and it belongs to the user.
 
 This call is a publication request, not proof of data continuation. The current Harness worker
-cannot execute the catch-up backfill, refresh mode, or windowed acquisition needed to close the
-idle interval after the last successful run. It also does not attach or execute a warehouse
-schedule. Another deployed Studio or warehouse component may do that work, but only its returned
-state and durable run evidence support a claim that the table is live, caught up, or refreshing.
-If that evidence is absent, report that publication was requested and that ongoing freshness is
-unavailable; do not imply that promotion filled the gap.
+can execute a supported refresh, including declared source windows, but it does not make a frozen
+date, a generic cursor or a file listing advance by inference. It also does not attach or execute a
+warehouse schedule. Another deployed Studio or warehouse component may do that work, but only its
+returned state and durable run evidence support a claim that the table is live, caught up, or
+refreshing. If that evidence is absent, report that publication was requested and that ongoing
+freshness is unavailable; do not imply that promotion filled the gap.
 
 `mr-data pin TABLE_ID --version VERSION_ID` freezes the pointer on an exact version for a rollback
 or a hold, `mr-data unpin TABLE_ID` resumes tracking, and `mr-data demote TABLE_ID` detaches the

{mostlyright_data-0.15.3 → mostlyright_data-0.16.1}/src/mostlyright/data_harness/acquisition/http.py

@@ -3834,3 +3834,22 @@ def _require_snapshot_fd_bytes(
             "SNAPSHOT_COLLISION",
             "existing content-addressed snapshot bytes differ",
         )
+    # A write can land in an earlier chunk after that chunk was hashed.  Metadata alone cannot
+    # close that interval: some filesystems expose timestamps too coarsely for a same-size write.
+    # Re-read positionally and compare against the caller-owned expected bytes, preserving the
+    # first pass's bounded memory use and never advancing this descriptor's stream position.
+    offset = 0
+    while offset < expected_length:
+        try:
+            repeated = os.pread(file_descriptor, min(65_536, expected_length - offset), offset)
+        except OSError as error:
+            raise AcquisitionSecurityError(
+                "SNAPSHOT_COLLISION",
+                "existing content-addressed snapshot could not be re-read",
+            ) from error
+        if not repeated or repeated != expected[offset : offset + len(repeated)]:
+            raise AcquisitionSecurityError(
+                "SNAPSHOT_COLLISION",
+                "existing content-addressed snapshot bytes changed during validation",
+            )
+        offset += len(repeated)

{mostlyright_data-0.15.3 → mostlyright_data-0.16.1}/src/mostlyright/data_harness/acquisition/parsing.py

@@ -28,6 +28,7 @@ from mostlyright.data_harness.formats import (
     FORMAT_MEDIA_TYPES,
     FORMAT_SUFFIXES,
 )
+from mostlyright.data_harness.source_partition import PARTITION_KEYS, source_partition_day
 
 # Read from the single closed table in ``mostlyright.data_harness.formats``; this module
 # keeps the private names it has always used so its call sites are unchanged.
@@ -441,6 +442,215 @@ def parse_csv_evidence(
     )
 
 
+def parse_ndjson_evidence(
+    content: bytes,
+    *,
+    media_type: str,
+    filename: str,
+    limits: ParseLimits,
+) -> ParsedTabularEvidence:
+    """Stream one NDJSON verification pass: the admissions of the drained parse, record by record.
+
+    The second streaming pass, and the reason :data:`STREAMED_EVIDENCE_FORMATS` is a table rather
+    than the word ``csv``.  It serves NDJSON acquired over public or authenticated HTTPS, which is
+    the lane that reaches ``InProcessPublicHttpsAdapter._confined_read``, and a replayed WebSocket
+    capture, which reaches it through ``v4_stream_recording.RecordedStreamAdapter``.  That second
+    caller still needs rows, but only one per sealed batch, so it drains each batch on its own
+    and reads the concatenation through this pass alone.
+
+    WHAT IT ACTUALLY BUYS, MEASURED INSIDE THIS FUNCTION WITH ``tracemalloc``, WHICH IS NOT THE
+    SAME QUANTITY THE BENCHMARK REPORTS.  Every figure in this paragraph is the peak of the Python
+    objects THIS PASS allocates.  It is deliberately not the number
+    ``evidence/acquisition-ceiling-benchmark.macos-arm64.json`` carries: that file records the
+    CHILD'S peak resident set (``ru_maxrss``), which also holds the interpreter, the PyArrow
+    import and the allocator's own slack.  The two registers are reconciled at the end of this
+    paragraph, because reading one as the other is how a later change came to claim a memory win
+    twice the size of the real one.
+
+    No list of decoded records and no tuple of rows is ever built, where the drained
+    ``_parse_json`` holds BOTH at once.  On a four-column order-book shape that is 2.87x the
+    source against 10.95x at 320k records, and the ratio is what moves rather than the growth:
+    this pass is NOT constant in the number of records and saying so would be false.
+    ``text.splitlines()`` materialises every line of the document, so the peak grows linearly with
+    the row count exactly as the drained parse's does -- 2.89x at 50k records and 2.87x at 320k,
+    against 11.12x and 10.95x drained.  It is flat from 50k up rather than at every size: at 5k
+    records the pass's own constant costs are still visible and it reads 3.46x.  The shape moves
+    it too -- the benchmark's seven-column frame reads 2.38x against 9.04x at 320k -- so the pair
+    is quoted together or neither number means anything.
+
+    RECONCILING THE TWO REGISTERS, ONCE, HERE.  Function-level 2.87x and the child's 7.33x for the
+    same read are both honest: the child's reading adds a large fixed cost that no source byte
+    pays for.  That cost is common to BOTH operations, so it raises both multipliers and
+    COMPRESSES the ratio between them -- this pass is worth 3.8x at the function level and 2.0x
+    measured as the child's peak on the order-book shape.  A caller sizing a confined read wants
+    the child's number; a reader asking what this function holds wants this one.
+
+    THE LINE LIST IS REQUIRED, NOT AN OVERSIGHT.  ``_parse_json`` numbers its records by
+    ``str.splitlines()``, which breaks on U+2028, U+0085 and the vertical tab as well as on the
+    newline.  A reader that split the bytes on ``\n`` would find a different number of records in
+    the same document and refuse at different record numbers, which is the parity this pass exists
+    to hold.  So the trade is deliberate: the same line list, and just over a quarter of what this
+    function allocates, at a fetch ceiling 2.25 times higher.  Both halves of that trade are in
+    the ``tracemalloc`` register named above; the child-level statement of the same trade is the
+    one in ``sandbox.py`` beside ``STREAMING_OPERATIONS``, and it is the one to quote when the
+    question is what a confined read costs.
+
+    THE REFUSALS ARE ``_parse_json``'s OWN, AT THE SAME RECORDS, IN THE SAME ORDER, and preserving
+    that order is most of this function.  The drained parse reads every line into a list before it
+    asks a single question about shape, so its refusals fall in four groups that do not interleave:
+    the per-line group (the row budget, then a line that is not JSON), then the whole-document
+    group (an empty document, then a member that is not an object), then the per-record group (the
+    nesting budget, the first-record schema, the field budget), then the table group (the cell
+    budget).  A pass that raised each fault where it found it would report the SECOND group's
+    fault only when no later line carried a FIRST group's, and would report a third-group fault
+    that the drained parse never reaches at all.
+
+    So only the per-line group raises where it is found -- it is the group the drained parse also
+    resolves before anything else -- and every later group is recorded and raised after the last
+    line has been read, in the drained parse's own order.  That is the same deferral
+    :func:`parse_csv_evidence` applies to the total-cell budget, applied to three more groups
+    because NDJSON has three more questions that are asked about the document rather than the row.
+
+    The row digest is fed to the hash incrementally, by the framing
+    :func:`row_digest_for` uses, for the reason stated there.
+    """
+
+    _admit_tabular_input(content, data_format="ndjson", media_type=media_type, filename=filename)
+    if not content or len(content) > limits.max_input_bytes:
+        raise AcquisitionSecurityError(
+            "PARSE_INPUT_LIMIT",
+            "source bytes are empty or exceed the parser input budget",
+        )
+    if any(content.startswith(magic) for magic in _ARCHIVE_OR_EXECUTABLE_MAGICS):
+        raise AcquisitionSecurityError(
+            "PARSE_FORBIDDEN_CONTAINER",
+            "archives, executables, documents, and nested containers are forbidden",
+        )
+    # No NUL check, deliberately.  ``_parse_csv`` makes one and ``_parse_json`` does not, so a
+    # NUL inside an NDJSON string reaches the decoder in the drained parse and must reach it
+    # here; adding the CSV check would refuse a document the drained read admits.
+    text = _strict_utf8(content)
+    decoder = json.JSONDecoder(
+        object_pairs_hook=_unique_object,
+        parse_constant=lambda value: _invalid_json_number(value),
+    )
+
+    columns: tuple[str, ...] = ()
+    expected: set[str] = set()
+    observed_types: list[set[str]] = []
+    row_hash = hashlib.sha256()
+    row_count = 0
+    hashed_rows = 0
+    # The deferred groups, in the order the drained parse resolves them.  ``not_an_object`` and
+    # an exhausted loop with ``row_count`` still zero are the whole-document group; the two
+    # ``AcquisitionSecurityError`` slots hold a refusal that is RE-RAISED rather than rebuilt, so
+    # the sentence a person is told is the drained parse's own down to the record number in it.
+    not_an_object = False
+    no_columns: AcquisitionSecurityError | None = None
+    record_refusal: AcquisitionSecurityError | None = None
+    over_cell_budget = False
+    canonical_error: CanonicalJSONError | None = None
+
+    for line_number, line in enumerate(text.splitlines(), start=1):
+        if not line.strip():
+            continue
+        if row_count >= limits.max_rows:
+            raise AcquisitionSecurityError("PARSE_ROW_LIMIT", "NDJSON exceeds the row budget")
+        try:
+            record = decoder.decode(line)
+        except json.JSONDecodeError:
+            raise AcquisitionSecurityError(
+                "PARSE_JSON",
+                f"NDJSON line {line_number} is malformed",
+            ) from None
+        row_count += 1
+        if not isinstance(record, dict):
+            not_an_object = True
+        # Nothing below this line can win against a fault already recorded above it, so the work
+        # is skipped rather than done and discarded.  That is what keeps the deferral from costing
+        # a full validation pass over a document whose first question already has an answer.
+        if not_an_object or no_columns is not None or record_refusal is not None:
+            continue
+        if not columns:
+            try:
+                columns = _columns(list(record), limits)
+            except AcquisitionSecurityError as error:
+                no_columns = error
+                continue
+            expected = set(columns)
+            observed_types = [set() for _ in columns]
+            row_hash.update(b'{"columns":' + canonical_json_bytes(list(columns)) + b',"rows":[')
+        try:
+            _validate_json_value(record, depth=1, limits=limits)
+            if set(record) != expected:
+                raise AcquisitionSecurityError(
+                    "PARSE_ROW_SCHEMA",
+                    f"JSON row {row_count} does not match the first-row schema",
+                )
+            row = tuple(record[column] for column in columns)
+            _validate_row(row, limits)
+        except AcquisitionSecurityError as error:
+            record_refusal = error
+            continue
+        if row_count * len(columns) > limits.max_total_cells:
+            over_cell_budget = True
+        # A value the canonical encoder refuses keeps the position the one-shot digest gave it:
+        # after every parse refusal and the cell budget, never mid-loop.  The hash is dead on that
+        # path, so it stops accumulating with the first error.
+        if canonical_error is None:
+            try:
+                encoded_row = canonical_json_bytes(list(row))
+            except CanonicalJSONError as error:
+                canonical_error = error
+            else:
+                if hashed_rows:
+                    row_hash.update(b",")
+                row_hash.update(encoded_row)
+                hashed_rows += 1
+        for index, value in enumerate(row):
+            observed_types[index].add("null" if value is None else type(value).__name__)
+
+    if not_an_object:
+        raise AcquisitionSecurityError("PARSE_JSON_SHAPE", "every JSON row must be an object")
+    if not row_count:
+        raise AcquisitionSecurityError(
+            "PARSE_JSON_SHAPE",
+            "JSON tabular input must be a non-empty array of objects",
+        )
+    if no_columns is not None:
+        raise no_columns
+    if record_refusal is not None:
+        raise record_refusal
+    if over_cell_budget:
+        raise AcquisitionSecurityError("PARSE_CELL_LIMIT", "table exceeds the cell budget")
+    if canonical_error is not None:
+        # TYPED, LIKE EVERY OTHER PARSE REFUSAL HERE, and for the reason ``parse_csv_evidence``
+        # states at its own copy of this branch: raised bare it leaves this boundary as an
+        # exception nothing above can name.
+        raise AcquisitionSecurityError(
+            "PARSE_VALUE", "parsed field contains a non-canonical value"
+        ) from canonical_error
+    row_hash.update(b"]}")
+
+    return ParsedTabularEvidence(
+        data_format="ndjson",
+        input_sha256=sha256_bytes(content),
+        columns=columns,
+        row_count=row_count,
+        schema_digest=canonical_sha256(
+            {
+                "data_format": "ndjson",
+                "columns": list(columns),
+                "types": [
+                    "|".join(sorted(observed)) if observed else "empty"
+                    for observed in observed_types
+                ],
+            }
+        ),
+        row_digest=row_hash.hexdigest(),
+    )
+
+
 def parse_csv_evidence_to_file(
     source: BinaryIO,
     destination: BinaryIO,
@@ -594,7 +804,7 @@ def parse_streaming_csv_window(
         or not 1 <= max_output_bytes <= MAX_FILE_BACKED_WINDOW_BYTES
     ):
         raise AcquisitionSecurityError("WINDOW_STREAM_LIMIT", "window byte ceiling is invalid")
-    if partition_key not in {"iso_date_prefix", "iso_date_value"}:
+    if partition_key not in PARTITION_KEYS:
         raise AcquisitionSecurityError(
             "WINDOW_STREAM_PARTITION", "partition key encoding is invalid"
         )
@@ -858,9 +1068,12 @@ def _window_instant(value: object) -> datetime.datetime:
 
 
 def _partition_key_and_date(value: str, *, encoding: str) -> tuple[str, datetime.date]:
-    key = value[:10] if encoding == "iso_date_prefix" else value
-    if _ISO_DATE.fullmatch(key) is None:
-        raise AcquisitionSecurityError("WINDOW_STREAM_PARTITION", "partition key is not canonical")
+    try:
+        key = source_partition_day(value, encoding)
+    except ValueError:
+        raise AcquisitionSecurityError(
+            "WINDOW_STREAM_PARTITION", "partition key is not canonical"
+        ) from None
     try:
         parsed_date = datetime.date.fromisoformat(key)
     except ValueError: