@pol-studios/powersync 1.0.25 → 1.0.32

package/dist/{pol-attachment-queue-BE2HU3Us.d.ts → types-JCEhw2Lf.d.ts}

@@ -1,6 +1,4 @@
-import { AbstractAttachmentQueue, AttachmentQueueOptions, AttachmentRecord as AttachmentRecord$1 } from '@powersync/attachments';
 import { AbstractPowerSyncDatabase } from '@powersync/common';
-import { PlatformAdapter } from './platform/index.js';
 
 /**
  * Attachment Queue Types for @pol-studios/powersync
@@ -49,9 +47,7 @@ declare enum PolAttachmentState {
     /** Attachment has been orphaned, i.e. the associated record has been deleted */
     ARCHIVED = 4,
     /** Permanently failed (exhausted retries or unrecoverable error) - POL extension */
-    FAILED_PERMANENT = 5,
-    /** Download was skipped due to downloadFilter returning false - POL extension */
-    DOWNLOAD_SKIPPED = 6
+    FAILED_PERMANENT = 5
 }
 /**
  * Extended attachment record with POL-specific upload tracking fields.
@@ -94,23 +90,12 @@ interface PolAttachmentRecord {
 /**
  * Configuration for watching a source table.
  * Used by query-builder utilities to generate SQL queries.
- *
- * Note: Either `pathColumn` or `idColumn` must be provided.
- * `pathColumn` is the preferred option; `idColumn` is deprecated but still supported.
  */
 interface WatchConfig {
     /** Source table name */
     table: string;
-    /**
-     * Column containing attachment path/ID.
-     * Preferred over `idColumn`.
-     */
-    pathColumn?: string;
-    /**
-     * Column containing attachment ID/path.
-     * @deprecated Use `pathColumn` instead. Will be removed in a future version.
-     */
-    idColumn?: string;
+    /** Column containing attachment path */
+    pathColumn: string;
     /** Additional columns to include in context */
     selectColumns?: string[];
     /** Optional WHERE clause fragment (e.g., "storagePath IS NOT NULL") */
@@ -144,20 +129,54 @@ interface SimpleAttachmentConfig {
     pathColumn: string;
 }
 /**
- * Legacy context for batch filtering of attachments.
- * @deprecated Use SkipDownloadContext with skipDownload callback instead.
- */
-interface BatchFilterContext {
-    /** All pending attachment IDs */
-    ids: string[];
-    /** Source records from watch config (ID → record) */
-    records: Map<string, Record<string, unknown>>;
-    /** Database access for batch queries */
-    db: {
-        getAll<T>(sql: string, params?: unknown[]): Promise<T[]>;
-        getOptional<T>(sql: string, params?: unknown[]): Promise<T | null>;
-    };
+ * Supabase bucket source configuration.
+ * Uses Supabase Storage as the attachment backend.
+ */
+interface SupabaseBucketSource {
+    type: 'supabase-bucket';
+    /** Supabase Storage bucket name */
+    bucket: string;
+    /**
+     * Whether to use signed URLs (default: true).
+     * Set to false for public buckets to use getPublicUrl instead of createSignedUrl.
+     */
+    signed?: boolean;
+    /**
+     * Optional: image compression settings for downloads.
+     * Uses Supabase's transform feature to resize/compress images on download.
+     * Only applies to supported image formats (jpg, png, webp, avif, gif, heic).
+     * Note: Compression is only available for supabase-bucket sources, not custom sources.
+     */
+    compression?: Partial<CompressionConfig>;
 }
+/**
+ * Custom source configuration for non-Supabase backends.
+ * Provide a getUrl function to resolve download URLs for attachment paths.
+ */
+interface CustomAttachmentSource {
+    type: 'custom';
+    /**
+     * Resolve a download URL for a given attachment path.
+     * Called during download to get the URL to fetch the file from.
+     *
+     * @param path - The attachment storage path
+     * @returns The URL to download the file from (can be async)
+     *
+     * @example
+     * ```typescript
+     * source: {
+     *   type: 'custom',
+     *   getUrl: (path) => `https://cdn.example.com/attachments/${path}`,
+     * }
+     * ```
+     */
+    getUrl: (path: string) => Promise<string> | string;
+}
+/**
+ * Discriminated union for attachment source configuration.
+ * Supports both Supabase Storage and custom backends.
+ */
+type AttachmentSource = SupabaseBucketSource | CustomAttachmentSource;
 /**
  * Configuration for an attachment source.
  *
@@ -167,57 +186,72 @@ interface BatchFilterContext {
  * @example
  * ```typescript
  * const config: AttachmentSourceConfig = {
- *   bucket: 'project-assets',
+ *   source: {
+ *     type: 'supabase-bucket',
+ *     bucket: 'project-assets',
+ *   },
  *
- *   // Reactive source of attachment IDs
- *   watchIds: (db, onUpdate) => {
- *     // Using PowerSync's watch API
+ *   // Reactive source of attachment paths
+ *   watchPaths: (db, supabase, onUpdate) => {
+ *     const controller = new AbortController();
  *     db.watch('SELECT storagePath FROM photos WHERE storagePath IS NOT NULL', [], {
  *       onResult: (results) => {
  *         onUpdate(results.rows._array.map(r => r.storagePath));
  *       }
- *     });
+ *     }, { signal: controller.signal });
+ *     return () => controller.abort();
  *   },
- *
- *   // Optional: skip downloading videos
- *   skipDownload: async ({ ids, db }) => {
- *     const videos = await db.getAll<{ path: string }>(
- *       `SELECT storagePath as path FROM photos WHERE storagePath IN (${ids.map(() => '?').join(',')}) AND mediaType LIKE 'video/%'`,
- *       ids
- *     );
- *     return videos.map(v => v.path);
- *   }
  * };
  * ```
  */
 interface AttachmentSourceConfig {
     /**
-     * Storage bucket name for this attachment source.
-     * Maps to the Supabase Storage bucket (or equivalent in other backends).
+     * Attachment storage source configuration.
+     * Supports Supabase Storage buckets or custom backends.
+     *
+     * For Supabase Storage:
+     * ```typescript
+     * source: {
+     *   type: 'supabase-bucket',
+     *   bucket: 'my-bucket',
+     *   signed: true, // default, uses createSignedUrl
+     * }
+     * ```
+     *
+     * For custom backends:
+     * ```typescript
+     * source: {
+     *   type: 'custom',
+     *   getUrl: (path) => `https://cdn.example.com/${path}`,
+     * }
+     * ```
      */
-    bucket: string;
+    source?: AttachmentSource;
     /**
-     * Reactive source of attachment IDs. Called once during initialization.
+     * Reactive source of attachment paths. Called once during initialization.
      *
      * This callback should set up a reactive subscription that calls `onUpdate`
-     * whenever the set of attachment IDs changes. The queue will:
-     * - Queue downloads for new IDs on first emission
-     * - Queue downloads for IDs that appear in subsequent emissions
-     * - Auto-archive attachments whose IDs disappear from emissions
+     * whenever the set of attachment paths changes. The queue will:
+     * - Queue downloads for new paths on first emission
+     * - Queue downloads for paths that appear in subsequent emissions
+     * - Auto-archive attachments whose paths disappear from emissions
      *
-     * For simple single-table cases, you can use `table` and `pathColumn` instead
-     * of providing a custom `watchIds` callback.
+     * Filtering should happen in this callback - only emit paths you want to download.
      *
      * @param db - PowerSync database instance for querying
-     * @param onUpdate - Callback to emit current set of attachment IDs
+     * @param supabase - Supabase client for additional queries if needed
+     * @param onUpdate - Callback to emit current set of attachment paths
      * @returns Optional cleanup function to dispose of the watch subscription
      *
      * @example
      * ```typescript
-     * watchIds: (db, onUpdate) => {
+     * watchPaths: (db, supabase, onUpdate) => {
      *   const abort = new AbortController();
      *   db.watch(
-     *     'SELECT storagePath FROM photos WHERE storagePath IS NOT NULL',
+     *     // Only emit non-video paths (filtering happens here)
+     *     `SELECT storagePath FROM photos
+     *      WHERE storagePath IS NOT NULL
+     *      AND mediaType NOT LIKE 'video/%'`,
      *     [],
      *     { onResult: (r) => onUpdate(r.rows._array.map(row => row.storagePath)) },
      *     { signal: abort.signal }
@@ -226,16 +260,17 @@ interface AttachmentSourceConfig {
      * }
      * ```
      */
-    watchIds?: (db: AbstractPowerSyncDatabase, onUpdate: (ids: string[]) => void) => (() => void) | void;
+    watchPaths?: (db: AbstractPowerSyncDatabase, supabase: unknown, // SupabaseClient - using unknown to avoid import
+    onUpdate: (paths: string[]) => void) => (() => void) | void;
     /**
      * Source table name for simplified configuration.
-     * Use with `pathColumn` as an alternative to providing a custom `watchIds` callback.
+     * Use with `pathColumn` as an alternative to providing a custom `watchPaths` callback.
      * Only for simple single-table cases without JOINs.
      *
      * @example
      * ```typescript
      * const config: AttachmentSourceConfig = {
-     *   bucket: 'photos',
+     *   source: { type: 'supabase-bucket', bucket: 'photos' },
      *   table: 'EquipmentUnitMediaContent',
      *   pathColumn: 'storagePath',
      * };
@@ -243,74 +278,45 @@ interface AttachmentSourceConfig {
      */
     table?: string;
     /**
-     * Column containing the attachment path/ID for simplified configuration.
-     * Use with `table` as an alternative to providing a custom `watchIds` callback.
+     * Column containing the attachment path for simplified configuration.
+     * Use with `table` as an alternative to providing a custom `watchPaths` callback.
      *
      * @example
      * ```typescript
      * const config: AttachmentSourceConfig = {
-     *   bucket: 'photos',
+     *   source: { type: 'supabase-bucket', bucket: 'photos' },
      *   table: 'EquipmentUnitMediaContent',
      *   pathColumn: 'storagePath',
      * };
      * ```
      */
     pathColumn?: string;
-    /**
-     * Optional batch filter to skip downloading certain attachments.
-     *
-     * Called with all pending attachment IDs. Return the IDs that should
-     * be SKIPPED (not downloaded). Useful for:
-     * - Filtering out video files on mobile
-     * - Skipping large files
-     * - Conditional download based on user preferences
-     *
-     * @param context - Contains pending IDs and database access
-     * @returns Promise resolving to array of IDs to skip
-     *
-     * @example
-     * ```typescript
-     * skipDownload: async ({ ids, db }) => {
-     *   // Skip video files
-     *   const videos = await db.getAll<{ id: string }>(
-     *     `SELECT storagePath as id FROM photos
-     *      WHERE storagePath IN (${ids.map(() => '?').join(',')})
-     *      AND mediaType LIKE 'video/%'`,
-     *     ids
-     *   );
-     *   return videos.map(v => v.id);
-     * }
-     * ```
-     */
-    skipDownload?: (context: SkipDownloadContext) => Promise<string[]>;
-}
-/**
- * Context passed to the skipDownload callback.
- */
-interface SkipDownloadContext {
-    /** All pending attachment IDs to evaluate */
-    ids: string[];
-    /** PowerSync database instance for queries */
-    db: AbstractPowerSyncDatabase;
 }
 /**
  * Full attachment configuration including source configs and handlers.
  * This extends the source config with upload/download handlers and callbacks.
  */
 interface AttachmentConfig {
-    /** Bucket name in Supabase storage */
-    bucket: string;
     /**
-     * Reactive source of attachment IDs. Called once during initialization.
-     * May return an optional cleanup function to dispose of the watch subscription.
-     * @see AttachmentSourceConfig.watchIds
+     * Attachment storage source configuration.
+     * Supports Supabase Storage buckets or custom backends.
+     *
+     * @example
+     * ```typescript
+     * source: {
+     *   type: 'supabase-bucket',
+     *   bucket: 'my-bucket',
+     *   signed: true, // default
+     * }
+     * ```
      */
-    watchIds: AttachmentSourceConfig["watchIds"];
+    source?: AttachmentSource;
     /**
-     * Optional batch filter to skip downloading certain attachments.
-     * @see AttachmentSourceConfig.skipDownload
+     * Reactive source of attachment paths. Called once during initialization.
+     * May return an optional cleanup function to dispose of the watch subscription.
+     * @see AttachmentSourceConfig.watchPaths
      */
-    skipDownload?: AttachmentSourceConfig["skipDownload"];
+    watchPaths?: AttachmentSourceConfig["watchPaths"];
     /** Optional: callback when upload completes */
     onUploadComplete?: (attachment: AttachmentRecord) => void;
     /** Optional: callback when upload fails */
@@ -321,12 +327,6 @@ interface AttachmentConfig {
     remoteStorage?: AttachmentStorageAdapter;
     /** Optional: upload handler for uploads */
     uploadHandler?: UploadHandler;
-    /**
-     * Optional: image compression settings for downloads.
-     * Uses Supabase's transform feature to resize/compress images on download.
-     * Only applies to supported image formats (jpg, png, webp, avif, gif, heic).
-     */
-    compression?: Partial<CompressionConfig>;
     /**
      * Optional: download configuration for performance tuning.
      * Adjusts concurrency and timeout for downloads.
@@ -639,243 +639,36 @@ interface IdRow {
  * AttachmentRecord is exported as OfficialAttachmentRecord.
  */
 type AttachmentRecord = PolAttachmentRecord;
-
 /**
- * POL Attachment Queue
- *
- * Extends the official @powersync/attachments AbstractAttachmentQueue with
- * POL-specific features:
- * - Reactive watchIds callback for attachment ID sources
- * - Optional skipDownload callback for filtering downloads
- * - Durable upload queue with exponential backoff retry
- * - FAILED_PERMANENT state for unrecoverable upload errors
- * - Image compression integration
- * - Upload callbacks (onUploadComplete, onUploadFailed)
+ * Resolve the bucket name from an AttachmentConfig or AttachmentSourceConfig.
  *
- * @example
- * ```typescript
- * const queue = new PolAttachmentQueue({
- *   powersync: db,
- *   storage: storageAdapter,
- *   source: {
- *     bucket: 'project-assets',
- *     watchIds: (db, onUpdate) => {
- *       db.watch('SELECT storagePath FROM photos WHERE storagePath IS NOT NULL', [], {
- *         onResult: (r) => onUpdate(r.rows._array.map(row => row.storagePath))
- *       });
- *     },
- *     skipDownload: async ({ ids, db }) => {
- *       // Return IDs to skip downloading
- *       const videos = await db.getAll('SELECT storagePath FROM photos WHERE mediaType LIKE "video/%"');
- *       return videos.map(v => v.storagePath);
- *     }
- *   },
- * });
- *
- * await queue.init();
- * ```
+ * @param config - The attachment configuration
+ * @returns The bucket name, or undefined if not configured
  */
-
+declare function resolveBucketFromConfig(config: AttachmentConfig | AttachmentSourceConfig): string | undefined;
 /**
- * Options for PolAttachmentQueue that extend the official AttachmentQueueOptions.
+ * Check if the attachment source uses signed URLs.
+ * Defaults to true for Supabase buckets, not applicable for custom sources.
+ *
+ * @param config - The attachment configuration
+ * @returns true if signed URLs should be used
  */
-interface PolAttachmentQueueOptions extends AttachmentQueueOptions {
-    platform: PlatformAdapter;
-    remoteStorage: AttachmentStorageAdapter;
-    /** Attachment source configuration with reactive watchIds callback */
-    source: AttachmentSourceConfig;
-    uploadHandler?: UploadHandler;
-    uploadConfig?: Partial<UploadConfig>;
-    /** Download configuration for concurrency tuning */
-    downloadConfig?: Partial<DownloadConfig>;
-    onUploadComplete?: (record: PolAttachmentRecord) => Promise<void>;
-    onUploadFailed?: (record: PolAttachmentRecord, error: Error) => void;
-    compression?: Partial<CompressionConfig>;
-    cache?: Partial<CacheConfig>;
-}
+declare function isSignedUrlSource(config: AttachmentConfig | AttachmentSourceConfig): boolean;
 /**
- * POL Attachment Queue that extends the official AbstractAttachmentQueue.
- */
-declare class PolAttachmentQueue extends AbstractAttachmentQueue<PolAttachmentQueueOptions> {
-    private readonly platform;
-    private readonly polLogger;
-    private readonly source;
-    private readonly remoteStorage;
-    private readonly uploadHandler?;
-    private readonly uploadConfig;
-    private readonly downloadConfig;
-    private readonly compressionConfig;
-    private readonly cacheConfig;
-    private _uploadState;
-    private _disposed;
-    private _initialized;
-    private _watchGeneration;
-    private _watchIdsCleanup;
-    private _watchMutex;
-    private _networkListenerCleanup;
-    private _wasConnected;
-    private _progressCallbacks;
-    private _lastNotifyTime;
-    private _notifyTimer;
-    private _cachedStats;
-    private _cachedStatsTimestamp;
-    constructor(options: PolAttachmentQueueOptions);
-    watchUploads(): void;
-    /**
-     * Override parent's expireCache to disable count-based cache eviction.
-     *
-     * The parent implementation deletes SYNCED/ARCHIVED records beyond cacheLimit,
-     * which caused a bug where downloads would reset because:
-     * 1. expireCache deleted records beyond cacheLimit (default 100)
-     * 2. watchIds still emitted those IDs
-     * 3. They got re-created as QUEUED_DOWNLOAD
-     * 4. Downloads restarted in an infinite loop
-     *
-     * Our implementation uses size-based cache limits only (via clearCache/cacheConfig.maxSize).
-     */
-    expireCache(): Promise<void>;
-    /**
-     * Override parent's watchDownloads to use concurrent downloads.
-     *
-     * The parent implementation downloads one file at a time.
-     * This override processes downloads in parallel batches for faster sync.
-     */
-    watchDownloads(): void;
-    /**
-     * Process pending downloads with concurrency control.
-     * Downloads multiple files in parallel based on downloadConfig.concurrency.
-     * Enforces cache size limits after each batch completes.
-     */
-    private _downloadRecordsConcurrent;
-    uploadAttachment(record: {
-        id: string;
-    }): Promise<boolean>;
-    watchAttachmentIds(): Promise<void>;
-    saveToQueue(record: Omit<AttachmentRecord$1, 'timestamp'>): Promise<AttachmentRecord$1>;
-    onAttachmentIdsChange(onUpdate: (ids: string[]) => void): void;
-    downloadRecord(record: AttachmentRecord$1): Promise<boolean>;
-    newAttachmentRecord(record?: Partial<AttachmentRecord$1>): Promise<AttachmentRecord$1>;
-    init(): Promise<void>;
-    /**
-     * Dispose the attachment queue and clean up resources.
-     * This method is synchronous to ensure callers don't need to await it,
-     * but it fires off async cleanup in the background for graceful shutdown.
-     */
-    dispose(): void;
-    /**
-     * Async cleanup that runs in the background after dispose().
-     * Waits for active upload promises to settle gracefully.
-     */
-    private _asyncCleanup;
-    queueUpload(options: {
-        storagePath: string;
-        sourceUri: string;
-        filename: string;
-        mediaType: string;
-        bucketId?: string;
-        metadata?: Record<string, unknown>;
-    }): Promise<void>;
-    getPendingUploads(): Promise<PolAttachmentRecord[]>;
-    getSoonestRetryTime(): Promise<number | null>;
-    getFailedPermanentUploads(): Promise<PolAttachmentRecord[]>;
-    getStaleUploads(): Promise<PolAttachmentRecord[]>;
-    getSyncedUploadsWithPendingCallback(): Promise<PolAttachmentRecord[]>;
-    clearUploadCallback(id: string): Promise<void>;
-    retryUpload(id: string): Promise<void>;
-    /**
-     * Reset all uploads in QUEUED_UPLOAD state so they retry immediately.
-     * This clears retry counts and errors, allowing uploads to be retried fresh.
-     *
-     * @returns The number of uploads that were reset
-     */
-    resetUploadRetries(): Promise<number>;
-    /**
-     * Trigger immediate retry of uploads WITHOUT resetting their retry count.
-     * This preserves backoff state for truly failing uploads while allowing
-     * uploads that were waiting for network to retry immediately.
-     *
-     * Only affects uploads that:
-     * - Are past their retry time (upload_next_retry_at <= now), OR
-     * - Have no retry time set (upload_next_retry_at IS NULL)
-     *
-     * @returns The number of uploads that will be retried
-     */
-    retryUploads(): Promise<number>;
-    deleteUpload(id: string): Promise<void>;
-    /**
-     * Re-queue an upload for an orphaned attachment.
-     * Use this when a database record exists with a storagePath but the file was never uploaded.
-     *
-     * This handles the case where:
-     * - User took a photo and the database record was created with a storagePath
-     * - The attachment queue record was created but disappeared before upload completed
-     * - The photo shows locally but was never uploaded to storage
-     *
-     * @param options.storagePath - The storage path (e.g., "projectId/fileId.jpg")
-     * @param options.localFileUri - URI to the local file to upload
-     * @param options.mediaType - MIME type of the file
-     * @param options.bucketId - Optional bucket ID for multi-bucket setups
-     * @returns true if upload was queued, false if already exists in valid state
-     */
-    requeueOrphanedUpload(options: {
-        storagePath: string;
-        localFileUri: string;
-        mediaType: string;
-        bucketId?: string;
-    }): Promise<boolean>;
-    getRecord(id: string): Promise<PolAttachmentRecord | null>;
-    getFailedUploads(): Promise<PolAttachmentRecord[]>;
-    retryFailedUpload(id: string): Promise<void>;
-    deleteFailedUpload(id: string): Promise<void>;
-    get activeUploads(): UploadStatus[];
-    pauseUploads(): void;
-    resumeUploads(): void;
-    clearCache(): Promise<void>;
-    cacheLocalFile(storagePath: string, sourceUri: string): Promise<void>;
-    getLocalUriForStoragePath(storagePath: string): Promise<string | null>;
-    /**
-     * Purge attachments by their IDs.
-     * Archives and deletes local files for the specified attachment IDs.
-     * Useful for edge cases where external code needs to force-remove attachments.
-     *
-     * @param ids - Array of attachment IDs to purge
-     */
-    purgeAttachments(ids: string[]): Promise<void>;
-    onProgress(callback: (stats: AttachmentSyncStats) => void): () => void;
-    getStats(): Promise<AttachmentSyncStats>;
-    /**
-     * Repair attachment sizes for synced records that have size=0.
-     * This backfills sizes from the actual file system for existing downloads.
-     * @returns Number of records repaired
-     */
-    repairAttachmentSizes(): Promise<number>;
-    private _getDownloadManagerDeps;
-    private _getUploadManagerDeps;
-    private _getCacheManagerDeps;
-    private _startUploadProcessing;
-    private _createTableIfNotExists;
-    private _migrateUploadColumns;
-    private _invalidateStatsCache;
-    private _getStatus;
-    private _notify;
-}
+ * Check if the attachment source is a custom (non-Supabase) source.
+ *
+ * @param config - The attachment configuration
+ * @returns true if this is a custom source
+ */
+declare function isCustomSource(config: AttachmentConfig | AttachmentSourceConfig): config is AttachmentConfig & {
+    source: CustomAttachmentSource;
+};
 /**
- * Factory function options that combine AttachmentConfig with required runtime dependencies.
+ * Get the URL resolver function for a custom source.
+ *
+ * @param config - The attachment configuration
+ * @returns The getUrl function, or undefined if not a custom source
  */
-interface CreateAttachmentQueueOptions extends AttachmentConfig {
-    /** Remote storage adapter for downloading/uploading files */
-    remoteStorage: AttachmentStorageAdapter;
-    /** Upload handler for processing uploads */
-    uploadHandler?: UploadHandler;
-    /** Upload configuration */
-    uploadConfig?: Partial<UploadConfig>;
-    /** Download configuration (concurrency, timeout) */
-    downloadConfig?: Partial<DownloadConfig>;
-    /** Compression configuration */
-    compression?: Partial<CompressionConfig>;
-    /** Cache configuration */
-    cache?: Partial<CacheConfig>;
-}
-declare function createPolAttachmentQueue(powersync: AbstractPowerSyncDatabase, platform: PlatformAdapter, config: CreateAttachmentQueueOptions): PolAttachmentQueue;
+declare function getCustomUrlResolver(config: AttachmentConfig | AttachmentSourceConfig): ((path: string) => Promise<string> | string) | undefined;
 
-export { type AttachmentSourceConfig as A, type BatchFilterContext as B, type CompressionConfig as C, DEFAULT_COMPRESSION_CONFIG as D, type EvictRow as E, type AttachmentRecord as F, type IdRow as I, PolAttachmentQueue as P, type SimpleAttachmentConfig as S, type UploadConfig as U, type WatchConfig as W, type PolAttachmentQueueOptions as a, PolAttachmentState as b, createPolAttachmentQueue as c, type PolAttachmentRecord as d, type SkipDownloadContext as e, type AttachmentConfig as f, type AttachmentStorageAdapter as g, DEFAULT_UPLOAD_CONFIG as h, type UploadHandler as i, type DownloadConfig as j, DEFAULT_DOWNLOAD_CONFIG as k, type CacheConfig as l, DEFAULT_CACHE_CONFIG as m, CACHE_SIZE_PRESETS as n, type CacheSizePreset as o, type CacheSizeValue as p, formatCacheSize as q, type DownloadPhase as r, type DownloadStatus as s, type UploadPhase as t, type UploadStatus as u, type AttachmentSyncStatus as v, type AttachmentSyncStats as w, type AttachmentStatsRow as x, type CacheFileRow as y, type CachedSizeRow as z };
+export { type AttachmentSource as A, resolveBucketFromConfig as B, type CustomAttachmentSource as C, DEFAULT_COMPRESSION_CONFIG as D, type EvictRow as E, isSignedUrlSource as F, isCustomSource as G, getCustomUrlResolver as H, type IdRow as I, PolAttachmentState as P, type SimpleAttachmentConfig as S, type UploadConfig as U, type WatchConfig as W, type PolAttachmentRecord as a, type SupabaseBucketSource as b, type AttachmentSourceConfig as c, type AttachmentConfig as d, type AttachmentStorageAdapter as e, type CompressionConfig as f, DEFAULT_UPLOAD_CONFIG as g, type UploadHandler as h, type DownloadConfig as i, DEFAULT_DOWNLOAD_CONFIG as j, type CacheConfig as k, DEFAULT_CACHE_CONFIG as l, CACHE_SIZE_PRESETS as m, type CacheSizePreset as n, type CacheSizeValue as o, formatCacheSize as p, type DownloadPhase as q, type DownloadStatus as r, type UploadPhase as s, type UploadStatus as t, type AttachmentSyncStatus as u, type AttachmentSyncStats as v, type AttachmentStatsRow as w, type CacheFileRow as x, type CachedSizeRow as y, type AttachmentRecord as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pol-studios/powersync",
-  "version": "1.0.25",
+  "version": "1.0.32",
   "description": "Enterprise PowerSync integration for offline-first applications",
   "license": "UNLICENSED",
   "type": "module",
@@ -52,8 +52,18 @@
       "types": "./dist/attachments/index.d.ts"
     },
     "./provider": {
-      "import": "./dist/provider/index.js",
-      "types": "./dist/provider/index.d.ts"
+      "react-native": {
+        "import": "./dist/provider/index.native.js",
+        "types": "./dist/provider/index.native.d.ts"
+      },
+      "browser": {
+        "import": "./dist/provider/index.web.js",
+        "types": "./dist/provider/index.web.d.ts"
+      },
+      "default": {
+        "import": "./dist/provider/index.js",
+        "types": "./dist/provider/index.d.ts"
+      }
     },
     "./sync": {
       "import": "./dist/sync/index.js",
@@ -132,6 +142,10 @@
     "./generator": {
       "import": "./dist/generator/index.js",
       "types": "./dist/generator/index.d.ts"
+    },
+    "./config": {
+      "import": "./dist/config/index.js",
+      "types": "./dist/config/index.d.ts"
     }
   },
   "files": [
@@ -141,7 +155,7 @@
     "commander": "^12.0.0",
     "jiti": "^2.4.0",
     "picocolors": "^1.0.0",
-    "@pol-studios/db": "1.0.59"
+    "@pol-studios/db": "1.0.61"
   },
   "peerDependencies": {
     "@powersync/react-native": ">=1.0.8",