@stackshift-cloud/sdk 1.0.0 → 1.2.0

package/dist/assets-platform.js

@@ -0,0 +1,90 @@
+const encoded = encodeURIComponent;
+export class AssetConnectionsClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    list() { return this.client.request('/assets/connections'); }
+    get(connectionId) { return this.client.request(`/assets/connections/${encoded(connectionId)}`); }
+    create(input) {
+        return this.client.request('/assets/connections', { method: 'POST', body: input });
+    }
+    update(connectionId, input) {
+        return this.client.request(`/assets/connections/${encoded(connectionId)}`, { method: 'PATCH', body: input });
+    }
+    verify(connectionId) {
+        return this.client.request(`/assets/connections/${encoded(connectionId)}/verify`, { method: 'POST' });
+    }
+    delete(connectionId) {
+        return this.client.request(`/assets/connections/${encoded(connectionId)}`, { method: 'DELETE' });
+    }
+}
+export class AssetStorageClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    configure(bucketId, revision, input) {
+        return this.client.request(`/assets/buckets/${encoded(bucketId)}/storage`, {
+            method: 'PUT', body: input, headers: { 'If-Match': `"${revision}"` },
+        });
+    }
+    listS2Buckets() { return this.client.request('/assets/s2-buckets'); }
+    createS2Bucket(input) {
+        return this.client.request('/assets/s2-buckets', { method: 'POST', body: input });
+    }
+    relocate(bucketId, input = {}) {
+        return this.client.request(`/assets/buckets/${encoded(bucketId)}/relocations`, { method: 'POST', body: input });
+    }
+}
+export class AssetMigrationsClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    start(input) {
+        return this.client.request('/assets/migrations', { method: 'POST', body: input });
+    }
+    list(options = {}) {
+        const query = new URLSearchParams();
+        if (options.limit !== undefined)
+            query.set('limit', String(options.limit));
+        const suffix = query.toString();
+        return this.client.request(`/assets/migrations${suffix ? `?${suffix}` : ''}`);
+    }
+    get(migrationId) { return this.client.request(`/assets/migrations/${encoded(migrationId)}`); }
+    cancel(migrationId) {
+        return this.client.request(`/assets/migrations/${encoded(migrationId)}/cancel`, { method: 'POST' });
+    }
+    retryItem(migrationId, itemId) {
+        return this.client.request(`/assets/migrations/${encoded(migrationId)}/items/${encoded(itemId)}/retry`, { method: 'POST' });
+    }
+    report(migrationId, format = 'json') {
+        return this.client.request(`/assets/migrations/${encoded(migrationId)}/report?format=${format}`);
+    }
+    async downloadReport(migrationId, format = 'json') {
+        return this.client.requestRaw(`/assets/migrations/${encoded(migrationId)}/report?format=${format}`).then((response) => response.blob());
+    }
+}
+export class AssetTextClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    start(assetId, input = {}) {
+        return this.client.request(`/assets/${encoded(assetId)}/text-extraction`, { method: 'POST', body: input });
+    }
+    get(assetId) { return this.client.request(`/assets/${encoded(assetId)}/text-extraction`); }
+    retry(extractionId) {
+        return this.client.request(`/assets/text-extractions/${encoded(extractionId)}/retry`, { method: 'POST' });
+    }
+}
+export class AssetUploadCapabilitiesClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    create(input) {
+        return this.client.request('/assets/upload-capabilities', { method: 'POST', body: input });
+    }
+}

package/dist/assets-video-types.d.ts

