@proveanything/smartlinks 1.15.15 → 1.15.17

package/dist/api/asset.d.ts

@@ -1,4 +1,4 @@
-import { Asset, AssetResponse, UploadAssetOptions, UploadFromUrlOptions, ListAssetsOptions, GetAssetOptions, RemoveAssetOptions, AdminListAssetsOptions, AdminListAssetsResponse, UpdateAssetOptions, ReplaceAssetFileOptions, DeleteAssetOptions, BulkDeleteAssetsOptions, RequestUploadTokenOptions, UploadTokenResponse, PublicTokenUploadOptions } from "../types/asset";
+import { Asset, AssetResponse, UploadAssetOptions, UploadFromUrlOptions, ListAssetsOptions, GetAssetOptions, RemoveAssetOptions, AdminListAssetsOptions, AdminListAssetsResponse, UpdateAssetOptions, ReplaceAssetFileOptions, DeleteAssetOptions, BulkDeleteAssetsOptions, RequestUploadTokenOptions, UploadTokenResponse, PublicTokenUploadOptions, CreateResumableUploadOptions, ResumableUploadHandle } from "../types/asset";
 export declare namespace asset {
     /**
      * Error type for asset uploads
@@ -136,4 +136,27 @@ export declare namespace asset {
      * has `reviewRequired: true`.
      */
     function publicUploadWithToken(options: PublicTokenUploadOptions): Promise<Asset>;
+    /** Thrown by a resumable `start()`/`resume()` when the caller pauses mid-transfer. */
+    class UploadPausedError extends Error {
+        constructor();
+    }
+    /**
+     * Open a resumable upload for a large file (e.g. video). The bytes are chunked
+     * directly to storage and can be paused/resumed — including after a page reload
+     * or app restart, by persisting `handle.id` and calling {@link resumeUpload}.
+     *
+     * @example
+     * ```ts
+     * const handle = await asset.createResumableUpload({ file, scope, appId })
+     * localStorage.setItem('pendingUpload', handle.id)   // survives reload
+     * const uploaded = await handle.start({ onProgress: p => setPct(p) })
+     * ```
+     */
+    function createResumableUpload(options: CreateResumableUploadOptions): Promise<ResumableUploadHandle>;
+    /**
+     * Resume a previously-created resumable upload after a reload/app restart.
+     * Pass the persisted `handle.id` and the same `File`; the transfer continues
+     * from the offset storage already holds rather than restarting.
+     */
+    function resumeUpload(handleId: string, file: File): Promise<ResumableUploadHandle>;
 }

package/dist/api/asset.js

@@ -104,6 +104,14 @@ export var asset;
                     }
                 };
                 xhr.onerror = () => reject(new AssetUploadError("Network error during asset upload", 'NETWORK_ERROR'));
+                if (options.signal) {
+                    if (options.signal.aborted) {
+                        xhr.abort();
+                        return reject(new AssetUploadError("Upload aborted", 'NETWORK_ERROR'));
+                    }
+                    options.signal.addEventListener('abort', () => xhr.abort(), { once: true });
+                    xhr.onabort = () => reject(new AssetUploadError("Upload aborted", 'NETWORK_ERROR'));
+                }
                 xhr.send(formData);
             });
         }
@@ -529,4 +537,174 @@ export var asset;
         return response.json();
     }
     asset.publicUploadWithToken = publicUploadWithToken;
