@proveanything/smartlinks 1.15.17 → 1.15.19

package/docs/API_SUMMARY.md

@@ -1,6 +1,6 @@
 # Smartlinks API Summary
 
-Version: 1.15.17  |  Generated: 2026-08-18T08:10:50.608Z
+Version: 1.15.19  |  Generated: 2026-08-20T18:06:08.134Z
 
 This is a concise summary of all available API functions and types.
 
@@ -1993,6 +1993,10 @@ interface CreateThreadInput {
   data?: Record<string, unknown>
   owner?: Record<string, unknown>
   admin?: Record<string, unknown> // admin only
+  * Optional atomic first reply. Posting a comment no longer needs a separate
+  * create-thread-then-reply round trip (which could orphan an empty thread on
+  * partial failure). The reply is stored with a generated `id` and timestamp.
+  firstReply?: ReplyInput
 }
 ```
 
@@ -3460,6 +3464,55 @@ interface AuthKitConfig {
   supportEmail?: string
   redirectUrl?: string
   updatedAt?: string
+  * Per-collection security policy. On the public config endpoint only
+  * `passwordPolicy` + `session` are returned (the client renders password
+  * checklists / idle sign-out from them); `lockout` is admin-only and enforced
+  * server-side. See {@link AuthKitSecurityConfig}.
+  security?: AuthKitSecurityConfig
+}
+```
+
+**AuthKitSecurityConfig** (interface)
+```typescript
+interface AuthKitSecurityConfig {
+  passwordPolicy?: AuthKitPasswordPolicy
+  session?: AuthKitSessionPolicy
+  lockout?: AuthKitLockoutPolicy
+}
+```
+
+**AuthKitPasswordPolicy** (interface)
+```typescript
+interface AuthKitPasswordPolicy {
+  minLength?: number
+  requireUppercase?: boolean
+  requireLowercase?: boolean
+  requireNumber?: boolean
+  requireSymbol?: boolean
+  blockCommonPasswords?: boolean
+  expiryDays?: number
+  historyCount?: number
+}
+```
+
+**AuthKitSessionPolicy** (interface)
+```typescript
+interface AuthKitSessionPolicy {
+  inactivityTimeoutMinutes?: number
+  inactivityWarningSeconds?: number
+  absoluteTimeoutHours?: number
+  rememberMe?: boolean
+}
+```
+
+**AuthKitLockoutPolicy** (interface)
+```typescript
+interface AuthKitLockoutPolicy {
+  enabled?: boolean
+  maxFailedAttempts?: number
+  attemptWindowMinutes?: number
+  lockoutMinutes?: number
+  notifyUserOnLockout?: boolean
 }
 ```
 