@@ -0,0 +1,116 @@
+export interface AssetVideoPackage {
+    id: string;
+    asset_space_id: string;
+    asset_id: string;
+    version_id: string;
+    source_checksum_sha256: string;
+    recipe_hash: string;
+    recipe: string;
+    processor_revision: string;
+    status: 'queued' | 'processing' | 'ready' | 'degraded' | 'failed' | 'cancelled';
+    phase: string;
+    progress_percent: number;
+    job_id?: string;
+    published_attempt?: string;
+    admitted_at?: string;
+    created_at: string;
+    updated_at: string;
+    failure_code: string;
+    metadata: {
+        asset_id: string;
+        duration_seconds: number;
+        width: number;
+        height: number;
+        codec: string;
+        bitrate: number;
+        frame_rate: number;
+        has_audio: boolean;
+        rotation: number;
+        created_at: string;
+        updated_at: string;
+    };
+}
+export interface AssetVideoWorkspace {
+    active?: AssetVideoPackage;
+    pending?: AssetVideoPackage;
+    source?: {
+        version_id: string;
+        scan_status: 'pending' | 'clean' | 'infected' | 'failed';
+        review_status: 'not_required' | 'pending' | 'approved' | 'rejected';
+        review_reason: string;
+    };
+    renditions: Array<{
+        id: string;
+        package_id?: string;
+        asset_id: string;
+        source_checksum_sha256: string;
+        kind: 'hls' | 'mp4' | 'poster';
+        profile: string;
+        width: number;
+        height: number;
+        size: number;
+        mime_type: string;
+        status: string;
+        created_at: string;
+        updated_at: string;
+    }>;
+    admission_enabled: boolean;
+}
+export interface AssetVideoCaptionInput {
+    /** Atomically replace this active track; the new reference receives a new ID. */
+    replace_caption_id?: string;
+    caption_asset_id: string;
+    caption_version_id: string;
+    language: string;
+    label: string;
+    kind: 'captions' | 'subtitles';
+    is_default?: boolean;
+}
+export interface AssetVideoCaption extends AssetVideoCaptionInput {
+    id: string;
+    asset_space_id: string;
+    asset_id: string;
+    version_id: string;
+    is_default: boolean;
+}
+export interface AssetPlaybackGrant {
+    has_audio: boolean;
+    session: {
+        id: string;
+        asset_space_id: string;
+        asset_id: string;
+        package_id: string;
+        version_id: string;
+        owner_id?: string;
+        is_private: boolean;
+        expires_at: string;
+        maximum_expires_at: string;
+        revoked_at?: string;
+        created_at: string;
+    };
+    credential: string;
+    hls: string;
+    mp4: string;
+    poster?: string;
+    captions: Array<{
+        id: string;
+        url: string;
+        language: string;
+        label: string;
+        kind: 'captions' | 'subtitles';
+        is_default: boolean;
+    }>;
+}
+export interface AssetPlaybackEvent {
+    sequence: number;
+    kind: 'startup' | 'rebuffer' | 'error' | 'quality' | 'watched' | 'completed';
+    value: number;
+}
+export interface AssetPlaybackAnalytics {
+    starts: number;
+    completions: number;
+    errors: number;
+    startup_ms: number;
+    rebuffer_ms: number;
+    watched_ms: number;
+}

package/dist/assets-video-types.js

@@ -0,0 +1 @@
+export {};

package/dist/assets-video.d.ts

@@ -0,0 +1,25 @@
+import type { StackShift } from './client.js';
+import type { AssetVideoWorkspace, AssetVideoPackage, AssetVideoCaption, AssetVideoCaptionInput, AssetPlaybackGrant, AssetPlaybackEvent, AssetPlaybackAnalytics } from './assets-video-types.js';
+export declare class AssetVideoClient {
+    private readonly client;
+    constructor(client: StackShift);
+    workspace(assetId: string): Promise<AssetVideoWorkspace>;
+    process(assetId: string, versionId: string): Promise<AssetVideoPackage>;
+    createSession(assetId: string): Promise<AssetPlaybackGrant>;
+    renewSession(credential: string): Promise<AssetPlaybackGrant>;
+    revokeSession(assetId: string, sessionId: string): Promise<{
+        revoked: boolean;
+    }>;
+    captions(assetId: string, versionId: string): Promise<AssetVideoCaption[]>;
+    addCaption(assetId: string, versionId: string, input: AssetVideoCaptionInput): Promise<AssetVideoCaption>;
+    removeCaption(assetId: string, versionId: string, captionId: string): Promise<{
+        removed: boolean;
+    }>;
+    review(assetId: string, versionId: string, decision: 'approved' | 'rejected', reason: string): Promise<{
+        reviewed: boolean;
+    }>;
+    events(credential: string, events: AssetPlaybackEvent[]): Promise<{
+        accepted: boolean;
+    }>;
+    analytics(assetId: string): Promise<AssetPlaybackAnalytics>;
+}

package/dist/assets-video.js

