@stackshift-cloud/sdk 0.1.4 → 1.1.0

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

@@ -0,0 +1,218 @@
+import type { Asset, AssetBucket, JsonValue } from './types.js';
+export type AssetConnectionProvider = 'aws_s3' | 'r2' | 'wasabi' | 'minio' | 's3' | 'stackshift_s2' | 'cloudinary';
+export type AssetConnectionStatus = 'unverified' | 'verified' | 'failed' | 'revoked';
+export type AssetStorageMode = 'managed' | 'byob' | 'stackshift_s2';
+export type AssetMigrationStatus = 'queued' | 'running' | 'completed' | 'failed' | 'canceled';
+export type AssetMigrationItemStatus = 'queued' | 'running' | 'imported' | 'skipped' | 'failed' | 'canceled';
+export interface AssetConnection {
+    id: string;
+    provider: AssetConnectionProvider;
+    name: string;
+    configuration: Record<string, JsonValue>;
+    external_id: string;
+    s2_bucket_id?: string;
+    status: AssetConnectionStatus;
+    last_verified_at?: string;
+    verification_error?: string;
+    created_at: string;
+    updated_at: string;
+}
+export interface AssetS3ConnectionConfiguration {
+    bucket: string;
+    region?: string;
+    endpoint?: string;
+    prefix?: string;
+    role_arn?: string;
+    auth_type: 'assume_role' | 'static';
+    path_style?: boolean;
+}
+export interface AssetS3StaticCredentials {
+    access_key_id: string;
+    secret_access_key: string;
+    session_token?: string;
+}
+export interface AssetCloudinaryConfiguration {
+    cloud_name: string;
+    api_key: string;
+}
+export interface AssetCloudinaryCredentials {
+    api_secret: string;
+}
+interface AssetConnectionInputBase {
+    name: string;
+}
+export type AssetConnectionInput = AssetConnectionInputBase & ({
+    provider: 'aws_s3';
+    configuration: AssetS3ConnectionConfiguration;
+    credentials?: AssetS3StaticCredentials;
+} | {
+    provider: 'r2' | 'wasabi' | 'minio' | 's3';
+    configuration: AssetS3ConnectionConfiguration;
+    credentials: AssetS3StaticCredentials;
+} | {
+    provider: 'cloudinary';
+    configuration: AssetCloudinaryConfiguration;
+    credentials: AssetCloudinaryCredentials;
+} | {
+    provider: 'stackshift_s2';
+    s2_bucket_id: string;
+    configuration?: never;
+    credentials?: never;
+});
+export interface AssetStorageConfiguration {
+    storage_mode: AssetStorageMode;
+    connection_id?: string;
+    s2_bucket_id?: string;
+    object_prefix?: string;
+    derivative_prefix?: string;
+    auto_extract_text?: boolean;
+    expected_revision?: number;
+}
+export interface AssetS2Bucket {
+    id: string;
+    name: string;
+    workspace_id?: string;
+    project_id?: string;
+    region: string;
+    visibility: string;
+    versioning_enabled: boolean;
+    quota_bytes?: number;
+    object_count: number;
+    size_bytes: number;
+    created_at: string;
+    updated_at: string;
+}
+export interface AssetMigrationInput {
+    kind?: 'import' | 'relocate';
+    source_connection_id?: string;
+    destination_bucket_id: string;
+    source_prefix?: string;
+    conflict_policy?: 'skip' | 'new_version' | 'rename';
+    dry_run?: boolean;
+}
+export interface AssetMigration {
+    id: string;
+    kind: 'import' | 'relocate';
+    source_connection_id?: string;
+    destination_bucket_id: string;
+    source_prefix: string;
+    conflict_policy: 'skip' | 'new_version' | 'rename';
+    dry_run: boolean;
+    status: AssetMigrationStatus;
+    phase: 'inventory' | 'transfer' | 'complete' | string;
+    total_items: number;
+    processed_items: number;
+    imported_items: number;
+    skipped_items: number;
+    failed_items: number;
+    total_bytes: number;
+    processed_bytes: number;
+    report: Record<string, JsonValue>;
+    cancel_requested_at?: string;
+    started_at?: string;
+    completed_at?: string;
+    created_at: string;
+    updated_at: string;
+}
+export interface AssetMigrationItem {
+    id: string;
+    migration_id: string;
+    source_identity: string;
+    source_key: string;
+    destination_key: string;
+    content_type?: string;
+    size?: number;
+    checksum_sha256?: string;
+    checksum_state: 'known' | 'pending_execution' | 'verified';
+    source_metadata: Record<string, JsonValue>;
+    source_tags: string[];
+    status: AssetMigrationItemStatus;
+    attempt_count: number;
+    max_attempts: number;
+    mapped_asset_id?: string;
+    warning_code?: string;
+    error_code?: string;
+    error_message?: string;
+    created_at: string;
+    updated_at: string;
+    finished_at?: string;
+}
+export interface AssetTextBlock {
+    text: string;
+    type: string;
+    confidence: number;
+    box: [number, number, number, number];
+}
+export interface AssetTextPage {
+    number: number;
+    width: number;
+    height: number;
+    blocks: AssetTextBlock[];
+}
+export interface AssetTextExtraction {
+    id: string;
+    checksum_sha256: string;
+    provider: string;
+    engine_version: string;
+    language: string;
+    options_hash: string;
+    status: 'pending' | 'processing' | 'ready' | 'failed';
+    plain_text?: string;
+    pages: AssetTextPage[];
+    page_count: number;
+    error_code?: string;
+    error_message?: string;
+    created_at: string;
+    updated_at: string;
+    completed_at?: string;
+}
+export interface AssetUploadCapabilityInput {
+    bucket: string;
+    key_prefix?: string;
+    fixed_key?: string;
+    allowed_mime_types?: string[];
+    allowed_origins: string[];
+    max_bytes: number;
+    allow_remote_url?: boolean;
+    expires_in: string;
+}
+export interface AssetUploadCapability {
+    id: string;
+    bucket: string;
+    key_prefix: string;
+    fixed_key?: string;
+    allowed_mime_types: string[];
+    allowed_origins: string[];
+    max_bytes: number;
+    allow_remote_url: boolean;
+    session_id?: string;
+    expires_at: string;
+    created_at: string;
+}
+export interface CreatedAssetUploadCapability {
+    capability: AssetUploadCapability;
+    token: string;
+}
+export interface AssetMigrationListResult {
+    migrations: AssetMigration[];
+}
+export interface AssetConnectionListResult {
+    connections: AssetConnection[];
+}
+export interface AssetS2BucketListResult {
+    buckets: AssetS2Bucket[];
+}
+export interface AssetRelocationInput {
+    dry_run?: boolean;
+}
+export interface AssetTextExtractionInput {
+    language?: string;
+    options?: Record<string, JsonValue>;
+}
+export type AssetMigrationReport = {
+    migration: AssetMigration;
+    items: AssetMigrationItem[];
+} | Record<string, JsonValue>;
+export type AssetCapabilityUploadResult = Asset;
+export type AssetStorageBucket = AssetBucket;
+export {};