@@ -3471,6 +3524,10 @@ interface AuthKitConfig {
 
 **VerifyStatus** = `'pending' | 'verified' | 'failed' | 'expired' | 'unknown'`
 
+**PasswordPolicyErrorCode** = ``
+
+**LoginSecurityErrorCode** = ``
+
 ### batch
 
 **FirebaseTimestamp** (interface)
@@ -7275,14 +7332,36 @@ interface Proof {
 }
 ```
 
-**ProofCreateRequest** (interface)
+**ProofWrite** (interface)
 ```typescript
-interface ProofCreateRequest {
-  values: ProofValues
+interface ProofWrite {
+  * Choose the proof's ID (serial, NFC id, etc.). Honoured **on create only** —
+  * the ledger doc becomes `{productId}-{id}`. Omit to auto-generate. Ignored on
+  * update (a proof's ID is immutable).
+  id?: string
+  values?: ProofValues
   data?: Record<string, JsonValue>
   admin?: Record<string, JsonValue>
+  owner?: Record<string, JsonValue>
+  claimable?: boolean
+  [key: string]: JsonValue | Record<string, JsonValue> | ProofValues | undefined
+}
+```
+
+**ProofCreateRequest** (interface)
+```typescript
+interface ProofCreateRequest {
+  * The proof to create, by zone (mirrors the proof document). This is the clear,
+  * recommended shape — `create(collectionId, productId, { proof: {...} })`.
+  proof?: ProofWrite
+  values?: ProofValues
   claimable?: boolean
   virtual?: boolean
+  core?: ProofWrite
+  * @deprecated On the request body this is folded into the **values bag**
+  * (public + owner-writable) — NOT `proof.data`. Use `proof.data`.
+  data?: Record<string, JsonValue>
+  admin?: Record<string, JsonValue>
 }
 ```
 
@@ -7339,7 +7418,7 @@ interface RedeemGrantOptions {
 
 **ProofResponse** = `Proof`
 
-**ProofUpdateRequest** = `Partial<ProofCreateRequest>`
+**ProofUpdateRequest** = `Partial<ProofWrite> & { proof?: ProofWrite }`
 
 **ProofClaimRequest** = `Record<string, any>`
 
@@ -8435,6 +8514,13 @@ Soft delete a thread DELETE /threads/:threadId
     admin: boolean = false) → `Promise<AppThread>`
 Add a reply to a thread POST /threads/:threadId/reply Atomically appends to replies array, increments replyCount, updates lastReplyAt
 
+**deleteReply**(collectionId: string,
+    appId: string,
+    threadId: string,
+    replyId: string,
+    admin: boolean = false) → `Promise<AppThread>`
+Delete a single reply from a thread by its reply id (moderation). DELETE /threads/:threadId/reply/:replyId Authorised for the reply's author, the proof owner, or a collection admin.
+
 **aggregate**(collectionId: string,
     appId: string,
     request: AggregateRequest,
@@ -8737,10 +8823,10 @@ Gets current account information for the logged in user. Returns user, owner, ac
 ### authKit
 
 **login**(clientId: string, email: string, password: string, trustedDeviceToken?: string) → `Promise<AuthLoginResponse>`
-Login with email + password (public). When the client's MFA policy requires a step-up, the server returns **403 `MFA_REQUIRED`** instead of a session — `login()` throws a `SmartlinksApiError` with `err.errorResponse?.errorCode === 'MFA_REQUIRED'` and the challenge details in `err.details` (see {@link MfaRequiredDetails}). Route the caller to {@link mfaChallengeSend} on that error; this method's return type is unchanged. returned one (via {@link mfaChallengeVerify}/{@link mfaRecoveryCode} with `trustDevice: true`), pass it here to skip the challenge entirely as long as it's still valid. If it's revoked/expired, the server silently falls back to requiring a fresh challenge — `login()` just returns `MFA_REQUIRED` again, no special handling.
+Login with email + password (public). When the client's MFA policy requires a step-up, the server returns **403 `MFA_REQUIRED`** instead of a session — `login()` throws a `SmartlinksApiError` with `err.errorResponse?.errorCode === 'MFA_REQUIRED'` and the challenge details in `err.details` (see {@link MfaRequiredDetails}). Route the caller to {@link mfaChallengeSend} on that error; this method's return type is unchanged. returned one (via {@link mfaChallengeVerify}/{@link mfaRecoveryCode} with `trustDevice: true`), pass it here to skip the challenge entirely as long as it's still valid. If it's revoked/expired, the server silently falls back to requiring a fresh challenge — `login()` just returns `MFA_REQUIRED` again, no special handling. Security errors (thrown as `SmartlinksApiError`, see {@link LoginSecurityErrorCode}): - `ACCOUNT_TEMPORARILY_LOCKED` (429) — `err.details.retryAfterSeconds` says how long to wait. - `PASSWORD_EXPIRED` (403) — `err.details.resetToken` is short-lived; route into {@link completePasswordReset} to change the password in place.
 
 **register**(clientId: string, data: { email: string; password: string; displayName?: string; accountData?: Record<string, any> }) → `Promise<AuthLoginResponse>`
-Register a new user (public). Not gated by step-up MFA — a brand-new user has no enrolled factors yet, so there's nothing to challenge against.
+Register a new user (public). Not gated by step-up MFA — a brand-new user has no enrolled factors yet, so there's nothing to challenge against. The new password is validated against the collection's `passwordPolicy` — may throw a {@link PasswordPolicyErrorCode} (400). The same validation applies to {@link completePasswordReset} and {@link changePassword}. Read the policy for a live checklist from `authKit.load(clientId)` → `config.security.passwordPolicy`.
 
 **googleLogin**(clientId: string, idToken: string, trustedDeviceToken?: string) → `Promise<AuthLoginResponse>`
 Google OAuth login via ID token (public). Gated by step-up MFA — see {@link login} for the `MFA_REQUIRED` error shape. {@link mfaChallengeVerify}/{@link mfaRecoveryCode} (with `trustDevice: true`) to skip the challenge on this device, same as {@link login}.
@@ -9941,14 +10027,14 @@ List all Proofs for a Collection.
 
 **create**(collectionId: string,
     productId: string,
-    values: ProofCreateRequest) → `Promise<ProofResponse>`
-Create a proof for a product (admin only). POST /admin/collection/:collectionId/product/:productId/proof
+    request: ProofCreateRequest) → `Promise<ProofResponse>`
+Create a proof for a product (admin only). POST /admin/collection/:collectionId/product/:productId/proof Pass the proof's content in a `proof` block, keyed by zone (see {@link ProofWrite}): ```ts proof.create(collectionId, productId, { proof: { values: { colour: 'red' },   // public + owner readable, owner + admin writable data:   { serialNo: 1001 },  // public + owner readable, ADMIN-only writable admin:  { costPrice: 4.20 }, // admin-only }, claimable: true, }) ``` Note: a top-level `data`/`admin` on the request body is legacy — top-level `data` gets folded into the values bag, so use `proof.data` for `proof.data`.
 
 **update**(collectionId: string,
     productId: string,
     proofId: string,
     values: ProofUpdateRequest) → `Promise<ProofResponse>`
-Update a proof for a product (admin only). PUT /admin/collection/:collectionId/product/:productId/proof/:proofId
+Update a proof for a product (admin only). PUT /admin/collection/:collectionId/product/:productId/proof/:proofId Pass the fields to change **at the root**, keyed by zone (see {@link ProofWrite}): ```ts proof.update(collectionId, productId, proofId, { data:   { serialNo: 1002 },   // → proof.data (admin-only writable) values: { colour: 'blue' },   // → proof.values }) ``` Object zones deep-merge, so you can change one field without wiping the rest.
 
 **claim**(collectionId: string,
     productId: string,

package/docs/app-objects.md

@@ -429,6 +429,71 @@ const productComments = await app.threads.list(collectionId, appId, {
 });
 ```
 
+### Anchoring to app entities and proofs
+
+Anchor a thread to your own entity with `parentType` + `parentId`. `parentId` is a
+free-form string (SmartLinks short ids, not just UUIDs), so you can use your app's
+native ids directly — no need to stash them in `body` or a tag.
+
+```typescript
+await app.threads.create(collectionId, appId, {
+  parentType: 'memory',
+  parentId: memoryId,          // e.g. "dVdthBQLAjQEnitU7aWy" — text, not a UUID
+  proofId,                     // anchor to a proof (enables grant-tier reads)
+  body: { text: 'Lovely photo' },
+});
+```
+
+List filters that pair with this (see `ThreadListQueryParams`):
+
+| Param | Purpose |
+|-------|---------|
+| `parentType` / `parentId` | one app entity's threads |
+| `parentIds` | **batch** — every thread for many entities in one call (e.g. a feed) |
+| `proofId` / `productId` | threads anchored to a proof / product |
+
+```typescript
+// One request for the 30 memories currently on screen:
+const feed = await app.threads.list(collectionId, appId, {
+  parentType: 'memory',
+  parentIds: visibleMemoryIds,
+  sort: 'createdAt:desc',
+});
+```
+
+### Atomic first comment (`firstReply`)
+
+Posting the first comment no longer needs a create-thread-then-reply two-step (which
+could leave an orphan empty thread if the reply failed). Pass `firstReply` to create
+the thread and its first reply in one atomic call:
+
+```typescript
+await app.threads.create(collectionId, appId, {
+  parentType: 'memory', parentId: memoryId, proofId,
+  firstReply: { text: 'Lovely photo', authorName: 'Sam' },
+});
+```
+
+### Deleting a reply (moderation)
+
+Replies carry a stable `id`. Remove a single one — authorised for the reply's author,
+the proof owner, or a collection admin:
+
+```typescript
+await app.threads.deleteReply(collectionId, appId, threadId, replyId);
+```
+
+### Grant-tier access (private, shareable comments)
+
+A comment thread on a shared album should be `visibility: 'owner'` (private to the
+proof), with access coming from a **share grant** rather than opening the data to the
+world. A holder of an active `read`/`comment` grant on the proof is treated as
+owner-tier **for that proof only**. Enable it with the `publicCreate.threads.grant`
+policy branch and carry the token via `setGrantToken`.
+
+See **[Proof Share Grants](proof-share-grants.md)** for the full flow (create/redeem
+grants, guest commenting, revocation, and the app config).
+
 ---
 
 ## Records

package/docs/assets.md

@@ -243,6 +243,87 @@ await Api.asset.bulkDelete({
 
 ---
 
+## Resumable uploads (large files, e.g. video)
+
+`asset.upload()` is a single request — if the connection drops, the whole file
+restarts. For large files on flaky connections (e.g. phone video), use a
+**resumable** upload: the file is chunked directly to storage and can be paused,
+resumed, and — crucially — **continued after a page reload or app restart**.
+
+```typescript
+import { asset } from '@proveanything/smartlinks'
+
+// 1. Open a resumable upload.
+const handle = await asset.createResumableUpload({
+  file,                                   // a File (input[type=file] / drag-drop)
+  scope: { type: 'proof', collectionId, productId, proofId },
+  appId: 'photo-memory',
+  // token: uploadToken,                  // for public/token uploads (see below)
+})
+
+// 2. Persist handle.id so the upload survives a reload.
+localStorage.setItem('pendingUpload', handle.id)
+
+// 3. Upload. Resumes automatically from the offset storage already holds.
+const uploaded = await handle.start({
+  onProgress: (pct) => setProgress(pct),  // 0–100
+  signal: abortController.signal,         // optional: cancel a stalled upload
+})
+localStorage.removeItem('pendingUpload')
+```
+
+### Pause / resume, and resume after a reload
+
+```typescript
+handle.pause()                            // stop after the current chunk
+await handle.resume({ onProgress })       // continue
+
+// After a reload / app kill — rehydrate from the persisted id and the same file:
+const saved = localStorage.getItem('pendingUpload')
+if (saved) {
+  const handle = await asset.resumeUpload(saved, file)
+  await handle.start({ onProgress })      // continues, does not restart
+}
+```
+
+### API
+
+```typescript
+namespace asset {
+  createResumableUpload(options: CreateResumableUploadOptions): Promise<ResumableUploadHandle>
+  resumeUpload(handleId: string, file: File): Promise<ResumableUploadHandle>
+}
+
+interface CreateResumableUploadOptions {
+  file: File
+  scope: { type: 'collection'; collectionId: string }
+       | { type: 'product'; collectionId: string; productId: string }
+       | { type: 'proof'; collectionId: string; productId: string; proofId: string }
+  name?: string
+  metadata?: Record<string, any>
+  appId?: string
+  admin?: boolean          // admin route (default is the public route)
+  token?: string           // upload token for public/unauthenticated uploads
+}
+
+interface ResumableUploadHandle {
+  readonly id: string      // durable, persistable — pass to resumeUpload() after a reload
+  readonly size: number    // total bytes
+  start(opts?: { onProgress?: (pct: number) => void; signal?: AbortSignal }): Promise<Asset>
+  pause(): void
+  resume(opts?: { onProgress?: (pct: number) => void; signal?: AbortSignal }): Promise<Asset>
+}
+```
+
+**Notes**
+
+- `handle.id` is an opaque string that carries everything needed to resume — persist it as-is.
+- On completion, `start()`/`resume()` resolves to the finalized `Asset` record.
+- `pause()` causes the in-flight `start()`/`resume()` promise to reject with an `UploadPausedError`; call `resume()` to continue.
+- `asset.upload()` also now accepts an `AbortSignal` (`upload({ ..., signal })`) for cancelling a stalled single-shot upload.
+
+---
+
 ## Public (token-based) uploads
 
 For anonymous or contact-initiated uploads from the portal — no admin auth required.

package/docs/auth-kit.md

@@ -502,6 +502,79 @@ await authKit.completePasswordReset(clientId, tokenFromUrl, 'newSecurePassword')
 
 ---
 
+## Account security policy
+
+Each collection can configure account-security rules (via the admin console). **The API
+enforces all of it**; your login UI reads the policy for UX only (a live password checklist,
+idle sign-out). Read it from the config:
+
+```ts
+const config = await authKit.load(clientId);
+const policy  = config.security?.passwordPolicy; // min length, char classes, block-common
+const session = config.security?.session;        // inactivity + absolute timeouts, rememberMe
+```
+
+`lockout` values are admin-only and never returned here.
+
+### Password policy
+
+`register`, `completePasswordReset`, and `changePassword` validate the new password
+server-side and throw a `SmartlinksApiError` with a {@link PasswordPolicyErrorCode}:
+
+| `errorCode` (400) | Meaning |
+|---|---|
+| `PASSWORD_TOO_SHORT` | below `minLength` |
+| `PASSWORD_REQUIREMENTS_NOT_MET` | missing a required character class |
+| `PASSWORD_TOO_COMMON` | on the common/breached list |
+| `PASSWORD_RECENTLY_USED` | matched one of the last `historyCount` passwords |
+
+Render a live checklist from `policy` so users see the rules before submitting.
+
+### Lockout
+
+After too many failed logins the account is temporarily locked. `login` throws:
+
+```ts
+try {
+  await authKit.login(clientId, email, password);
+} catch (err) {
+  if (err.errorCode === 'ACCOUNT_TEMPORARILY_LOCKED') {
+    const mins = Math.ceil(err.details.retryAfterSeconds / 60);
+    show(`Too many attempts. Try again in ${mins} minute(s).`);
+  }
+}
+```
+
+Failed MFA challenges count toward the same lock. Locking responds identically for unknown
+accounts (no enumeration).
+
+### Password expiry
+
+If a password is older than `passwordPolicy.expiryDays`, a valid login is refused with
+**403 `PASSWORD_EXPIRED`** carrying a short-lived `resetToken` — send the user straight into
+the reset form to change it in place:
+
+```ts
+catch (err) {
+  if (err.errorCode === 'PASSWORD_EXPIRED') {
+    await authKit.completePasswordReset(clientId, err.details.resetToken, newPassword);
+  }
+}
+```
+
+### Session lifetime
+
+- **Absolute timeout** (`session.absoluteTimeoutHours`) is enforced server-side on the native
+  refresh path: once the session is too old, `refreshToken` throws **401 `SESSION_EXPIRED`**
+  (see {@link RefreshErrorCode}) — clear storage and route to login. Web sessions use the
+  stateless bearer token and rely on inactivity sign-out below.
+- **Inactivity timeout** (`session.inactivityTimeoutMinutes` / `inactivityWarningSeconds`) is
+  **client-enforced** — sign the user out after idle, warning first. Sync across tabs.
+- **`session.rememberMe: false`** → don't persist tokens to durable storage; treat the session
+  as browser-scoped.
+
+---
+
 ## Relationship to other parts of the SDK
 
 | Concern | Where it lives |

package/docs/proof-share-grants.md

@@ -0,0 +1,232 @@
+# Proof Share Grants
+
+Delegated, scoped, **revocable** bearer access to a single proof — the middle tier
+between "public" (everyone) and "owner" (only the signed-in owner).
+
+A grant lets an owner hand out a link that lets specific recipients **see or do
+specific things on one proof for a limited time**, without those recipients needing
+a SmartLinks account or a proof claim. Typical uses: sharing a private photo album,
+letting guests comment on it, or publishing a verifiable "I own this" assertion.
+
+---
+
+## Concepts
+
+A **grant** is a row issued by the proof owner (or a collection admin) and redeemed
+by a bearer holding an opaque token. Every data request that touches the proof
+re-checks the grant **server-side** against the database, so revocation is immediate.
+
+### Scopes — what a grant authorises
+
+| Scope | Grants the bearer… |
+|-------|--------------------|
+| `read` | read owner-tier data on the proof (attestations, threads, records, cases) |
+| `comment` | create threads/replies on the proof (guest comments) |
+| `admin` | read owner-tier data (reserved for elevated share cases; never exposes the platform admin zone) |
+| `verify_owner` | redeem a shareable ownership **assertion** (not the account) |
+
+A grant can carry several scopes, e.g. `['read', 'comment']` for a shareable,
+commentable album.
+
+### Security & lifecycle
+
+- The token is opaque, unguessable, and returned to the issuer **exactly once** (on `createGrant`). It is never returned by `listGrants`.
+- **Revocation is immediate** — the grant is re-checked on every request, so `revokeGrant` invalidates a token across all clients at once.
+- **Auto-invalidation on transfer** — every grant is voided the moment the proof's `ownerId` changes (e.g. a resale/re-claim), so a stale "I own this" link cannot keep resolving.
+- A grant is scoped to **one proof**; it can never widen access to other proofs or collection-level data.
+
+---
+
+## Owner flow — create, list, revoke
+
+```typescript
+import { proof } from '@proveanything/smartlinks'
+
+// Create a read+comment grant that expires in 7 days.
+const grant = await proof.createGrant(collectionId, productId, proofId, {
+  scope: ['read', 'comment'],
+  audience: { kind: 'public_link' },
+  expiresAt: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000),
+})
+
+// `grant.token` is available ONLY here — embed it in your share link now.
+const shareUrl = `https://app.example.com/album?proofId=${proofId}&shareToken=${grant.token}`
+
+// List active + past grants (tokens are never included).
+const grants = await proof.listGrants(collectionId, productId, proofId)
+
+// Stop sharing — takes effect on the very next request from any client.
+await proof.revokeGrant(collectionId, productId, proofId, grant.grantId)
+```
+
+`createGrant` / `listGrants` / `revokeGrant` require the caller to be the **proof
+owner** (or a collection admin) — i.e. a signed-in user whose `bearerToken` is set.
+
+---
+
+## Recipient flow — redeem, then carry the token
+
+A recipient opens the share link, redeems the token once, then sets it as the
+active grant token. From then on **every** SDK request carries the token
+(`X-Grant-Token`), so all proof reads/writes are evaluated against the grant.
+
+```typescript
+import { proof, setGrantToken } from '@proveanything/smartlinks'
+
+const shareToken = new URLSearchParams(location.search).get('shareToken')!
+
+// Redeem once (anonymous or signed-in). Records the redemption; optionally names the guest.
+await proof.redeemGrant(collectionId, productId, proofId, shareToken, {
+  guestName: 'Sam',            // stamped on guest activity when not signed in
+})
+
+// Attach the token to every subsequent request.
+setGrantToken(shareToken)
+
+// Now grant-tier reads succeed — e.g. owner-visibility memories on the proof:
+const { attestations } = await attestation.publicList(collectionId, {
+  subjectType: 'proof', subjectId: proofId,
+})
+
+// Clear it when leaving the shared view:
+setGrantToken(undefined)
+```
+
+> **Persisting across reloads.** `setGrantToken` holds the token in memory. To keep a
+> shared session across reloads, persist `shareToken` yourself (e.g. in `localStorage`)
+> and call `setGrantToken` again on load.
+
+---
+
+## Guest commenting
+
+With a `comment` scope grant, a bearer can post comments even when they are not
+signed in. The app must enable the **grant branch** of the thread create policy
+(see [App config](#app-config)); comments are then created at `visibility: 'owner'`
+(private to the proof) and stamped `authorType: 'guest'`.
+
+```typescript
+import { app } from '@proveanything/smartlinks'
+// setGrantToken(shareToken) has already been called.
+
+// One atomic call — no separate create-then-reply round trip.
+await app.threads.create(collectionId, 'photo-memory', {
+  parentType: 'memory',
+  parentId: memoryId,          // text — SmartLinks short ids are fine (not just UUIDs)
+  proofId,                     // anchor to the proof so grant readers see it
+  firstReply: { text: 'Lovely photo', authorName: 'Sam' },
+})
+```
+
+Other grant holders (and the owner) see these comments because a `read` grant reveals
+`owner`-visibility threads for the proof. See
+[App Objects → Threads](app-objects.md#threads) for the full threads API.
+
+---
+
+## Proof of ownership — `verify_owner`
+
+Ownership itself is **not** a grant — it is `proof.ownerId`, established via the
+existing [claim flow](proof-claiming-methods.md). A `verify_owner` grant only
+publishes a shareable, verifiable **assertion** derived from that ownership, without
+handing over the account:
+
+```typescript
+const grant = await proof.createGrant(collectionId, productId, proofId, {
+  scope: ['verify_owner'],
+})
+
+// The recipient redeems it and gets the assertion — never the account:
+const result = await proof.redeemGrant(collectionId, productId, proofId, grant.token)
+// { proofId, assertsOwnership: true, ownerDisplayName?, issuedAt, expiresAt }
+```
+
+Because grants auto-invalidate on transfer, a resale cannot leave a stale
+"I own this" link in circulation.
+
+---
+
+## What a grant gates
+
+When a valid grant token is present, these public reads elevate to owner-tier for the
+granted proof (and only that proof):
+
+- **Attestations** — `attestation.publicList({ subjectType: 'proof', subjectId })`
+- **Threads / Records / Cases** — `app.threads.list`, `app.records.*`, `app.cases.list`, and the single-item GETs, filtered to the granted proof
+- **Thread creation / replies** — with a `comment` scope grant (see below)
+
+The token never exposes the platform `admin` zone, and only reveals `owner`-visibility
+rows for the granted `proofId`.
+
+---
+
+## App config
+
+Grant-based commenting is opt-in per app, configured on the app's Firestore config
+at `sites/{collectionId}/apps/{appId}` — a `grant` branch alongside
+`anonymous` / `authenticated`:
+
+```jsonc
+{
+  "publicCreate": {
+    "threads": {
+      "grant": {
+        "allow": true,
+        "requireScope": "comment",
+        "enforce": { "visibility": "owner", "status": "open" }
+      }
+    }
+  }
+}
+```
+
+This enables grant-scoped commenting **without** opening up anonymous creation. The
+`enforce.visibility: "owner"` keeps comments private to the proof (visible to the
+owner and other grant holders, not the wider public).
+
+---
+
+## API reference
+
+```typescript
+namespace proof {
+  createGrant(collectionId, productId, proofId, options: CreateGrantOptions): Promise<ProofGrant>
+  listGrants(collectionId, productId, proofId): Promise<ProofGrant[]>
+  revokeGrant(collectionId, productId, proofId, grantId): Promise<void>
+  redeemGrant(collectionId, productId, proofId, token, options?: RedeemGrantOptions): Promise<RedeemGrantResult>
+}
+
+// Attach / clear the active grant token (sent as X-Grant-Token on every request).
+function setGrantToken(token: string | undefined): void
+function getGrantToken(): string | undefined
+
+type GrantScope = 'read' | 'comment' | 'admin' | 'verify_owner'
+
+interface CreateGrantOptions {
+  scope: GrantScope[]                                   // at least one
+  audience?: { kind: 'public_link' } | { kind: 'named'; email?: string; userId?: string }
+  expiresAt?: Date | string
+}
+
+interface RedeemGrantOptions { guestName?: string }
+
+type RedeemGrantResult =
+  | { scope: GrantScope[]; redeemedAt: string }
+  | { proofId: string; assertsOwnership: true; ownerDisplayName?: string; issuedAt?: string; expiresAt?: string }
+
+interface ProofGrant {
+  grantId: string
+  proofId: string
+  productId?: string | null
+  scope: GrantScope[]
+  audience: { kind: 'public_link' | 'named'; email?: string; userId?: string }
+  createdBy: string
+  expiresAt?: string | null
+  revokedAt?: string | null
+  redeemedBy?: { userId?: string; guestName?: string; redeemedAt: string }
+  redeemCount: number
+  createdAt: string
+  updatedAt: string
+  token?: string   // present ONLY on the createGrant response
+}
+```