@@ -0,0 +1,19 @@
+const assetPath = (id) => `/assets/${encodeURIComponent(id)}`;
+const versionPath = (id, version) => `${assetPath(id)}/versions/${encodeURIComponent(version)}/video`;
+export class AssetVideoClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    workspace(assetId) { return this.client.request(`${assetPath(assetId)}/video`); }
+    process(assetId, versionId) { return this.client.request(versionPath(assetId, versionId), { method: 'POST' }); }
+    createSession(assetId) { return this.client.request(`${assetPath(assetId)}/playback-sessions`, { method: 'POST' }); }
+    renewSession(credential) { return this.client.playbackRequest('/sessions/renew', credential, {}); }
+    revokeSession(assetId, sessionId) { return this.client.request(`${assetPath(assetId)}/playback-sessions/${encodeURIComponent(sessionId)}`, { method: 'DELETE' }); }
+    captions(assetId, versionId) { return this.client.request(`${versionPath(assetId, versionId)}/captions`); }
+    addCaption(assetId, versionId, input) { return this.client.request(`${versionPath(assetId, versionId)}/captions`, { method: 'POST', body: input }); }
+    removeCaption(assetId, versionId, captionId) { return this.client.request(`${versionPath(assetId, versionId)}/captions/${encodeURIComponent(captionId)}`, { method: 'DELETE' }); }
+    review(assetId, versionId, decision, reason) { return this.client.request(`${versionPath(assetId, versionId)}/review`, { method: 'POST', body: { decision, reason } }); }
+    events(credential, events) { return this.client.playbackRequest('/events', credential, { events }); }
+    analytics(assetId) { return this.client.request(`${assetPath(assetId)}/video/analytics`); }
+}

package/dist/assets.d.ts

@@ -1,4 +1,9 @@
+import { AssetDAMClient } from './assets-dam.js';
+import { AssetVideoClient } from './assets-video.js';
 import type { StackShift } from './client.js';
+import { AssetConnectionsClient, AssetMigrationsClient, AssetStorageClient, AssetTextClient, AssetUploadCapabilitiesClient } from './assets-platform.js';
+import { AssetWorkflowsClient } from './asset-workflows.js';
+import type { AssetDerivedAsset, AssetImageGenerationInput, AssetTransformDefinition, AssetTransformMaterializeInput } from './asset-media-v2.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;
@@ -6,6 +11,14 @@ export declare function assetTransformOptions(preset: AssetTransformPreset): Ass
 export declare function assetTransformSpec(options: AssetTransformOptions): string;
 export declare class AssetsClient {
     private readonly client;
+    readonly dam: AssetDAMClient;
+    readonly video: AssetVideoClient;
+    readonly connections: AssetConnectionsClient;
+    readonly storage: AssetStorageClient;
+    readonly migrations: AssetMigrationsClient;
+    readonly text: AssetTextClient;
+    readonly uploadCapabilities: AssetUploadCapabilitiesClient;
+    readonly workflows: AssetWorkflowsClient;
     constructor(client: StackShift);
     upload(file: Blob, options?: AssetUploadOptions): Promise<Asset>;
     list(options?: AssetListOptions): Promise<AssetListResult>;
@@ -70,7 +83,7 @@ export declare class AssetsClient {
         description?: string;
         asset_ids?: string[];
     }): Promise<AssetCollection>;
