@tollbooth-dpyc/web 1.9.0 → 2.0.1

package/README.md

@@ -5,8 +5,9 @@ the shared code every operator front end needs, so a site holds only its own
 features. It is the peer of the `tollbooth-dpyc` Python wheel.
 
 - **npub sign-in** — a Nostr DM challenge, or an in-browser session key
-- **proofs** — the npub/`dpop_token` envelope on every paid call, a fresh
-  kind-27235 inline proof when the tab holds a session key
+- **identity on the connection** — every request signed with the tab's session
+  key (NIP-98), or carried by the tab's holder connection, whose npubs a DM
+  proved; a call names only the npub
 - **MCP client** — one shared connection to the operator, typed wrappers for
   the standard tools (balance, top-up, statement, price, profile)
 - **React components** — `AppShell` / `useAppShell`, `SiteNav`, `AccountPage`,

package/dist/client.d.ts

@@ -4,10 +4,10 @@
  * 1. One @modelcontextprotocol/sdk Client over StreamableHTTP, shared by the
  *    whole page. The SDK handles the initialize handshake and the session.
  * 2. Identity rides on the connection, invisible to callers: while this tab
- *    holds the signed-in npub's key, every request is signed with it (NIP-98)
- *    and a call names only the npub. Otherwise the DM proof token cached at
- *    `receive_npub_proof` is sent as is.
- * 3. Bootstrap tools take no envelope and are safe before sign-in.
+ *    holds the signed-in npub's key, every request is signed with it (NIP-98);
+ *    otherwise the request carries this tab's holder bearer, and the operator
+ *    holds the DM proof. A call names only the npub.
+ * 3. Bootstrap tools take no npub and are safe before sign-in.
  */
 import { type ImageBlock } from "./toolResult.ts";
 export { isNetworkError, NetworkError } from "./networkError.ts";
