@uploadista/client-core 0.0.3

package/dist/client/uploadista-websocket-manager.js

@@ -0,0 +1,207 @@
+import { webSocketMessageSchema } from "@uploadista/core/types";
+/**
+ * Unified WebSocket management for both upload and flow events
+ */
+export class UploadistaWebSocketManager {
+    constructor(uploadistaApi, logger, onEvent) {
+        this.uploadistaApi = uploadistaApi;
+        this.logger = logger;
+        this.onEvent = onEvent;
+        this.uploadWebsockets = new Map();
+        this.flowWebsockets = new Map();
+    }
+    /**
+     * Open a WebSocket connection for upload events
+     */
+    async openUploadWebSocket(uploadId) {
+        // Close existing connection if any
+        this.closeUploadWebSocket(uploadId);
+        const ws = await this.uploadistaApi.openUploadWebSocket(uploadId);
+        this.uploadWebsockets.set(uploadId, ws);
+        ws.onmessage = (event) => {
+            try {
+                const parsedEvent = webSocketMessageSchema.safeParse(JSON.parse(event.data));
+                if (parsedEvent.success) {
+                    if (parsedEvent.data.type === "upload_event") {
+                        this.onEvent?.(parsedEvent.data.payload);
+                    }
+                }
+                else {
+                    this.logger.error(`Error parsing upload event: ${parsedEvent.error.message}`);
+                }
+            }
+            catch (error) {
+                this.logger.error(`Error parsing upload event: ${error}`);
+            }
+        };
+        ws.onerror = (error) => {
+            this.logger.error(`Upload WebSocket error for ${uploadId}: ${error}`);
+        };
+        ws.onclose = (event) => {
+            this.logger.log(`Upload WebSocket closed for ${uploadId}, \n code: ${event.code}, reason: ${event.reason}`);
+            this.uploadWebsockets.delete(uploadId);
+        };
+        return ws;
+    }
+    /**
+     * Open a WebSocket connection for flow/job events
+     */
+    async openFlowWebSocket(jobId) {
+        // Close existing connection if any
+        this.closeFlowWebSocket(jobId);
+        const ws = await this.uploadistaApi.openFlowWebSocket(jobId);
+        this.flowWebsockets.set(jobId, ws);
+        ws.onmessage = (event) => {
+            try {
+                const message = JSON.parse(event.data);
+                switch (message.type) {
+                    case "connection":
+                        this.logger.log(`Flow WebSocket connected for job: ${message.id}`);
+                        break;
+                    case "subscribed":
+                        this.logger.log(`Flow WebSocket subscribed for job: ${message.payload.jobId}`);
+                        break;
+                    case "error":
+                        this.logger.error(`Flow WebSocket error: ${message.message} for job ${jobId} with code ${message.code}`);
+                        break;
+                    case "pong":
+                        this.logger.log(`Flow WebSocket pong received for job: ${jobId}`);
+                        break;
+                    case "flow_event":
+                        this.onEvent?.(message.payload);
+                        break;
+                    default:
+                        this.logger.warn(`Unknown flow WebSocket message type: ${message.type}`);
+                }
+            }
+            catch (error) {
+                this.logger.error(`Error parsing flow WebSocket message:${error}`);
+            }
+        };
+        ws.onerror = (error) => {
+            this.logger.error(`Flow WebSocket error for job ${jobId}: ${error}`);
+        };
+        ws.onclose = (event) => {
+            this.logger.log(`Flow WebSocket closed for job ${jobId}, \n code: ${event.code}, reason: ${event.reason}`);
+            this.flowWebsockets.delete(jobId);
+        };
+        return ws;
+    }
+    /**
+     * Open a unified WebSocket connection - automatically determines if it's for upload or flow
+     * based on the ID format (upload IDs typically start with 'upload-', job IDs start with 'job-')
+     */
+    async openWebSocket(id) {
+        // Heuristic: if ID starts with 'upload-' or contains upload-related patterns, treat as upload
+        // Otherwise, treat as flow/job
+        if (id.startsWith("upload-") || id.includes("upload")) {
+            return await this.openUploadWebSocket(id);
+        }
+        return await this.openFlowWebSocket(id);
+    }
+    /**
+     * Close upload WebSocket connection
+     */
+    closeUploadWebSocket(uploadId) {
+        const ws = this.uploadWebsockets.get(uploadId);
+        if (ws) {
+            this.uploadistaApi.closeWebSocket(ws);
+            this.uploadWebsockets.delete(uploadId);
+        }
+    }
+    /**
+     * Close flow WebSocket connection
+     */
+    closeFlowWebSocket(jobId) {
+        const ws = this.flowWebsockets.get(jobId);
+        if (ws) {
+            this.uploadistaApi.closeWebSocket(ws);
+            this.flowWebsockets.delete(jobId);
+        }
+    }
+    /**
+     * Close WebSocket connection by ID (auto-detects type)
+     */
+    closeWebSocket(id) {
+        // Try both maps
+        this.closeUploadWebSocket(id);
+        this.closeFlowWebSocket(id);
+    }
+    /**
+     * Close all WebSocket connections (both upload and flow)
+     */
+    closeAll() {
+        // Close all upload websockets
+        for (const [uploadId, ws] of this.uploadWebsockets.entries()) {
+            this.uploadistaApi.closeWebSocket(ws);
+            this.uploadWebsockets.delete(uploadId);
+        }
+        // Close all flow websockets
+        for (const [jobId, ws] of this.flowWebsockets.entries()) {
+            this.uploadistaApi.closeWebSocket(ws);
+            this.flowWebsockets.delete(jobId);
+        }
+    }
+    /**
+     * Send ping to flow WebSocket
+     */
+    sendPing(jobId) {
+        const ws = this.flowWebsockets.get(jobId);
+        if (ws && ws.readyState === ws.OPEN) {
+            ws.send(JSON.stringify({
+                type: "ping",
+                timestamp: new Date().toISOString(),
+            }));
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Get upload WebSocket by ID
+     */
+    getUploadWebSocket(uploadId) {
+        return this.uploadWebsockets.get(uploadId);
+    }
+    /**
+     * Get flow WebSocket by ID
+     */
+    getFlowWebSocket(jobId) {
+        return this.flowWebsockets.get(jobId);
+    }
+    /**
+     * Check if upload WebSocket is connected
+     */
+    isUploadConnected(uploadId) {
+        const ws = this.uploadWebsockets.get(uploadId);
+        return ws?.readyState === ws?.OPEN;
+    }
+    /**
+     * Check if flow WebSocket is connected
+     */
+    isFlowConnected(jobId) {
+        const ws = this.flowWebsockets.get(jobId);
+        return ws?.readyState === ws?.OPEN;
+    }
+    /**
+     * Check if WebSocket is connected (auto-detects type)
+     */
+    isConnected(id) {
+        return this.isUploadConnected(id) || this.isFlowConnected(id);
+    }
+    /**
+     * Get total number of active WebSocket connections
+     */
+    getConnectionCount() {
+        return this.uploadWebsockets.size + this.flowWebsockets.size;
+    }
+    /**
+     * Get connection counts by type
+     */
+    getConnectionCountByType() {
+        return {
+            upload: this.uploadWebsockets.size,
+            flow: this.flowWebsockets.size,
+            total: this.uploadWebsockets.size + this.flowWebsockets.size,
+        };
+    }
+}

package/dist/error.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Specific error types that can occur during upload and flow operations.
+ *
+ * These error names provide fine-grained categorization of failures,
+ * allowing applications to implement targeted error handling and recovery strategies.
+ *
+ * @example Error handling by type
+ * ```typescript
+ * try {
+ *   await client.upload(file);
+ * } catch (error) {
+ *   if (error instanceof UploadistaError) {
+ *     if (error.isNetworkError()) {
+ *       // Retry network-related failures
+ *       console.log('Network issue, retrying...');
+ *     } else if (error.name === 'UPLOAD_NOT_FOUND') {
+ *       // Handle missing upload
+ *       console.log('Upload not found, starting fresh');
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export type UploadistaErrorName = "UPLOAD_SIZE_NOT_SPECIFIED" | "NETWORK_ERROR" | "NETWORK_UNEXPECTED_RESPONSE" | "UPLOAD_CHUNK_FAILED" | "WRONG_UPLOAD_SIZE" | "UPLOAD_LOCKED" | "UPLOAD_NOT_FOUND" | "CREATE_UPLOAD_FAILED" | "DELETE_UPLOAD_FAILED" | "PARALLEL_SEGMENT_CREATION_FAILED" | "PARALLEL_SEGMENT_UPLOAD_FAILED" | "FLOW_NOT_FOUND" | "FLOW_INIT_FAILED" | "FLOW_RUN_FAILED" | "FLOW_CONTINUE_FAILED" | "FLOW_UNEXPECTED_STATE" | "FLOW_INCOMPATIBLE" | "FLOW_NO_UPLOAD_ID" | "FLOW_TIMEOUT" | "FLOW_FINALIZE_FAILED" | "JOB_NOT_FOUND" | "WEBSOCKET_AUTH_FAILED";
+/**
+ * Custom error class for all Uploadista client operations.
+ *
+ * Extends the standard Error class with additional context including
+ * typed error names, HTTP status codes, and underlying error causes.
+ * This allows for precise error handling and debugging.
+ *
+ * @example Basic error handling
+ * ```typescript
+ * try {
+ *   await client.upload(file);
+ * } catch (error) {
+ *   if (error instanceof UploadistaError) {
+ *     console.log(`Error: ${error.name} - ${error.message}`);
+ *     console.log(`HTTP Status: ${error.status}`);
+ *   }
+ * }
+ * ```
+ *
+ * @example Network error detection
+ * ```typescript
+ * try {
+ *   await client.upload(file);
+ * } catch (error) {
+ *   if (error instanceof UploadistaError && error.isNetworkError()) {
+ *     // Implement retry logic for network failures
+ *     await retryWithBackoff(() => client.upload(file));
+ *   }
+ * }
+ * ```
+ */
+export declare class UploadistaError extends Error {
+    /**
+     * Typed error name indicating the specific type of failure
+     */
+    name: UploadistaErrorName;
+    /**
+     * Human-readable error message describing what went wrong
+     */
+    message: string;
+    /**
+     * The underlying error that caused this failure, if any
+     */
+    cause: Error | undefined;
+    /**
+     * HTTP status code from the server response, if applicable
+     */
+    status: number | undefined;
+    /**
+     * Creates a new UploadistaError instance.
+     *
+     * @param options - Error configuration
+     * @param options.name - Typed error name for categorization
+     * @param options.message - Descriptive error message
+     * @param options.cause - Optional underlying error that caused this failure
+     * @param options.status - Optional HTTP status code from server response
+     */
+    constructor({ name, message, cause, status, }: {
+        name: UploadistaErrorName;
+        message: string;
+        cause?: Error;
+        status?: number;
+    });
+    /**
+     * Checks if this error is related to network connectivity issues.
+     *
+     * Network errors are typically transient and may succeed on retry,
+     * making them good candidates for automatic retry logic.
+     *
+     * @returns True if this is a network-related error
+     *
+     * @example
+     * ```typescript
+     * if (error.isNetworkError()) {
+     *   // Safe to retry
+     *   await retry(() => uploadChunk());
+     * }
+     * ```
+     */
+    isNetworkError(): boolean;
+}
+//# sourceMappingURL=error.d.ts.map

package/dist/error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../src/error.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,MAAM,mBAAmB,GAC3B,2BAA2B,GAC3B,eAAe,GACf,6BAA6B,GAC7B,qBAAqB,GACrB,mBAAmB,GACnB,eAAe,GACf,kBAAkB,GAClB,sBAAsB,GACtB,sBAAsB,GACtB,kCAAkC,GAClC,gCAAgC,GAChC,gBAAgB,GAChB,kBAAkB,GAClB,iBAAiB,GACjB,sBAAsB,GACtB,uBAAuB,GACvB,mBAAmB,GACnB,mBAAmB,GACnB,cAAc,GACd,sBAAsB,GACtB,eAAe,GACf,uBAAuB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,qBAAa,eAAgB,SAAQ,KAAK;IACxC;;OAEG;IACH,IAAI,EAAE,mBAAmB,CAAC;IAE1B;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;OAEG;IACH,KAAK,EAAE,KAAK,GAAG,SAAS,CAAC;IAEzB;;OAEG;IACH,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAE3B;;;;;;;;OAQG;gBACS,EACV,IAAI,EACJ,OAAO,EACP,KAAK,EACL,MAAM,GACP,EAAE;QACD,IAAI,EAAE,mBAAmB,CAAC;QAC1B,OAAO,EAAE,MAAM,CAAC;QAChB,KAAK,CAAC,EAAE,KAAK,CAAC;QACd,MAAM,CAAC,EAAE,MAAM,CAAC;KACjB;IAQD;;;;;;;;;;;;;;;OAeG;IACH,cAAc,IAAI,OAAO;CAM1B"}

package/dist/error.js

@@ -0,0 +1,69 @@
+/**
+ * Custom error class for all Uploadista client operations.
+ *
+ * Extends the standard Error class with additional context including
+ * typed error names, HTTP status codes, and underlying error causes.
+ * This allows for precise error handling and debugging.
+ *
+ * @example Basic error handling
+ * ```typescript
+ * try {
+ *   await client.upload(file);
+ * } catch (error) {
+ *   if (error instanceof UploadistaError) {
+ *     console.log(`Error: ${error.name} - ${error.message}`);
+ *     console.log(`HTTP Status: ${error.status}`);
+ *   }
+ * }
+ * ```
+ *
+ * @example Network error detection
+ * ```typescript
+ * try {
+ *   await client.upload(file);
+ * } catch (error) {
+ *   if (error instanceof UploadistaError && error.isNetworkError()) {
+ *     // Implement retry logic for network failures
+ *     await retryWithBackoff(() => client.upload(file));
+ *   }
+ * }
+ * ```
+ */
+export class UploadistaError extends Error {
+    /**
+     * Creates a new UploadistaError instance.
+     *
+     * @param options - Error configuration
+     * @param options.name - Typed error name for categorization
+     * @param options.message - Descriptive error message
+     * @param options.cause - Optional underlying error that caused this failure
+     * @param options.status - Optional HTTP status code from server response
+     */
+    constructor({ name, message, cause, status, }) {
+        super();
+        this.name = name;
+        this.cause = cause;
+        this.message = message;
+        this.status = status;
+    }
+    /**
+     * Checks if this error is related to network connectivity issues.
+     *
+     * Network errors are typically transient and may succeed on retry,
+     * making them good candidates for automatic retry logic.
+     *
+     * @returns True if this is a network-related error
+     *
+     * @example
+     * ```typescript
+     * if (error.isNetworkError()) {
+     *   // Safe to retry
+     *   await retry(() => uploadChunk());
+     * }
+     * ```
+     */
+    isNetworkError() {
+        return (this.name === "NETWORK_ERROR" ||
+            this.name === "NETWORK_UNEXPECTED_RESPONSE");
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./chunk-buffer";
+export * from "./client";
+export * from "./error";
+export * from "./logger";
+export * from "./network-monitor";
+export * from "./services";
+export * from "./storage";
+export * from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC;AAEzB,cAAc,mBAAmB,CAAC;AAClC,cAAc,YAAY,CAAC;AAE3B,cAAc,WAAW,CAAC;AAE1B,cAAc,SAAS,CAAC"}

package/dist/index.js

@@ -0,0 +1,12 @@
+// Service interfaces
+export * from "./chunk-buffer";
+export * from "./client";
+export * from "./error";
+export * from "./logger";
+// Utilities
+export * from "./network-monitor";
+export * from "./services";
+// Storage
+export * from "./storage";
+// Core types
+export * from "./types";

package/dist/logger.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Logger interface for Uploadista client operations.
+ *
+ * Provides structured logging capabilities for debugging upload progress,
+ * flow execution, and client operations. Platform implementations should
+ * provide their own logging functions (e.g., console.log, custom loggers).
+ *
+ * @example Using with console
+ * ```typescript
+ * const logger = createLogger(true, console.log);
+ * logger.log('Upload started');
+ * logger.warn('Retrying failed chunk');
+ * logger.error('Upload failed');
+ * ```
+ */
+export type Logger = {
+    /**
+     * Log informational messages (e.g., upload progress, state changes)
+     */
+    log: (message: string) => void;
+    /**
+     * Log warning messages (e.g., retry attempts, degraded performance)
+     */
+    warn: (message: string) => void;
+    /**
+     * Log error messages (e.g., upload failures, network errors)
+     */
+    error: (message: string) => void;
+};
+/**
+ * Platform-specific logging function type.
+ *
+ * Accepts a message string and outputs it to the appropriate logging destination.
+ * This abstraction allows the client to work across different platforms
+ * (browser, Node.js, React Native) with their own logging mechanisms.
+ */
+export type LogFunction = (message: string) => void;
+/**
+ * Creates a Logger instance with configurable output.
+ *
+ * This factory function creates a logger that can be enabled/disabled
+ * and customized with a platform-specific logging function.
+ *
+ * @param enabled - Whether logging is enabled. When false, all log calls are no-ops
+ * @param logFn - Optional custom logging function. Defaults to no-op. Pass console.log for browser/Node.js
+ * @returns A Logger instance with log, warn, and error methods
+ *
+ * @example Basic usage with console
+ * ```typescript
+ * const logger = createLogger(true, console.log);
+ * logger.log('Upload started');
+ * ```
+ *
+ * @example Disabled logger (no output)
+ * ```typescript
+ * const logger = createLogger(false);
+ * logger.log('This will not be logged');
+ * ```
+ *
+ * @example Custom logging function
+ * ```typescript
+ * const customLog = (msg: string) => {
+ *   // Send to analytics service
+ *   analytics.track('upload_log', { message: msg });
+ * };
+ * const logger = createLogger(true, customLog);
+ * ```
+ */
+export declare function createLogger(enabled: boolean, logFn?: LogFunction): Logger;
+//# sourceMappingURL=logger.d.ts.map

package/dist/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,MAAM,GAAG;IACnB;;OAEG;IACH,GAAG,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IAE/B;;OAEG;IACH,IAAI,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IAEhC;;OAEG;IACH,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CAClC,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;AAYpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,OAAO,EAChB,KAAK,GAAE,WAAqB,GAC3B,MAAM,CAkBR"}

package/dist/logger.js

@@ -0,0 +1,59 @@
+/**
+ * Default no-op logger function.
+ *
+ * Used when no custom logging function is provided.
+ * Platform implementations should provide their own (e.g., console.log).
+ */
+const noopLog = () => {
+    // No-op by default - platforms will override
+};
+/**
+ * Creates a Logger instance with configurable output.
+ *
+ * This factory function creates a logger that can be enabled/disabled
+ * and customized with a platform-specific logging function.
+ *
+ * @param enabled - Whether logging is enabled. When false, all log calls are no-ops
+ * @param logFn - Optional custom logging function. Defaults to no-op. Pass console.log for browser/Node.js
+ * @returns A Logger instance with log, warn, and error methods
+ *
+ * @example Basic usage with console
+ * ```typescript
+ * const logger = createLogger(true, console.log);
+ * logger.log('Upload started');
+ * ```
+ *
+ * @example Disabled logger (no output)
+ * ```typescript
+ * const logger = createLogger(false);
+ * logger.log('This will not be logged');
+ * ```
+ *
+ * @example Custom logging function
+ * ```typescript
+ * const customLog = (msg: string) => {
+ *   // Send to analytics service
+ *   analytics.track('upload_log', { message: msg });
+ * };
+ * const logger = createLogger(true, customLog);
+ * ```
+ */
+export function createLogger(enabled, logFn = noopLog) {
+    return {
+        log: (message) => {
+            if (enabled) {
+                logFn(message);
+            }
+        },
+        warn: (message) => {
+            if (enabled) {
+                logFn(message);
+            }
+        },
+        error: (message) => {
+            if (enabled) {
+                logFn(message);
+            }
+        },
+    };
+}

package/dist/mock-data-store.d.ts

@@ -0,0 +1,30 @@
+import type { DataStoreCapabilities, UploadStrategy } from "@uploadista/core/types";
+/**
+ * Mock data store implementation for client-side capability negotiation.
+ * This doesn't perform actual data store operations but provides capability information
+ * for upload strategy decisions.
+ */
+export declare class MockClientDataStore {
+    private capabilities;
+    constructor(capabilities: DataStoreCapabilities);
+    getCapabilities(): DataStoreCapabilities;
+    validateUploadStrategy(strategy: UploadStrategy): boolean;
+}
+/**
+ * Default capabilities that assume basic parallel upload support
+ * (conservative defaults that work with most backends)
+ */
+export declare const defaultClientCapabilities: DataStoreCapabilities;
+/**
+ * Capabilities for S3-compatible backends
+ */
+export declare const s3LikeCapabilities: DataStoreCapabilities;
+/**
+ * Capabilities for GCS-compatible backends
+ */
+export declare const gcsLikeCapabilities: DataStoreCapabilities;
+/**
+ * Capabilities for filesystem-based backends
+ */
+export declare const filesystemLikeCapabilities: DataStoreCapabilities;
+//# sourceMappingURL=mock-data-store.d.ts.map

package/dist/mock-data-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-data-store.d.ts","sourceRoot":"","sources":["../src/mock-data-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,qBAAqB,EACrB,cAAc,EACf,MAAM,wBAAwB,CAAC;AAEhC;;;;GAIG;AACH,qBAAa,mBAAmB;IAClB,OAAO,CAAC,YAAY;gBAAZ,YAAY,EAAE,qBAAqB;IAEvD,eAAe,IAAI,qBAAqB;IAIxC,sBAAsB,CAAC,QAAQ,EAAE,cAAc,GAAG,OAAO;CAU1D;AAED;;;GAGG;AACH,eAAO,MAAM,yBAAyB,EAAE,qBAYvC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,qBAYhC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,mBAAmB,EAAE,qBAYjC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,0BAA0B,EAAE,qBAYxC,CAAC"}

package/dist/mock-data-store.js

@@ -0,0 +1,88 @@
+/**
+ * Mock data store implementation for client-side capability negotiation.
+ * This doesn't perform actual data store operations but provides capability information
+ * for upload strategy decisions.
+ */
+export class MockClientDataStore {
+    constructor(capabilities) {
+        this.capabilities = capabilities;
+    }
+    getCapabilities() {
+        return this.capabilities;
+    }
+    validateUploadStrategy(strategy) {
+        switch (strategy) {
+            case "parallel":
+                return this.capabilities.supportsParallelUploads;
+            case "single":
+                return true;
+            default:
+                return false;
+        }
+    }
+}
+/**
+ * Default capabilities that assume basic parallel upload support
+ * (conservative defaults that work with most backends)
+ */
+export const defaultClientCapabilities = {
+    supportsParallelUploads: true,
+    supportsConcatenation: true,
+    supportsDeferredLength: true,
+    supportsResumableUploads: true,
+    supportsTransactionalUploads: false,
+    maxConcurrentUploads: 6, // Browser-safe default
+    minChunkSize: 64 * 1024, // 64KB
+    maxChunkSize: 100 * 1024 * 1024, // 100MB
+    maxParts: 10000,
+    optimalChunkSize: 8 * 1024 * 1024, // 8MB
+    requiresOrderedChunks: false,
+};
+/**
+ * Capabilities for S3-compatible backends
+ */
+export const s3LikeCapabilities = {
+    supportsParallelUploads: true,
+    supportsConcatenation: true,
+    supportsDeferredLength: true,
+    supportsResumableUploads: true,
+    supportsTransactionalUploads: true,
+    maxConcurrentUploads: 60,
+    minChunkSize: 5 * 1024 * 1024, // 5MiB S3 minimum
+    maxChunkSize: 5 * 1024 * 1024 * 1024, // 5GiB S3 maximum
+    maxParts: 10000,
+    optimalChunkSize: 8 * 1024 * 1024, // 8MB
+    requiresOrderedChunks: false,
+};
+/**
+ * Capabilities for GCS-compatible backends
+ */
+export const gcsLikeCapabilities = {
+    supportsParallelUploads: false, // GCS doesn't have native multipart
+    supportsConcatenation: true, // Can combine files
+    supportsDeferredLength: true,
+    supportsResumableUploads: true,
+    supportsTransactionalUploads: false,
+    maxConcurrentUploads: 1,
+    minChunkSize: undefined,
+    maxChunkSize: undefined,
+    maxParts: undefined,
+    optimalChunkSize: 8 * 1024 * 1024, // 8MB
+    requiresOrderedChunks: true,
+};
+/**
+ * Capabilities for filesystem-based backends
+ */
+export const filesystemLikeCapabilities = {
+    supportsParallelUploads: false, // Sequential operations
+    supportsConcatenation: false,
+    supportsDeferredLength: false,
+    supportsResumableUploads: true,
+    supportsTransactionalUploads: false,
+    maxConcurrentUploads: 1,
+    minChunkSize: undefined,
+    maxChunkSize: undefined,
+    maxParts: undefined,
+    optimalChunkSize: 1024 * 1024, // 1MB
+    requiresOrderedChunks: true,
+};