-    updateCollection(collectionId: string, input: {
+    updateCollection(collectionId: string, revision: number, input: {
         name: string;
         description?: string;
         asset_ids?: string[];
@@ -95,6 +108,13 @@ export declare class AssetsClient {
     getPolicy(): Promise<AssetContentPolicy>;
     updatePolicy(policy: AssetContentPolicy): Promise<AssetContentPolicy>;
     createTransformation(input: AssetNamedTransformInput): Promise<unknown>;
+    createTransformationV2(name: string, definition: AssetTransformDefinition, eager?: boolean): Promise<unknown>;
+    materializeTransform(assetId: string, input: AssetTransformMaterializeInput, idempotencyKey?: string): Promise<AssetJobSubmission>;
+    derivatives(assetId: string): Promise<{
+        derivatives: AssetDerivedAsset[];
+    }>;
+    generate(input: AssetImageGenerationInput, idempotencyKey: string): Promise<AssetJobSubmission>;
+    automation(): Promise<import("./asset-workflows.js").AssetAutomationOverview>;
     listTransformations(): Promise<unknown>;
     deleteTransformation(name: string): Promise<{
         deleted: boolean;

package/dist/assets.js

@@ -1,3 +1,8 @@
+import { AssetDAMClient } from './assets-dam.js';
+import { AssetVideoClient } from './assets-video.js';
+import { AssetConnectionsClient, AssetMigrationsClient, AssetStorageClient, AssetTextClient, AssetUploadCapabilitiesClient } from './assets-platform.js';
+import { AssetWorkflowsClient } from './asset-workflows.js';
+import { ChunkedUploadController, putBlob, sha256Blob } from './upload-controller.js';
 export const assetTransformPresets = [
     preset('web-thumbnail', 'responsive-web', 'Compact grid thumbnail for libraries and dashboards.', 320, 180, 'fill', 'webp', 78),
     preset('web-card', 'responsive-web', 'Balanced card image for product and content listings.', 640, 360, 'fill', 'webp', 82),
@@ -41,8 +46,24 @@ export function assetTransformSpec(options) {
 }
 export class AssetsClient {
     client;
+    dam;
+    video;
+    connections;
+    storage;
+    migrations;
+    text;
+    uploadCapabilities;
+    workflows;
     constructor(client) {
         this.client = client;
+        this.dam = new AssetDAMClient(client);
+        this.video = new AssetVideoClient(client);
+        this.connections = new AssetConnectionsClient(client);
+        this.storage = new AssetStorageClient(client);
+        this.migrations = new AssetMigrationsClient(client);
+        this.text = new AssetTextClient(client);
+        this.uploadCapabilities = new AssetUploadCapabilitiesClient(client);
+        this.workflows = new AssetWorkflowsClient(client);
     }
     upload(file, options = {}) {
         return this.client.request('/assets/upload', {
@@ -61,6 +82,9 @@ export class AssetsClient {
         append(query, 'type', options.type);
         append(query, 'folder', options.folder);
         append(query, 'checksum', options.checksum);
+        append(query, 'collection_id', options.collectionId);
+        append(query, 'duplicates', options.duplicates === undefined ? undefined : String(options.duplicates));
+        append(query, 'security', options.security);
         append(query, 'status', options.status);
         append(query, 'scan_status', options.scanStatus);
         append(query, 'replication_status', options.replicationStatus);
@@ -130,7 +154,13 @@ export class AssetsClient {
         const target = uploadUrlOrToken.startsWith('http')
             ? `${uploadUrlOrToken.replace(/\/$/, '')}/parts/${partNumber}`
             : `${this.originBaseUrl()}/uploads/${encodeURIComponent(uploadUrlOrToken)}/parts/${partNumber}`;
-        return uploadBlob(target, chunk, callbacks, partNumber, { 'X-Content-SHA256': await sha256Blob(chunk) });
+        return putBlob(target, chunk, {
+            signal: callbacks.signal,
+            onProgress: (progress) => {
+                callbacks.onProgress?.(progress);
+                callbacks.onPartProgress?.(partNumber, progress);
+            },
+        }, { 'X-Content-SHA256': await sha256Blob(chunk) });
     }
     resumeUploadSession(sessionId) {
         return this.client.request(`/assets/upload-sessions/${encodeURIComponent(sessionId)}`);
@@ -190,56 +220,22 @@ export class AssetsClient {
                 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) {
-            if (!completed.has(part))
-                tasks.push({ part, chunk: file.slice(offset, offset + partSize) });
-        }
-        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;
-        }
+        const controller = new ChunkedUploadController({
+            create: async () => toControllerSession(session),
+            resume: async (sessionId) => toControllerSession(await this.resumeUploadSession(sessionId)),
+            uploadPart: async (current, partNumber, chunk, checksum, progress) => {
+                const target = `${this.originBaseUrl()}/uploads/${encodeURIComponent(current.uploadToken)}/parts/${partNumber}`;
+                await putBlob(target, chunk, progress, { 'X-Content-SHA256': checksum });
+            },
+            complete: (current) => this.completeUploadSession(current.id),
+            cancel: (current) => this.cancelUploadSession(current.id).then(() => undefined),
+        });
+        return controller.upload(file, {
+            key: options.key ?? options.fileName ?? blobName(file) ?? 'upload',
+            fileName: options.fileName ?? blobName(file) ?? 'upload',
+            mimeType: options.mimeType ?? file.type,
+            metadata: options.metadata,
+        }, { ...callbacks, concurrency: options.concurrency, retryAttempts: options.retryAttempts, cancelOnAbort: true });
     }
     url(assetId, options) {
         return `${this.client.cdnBaseUrl}/assets/${encodeURIComponent(assetId)}/tr/${encodeURIComponent(transformSpec(options))}`;
@@ -313,8 +309,8 @@ export class AssetsClient {
     createCollection(input) {
         return this.client.request('/assets/collections', { method: 'POST', body: input });
     }
-    updateCollection(collectionId, input) {
-        return this.client.request(`/assets/collections/${encodeURIComponent(collectionId)}`, { method: 'PUT', body: input });
+    updateCollection(collectionId, revision, input) {
+        return this.client.request(`/assets/collections/${encodeURIComponent(collectionId)}`, { method: 'PUT', body: input, headers: { 'If-Match': `"${revision}"` } });
     }
     deleteCollection(collectionId) {
         return this.client.request(`/assets/collections/${encodeURIComponent(collectionId)}`, { method: 'DELETE' });
@@ -346,6 +342,28 @@ export class AssetsClient {
             body: input,
         });
     }
+    createTransformationV2(name, definition, eager = false) {
+        return this.client.request('/assets/transformations', {
+            method: 'POST', body: { name, definition, eager },
+        });
+    }
+    materializeTransform(assetId, input, idempotencyKey) {
+        return this.client.request(`/assets/${encodeURIComponent(assetId)}/transforms`, {
+            method: 'POST', body: input,
+            headers: idempotencyKey ? { 'Idempotency-Key': idempotencyKey } : undefined,
+        });
+    }
+    derivatives(assetId) {
+        return this.client.request(`/assets/${encodeURIComponent(assetId)}/derivatives`);
+    }
+    generate(input, idempotencyKey) {
+        return this.client.request('/assets/generations', {
+            method: 'POST', body: input, headers: { 'Idempotency-Key': idempotencyKey },
+        });
+    }
+    automation() {
+        return this.client.request('/assets/automation');
+    }
     listTransformations() {
         return this.client.request('/assets/transformations');
     }
@@ -441,7 +459,7 @@ export class AssetsClient {
             mode: 'single',
             maxBytes: options.maxBytes ?? file.size,
         });
-        await uploadBlob(session.url, file, callbacks);
+        await putBlob(session.url, file, callbacks);
         return session;
     }
 }
@@ -495,82 +513,6 @@ const defaultPartSize = 5 * 1024 * 1024;
 function blobName(file) {
     return file.name;
 }
-function uploadBlob(url, blob, callbacks, partNumber, headers = {}) {
-    if (typeof XMLHttpRequest === 'undefined') {
-        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 };
-            callbacks.onProgress?.(progress);
-            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 = () => { 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();
@@ -578,6 +520,17 @@ function throwIfAborted(signal) {
 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';
+function toControllerSession(session) {
+    const id = session.session_id;
+    if (!id)
+        throw new Error('Chunked upload session did not include a resumable session id');
+    return {
+        id,
+        uploadToken: session.upload_session_id,
+        expiresAt: session.expires_at,
+        maxBytes: session.max_bytes,
+        partSize: session.part_size ?? defaultPartSize,
+        parts: (session.parts ?? []).map((part) => ({ partNumber: part.part_number, size: part.size, checksumSHA256: part.checksum_sha256 })),
+        resumeContext: id,
+    };
 }

package/dist/client.d.ts

@@ -1,8 +1,10 @@
 import { AssetsClient } from './assets.js';
 import { MailClient } from './mail.js';
 import { ProjectsClient } from './projects.js';
+import { WorkloadSecurityClient } from './workload-security.js';
 import type { StackShiftOptions } from './types.js';
 export declare class StackShift {
+    readonly assetSpaceId?: string;
     readonly apiKey: string;
     readonly baseUrl: string;
     readonly mailBaseUrl: string;
@@ -10,6 +12,7 @@ export declare class StackShift {
     readonly projects: ProjectsClient;
     readonly assets: AssetsClient;
     readonly mail: MailClient;
+    readonly workloadSecurity: WorkloadSecurityClient;
     private readonly fetcher;
     constructor(options?: StackShiftOptions);
     request<T>(path: string, init?: {
@@ -17,12 +20,19 @@ export declare class StackShift {
         body?: unknown;
         headers?: Record<string, string>;
     }): Promise<T>;
+    requestRaw(path: string, init?: {
+        method?: string;
+        body?: unknown;
+        headers?: Record<string, string>;
+    }): Promise<Response>;
     mailRequest<T>(path: string, init?: {
         method?: string;
         body?: unknown;
         headers?: Record<string, string>;
     }): Promise<T>;
+    playbackRequest<T>(path: '/sessions/renew' | '/events', credential: string, body: unknown): Promise<T>;
     private requestFrom;
+    private fetchFrom;
 }
 export declare class StackShiftAPIError extends Error {
     readonly status: number;