package/dist/assets-platform-types.js

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

package/dist/assets-platform.d.ts

@@ -0,0 +1,55 @@
+import type { StackShift } from './client.js';
+import type { AssetBucket } from './types.js';
+import type { AssetConnection, AssetConnectionInput, AssetConnectionListResult, AssetMigration, AssetMigrationInput, AssetMigrationListResult, AssetMigrationReport, AssetRelocationInput, AssetS2Bucket, AssetS2BucketListResult, AssetStorageConfiguration, AssetTextExtraction, AssetTextExtractionInput, AssetUploadCapabilityInput, CreatedAssetUploadCapability } from './assets-platform-types.js';
+export declare class AssetConnectionsClient {
+    private readonly client;
+    constructor(client: StackShift);
+    list(): Promise<AssetConnectionListResult>;
+    get(connectionId: string): Promise<AssetConnection>;
+    create(input: AssetConnectionInput): Promise<AssetConnection>;
+    update(connectionId: string, input: Partial<AssetConnectionInput>): Promise<AssetConnection>;
+    verify(connectionId: string): Promise<AssetConnection>;
+    delete(connectionId: string): Promise<{
+        deleted: boolean;
+    }>;
+}
+export declare class AssetStorageClient {
+    private readonly client;
+    constructor(client: StackShift);
+    configure(bucketId: string, revision: number, input: AssetStorageConfiguration): Promise<AssetBucket>;
+    listS2Buckets(): Promise<AssetS2BucketListResult>;
+    createS2Bucket(input: {
+        name: string;
+        region: string;
+    }): Promise<AssetS2Bucket>;
+    relocate(bucketId: string, input?: AssetRelocationInput): Promise<AssetMigration>;
+}
+export declare class AssetMigrationsClient {
+    private readonly client;
+    constructor(client: StackShift);
+    start(input: AssetMigrationInput): Promise<AssetMigration>;
+    list(options?: {
+        limit?: number;
+    }): Promise<AssetMigrationListResult>;
+    get(migrationId: string): Promise<AssetMigration>;
+    cancel(migrationId: string): Promise<{
+        canceled: boolean;
+    }>;
+    retryItem(migrationId: string, itemId: string): Promise<{
+        queued: boolean;
+    }>;
+    report(migrationId: string, format?: 'json'): Promise<AssetMigrationReport>;
+    downloadReport(migrationId: string, format?: 'json' | 'csv'): Promise<Blob>;
+}
+export declare class AssetTextClient {
+    private readonly client;
+    constructor(client: StackShift);
+    start(assetId: string, input?: AssetTextExtractionInput): Promise<AssetTextExtraction>;
+    get(assetId: string): Promise<AssetTextExtraction>;
+    retry(extractionId: string): Promise<AssetTextExtraction>;
+}
+export declare class AssetUploadCapabilitiesClient {
+    private readonly client;
+    constructor(client: StackShift);
+    create(input: AssetUploadCapabilityInput): Promise<CreatedAssetUploadCapability>;
+}

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.d.ts

@@ -1,4 +1,7 @@
 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 +9,12 @@ export declare function assetTransformOptions(preset: AssetTransformPreset): Ass
 export declare function assetTransformSpec(options: AssetTransformOptions): string;
 export declare class AssetsClient {
     private readonly client;
+    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>;
@@ -95,6 +104,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,6 @@
+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 +44,20 @@ export function assetTransformSpec(options) {
 }
 export class AssetsClient {
     client;
+    connections;
+    storage;
+    migrations;
+    text;
+    uploadCapabilities;
+    workflows;
     constructor(client) {
         this.client = 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', {
@@ -130,7 +145,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 +211,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))}`;
@@ -346,6 +333,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 +450,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 +504,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 +511,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

@@ -17,12 +17,18 @@ 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>;
     private requestFrom;
+    private fetchFrom;
 }
 export declare class StackShiftAPIError extends Error {
     readonly status: number;