@bugspotter/sdk 0.1.0-alpha.1 → 0.1.0-alpha.3

package/dist/capture/network.js

@@ -73,8 +73,11 @@ class NetworkCapture extends base_capture_1.BaseCapture {
             }
             try {
                 const response = await originalFetch(...args);
-                const request = this.createNetworkRequest(url, method, response.status, startTime);
-                this.addRequest(request);
+                // Only log if response is valid (handles mocked data URLs that return undefined)
+                if (response && typeof response.status === 'number') {
+                    const request = this.createNetworkRequest(url, method, response.status, startTime);
+                    this.addRequest(request);
+                }
                 return response;
             }
             catch (error) {

package/dist/collectors/dom.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DOMCollector = void 0;
 const rrweb_1 = require("rrweb");
 const buffer_1 = require("../core/buffer");
+const constants_1 = require("../constants");
 /**
  * DOM Collector - Records user interactions and DOM mutations
  * @packageDocumentation
@@ -15,7 +16,7 @@ class DOMCollector {
         this.isRecording = false;
         this.sanitizer = config.sanitizer;
         this.config = {
-            duration: (_a = config.duration) !== null && _a !== void 0 ? _a : 15,
+            duration: (_a = config.duration) !== null && _a !== void 0 ? _a : constants_1.DEFAULT_REPLAY_DURATION_SECONDS,
             sampling: {
                 mousemove: (_c = (_b = config.sampling) === null || _b === void 0 ? void 0 : _b.mousemove) !== null && _c !== void 0 ? _c : 50,
                 scroll: (_e = (_d = config.sampling) === null || _d === void 0 ? void 0 : _d.scroll) !== null && _e !== void 0 ? _e : 100,

package/dist/constants.d.ts

@@ -0,0 +1,13 @@
+/**
+ * SDK-wide constants
+ */
+/**
+ * Default duration in seconds to keep replay events in buffer
+ * Used by both BugSpotter and DOMCollector
+ */
+export declare const DEFAULT_REPLAY_DURATION_SECONDS = 15;
+/**
+ * Maximum recommended replay duration in seconds
+ * Longer durations increase memory usage
+ */
+export declare const MAX_RECOMMENDED_REPLAY_DURATION_SECONDS = 30;

package/dist/constants.js

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * SDK-wide constants
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_RECOMMENDED_REPLAY_DURATION_SECONDS = exports.DEFAULT_REPLAY_DURATION_SECONDS = void 0;
+/**
+ * Default duration in seconds to keep replay events in buffer
+ * Used by both BugSpotter and DOMCollector
+ */
+exports.DEFAULT_REPLAY_DURATION_SECONDS = 15;
+/**
+ * Maximum recommended replay duration in seconds
+ * Longer durations increase memory usage
+ */
+exports.MAX_RECOMMENDED_REPLAY_DURATION_SECONDS = 30;

package/dist/core/file-upload-handler.d.ts

@@ -0,0 +1,61 @@
+import type { BugReport } from '../index';
+export interface PresignedUrlData {
+    uploadUrl: string;
+    storageKey: string;
+}
+export interface FileToUpload {
+    type: 'screenshot' | 'replay';
+    url: string;
+    key: string;
+    blob: Blob;
+}
+export interface UploadConfirmation {
+    success: boolean;
+    type: 'screenshot' | 'replay';
+}
+/**
+ * Handles file upload operations using presigned URLs
+ * Separates concerns: preparation → upload → confirmation
+ *
+ * @remarks
+ * Upload timeout is set to 60 seconds (UPLOAD_TIMEOUT_MS).
+ * This timeout applies to individual file uploads to S3.
+ */
+export declare class FileUploadHandler {
+    private readonly apiEndpoint;
+    private readonly apiKey;
+    private static readonly UPLOAD_TIMEOUT_MS;
+    constructor(apiEndpoint: string, apiKey: string);
+    /**
+     * Orchestrates the complete file upload flow
+     * @throws Error if any step fails
+     */
+    uploadFiles(bugId: string, report: BugReport, presignedUrls: {
+        screenshot?: PresignedUrlData;
+        replay?: PresignedUrlData;
+    }): Promise<void>;
+    /**
+     * Prepare file blobs and validate presigned URLs
+     */
+    private prepareFiles;
+    /**
+     * Upload files to storage using presigned URLs (parallel execution)
+     */
+    private uploadToStorage;
+    /**
+     * Confirm uploads with backend (parallel execution)
+     */
+    private confirmUploads;
+    /**
+     * Get presigned URL with validation
+     */
+    private getPresignedUrl;
+    /**
+     * Convert data URL to Blob
+     */
+    private dataUrlToBlob;
+    /**
+     * Format file type for error messages (capitalize first letter)
+     */
+    private formatFileType;
+}

package/dist/core/file-upload-handler.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileUploadHandler = void 0;
+const compress_1 = require("./compress");
+const logger_1 = require("../utils/logger");
+const logger = (0, logger_1.getLogger)();
+/**
+ * Handles file upload operations using presigned URLs
+ * Separates concerns: preparation → upload → confirmation
+ *
+ * @remarks
+ * Upload timeout is set to 60 seconds (UPLOAD_TIMEOUT_MS).
+ * This timeout applies to individual file uploads to S3.
+ */
+class FileUploadHandler {
+    constructor(apiEndpoint, apiKey) {
+        this.apiEndpoint = apiEndpoint;
+        this.apiKey = apiKey;
+    }
+    /**
+     * Orchestrates the complete file upload flow
+     * @throws Error if any step fails
+     */
+    async uploadFiles(bugId, report, presignedUrls) {
+        const filesToUpload = await this.prepareFiles(report, presignedUrls);
+        if (filesToUpload.length === 0) {
+            return; // No files to upload
+        }
+        await this.uploadToStorage(filesToUpload);
+        await this.confirmUploads(filesToUpload, bugId);
+    }
+    /**
+     * Prepare file blobs and validate presigned URLs
+     */
+    async prepareFiles(report, presignedUrls) {
+        const files = [];
+        // Prepare screenshot
+        if (report._screenshotPreview && report._screenshotPreview.startsWith('data:image/')) {
+            const screenshotUrl = this.getPresignedUrl('screenshot', presignedUrls);
+            const screenshotBlob = await this.dataUrlToBlob(report._screenshotPreview);
+            files.push({
+                type: 'screenshot',
+                url: screenshotUrl.uploadUrl,
+                key: screenshotUrl.storageKey,
+                blob: screenshotBlob,
+            });
+        }
+        // Prepare replay
+        if (report.replay && report.replay.length > 0) {
+            const replayUrl = this.getPresignedUrl('replay', presignedUrls);
+            const compressed = await (0, compress_1.compressData)(report.replay);
+            const replayBlob = new Blob([compressed], { type: 'application/gzip' });
+            files.push({
+                type: 'replay',
+                url: replayUrl.uploadUrl,
+                key: replayUrl.storageKey,
+                blob: replayBlob,
+            });
+        }
+        return files;
+    }
+    /**
+     * Upload files to storage using presigned URLs (parallel execution)
+     */
+    async uploadToStorage(files) {
+        const uploadPromises = files.map(async (file) => {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), FileUploadHandler.UPLOAD_TIMEOUT_MS);
+            try {
+                const response = await fetch(file.url, {
+                    method: 'PUT',
+                    headers: {
+                        'Content-Type': file.blob.type || 'application/octet-stream',
+                    },
+                    body: file.blob,
+                    signal: controller.signal,
+                });
+                clearTimeout(timeoutId);
+                return { success: response.ok, type: file.type };
+            }
+            catch (error) {
+                clearTimeout(timeoutId);
+                logger.error(`Upload failed for ${file.type}:`, error);
+                return { success: false, type: file.type };
+            }
+        });
+        const results = await Promise.all(uploadPromises);
+        // Check for upload failures
+        for (const result of results) {
+            if (!result.success) {
+                throw new Error(`${this.formatFileType(result.type)} upload failed: Upload to storage failed`);
+            }
+        }
+    }
+    /**
+     * Confirm uploads with backend (parallel execution)
+     */
+    async confirmUploads(files, bugId) {
+        const confirmPromises = files.map(async (file) => {
+            try {
+                const response = await fetch(`${this.apiEndpoint}/api/v1/reports/${bugId}/confirm-upload`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'X-API-Key': this.apiKey,
+                    },
+                    body: JSON.stringify({
+                        fileType: file.type,
+                    }),
+                });
+                return { success: response.ok, type: file.type };
+            }
+            catch (error) {
+                logger.error(`Confirmation failed for ${file.type}:`, error);
+                return { success: false, type: file.type };
+            }
+        });
+        const results = await Promise.all(confirmPromises);
+        // Check for confirmation failures
+        for (const result of results) {
+            if (!result.success) {
+                throw new Error(`${this.formatFileType(result.type)} confirmation failed: Backend did not acknowledge upload`);
+            }
+        }
+    }
+    /**
+     * Get presigned URL with validation
+     */
+    getPresignedUrl(type, presignedUrls) {
+        const url = presignedUrls[type];
+        if (!url) {
+            throw new Error(`${this.formatFileType(type)} presigned URL not provided by server`);
+        }
+        return url;
+    }
+    /**
+     * Convert data URL to Blob
+     */
+    async dataUrlToBlob(dataUrl) {
+        if (!dataUrl || !dataUrl.startsWith('data:')) {
+            throw new Error('Invalid data URL');
+        }
+        const response = await fetch(dataUrl);
+        if (!response || !response.blob) {
+            throw new Error('Failed to convert data URL to Blob');
+        }
+        return await response.blob();
+    }
+    /**
+     * Format file type for error messages (capitalize first letter)
+     */
+    formatFileType(type) {
+        return type.charAt(0).toUpperCase() + type.slice(1);
+    }
+}
+exports.FileUploadHandler = FileUploadHandler;
+FileUploadHandler.UPLOAD_TIMEOUT_MS = 60000; // 60 seconds

