A browser cannot hold a signing key
The credential model is what it holds instead, the kit’s own account of this path is the implementation, the zero-logging commitment covers what does transit us, and what it never stores is what does not.
Shipping one to a page is shipping it to every extension, every debugger, and every copy of that page’s storage.
So the browser gets a sixty-second one
Our server mints a short-lived, single-scope, user-bound token and hands it to your browser, which calls your Worker directly.
Response bodies never touch our origin on that path, and our private key never leaves our server.
sequenceDiagram
autonumber
actor You as You, an admin
participant Pane as The dashboard,<br/>in your browser
participant Ours as Our Worker
box Your Cloudflare account
participant W as Your Worker
participant DB as Your D1
end
You->>Pane: open a pane
Pane->>Ours: ask for a token for this one call
Ours->>Ours: mint it: sixty seconds, one scope,<br/>bound to you and to the body
Ours-->>Pane: the token — the private key never leaves our server
Pane->>W: call the discovered route, on pithy-control-plane
W->>DB: verify against the public key you hold
W->>DB: read the records
DB-->>W: rows
W-->>Pane: the response, straight back
Note over Ours: Response bodies never touch our origin on this path.
Pane-->>You: the pane renders
opt After an act whose outcome is reported
Pane->>Ours: report the outcome it already validated
Ours->>Ours: write an audit row — names, ids and closed states, never values
end
opt The only calls we make from our own server
Ours->>W: the connect proving ping, the key-rotation workflow,<br/>on Team the hourly alert reads,<br/>and on Enterprise the scheduled privacy reads
W-->>Ours: none of them renders a pane, and no body is kept
end
The gap in our lifeline between steps 5 and 9 is the argument: that stretch is your browser talking to your Worker, and we are not on it.
Your Worker cannot tell the difference, deliberately
A browser call and a machine call are the same token, verified by the same code.
There is no second token class to get wrong, and no route whose auth model depends on which client made the call.
What does pass through us
Four calls, and none of them renders a pane: the ping that proves a new connection answers, the key rotation that appends a successor, on Team the hourly reads alerts makes to find a failed renewal or a stopped reconcile, and on Enterprise the scheduled reads of your privacy inventory. All four are ours to start, so none can be made from a browser — only our server holds a private key, and a schedule runs when nobody has a browser open.
There is no fifth. No pane fetches through us, because there is nothing here to fetch through: the dashboard has no route that relays a response from your Worker. The alert reads are evaluated on our server and discarded; what they keep is a hash of each occurrence already mailed, and nothing from the response. The privacy reads keep the inventory itself, which names fields and never holds a value.
One kind of thing does come back to us: how an act ended. After an act such as a secret rotation, a data-subject export or a legal hold, your browser reports the outcome it already read so the act lands in our audit trail. What it never stores lists every act that reports one. Each report carries names, ids, closed states and the reason the operator typed — never a value, and nothing at all for any other kind of act.
Where a response does reach our server, the commitment is a zero-logging policy on your data — see the zero-logging commitment.
Every response is validated
A malformed, hostile, or unavailable response from your Worker must not crash a pane or reach your browser unvalidated.
That is a tested boundary rather than an assumption — your Worker is a service we do not control, and it is treated that way.
What the browser is shown
The record is one thing in full. The index lists the things of a kind. The rail names the kinds.
Left to right, always — and the triad is meaning rather than layout, so it holds whatever the things are.
Where scopes show up in the UI
Each declared route names the scope it needs, and the manifest reports what you granted.
So an action you did not grant is grayed out rather than offered and answered with a 403.
The paths are discovered, not assumed
A client that hardcoded /payments would 404 against exactly the adopters who customized anything.
Every capability’s mount point is configurable, and each builds its manifest entry from its resolved config — so the dashboard calls where things actually are.
The one address it cannot discover is the seam’s own, which is why pithy dashboard connect sends it at registration.