+    // ---------------------------------------------------------------------------
+    // Resumable uploads (large files, e.g. video) — GCS-backed, chunked, resumable
+    // ---------------------------------------------------------------------------
+    const RESUMABLE_CHUNK_SIZE = 8 * 1024 * 1024; // 8 MiB — must be a multiple of 256 KiB (GCS rule)
+    const RESUMABLE_MAX_RETRIES = 5;
+    /** Thrown by a resumable `start()`/`resume()` when the caller pauses mid-transfer. */
+    class UploadPausedError extends Error {
+        constructor() { super('Upload paused'); this.name = 'UploadPausedError'; }
+    }
+    asset.UploadPausedError = UploadPausedError;
+    function backoff(attempt) {
+        const ms = Math.min(30000, 1000 * Math.pow(2, attempt - 1));
+        return new Promise(r => setTimeout(r, ms));
+    }
+    class ResumableUpload {
+        constructor(uploadId, // signed JWT — capability for finalize
+        sessionUrl, // GCS resumable session URI
+        file, finalizePath, finalizeBody) {
+            this.uploadId = uploadId;
+            this.sessionUrl = sessionUrl;
+            this.file = file;
+            this.finalizePath = finalizePath;
+            this.finalizeBody = finalizeBody;
+            this._paused = false;
+            this._offset = 0;
+        }
+        get id() {
+            const st = { u: this.uploadId, s: this.sessionUrl, n: this.file.name, z: this.file.size, f: this.finalizePath };
+            return JSON.stringify(st);
+        }
+        get size() { return this.file.size; }
+        pause() { this._paused = true; }
+        resume(options) {
+            this._paused = false;
+            return this.start(options);
+        }
+        async start(options) {
+            this._paused = false;
+            const onProgress = options === null || options === void 0 ? void 0 : options.onProgress;
+            const signal = options === null || options === void 0 ? void 0 : options.signal;
+            // Probe the storage offset first — this is what makes resume work after a reload.
+            this._offset = await this.probeOffset(signal);
+            while (this._offset < this.file.size) {
+                if (signal === null || signal === void 0 ? void 0 : signal.aborted)
+                    throw new AssetUploadError('Upload aborted', 'NETWORK_ERROR');
+                if (this._paused)
+                    throw new UploadPausedError();
+                const end = Math.min(this._offset + RESUMABLE_CHUNK_SIZE, this.file.size);
+                const complete = await this.putChunk(this._offset, end, signal);
+                this._offset = end;
+                if (onProgress)
+                    onProgress(Math.round((this._offset / this.file.size) * 100));
+                if (complete)
+                    break;
+            }
+            return post(this.finalizePath, this.finalizeBody);
+        }
+        // PUT with `bytes * /total` returns the current stored offset (or completion).
+        async probeOffset(signal) {
+            const res = await this.putWithRetry({ 'Content-Range': `bytes */${this.file.size}` }, undefined, signal);
+            if (res.status === 200 || res.status === 201)
+                return this.file.size;
+            if (res.status === 308) {
+                const range = res.headers.get('Range');
+                const m = range && /bytes=0-(\d+)/.exec(range);
+                return m ? parseInt(m[1], 10) + 1 : 0;
+            }
+            if (res.status === 404 || res.status === 410)
+                throw new AssetUploadError('Upload session expired', 'UNKNOWN');
+            throw new AssetUploadError(`Unexpected resume-probe status ${res.status}`, 'UNKNOWN');
+        }
+        // Returns true when the final chunk completed the upload (2xx from GCS).
+        async putChunk(start, end, signal) {
+            const blob = this.file.slice(start, end);
+            const res = await this.putWithRetry({ 'Content-Range': `bytes ${start}-${end - 1}/${this.file.size}` }, blob, signal);
+            if (res.status === 200 || res.status === 201)
+                return true;
+            if (res.status === 308)
+                return false;
+            throw new AssetUploadError(`Chunk upload failed (${res.status})`, res.status === 413 ? 'FILE_TOO_LARGE' : 'UNKNOWN');
+        }
+        async putWithRetry(headers, body, signal) {
+            let attempt = 0;
+            while (true) {
+                if (signal === null || signal === void 0 ? void 0 : signal.aborted)
+                    throw new AssetUploadError('Upload aborted', 'NETWORK_ERROR');
+                try {
+                    const res = await fetch(this.sessionUrl, { method: 'PUT', headers, body, signal });
+                    if (res.status >= 500 && attempt < RESUMABLE_MAX_RETRIES) {
+                        attempt++;
+                        await backoff(attempt);
+                        continue;
+                    }
+                    return res;
+                }
+                catch (err) {
+                    if (signal === null || signal === void 0 ? void 0 : signal.aborted)
+                        throw new AssetUploadError('Upload aborted', 'NETWORK_ERROR');
+                    if (attempt < RESUMABLE_MAX_RETRIES) {
+                        attempt++;
+                        await backoff(attempt);
+                        continue;
+                    }
+                    throw new AssetUploadError('Network error during resumable upload', 'NETWORK_ERROR');
+                }
+            }
+        }
+    }
+    function resumableBasePath(opts) {
+        const prefix = (opts.admin && !opts.token) ? '/admin' : '/public';
+        return `${prefix}/collection/${encodeURIComponent(opts.collectionId)}/asset/resumable`;
+    }
+    /**
+     * Open a resumable upload for a large file (e.g. video). The bytes are chunked
+     * directly to storage and can be paused/resumed — including after a page reload
+     * or app restart, by persisting `handle.id` and calling {@link resumeUpload}.
+     *
+     * @example
+     * ```ts
+     * const handle = await asset.createResumableUpload({ file, scope, appId })
+     * localStorage.setItem('pendingUpload', handle.id)   // survives reload
+     * const uploaded = await handle.start({ onProgress: p => setPct(p) })
+     * ```
+     */
+    async function createResumableUpload(options) {
+        const { file, scope, name, appId, token, admin } = options;
+        const base = resumableBasePath({ admin, token, collectionId: scope.collectionId });
+        const startBody = {
+            filename: name || file.name,
+            mime: file.type || 'application/octet-stream',
+            appId,
+        };
+        if (scope.type !== 'collection')
+            startBody.productId = scope.productId;
+        if (scope.type === 'proof')
+            startBody.proofId = scope.proofId;
+        const started = await post(base, startBody, token ? { 'X-Upload-Token': token } : undefined);
+        const finalizePath = `${base}/${encodeURIComponent(started.uploadId)}/complete`;
+        const finalizeBody = {};
+        if (name)
+            finalizeBody.name = name;
+        if (options.metadata)
+            finalizeBody.metadata = options.metadata;
+        return new ResumableUpload(started.uploadId, started.sessionUrl, file, finalizePath, finalizeBody);
+    }
+    asset.createResumableUpload = createResumableUpload;
+    /**
+     * Resume a previously-created resumable upload after a reload/app restart.
+     * Pass the persisted `handle.id` and the same `File`; the transfer continues
+     * from the offset storage already holds rather than restarting.
+     */
+    async function resumeUpload(handleId, file) {
+        let st;
+        try {
+            st = JSON.parse(handleId);
+        }
+        catch (_b) {
+            throw new AssetUploadError('Invalid resumable upload handle', 'UNKNOWN');
+        }
+        if (!st.u || !st.s || !st.f)
+            throw new AssetUploadError('Invalid resumable upload handle', 'UNKNOWN');
+        if (typeof st.z === 'number' && file.size !== st.z) {
+            throw new AssetUploadError('Resumed file does not match the original upload', 'UNKNOWN');
+        }
+        const finalizeBody = {};
+        if (st.n)
+            finalizeBody.name = st.n;
+        return new ResumableUpload(st.u, st.s, file, st.f, finalizeBody);
+    }
+    asset.resumeUpload = resumeUpload;
 })(asset || (asset = {}));

