mostlyright-data 0.17.2__tar.gz → 0.17.3__tar.gz

{mostlyright_data-0.17.2 → mostlyright_data-0.17.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mostlyright-data
-Version: 0.17.2
+Version: 0.17.3
 Summary: Mostly Right CLI for reproducible, reviewed Parquet datasets
 Project-URL: Homepage, https://mostlyright.md/
 Project-URL: Documentation, https://mostlyright.md/docs/guides/cli/

{mostlyright_data-0.17.2 → mostlyright_data-0.17.3}/pyproject.toml

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

{mostlyright_data-0.17.2 → mostlyright_data-0.17.3}/skills/mr-data-build/SKILL.md

@@ -117,7 +117,7 @@ gap rather than doing anything, and `export-hosted-candidate`, which is a backen
 | `mr-data whoami` | Use the compatibility alias for the remotely validated `auth status` answer. |
 | `mr-data clarify` | Say whether one clarifying question may be put to the user right now, and compose the record of their answer. It reaches nothing, asks nobody and waits for nothing. Exits non-zero when no person can answer or when a recipe is already registered. |
 | `mr-data probe` | Ask one registered source one question and print the answer. **Currently unusable:** it reaches `/v3/sessions`, which Studio refuses, and it takes a question identifier that no v4 receipt returns. Do not plan a source inspection around it. |
-| `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 --topics "a,b,c" --license ID --description-file F` writes the title, the categories, the SPDX licence and the description under the version it was read at, retrying once if somebody else wrote first, and an empty `--topics` or `--license` takes that value off the page; `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 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 --topics "a,b,c" --license ID --description-file F` writes the title, the categories, the SPDX licence and the description under the version it was read at, retrying once if somebody else wrote first, and an empty `--topics` or `--license` takes that value off the page; `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 publish ID [--mode public|link|private]` says who can read the dataset — `public` lists it in the public directory and serves it at an address anybody can read, `link` serves it at an unlisted address, `private` takes it back to the workspace — and `dataset publish ID --show` reads that back without changing it; `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 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. |

{mostlyright_data-0.17.2 → mostlyright_data-0.17.3}/src/mostlyright/data_harness/hosted_run_worker.py

@@ -1765,6 +1765,15 @@ class PredecessorRecord:
     #: already holds. Read leniently: a receipt sealed before the member existed states none, and
     #: a run continuing from one is left to the guards that were already there.
     recording_bookmarks: Mapping[str, str] = MappingProxyType({})
+    #: The sources whose committed state was DERIVED from a recording commitment because the
+    #: receipt stated no digest of its own for them; see :func:`_recorded_source_state`.
+    #:
+    #: It is the one place a reader can tell a version a run sealed from a version composed at a
+    #: recorder's checkpoint. A checkpoint acquires nothing -- its receipt states an empty source
+    #: list -- so a name here says the position beside it was committed by the recorder rather
+    #: than by an acquisition, which is the only lineage in which a commitment can have jumped
+    #: ahead of the rows the version holds.
+    recorded_source_states: frozenset[str] = frozenset()
 
     @property
     def layout_format_version(self) -> int:
@@ -1832,6 +1841,57 @@ def _receipt_table_record(
     }
 
 
+#: The commitment members a recorded source's committed state is derived from.
+#:
+#: CLOSED RATHER THAN "WHATEVER THE ENTRY CARRIES". The derived state is a digest, so every member
+#: folded into it decides what that digest is; taking the entry whole would let a member a later
+#: control plane adds silently change the state a source is recorded at. These five are the
+#: position and the identity of the recording it is a position in, which is the whole of what a
+#: recorded source's state consists of.
+_RECORDING_STATE_MEMBERS = (
+    "bookmark_after",
+    "connector_document_digest",
+    "recording_id",
+    "series_id",
+    "stream_id",
+)
+
+
+def _recorded_source_state(commitment: Mapping[str, Any]) -> str | None:
+    """The committed state of a source whose bytes a recorder sealed, or ``None`` for no position.
+
+    WHAT A SOURCE'S COMMITTED STATE IS, AND WHY A RECORDED ONE CANNOT BE A CONTENT DIGEST. For a
+    source read from an address the state is the digest of the bytes that run read, because those
+    bytes are what the version was built from and re-reading the address is how a successor tells
+    whether anything moved. A recorded stream has no such reading: the version is the rows of the
+    batches a recorder sealed, the successor reads the batches AFTER a position rather than the
+    same ones again, and the position is therefore the entire state -- which is exactly what the
+    receipt's ``recordings`` commitment states.
+
+    So the state is the digest of that commitment: the bookmark the version stopped at, and the
+    identity of the recording the bookmark is a position in. Two versions of one table agree here
+    only when they stopped at the same position of the same recording, which is the statement the
+    member is read for, and the value can never collide with the digest of any source's bytes.
+
+    ⚠ A VERSION COMPOSED AT A RECORDER'S CHECKPOINT STATES NO SOURCE DIGESTS AT ALL. Its receipt
+    carries an empty ``sources`` list -- nothing was fetched and no window was covered -- so a
+    successor that required a per-source digest could not number itself after it, and a stream
+    table whose live version is a checkpoint could not be continued by any run. The commitment is
+    the authenticated statement of what that version committed, and deriving the state from it is
+    what lets a refresh or a debt drain continue a lineage the recorder is writing.
+    """
+
+    after = commitment.get("bookmark_after")
+    if not isinstance(after, str) or RECORDING_BOOKMARK.fullmatch(after) is None:
+        return None
+    stated = {
+        member: commitment[member]
+        for member in _RECORDING_STATE_MEMBERS
+        if isinstance(commitment.get(member), str) and commitment[member]
+    }
+    return hashlib.sha256(canonical_json_bytes(stated)).hexdigest()
+
+
 def _decode_predecessor_receipt(raw: bytes, job: RunExecution) -> PredecessorRecord:
     """Read the authenticated receipt bytes into the record, or refuse by name."""
 
@@ -1954,6 +2014,7 @@ def _decode_predecessor_receipt(raw: bytes, job: RunExecution) -> PredecessorRec
     # entry states no `bookmark_after`, contributes nothing rather than refusing -- the successor
     # then has no rewind to compare against and behaves exactly as it did before this member.
     bookmarks: dict[str, str] = {}
+    recorded: set[str] = set()
     recordings = value.get("recordings")
     if isinstance(recordings, Mapping):
         for name, entry in recordings.items():
@@ -1962,6 +2023,15 @@ def _decode_predecessor_receipt(raw: bytes, job: RunExecution) -> PredecessorRec
             committed = entry.get("bookmark_after")
             if isinstance(committed, str) and RECORDING_BOOKMARK.fullmatch(committed) is not None:
                 bookmarks[name] = committed
+                # AND THE SAME COMMITMENT IS THE SOURCE'S COMMITTED STATE WHEN THE RECEIPT
+                # STATES NO DIGEST FOR IT; see `_recorded_source_state`. A receipt that states
+                # both keeps the digest of the bytes its own acquisition read: that reading is
+                # the stronger one wherever it exists, a derived state must never displace it,
+                # and the name is recorded only when the derivation is what supplied the state.
+                derived = _recorded_source_state(entry)
+                if derived is not None and name not in states:
+                    states[name] = derived
+                    recorded.add(name)
     evidence["recipe_digest"] = recipe_digest
     # ⚠ A CARRIED PREVIEW IS DROPPED RATHER THAN REFUSED WHEN IT IS NOT THIS WORKER'S SHAPE. The
     # member is a template a successor RE-STAMPS, so a document written under an older
@@ -2020,6 +2090,7 @@ def _decode_predecessor_receipt(raw: bytes, job: RunExecution) -> PredecessorRec
         observed_at=min(observations) if observations else None,
         source_validators=MappingProxyType(validators),
         recording_bookmarks=MappingProxyType(bookmarks),
+        recorded_source_states=frozenset(recorded),
     )
 
 
@@ -3376,6 +3447,24 @@ def _refuse_rewound_continuation(job: RunExecution, predecessor: PredecessorReco
     position PAST it is a forward gap, which is the documented and benign outcome of a rotation
     and is left alone. Below it is a rewind and refused.
 
+    ⚠ ONE REWIND IS NOT A RE-READ, AND IT IS THE ONE A RECORDER'S OWN LINEAGE PRODUCES. This
+    guard's premise is that a version covers everything up to the position it committed at. That
+    holds for every version a run sealed, and it fails for exactly one shape: a version composed
+    at a recorder's checkpoint whose commitment JUMPED, because the control plane handed the
+    table to the recorder at its own frontier rather than leaving a gap no run could ever close.
+    Such a version's commitment names ground it does not hold, the skipped batch-counter range is
+    written down as a debt, and the run that drains it is dispatched to read that range and stop
+    inside it -- so its opening position is below the commitment by construction and comparing
+    the two says nothing about duplication.
+
+    The exemption is therefore held to both halves of that shape at once, and neither alone is
+    enough. The source's committed position must come from a version that ACQUIRED NOTHING (see
+    ``recorded_source_states``: a checkpoint states no source digests, and only a checkpoint can
+    have jumped), and this run's span must CLOSE below that position -- an interval, not a
+    continuation. A span that opens below and then runs to or past the commitment is the re-read
+    of a tail, which is what a stale commitment produces, and it stays refused whatever composed
+    the predecessor.
+
     ⚠ ONLY WITHIN ONE RECORDING. The epoch half of a bookmark names the recording the counter is
     a counter in, so two positions of different recordings are not comparable at all -- and a
     successor recording is started only when no active predecessor exists and can only capture
@@ -3403,16 +3492,25 @@ def _refuse_rewound_continuation(job: RunExecution, predecessor: PredecessorReco
             continue
         # Fixed-width counters, so the text order IS the numeric order -- the same comparison
         # `_parse_recording` makes between two batches of one run.
-        if position < committed:
-            raise RunExecutionError(
-                "RUN_RECORDING_INVALID",
-                failure_detail(
-                    f"this refresh was dispatched to continue {name} from {position} while the "
-                    f"version it appends to already covers {committed}, so the batches it read "
-                    "hold rows the table already has; a re-dispatched span cannot be added"
-                ),
-                stage=_CONTINUATION_STAGE,
-            )
+        if position >= committed:
+            continue
+        reaches = job.recordings[name].expected_watermark
+        if (
+            name in predecessor.recorded_source_states
+            and _recording_epoch(reaches) == _recording_epoch(committed)
+            and reaches < committed
+        ):
+            continue
+        raise RunExecutionError(
+            "RUN_RECORDING_INVALID",
+            failure_detail(
+                f"this refresh was dispatched to continue {name} from {position} through "
+                f"{reaches} while the version it appends to already covers {committed}, so the "
+                "batches it read hold rows the table already has; a re-dispatched span cannot "
+                "be added"
+            ),
+            stage=_CONTINUATION_STAGE,
+        )
 
 
 def _refuse_multi_source_stream_continuation(

{mostlyright_data-0.17.2 → mostlyright_data-0.17.3}/src/mostlyright/data_harness/studio_boundary.py

@@ -85,7 +85,7 @@ PINNED_OPENAPI_SOURCE_SHA256 = "f2164517534e299f96449659332fc5bc0552fa7f94539c3d
 #: One line, and it stays one line: ``_replace_exactly`` in the repin matches the whole assignment
 #: as a literal and refuses on any count but one, so a wrapped constant is a constant the repin can
 #: no longer rewrite.
-PINNED_V4_OPENAPI_SOURCE_SHA256 = "fb4f245be1bc17cbf407be89855222ff2f37ee05e3d0596d782edef228268d4d"
+PINNED_V4_OPENAPI_SOURCE_SHA256 = "fe6184bc1205c73600647f6a1ad6b5ee708fd357e2b29350be0b11c0eee24bbc"
 
 _DIGEST = re.compile(r"^sha256:[0-9a-f]{64}$")
 _IMAGE_DIGEST = re.compile(r"^[a-z0-9][a-z0-9._/-]{0,254}@sha256:[0-9a-f]{64}$")

{mostlyright_data-0.17.2 → mostlyright_data-0.17.3}/src/mostlyright/data_harness/thin/router.py

@@ -116,7 +116,7 @@ HOSTED_SUMMARY = dict(
         # finished; every other authoring command edits something that already exists.
         (
             "dataset",
-            "create the page, correct it, write its record, watch it fill in, and retire it",
+            "create the page, correct it, write its record, say who can read it, and retire it",
         ),
         ("recipe", "register one whole recipe and print the identifiers the server derived"),
         ("connections", "list saved connections available for recipes"),

{mostlyright_data-0.17.2 → mostlyright_data-0.17.3}/src/mostlyright/data_harness/thin/session.py

@@ -16,6 +16,7 @@ recorded production failures on 2026-08-20.
 
 from __future__ import annotations
 
+import json
 import re
 import time
 from collections.abc import Callable, Mapping
@@ -52,6 +53,16 @@ CLOUD_TOKEN_PATH = "/api/cli/studio-token"
 #: check and Studio cannot.
 CLOUD_SESSION_HANDOFF_PATH = "/api/cli/session-handoffs"
 
+#: Cloud's own route for how one dataset is shared: read it with ``GET``, change it with ``POST``.
+#:
+#: ⚠ CLOUD RATHER THAN STUDIO, FOR A REASON THAT IS NOT THE HANDOFF'S. Making a dataset public is
+#: not one Studio call: it initialises the dataset's publication with the organization's publisher
+#: handle, flips the mode, and writes Cloud's OWN public index row and the slug that serves
+#: ``/datasets/<slug>``. Only Cloud holds all three, and it already held them for the dashboard's
+#: Share dialog -- so this route is that dialog's own decision behind the device credential, and
+#: this client sends a mode and renders what came back rather than deciding any part of it.
+CLOUD_DATASET_ACCESS_PATH = "/api/cli/datasets/{dataset_id}/access"
+
 #: The one Cloud address a Dataset has. ``mostlyright-cloud`` serves it at this route with
 #: section suffixes, and a run has no page of its own: its evidence lives on this page's Harness
 #: card, so a receipt names its run with :func:`run_dashboard_url` as a query member here rather
@@ -315,19 +326,203 @@ def open_studio_session(
     )
 
 
+#: What a stated refusal code has to look like before it is interpolated into one.
+#:
+#: The shape every code in this lane's own vocabulary has, applied to somebody else's: a leading
+#: letter, then letters, digits and underscores, bounded. It is not a check that the code is one
+#: this build knows -- Cloud may ship a code before this client learns it, and forwarding an
+#: unknown one is the point -- it is a check that what arrives is a CODE and not prose, markup or
+#: a sentence with spaces in it.
+CLOUD_REFUSAL_CODE = re.compile(r"[A-Z][A-Z0-9_]{0,63}")
+
+#: The longest sentence somebody else's service composed that this lane will repeat, and the
+#: shape it has to have. Cloud and Studio are this product's own services, so their sentence is
+#: worth showing -- and it is still text this lane did not compose, so it is bounded, has to be
+#: printable, and is quoted with its author named rather than presented as this lane's own words.
+MAX_STATED_MESSAGE_CHARS = 300
+
+
+def stated_sentence(value: Any) -> str | None:
+    """One sentence somebody else composed, admitted only when it is a sentence and not a payload.
+
+    ⚠ THE MESSAGE IS SHOWN AND THE CODE IS ACTED ON, WHICH IS THE SPLIT EVERY COMMAND IN THIS
+    LANE MAKES. A refusal a person cannot act on is a refusal they file a bug about, and the
+    useful half of a service's answer -- which capability is missing, which setting to change --
+    is in its sentence. So the sentence reaches the person, bounded and printable, and nothing
+    branches on it: what a script reads is the typed code beside it.
+    """
+
+    if not isinstance(value, str):
+        return None
+    stated = value.strip()
+    if not stated or len(stated) > MAX_STATED_MESSAGE_CHARS or not stated.isprintable():
+        return None
+    return stated
+
+
+def cloud_refusal(
+    status: int, parsed: Any, *, act: str, absent: str | None = None
+) -> ThinLaneError:
+    """One Cloud refusal, folded the way ``runs._studio_refusal`` folds Studio's.
+
+    ⚠ THE TWO ISSUERS MUST REMEDIATE THE SAME SITUATION THE SAME WAY. ``ux/remediation.py``
+    keys on the code PREFIX, so a revoked device key arriving as ``THIN_CLOUD_...`` and a
+    revoked Studio token arriving as ``THIN_AUTHORIZATION_DENIED`` sent one person to two
+    different fixes for one problem. 401 and 403 fold onto the shared code here as they do
+    there, with Cloud's own code kept in the sentence so an expired key and a refused scope
+    stay distinguishable, and ``http_status`` rides along for the same reason it does there.
+
+    ⚠ AND THE CODE CLOUD STATED IS A CODE, NOT A STRING TO INTERPOLATE. The comment this
+    replaces said "the code is a closed vocabulary" and nothing checked it, so a Cloud answer
+    of ``{"code": "<script>"}`` composed ``THIN_CLOUD_<script>`` -- a refusal code no caller
+    can branch on and no vocabulary contains. A stated code that does not look like one falls
+    through to ``THIN_CLOUD_REFUSED``, which is the answer for "Cloud stated nothing usable".
+
+    ``act`` is what this call was trying to do, written as a verb phrase, and it is THIS lane's
+    words rather than Cloud's.
+
+    ⚠ AND ``absent`` IS WHY A 404 IS NOT ONE SENTENCE FOR EVERY ROUTE. On the handoff mint a 404
+    really is "Cloud has no such route" -- a Cloud too old to serve it. On a route whose path
+    carries a dataset identifier this lane has already checked is a uuid, a 404 cannot be a
+    missing route: it is Cloud saying it holds no such dataset for this workspace. Telling that
+    person to look at a deployment would send them after a problem that does not exist, so the
+    caller states the sentence its own 404 means and the default stays the mint's.
+
+    ⚠ AND A ROUTE THAT NAMES NO CODE STILL NAMED SOMETHING. NO Cloud CLI route sends a top-level
+    ``code``: every refusal on ``/api/cli/`` -- the handoff mint's 401, 429 and 503, the dataset
+    sharing route's 400 and 403 -- is a one-line ``error`` and nothing else. So this is the branch
+    the real wire takes on both routes, and dropping the sentence folded "this key may not change
+    dataset sharing" onto the same bare words as an expired key. Where Cloud stated no code, its
+    sentence is quoted -- bounded, printable, and attributed to Cloud -- so the two stay
+    distinguishable. The ``named`` branch above stands for a Cloud that starts sending a code, not
+    for one that does. Nothing branches on the sentence; the code beside it is what a script reads.
+    """
+
+    stated = parsed.get("code") if isinstance(parsed, dict) else None
+    named = stated if isinstance(stated, str) and CLOUD_REFUSAL_CODE.fullmatch(stated) else None
+    said = (
+        stated_sentence(parsed.get("error")) if named is None and isinstance(parsed, dict) else None
+    )
+    if status in {401, 403}:
+        if named:
+            suffix = f" (Cloud said {named}, HTTP {status})"
+        elif said:
+            suffix = f" (HTTP {status}; Cloud said: {said})"
+        else:
+            suffix = ""
+        refusal = ThinLaneError(
+            "THIN_AUTHORIZATION_DENIED",
+            f"the device key does not carry the authority this call needs{suffix}",
+        )
+    elif status == 404:
+        suffix = f" (Cloud said {named})" if named else ""
+        sentence = absent or f"Cloud has no route here to {act}"
+        refusal = ThinLaneError("THIN_NOT_FOUND", f"{sentence}{suffix}")
+    elif named is not None:
+        refusal = ThinLaneError(f"THIN_CLOUD_{named}", f"Cloud refused to {act} ({named})")
+    else:
+        detail = f"Cloud answered the request to {act} with HTTP {status}"
+        refusal = ThinLaneError(
+            "THIN_CLOUD_REFUSED", f"{detail}. Cloud said: {said}" if said else detail
+        )
+    refusal.http_status = status  # type: ignore[attr-defined]
+    return refusal
+
+
+class CloudClient:
+    """One bounded call to the Cloud origin, authenticated by the device key Cloud itself issued.
+
+    NOT a :class:`~mostlyright.data_harness.thin.v4.StudioV4Client` subclass, and that is
+    structural rather than stylistic: that class carries a Studio bearer and a Studio base URL,
+    and these calls carry the DEVICE key to the CLOUD origin. Making it look like a Studio client
+    would be the first step towards somebody passing it a Studio session.
+
+    ⚠ ONE CLASS FOR EVERY CLOUD ROUTE THIS LANE CALLS, for the reason
+    :class:`~mostlyright.data_harness.thin.v4.StudioV4Client` gives about its own single ``_call``:
+    a second one would be a second place for the origin check, the byte ceiling, the credential
+    header and the refusal folding to drift. The handoff mint was the first caller and the dataset
+    sharing route is the second; both are ``self.call`` and one line of route.
+    """
+
+    def __init__(
+        self, credentials: ResolvedCloudCredentials, *, transport: Transport | None = None
+    ) -> None:
+        self._credentials = credentials
+        self._origin = service_origin(credentials.cloud_url, "Cloud URL", allow_loopback_http=False)
+        self._transport = transport or UrlLibTransport()
+
+    @property
+    def cloud_url(self) -> str:
+        return self._origin
+
+    def call(
+        self,
+        method: str,
+        path: str,
+        *,
+        act: str,
+        body: Mapping[str, Any] | None = None,
+        expected: tuple[int, ...] = (200,),
+        absent: str | None = None,
+    ) -> dict[str, Any]:
+        """Make one Cloud call and return the object it answered with, or raise the refusal.
+
+        ``expected`` is stated by the caller rather than defaulted to "anything below 400",
+        because the difference between the statuses a route can answer is the difference between
+        two things having happened: a ``200`` where a ``201`` was contracted means something other
+        than "it was created", and this client has nothing to do with anything else.
+
+        ``absent`` is what this route's own 404 means, in the caller's words; see
+        :func:`cloud_refusal` for why one sentence could not serve both routes.
+        """
+
+        headers = {
+            "Accept": "application/json",
+            "Authorization": f"Bearer {self._credentials.raw_key}",
+        }
+        encoded: bytes | None = None
+        if body is not None:
+            headers["Content-Type"] = "application/json"
+            encoded = json.dumps(dict(body), separators=(",", ":")).encode("utf-8")
+        status, raw, _headers = self._transport.request(
+            method,
+            f"{self._origin}{path}",
+            headers,
+            encoded,
+            MAX_TOKEN_RESPONSE_BYTES,
+        )
+        try:
+            parsed = parse_json(raw)
+        except CanonicalJSONError:
+            parsed = None
+        if status not in expected:
+            raise cloud_refusal(status, parsed, act=act, absent=absent)
+        if not isinstance(parsed, dict):
+            raise ThinLaneError(
+                "THIN_RESPONSE_INVALID",
+                f"Cloud answered the request to {act} without an object to read it from",
+            )
+        return parsed
+
+
 __all__ = [
     "CLOUD_APPROVAL_DASHBOARD_PATH",
+    "CLOUD_DATASET_ACCESS_PATH",
     "CLOUD_DATASET_DASHBOARD_PATH",
     "CLOUD_DATASET_RUN_QUERY_KEY",
+    "CLOUD_REFUSAL_CODE",
     "CLOUD_SESSION_HANDOFF_PATH",
     "CLOUD_TEAM_DASHBOARD_PATH",
     "CLOUD_TOKEN_PATH",
     "MAX_JSON_RESPONSE_BYTES",
+    "MAX_STATED_MESSAGE_CHARS",
     "MAX_TOKEN_RESPONSE_BYTES",
     "TOKEN_EXCHANGE_MAX_RETRY_SECONDS",
     "TOKEN_EXCHANGE_RETRY_ATTEMPTS",
+    "CloudClient",
     "StudioSession",
     "approval_dashboard_url",
+    "cloud_refusal",
     "dataset_dashboard_url",
     "dataset_research_dashboard_url",
     "is_device_key",
@@ -335,5 +530,6 @@ __all__ = [
     "require_device_key",
     "run_dashboard_url",
     "run_record_dashboard_url",
+    "stated_sentence",
     "team_dashboard_url",
 ]