@proveanything/smartlinks 1.1.23 → 1.1.25

package/API_SUMMARY.md

@@ -1,6 +1,6 @@
 # Smartlinks API Summary
 
-Version: 1.1.23  |  Generated: 2026-01-07T13:11:08.113Z
+Version: 1.1.25  |  Generated: 2026-01-13T20:40:07.743Z
 
 This is a concise summary of all available API functions and types.
 
@@ -57,6 +57,9 @@ The Smartlinks SDK is organized into the following namespaces:
 
 Core HTTP functions for API configuration and communication:
 
+**isProxyEnabled**() → `boolean`
+Return whether proxy mode is currently enabled.
+
 **initializeApi**(options: {
   baseURL: string
   apiKey?: string
@@ -78,6 +81,11 @@ Replace or augment globally applied custom headers.
 **setBearerToken**(token: string | undefined) → `void`
 Allows setting the bearerToken at runtime (e.g. after login/logout).
 
+**proxyUploadFormData**(path: string,
+  formData: FormData,
+  onProgress?: (percent: number) → `void`
+Upload a FormData payload via proxy with progress events using chunked postMessage. Parent is expected to implement the counterpart protocol.
+
 **request**(path: string) → `Promise<T>`
 Internal helper that performs a GET request to \`\${baseURL}\${path}\`, injecting headers for apiKey or bearerToken if present. Returns the parsed JSON as T, or throws an Error.
 
@@ -125,15 +133,84 @@ interface AppConfigurationResponse {
 
 ### asset
 
-**AssetResponse** (interface)
+**Asset** (interface)
 ```typescript
-interface AssetResponse {
+interface Asset {
   id: string
-  name: string
   url: string
+  name: string
+  mimeType?: string
+  size?: number
+  createdAt?: string
+  metadata?: Record<string, any>
+  assetType?: string
+  type?: string
+  collectionId?: string
+  hash?: string
+  thumbnails?: {
+  x100?: string
+  x200?: string
+  x512?: string
+  [key: string]: string | undefined
+  }
+  site?: string
+  cleanName?: string
 }
 ```
 
+**UploadAssetOptions** (interface)
+```typescript
+interface UploadAssetOptions {
+  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>
+  onProgress?: (percent: number) => void
+  appId?: string
+}
+```
+
+**ListAssetsOptions** (interface)
+```typescript
+interface ListAssetsOptions {
+  scope:
+  | { type: 'collection'; collectionId: string }
+  | { type: 'product'; collectionId: string; productId: string }
+  | { type: 'proof'; collectionId: string; productId: string; proofId: string }
+  appId?: string
+  mimeTypePrefix?: string
+  limit?: number
+  offset?: number
+}
+```
+
+**GetAssetOptions** (interface)
+```typescript
+interface GetAssetOptions {
+  assetId: string
+  scope:
+  | { type: 'collection'; collectionId: string }
+  | { type: 'product'; collectionId: string; productId: string }
+  | { type: 'proof'; collectionId: string; productId: string; proofId: string }
+}
+```
+
+**RemoveAssetOptions** (interface)
+```typescript
+interface RemoveAssetOptions {
+  assetId: string
+  scope:
+  | { type: 'collection'; collectionId: string }
+  | { type: 'product'; collectionId: string; productId: string }
+  | { type: 'proof'; collectionId: string; productId: string; proofId: string }
+}
+```
+
+**AssetResponse** = `Asset`
+
 ### attestation
 
 **AttestationResponse** (interface)
@@ -1552,12 +1629,18 @@ interface TemplateBase {
   collectionId: string
   name: string
   description?: string
-  type: string
+  type: 'pdf' | 'email' | 'multichannel' | 'label'
   resizeMode?: string
   pdf?: {
   base: { url: string }
   orientation: 'portrait' | 'landscape'
   }
+  channels?: {
+  email?: {subject: string; body: string},
+  sms?: { body: string },
+  push: { title: string; body: string, url?: string, iconUrl?: string },
+  wallet?: { header: string; body: string; imageUri?: string }
+  }
   subject?: string
   body?: string
   css?: string
@@ -1794,27 +1877,36 @@ Post a chat message to the AI (admin or public)
 
 ### asset
 
+**upload**(options: UploadAssetOptions) → `Promise<Asset>`
+Upload an asset file
+
 **getForCollection**(collectionId: string,
     assetId: string) → `Promise<AssetResponse>`
+Upload an asset file
 
 **listForCollection**(collectionId: string) → `Promise<AssetResponse[]>`
+Upload an asset file
 
 **getForProduct**(collectionId: string,
     productId: string,
     assetId: string) → `Promise<AssetResponse>`
+Upload an asset file
 
 **listForProduct**(collectionId: string,
     productId: string) → `Promise<AssetResponse[]>`
+Upload an asset file
 
 **getForProof**(collectionId: string,
     productId: string,
     proofId: string,
     assetId: string) → `Promise<AssetResponse>`
+Upload an asset file
 
 **listForProof**(collectionId: string,
     productId: string,
     proofId: string,
     appId?: string) → `Promise<AssetResponse[]>`
+Upload an asset file
 
 **uploadAsset**(collectionId: string,
     productId: string,
@@ -1824,6 +1916,15 @@ Post a chat message to the AI (admin or public)
     onProgress?: (percent: number) → `void`
 Uploads an asset file to a proof, with optional extraData as JSON. Supports progress reporting via onProgress callback (browser only).
 
+**list**(options: ListAssetsOptions) → `Promise<Asset[]>`
+List assets for a given scope
+
+**get**(options: GetAssetOptions) → `Promise<Asset>`
+Get an asset by id within a scope (public)
+
+**remove**(options: RemoveAssetOptions) → `Promise<void>`
+Remove an asset by id within a scope (admin)
+
 ### async
 
 **enqueueAsyncJob**(collectionId: string,

package/README.md

@@ -96,24 +96,174 @@ await product.update('collectionId', 'productId', { description: 'Updated' })
 await product.remove('collectionId', 'productId')
 ```
 
-### Assets (upload)
+### Assets
 
-Browser-side upload to a proof with progress callback:
+Upload, list, get, and remove assets within a scope (collection/product/proof).
+
+#### Upload (new)
 
 ```ts
 import { asset } from '@proveanything/smartlinks'
 
-const result = await asset.uploadAsset(
-  'collectionId',
-  'productId',
-  'proofId',
+const uploaded = await asset.upload({
   file, // File from an <input type="file">
-  { description: 'Uploaded via SDK' },
-  (progress) => console.log(`Upload: ${progress}%`)
-)
-console.log('Uploaded asset:', result)
+  scope: { type: 'proof', collectionId, productId, proofId },
+  name: 'hero.png',
+  metadata: { description: 'Uploaded via SDK' },
+  onProgress: (p) => console.log(`Upload: ${p}%`),
+  // appId: 'microapp-123' // optional
+})
+console.log('Uploaded asset:', uploaded)
+```
+
+Deprecated upload helper (wraps to the new `upload` internally):
+
+```ts
+// @deprecated Use asset.upload(options)
+const legacy = await asset.uploadAsset(collectionId, productId, proofId, file)
 ```
 
+#### List
+
+```ts
+// Collection assets, first 20 images
+const list1 = await asset.list({
+  scope: { type: 'collection', collectionId },
+  mimeTypePrefix: 'image/',
+  limit: 20,
+})
+
+// Product assets, filter by appId
+const list2 = await asset.list({
+  scope: { type: 'product', collectionId, productId },
+  appId: 'microapp-123',
+})
+```
+
+#### Get (scoped)
+
+```ts
+const a = await asset.get({
+  assetId,
+  scope: { type: 'proof', collectionId, productId, proofId },
+})
+```
+
+#### Remove (scoped, admin)
+
+```ts
+await asset.remove({
+  assetId,
+  scope: { type: 'product', collectionId, productId },
+})
+```
+
+#### Asset response example
+
+```json
+{
+  "name": "Screenshot 2025-09-15 at 15.21.14",
+  "assetType": "Image",
+  "type": "png",
+  "collectionId": "ChaseAtlantic",
+  "url": "https://cdn.smartlinks.app/sites%2FChaseAtlantic%2Fimages%2F2025%2F9%2FScreenshot%202025-09-15%20at%2015%2C21%2C14-1757946214537.png",
+  "createdAt": "2005-10-10T23:15:03",
+  "hash": "fb98140a6b41ee69b824f29cc8b6795444246f871e4ab2379528b34a4d16284e",
+  "thumbnails": {
+    "x100": "https://cdn.smartlinks.app/..._100x100.png",
+    "x200": "https://cdn.smartlinks.app/..._200x200.png",
+    "x512": "https://cdn.smartlinks.app/..._512x512.png"
+  },
+  "id": "7k1cGErrlmQ94J8yDlVj",
+  "site": "ChaseAtlantic",
+  "cleanName": "Screenshot 2025-09-15 at 15.21"
+}
+```
+
+#### Proxy mode and uploads
+
+When `initializeApi({ proxyMode: true })` is active (e.g., SDK runs inside an iframe and the parent performs API calls), the SDK serializes `FormData` for upload into a proxy-safe shape and posts a message to the parent window. The parent proxy handler should detect this payload and reconstruct a native `FormData` before performing the actual HTTP request.
+
+- SDK proxy message body shape for uploads:
+  - `{ _isFormData: true, entries: Array<[name: string, value: string | File]> }`
+  - Each entry’s value is either a string or a `File` object (structured-cloneable).
+- Direct XHR uploads are only used when NOT in proxy mode. In proxy mode, the SDK uses the proxy channel and `postMessage`.
+
+Progress support in proxy mode:
+
+- If you pass `onProgress`, the SDK uses an enhanced upload protocol with chunked messages and progress events.
+- Unified envelope protocol (single message shape):
+  - Iframe → Parent
+    - `{ _smartlinksProxyUpload: true, phase: 'start', id, path, method: 'POST', headers, fields, fileInfo }`
+    - `{ _smartlinksProxyUpload: true, phase: 'chunk', id, seq, chunk: ArrayBuffer }`
+    - `{ _smartlinksProxyUpload: true, phase: 'end', id }`
+  - Parent → Iframe
+    - `{ _smartlinksProxyUpload: true, phase: 'ack', id, seq }` (reply via `event.source.postMessage`)
+    - `{ _smartlinksProxyUpload: true, phase: 'progress', id, percent }` (reply via `event.source.postMessage`)
+    - `{ _smartlinksProxyUpload: true, phase: 'done', id, ok, data? | error? }` (reply via `event.source.postMessage`)
+
+Example parent handler (buffered, simple):
+
+```html
+<script>
+  const uploads = new Map();
+  window.addEventListener('message', async (e) => {
+    const m = e.data;
+    if (!m || m._smartlinksProxyUpload !== true) return;
+    const target = e.source; // reply to the sender iframe
+    const origin = e.origin; // consider validating and passing a strict origin
+    switch (m.phase) {
+      case 'start': {
+        uploads.set(m.id, { chunks: [], fields: m.fields, fileInfo: m.fileInfo, path: m.path, headers: m.headers });
+        break;
+      }
+      case 'chunk': {
+        const u = uploads.get(m.id);
+        if (!u) break;
+        u.chunks.push(new Uint8Array(m.chunk));
+        target && target.postMessage({ _smartlinksProxyUpload: true, phase: 'ack', id: m.id, seq: m.seq }, origin);
+        break;
+      }
+      case 'end': {
+        const u = uploads.get(m.id);
+        if (!u) break;
+        const blob = new Blob(u.chunks, { type: u.fileInfo.type || 'application/octet-stream' });
+        const fd = new FormData();
+        for (const [k, v] of u.fields) fd.append(k, v);
+        fd.append(u.fileInfo.key || 'file', blob, u.fileInfo.name || 'upload.bin');
+
+        const xhr = new XMLHttpRequest();
+        xhr.open('POST', (window.SMARTLINKS_API_BASEURL || '') + u.path);
+        for (const [k, v] of Object.entries(u.headers || {})) xhr.setRequestHeader(k, v);
+        xhr.upload.onprogress = (ev) => {
+          if (ev.lengthComputable) {
+            const pct = Math.round((ev.loaded / ev.total) * 100);
+            target && target.postMessage({ _smartlinksProxyUpload: true, phase: 'progress', id: m.id, percent: pct }, origin);
+          }
+        };
+        xhr.onload = () => {
+          const ok = xhr.status >= 200 && xhr.status < 300;
+          try {
+            const data = JSON.parse(xhr.responseText);
+            target && target.postMessage({ _smartlinksProxyUpload: true, phase: 'done', id: m.id, ok, data, error: ok ? undefined : data?.message }, origin);
+          } catch (err) {
+            target && target.postMessage({ _smartlinksProxyUpload: true, phase: 'done', id: m.id, ok: false, error: 'Invalid server response' }, origin);
+          }
+        };
+        xhr.onerror = () => target && target.postMessage({ _smartlinksProxyUpload: true, phase: 'done', id: m.id, ok: false, error: 'Network error' }, origin);
+        xhr.send(fd);
+        uploads.delete(m.id);
+        break;
+      }
+    }
+  });
+</script>
+```
+
+If you maintain the parent proxy, ensure its handler for `_smartlinksProxyRequest`:
+- Detects `body._isFormData === true` and rebuilds `const fd = new FormData(); for (const [k,v] of body.entries) fd.append(k, v);`
+- Issues the HTTP request with that `FormData` and returns the parsed JSON response back to the iframe.
+
 ### AI helpers
 
 ```ts

package/dist/api/asset.d.ts

@@ -1,5 +1,19 @@
-import { AssetResponse } from "../types/asset";
+import { Asset, AssetResponse, UploadAssetOptions, ListAssetsOptions, GetAssetOptions, RemoveAssetOptions } from "../types/asset";
 export declare namespace asset {
+    /**
+     * Error type for asset uploads
+     */
+    class AssetUploadError extends Error {
+        readonly code: 'FILE_TOO_LARGE' | 'INVALID_TYPE' | 'NETWORK_ERROR' | 'UNAUTHORIZED' | 'QUOTA_EXCEEDED' | 'UNKNOWN';
+        readonly details?: Record<string, any> | undefined;
+        constructor(message: string, code: 'FILE_TOO_LARGE' | 'INVALID_TYPE' | 'NETWORK_ERROR' | 'UNAUTHORIZED' | 'QUOTA_EXCEEDED' | 'UNKNOWN', details?: Record<string, any> | undefined);
+    }
+    /**
+     * Upload an asset file
+     * @returns The uploaded asset with its public URL
+     * @throws AssetUploadError if upload fails
+     */
+    function upload(options: UploadAssetOptions): Promise<Asset>;
     function getForCollection(collectionId: string, assetId: string): Promise<AssetResponse>;
     function listForCollection(collectionId: string): Promise<AssetResponse[]>;
     function getForProduct(collectionId: string, productId: string, assetId: string): Promise<AssetResponse>;
@@ -8,6 +22,7 @@ export declare namespace asset {
     function listForProof(collectionId: string, productId: string, proofId: string, appId?: string): Promise<AssetResponse[]>;
     /**
      * Uploads an asset file to a proof, with optional extraData as JSON.
+     * @deprecated Use `asset.upload(options)` instead.
      * Supports progress reporting via onProgress callback (browser only).
      * @param collectionId - The collection ID
      * @param productId - The product ID
@@ -18,4 +33,16 @@ export declare namespace asset {
      * @returns Promise resolving to an AssetResponse object
      */
     function uploadAsset(collectionId: string, productId: string, proofId: string, file: File, extraData?: Record<string, any>, onProgress?: (percent: number) => void): Promise<AssetResponse>;
+    /**
+     * List assets for a given scope
+     */
+    function list(options: ListAssetsOptions): Promise<Asset[]>;
+    /**
+     * Get an asset by id within a scope (public)
+     */
+    function get(options: GetAssetOptions): Promise<Asset>;
+    /**
+     * Remove an asset by id within a scope (admin)
+     */
+    function remove(options: RemoveAssetOptions): Promise<void>;
 }

package/dist/api/asset.js

@@ -1,6 +1,124 @@
-import { request, getApiHeaders } from "../http";
+import { request, post, del, getApiHeaders, isProxyEnabled, proxyUploadFormData } from "../http";
 export var asset;
 (function (asset) {
+    /**
+     * Error type for asset uploads
+     */
+    class AssetUploadError extends Error {
+        constructor(message, code, details) {
+            super(message);
+            this.code = code;
+            this.details = details;
+            this.name = 'AssetUploadError';
+        }
+    }
+    asset.AssetUploadError = AssetUploadError;
+    function buildScopeBase(scope) {
+        if (scope.type === 'collection') {
+            return `/public/collection/${encodeURIComponent(scope.collectionId)}`;
+        }
+        if (scope.type === 'product') {
+            return `/public/collection/${encodeURIComponent(scope.collectionId)}/product/${encodeURIComponent(scope.productId)}`;
+        }
+        // proof
+        return `/public/collection/${encodeURIComponent(scope.collectionId)}/product/${encodeURIComponent(scope.productId)}/proof/${encodeURIComponent(scope.proofId)}`;
+    }
+    /**
+     * Upload an asset file
+     * @returns The uploaded asset with its public URL
+     * @throws AssetUploadError if upload fails
+     */
+    async function upload(options) {
+        const base = buildScopeBase(options.scope);
+        let path = `${base}/asset`;
+        if (options.appId) {
+            const qp = new URLSearchParams({ appId: options.appId });
+            path += `?${qp.toString()}`;
+        }
+        const formData = new FormData();
+        formData.append("file", options.file);
+        if (options.name)
+            formData.append("name", options.name);
+        if (options.metadata)
+            formData.append("metadata", JSON.stringify(options.metadata));
+        // If progress callback provided and NOT in proxy mode, use XHR for progress events (browser-only)
+        if (options.onProgress && typeof window !== "undefined" && !isProxyEnabled()) {
+            const url = (typeof window !== "undefined" && window.SMARTLINKS_API_BASEURL)
+                ? window.SMARTLINKS_API_BASEURL + path
+                : path;
+            const headers = getApiHeaders ? getApiHeaders() : {};
+            return new Promise((resolve, reject) => {
+                const xhr = new XMLHttpRequest();
+                xhr.open("POST", url);
+                for (const [key, value] of Object.entries(headers))
+                    xhr.setRequestHeader(key, value);
+                xhr.upload.onprogress = (event) => {
+                    if (options.onProgress && event.lengthComputable) {
+                        const percent = Math.round((event.loaded / event.total) * 100);
+                        options.onProgress(percent);
+                    }
+                };
+                xhr.onload = () => {
+                    const status = xhr.status;
+                    const text = xhr.responseText;
+                    if (status >= 200 && status < 300) {
+                        try {
+                            resolve(JSON.parse(text));
+                        }
+                        catch (e) {
+                            reject(new AssetUploadError("Failed to parse server response", 'UNKNOWN'));
+                        }
+                    }
+                    else {
+                        try {
+                            const errBody = JSON.parse(text);
+                            const code = mapStatusToUploadErrorCode(status, errBody === null || errBody === void 0 ? void 0 : errBody.code);
+                            reject(new AssetUploadError((errBody === null || errBody === void 0 ? void 0 : errBody.message) || `Upload failed (${status})`, code, errBody));
+                        }
+                        catch (_a) {
+                            const code = mapStatusToUploadErrorCode(status);
+                            reject(new AssetUploadError(`Asset upload failed with status ${status}`, code));
+                        }
+                    }
+                };
+                xhr.onerror = () => reject(new AssetUploadError("Network error during asset upload", 'NETWORK_ERROR'));
+                xhr.send(formData);
+            });
+        }
+        // If in proxy mode and progress requested, use enhanced proxy upload to support progress
+        if (options.onProgress && isProxyEnabled()) {
+            try {
+                return await proxyUploadFormData(path, formData, options.onProgress);
+            }
+            catch (e) {
+                const msg = (e === null || e === void 0 ? void 0 : e.message) || 'Upload failed';
+                throw new AssetUploadError(msg, 'UNKNOWN');
+            }
+        }
+        // Otherwise use fetch helper (in proxy mode this becomes a postMessage with serialized FormData)
+        try {
+            return await post(path, formData);
+        }
+        catch (e) {
+            // Map generic Error to AssetUploadError
+            const msg = (e === null || e === void 0 ? void 0 : e.message) || 'Upload failed';
+            throw new AssetUploadError(msg, 'UNKNOWN');
+        }
+    }
+    asset.upload = upload;
+    function mapStatusToUploadErrorCode(status, serverCode) {
+        if (status === 401 || status === 403)
+            return 'UNAUTHORIZED';
+        if (status === 413)
+            return 'FILE_TOO_LARGE';
+        if (status === 415)
+            return 'INVALID_TYPE';
+        if (status === 429)
+            return 'QUOTA_EXCEEDED';
+        if (status === 0)
+            return 'NETWORK_ERROR';
+        return 'UNKNOWN';
+    }
     // Collection-level
     async function getForCollection(collectionId, assetId) {
         const path = `/public/collection/${encodeURIComponent(collectionId)}/asset/${encodeURIComponent(assetId)}`;
@@ -39,6 +157,7 @@ export var asset;
     asset.listForProof = listForProof;
     /**
      * Uploads an asset file to a proof, with optional extraData as JSON.
+     * @deprecated Use `asset.upload(options)` instead.
      * Supports progress reporting via onProgress callback (browser only).
      * @param collectionId - The collection ID
      * @param productId - The product ID
@@ -49,52 +168,60 @@ export var asset;
      * @returns Promise resolving to an AssetResponse object
      */
     async function uploadAsset(collectionId, productId, proofId, file, extraData, onProgress) {
-        const path = `/public/collection/${encodeURIComponent(collectionId)}/product/${encodeURIComponent(productId)}/proof/${encodeURIComponent(proofId)}/asset`;
-        const url = (typeof window !== "undefined" && window.SMARTLINKS_API_BASEURL)
-            ? window.SMARTLINKS_API_BASEURL + path
-            : path; // fallback for SSR or Node
-        const formData = new FormData();
-        formData.append("file", file);
-        if (extraData) {
-            formData.append("extraData", JSON.stringify(extraData));
-        }
-        // Use getApiHeaders from http module
-        const headers = getApiHeaders ? getApiHeaders() : {};
-        return new Promise((resolve, reject) => {
-            const xhr = new XMLHttpRequest();
-            xhr.open("POST", url);
-            // Set headers for API key and bearer token if available
-            for (const [key, value] of Object.entries(headers)) {
-                xhr.setRequestHeader(key, value);
-            }
-            xhr.upload.onprogress = (event) => {
-                if (onProgress && event.lengthComputable) {
-                    const percent = Math.round((event.loaded / event.total) * 100);
-                    onProgress(percent);
-                }
-            };
-            xhr.onload = () => {
-                if (xhr.status >= 200 && xhr.status < 300) {
-                    try {
-                        resolve(JSON.parse(xhr.responseText));
-                    }
-                    catch (e) {
-                        reject(new Error("Failed to parse server response"));
-                    }
-                }
-                else {
-                    try {
-                        const errBody = JSON.parse(xhr.responseText);
-                        reject(new Error(`Error ${errBody.code}: ${errBody.message}`));
-                    }
-                    catch (_a) {
-                        reject(new Error(`Asset upload failed with status ${xhr.status}`));
-                    }
-                }
-            };
-            xhr.onerror = () => reject(new Error("Network error during asset upload"));
-            xhr.send(formData);
+        // Route through new upload API for backward compatibility
+        const res = await upload({
+            file,
+            name: file === null || file === void 0 ? void 0 : file.name,
+            metadata: extraData,
+            onProgress,
+            scope: { type: 'proof', collectionId, productId, proofId },
         });
+        return res;
     }
     asset.uploadAsset = uploadAsset;
+    /**
+     * List assets for a given scope
+     */
+    async function list(options) {
+        const base = buildScopeBase(options.scope);
+        const params = new URLSearchParams();
+        if (options.appId)
+            params.set('appId', options.appId);
+        if (options.mimeTypePrefix)
+            params.set('mimeTypePrefix', options.mimeTypePrefix);
+        if (typeof options.limit === 'number')
+            params.set('limit', String(options.limit));
+        if (typeof options.offset === 'number')
+            params.set('offset', String(options.offset));
+        const path = `${base}/asset${params.toString() ? `?${params}` : ''}`;
+        return request(path);
+    }
+    asset.list = list;
+    /**
+     * Get an asset by id within a scope (public)
+     */
+    async function get(options) {
+        const base = buildScopeBase(options.scope);
+        const path = `${base}/asset/${encodeURIComponent(options.assetId)}`;
+        return request(path);
+    }
+    asset.get = get;
+    /**
+     * Remove an asset by id within a scope (admin)
+     */
+    async function remove(options) {
+        const scope = options.scope;
+        let path;
+        if (scope.type === 'collection') {
+            path = `/admin/collection/${encodeURIComponent(scope.collectionId)}/asset/${encodeURIComponent(options.assetId)}`;
+        }
+        else if (scope.type === 'product') {
+            path = `/admin/collection/${encodeURIComponent(scope.collectionId)}/product/${encodeURIComponent(scope.productId)}/asset/${encodeURIComponent(options.assetId)}`;
+        }
+        else {
+            path = `/admin/collection/${encodeURIComponent(scope.collectionId)}/product/${encodeURIComponent(scope.productId)}/proof/${encodeURIComponent(scope.proofId)}/asset/${encodeURIComponent(options.assetId)}`;
+        }
+        return del(path);
+    }
+    asset.remove = remove;
 })(asset || (asset = {}));

package/dist/http.d.ts

@@ -5,6 +5,8 @@ type Logger = {
     error?: (...args: any[]) => void;
     log?: (...args: any[]) => void;
 } | ((...args: any[]) => void);
+/** Return whether proxy mode is currently enabled. */
+export declare function isProxyEnabled(): boolean;
 export declare function initializeApi(options: {
     baseURL: string;
     apiKey?: string;
@@ -23,6 +25,11 @@ export declare function setExtraHeaders(headers: Record<string, string>): void;
  * Allows setting the bearerToken at runtime (e.g. after login/logout).
  */
 export declare function setBearerToken(token: string | undefined): void;
+/**
+ * Upload a FormData payload via proxy with progress events using chunked postMessage.
+ * Parent is expected to implement the counterpart protocol.
+ */
+export declare function proxyUploadFormData<T>(path: string, formData: FormData, onProgress?: (percent: number) => void): Promise<T>;
 /**
  * Internal helper that performs a GET request to \`\${baseURL}\${path}\`,
  * injecting headers for apiKey or bearerToken if present.

package/dist/http.js

@@ -19,6 +19,10 @@ function logDebug(...args) {
     if (logger.log)
         return logger.log(...args);
 }
+/** Return whether proxy mode is currently enabled. */
+export function isProxyEnabled() {
+    return proxyMode;
+}
 function maskSensitive(value) {
     if (!value)
         return value;
@@ -138,15 +142,26 @@ function ensureProxyListener() {
     window._smartlinksProxyListener = true;
 }
 // Proxy request implementation
+function serializeFormDataForProxy(fd) {
+    const entries = [];
+    // FormData#forEach iterates values which can be string | Blob (File extends Blob)
+    fd.forEach((value, key) => {
+        entries.push([key, value]);
+    });
+    return { _isFormData: true, entries };
+}
 async function proxyRequest(method, path, body, headers, options) {
     ensureProxyListener();
+    const payloadBody = (typeof FormData !== 'undefined' && body instanceof FormData)
+        ? serializeFormDataForProxy(body)
+        : body;
     const id = generateProxyId();
     const msg = {
         _smartlinksProxyRequest: true,
         id,
         method,
         path,
-        body,
+        body: payloadBody,
         headers,
         options,
     };
@@ -157,6 +172,140 @@ async function proxyRequest(method, path, body, headers, options) {
         // Optionally: add a timeout here to reject if no response
     });
 }
+/**
+ * Upload a FormData payload via proxy with progress events using chunked postMessage.
+ * Parent is expected to implement the counterpart protocol.
+ */
+export async function proxyUploadFormData(path, formData, onProgress) {
+    var _a;
+    if (!proxyMode) {
+        throw new Error('proxyUploadFormData called when proxyMode is disabled');
+    }
+    ensureProxyListener();
+    // Extract file and plain fields
+    let fileKey = null;
+    let file = null;
+    const fields = [];
+    formData.forEach((value, key) => {
+        const isFile = typeof value !== 'string';
+        if (!file && isFile) {
+            fileKey = key;
+            file = value; // File | Blob in browser
+        }
+        else {
+            fields.push([key, String(value)]);
+        }
+    });
+    if (!file || !fileKey) {
+        throw new Error('proxyUploadFormData requires a File/Blob in FormData');
+    }
+    const id = generateProxyId();
+    const headers = getApiHeaders();
+    let resolveDone;
+    let rejectDone;
+    const done = new Promise((resolve, reject) => { resolveDone = resolve; rejectDone = reject; });
+    function handleMessage(event) {
+        const msg = event.data;
+        if (!msg || msg.id !== id)
+            return;
+        // Unified envelope support
+        if (msg._smartlinksProxyUpload === true) {
+            if (msg.phase === 'progress' && typeof msg.percent === 'number') {
+                try {
+                    onProgress && onProgress(Math.max(0, Math.min(100, Math.round(msg.percent))));
+                }
+                catch (_a) { }
+                return;
+            }
+            if (msg.phase === 'done') {
+                window.removeEventListener('message', handleMessage);
+                if (msg.ok) {
+                    resolveDone(msg.data);
+                }
+                else {
+                    rejectDone(new Error(msg.error || 'Upload failed'));
+                }
+                return;
+            }
+            return;
+        }
+        // Backward-compat flags (older docs)
+        if (msg._smartlinksProxyUploadProgress === true && typeof msg.percent === 'number') {
+            try {
+                onProgress && onProgress(Math.max(0, Math.min(100, Math.round(msg.percent))));
+            }
+            catch (_b) { }
+            return;
+        }
+        if (msg._smartlinksProxyUploadDone === true) {
+            window.removeEventListener('message', handleMessage);
+            if (msg.ok) {
+                resolveDone(msg.data);
+            }
+            else {
+                rejectDone(new Error(msg.error || 'Upload failed'));
+            }
+            return;
+        }
+    }
+    window.addEventListener('message', handleMessage);
+    // Start
+    const startMsg = {
+        _smartlinksProxyUpload: true,
+        phase: 'start',
+        id,
+        path,
+        method: 'POST',
+        headers,
+        fields,
+        fileInfo: { name: file.name || fileKey, size: file.size || undefined, type: file.type || undefined, key: fileKey },
+    };
+    window.parent.postMessage(startMsg, '*');
+    // Send chunks with simple ack pacing
+    const CHUNK_SIZE = 256 * 1024; // 256KB
+    const totalSize = (_a = file.size) !== null && _a !== void 0 ? _a : 0;
+    let offset = 0;
+    let seq = 0;
+    while (totalSize && offset < totalSize) {
+        const end = Math.min(offset + CHUNK_SIZE, totalSize);
+        const blob = file.slice(offset, end);
+        // eslint-disable-next-line no-await-in-loop
+        const buf = await blob.arrayBuffer();
+        const chunkMsg = {
+            _smartlinksProxyUpload: true,
+            phase: 'chunk',
+            id,
+            seq,
+            chunk: buf,
+        };
+        window.parent.postMessage(chunkMsg, '*', [buf]);
+        // Wait for ack for this seq
+        // eslint-disable-next-line no-await-in-loop
+        await new Promise((res) => {
+            function onAck(ev) {
+                const m = ev.data;
+                // Unified envelope ack
+                if (m && m._smartlinksProxyUpload === true && m.id === id && m.phase === 'ack' && m.seq === seq) {
+                    window.removeEventListener('message', onAck);
+                    res();
+                    return;
+                }
+                // Backward-compat ack
+                if (m && m._smartlinksProxyUploadAck === true && m.id === id && m.seq === seq) {
+                    window.removeEventListener('message', onAck);
+                    res();
+                }
+            }
+            window.addEventListener('message', onAck);
+        });
+        offset = end;
+        seq += 1;
+    }
+    // End
+    const endMsg = { _smartlinksProxyUpload: true, phase: 'end', id };
+    window.parent.postMessage(endMsg, '*');
+    return done;
+}
 /**
  * Internal helper that performs a GET request to \`\${baseURL}\${path}\`,
  * injecting headers for apiKey or bearerToken if present.

package/dist/types/asset.d.ts

@@ -1,8 +1,142 @@
+/**
+ * Response from any asset upload or retrieval operation
+ */
 /**
  * Represents an Asset object.
+ *
+ * Example server response shape:
+ * @example
+ * {
+ *   "name": "Screenshot 2025-09-15 at 15.21.14",
+ *   "assetType": "Image",
+ *   "type": "png",
+ *   "collectionId": "myCollection",
+ *   "url": "https://cdn.smartlinks.app/s25-09-15%20at14537.png",
+ *   "createdAt": "2005-10-10T23:15:03",
+ *   "hash": "fb98140a6b41ee69b824f29cc8b6795444246f871e4ab2379528b34a4d16284e",
+ *   "thumbnails": {
+ *     "x100": "https://cdn.smartlinks.app/sit2F..._100x100.png",
+ *     "x200": "https://cdn.smartlinks.app/sit2F..._200x200.png",
+ *     "x512": "https://cdn.smartlinks.app/sit2F..._512x512.png"
+ *   },
+ *   "id": "7k1cGErrlmQ94J8yDlVj",
+ *   "site": "ChaseAtlantic",
+ *   "cleanName": "Screenshot 2025-09-15 at 15.21"
+ * }
  */
-export interface AssetResponse {
+export interface Asset {
+    /** Unique identifier for the asset */
     id: string;
-    name: string;
+    /** The public URL to access the asset */
     url: string;
+    /** Original filename */
+    name: string;
+    /** MIME type (e.g., 'image/jpeg', 'video/mp4') */
+    mimeType?: string;
+    /** File size in bytes */
+    size?: number;
+    /** When the asset was uploaded */
+    createdAt?: string;
+    /** Any custom metadata attached during upload */
+    metadata?: Record<string, any>;
+    /** Optional: broader classification like 'Image' or 'Video' */
+    assetType?: string;
+    /** Optional: file extension/type shorthand (e.g., 'png') */
+    type?: string;
+    /** Optional: owning collection identifier */
+    collectionId?: string;
+    /** Optional: content hash */
+    hash?: string;
+    /** Optional: CDN thumbnail URLs */
+    thumbnails?: {
+        x100?: string;
+        x200?: string;
+        x512?: string;
+        [key: string]: string | undefined;
+    };
+    /** Optional: site identifier alias */
+    site?: string;
+    /** Optional: prettified name */
+    cleanName?: string;
+}
+export type AssetResponse = Asset;
+export interface UploadAssetOptions {
+    /** The file to upload (from input[type="file"] or drag-drop) */
+    file: File;
+    /** Where to attach the asset */
+    scope: {
+        type: 'collection';
+        collectionId: string;
+    } | {
+        type: 'product';
+        collectionId: string;
+        productId: string;
+    } | {
+        type: 'proof';
+        collectionId: string;
+        productId: string;
+        proofId: string;
+    };
+    /** Optional: Custom filename (defaults to file.name) */
+    name?: string;
+    /** Optional: Custom metadata to store with the asset */
+    metadata?: Record<string, any>;
+    /** Optional: Progress callback (0-100) */
+    onProgress?: (percent: number) => void;
+    /** Optional: App ID for scoping to a specific microapp */
+    appId?: string;
+}
+export interface ListAssetsOptions {
+    scope: {
+        type: 'collection';
+        collectionId: string;
+    } | {
+        type: 'product';
+        collectionId: string;
+        productId: string;
+    } | {
+        type: 'proof';
+        collectionId: string;
+        productId: string;
+        proofId: string;
+    };
+    /** Filter by app ID */
+    appId?: string;
+    /** Filter by MIME type prefix (e.g., 'image/', 'video/') */
+    mimeTypePrefix?: string;
+    /** Pagination */
+    limit?: number;
+    offset?: number;
+}
+export interface GetAssetOptions {
+    assetId: string;
+    scope: {
+        type: 'collection';
+        collectionId: string;
+    } | {
+        type: 'product';
+        collectionId: string;
+        productId: string;
+    } | {
+        type: 'proof';
+        collectionId: string;
+        productId: string;
+        proofId: string;
+    };
+}
+export interface RemoveAssetOptions {
+    assetId: string;
+    scope: {
+        type: 'collection';
+        collectionId: string;
+    } | {
+        type: 'product';
+        collectionId: string;
+        productId: string;
+    } | {
+        type: 'proof';
+        collectionId: string;
+        productId: string;
+        proofId: string;
+    };
 }

package/dist/types/template.d.ts

@@ -3,7 +3,7 @@ export interface TemplateBase {
     collectionId: string;
     name: string;
     description?: string;
-    type: string;
+    type: 'pdf' | 'email' | 'multichannel' | 'label';
     resizeMode?: string;
     pdf?: {
         base: {
@@ -11,6 +11,26 @@ export interface TemplateBase {
         };
         orientation: 'portrait' | 'landscape';
     };
+    channels?: {
+        email?: {
+            subject: string;
+            body: string;
+        };
+        sms?: {
+            body: string;
+        };
+        push: {
+            title: string;
+            body: string;
+            url?: string;
+            iconUrl?: string;
+        };
+        wallet?: {
+            header: string;
+            body: string;
+            imageUri?: string;
+        };
+    };
     subject?: string;
     body?: string;
     css?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@proveanything/smartlinks",
-  "version": "1.1.23",
+  "version": "1.1.25",
   "description": "Official JavaScript/TypeScript SDK for the Smartlinks API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",