package/dist/api/navigation.js

@@ -122,7 +122,7 @@ export var navigation;
                         type: 'smartlinks-navigate',
                         appId: link.appId,
                         path: link.kind === 'deep' ? deepPath(link.deepLinkId) : '/',
-                        params: link.kind === 'deep' ? ((_b = link.params) !== null && _b !== void 0 ? _b : {}) : {},
+                        params: (link.kind === 'deep' || link.kind === 'app') ? ((_b = link.params) !== null && _b !== void 0 ? _b : {}) : {},
                         target: (_c = link.target) !== null && _c !== void 0 ? _c : '_self',
                     }, '*');
                     return;
@@ -134,7 +134,8 @@ export var navigation;
                 const hash = link.kind === 'deep'
                     ? `#${deepPath(link.deepLinkId)}${qs(link.params)}`
                     : `#/`;
-                const url = `${win.location.pathname}?appId=${encodeURIComponent(link.appId)}${hash}`;
+                const appParams = link.kind === 'app' && link.params ? qs(link.params).replace(/^\?/, '&') : '';
+                const url = `${win.location.pathname}?appId=${encodeURIComponent(link.appId)}${appParams}${hash}`;
                 if (link.target === '_blank') {
                     win.open(url, '_blank', windowFeatures());
                 }

package/dist/api/proof.d.ts

@@ -1,4 +1,4 @@
-import { ProofResponse, ProofCreateRequest, ProofUpdateRequest, ProofClaimRequest } from "../types/proof";
+import { ProofResponse, ProofCreateRequest, ProofUpdateRequest, ProofClaimRequest, ProofGrant, CreateGrantOptions, RedeemGrantOptions, RedeemGrantResult } from "../types/proof";
 export declare namespace proof {
     /**
      * Retrieves a single Proof by Collection ID, Product ID, and Proof ID.
@@ -104,4 +104,22 @@ export declare namespace proof {
     data: {
         targetProductId: string;
     }): Promise<ProofResponse>;
+    /**
+     * Create a share grant on a proof (owner / collection admin only). The returned
+     * grant includes `token` — the opaque bearer secret, available ONLY on this
+     * response. Embed it in a share link and hand recipients {@link redeemGrant} /
+     * {@link setGrantToken}.
+     */
+    function createGrant(collectionId: string, productId: string, proofId: string, options: CreateGrantOptions): Promise<ProofGrant>;
+    /** List the active + past grants on a proof (owner / collection admin only). Tokens are never returned here. */
+    function listGrants(collectionId: string, productId: string, proofId: string): Promise<ProofGrant[]>;
+    /** Revoke a grant by id (owner / collection admin only). Takes effect immediately. */
+    function revokeGrant(collectionId: string, productId: string, proofId: string, grantId: string): Promise<void>;
+    /**
+     * Redeem a grant token (anonymous or signed-in). Records the redemption and
+     * returns the granted scope, or — for a `verify_owner` grant — an ownership
+     * assertion (never the account). After redeeming, call
+     * {@link setGrantToken} so subsequent data requests carry the token.
+     */
+    function redeemGrant(collectionId: string, productId: string, proofId: string, token: string, options?: RedeemGrantOptions): Promise<RedeemGrantResult>;
 }