package/dist/core/transport.d.ts

@@ -9,28 +9,19 @@ export declare class TransportError extends Error {
     readonly cause?: Error | undefined;
     constructor(message: string, endpoint: string, cause?: Error | undefined);
 }
-export declare class TokenRefreshError extends TransportError {
-    constructor(endpoint: string, cause?: Error);
+/**
+ * Authentication error - not retryable
+ */
+export declare class AuthenticationError extends Error {
+    constructor(message: string);
 }
+/**
+ * Authentication configuration - API key only
+ */
 export type AuthConfig = {
     type: 'api-key';
-    apiKey?: string;
-} | {
-    type: 'jwt';
-    token?: string;
-    onTokenExpired?: () => Promise<string>;
-} | {
-    type: 'bearer';
-    token?: string;
-    onTokenExpired?: () => Promise<string>;
-} | {
-    type: 'custom';
-    customHeader?: {
-        name: string;
-        value: string;
-    };
-} | {
-    type: 'none';
+    apiKey: string;
+    projectId: string;
 };
 export interface RetryConfig {
     /** Maximum number of retry attempts (default: 3) */
@@ -43,12 +34,10 @@ export interface RetryConfig {
     retryOn?: number[];
 }
 export interface TransportOptions {
-    /** Authentication configuration */
-    auth?: AuthConfig;
+    /** Authentication configuration (required) */
+    auth: AuthConfig;
     /** Optional logger for debugging */
     logger?: Logger;
-    /** Enable retry on token expiration (default: true) */
-    enableRetry?: boolean;
     /** Retry configuration */
     retry?: RetryConfig;
     /** Offline queue configuration */
@@ -59,7 +48,7 @@ export interface TransportOptions {
  * @param auth - Authentication configuration
  * @returns HTTP headers for authentication
  */
-export declare function getAuthHeaders(auth?: AuthConfig): Record<string, string>;
+export declare function getAuthHeaders(auth: AuthConfig): Record<string, string>;
 /**
  * Submit request with authentication, exponential backoff retry, and offline queue support
  *
@@ -69,5 +58,5 @@ export declare function getAuthHeaders(auth?: AuthConfig): Record<string, string
  * @param authOrOptions - Auth config or TransportOptions
  * @returns Response from the server
  */
-export declare function submitWithAuth(endpoint: string, body: BodyInit, contentHeaders: Record<string, string>, authOrOptions?: AuthConfig | TransportOptions): Promise<Response>;
+export declare function submitWithAuth(endpoint: string, body: BodyInit, contentHeaders: Record<string, string> | undefined, options: TransportOptions): Promise<Response>;
 export { clearOfflineQueue, type OfflineConfig } from './offline-queue';

package/dist/core/transport.js

@@ -4,7 +4,7 @@
  * exponential backoff retry, and offline queue support
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.clearOfflineQueue = exports.TokenRefreshError = exports.TransportError = void 0;
+exports.clearOfflineQueue = exports.AuthenticationError = exports.TransportError = void 0;
 exports.getAuthHeaders = getAuthHeaders;
 exports.submitWithAuth = submitWithAuth;
 const logger_1 = require("../utils/logger");
@@ -12,9 +12,7 @@ const offline_queue_1 = require("./offline-queue");
 // ============================================================================
 // CONSTANTS
 // ============================================================================
-const TOKEN_REFRESH_STATUS = 401;
 const JITTER_PERCENTAGE = 0.1;
-const DEFAULT_ENABLE_RETRY = true;
 // ============================================================================
 // CUSTOM ERROR TYPES
 // ============================================================================
@@ -27,13 +25,16 @@ class TransportError extends Error {
     }
 }
 exports.TransportError = TransportError;
-class TokenRefreshError extends TransportError {
-    constructor(endpoint, cause) {
-        super('Failed to refresh authentication token', endpoint, cause);
-        this.name = 'TokenRefreshError';
+/**
+ * Authentication error - not retryable
+ */
+class AuthenticationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'AuthenticationError';
     }
 }
-exports.TokenRefreshError = TokenRefreshError;
+exports.AuthenticationError = AuthenticationError;
 // Default configurations
 const DEFAULT_RETRY_CONFIG = {
     maxRetries: 3,
@@ -45,31 +46,18 @@ const DEFAULT_OFFLINE_CONFIG = {
     enabled: false,
     maxQueueSize: 10,
 };
-const authStrategies = {
-    'api-key': (config) => {
-        const apiKey = config.apiKey;
-        return apiKey ? { 'X-API-Key': apiKey } : {};
-    },
-    jwt: (config) => {
-        const token = config.token;
-        return token ? { Authorization: `Bearer ${token}` } : {};
-    },
-    bearer: (config) => {
-        const token = config.token;
-        return token ? { Authorization: `Bearer ${token}` } : {};
-    },
-    custom: (config) => {
-        const customHeader = config.customHeader;
-        if (!customHeader) {
-            return {};
-        }
-        const { name, value } = customHeader;
-        return name && value ? { [name]: value } : {};
-    },
-    none: () => {
-        return {};
-    },
-};
+// ============================================================================
+// AUTHENTICATION
+// ============================================================================
+/**
+ * Generate authentication headers for API key
+ */
+function generateAuthHeaders(config) {
+    if (!config || !config.apiKey) {
+        throw new AuthenticationError('Authentication is required: API key must be provided');
+    }
+    return { 'X-API-Key': config.apiKey };
+}
 // ============================================================================
 // RETRY HANDLER - Exponential Backoff Logic
 // ============================================================================
@@ -98,6 +86,10 @@ class RetryHandler {
             }
             catch (error) {
                 lastError = error;
+                // Don't retry authentication errors - they won't succeed on retry
+                if (error instanceof AuthenticationError) {
+                    throw error;
+                }
                 // Retry on network errors
                 if (attempt < this.config.maxRetries) {
                     const delay = this.calculateDelay(attempt);
@@ -132,57 +124,6 @@ class RetryHandler {
         return Math.min(delayWithJitter, this.config.maxDelay);
     }
 }
-/**
- * Type guard to check if parameter is TransportOptions
- *
- * Strategy: Check for properties that ONLY exist in TransportOptions, not in AuthConfig.
- * AuthConfig has: type, apiKey?, token?, onTokenExpired?, customHeader?
- * TransportOptions has: auth?, logger?, enableRetry?, retry?, offline?
- *
- * Key distinction: AuthConfig always has 'type' property, TransportOptions never does.
- */
-function isTransportOptions(obj) {
-    if (typeof obj !== 'object' || obj === null) {
-        return false;
-    }
-    const record = obj;
-    // If it has 'type' property, it's an AuthConfig, not TransportOptions
-    if ('type' in record) {
-        return false;
-    }
-    // Key insight: If object has TransportOptions-specific keys (even if undefined),
-    // it's likely TransportOptions since AuthConfig never has these keys
-    const hasTransportOptionsKeys = 'auth' in record ||
-        'retry' in record ||
-        'offline' in record ||
-        'logger' in record ||
-        'enableRetry' in record;
-    // Return true if it has any TransportOptions-specific keys
-    return hasTransportOptionsKeys;
-}
-/**
- * Parse transport parameters, supporting both legacy and new API signatures
- */
-function parseTransportParams(authOrOptions) {
-    var _a;
-    if (isTransportOptions(authOrOptions)) {
-        // Type guard ensures authOrOptions is TransportOptions
-        return {
-            auth: authOrOptions.auth,
-            logger: authOrOptions.logger || (0, logger_1.getLogger)(),
-            enableRetry: (_a = authOrOptions.enableRetry) !== null && _a !== void 0 ? _a : DEFAULT_ENABLE_RETRY,
-            retryConfig: Object.assign(Object.assign({}, DEFAULT_RETRY_CONFIG), authOrOptions.retry),
-            offlineConfig: Object.assign(Object.assign({}, DEFAULT_OFFLINE_CONFIG), authOrOptions.offline),
-        };
-    }
-    return {
-        auth: authOrOptions,
-        logger: (0, logger_1.getLogger)(),
-        enableRetry: DEFAULT_ENABLE_RETRY,
-        retryConfig: DEFAULT_RETRY_CONFIG,
-        offlineConfig: DEFAULT_OFFLINE_CONFIG,
-    };
-}
 // ============================================================================
 // HELPER FUNCTIONS
 // ============================================================================
@@ -207,7 +148,7 @@ async function handleOfflineFailure(error, endpoint, body, contentHeaders, auth,
     }
     logger.warn('Network error detected, queueing request for offline retry');
     const queue = new offline_queue_1.OfflineQueue(offlineConfig, logger);
-    const authHeaders = getAuthHeaders(auth);
+    const authHeaders = generateAuthHeaders(auth);
     await queue.enqueue(endpoint, body, Object.assign(Object.assign({}, contentHeaders), authHeaders));
 }
 // ============================================================================
@@ -219,13 +160,7 @@ async function handleOfflineFailure(error, endpoint, body, contentHeaders, auth,
  * @returns HTTP headers for authentication
  */
 function getAuthHeaders(auth) {
-    // No auth
-    if (!auth) {
-        return {};
-    }
-    // Apply strategy
-    const strategy = authStrategies[auth.type];
-    return strategy ? strategy(auth) : {};
+    return generateAuthHeaders(auth);
 }
 /**
  * Submit request with authentication, exponential backoff retry, and offline queue support
@@ -236,35 +171,31 @@ function getAuthHeaders(auth) {
  * @param authOrOptions - Auth config or TransportOptions
  * @returns Response from the server
  */
-async function submitWithAuth(endpoint, body, contentHeaders, authOrOptions) {
-    // Parse options (support both old signature and new options-based API)
-    const { auth, logger, enableRetry, retryConfig, offlineConfig } = parseTransportParams(authOrOptions);
+async function submitWithAuth(endpoint, body, contentHeaders = {}, options) {
+    const logger = options.logger || (0, logger_1.getLogger)();
+    const retryConfig = Object.assign(Object.assign({}, DEFAULT_RETRY_CONFIG), options.retry);
+    const offlineConfig = Object.assign(Object.assign({}, DEFAULT_OFFLINE_CONFIG), options.offline);
     // Process offline queue on each request (run in background without awaiting)
     processQueueInBackground(offlineConfig, retryConfig, logger);
     try {
         // Send with retry logic
-        const response = await sendWithRetry(endpoint, body, contentHeaders, auth, retryConfig, logger, enableRetry);
+        const response = await sendWithRetry(endpoint, body, contentHeaders, options.auth, retryConfig, logger);
         return response;
     }
     catch (error) {
         // Queue for offline retry if enabled
-        await handleOfflineFailure(error, endpoint, body, contentHeaders, auth, offlineConfig, logger);
+        await handleOfflineFailure(error, endpoint, body, contentHeaders, options.auth, offlineConfig, logger);
         throw error;
     }
 }
-/**
- * Check if auth config supports token refresh
- */
-function shouldRetryWithRefresh(auth) {
-    return (typeof auth === 'object' &&
-        (auth.type === 'jwt' || auth.type === 'bearer') &&
-        typeof auth.onTokenExpired === 'function');
-}
+// ============================================================================
+// INTERNAL HELPERS
+// ============================================================================
 /**
  * Make HTTP request with auth headers
  */
 async function makeRequest(endpoint, body, contentHeaders, auth) {
-    const authHeaders = getAuthHeaders(auth);
+    const authHeaders = generateAuthHeaders(auth);
     const headers = Object.assign(Object.assign({}, contentHeaders), authHeaders);
     return fetch(endpoint, {
         method: 'POST',
@@ -275,25 +206,9 @@ async function makeRequest(endpoint, body, contentHeaders, auth) {
 /**
  * Send request with exponential backoff retry
  */
-async function sendWithRetry(endpoint, body, contentHeaders, auth, retryConfig, logger, enableTokenRetry) {
+async function sendWithRetry(endpoint, body, contentHeaders, auth, retryConfig, logger) {
     const retryHandler = new RetryHandler(retryConfig, logger);
-    let hasAttemptedRefresh = false;
-    // Use retry handler with token refresh support
-    return retryHandler.executeWithRetry(async () => {
-        const response = await makeRequest(endpoint, body, contentHeaders, auth);
-        // Check for 401 and retry with token refresh if applicable (only once)
-        if (response.status === TOKEN_REFRESH_STATUS &&
-            enableTokenRetry &&
-            !hasAttemptedRefresh &&
-            shouldRetryWithRefresh(auth)) {
-            hasAttemptedRefresh = true;
-            const refreshedResponse = await retryWithTokenRefresh(endpoint, body, contentHeaders, auth, logger);
-            return refreshedResponse;
-        }
-        return response;
-    }, (status) => {
-        return retryConfig.retryOn.includes(status);
-    });
+    return retryHandler.executeWithRetry(async () => makeRequest(endpoint, body, contentHeaders, auth), (status) => retryConfig.retryOn.includes(status));
 }
 /**
  * Sleep for specified milliseconds
@@ -326,27 +241,6 @@ function isNetworkError(error) {
         // TypeError only if it mentions fetch or network
         (error.name === 'TypeError' && (message.includes('fetch') || message.includes('network'))));
 }
-/**
- * Retry request with refreshed token
- */
-async function retryWithTokenRefresh(endpoint, body, contentHeaders, auth, logger) {
-    try {
-        logger.warn('Token expired, attempting refresh...');
-        // Get new token
-        const newToken = await auth.onTokenExpired();
-        // Create updated auth config
-        const refreshedAuth = Object.assign(Object.assign({}, auth), { token: newToken });
-        // Retry request
-        const response = await makeRequest(endpoint, body, contentHeaders, refreshedAuth);
-        logger.log('Request retried with refreshed token');
-        return response;
-    }
-    catch (error) {
-        logger.error('Token refresh failed:', error);
-        // Return original 401 - caller should handle
-        return new Response(null, { status: TOKEN_REFRESH_STATUS, statusText: 'Unauthorized' });
-    }
-}
 // Re-export offline queue utilities
 var offline_queue_2 = require("./offline-queue");
 Object.defineProperty(exports, "clearOfflineQueue", { enumerable: true, get: function () { return offline_queue_2.clearOfflineQueue; } });

package/dist/index.d.ts

@@ -23,6 +23,20 @@ export declare class BugSpotter {
      */
     capture(): Promise<BugReport>;
     private handleBugReport;
+    /**
+     * Validate authentication configuration
+     * @throws Error if configuration is invalid
+     */
+    private validateAuthConfig;
+    /**
+     * Strip endpoint suffix from path
+     */
+    private stripEndpointSuffix;
+    /**
+     * Get the base API URL for confirm-upload calls
+     * Extracts scheme, host, and base path from the configured endpoint
+     */
+    private getApiBaseUrl;
     private submitBugReport;
     getConfig(): Readonly<BugSpotterConfig>;
     destroy(): void;
@@ -31,8 +45,11 @@ export interface BugSpotterConfig {
     endpoint?: string;
     showWidget?: boolean;
     widgetOptions?: FloatingButtonOptions;
-    /** Authentication configuration */
-    auth?: AuthConfig;
+    /**
+     * Authentication configuration (required)
+     * API key authentication with project ID
+     */
+    auth: AuthConfig;
     /** Retry configuration for failed requests */
     retry?: RetryConfig;
     /** Offline queue configuration */
@@ -124,6 +141,7 @@ export type { FloatingButtonOptions } from './widget/button';
 export { BugReportModal } from './widget/modal';
 export type { BugReportData, BugReportModalOptions, PIIDetection } from './widget/modal';
 export type { eventWithTime } from '@rrweb/types';
+export { DEFAULT_REPLAY_DURATION_SECONDS, MAX_RECOMMENDED_REPLAY_DURATION_SECONDS, } from './constants';
 /**
  * Convenience function to sanitize text with default PII patterns
  * Useful for quick sanitization without creating a Sanitizer instance