@stackshift-cloud/sdk 0.1.3 → 1.0.0

package/README.md

@@ -44,16 +44,16 @@ const message = await stackshift.mail.send({
 console.log(message.id, message.status, message.idempotencyStatus)
 ```
 
-Inspect sent messages:
+Inspect MTA-accepted messages:
 
 ```ts
-const messages = await stackshift.mail.messages.list({ status: 'sent', limit: 20 })
+const messages = await stackshift.mail.messages.list({ status: 'mta_accepted', limit: 20 })
 const detail = await stackshift.mail.messages.get(messages.data[0].id)
 const attempts = await stackshift.mail.messages.attempts(detail.id)
 const logs = await stackshift.mail.messages.logs(detail.id)
 ```
 
-In this MVP, `sent` means the message was accepted by StackShift's outbound MTA. It does not mean inbox delivery, opens, clicks, or spam placement. A `sent` message can later become `bounced` if StackShift receives a delivery-status notification.
+`mta_accepted` means StackShift's outbound MTA accepted the message. `delivered` means the recipient MX accepted a recipient; it does not claim inbox placement or human receipt. Recipient records remain authoritative for mixed outcomes.
 
 ## Send a template
 

package/dist/assets-framework.d.ts

@@ -0,0 +1,21 @@
+import { AssetsClient } from './assets.js';
+import type { AssetSignedTransformOptions, AssetSignedUploadUrl, AssetTransformOptions } from './types.js';
+export interface ResponsiveImageOptions extends Omit<AssetSignedTransformOptions, 'width'> {
+    widths: number[];
+    sizes?: string;
+}
+export interface ResponsiveImageDescriptor {
+    src: string;
+    srcSet: string;
+    sizes: string;
+    widthUrls: Record<number, string>;
+}
+/** Shared by Next.js server actions, React/TanStack loaders, and NestJS services. */
+export declare function createResponsiveImage(assets: AssetsClient, assetId: string, options: ResponsiveImageOptions): Promise<ResponsiveImageDescriptor>;
+/** Uploads through a short-lived session without exposing the account API key. */
+export declare function uploadBrowserFile(session: AssetSignedUploadUrl, file: Blob, fetcher?: typeof fetch): Promise<Response>;
+export declare function namedResponsiveSource(assets: AssetsClient, assetId: string, preset: string, widths: number[]): string;
+export type ArtDirectionSource = {
+    media: string;
+    transform: AssetTransformOptions;
+};

package/dist/assets-framework.js

@@ -0,0 +1,34 @@
+/** Shared by Next.js server actions, React/TanStack loaders, and NestJS services. */
+export async function createResponsiveImage(assets, assetId, options) {
+    const widths = [...new Set(options.widths)].filter((width) => Number.isSafeInteger(width) && width > 0).sort((a, b) => a - b);
+    if (widths.length === 0 || widths.length > 12)
+        throw new Error('Responsive images require 1-12 positive integer widths');
+    const { widths: _widths, sizes = '100vw', ...transform } = options;
+    const signed = await Promise.all(widths.map(async (width) => [width, await assets.signedTransformUrl(assetId, { ...transform, width })]));
+    const widthUrls = Object.fromEntries(signed.map(([width, result]) => [width, result.url]));
+    return {
+        src: widthUrls[widths[widths.length - 1]],
+        srcSet: widths.map((width) => `${widthUrls[width]} ${width}w`).join(', '),
+        sizes,
+        widthUrls,
+    };
+}
+/** Uploads through a short-lived session without exposing the account API key. */
+export async function uploadBrowserFile(session, file, fetcher = fetch) {
+    if (session.method !== 'PUT')
+        throw new Error(`Unsupported upload method: ${session.method}`);
+    if (file.size > session.max_bytes)
+        throw new Error(`File exceeds signed upload limit of ${session.max_bytes} bytes`);
+    const response = await fetcher(session.url, {
+        method: session.method,
+        body: file,
+        headers: file.type ? { 'Content-Type': file.type } : undefined,
+    });
+    if (!response.ok)
+        throw new Error(`StackShift browser upload failed with HTTP ${response.status}`);
+    return response;
+}
+export function namedResponsiveSource(assets, assetId, preset, widths) {
+    const clean = [...new Set(widths)].filter((width) => Number.isSafeInteger(width) && width > 0).sort((a, b) => a - b);
+    return clean.map((width) => `${assets.namedUrl(assetId, `${preset}-${width}`)} ${width}w`).join(', ');
+}

package/dist/assets.d.ts

@@ -1,5 +1,5 @@
 import type { StackShift } from './client.js';
-import type { Asset, AssetAIInfo, AssetCollection, AssetContentPolicy, AssetNamedTransformInput, AssetListOptions, AssetListResult, AssetSavedSearch, AssetTranscript, AssetUploadProgressCallbacks, AssetVersion, AssetSignedUploadUrl, AssetSignedUploadUrlOptions, AssetSignedTransformOptions, AssetSignedUrl, AssetSignedUrlOptions, AssetTransformOptions, AssetTransformPreset, AssetUploadOptions } from './types.js';
+import type { Asset, AssetBucket, AssetBucketInput, AssetAIAccountConfig, AssetPatchInput, AssetCustomDomain, AssetEvent, AssetJob, AssetJobSubmission, AssetLifecycleRule, AssetUsageSummary, AssetWebhook, AssetWebhookDelivery, AssetAIInfo, AssetCollection, AssetContentPolicy, AssetNamedTransformInput, AssetListOptions, AssetListResult, AssetSavedSearch, AssetTranscript, AssetUploadProgressCallbacks, AssetVersion, AssetSignedUploadUrl, AssetSignedUploadUrlOptions, AssetSignedTransformOptions, AssetSignedUrl, AssetSignedUrlOptions, AssetTransformOptions, AssetTransformPreset, AssetUploadOptions } from './types.js';
 export declare const assetTransformPresets: AssetTransformPreset[];
 export declare function getAssetTransformPreset(name: string): AssetTransformPreset | undefined;
 export declare function assetTransformOptions(preset: AssetTransformPreset): AssetTransformOptions;
@@ -10,10 +10,8 @@ export declare class AssetsClient {
     upload(file: Blob, options?: AssetUploadOptions): Promise<Asset>;
     list(options?: AssetListOptions): Promise<AssetListResult>;
     get(assetId: string): Promise<Asset>;
-    delete(assetId: string): Promise<{
-        deleted: boolean;
-    }>;
-    replace(assetId: string, file: Blob, options?: Pick<AssetUploadOptions, 'cacheControl' | 'metadata'>): Promise<Asset>;
+    delete(assetId: string, revision: number, idempotencyKey?: string): Promise<AssetJobSubmission>;
+    replace(assetId: string, revision: number, file: Blob, options?: Pick<AssetUploadOptions, 'cacheControl' | 'metadata'>): Promise<Asset>;
     signedUrl(assetId: string, options: AssetSignedUrlOptions): Promise<AssetSignedUrl>;
     signedUploadUrl(options?: AssetSignedUploadUrlOptions): Promise<AssetSignedUploadUrl>;
     createUploadSession(options?: AssetSignedUploadUrlOptions): Promise<AssetSignedUploadUrl>;
@@ -24,29 +22,36 @@ export declare class AssetsClient {
     cancelUploadSession(sessionId: string): Promise<{
         cancelled: boolean;
     }>;
+    listBuckets(): Promise<{
+        buckets: AssetBucket[];
+    }>;
+    createBucket(input: AssetBucketInput & {
+        name: string;
+    }): Promise<AssetBucket>;
+    updateBucket(bucketId: string, revision: number, input: AssetBucketInput): Promise<AssetBucket>;
+    deleteBucket(bucketId: string, revision: number): Promise<void>;
+    setTags(assetId: string, revision: number, tags: string[]): Promise<{
+        tags: string[];
+        revision: number;
+    }>;
+    patchMetadata(assetId: string, revision: number, metadata: Record<string, unknown>): Promise<{
+        updated: boolean;
+        revision: number;
+    }>;
+    patch(assetId: string, revision: number, input: AssetPatchInput): Promise<Asset>;
     uploadWithProgress(file: Blob, options?: AssetSignedUploadUrlOptions, callbacks?: AssetUploadProgressCallbacks): Promise<Asset | AssetSignedUploadUrl>;
     url(assetId: string, options: AssetTransformOptions): string;
     namedUrl(assetId: string, name: string): string;
-    videoUrl(assetId: string, kind: 'hls' | 'poster' | 'mp4', profile?: string, token?: string): string;
+    videoUrl(assetId: string, kind: 'hls' | 'poster' | 'thumbnail' | 'mp4', profile?: string, token?: string): string;
     versionUrl(assetId: string, versionId: string, token?: string): string;
     branchUrl(assetId: string, branch: string, token?: string): string;
     ai(assetId: string): Promise<AssetAIInfo>;
-    analyze(assetId: string): Promise<{
-        analysis_queued: boolean;
-    }>;
-    moderate(assetId: string): Promise<{
-        moderation_queued: boolean;
-    }>;
+    analyze(assetId: string, idempotencyKey?: string): Promise<AssetJobSubmission>;
+    moderate(assetId: string, idempotencyKey?: string): Promise<AssetJobSubmission>;
     transcript(assetId: string): Promise<AssetTranscript>;
-    requestTranscript(assetId: string): Promise<{
-        transcript_queued: boolean;
-    }>;
-    requestSmartCrop(assetId: string): Promise<{
-        smart_crop_queued: boolean;
-    }>;
-    requestBackgroundRemoval(assetId: string): Promise<{
-        background_remove_queued: boolean;
-    }>;
+    requestTranscript(assetId: string, idempotencyKey?: string): Promise<AssetJobSubmission>;
+    requestSmartCrop(assetId: string, idempotencyKey?: string): Promise<AssetJobSubmission>;
+    requestBackgroundRemoval(assetId: string, idempotencyKey?: string): Promise<AssetJobSubmission>;
     versions(assetId: string): Promise<{
         versions: AssetVersion[];
     }>;
@@ -95,6 +100,66 @@ export declare class AssetsClient {
         deleted: boolean;
     }>;
     signedTransformUrl(assetId: string, options: AssetSignedTransformOptions): Promise<AssetSignedUrl>;
+    getAIConfig(): Promise<AssetAIAccountConfig>;
+    updateAIConfig(revision: number, enabledActions: string[], monthlySpendCapMicros: number): Promise<import("./types.js").AssetAIPolicy>;
+    job(jobId: string): Promise<AssetJob>;
+    cancelJob(jobId: string): Promise<AssetJob>;
+    createLifecycleRule(input: {
+        name: string;
+        prefix?: string;
+        action: 'delete' | 'expire_versions';
+        age_days: number;
+        enabled?: boolean;
+    }): Promise<AssetLifecycleRule>;
+    listLifecycleRules(): Promise<{
+        lifecycle_rules: AssetLifecycleRule[];
+    }>;
+    deleteLifecycleRule(ruleId: string): Promise<{
+        deleted: boolean;
+    }>;
+    createDomain(domain: string): Promise<AssetCustomDomain>;
+    listDomains(): Promise<{
+        domains: AssetCustomDomain[];
+    }>;
+    verifyDomain(domainId: string): Promise<AssetCustomDomain>;
+    deleteDomain(domainId: string): Promise<{
+        deleted: boolean;
+    }>;
+    analytics(): Promise<AssetUsageSummary>;
+    usageSummary(): Promise<AssetUsageSummary>;
+    events(limit?: number): Promise<{
+        events: AssetEvent[];
+        total: number;
+    }>;
+    createWebhook(url: string, eventTypes?: string[]): Promise<{
+        webhook: AssetWebhook;
+        secret: string;
+    }>;
+    listWebhooks(): Promise<{
+        webhooks: AssetWebhook[];
+    }>;
+    deleteWebhook(webhookId: string): Promise<{
+        deleted: boolean;
+    }>;
+    listWebhookDeliveries(webhookId: string, limit?: number): Promise<{
+        deliveries: AssetWebhookDelivery[];
+    }>;
+    retryWebhookDelivery(deliveryId: string): Promise<AssetWebhookDelivery>;
+    purge(assetId: string): Promise<{
+        purged: boolean;
+        asset_id: string;
+    }>;
+    bulk(input: {
+        action: 'delete' | 'visibility' | 'add_tags';
+        items: Array<{
+            asset_id: string;
+            revision: number;
+        }>;
+        visibility?: string;
+        tags?: string[];
+        idempotencyKey?: string;
+    }): Promise<AssetJobSubmission>;
     private originBaseUrl;
+    private requestAssetJob;
     private uploadSingleWithProgress;
 }

package/dist/assets.js

@@ -57,10 +57,17 @@ export class AssetsClient {
         append(query, 'visibility', options.visibility);
         append(query, 'query', options.query);
         append(query, 'tag', options.tag);
-        append(query, 'mimeType', options.mimeType);
+        append(query, 'mime_type', options.mimeType);
         append(query, 'type', options.type);
         append(query, 'folder', options.folder);
         append(query, 'checksum', options.checksum);
+        append(query, 'status', options.status);
+        append(query, 'scan_status', options.scanStatus);
+        append(query, 'replication_status', options.replicationStatus);
+        append(query, 'moderation_status', options.moderationStatus);
+        append(query, 'quarantine_status', options.quarantineStatus);
+        append(query, 'sort', options.sort);
+        append(query, 'direction', options.direction);
         append(query, 'limit', options.limit);
         append(query, 'cursor', options.cursor);
         const suffix = query.toString();
@@ -69,23 +76,25 @@ export class AssetsClient {
     get(assetId) {
         return this.client.request(`/assets/${encodeURIComponent(assetId)}`);
     }
-    delete(assetId) {
+    delete(assetId, revision, idempotencyKey) {
         return this.client.request(`/assets/${encodeURIComponent(assetId)}`, {
             method: 'DELETE',
+            headers: { 'If-Match': `"${revision}"`, ...(idempotencyKey ? { 'Idempotency-Key': idempotencyKey } : {}) },
         });
     }
-    replace(assetId, file, options = {}) {
+    replace(assetId, revision, file, options = {}) {
         return this.client.request(`/assets/${encodeURIComponent(assetId)}/replace`, {
             method: 'PUT',
             body: assetForm(file, options),
+            headers: { 'If-Match': `"${revision}"` },
         });
     }
     signedUrl(assetId, options) {
         return this.client.request(`/assets/${encodeURIComponent(assetId)}/signed-url`, {
             method: 'POST',
             body: {
-                expiresIn: options.expiresIn,
-                maxDownloads: options.maxDownloads,
+                expires_in: options.expiresIn,
+                max_downloads: options.maxDownloads,
             },
         });
     }
@@ -95,32 +104,33 @@ export class AssetsClient {
     createUploadSession(options = {}) {
         return this.client.request('/assets/upload-sessions', {
             method: 'POST',
+            headers: options.idempotencyKey ? { 'Idempotency-Key': options.idempotencyKey } : undefined,
             body: {
                 bucket: options.bucket,
                 key: options.key,
                 folder: options.folder,
                 visibility: options.visibility,
-                cacheControl: options.cacheControl,
+                cache_control: options.cacheControl,
                 metadata: options.metadata,
                 mode: options.mode,
-                fileName: options.fileName,
-                fileSize: options.fileSize,
-                mimeType: options.mimeType,
-                checksumSHA256: options.checksumSHA256,
-                partSize: options.partSize,
-                expiresIn: options.expiresIn,
-                maxBytes: options.maxBytes,
+                file_name: options.fileName,
+                file_size: options.fileSize,
+                mime_type: options.mimeType,
+                checksum_sha256: options.checksumSHA256,
+                part_size: options.partSize,
+                expires_in: options.expiresIn,
+                max_bytes: options.maxBytes,
             },
         });
     }
     createChunkedUploadSession(options) {
         return this.createUploadSession({ ...options, mode: 'chunked' });
     }
-    uploadChunk(uploadUrlOrToken, partNumber, chunk, callbacks = {}) {
+    async uploadChunk(uploadUrlOrToken, partNumber, chunk, callbacks = {}) {
         const target = uploadUrlOrToken.startsWith('http')
             ? `${uploadUrlOrToken.replace(/\/$/, '')}/parts/${partNumber}`
             : `${this.originBaseUrl()}/uploads/${encodeURIComponent(uploadUrlOrToken)}/parts/${partNumber}`;
-        return uploadBlob(target, chunk, callbacks, partNumber);
+        return uploadBlob(target, chunk, callbacks, partNumber, { 'X-Content-SHA256': await sha256Blob(chunk) });
     }
     resumeUploadSession(sessionId) {
         return this.client.request(`/assets/upload-sessions/${encodeURIComponent(sessionId)}`);
@@ -135,25 +145,101 @@ export class AssetsClient {
             method: 'DELETE',
         });
     }
+    listBuckets() {
+        return this.client.request('/assets/buckets');
+    }
+    createBucket(input) {
+        return this.client.request('/assets/buckets', { method: 'POST', body: input });
+    }
+    updateBucket(bucketId, revision, input) {
+        return this.client.request(`/assets/buckets/${encodeURIComponent(bucketId)}`, {
+            method: 'PUT', body: input, headers: { 'If-Match': `"${revision}"` },
+        });
+    }
+    deleteBucket(bucketId, revision) {
+        return this.client.request(`/assets/buckets/${encodeURIComponent(bucketId)}`, {
+            method: 'DELETE', headers: { 'If-Match': `"${revision}"` },
+        });
+    }
+    setTags(assetId, revision, tags) {
+        return this.client.request(`/assets/${encodeURIComponent(assetId)}/tags`, {
+            method: 'PUT', body: { tags }, headers: { 'If-Match': `"${revision}"` },
+        });
+    }
+    patchMetadata(assetId, revision, metadata) {
+        return this.client.request(`/assets/${encodeURIComponent(assetId)}/metadata`, {
+            method: 'PATCH', body: { metadata }, headers: { 'If-Match': `"${revision}"` },
+        });
+    }
+    patch(assetId, revision, input) {
+        return this.client.request(`/assets/${encodeURIComponent(assetId)}`, {
+            method: 'PATCH', body: input, headers: { 'If-Match': `"${revision}"` },
+        });
+    }
     async uploadWithProgress(file, options = {}, callbacks = {}) {
         const size = options.fileSize ?? file.size;
         if (size <= defaultPartSize) {
             return this.uploadSingleWithProgress(file, options, callbacks);
         }
-        const session = await this.createChunkedUploadSession({
-            ...options,
-            fileSize: size,
-            fileName: options.fileName ?? blobName(file),
-            mimeType: options.mimeType ?? file.type,
-        });
+        throwIfAborted(callbacks.signal);
+        const session = options.uploadSessionId
+            ? await this.resumeUploadSession(options.uploadSessionId)
+            : await this.createChunkedUploadSession({
+                ...options,
+                fileSize: size,
+                fileName: options.fileName ?? blobName(file),
+                mimeType: options.mimeType ?? file.type,
+            });
         const partSize = session.part_size ?? defaultPartSize;
+        const sessionId = session.session_id ?? options.uploadSessionId;
+        if (!sessionId) {
+            throw new Error('Chunked upload session did not include a resumable session id');
+        }
+        const completed = new Map((session.parts ?? []).map((part) => [part.part_number, part.size]));
+        const loadedByPart = new Map(completed);
+        const tasks = [];
         for (let offset = 0, part = 1; offset < size; offset += partSize, part += 1) {
-            await this.uploadChunk(session.upload_session_id, part, file.slice(offset, offset + partSize), callbacks);
+            if (!completed.has(part))
+                tasks.push({ part, chunk: file.slice(offset, offset + partSize) });
         }
-        if (!session.session_id) {
-            throw new Error('Chunked upload session did not include a resumable session id');
+        const reportProgress = () => {
+            const loaded = Math.min(size, Array.from(loadedByPart.values()).reduce((sum, value) => sum + value, 0));
+            callbacks.onProgress?.({ loaded, total: size, percent: size ? Math.round((loaded / size) * 100) : 100 });
+        };
+        reportProgress();
+        const concurrency = boundedInteger(options.concurrency, 4, 1, 8);
+        const attempts = boundedInteger(options.retryAttempts, 4, 1, 8);
+        let next = 0;
+        const worker = async () => {
+            while (next < tasks.length) {
+                throwIfAborted(callbacks.signal);
+                const task = tasks[next++];
+                await retryWithBackoff(async () => {
+                    throwIfAborted(callbacks.signal);
+                    await this.uploadChunk(session.upload_session_id, task.part, task.chunk, {
+                        signal: callbacks.signal,
+                        onProgress: (progress) => {
+                            loadedByPart.set(task.part, progress.loaded);
+                            callbacks.onPartProgress?.(task.part, progress);
+                            reportProgress();
+                        },
+                    });
+                    loadedByPart.set(task.part, task.chunk.size);
+                    reportProgress();
+                }, attempts, callbacks.signal);
+            }
+        };
+        try {
+            await Promise.all(Array.from({ length: Math.min(concurrency, tasks.length || 1) }, worker));
+            throwIfAborted(callbacks.signal);
+            return await retryWithBackoff(() => this.completeUploadSession(sessionId), attempts, callbacks.signal);
+        }
+        catch (error) {
+            if (isAbortError(error)) {
+                await this.cancelUploadSession(sessionId).catch(() => undefined);
+            }
+            throw error;
         }
-        return this.completeUploadSession(session.session_id);
     }
     url(assetId, options) {
         return `${this.client.cdnBaseUrl}/assets/${encodeURIComponent(assetId)}/tr/${encodeURIComponent(transformSpec(options))}`;
@@ -188,23 +274,23 @@ export class AssetsClient {
     ai(assetId) {
         return this.client.request(`/assets/${encodeURIComponent(assetId)}/ai`);
     }
-    analyze(assetId) {
-        return this.client.request(`/assets/${encodeURIComponent(assetId)}/ai/analyze`, { method: 'POST' });
+    analyze(assetId, idempotencyKey) {
+        return this.requestAssetJob(`/assets/${encodeURIComponent(assetId)}/ai/analyze`, idempotencyKey);
     }
-    moderate(assetId) {
-        return this.client.request(`/assets/${encodeURIComponent(assetId)}/moderation`, { method: 'POST' });
+    moderate(assetId, idempotencyKey) {
+        return this.requestAssetJob(`/assets/${encodeURIComponent(assetId)}/moderation`, idempotencyKey);
     }
     transcript(assetId) {
         return this.client.request(`/assets/${encodeURIComponent(assetId)}/transcript`);
     }
-    requestTranscript(assetId) {
-        return this.client.request(`/assets/${encodeURIComponent(assetId)}/transcript`, { method: 'POST' });
+    requestTranscript(assetId, idempotencyKey) {
+        return this.requestAssetJob(`/assets/${encodeURIComponent(assetId)}/transcript`, idempotencyKey);
     }
-    requestSmartCrop(assetId) {
-        return this.client.request(`/assets/${encodeURIComponent(assetId)}/smart-crop`, { method: 'POST' });
+    requestSmartCrop(assetId, idempotencyKey) {
+        return this.requestAssetJob(`/assets/${encodeURIComponent(assetId)}/smart-crop`, idempotencyKey);
     }
-    requestBackgroundRemoval(assetId) {
-        return this.client.request(`/assets/${encodeURIComponent(assetId)}/background-remove`, { method: 'POST' });
+    requestBackgroundRemoval(assetId, idempotencyKey) {
+        return this.requestAssetJob(`/assets/${encodeURIComponent(assetId)}/background-remove`, idempotencyKey);
     }
     versions(assetId) {
         return this.client.request(`/assets/${encodeURIComponent(assetId)}/versions`);
@@ -274,9 +360,81 @@ export class AssetsClient {
             body: transformBody(options),
         });
     }
+    getAIConfig() {
+        return this.client.request('/assets/ai/config');
+    }
+    updateAIConfig(revision, enabledActions, monthlySpendCapMicros) {
+        return this.client.request('/assets/ai/config', {
+            method: 'PUT', headers: { 'If-Match': `"${revision}"` },
+            body: { enabled_actions: enabledActions, monthly_spend_cap_micros: monthlySpendCapMicros },
+        });
+    }
+    job(jobId) {
+        return this.client.request(`/assets/jobs/${encodeURIComponent(jobId)}`);
+    }
+    cancelJob(jobId) {
+        return this.client.request(`/assets/jobs/${encodeURIComponent(jobId)}/cancel`, { method: 'POST' });
+    }
+    createLifecycleRule(input) {
+        return this.client.request('/assets/lifecycle-rules', { method: 'POST', body: input });
+    }
+    listLifecycleRules() {
+        return this.client.request('/assets/lifecycle-rules');
+    }
+    deleteLifecycleRule(ruleId) {
+        return this.client.request(`/assets/lifecycle-rules/${encodeURIComponent(ruleId)}`, { method: 'DELETE' });
+    }
+    createDomain(domain) {
+        return this.client.request('/assets/domains', { method: 'POST', body: { domain } });
+    }
+    listDomains() {
+        return this.client.request('/assets/domains');
+    }
+    verifyDomain(domainId) {
+        return this.client.request(`/assets/domains/${encodeURIComponent(domainId)}/verify`, { method: 'POST' });
+    }
+    deleteDomain(domainId) {
+        return this.client.request(`/assets/domains/${encodeURIComponent(domainId)}`, { method: 'DELETE' });
+    }
+    analytics() {
+        return this.client.request('/assets/analytics');
+    }
+    usageSummary() {
+        return this.client.request('/assets/summary');
+    }
+    events(limit = 50) {
+        return this.client.request(`/assets/events?limit=${limit}`);
+    }
+    createWebhook(url, eventTypes = ['asset.*']) {
+        return this.client.request('/assets/webhooks', {
+            method: 'POST', body: { url, event_types: eventTypes },
+        });
+    }
+    listWebhooks() {
+        return this.client.request('/assets/webhooks');
+    }
+    deleteWebhook(webhookId) {
+        return this.client.request(`/assets/webhooks/${encodeURIComponent(webhookId)}`, { method: 'DELETE' });
+    }
+    listWebhookDeliveries(webhookId, limit = 50) {
+        return this.client.request(`/assets/webhooks/${encodeURIComponent(webhookId)}/deliveries?limit=${limit}`);
+    }
+    retryWebhookDelivery(deliveryId) {
+        return this.client.request(`/assets/webhook-deliveries/${encodeURIComponent(deliveryId)}/retry`, { method: 'POST' });
+    }
+    purge(assetId) {
+        return this.client.request(`/assets/${encodeURIComponent(assetId)}/purge`, { method: 'POST' });
+    }
+    bulk(input) {
+        const { idempotencyKey, ...body } = input;
+        return this.client.request('/assets/bulk', { method: 'POST', body, headers: idempotencyKey ? { 'Idempotency-Key': idempotencyKey } : undefined });
+    }
     originBaseUrl() {
         return this.client.baseUrl.replace(/\/api\/v1$/, '');
     }
+    requestAssetJob(path, idempotencyKey) {
+        return this.client.request(path, { method: 'POST', headers: idempotencyKey ? { 'Idempotency-Key': idempotencyKey } : undefined });
+    }
     async uploadSingleWithProgress(file, options, callbacks) {
         const session = await this.createUploadSession({
             ...options,
@@ -294,7 +452,7 @@ function assetForm(file, options) {
     append(body, 'key', options.key);
     append(body, 'folder', options.folder);
     append(body, 'visibility', options.visibility);
-    append(body, 'cacheControl', options.cacheControl);
+    append(body, 'cache_control', options.cacheControl);
     if (options.metadata) {
         body.append('metadata', JSON.stringify(options.metadata));
     }
@@ -314,6 +472,8 @@ function transformSpec(options) {
     parts.push(`c_${options.crop ?? 'fit'}`);
     parts.push(`f_${options.format ?? 'auto'}`);
     parts.push(`q_${options.quality ?? 'auto'}`);
+    parts.push(`g_${options.gravity ?? 'centre'}`);
+    parts.push(`a_${options.animation ?? 'first'}`);
     return parts.join(',');
 }
 function preset(name, category, description, width, height, crop = 'fit', format = 'auto', quality = 'auto') {
@@ -326,23 +486,33 @@ function transformBody(options) {
         crop: options.crop,
         format: options.format,
         quality: options.quality,
-        expiresIn: options.expiresIn,
+        gravity: options.gravity,
+        animation: options.animation,
+        expires_in: options.expiresIn,
     };
 }
 const defaultPartSize = 5 * 1024 * 1024;
 function blobName(file) {
     return file.name;
 }
-function uploadBlob(url, blob, callbacks, partNumber) {
+function uploadBlob(url, blob, callbacks, partNumber, headers = {}) {
     if (typeof XMLHttpRequest === 'undefined') {
-        return fetch(url, { method: 'PUT', body: blob }).then((response) => {
+        return fetch(url, { method: 'PUT', body: blob, signal: callbacks.signal, headers }).then((response) => {
             if (!response.ok)
                 throw new Error(`Upload failed with ${response.status}`);
+            const progress = { loaded: blob.size, total: blob.size, percent: 100 };
+            callbacks.onProgress?.(progress);
+            if (partNumber)
+                callbacks.onPartProgress?.(partNumber, progress);
         });
     }
     return new Promise((resolve, reject) => {
         const xhr = new XMLHttpRequest();
         xhr.open('PUT', url);
+        for (const [name, value] of Object.entries(headers))
+            xhr.setRequestHeader(name, value);
+        const abort = () => xhr.abort();
+        callbacks.signal?.addEventListener('abort', abort, { once: true });
         xhr.upload.onprogress = (event) => {
             const total = event.total || blob.size;
             const progress = { loaded: event.loaded, total, percent: total ? Math.round((event.loaded / total) * 100) : 0 };
@@ -350,13 +520,64 @@ function uploadBlob(url, blob, callbacks, partNumber) {
             if (partNumber)
                 callbacks.onPartProgress?.(partNumber, progress);
         };
+        const cleanup = () => callbacks.signal?.removeEventListener('abort', abort);
         xhr.onload = () => {
+            cleanup();
             if (xhr.status >= 200 && xhr.status < 300)
                 resolve();
             else
                 reject(new Error(`Upload failed with ${xhr.status}`));
         };
-        xhr.onerror = () => reject(new Error('Upload failed'));
+        xhr.onerror = () => { cleanup(); reject(new Error('Upload failed')); };
+        xhr.onabort = () => { cleanup(); reject(abortError()); };
         xhr.send(blob);
     });
 }
+async function sha256Blob(blob) {
+    if (!globalThis.crypto?.subtle)
+        throw new Error('Web Crypto SHA-256 is required for multipart uploads');
+    const digest = await globalThis.crypto.subtle.digest('SHA-256', await blob.arrayBuffer());
+    return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, '0')).join('');
+}
+function boundedInteger(value, fallback, minimum, maximum) {
+    if (value === undefined)
+        return fallback;
+    if (!Number.isSafeInteger(value))
+        throw new Error('Upload concurrency and retry attempts must be integers');
+    return Math.min(maximum, Math.max(minimum, value));
+}
+async function retryWithBackoff(operation, attempts, signal) {
+    let lastError;
+    for (let attempt = 0; attempt < attempts; attempt += 1) {
+        try {
+            return await operation();
+        }
+        catch (error) {
+            if (isAbortError(error) || signal?.aborted)
+                throw abortError();
+            lastError = error;
+            if (attempt + 1 < attempts)
+                await abortableDelay(250 * 2 ** attempt, signal);
+        }
+    }
+    throw lastError;
+}
+function abortableDelay(milliseconds, signal) {
+    throwIfAborted(signal);
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => { cleanup(); resolve(); }, milliseconds);
+        const abort = () => { clearTimeout(timer); cleanup(); reject(abortError()); };
+        const cleanup = () => signal?.removeEventListener('abort', abort);
+        signal?.addEventListener('abort', abort, { once: true });
+    });
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted)
+        throw abortError();
+}
+function abortError() {
+    return typeof DOMException === 'undefined' ? Object.assign(new Error('Upload cancelled'), { name: 'AbortError' }) : new DOMException('Upload cancelled', 'AbortError');
+}
+function isAbortError(error) {
+    return error instanceof Error && error.name === 'AbortError';
+}