package/dist/api/proof.js

@@ -156,4 +156,48 @@ export var proof;
         return post(path, data);
     }
     proof.migrate = migrate;
+    // ---------------------------------------------------------------------------
+    // Share grants — delegated, scoped, revocable bearer access to this proof
+    // ---------------------------------------------------------------------------
+    function grantBase(collectionId, productId, proofId) {
+        return `/public/collection/${encodeURIComponent(collectionId)}/product/${encodeURIComponent(productId)}/proof/${encodeURIComponent(proofId)}/grant`;
+    }
+    /**
+     * Create a share grant on a proof (owner / collection admin only). The returned
+     * grant includes `token` — the opaque bearer secret, available ONLY on this
+     * response. Embed it in a share link and hand recipients {@link redeemGrant} /
+     * {@link setGrantToken}.
+     */
+    async function createGrant(collectionId, productId, proofId, options) {
+        const body = { scope: options.scope };
+        if (options.audience)
+            body.audience = options.audience;
+        if (options.expiresAt)
+            body.expiresAt = options.expiresAt instanceof Date ? options.expiresAt.toISOString() : options.expiresAt;
+        return post(grantBase(collectionId, productId, proofId), body);
+    }
+    proof.createGrant = createGrant;
+    /** List the active + past grants on a proof (owner / collection admin only). Tokens are never returned here. */
+    async function listGrants(collectionId, productId, proofId) {
+        return request(grantBase(collectionId, productId, proofId));
+    }
+    proof.listGrants = listGrants;
+    /** Revoke a grant by id (owner / collection admin only). Takes effect immediately. */
+    async function revokeGrant(collectionId, productId, proofId, grantId) {
+        return del(`${grantBase(collectionId, productId, proofId)}/${encodeURIComponent(grantId)}`);
+    }
+    proof.revokeGrant = revokeGrant;
+    /**
+     * Redeem a grant token (anonymous or signed-in). Records the redemption and
+     * returns the granted scope, or — for a `verify_owner` grant — an ownership
+     * assertion (never the account). After redeeming, call
+     * {@link setGrantToken} so subsequent data requests carry the token.
+     */
+    async function redeemGrant(collectionId, productId, proofId, token, options) {
+        const body = { token };
+        if (options === null || options === void 0 ? void 0 : options.guestName)
+            body.guestName = options.guestName;
+        return post(`${grantBase(collectionId, productId, proofId)}/redeem`, body);
+    }
+    proof.redeemGrant = redeemGrant;
 })(proof || (proof = {}));

package/dist/docs/API_SUMMARY.md

@@ -1,6 +1,6 @@
 # Smartlinks API Summary
 
-Version: 1.15.15  |  Generated: 2026-07-29T17:46:34.198Z
+Version: 1.15.17  |  Generated: 2026-08-18T08:10:50.608Z
 
 This is a concise summary of all available API functions and types.
 
@@ -170,6 +170,12 @@ Replace or augment globally applied custom headers.
 **setBearerToken**(token: string | undefined) → `void`
 Allows setting the bearerToken at runtime (e.g. after login/logout). Clears the HTTP cache whenever the token actually changes so that stale user-scoped responses (e.g. /account/profile) are not served after a login or logout event.
 
