@yetter/client 0.0.11 → 0.0.13

package/dist/client.js

@@ -1,38 +1,127 @@
 var _a;
 import { YetterImageClient } from "./api.js";
-import { EventSourcePolyfill } from 'event-source-polyfill';
-export class yetter {
-    static configure(options) {
-        if (options.apiKey) {
-            if (options.is_bearer) {
-                _a.apiKey = 'Bearer ' + options.apiKey;
-            }
-            else {
-                _a.apiKey = 'Key ' + options.apiKey;
+import { EventSourcePolyfill } from "event-source-polyfill";
+const DEFAULT_POLL_INTERVAL_MS = 2000;
+const DEFAULT_UPLOAD_TIMEOUT_MS = 5 * 60 * 1000;
+const STREAM_HEARTBEAT_TIMEOUT_MS = 120000;
+const DEFAULT_ENDPOINT = "https://api.yetter.ai";
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function getEnvApiKey() {
+    return process.env.YTR_API_KEY || process.env.REACT_APP_YTR_API_KEY || "";
+}
+export class YetterClient {
+    constructor(options = {}) {
+        this.queue = {
+            submit: async (model, options) => {
+                const client = this.createApiClient();
+                return client.generate({
+                    model,
+                    ...options.input,
+                });
+            },
+            status: async (model, options) => {
+                const client = this.createApiClient();
+                const endpoint = client.getApiEndpoint();
+                const statusUrl = `${endpoint}/${model}/requests/${options.requestId}/status`;
+                const statusData = await client.getStatus({ url: statusUrl });
+                return {
+                    data: statusData,
+                    requestId: options.requestId,
+                };
+            },
+            result: async (model, options) => {
+                const client = this.createApiClient();
+                const endpoint = client.getApiEndpoint();
+                const responseUrl = `${endpoint}/${model}/requests/${options.requestId}`;
+                const responseData = await client.getResponse({ url: responseUrl });
+                return {
+                    data: responseData,
+                    requestId: options.requestId,
+                };
+            },
+        };
+        this.apiKey = "";
+        this.endpoint = options.endpoint || DEFAULT_ENDPOINT;
+        const envKey = getEnvApiKey();
+        if (envKey) {
+            this.apiKey = `Key ${envKey}`;
+        }
+        if (typeof options.apiKey === "string") {
+            this.setApiKey(options.apiKey, options.is_bearer);
+        }
+    }
+    setApiKey(rawApiKey, isBearer) {
+        const normalizedApiKey = rawApiKey.trim();
+        if (!normalizedApiKey) {
+            this.apiKey = "";
+            return;
+        }
+        this.apiKey = isBearer ? `Bearer ${normalizedApiKey}` : `Key ${normalizedApiKey}`;
+    }
+    assertApiKeyConfigured() {
+        if (!this.apiKey) {
+            throw new Error("API key is not configured. Call configure({ apiKey: 'your_key' }) or set YTR_API_KEY.");
+        }
+    }
+    createApiClient() {
+        this.assertApiKeyConfigured();
+        return new YetterImageClient({
+            apiKey: this.apiKey,
+            endpoint: this.endpoint,
+        });
+    }
+    getUploadTimeoutMs(options) {
+        if (typeof options.timeout === "number" && Number.isFinite(options.timeout) && options.timeout > 0) {
+            return options.timeout;
+        }
+        return DEFAULT_UPLOAD_TIMEOUT_MS;
+    }
+    async putWithTimeout(url, body, headers, timeoutMs) {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            return await fetch(url, {
+                method: "PUT",
+                headers,
+                body,
+                signal: controller.signal,
+            });
+        }
+        catch (error) {
+            if ((error === null || error === void 0 ? void 0 : error.name) === "AbortError") {
+                throw new Error(`Upload request timed out after ${timeoutMs}ms`);
             }
+            throw error;
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    configure(options) {
+        if (typeof options.apiKey === "string") {
+            this.setApiKey(options.apiKey, options.is_bearer);
         }
         if (options.endpoint) {
-            _a.endpoint = options.endpoint;
+            this.endpoint = options.endpoint;
         }
     }
-    static async subscribe(model, options) {
+    async subscribe(model, options) {
         var _b;
-        if (!_a.apiKey) {
-            throw new Error("API key is not configured. Call yetter.configure({ apiKey: 'your_key' }) or set YTR_API_KEY.");
-        }
-        const client = new YetterImageClient({
-            apiKey: _a.apiKey,
-            endpoint: _a.endpoint
-        });
+        const client = this.createApiClient();
         const generateResponse = await client.generate({
-            model: model,
+            model,
             ...options.input,
         });
         let status = generateResponse.status;
         let lastStatusResponse;
         const startTime = Date.now();
-        const timeoutMilliseconds = 30 * 60 * 1000; // 30 minutes
-        while (status !== "COMPLETED" && status !== "FAILED") {
+        const timeoutMilliseconds = 30 * 60 * 1000;
+        const pollIntervalMs = typeof options.pollIntervalMs === "number" && Number.isFinite(options.pollIntervalMs) && options.pollIntervalMs > 0
+            ? options.pollIntervalMs
+            : DEFAULT_POLL_INTERVAL_MS;
+        while (status !== "COMPLETED" && status !== "ERROR" && status !== "CANCELLED") {
             if (Date.now() - startTime > timeoutMilliseconds) {
                 console.warn(`Subscription timed out after 30 minutes for request ID: ${generateResponse.request_id}. Attempting to cancel.`);
                 try {
@@ -53,40 +142,38 @@ export class yetter {
                 if (options.onQueueUpdate) {
                     options.onQueueUpdate(lastStatusResponse);
                 }
+                if (status !== "COMPLETED" && status !== "ERROR" && status !== "CANCELLED") {
+                    await sleep(pollIntervalMs);
+                }
             }
             catch (error) {
                 console.error("Error during status polling:", error);
                 throw error;
             }
         }
-        if (status === "FAILED") {
-            const errorMessage = ((_b = lastStatusResponse === null || lastStatusResponse === void 0 ? void 0 : lastStatusResponse.logs) === null || _b === void 0 ? void 0 : _b.map(log => log.message).join("\n")) || "Image generation failed.";
+        if (status === "ERROR") {
+            const errorMessage = ((_b = lastStatusResponse === null || lastStatusResponse === void 0 ? void 0 : lastStatusResponse.logs) === null || _b === void 0 ? void 0 : _b.map((log) => log.message).join("\n")) || "Image generation failed.";
             throw new Error(errorMessage);
         }
-        const finalResponse = await client.getResponse({
+        if (status === "CANCELLED") {
+            throw new Error("Image generation was cancelled by user.");
+        }
+        return client.getResponse({
             url: generateResponse.response_url,
         });
-        return finalResponse;
     }
-    static async stream(model, options) {
-        if (!_a.apiKey) {
-            throw new Error("API key is not configured. Call yetter.configure({ apiKey: 'your_key' }) or set YTR_API_KEY.");
-        }
-        const client = new YetterImageClient({
-            apiKey: _a.apiKey,
-            endpoint: _a.endpoint
-        });
+    async stream(model, options) {
+        const client = this.createApiClient();
         const initialApiResponse = await client.generate({
-            model: model,
+            model,
             ...options.input,
         });
         const requestId = initialApiResponse.request_id;
         const responseUrl = initialApiResponse.response_url;
+        const statusUrl = initialApiResponse.status_url;
         const cancelUrl = initialApiResponse.cancel_url;
         const sseStreamUrl = `${client.getApiEndpoint()}/${model}/requests/${requestId}/status/stream`;
         let eventSource;
-        let streamEnded = false;
-        // Setup the promise for the done() method
         let resolveDonePromise;
         let rejectDonePromise;
         const donePromise = new Promise((resolve, reject) => {
@@ -94,13 +181,24 @@ export class yetter {
             rejectDonePromise = reject;
         });
         const controller = {
-            // This will be used by the async iterator to pull events
-            // It needs a way to buffer events or signal availability
             events: [],
             resolvers: [],
             isClosed: false,
+            isSettled: false,
+            currentStatus: "",
+            callResolver(value) {
+                if (this.isSettled)
+                    return;
+                this.isSettled = true;
+                resolveDonePromise(value);
+            },
+            callRejecter(reason) {
+                if (this.isSettled)
+                    return;
+                this.isSettled = true;
+                rejectDonePromise(reason);
+            },
             push(event) {
-                var _b;
                 if (this.isClosed)
                     return;
                 if (this.resolvers.length > 0) {
@@ -109,54 +207,43 @@ export class yetter {
                 else {
                     this.events.push(event);
                 }
-                // Check for terminal events to resolve/reject the donePromise
-                if (event.status === "COMPLETED") {
-                    streamEnded = true;
-                    client.getResponse({ url: responseUrl })
-                        .then(resolveDonePromise)
-                        .catch(rejectDonePromise)
-                        .finally(() => this.close());
-                }
-                else if (event.status === "FAILED") {
-                    streamEnded = true;
-                    rejectDonePromise(new Error(((_b = event.logs) === null || _b === void 0 ? void 0 : _b.map(l => l.message).join('\n')) || `Stream reported FAILED for ${requestId}`));
-                    this.close();
-                }
+                this.currentStatus = event.status;
             },
             error(err) {
                 if (this.isClosed)
                     return;
-                // If streamEnded is true, it means a terminal event (COMPLETED/FAILED)
-                // has already been processed and is handling the donePromise.
-                // This error is likely a secondary effect of the connection closing.
-                if (!streamEnded) {
-                    rejectDonePromise(err); // Only reject if no terminal event was processed
+                if (this.resolvers.length > 0) {
+                    this.resolvers.shift()({ value: undefined, done: true });
                 }
-                else {
-                    console.warn("SSE 'onerror' event after stream was considered ended (COMPLETED/FAILED). This error will not alter the done() promise.", err);
+                this._close();
+                const errorToReport = err instanceof Error ? err : new Error("Stream closed prematurely or unexpectedly.");
+                this.callRejecter(errorToReport);
+            },
+            done(value) {
+                if (this.isClosed)
+                    return;
+                if (this.resolvers.length > 0) {
+                    this.resolvers.shift()({ value: undefined, done: true });
                 }
-                streamEnded = true; // Ensure it's marked as ended
+                this._close();
+                this.callResolver(value);
+            },
+            cancel() {
+                if (this.isClosed)
+                    return;
                 if (this.resolvers.length > 0) {
-                    this.resolvers.shift()({ value: undefined, done: true }); // Signal error to iterator consumer
+                    this.resolvers.shift()({ value: undefined, done: true });
                 }
-                this.close(); // Proceed to close EventSource etc.
+                this._close();
+                this.callRejecter(new Error("Stream was cancelled by user."));
             },
-            close() {
+            _close() {
                 if (this.isClosed)
                     return;
                 this.isClosed = true;
-                this.resolvers.forEach(resolve => resolve({ value: undefined, done: true }));
+                this.resolvers.forEach((resolve) => resolve({ value: undefined, done: true }));
                 this.resolvers = [];
                 eventSource === null || eventSource === void 0 ? void 0 : eventSource.close();
-                // If donePromise is still pending, reject it as stream closed prematurely
-                // Use a timeout to allow any final event processing for COMPLETED/FAILED to settle it first
-                setTimeout(() => {
-                    donePromise.catch(() => { }).finally(() => {
-                        if (!streamEnded) { // If not explicitly completed or failed
-                            rejectDonePromise(new Error("Stream closed prematurely or unexpectedly."));
-                        }
-                    });
-                }, 100);
             },
             next() {
                 if (this.events.length > 0) {
@@ -165,46 +252,98 @@ export class yetter {
                 if (this.isClosed) {
                     return Promise.resolve({ value: undefined, done: true });
                 }
-                return new Promise(resolve => this.resolvers.push(resolve));
-            }
-        };
-        eventSource = new EventSourcePolyfill(sseStreamUrl, {
-            headers: { 'Authorization': `${_a.apiKey}` },
-        });
-        eventSource.onopen = (event) => {
-            console.log("SSE Connection Opened:", event);
-        };
-        eventSource.addEventListener('data', (event) => {
-            // console.log("SSE 'data' event received, raw data:", event.data);
-            try {
-                const statusData = JSON.parse(event.data);
-                controller.push(statusData);
-            }
-            catch (e) {
-                console.error("Error parsing SSE 'data' event:", e, "Raw data:", event.data);
-                controller.error(new Error(`Error parsing SSE 'data' event: ${e.message}`));
-            }
-        });
-        eventSource.addEventListener('done', (event) => {
-            // console.log("SSE 'done' event received, raw data:", event.data);
-            controller.close();
-        });
-        eventSource.onerror = (err) => {
-            var _b;
-            const message = ((_b = err === null || err === void 0 ? void 0 : err.error) === null || _b === void 0 ? void 0 : _b.message) || (err === null || err === void 0 ? void 0 : err.message) || '';
-            const isIdleTimeout = typeof message === 'string' && message.includes('No activity within') && message.includes('Reconnecting');
-            if (isIdleTimeout) {
-                console.warn("SSE idle timeout; letting EventSource auto-reconnect.", err);
-                return;
-            }
-            console.warn("SSE Connection Error (onerror) - will allow auto-reconnect:", err);
+                return new Promise((resolve) => this.resolvers.push(resolve));
+            },
         };
-        // Handle if API immediately returns a terminal status in initialApiResponse (e.g. already completed/failed)
         if (initialApiResponse.status === "COMPLETED") {
             controller.push(initialApiResponse);
+            const finalResponse = await client.getResponse({ url: responseUrl });
+            controller.done(finalResponse);
         }
-        else if (initialApiResponse.status === "FAILED") {
+        else if (initialApiResponse.status === "ERROR") {
             controller.push(initialApiResponse);
+            controller.error(new Error(`Stream reported ERROR for ${requestId}`));
+        }
+        else if (initialApiResponse.status === "CANCELLED") {
+            controller.push(initialApiResponse);
+            controller.cancel();
+        }
+        else {
+            eventSource = new EventSourcePolyfill(sseStreamUrl, {
+                headers: { Authorization: this.apiKey },
+                heartbeatTimeout: STREAM_HEARTBEAT_TIMEOUT_MS,
+            });
+            eventSource.onopen = (event) => {
+                console.log("SSE Connection Opened:", event);
+            };
+            eventSource.addEventListener("data", (event) => {
+                try {
+                    const statusData = JSON.parse(event.data);
+                    controller.push(statusData);
+                }
+                catch (e) {
+                    console.error("Error parsing SSE 'data' event:", e, "Raw data:", event.data);
+                    controller.error(new Error(`Error parsing SSE 'data' event: ${e.message}`));
+                }
+            });
+            eventSource.addEventListener("done", async (event) => {
+                try {
+                    try {
+                        eventSource === null || eventSource === void 0 ? void 0 : eventSource.close();
+                    }
+                    catch { }
+                    if (controller.currentStatus === "COMPLETED") {
+                        const response = await client.getResponse({ url: responseUrl });
+                        controller.done(response);
+                        return;
+                    }
+                    if (controller.currentStatus === "CANCELLED") {
+                        controller.cancel();
+                        return;
+                    }
+                    if (controller.currentStatus === "ERROR") {
+                        controller.error(new Error(`Stream reported ERROR for ${requestId}`));
+                        return;
+                    }
+                    const latestStatus = await client.getStatus({ url: statusUrl });
+                    controller.push(latestStatus);
+                    if (latestStatus.status === "COMPLETED") {
+                        const response = await client.getResponse({ url: responseUrl });
+                        controller.done(response);
+                    }
+                    else if (latestStatus.status === "CANCELLED") {
+                        controller.cancel();
+                    }
+                    else {
+                        controller.error(new Error(`Stream ended without terminal status for ${requestId}`));
+                    }
+                }
+                catch (e) {
+                    console.error("Error parsing SSE 'done' event:", e, "Raw data:", event.data);
+                    controller.error(new Error(`Error parsing SSE 'done' event: ${e.message}`));
+                }
+            });
+            eventSource.addEventListener("error", (event) => {
+                const rawData = event === null || event === void 0 ? void 0 : event.data;
+                if (!rawData) {
+                    console.warn("SSE transport error event; waiting for reconnect.");
+                    return;
+                }
+                console.log("SSE application 'error' event received, raw data:", rawData);
+                controller.error(new Error(`Stream reported ERROR for ${requestId}: ${rawData}`));
+            });
+            eventSource.onerror = (err) => {
+                var _b;
+                const message = ((_b = err === null || err === void 0 ? void 0 : err.error) === null || _b === void 0 ? void 0 : _b.message) || (err === null || err === void 0 ? void 0 : err.message) || "";
+                const isIdleTimeout = typeof message === "string" &&
+                    message.includes("No activity within") &&
+                    message.includes("Reconnecting");
+                if (isIdleTimeout) {
+                    console.warn("SSE idle timeout; letting EventSource auto-reconnect.", err);
+                    return;
+                }
+                console.warn("SSE connection issue (onerror); waiting for auto-reconnect.", err);
+            };
         }
         return {
             async *[Symbol.asyncIterator]() {
@@ -217,7 +356,6 @@ export class yetter {
             },
             done: () => donePromise,
             cancel: async () => {
-                controller.close();
                 try {
                     await client.cancel({ url: cancelUrl });
                     console.log(`Stream for ${requestId} - underlying request cancelled.`);
@@ -225,63 +363,181 @@ export class yetter {
                 catch (e) {
                     console.error(`Error cancelling underlying request for stream ${requestId}:`, e.message);
                 }
-                // Ensure donePromise is settled if not already
-                if (!streamEnded) {
-                    rejectDonePromise(new Error("Stream was cancelled by user."));
-                }
             },
             getRequestId: () => requestId,
         };
     }
-}
-_a = yetter;
-yetter.apiKey = 'Key ' + (process.env.YTR_API_KEY || process.env.REACT_APP_YTR_API_KEY || "");
-yetter.endpoint = "https://api.yetter.ai";
-yetter.queue = {
-    submit: async (model, options) => {
-        if (!_a.apiKey) {
-            throw new Error("API key is not configured. Call yetter.configure({ apiKey: 'your_key' }) or set YTR_API_KEY.");
+    async uploadFile(fileOrPath, options = {}) {
+        this.assertApiKeyConfigured();
+        if (typeof fileOrPath === "string") {
+            return this._uploadFromPath(fileOrPath, options);
         }
-        const client = new YetterImageClient({
-            apiKey: _a.apiKey,
-            endpoint: _a.endpoint
+        return this._uploadFromBlob(fileOrPath, options);
+    }
+    async uploadBlob(file, options = {}) {
+        return this.uploadFile(file, options);
+    }
+    async _uploadFromPath(filePath, options) {
+        const fs = await import("fs");
+        const mime = await import("mime-types");
+        if (!fs.existsSync(filePath)) {
+            throw new Error(`File not found: ${filePath}`);
+        }
+        const stats = fs.statSync(filePath);
+        const fileSize = stats.size;
+        const fileName = filePath.split(/[\\/]/).pop() || "upload";
+        const mimeType = mime.default.lookup(filePath) || "application/octet-stream";
+        const uploadTimeoutMs = this.getUploadTimeoutMs(options);
+        const client = this.createApiClient();
+        const uploadUrlResponse = await client.getUploadUrl({
+            file_name: fileName,
+            content_type: mimeType,
+            size: fileSize,
         });
-        const generateResponse = await client.generate({
-            model: model,
-            ...options.input,
+        if (uploadUrlResponse.mode === "single") {
+            await this._uploadFileSingle(filePath, uploadUrlResponse.put_url, mimeType, fileSize, options, fs, uploadTimeoutMs);
+        }
+        else {
+            await this._uploadFileMultipart(filePath, uploadUrlResponse.part_urls, uploadUrlResponse.part_size, fileSize, options, fs, uploadTimeoutMs);
+        }
+        const result = await client.uploadComplete({
+            key: uploadUrlResponse.key,
         });
-        return generateResponse;
-    },
-    status: async (model, options) => {
-        if (!_a.apiKey) {
-            throw new Error("API key is not configured. Call yetter.configure({ apiKey: 'your_key' }) or set YTR_API_KEY.");
+        if (options.onProgress) {
+            options.onProgress(100);
         }
-        const client = new YetterImageClient({
-            apiKey: _a.apiKey,
-            endpoint: _a.endpoint
+        return result;
+    }
+    async _uploadFromBlob(file, options) {
+        const fileSize = file.size;
+        const fileName = options.filename || (file instanceof File ? file.name : "blob-upload");
+        const mimeType = file.type || "application/octet-stream";
+        const uploadTimeoutMs = this.getUploadTimeoutMs(options);
+        const client = this.createApiClient();
+        const uploadUrlResponse = await client.getUploadUrl({
+            file_name: fileName,
+            content_type: mimeType,
+            size: fileSize,
         });
-        const endpoint = client.getApiEndpoint();
-        const statusUrl = `${endpoint}/${model}/requests/${options.requestId}/status`;
-        const statusData = await client.getStatus({ url: statusUrl });
-        return {
-            data: statusData,
-            requestId: options.requestId,
-        };
-    },
-    result: async (model, options) => {
-        if (!_a.apiKey) {
-            throw new Error("API key is not configured. Call yetter.configure({ apiKey: 'your_key' }) or set YTR_API_KEY.");
+        if (uploadUrlResponse.mode === "single") {
+            await this._uploadBlobSingle(file, uploadUrlResponse.put_url, mimeType, fileSize, options, uploadTimeoutMs);
         }
-        const client = new YetterImageClient({
-            apiKey: _a.apiKey,
-            endpoint: _a.endpoint
+        else {
+            await this._uploadBlobMultipart(file, uploadUrlResponse.part_urls, uploadUrlResponse.part_size, fileSize, options, uploadTimeoutMs);
+        }
+        const result = await client.uploadComplete({
+            key: uploadUrlResponse.key,
         });
-        const endpoint = client.getApiEndpoint();
-        const responseUrl = `${endpoint}/${model}/requests/${options.requestId}`;
-        const responseData = await client.getResponse({ url: responseUrl });
-        return {
-            data: responseData,
-            requestId: options.requestId,
-        };
+        if (options.onProgress) {
+            options.onProgress(100);
+        }
+        return result;
+    }
+    async _uploadFileSingle(filePath, presignedUrl, contentType, totalSize, options, fs, timeoutMs) {
+        const fileBuffer = fs.readFileSync(filePath);
+        const response = await this.putWithTimeout(presignedUrl, fileBuffer, {
+            "Content-Type": contentType,
+            "Content-Length": String(totalSize),
+        }, timeoutMs);
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Single-part upload failed (${response.status}): ${errorText}`);
+        }
+        if (options.onProgress) {
+            options.onProgress(90);
+        }
     }
+    async _uploadFileMultipart(filePath, partUrls, partSize, totalSize, options, fs, timeoutMs) {
+        const sortedParts = [...partUrls].sort((a, b) => a.part_number - b.part_number);
+        const fileHandle = fs.openSync(filePath, "r");
+        try {
+            for (let i = 0; i < sortedParts.length; i++) {
+                const part = sortedParts[i];
+                const buffer = Buffer.alloc(partSize);
+                const offset = (part.part_number - 1) * partSize;
+                const bytesRead = fs.readSync(fileHandle, buffer, 0, partSize, offset);
+                const chunk = buffer.slice(0, bytesRead);
+                if (chunk.length === 0) {
+                    break;
+                }
+                const response = await this.putWithTimeout(part.url, chunk, {
+                    "Content-Length": String(chunk.length),
+                }, timeoutMs);
+                if (!response.ok) {
+                    const errorText = await response.text();
+                    throw new Error(`Multipart upload failed at part ${part.part_number} (${response.status}): ${errorText}`);
+                }
+                if (options.onProgress) {
+                    const progress = Math.min(90, Math.floor(((i + 1) / sortedParts.length) * 90));
+                    options.onProgress(progress);
+                }
+            }
+        }
+        finally {
+            fs.closeSync(fileHandle);
+        }
+    }
+    async _uploadBlobSingle(blob, presignedUrl, contentType, _totalSize, options, timeoutMs) {
+        const response = await this.putWithTimeout(presignedUrl, blob, {
+            "Content-Type": contentType,
+        }, timeoutMs);
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Single-part upload failed (${response.status}): ${errorText}`);
+        }
+        if (options.onProgress) {
+            options.onProgress(90);
+        }
+    }
+    async _uploadBlobMultipart(blob, partUrls, partSize, totalSize, options, timeoutMs) {
+        const sortedParts = [...partUrls].sort((a, b) => a.part_number - b.part_number);
+        for (let i = 0; i < sortedParts.length; i++) {
+            const part = sortedParts[i];
+            const start = (part.part_number - 1) * partSize;
+            const end = Math.min(start + partSize, totalSize);
+            const chunk = blob.slice(start, end);
+            if (chunk.size === 0) {
+                break;
+            }
+            const response = await this.putWithTimeout(part.url, chunk, {}, timeoutMs);
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`Multipart upload failed at part ${part.part_number} (${response.status}): ${errorText}`);
+            }
+            if (options.onProgress) {
+                const progress = Math.min(90, Math.floor(((i + 1) / sortedParts.length) * 90));
+                options.onProgress(progress);
+            }
+        }
+    }
+}
+export class yetter {
+    static configure(options) {
+        this.client.configure(options);
+    }
+    static subscribe(model, options) {
+        return this.client.subscribe(model, options);
+    }
+    static stream(model, options) {
+        return this.client.stream(model, options);
+    }
+    static uploadFile(fileOrPath, options = {}) {
+        return this.client.uploadFile(fileOrPath, options);
+    }
+    static uploadBlob(file, options = {}) {
+        return this.client.uploadBlob(file, options);
+    }
+}
+_a = yetter;
+yetter.client = new YetterClient();
+yetter.queue = {
+    submit: async (model, options) => {
+        return _a.client.queue.submit(model, options);
+    },
+    status: async (model, options) => {
+        return _a.client.queue.status(model, options);
+    },
+    result: async (model, options) => {
+        return _a.client.queue.result(model, options);
+    },
 };