@@ -18,7 +18,7 @@ export declare class ProofRequiredError extends Error {
 type ProofExpiredListener = (message: string) => void;
 /**
  * Subscribe to proof bounces from anywhere in the app. Without this the tree
- * never learns the token was cleared, and the patron is stranded on a page
+ * never learns the sign-in was dropped, and the patron is stranded on a page
  * whose data will not load. Returns an unsubscribe function.
  */
 export declare function onProofExpired(cb: ProofExpiredListener): () => void;

package/dist/client.js

@@ -4,22 +4,23 @@
  * 1. One @modelcontextprotocol/sdk Client over StreamableHTTP, shared by the
  *    whole page. The SDK handles the initialize handshake and the session.
  * 2. Identity rides on the connection, invisible to callers: while this tab
- *    holds the signed-in npub's key, every request is signed with it (NIP-98)
- *    and a call names only the npub. Otherwise the DM proof token cached at
- *    `receive_npub_proof` is sent as is.
- * 3. Bootstrap tools take no envelope and are safe before sign-in.
+ *    holds the signed-in npub's key, every request is signed with it (NIP-98);
+ *    otherwise the request carries this tab's holder bearer, and the operator
+ *    holds the DM proof. A call names only the npub.
+ * 3. Bootstrap tools take no npub and are safe before sign-in.
  */
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { tollboothConfig, toolName } from "./config.js";
 import { debugPush, redact } from "./debugLog.js";
-import { clearStoredProof, forgetRecentLogin, getStoredNpub, getStoredProof, } from "./identity.js";
+import { isHolder } from "./holder.js";
+import { forgetRecentLogin, getStoredNpub } from "./identity.js";
 import { isTransportFailure, NetworkError } from "./networkError.js";
 import { signingFetch, signsForSignedInNpub } from "./requestSigning.js";
 import { errorText, deadGrantMessage, looksFailed, proofBounceMessage, readToolResult, } from "./toolResult.js";
 /**
- * Standard tools whose wheel signature takes no npub/proof envelope. Pydantic
- * strict mode rejects unexpected kwargs, so they must not get one.
+ * Standard tools whose wheel signature takes no `npub`. Pydantic strict mode
+ * rejects unexpected kwargs, so they must not get one.
  */
 const STANDARD_BOOTSTRAP = [
     "request_npub_proof",
@@ -66,20 +67,6 @@ async function getClient() {
         throw new Error("Could not connect to the service.");
     return client;
 }
-/**
- * What a call adds to prove the npub: nothing when the request itself is
- * signed with the signed-in npub's key, else the cached DM token.
- */
-function proofFor() {
-    try {
-        if (signsForSignedInNpub())
-            return {};
-    }
-    catch {
-        /* fall through to the cached token */
-    }
-    return { dpop_token: getStoredProof() };
-}
 export { isNetworkError, NetworkError } from "./networkError.js";
 /** A paid call bounced for a lapsed or missing proof. The gate re-arms sign-in. */
 export class ProofRequiredError extends Error {
@@ -91,7 +78,7 @@ export class ProofRequiredError extends Error {
 const proofExpiredListeners = new Set();
 /**
  * Subscribe to proof bounces from anywhere in the app. Without this the tree
- * never learns the token was cleared, and the patron is stranded on a page
+ * never learns the sign-in was dropped, and the patron is stranded on a page
  * whose data will not load. Returns an unsubscribe function.
  */
 export function onProofExpired(cb) {
@@ -120,13 +107,15 @@ export async function callToolWithContent(tool, args = {}, opts = {}) {
     const cfg = tollboothConfig();
     const name = toolName(tool);
     const quiet = STANDARD_QUIET.includes(tool) || cfg.quietTools.includes(tool);
-    // `args` holds only the caller's own parameters — the envelope is added
-    // below — so it is safe to log.
+    // `args` holds only the caller's own parameters — the npub is added below —
+    // so it is safe to log.
     if (!quiet)
         debugPush("call", `${name}(${redact(JSON.stringify(args)).slice(0, 140)})`);
     const bootstrap = STANDARD_BOOTSTRAP.includes(tool) || cfg.extraBootstrapTools.includes(tool);
-    const proof = bootstrap ? null : proofFor();
-    const merged = proof ? { npub: getStoredNpub(), ...proof, ...args } : { ...args };
+    const merged = bootstrap ? { ...args } : { npub: getStoredNpub(), ...args };
+    // A call this tab's holder proves rides a grant the operator keeps; a signed
+    // call proves itself afresh and has none to lose.
+    const rodeHolder = !bootstrap && isHolder() && !signsForSignedInNpub();
     let result;
     try {
         const c = await getClient();
@@ -156,16 +145,15 @@ export async function callToolWithContent(tool, args = {}, opts = {}) {
         const tail = images.length ? ` +${images.length} image` : "";
         debugPush(looksFailed(payload) ? "error" : "result", `${name} → ${redact(String(preview)).slice(0, 220)}${tail}`);
     }
-    // A stored grant the service refused for good signs the patron out even
-    // from a best-effort call: that is not a blip, and staying "signed in" on a
-    // dead grant leaves every page failing with nothing to tell them why.
+    // A held grant the service refused for good signs the patron out even from
+    // a best-effort call: that is not a blip, and staying "signed in" on a dead
+    // grant leaves every page failing with nothing to tell them why.
     const bounced = (opts.bestEffort ? null : proofBounceMessage(payload)) ??
-        (proof?.dpop_token ? deadGrantMessage(payload) : null);
+        (rodeHolder ? deadGrantMessage(payload) : null);
     if (bounced !== null) {
-        // The token just refused is the same one the recent-login shortcut
-        // would replay, so it goes too, or a returning patron re-bounces.
+        // The recent-login shortcut would re-enter on the same refused hold, so it
+        // goes too, or a returning patron re-bounces.
         const npub = getStoredNpub();
-        clearStoredProof();
         if (npub)
             forgetRecentLogin(npub);
         emitProofExpired(bounced);

package/dist/debugLog.d.ts

@@ -7,7 +7,7 @@
  * that flips the view can still be read and copied afterward.
  *
  * Every message is scrubbed on the way in: an nsec, a 64-hex key, a bearer
- * token, the value of any secret-named field (dpop_token, proof, poison,
+ * token, the value of any secret-named field (nonce, proof, poison,
  * password, api_key, …), and a secret inside a URL (a query token, a
  * bearer-like path segment, userinfo) never reach the buffer, the clipboard
  * or storage.

package/dist/debugLog.js

@@ -7,7 +7,7 @@
  * that flips the view can still be read and copied afterward.
  *
  * Every message is scrubbed on the way in: an nsec, a 64-hex key, a bearer
- * token, the value of any secret-named field (dpop_token, proof, poison,
+ * token, the value of any secret-named field (nonce, proof, poison,
  * password, api_key, …), and a secret inside a URL (a query token, a
  * bearer-like path segment, userinfo) never reach the buffer, the clipboard
  * or storage.
@@ -28,9 +28,9 @@ const listeners = new Set();
 // ── Redaction ──────────────────────────────────────────────────────────────
 const REDACTED = "[redacted]";
 /** Field names whose value is a secret wherever it appears. */
-const SECRET_FIELD = "(?:nsec|ncryptsec|dpop_token|proof|poison|password|passphrase|secret|token|authorization|api_?key|private_?key|client_secret|[a-z0-9_]*_(?:nsec|token|secret|password|passphrase|api_?key|private_?key))";
-// `"dpop_token":"…"`, `\"dpop_token\":\"…\"` (JSON inside a JSON string),
-// `dpop_token=…` (a query string) and `dpop_token: '…'` (a Python repr). A
+const SECRET_FIELD = "(?:nsec|ncryptsec|nonce|proof|poison|password|passphrase|secret|token|authorization|api_?key|private_?key|client_secret|[a-z0-9_]*_(?:nsec|token|secret|password|passphrase|api_?key|private_?key))";
+// `"nonce":"…"`, `\"nonce\":\"…\"` (JSON inside a JSON string),
+// `nonce=…` (a query string) and `nonce: '…'` (a Python repr). A
 // quoted value is taken whole — spaces, escaped quotes and the other kind of
 // quote included — up to its own closing quote or the end of a truncated line;
 // a bare one up to a delimiter. Stopping at the first quote of either kind let
@@ -56,7 +56,7 @@ function scrubbed(_match, head, quote) {
 // back in a tool result is logged whole. Three places a URL hides a secret:
 // the userinfo, a query or fragment parameter, and a bearer-like path segment.
 /** Query/fragment parameter names whose value is a secret (matched whole). */
-const URL_SECRET_PARAM = /([?&#;](?:token|access_token|refresh_token|id_token|auth|authorization|key|api_key|apikey|secret|client_secret|password|pass|sig|signature|code|proof|dpop_token|session|sessionid|nsec)=)[^&#;\s"'\\<>]*/gi;
+const URL_SECRET_PARAM = /([?&#;](?:token|access_token|refresh_token|id_token|auth|authorization|key|api_key|apikey|secret|client_secret|password|pass|sig|signature|code|proof|nonce|session|sessionid|nsec)=)[^&#;\s"'\\<>]*/gi;
 // A URL up to whitespace, a quote, an escape or an angle bracket — so one
 // inside JSON (or JSON inside JSON) ends at its own closing quote.
 const URL_IN_TEXT = /\b(?:https?|webcal|wss?):\/\/[^\s"'\\<>]+/gi;
@@ -211,7 +211,7 @@ export function debugLogText() {
 // Auth and funding outcomes are situations, not faults: the service answered
 // correctly and the patron has a step to take (sign in, top up). These SDK
 // error codes read as a notice and stay out of the failure count.
-const NOTICE_CODE = /error_code\\?"\s*:\s*\\?"(npub_missing|proof_missing|proof_required|proof_refresh_needed|dpop_token_missing|oauth_not_yet_authorized|oauth_token_expired|upstream_auth_refresh_needed|insufficient_balance|authority_insufficient_balance|upstream_subscription_required|operator_llm_unfunded)\\?"/i;
+const NOTICE_CODE = /error_code\\?"\s*:\s*\\?"(npub_missing|proof_required|nonce_missing|oauth_not_yet_authorized|oauth_token_expired|upstream_auth_refresh_needed|insufficient_balance|authority_insufficient_balance|upstream_subscription_required|operator_llm_unfunded)\\?"/i;
 function isFailure(entry) {
     if (entry.type === "error")
         return true;

package/dist/funding.d.ts

@@ -37,9 +37,11 @@ export interface BalanceThresholds {
 /** How this tab proves who it is. */
 export type ProofKind = {
     kind: "session_nsec";
-} | {
-    kind: "dm_proof";
-    status: "valid" | "expired" | "unknown";
+}
+/** The operator holds a DM proof for this tab's holder connection. */
+ | {
+    kind: "held";
+    status: "valid" | "lapsed" | "not_held" | "unknown";
     expiresInSec?: number | null;
 } | {
     kind: "none";

package/dist/funding.js

@@ -45,10 +45,12 @@ export function composeProofRow(proof, checkedAt) {
         return r("ok", "This tab's session key signs a fresh proof on every call — no expiry.");
     if (proof.kind === "none")
         return r("blocked", "No proof on hand — sign in again.");
-    if (proof.status === "expired")
+    if (proof.status === "lapsed")
         return r("blocked", "Proof has expired — sign in again to resume paid calls.");
+    if (proof.status === "not_held")
+        return r("blocked", "The service no longer holds your proof — sign in again.");
     if (proof.status === "unknown")
-        return r("warning", "No server-side proof record — the next paid call may ask you to sign in again.");
+        return r("warning", "Could not read the proof's status — the next paid call may ask you to sign in again.");
     const sec = proof.expiresInSec;
     if (sec != null && sec * 1000 < WARNING_WITHIN_MS)
         return r("warning", `Proof valid — expires in about ${durationText(sec)}.`);

package/dist/holder.js

@@ -26,8 +26,12 @@ function operator() {
 export function holderEnabled() {
     return Boolean(tollboothConfig().operatorUrl);
 }
+/**
+ * Back to the page the sign-in started on, since that page finishes it: a site
+ * whose `/` is not the sign-in page would otherwise drop the code on the floor.
+ */
 function redirectUri() {
-    return `${globalThis.location.origin}/`;
+    return `${globalThis.location.origin}${globalThis.location.pathname}`;
 }
 function readTokens() {
     try {
@@ -49,13 +53,13 @@ async function challengeFor(verifier) {
     const digest = new Uint8Array(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(verifier)));
     return btoa(String.fromCharCode(...digest)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
 }
-async function register() {
+async function register(redirect) {
     const r = await fetch(`${operator()}/register`, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({
             client_name: tollboothConfig().appName,
-            redirect_uris: [redirectUri()],
+            redirect_uris: [redirect],
             grant_types: ["authorization_code", "refresh_token"],
             response_types: ["code"],
             token_endpoint_auth_method: "none",
@@ -90,16 +94,17 @@ export function isHolder() {
  * sends it straight back. `resume` comes back from `completeHolderConnect`.
  */
 export async function connectAsHolder(resume) {
-    const clientId = readTokens()?.clientId || (await register());
+    const redirect = redirectUri();
+    const clientId = readTokens()?.clientId || (await register(redirect));
     const verifier = randomUrlSafe(48);
     const state = randomUrlSafe(16);
-    const pending = { clientId, verifier, state, resume };
+    const pending = { clientId, verifier, state, resume, redirectUri: redirect };
     globalThis.sessionStorage.setItem(PENDING, JSON.stringify(pending));
     const url = new URL(`${operator()}/authorize`);
     url.search = new URLSearchParams({
         response_type: "code",
         client_id: clientId,
-        redirect_uri: redirectUri(),
+        redirect_uri: redirect,
         state,
         code_challenge: await challengeFor(verifier),
         code_challenge_method: "S256",
@@ -123,7 +128,7 @@ export async function completeHolderConnect() {
     globalThis.history.replaceState(null, "", globalThis.location.pathname);
     if (params.get("state") !== pending.state)
         throw new Error("The service's reply did not match this sign-in.");
-    writeTokens(await token({ grant_type: "authorization_code", code, redirect_uri: redirectUri(), code_verifier: pending.verifier }, pending.clientId));
+    writeTokens(await token({ grant_type: "authorization_code", code, redirect_uri: pending.redirectUri, code_verifier: pending.verifier }, pending.clientId));
     return pending.resume;
 }
 /** The bearer for the next request, refreshed when it is about to lapse; null when not a holder. */

package/dist/identity.d.ts

@@ -1,36 +1,40 @@
 /**
  * Who this browser says it is, and what backs the claim.
  *
- * Three stored things, kept apart on purpose:
+ * Two stored things, kept apart on purpose:
  *   - the **npub** the app acts as — written only once it is proven;
- *   - the cached **DM proof** that backs it, when the patron signed in by DM;
  *   - the **last typed** npub, remembered only to prefill the field. Writing a
  *     name into the identity slot before it was proven is what once let an
  *     unanswered challenge become a session.
+ *
+ * What backs the npub lives on the connection: this tab's session key signs
+ * every request, or the operator holds the DM proof for this tab's holder
+ * connection. The page itself keeps no proof.
  */
 import { type Claim } from "./signedIn.ts";
 export declare function getStoredNpub(): string;
 export declare function setStoredNpub(npub: string): void;
-export declare function getStoredProof(): string;
-export declare function setStoredProof(proof: string): void;
-export declare function clearStoredProof(): void;
 export declare function getLastTypedNpub(): string;
 export declare function setLastTypedNpub(npub: string): void;
+/** An npub this tab's holder connection holds, until its DM proof lapses. */
 export interface RecentLogin {
     npub: string;
-    proof: string;
     /** Unix ms. */
     expiresAt: number;
     /** Unix ms. */
     lastUsed: number;
 }
-/** Unexpired recent logins, most recent first. Prunes the expired ones. */
+/**
+ * Unexpired recent logins, most recent first; none unless this tab is a
+ * holder, since the holder is what holds them. Prunes the expired ones.
+ */
 export declare function getValidRecentLogins(): RecentLogin[];
 /**
- * Record or refresh a successful login. The TTL is derated by 30 seconds so a
- * straggler never serves an already-expired token to the next paid call.
+ * Record or refresh a DM sign-in this tab's holder now holds. The TTL is
+ * derated by 30 seconds so a straggler never re-enters on a proof that lapses
+ * before the next paid call.
  */
-export declare function recordRecentLogin(npub: string, proof: string, expiresInSec: number): void;
+export declare function recordRecentLogin(npub: string, expiresInSec: number): void;
 export declare function forgetRecentLogin(npub: string): void;
 /** Read once and handed to the pure predicates in `signedIn.ts`. */
 export declare function currentClaim(): Claim;

package/dist/identity.js

@@ -1,19 +1,21 @@
 /**
  * Who this browser says it is, and what backs the claim.
  *
- * Three stored things, kept apart on purpose:
+ * Two stored things, kept apart on purpose:
  *   - the **npub** the app acts as — written only once it is proven;
- *   - the cached **DM proof** that backs it, when the patron signed in by DM;
  *   - the **last typed** npub, remembered only to prefill the field. Writing a
  *     name into the identity slot before it was proven is what once let an
  *     unanswered challenge become a session.
+ *
+ * What backs the npub lives on the connection: this tab's session key signs
+ * every request, or the operator holds the DM proof for this tab's holder
+ * connection. The page itself keeps no proof.
  */
 import { forgetHolder, isHolder } from "./holder.js";
 import { clearSessionNsec, hasSessionNsec, sessionNsecNpub } from "./sessionNsec.js";
 import { canSignFor, isProven } from "./signedIn.js";
 import { readStored, removeStored, writeStored } from "./storage.js";
 const NPUB = "patron_npub:v1";
-const PROOF = "proof_token:v1";
 const LAST_TYPED = "last_typed_npub:v1";
 const RECENT = "recent-logins:v1";
 const MAX_RECENT = 5;
@@ -23,15 +25,6 @@ export function getStoredNpub() {
 export function setStoredNpub(npub) {
     writeStored(NPUB, npub);
 }
-export function getStoredProof() {
-    return readStored(PROOF);
-}
-export function setStoredProof(proof) {
-    writeStored(PROOF, proof);
-}
-export function clearStoredProof() {
-    removeStored(PROOF);
-}
 export function getLastTypedNpub() {
     return readStored(LAST_TYPED);
 }
@@ -44,7 +37,7 @@ function readRecent() {
         if (!Array.isArray(parsed))
             return [];
         return parsed.filter((e) => typeof e === "object" && e !== null &&
-            typeof e.npub === "string" && typeof e.proof === "string" &&
+            typeof e.npub === "string" &&
             typeof e.expiresAt === "number" && typeof e.lastUsed === "number");
     }
     catch {
@@ -54,8 +47,13 @@ function readRecent() {
 function writeRecent(entries) {
     writeStored(RECENT, JSON.stringify(entries));
 }
-/** Unexpired recent logins, most recent first. Prunes the expired ones. */
+/**
+ * Unexpired recent logins, most recent first; none unless this tab is a
+ * holder, since the holder is what holds them. Prunes the expired ones.
+ */
 export function getValidRecentLogins() {
+    if (!isHolder())
+        return [];
     const now = Date.now();
     const entries = readRecent();
     const valid = entries.filter((e) => e.expiresAt > now);
@@ -64,14 +62,14 @@ export function getValidRecentLogins() {
     return valid.sort((a, b) => b.lastUsed - a.lastUsed);
 }
 /**
- * Record or refresh a successful login. The TTL is derated by 30 seconds so a
- * straggler never serves an already-expired token to the next paid call.
+ * Record or refresh a DM sign-in this tab's holder now holds. The TTL is
+ * derated by 30 seconds so a straggler never re-enters on a proof that lapses
+ * before the next paid call.
  */
-export function recordRecentLogin(npub, proof, expiresInSec) {
+export function recordRecentLogin(npub, expiresInSec) {
     const now = Date.now();
     const next = {
         npub,
-        proof,
         expiresAt: now + Math.max(0, expiresInSec - 30) * 1000,
         lastUsed: now,
     };
@@ -87,17 +85,13 @@ export function currentClaim() {
     const npub = getStoredNpub();
     return {
         npub,
-        proof: getStoredProof(),
         held: heldByThisTab(npub),
         sessionNpub: hasSessionNsec() ? sessionNsecNpub() : null,
     };
 }
-/**
- * True when this tab's holder connection holds `npub`: a DM sign-in recorded
- * here with no token, because the operator kept the grant.
- */
+/** True when this tab's holder connection holds `npub`: a DM sign-in recorded here. */
 function heldByThisTab(npub) {
-    return Boolean(npub) && isHolder() && getValidRecentLogins().some((e) => e.npub === npub && !e.proof);
+    return Boolean(npub) && getValidRecentLogins().some((e) => e.npub === npub);
 }
 export function isLoggedIn() {
     return isProven(currentClaim());
@@ -111,7 +105,6 @@ export function canSign() {
  */
 export function logOut() {
     removeStored(NPUB);
-    removeStored(PROOF);
     clearSessionNsec();
     void forgetHolder();
 }

package/dist/pagesProxy.d.ts

@@ -12,11 +12,10 @@
  * Only the headers MCP needs are forwarded upstream. Cookies and anything else
  * the browser attached stay behind.
  *
- * Every request upstream carries a bearer. An operator with holder bearer on
- * refuses a request without one; a page that holds no holder token is an
- * anonymous caller, so the proxy says so with `Bearer anonymous` and the page
- * proves itself with `dpop_token` as before. A page that does hold a token
- * sends it, and it is forwarded untouched.
+ * Every request upstream carries who it may act as. An operator refuses a
+ * request with no `Authorization`, so a page that neither signs (`Nostr`)
+ * nor holds a holder token is an anonymous caller, and the proxy says so with
+ * `Bearer anonymous`. A request that carries either is forwarded untouched.
  */
 export declare const CORS_HEADERS: Record<string, string>;
 export declare const ANONYMOUS_BEARER = "Bearer anonymous";

package/dist/pagesProxy.js

@@ -12,11 +12,10 @@
  * Only the headers MCP needs are forwarded upstream. Cookies and anything else
  * the browser attached stay behind.
  *
- * Every request upstream carries a bearer. An operator with holder bearer on
- * refuses a request without one; a page that holds no holder token is an
- * anonymous caller, so the proxy says so with `Bearer anonymous` and the page
- * proves itself with `dpop_token` as before. A page that does hold a token
- * sends it, and it is forwarded untouched.
+ * Every request upstream carries who it may act as. An operator refuses a
+ * request with no `Authorization`, so a page that neither signs (`Nostr`)
+ * nor holds a holder token is an anonymous caller, and the proxy says so with
+ * `Bearer anonymous`. A request that carries either is forwarded untouched.
  */
 export const CORS_HEADERS = {
     "Access-Control-Allow-Origin": "*",

package/dist/react/FundingStatus.js

@@ -69,11 +69,17 @@ async function proofKind() {
     const claim = currentClaim();
     if (canSignFor(claim))
         return { kind: "session_nsec" };
-    if (!claim.proof)
+    if (!claim.held)
         return { kind: "none" };
-    const s = await checkProofStatus(claim.npub, claim.proof).catch(() => null);
-    const status = s?.status === "valid" || s?.status === "expired" ? s.status : "unknown";
-    return { kind: "dm_proof", status, expiresInSec: s?.expires_in_seconds ?? null };
+    const s = await checkProofStatus(claim.npub).catch(() => null);
+    return { kind: "held", status: heldStatus(s?.status), expiresInSec: s?.expires_in_seconds ?? null };
+}
+function heldStatus(status) {
+    if (status === "valid" || status === "not_held")
+        return status;
+    if (status === "expired" || status === "revoked" || status === "invalid")
+        return "lapsed";
+    return "unknown";
 }
 /** The patron's own health: sign-in proof and credit balance. */
 export function PatronFundingStatus({ thresholds, siteRows, heading = "Account health", ...rest }) {

package/dist/react/NpubGate.d.ts

@@ -3,7 +3,10 @@
  *
  *   begin → request_npub_proof → awaiting reply → receive_npub_proof → app
  *
- * Success is not a `verified` flag but "no `error` and a token came back".
+ * Success is not a `verified` flag but the operator saying it now holds the
+ * npub for this tab's connection (`held_by_connection`). A DM sign-in therefore
+ * needs a holder connection first; a site without `operatorUrl` offers the
+ * session key only.
  *
  * Around the card: the site's `welcome` (its own words about what this place
  * is for), the network's register line, and — below — `SignInSteps`, which

package/dist/react/NpubGate.js

@@ -4,7 +4,10 @@ import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-run
  *
  *   begin → request_npub_proof → awaiting reply → receive_npub_proof → app
  *
- * Success is not a `verified` flag but "no `error` and a token came back".
+ * Success is not a `verified` flag but the operator saying it now holds the
+ * npub for this tab's connection (`held_by_connection`). A DM sign-in therefore
+ * needs a holder connection first; a site without `operatorUrl` offers the
+ * session key only.
  *
  * Around the card: the site's `welcome` (its own words about what this place
  * is for), the network's register line, and — below — `SignInSteps`, which
@@ -15,7 +18,7 @@ import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-run
 import { useEffect, useRef, useState } from "react";
 import { generateSecretKey, getPublicKey, nip19 } from "nostr-tools";
 import { tollboothConfig } from "../config.js";
-import { forgetRecentLogin, getLastTypedNpub, getValidRecentLogins, recordRecentLogin, setLastTypedNpub, setStoredNpub, setStoredProof, } from "../identity.js";
+import { forgetRecentLogin, getLastTypedNpub, getValidRecentLogins, recordRecentLogin, setLastTypedNpub, setStoredNpub, } from "../identity.js";
 import { completeHolderConnect, connectAsHolder, holderEnabled, isHolder } from "../holder.js";
 import { setSessionNsec } from "../sessionNsec.js";
 import { readSignInFailure } from "../signInSituation.js";
@@ -54,7 +57,7 @@ export default function NpubGate({ onLogin, startFresh = false, operatorHash, no
     // Prefilled from what was typed last, NOT from the stored identity.
     const [value, setValue] = useState(getLastTypedNpub());
     const [stage, setStage] = useState("begin");
-    const [pendingProof, setPendingProof] = useState("");
+    const [nonce, setNonce] = useState("");
     const [busy, setBusy] = useState(false);
     const [error, setError] = useState("");
     const [note, setNote] = useState("");
@@ -76,8 +79,7 @@ export default function NpubGate({ onLogin, startFresh = false, operatorHash, no
     const valid = isNsec || isNpub;
     function reuseRecent(entry) {
         setStoredNpub(entry.npub);
-        setStoredProof(entry.proof);
-        recordRecentLogin(entry.npub, entry.proof, Math.floor((entry.expiresAt - Date.now()) / 1000));
+        recordRecentLogin(entry.npub, Math.floor((entry.expiresAt - Date.now()) / 1000));
         onLogin();
     }
     function forget(npub) {
@@ -132,21 +134,25 @@ export default function NpubGate({ onLogin, startFresh = false, operatorHash, no
         setBusy(true);
         setError("");
         try {
-            // The grant will stay with the operator, so this tab connects to it
+            // The proof will stay with the operator, so this tab connects to it
             // first; the browser comes straight back here and the DM goes out.
-            if (holderEnabled() && !isHolder()) {
+            if (!holderEnabled()) {
+                setError("This site signs in with a key only — paste an nsec, or make one.");
+                return;
+            }
+            if (!isHolder()) {
                 await connectAsHolder(npubToProve);
                 return;
             }
             const r = await requestNpubProof(npubToProve, globalThis.location.origin, `You requested to sign in to ${appName} (${globalThis.location.host}).`);
             if (r.error)
                 return setError(r.error);
-            if (!r.dpop_token)
+            if (!r.nonce)
                 return setError("The service did not return a session phrase. Try again.");
             // Remembered for the field only. The identity is written by `finish()`,
             // once the human has answered the DM.
             setLastTypedNpub(npubToProve);
-            setPendingProof(r.dpop_token);
+            setNonce(r.nonce);
             setStage("awaiting");
         }
         catch (e) {
@@ -161,22 +167,18 @@ export default function NpubGate({ onLogin, startFresh = false, operatorHash, no
         setError("");
         setStage("checking");
         try {
-            const r = await receiveNpubProof(trimmed, pendingProof);
-            if (r.error) {
-                setError(r.error);
+            const r = await receiveNpubProof(trimmed, nonce);
+            if (r.error || !r.held_by_connection) {
+                setError(r.error || "The service did not keep the proof for this page. Try again.");
                 setStage("awaiting");
                 return;
             }
-            // A holder's grant stays with the operator; only a page that is not a
-            // holder keeps the token it is handed.
-            const token = r.held_by_connection ? "" : r.dpop_token || pendingProof;
             const npub = r.proven_npub || trimmed;
             setStoredNpub(npub);
-            setStoredProof(token);
             if (r.expires_in_seconds && r.expires_in_seconds > 0) {
-                recordRecentLogin(npub, token, r.expires_in_seconds);
+                recordRecentLogin(npub, r.expires_in_seconds);
                 const h = Math.floor(r.expires_in_seconds / 3600);
-                setNote(`Proof cached for ~${h > 0 ? `${h}h` : `${Math.round(r.expires_in_seconds / 60)}m`}.`);
+                setNote(`Proof held for ~${h > 0 ? `${h}h` : `${Math.round(r.expires_in_seconds / 60)}m`}.`);
             }
             onLogin();
         }
@@ -190,10 +192,10 @@ export default function NpubGate({ onLogin, startFresh = false, operatorHash, no
     }
     function reset() {
         setStage("begin");
-        setPendingProof("");
+        setNonce("");
         setError("");
     }
-    return (_jsxs("div", { className: cx("max-w-md mx-auto mt-12 px-4", c.root), children: [_jsxs("h1", { className: "text-xl font-semibold mb-1", children: ["Sign in to ", appName] }), welcome && _jsx("div", { className: cx("text-sm mb-3", c.welcome), children: welcome }), _jsxs("p", { className: cx(`text-sm mb-5 ${muted}`, c.register), children: [appName, " is an operator on the Tollbooth DPYC\u2122 network. DPYC\u2122 \u2014 Don't Pester Your Customer\u2122: no email, no password, no KYC. Your Nostr key is your identity."] }), notice && _jsx("div", { className: `mb-5 ${warnBox}`, children: notice }), stage === "begin" && recents.length > 0 && (_jsxs("div", { className: "mb-5", children: [_jsx("div", { className: `text-xs uppercase tracking-wider mb-2 ${muted}`, children: "Recent identities" }), _jsx("div", { className: "space-y-1.5", children: recents.map((e) => (_jsxs("div", { className: "flex gap-1.5", children: [_jsxs("button", { type: "button", onClick: () => reuseRecent(e), disabled: busy, title: `Re-enter as ${e.npub} on the cached proof`, className: `${card} flex-1 flex items-center justify-between px-3 py-2.5 text-left hover:border-[var(--tb-accent)]`, children: [_jsxs("span", { className: "font-mono text-xs truncate", children: [e.npub.slice(0, 12), "\u2026", e.npub.slice(-6)] }), _jsxs("span", { className: `text-xs shrink-0 ml-2 ${muted}`, children: [ttl(e.expiresAt), " left"] })] }), _jsx("button", { type: "button", onClick: () => forget(e.npub), disabled: busy, title: "Forget this identity", "aria-label": "Forget this identity", className: `w-9 rounded-lg border border-[var(--tb-line)] ${muted}`, children: "\u00D7" })] }, e.npub))) })] })), _jsxs("div", { className: `${card} p-4 space-y-3`, children: [stage === "begin" ? (_jsxs(_Fragment, { children: [_jsx("label", { className: `block text-xs uppercase tracking-wider ${muted}`, htmlFor: "tb-npub-field", children: "Enter npub (secure) or nsec (convenient)" }), _jsx("input", { id: "tb-npub-field", "data-tour": "tb.gate.npub", type: isNsec ? "password" : "text", value: value, onChange: (e) => {
+    return (_jsxs("div", { className: cx("max-w-md mx-auto mt-12 px-4", c.root), children: [_jsxs("h1", { className: "text-xl font-semibold mb-1", children: ["Sign in to ", appName] }), welcome && _jsx("div", { className: cx("text-sm mb-3", c.welcome), children: welcome }), _jsxs("p", { className: cx(`text-sm mb-5 ${muted}`, c.register), children: [appName, " is an operator on the Tollbooth DPYC\u2122 network. DPYC\u2122 \u2014 Don't Pester Your Customer\u2122: no email, no password, no KYC. Your Nostr key is your identity."] }), notice && _jsx("div", { className: `mb-5 ${warnBox}`, children: notice }), stage === "begin" && recents.length > 0 && (_jsxs("div", { className: "mb-5", children: [_jsx("div", { className: `text-xs uppercase tracking-wider mb-2 ${muted}`, children: "Recent identities" }), _jsx("div", { className: "space-y-1.5", children: recents.map((e) => (_jsxs("div", { className: "flex gap-1.5", children: [_jsxs("button", { type: "button", onClick: () => reuseRecent(e), disabled: busy, title: `Re-enter as ${e.npub} on the proof the service holds`, className: `${card} flex-1 flex items-center justify-between px-3 py-2.5 text-left hover:border-[var(--tb-accent)]`, children: [_jsxs("span", { className: "font-mono text-xs truncate", children: [e.npub.slice(0, 12), "\u2026", e.npub.slice(-6)] }), _jsxs("span", { className: `text-xs shrink-0 ml-2 ${muted}`, children: [ttl(e.expiresAt), " left"] })] }), _jsx("button", { type: "button", onClick: () => forget(e.npub), disabled: busy, title: "Forget this identity", "aria-label": "Forget this identity", className: `w-9 rounded-lg border border-[var(--tb-line)] ${muted}`, children: "\u00D7" })] }, e.npub))) })] })), _jsxs("div", { className: `${card} p-4 space-y-3`, children: [stage === "begin" ? (_jsxs(_Fragment, { children: [_jsx("label", { className: `block text-xs uppercase tracking-wider ${muted}`, htmlFor: "tb-npub-field", children: "Enter npub (secure) or nsec (convenient)" }), _jsx("input", { id: "tb-npub-field", "data-tour": "tb.gate.npub", type: isNsec ? "password" : "text", value: value, onChange: (e) => {
                                     setValue(e.target.value);
                                     setGeneratedHint(false);
                                 }, onKeyDown: (e) => {
@@ -203,7 +205,7 @@ export default function NpubGate({ onLogin, startFresh = false, operatorHash, no
                                         signInWithNsec();
                                     else
                                         void begin();
-                                }, placeholder: "npub1\u2026", spellCheck: false, autoCapitalize: "off", autoCorrect: "off", className: input }), generatedHint && (_jsxs("div", { className: warnBox, children: ["New key generated. ", _jsx("b", { children: "Save this nsec" }), " somewhere safe \u2014 it's the only copy and it lives only in this browser."] })), _jsx("button", { type: "button", onClick: () => (isNsec ? signInWithNsec() : void begin()), disabled: !valid || busy, className: primary, "data-tour": "tb.gate.send", children: busy ? "Sending…" : isNpub ? "Send message" : "Sign in" }), isNsec && _jsx("p", { className: `text-xs ${muted}`, children: "Your nsec stays in this browser and signs each call." }), isNpub && (_jsx("p", { className: `text-xs ${muted}`, children: "We send a message to your npub. Approve it from your Nostr client \u2014 your signature is the proof." })), _jsx("p", { className: `text-xs pt-1 ${muted}`, children: "Need a new identity?" }), _jsx("button", { type: "button", onClick: generateKey, className: ghost, children: "Generate a new key" })] })) : (_jsxs(_Fragment, { children: [_jsxs("div", { className: `${warnBox} space-y-1.5`, children: [_jsx("div", { className: "font-medium", children: "Message sent \u2014 open your Nostr client." }), _jsx("div", { children: "Reply with any text. Your signature on that reply is the proof." }), operatorHash && (_jsxs("div", { children: ["Sender fingerprint: ", _jsxs("span", { className: "font-mono", children: ["\uD83D\uDD12 ", operatorHash] })] }))] }), pendingProof && (_jsxs("div", { className: "rounded-lg p-3 text-xs border border-[var(--tb-accent)] space-y-2", children: [_jsx("div", { className: `uppercase tracking-wider text-[10px] ${muted}`, children: "Confirmation code" }), _jsx("div", { className: "font-mono text-base select-all", children: pendingProof }), _jsxs("div", { className: `leading-relaxed ${muted}`, children: ["The same code appears in the message. ", _jsx("b", { children: "Approve it only if the codes match." }), " If they differ \u2014 or the message points you somewhere other than this site \u2014 do not reply."] })] })), _jsx("button", { type: "button", onClick: () => void finish(), disabled: busy, className: primary, "data-tour": "tb.gate.verify", children: busy ? "Checking…" : "I've replied — verify" }), _jsx("button", { type: "button", onClick: () => void begin(), disabled: busy, className: ghost, children: "Resend" }), _jsx("button", { type: "button", onClick: reset, disabled: busy, className: `w-full text-xs py-1.5 ${muted}`, children: "Use a different npub" })] })), error && _jsx(Trouble, { raw: error, appName: appName }), note && _jsx("div", { className: `text-xs text-center italic ${muted}`, children: note })] }), steps && _jsx(SignInSteps, { stage: gateStage(stage, busy), classNames: { ...STEPS_LOOK, ...c.steps } }), links && _jsx(SignInLinks, { credit: linksCredit, classNames: { ...LINKS_LOOK, ...c.links } })] }));
+                                }, placeholder: "npub1\u2026", spellCheck: false, autoCapitalize: "off", autoCorrect: "off", className: input }), generatedHint && (_jsxs("div", { className: warnBox, children: ["New key generated. ", _jsx("b", { children: "Save this nsec" }), " somewhere safe \u2014 it's the only copy and it lives only in this browser."] })), _jsx("button", { type: "button", onClick: () => (isNsec ? signInWithNsec() : void begin()), disabled: !valid || busy, className: primary, "data-tour": "tb.gate.send", children: busy ? "Sending…" : isNpub ? "Send message" : "Sign in" }), isNsec && _jsx("p", { className: `text-xs ${muted}`, children: "Your nsec stays in this browser and signs each call." }), isNpub && (_jsx("p", { className: `text-xs ${muted}`, children: "We send a message to your npub. Approve it from your Nostr client \u2014 your signature is the proof." })), _jsx("p", { className: `text-xs pt-1 ${muted}`, children: "Need a new identity?" }), _jsx("button", { type: "button", onClick: generateKey, className: ghost, children: "Generate a new key" })] })) : (_jsxs(_Fragment, { children: [_jsxs("div", { className: `${warnBox} space-y-1.5`, children: [_jsx("div", { className: "font-medium", children: "Message sent \u2014 open your Nostr client." }), _jsx("div", { children: "Reply with any text. Your signature on that reply is the proof." }), operatorHash && (_jsxs("div", { children: ["Sender fingerprint: ", _jsxs("span", { className: "font-mono", children: ["\uD83D\uDD12 ", operatorHash] })] }))] }), nonce && (_jsxs("div", { className: "rounded-lg p-3 text-xs border border-[var(--tb-accent)] space-y-2", children: [_jsx("div", { className: `uppercase tracking-wider text-[10px] ${muted}`, children: "Confirmation code" }), _jsx("div", { className: "font-mono text-base select-all", children: nonce }), _jsxs("div", { className: `leading-relaxed ${muted}`, children: ["The same code appears in the message. ", _jsx("b", { children: "Approve it only if the codes match." }), " If they differ \u2014 or the message points you somewhere other than this site \u2014 do not reply."] })] })), _jsx("button", { type: "button", onClick: () => void finish(), disabled: busy, className: primary, "data-tour": "tb.gate.verify", children: busy ? "Checking…" : "I've replied — verify" }), _jsx("button", { type: "button", onClick: () => void begin(), disabled: busy, className: ghost, children: "Resend" }), _jsx("button", { type: "button", onClick: reset, disabled: busy, className: `w-full text-xs py-1.5 ${muted}`, children: "Use a different npub" })] })), error && _jsx(Trouble, { raw: error, appName: appName }), note && _jsx("div", { className: `text-xs text-center italic ${muted}`, children: note })] }), steps && _jsx(SignInSteps, { stage: gateStage(stage, busy), classNames: { ...STEPS_LOOK, ...c.steps } }), links && _jsx(SignInLinks, { credit: linksCredit, classNames: { ...LINKS_LOOK, ...c.links } })] }));
 }
 /** A failure, read to the person: the lead first, the service's own words underneath. */
 function Trouble({ raw, appName }) {

package/dist/signedIn.d.ts

@@ -4,10 +4,10 @@
  * An npub is public — it is on every note its owner ever wrote — so the npub
  * alone is a claim, never a credential. A shell that read "we know an npub" as
  * "signed in" let anyone who asked for a DM and never answered it in, as
- * themselves, unproven. Two things can back the claim:
+ * themselves, unproven. Two things can back the claim, both on the connection:
  *
  *   - a **DM proof**, won by answering a Nostr challenge — held by the operator
- *     for this tab's connection, or (before holders) cached here, or
+ *     for this tab's holder connection, or
  *   - a **session nsec** in this tab, which signs every request — and only
  *     counts for the npub it actually derives to.
  *
@@ -16,14 +16,12 @@
 export interface Claim {
     /** The npub the interface is showing, proven or not. */
     npub: string;
-    /** A cached DM proof token, if one was won and has not lapsed. */
-    proof: string;
     /** True when this tab's holder connection holds the npub, proven by DM. */
     held: boolean;
     /** The npub this tab's session key derives to, if it holds one. */
     sessionNpub: string | null;
 }
 /** True only when the claimed npub is backed by something. */
-export declare function isProven({ npub, proof, held, sessionNpub }: Claim): boolean;
+export declare function isProven({ npub, held, sessionNpub }: Claim): boolean;
 /** True when this tab can sign a fresh proof for the npub it is claiming. */
 export declare function canSignFor({ npub, sessionNpub }: Claim): boolean;

package/dist/signedIn.js

@@ -4,22 +4,18 @@
  * An npub is public — it is on every note its owner ever wrote — so the npub
  * alone is a claim, never a credential. A shell that read "we know an npub" as
  * "signed in" let anyone who asked for a DM and never answered it in, as
- * themselves, unproven. Two things can back the claim:
+ * themselves, unproven. Two things can back the claim, both on the connection:
  *
  *   - a **DM proof**, won by answering a Nostr challenge — held by the operator
- *     for this tab's connection, or (before holders) cached here, or
+ *     for this tab's holder connection, or
  *   - a **session nsec** in this tab, which signs every request — and only
  *     counts for the npub it actually derives to.
  *
  * Pure, so it is testable without a browser.
  */
 /** True only when the claimed npub is backed by something. */
-export function isProven({ npub, proof, held, sessionNpub }) {
-    if (!npub)
-        return false;
-    if (proof || held)
-        return true;
-    return sessionNpub === npub;
+export function isProven({ npub, held, sessionNpub }) {
+    return Boolean(npub) && (held || sessionNpub === npub);
 }
 /** True when this tab can sign a fresh proof for the npub it is claiming. */
 export function canSignFor({ npub, sessionNpub }) {

package/dist/standardTools.d.ts

@@ -53,8 +53,9 @@ export interface NpubProofResult {
     proven_npub?: string;
     status?: string;
     message?: string;
-    dpop_token?: string;
-    /** True when the operator kept the grant for this tab's holder connection. */
+    /** From `request_npub_proof`: the phrase the DM shows; it names the reply. */
+    nonce?: string;
+    /** From `receive_npub_proof`: the operator now holds the npub for this tab's connection. */
     held_by_connection?: boolean;
     expires_in_seconds?: number;
     expires_at?: string;
@@ -71,18 +72,21 @@ export interface NpubProofResult {
  */
 export declare function requestNpubProof(patronNpub: string, verifyAt?: string, reason?: string, opts?: CallOptions): Promise<NpubProofResult>;
 /**
- * Step 2: drain DMs for the signed reply to step 1. Call only after the human
- * says they replied — it is destructive, so never poll it.
+ * Step 2: drain DMs for the signed reply to step 1, naming it by the `nonce`
+ * step 1 returned. The operator keeps the proof for this tab's holder
+ * connection. Call only after the human says they replied — it is
+ * destructive, so never poll it.
  */
-export declare function receiveNpubProof(patronNpub: string, dpopToken: string, opts?: CallOptions): Promise<NpubProofResult>;
+export declare function receiveNpubProof(patronNpub: string, nonce: string, opts?: CallOptions): Promise<NpubProofResult>;
 export interface ProofStatusResult {
     success?: boolean;
-    status?: "valid" | "expired" | "unknown" | string;
+    status?: "valid" | "expired" | "invalid" | "revoked" | "not_held" | string;
     expires_in_seconds?: number | null;
     error?: string;
     error_code?: string;
 }
-export declare function checkProofStatus(patronNpub: string, dpopToken: string, opts?: CallOptions): Promise<ProofStatusResult>;
+/** Whether this tab's connection proves `patronNpub`, and until when. */
+export declare function checkProofStatus(patronNpub: string, opts?: CallOptions): Promise<ProofStatusResult>;
 /** One credit tranche: a purchase (or grant) and what is left of it. */
 export interface CreditTranche {
     id: string;

package/dist/standardTools.js

@@ -26,14 +26,17 @@ export function requestNpubProof(patronNpub, verifyAt, reason, opts) {
     }, opts);
 }
 /**
- * Step 2: drain DMs for the signed reply to step 1. Call only after the human
- * says they replied — it is destructive, so never poll it.
+ * Step 2: drain DMs for the signed reply to step 1, naming it by the `nonce`
+ * step 1 returned. The operator keeps the proof for this tab's holder
+ * connection. Call only after the human says they replied — it is
+ * destructive, so never poll it.
  */
-export function receiveNpubProof(patronNpub, dpopToken, opts) {
-    return callTool("receive_npub_proof", { patron_npub: patronNpub, dpop_token: dpopToken }, opts);
+export function receiveNpubProof(patronNpub, nonce, opts) {
+    return callTool("receive_npub_proof", { patron_npub: patronNpub, nonce }, opts);
 }
-export function checkProofStatus(patronNpub, dpopToken, opts) {
-    return callTool("check_proof_status", { patron_npub: patronNpub, dpop_token: dpopToken }, { bestEffort: true, ...opts });
+/** Whether this tab's connection proves `patronNpub`, and until when. */
+export function checkProofStatus(patronNpub, opts) {
+    return callTool("check_proof_status", { patron_npub: patronNpub }, { bestEffort: true, ...opts });
 }
 export function checkBalance(opts) {
     return callTool("check_balance", {}, opts);

package/dist/toolResult.d.ts

@@ -27,21 +27,21 @@ export interface ReadResult {
 export declare function errorText(result: RawToolResult): string;
 export declare function readToolResult(result: RawToolResult): ReadResult;
 /**
- * A soft proof failure: `{success: false, error_code: proof_required |
- * proof_refresh_needed}` with no isError flag. The wheel's codes are lowercase
- * snake_case; an earlier uppercase comparison never matched, so the bounce
- * silently never fired. Normalised here, once.
+ * A soft proof failure: `{success: false, error_code: proof_required}` with no
+ * isError flag — the connection does not prove the npub. The wheel's codes are
+ * lowercase snake_case; an earlier uppercase comparison never matched, so the
+ * bounce silently never fired. Normalised here, once.
  */
 export declare function proofBounceMessage(payload: unknown): string | null;
 /**
- * A stored proof grant the service refused for good: `{success: false,
+ * A held proof grant the service refused for good: `{success: false,
  * error_code: proof_invalid, reason}` where the reason is about the grant —
  * expired, revoked, issued for another npub or operator, malformed. Retrying
- * with it can never succeed, so the patron is signed out.
+ * on it can never succeed, so the patron is signed out.
  *
- * Only meaningful when the call carried the stored grant. A session key's
- * inline proof shares the code and even the word `expired` (outside its
- * window), but it is signed afresh for the next call and loses nothing.
+ * Only meaningful when the call rode this tab's holder. A signed request
+ * shares the code and even the word `expired` (outside its window), but it is
+ * signed afresh for the next call and loses nothing.
  */
 export declare function deadGrantMessage(payload: unknown): string | null;
 /** Whether a payload reports failure, for the debug log's colouring. */

package/dist/toolResult.js

@@ -36,17 +36,17 @@ export function readToolResult(result) {
     return { payload, images };
 }
 /**
- * A soft proof failure: `{success: false, error_code: proof_required |
- * proof_refresh_needed}` with no isError flag. The wheel's codes are lowercase
- * snake_case; an earlier uppercase comparison never matched, so the bounce
- * silently never fired. Normalised here, once.
+ * A soft proof failure: `{success: false, error_code: proof_required}` with no
+ * isError flag — the connection does not prove the npub. The wheel's codes are
+ * lowercase snake_case; an earlier uppercase comparison never matched, so the
+ * bounce silently never fired. Normalised here, once.
  */
 export function proofBounceMessage(payload) {
     if (!payload || typeof payload !== "object")
         return null;
     const p = payload;
     const code = String(p.error_code ?? "").toLowerCase();
-    if (p.success === false && (code === "proof_required" || code === "proof_refresh_needed")) {
+    if (p.success === false && code === "proof_required") {
         return String(p.error ?? "Sign-in required.");
     }
     return null;
@@ -58,14 +58,14 @@ export function proofBounceMessage(payload) {
  */
 const GRANT_STILL_GOOD = new Set(["operator_unknown", "revocations_unavailable"]);
 /**
- * A stored proof grant the service refused for good: `{success: false,
+ * A held proof grant the service refused for good: `{success: false,
  * error_code: proof_invalid, reason}` where the reason is about the grant —
  * expired, revoked, issued for another npub or operator, malformed. Retrying
- * with it can never succeed, so the patron is signed out.
+ * on it can never succeed, so the patron is signed out.
  *
- * Only meaningful when the call carried the stored grant. A session key's
- * inline proof shares the code and even the word `expired` (outside its
- * window), but it is signed afresh for the next call and loses nothing.
+ * Only meaningful when the call rode this tab's holder. A signed request
+ * shares the code and even the word `expired` (outside its window), but it is
+ * signed afresh for the next call and loses nothing.
  */
 export function deadGrantMessage(payload) {
     if (!payload || typeof payload !== "object")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tollbooth-dpyc/web",
-  "version": "1.9.0",
+  "version": "2.0.1",
   "description": "Shared browser SDK for Tollbooth DPYC operator front ends: npub sign-in, proofs, MCP client, profile and wallet",
   "license": "Apache-2.0",
   "author": "Lonnie VanZandt",