+**setGrantToken**(token: string | undefined) → `void`
+Set (or clear) the per-proof share-grant token. When set, it is attached as the `X-Grant-Token` header on every request, so a recipient who has opened a shared link can read/comment on the granted proof's data. Pass `undefined` to clear it. The server re-checks the grant against the database on every request, so calling `revokeGrant` invalidates an in-flight token immediately. Clears the GET cache on change so grant-tier responses are not served after the token changes. ```ts // On opening ?proofId=…&shareToken=abc setGrantToken(shareToken) const { attestations } = await proof.get(...)  // now sees owner-tier memories ```
+
+**getGrantToken**() → `string | undefined`
+Returns the currently-set share-grant token, or `undefined`.
+
 **getBearerToken**() → `string | undefined`
 Returns the bearer token currently held by the SDK, or `undefined` if none is set. In proxy mode, credentials are held by the parent frame, not the local SDK, so this returns `undefined` even when the caller is authenticated.
 
@@ -2459,6 +2465,7 @@ interface UploadAssetOptions {
   onProgress?: (percent: number) => void
   appId?: string
   admin?: boolean
+  signal?: AbortSignal
 }
 ```
 
@@ -2639,6 +2646,43 @@ interface PublicTokenUploadOptions {
 }
 ```
 
+**CreateResumableUploadOptions** (interface)
+```typescript
+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
+  * Upload token id (from {@link requestUploadToken}) for public/unauthenticated
+  * uploads. When provided, the public resumable route is used.
+  token?: string
+}
+```
+
+**ResumableStartOptions** (interface)
+```typescript
+interface ResumableStartOptions {
+  onProgress?: (percent: number) => void
+  signal?: AbortSignal
+}
+```
+
+**ResumableUploadHandle** (interface)
+```typescript
+interface ResumableUploadHandle {
+  readonly id: string
+  readonly size: number
+  start(options?: ResumableStartOptions): Promise<Asset>
+  pause(): void
+  resume(options?: ResumableStartOptions): Promise<Asset>
+}
+```
+
 **AssetResponse** = `Asset`
 
 ### attestation
@@ -7249,6 +7293,50 @@ interface ProofFieldsConfig {
 }
 ```
 
+**GrantAudience** (interface)
+```typescript
+interface GrantAudience {
+  kind: 'public_link' | 'named'
+  email?: string
+  userId?: string
+}
+```
+
+**ProofGrant** (interface)
+```typescript
+interface ProofGrant {
+  grantId: string
+  proofId: string
+  productId?: string | null
+  scope: GrantScope[]
+  audience: GrantAudience
+  createdBy: string
+  expiresAt?: string | null
+  revokedAt?: string | null
+  redeemedBy?: { userId?: string; guestName?: string; redeemedAt: string }
+  redeemCount: number
+  createdAt: string
+  updatedAt: string
+  token?: string
+}
+```
+
+**CreateGrantOptions** (interface)
+```typescript
+interface CreateGrantOptions {
+  scope: GrantScope[]
+  audience?: GrantAudience
+  expiresAt?: Date | string
+}
+```
+
+**RedeemGrantOptions** (interface)
+```typescript
+interface RedeemGrantOptions {
+  guestName?: string
+}
+```
+
 **ProofResponse** = `Proof`
 
 **ProofUpdateRequest** = `Partial<ProofCreateRequest>`
@@ -7259,6 +7347,10 @@ interface ProofFieldsConfig {
 
 **ProofFieldDef** = `ScopedFieldDef & { scope?: ProofFieldScope }`
 
+**GrantScope** = `'read' | 'comment' | 'admin' | 'verify_owner'`
+
+**RedeemGrantResult** = ``
+
 ### qr
 
 **QrShortCodeLookupResponse** (interface)
@@ -8479,6 +8571,12 @@ Request a single-use upload token for a public (unauthenticated) upload. The tok
 **publicUploadWithToken**(options: PublicTokenUploadOptions) → `Promise<Asset>`
 Upload a file using a single-use upload token (no admin auth required). Assets are created with `status: 'pending_review'` when the token policy has `reviewRequired: true`.
 
+**createResumableUpload**(options: CreateResumableUploadOptions) → `Promise<ResumableUploadHandle>`
+Open a resumable upload for a large file (e.g. video). The bytes are chunked directly to storage and can be paused/resumed — including after a page reload or app restart, by persisting `handle.id` and calling {@link resumeUpload}. ```ts const handle = await asset.createResumableUpload({ file, scope, appId }) localStorage.setItem('pendingUpload', handle.id)   // survives reload const uploaded = await handle.start({ onProgress: p => setPct(p) }) ```
+
+**resumeUpload**(handleId: string, file: File) → `Promise<ResumableUploadHandle>`
+Resume a previously-created resumable upload after a reload/app restart. Pass the persisted `handle.id` and the same `File`; the transfer continues from the offset storage already holds rather than restarting.
+
 ### async
 
 **enqueueAsyncJob**(collectionId: string,
@@ -9893,6 +9991,30 @@ Get proofs for a batch (admin only). GET /admin/collection/:collectionId/product
     data: { targetProductId: string }) → `Promise<ProofResponse>`
 Migrate a proof to a different product within the same collection (admin only). Because the Firestore ledger document ID is `{productId}-{proofId}`, a proof cannot simply be re-assigned to another product by updating a field — the document must be re-keyed. This endpoint handles that atomically: 1. Reads the source ledger document (`{sourceProductId}-{proofId}`). 2. Writes a new document (`{targetProductId}-{proofId}`) with `productId` and `proofGroup` updated. The short `proofId` (nanoid) is unchanged. 3. Writes a migration history entry to the new document's `history` subcollection (snapshot of the original proof + migration metadata). 4. Copies all subcollections — `assets`, `attestations`, `history` — from the old document to the new one. 5. Deletes the old subcollections and then the old document. Repeated migrations are safe — each one appends a history record; no migration metadata is stored on the proof document itself. ```typescript const migrated = await proof.migrate('coll_123', 'prod_old', 'proof_abc', { targetProductId: 'prod_new', }) console.log(migrated.productId) // 'prod_new' ```
 
+**createGrant**(collectionId: string,
+    productId: string,
+    proofId: string,
+    options: CreateGrantOptions) → `Promise<ProofGrant>`
+Create a share grant on a proof (owner / collection admin only). The returned grant includes `token` — the opaque bearer secret, available ONLY on this response. Embed it in a share link and hand recipients {@link redeemGrant} / {@link setGrantToken}.
+
+**listGrants**(collectionId: string,
+    productId: string,
+    proofId: string) → `Promise<ProofGrant[]>`
+List the active + past grants on a proof (owner / collection admin only). Tokens are never returned here.
+
+**revokeGrant**(collectionId: string,
+    productId: string,
+    proofId: string,
+    grantId: string) → `Promise<void>`
+Revoke a grant by id (owner / collection admin only). Takes effect immediately.
+
+**redeemGrant**(collectionId: string,
+    productId: string,
+    proofId: string,
+    token: string,
+    options?: RedeemGrantOptions) → `Promise<RedeemGrantResult>`
+Redeem a grant token (anonymous or signed-in). Records the redemption and returns the granted scope, or — for a `verify_owner` grant — an ownership assertion (never the account). After redeeming, call {@link setGrantToken} so subsequent data requests carry the token.
+
 ### publicClient
 
 **chat**(collectionId: string,

package/dist/http.d.ts

@@ -49,6 +49,25 @@ export declare function setExtraHeaders(headers: Record<string, string>): void;
  * login or logout event.
  */
 export declare function setBearerToken(token: string | undefined): void;
+/**
+ * Set (or clear) the per-proof share-grant token. When set, it is attached as the
+ * `X-Grant-Token` header on every request, so a recipient who has opened a shared
+ * link can read/comment on the granted proof's data. Pass `undefined` to clear it.
+ *
+ * The server re-checks the grant against the database on every request, so calling
+ * `revokeGrant` invalidates an in-flight token immediately. Clears the GET cache on
+ * change so grant-tier responses are not served after the token changes.
+ *
+ * @example
+ * ```ts
+ * // On opening ?proofId=…&shareToken=abc
+ * setGrantToken(shareToken)
+ * const { attestations } = await proof.get(...)  // now sees owner-tier memories
+ * ```
+ */
+export declare function setGrantToken(token: string | undefined): void;
+/** Returns the currently-set share-grant token, or `undefined`. */
+export declare function getGrantToken(): string | undefined;
 /**
  * Returns the bearer token currently held by the SDK, or `undefined` if none is set.
  * In proxy mode, credentials are held by the parent frame, not the local SDK,

package/dist/http.js

@@ -39,6 +39,12 @@ let extraHeadersGlobal = {};
  * issue refresh tokens and short-lived access tokens. Undefined → web behaviour.
  */
 let clientPlatform = undefined;
+/**
+ * Per-proof share-grant bearer token. When set (via setGrantToken), it is attached
+ * as `X-Grant-Token` on every request so the server can evaluate the grant on any
+ * data call that touches the granted proof (attestations, threads, app data).
+ */
+let grantToken = undefined;
 /** Whether initializeApi has been successfully called at least once. */
 let initialized = false;
 /** Safely returns the current browser hostname, or an empty string in non-browser / Node environments. */
@@ -466,6 +472,34 @@ export function setBearerToken(token) {
     if (cachePersistence !== 'none')
         idbClear().catch(() => { });
 }
+/**
+ * Set (or clear) the per-proof share-grant token. When set, it is attached as the
+ * `X-Grant-Token` header on every request, so a recipient who has opened a shared
+ * link can read/comment on the granted proof's data. Pass `undefined` to clear it.
+ *
+ * The server re-checks the grant against the database on every request, so calling
+ * `revokeGrant` invalidates an in-flight token immediately. Clears the GET cache on
+ * change so grant-tier responses are not served after the token changes.
+ *
+ * @example
+ * ```ts
+ * // On opening ?proofId=…&shareToken=abc
+ * setGrantToken(shareToken)
+ * const { attestations } = await proof.get(...)  // now sees owner-tier memories
+ * ```
+ */
+export function setGrantToken(token) {
+    if (token === grantToken)
+        return;
+    grantToken = token;
+    httpCache.clear();
+    if (cachePersistence !== 'none')
+        idbClear().catch(() => { });
+}
+/** Returns the currently-set share-grant token, or `undefined`. */
+export function getGrantToken() {
+    return grantToken;
+}
 /**
  * Returns the bearer token currently held by the SDK, or `undefined` if none is set.
  * In proxy mode, credentials are held by the parent frame, not the local SDK,
@@ -1107,6 +1141,10 @@ export async function request(path) {
                     headers["AUTHORIZATION"] = `Bearer ${bearerToken}`;
                 if (clientPlatform)
                     headers["X-Client-Platform"] = clientPlatform;
+                if (grantToken)
+                    headers["X-Grant-Token"] = grantToken;
+                if (grantToken)
+                    headers["X-Grant-Token"] = grantToken;
                 if (ngrokSkipBrowserWarning)
                     headers["ngrok-skip-browser-warning"] = "true";
                 const _getDomain = getSourceDomain();
@@ -1182,6 +1220,8 @@ export async function post(path, body, extraHeaders) {
         headers["AUTHORIZATION"] = `Bearer ${bearerToken}`;
     if (clientPlatform)
         headers["X-Client-Platform"] = clientPlatform;
+    if (grantToken)
+        headers["X-Grant-Token"] = grantToken;
     if (ngrokSkipBrowserWarning)
         headers["ngrok-skip-browser-warning"] = "true";
     const _postDomain = getSourceDomain();
@@ -1241,6 +1281,8 @@ export async function put(path, body, extraHeaders) {
         headers["AUTHORIZATION"] = `Bearer ${bearerToken}`;
     if (clientPlatform)
         headers["X-Client-Platform"] = clientPlatform;
+    if (grantToken)
+        headers["X-Grant-Token"] = grantToken;
     if (ngrokSkipBrowserWarning)
         headers["ngrok-skip-browser-warning"] = "true";
     const _putDomain = getSourceDomain();
@@ -1300,6 +1342,8 @@ export async function patch(path, body, extraHeaders) {
         headers["AUTHORIZATION"] = `Bearer ${bearerToken}`;
     if (clientPlatform)
         headers["X-Client-Platform"] = clientPlatform;
+    if (grantToken)
+        headers["X-Grant-Token"] = grantToken;
     if (ngrokSkipBrowserWarning)
         headers["ngrok-skip-browser-warning"] = "true";
     const _patchDomain = getSourceDomain();
@@ -1404,7 +1448,7 @@ export async function requestWithOptions(path, options) {
                 }
             }
             const _rwoDomain = getSourceDomain();
-            const headers = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ "Content-Type": "application/json" }, (apiKey ? { "X-API-Key": apiKey } : {})), (bearerToken ? { "AUTHORIZATION": `Bearer ${bearerToken}` } : {})), (clientPlatform ? { "X-Client-Platform": clientPlatform } : {})), (ngrokSkipBrowserWarning ? { "ngrok-skip-browser-warning": "true" } : {})), (_rwoDomain ? { "X-Source-Domain": _rwoDomain } : {})), extraHeaders);
+            const headers = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ "Content-Type": "application/json" }, (apiKey ? { "X-API-Key": apiKey } : {})), (bearerToken ? { "AUTHORIZATION": `Bearer ${bearerToken}` } : {})), (clientPlatform ? { "X-Client-Platform": clientPlatform } : {})), (grantToken ? { "X-Grant-Token": grantToken } : {})), (ngrokSkipBrowserWarning ? { "ngrok-skip-browser-warning": "true" } : {})), (_rwoDomain ? { "X-Source-Domain": _rwoDomain } : {})), extraHeaders);
             // Merge global custom headers (do not override existing keys from options.headers)
             for (const [k, v] of Object.entries(extraHeadersGlobal))
                 if (!(k in headers))
@@ -1510,6 +1554,8 @@ export async function del(path, extraHeaders) {
         headers["AUTHORIZATION"] = `Bearer ${bearerToken}`;
     if (clientPlatform)
         headers["X-Client-Platform"] = clientPlatform;
+    if (grantToken)
+        headers["X-Grant-Token"] = grantToken;
     if (ngrokSkipBrowserWarning)
         headers["ngrok-skip-browser-warning"] = "true";
     const _delDomain = getSourceDomain();
@@ -1552,6 +1598,8 @@ export function getApiHeaders() {
         headers["AUTHORIZATION"] = `Bearer ${bearerToken}`;
     if (clientPlatform)
         headers["X-Client-Platform"] = clientPlatform;
+    if (grantToken)
+        headers["X-Grant-Token"] = grantToken;
     if (ngrokSkipBrowserWarning)
         headers["ngrok-skip-browser-warning"] = "true";
     const sourceDomain = getSourceDomain();

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { initializeApi, isInitialized, hasAuthCredentials, configureSdkCache, invalidateCache, request, post, put, patch, del, sendCustomProxyMessage, getApiHeaders, isProxyEnabled, setBearerToken, getBearerToken } from "./http";
+export { initializeApi, isInitialized, hasAuthCredentials, configureSdkCache, invalidateCache, request, post, put, patch, del, sendCustomProxyMessage, getApiHeaders, isProxyEnabled, setBearerToken, getBearerToken, setGrantToken, getGrantToken } from "./http";
 export * from "./api";
 export * from "./types";
 export { iframe } from "./iframe";
@@ -17,7 +17,7 @@ export type { AdditionalGtin, ISODateString, JsonPrimitive, JsonValue, ProductCr
 export type { TranslationLookupMode, TranslationContentType, TranslationQuality, TranslationItemStatus, TranslationContextValue, TranslationContext, TranslationLookupRequestBase, TranslationLookupSingleRequest, TranslationLookupBatchRequest, TranslationLookupRequest, TranslationLookupItem, TranslationLookupResponse, ResolvedTranslationItem, ResolvedTranslationResponse, TranslationHashOptions, TranslationResolveOptions, TranslationRecord, TranslationListParams, TranslationListResponse, TranslationUpdateRequest, } from "./types/translations";
 export type { FacetBucket, FacetDefinition, FacetDefinitionWriteInput, FacetGetParams, FacetListParams, FacetListResponse, FacetNamespaceListResponse, FacetQueryRequest, FacetQueryResponse, FacetValue, FacetValueDefinition, FacetValueGetParams, FacetValueListParams, FacetValueListResponse, FacetValueResponse, FacetValueWriteInput, PublicFacetListParams, } from "./types/facets";
 export type { Collection, CollectionResponse, CollectionCreateRequest, CollectionUpdateRequest, DomainTarget, HubAvailabilityResponse, } from "./types/collection";
-export type { Proof, ProofResponse, ProofCreateRequest, ProofUpdateRequest, ProofClaimRequest, } from "./types/proof";
+export type { Proof, ProofResponse, ProofCreateRequest, ProofUpdateRequest, ProofClaimRequest, ProofGrant, GrantScope, GrantAudience, CreateGrantOptions, RedeemGrantOptions, RedeemGrantResult, } from "./types/proof";
 export type { QrShortCodeLookupResponse, } from "./types/qr";
 export type { ReverseTagLookupParams, ReverseTagLookupResponse, } from "./types/tags";
 export type { AdminMobileCapability, ActionableCapability, AdminMobileHostId, AdminMobileEvent, AdminMobileEventCallback, AdminMobileEventSubscriber, ScannerEventSubscriber, // @deprecated — use AdminMobileEventCallback

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/index.ts
 // Top-level entrypoint of the npm package. Re-export initializeApi + all namespaces.
-export { initializeApi, isInitialized, hasAuthCredentials, configureSdkCache, invalidateCache, request, post, put, patch, del, sendCustomProxyMessage, getApiHeaders, isProxyEnabled, setBearerToken, getBearerToken } from "./http";
+export { initializeApi, isInitialized, hasAuthCredentials, configureSdkCache, invalidateCache, request, post, put, patch, del, sendCustomProxyMessage, getApiHeaders, isProxyEnabled, setBearerToken, getBearerToken, setGrantToken, getGrantToken } from "./http";
 export * from "./api";
 export * from "./types";
 // Iframe namespace