@pol-studios/powersync 1.0.7 → 1.0.11

package/dist/provider/index.d.ts

@@ -2,12 +2,13 @@ import { SupabaseClient } from '@supabase/supabase-js';
 import { QueryClient } from '@tanstack/react-query';
 import { A as AbstractPowerSyncDatabase, a as SyncStatus, C as CrudEntry, S as SyncMode, F as FailedTransaction, h as CompletedTransaction, b as ConnectionHealth, e as SyncMetrics, D as DownloadProgress, E as EntitySyncState, f as SyncError } from '../types-CDqWh56B.js';
 import { PlatformAdapter } from '../platform/index.js';
-import { b as ConnectorConfig, S as SupabaseConnector, g as ConflictBus } from '../supabase-connector-qLm-WHkM.js';
-import { j as PolAttachmentQueueConfig, P as PolAttachmentQueue } from '../pol-attachment-queue-C7YNXXhK.js';
+import { a as ConnectorConfig, g as ConflictBus } from '../types-B212hgfA.js';
+import { e as AttachmentConfig, P as PolAttachmentQueue, A as AttachmentSourceConfig, z as AttachmentRecord, C as CompressionConfig, i as DownloadConfig } from '../pol-attachment-queue-BVAIueoP.js';
+import { S as SupabaseConnector } from '../supabase-connector-T9vHq_3i.js';
 import * as react from 'react';
 import react__default, { ReactNode } from 'react';
 import { Schema } from '@powersync/react-native';
-import { R as RemoteStorageAdapter, A as AttachmentUploadHandler } from '../types-Bgvx7-E8.js';
+import { a as StorageBackend } from '../types-D0WcHrq6.js';
 import { h as BackgroundSyncSystem, c as SyncControlActions } from '../background-sync-ChCXW-EV.js';
 import '@powersync/attachments';
 import '@powersync/common';
@@ -83,7 +84,7 @@ interface PowerSyncConfig<TSchema = unknown> {
      * }
      * ```
      */
-    attachments?: PolAttachmentQueueConfig;
+    attachments?: AttachmentConfig;
     /**
      * Optional: Sync behavior configuration.
      */
@@ -691,23 +692,26 @@ interface PowerSyncSyncStatusSnapshot {
     isOnline: boolean;
 }
 /**
- * Attachment configuration for OfflineDataProvider
- */
-interface OfflineDataAttachmentConfig {
-    /** Storage bucket name */
-    bucket: string;
-    /** Source table for attachments */
-    sourceTable: string;
-    /** Column containing the storage path/ID */
-    idColumn: string;
-    /** Optional: Column to order downloads by */
-    orderByColumn?: string;
-    /** Optional: Filter configuration */
-    projectFilter?: {
-        foreignKey: string;
-        intermediaryTable: string;
-        projectForeignKey: string;
-    };
+ * Attachment configuration for OfflineDataProvider.
+ * Uses the new 2-callback API (watchIds, skipDownload).
+ */
+interface OfflineDataAttachmentConfig extends AttachmentSourceConfig {
+    /** Optional: callback when upload completes */
+    onUploadComplete?: (attachment: AttachmentRecord) => void;
+    /** Optional: callback when upload fails */
+    onUploadFailed?: (attachment: AttachmentRecord, error: Error) => void;
+    /** Optional: max cache size in bytes */
+    maxCacheBytes?: number;
+    /**
+     * Optional: image compression settings for downloads.
+     * Uses Supabase's transform feature to resize/compress images on download.
+     */
+    compression?: Partial<CompressionConfig>;
+    /**
+     * Optional: download configuration for performance tuning.
+     * Adjusts concurrency and timeout for downloads.
+     */
+    download?: Partial<DownloadConfig>;
 }
 /**
  * Configuration for OfflineDataProvider
@@ -768,16 +772,11 @@ interface OfflineDataProviderProps {
     skipConflictProvider?: boolean;
     /** Skip rendering StorageQueueProvider (default: false) */
     skipStorageQueueProvider?: boolean;
-    /** Custom storage adapter (overrides built-in Supabase adapter) */
-    storageAdapter?: RemoteStorageAdapter;
-    /** Custom upload handler */
-    uploadHandler?: AttachmentUploadHandler;
+    /** Custom storage backend (overrides built-in Supabase adapter) */
+    storageBackend?: StorageBackend;
     /** Custom error UI for initialization errors */
     renderInitError?: (error: Error, retry: () => void) => ReactNode;
-    /**
-     * Custom error UI (alias for renderInitError for backward compatibility)
-     * @deprecated Use renderInitError instead
-     */
+    /** Custom error UI (alias for renderInitError) */
     renderError?: (error: Error, retry: () => void) => ReactNode;
     onReady?: () => void;
     onError?: (error: Error) => void;
@@ -823,8 +822,6 @@ interface ProviderBridgeProps {
  * - Error recovery UI with retry capability
  * - Online-only mode fallback (no PowerSync URL)
  *
- * This is the recommended entry point for apps using offline-first data.
- *
  * @example
  * ```tsx
  * <OfflineDataProvider
@@ -835,8 +832,15 @@ interface ProviderBridgeProps {
  *     powerSyncUrl: env.powerSyncUrl,
  *     attachments: {
  *       bucket: 'my-bucket',
- *       sourceTable: 'MediaContent',
- *       idColumn: 'storagePath',
+ *       watchIds: (db, onUpdate) => {
+ *         db.watch('SELECT storagePath as id FROM photos', [], {
+ *           onResult: (r) => onUpdate(r.rows._array.map(x => x.id)),
+ *         });
+ *       },
+ *       skipDownload: async ({ ids }) => {
+ *         // Return IDs to skip downloading (e.g., videos)
+ *         return ids.filter(id => id.endsWith('.mp4'));
+ *       },
  *     },
  *   }}
  *   dataLayer={{ config: dataLayerConfig }}
@@ -892,7 +896,7 @@ interface ProviderBridgeProps {
  * </OfflineDataProvider>
  * ```
  */
-declare function OfflineDataProvider({ config, children, dataLayer, backgroundSync, skipConflictProvider, skipStorageQueueProvider, storageAdapter: customStorageAdapter, uploadHandler: customUploadHandler, renderInitError, renderError, onReady, onError, onSyncStatusChange, onBackgroundSyncSystemReady: onBackgroundSyncSystemReadyProp, }: OfflineDataProviderProps): react__default.ReactElement;
+declare function OfflineDataProvider({ config, children, dataLayer, backgroundSync, skipConflictProvider, skipStorageQueueProvider, storageBackend, renderInitError, renderError, onReady, onError, onSyncStatusChange, onBackgroundSyncSystemReady: onBackgroundSyncSystemReadyProp, }: OfflineDataProviderProps): react__default.ReactElement;
 
 /**
  * ProviderBridge Component for @pol-studios/powersync

package/dist/provider/index.js

@@ -2,15 +2,17 @@ import {
   OfflineDataProvider,
   PowerSyncProvider,
   ProviderBridge
-} from "../chunk-BREGB4WL.js";
+} from "../chunk-BRXQNASY.js";
+import "../chunk-YHTZ7VMV.js";
 import "../chunk-P6WOZO7H.js";
-import "../chunk-ZEOKPWUC.js";
+import "../chunk-4TXTAEF2.js";
+import "../chunk-CUCAYK7Z.js";
 import {
   DEFAULT_CONNECTION_HEALTH,
   DEFAULT_SYNC_CONFIG,
   DEFAULT_SYNC_METRICS,
   DEFAULT_SYNC_STATUS
-} from "../chunk-H772V6XQ.js";
+} from "../chunk-24RDMMCL.js";
 import {
   AttachmentQueueContext,
   CompletedTransactionsContext,
@@ -49,17 +51,14 @@ import {
   useSyncStatus,
   useUploadStatus
 } from "../chunk-YSTEESEG.js";
-import "../chunk-LNL64IJZ.js";
-import "../chunk-WQ5MPAVC.js";
-import "../chunk-TGBT5XBE.js";
-import "../chunk-UEYRTLKE.js";
-import "../chunk-MKD2VCX3.js";
+import "../chunk-CAB26E6F.js";
+import "../chunk-XAEII4ZX.js";
+import "../chunk-Z6VOBGTU.js";
 import "../chunk-CGL33PL4.js";
-import "../chunk-53WH2JJV.js";
-import "../chunk-HFOFLW5F.js";
+import "../chunk-WN5ZJ3E2.js";
+import "../chunk-KN2IZERF.js";
 import "../chunk-FV2HXEIY.js";
-import "../chunk-XQAJM2MW.js";
-import "../chunk-DGUM43GV.js";
+import "../chunk-VACPAAQZ.js";
 export {
   AttachmentQueueContext,
   CompletedTransactionsContext,

package/dist/react/index.d.ts

@@ -0,0 +1,372 @@
+import * as react from 'react';
+import react__default, { ReactNode } from 'react';
+import { Schema } from '@powersync/react-native';
+import { A as AuthProvider } from '../types-B212hgfA.js';
+import { a as StorageBackend } from '../types-D0WcHrq6.js';
+import { e as AttachmentConfig, P as PolAttachmentQueue } from '../pol-attachment-queue-BVAIueoP.js';
+import { PlatformAdapter } from '../platform/index.js';
+import { f as SyncError, a as SyncStatus, A as AbstractPowerSyncDatabase } from '../types-CDqWh56B.js';
+import '@supabase/supabase-js';
+import '@powersync/attachments';
+import '@powersync/common';
+
+/**
+ * Types for the slim PowerSyncProvider
+ *
+ * This module contains type definitions for the new simplified provider API.
+ * The types here are designed for zero domain coupling - all domain-specific
+ * logic should be handled via callbacks at the consumer level.
+ */
+
+/**
+ * PowerSync provider configuration.
+ *
+ * @example
+ * ```typescript
+ * const config: PowerSyncConfig = {
+ *   schema: AppSchema,
+ *   powerSyncUrl: 'https://my-instance.powersync.journeyapps.com',
+ *   dbFilename: 'myapp.db',
+ * };
+ * ```
+ */
+interface PowerSyncConfig {
+    /**
+     * PowerSync schema definition.
+     * Defines the tables and their structure for the local database.
+     */
+    schema: Schema;
+    /**
+     * PowerSync service URL.
+     * @example "https://your-instance.powersync.journeyapps.com"
+     */
+    powerSyncUrl: string;
+    /**
+     * Database filename.
+     * @default "powersync.db"
+     */
+    dbFilename?: string;
+}
+/**
+ * Props for the slim PowerSyncProvider.
+ *
+ * This provider is designed to be minimal and composable:
+ * - No @pol/db coupling
+ * - No domain-specific logic
+ * - All callbacks are optional
+ *
+ * @example
+ * ```typescript
+ * <PowerSyncProvider
+ *   config={{
+ *     schema: AppSchema,
+ *     powerSyncUrl: POWERSYNC_URL,
+ *     dbFilename: 'myapp.db',
+ *   }}
+ *   auth={supabaseAuth}
+ *   storage={supabaseStorage}
+ *   attachments={{
+ *     watch: {
+ *       table: 'MediaContent',
+ *       idColumn: 'storagePath',
+ *     },
+ *   }}
+ *   onError={(error) => console.error(error)}
+ *   onReady={() => console.log('Ready!')}
+ * >
+ *   <App />
+ * </PowerSyncProvider>
+ * ```
+ */
+interface PowerSyncProviderProps {
+    /**
+     * PowerSync configuration.
+     */
+    config: PowerSyncConfig;
+    /**
+     * Authentication provider.
+     * Abstracts auth for the connector - works with any auth backend.
+     *
+     * @example
+     * ```typescript
+     * import { createSupabaseAuth } from '@pol-studios/powersync';
+     * const auth = createSupabaseAuth(supabaseClient);
+     * ```
+     */
+    auth: AuthProvider;
+    /**
+     * Storage backend for attachments (required if using attachments).
+     *
+     * @example
+     * ```typescript
+     * import { createSupabaseStorage } from '@pol-studios/powersync';
+     * const storage = createSupabaseStorage({
+     *   client: supabaseClient,
+     *   defaultBucket: 'attachments',
+     * });
+     * ```
+     */
+    storage?: StorageBackend;
+    /**
+     * Attachment configuration.
+     * Zero domain coupling - use skipDownload callback for domain-specific filtering.
+     */
+    attachments?: AttachmentConfig;
+    /**
+     * Platform adapter (auto-detected if omitted).
+     * Use createNativePlatformAdapter() for React Native.
+     */
+    platform?: PlatformAdapter;
+    /**
+     * Error handler for sync failures.
+     * Receives structured errors with classification and user messages.
+     */
+    onError?: (error: SyncError) => void;
+    /**
+     * Called when PowerSync is initialized and ready.
+     */
+    onReady?: () => void;
+    /**
+     * Called when sync status changes.
+     */
+    onSyncStatusChange?: (status: SyncStatus) => void;
+    /**
+     * Child components to render.
+     */
+    children: ReactNode;
+}
+/**
+ * Value provided by the main PowerSyncContext.
+ */
+interface PowerSyncContextValue {
+    /**
+     * The PowerSync database instance.
+     * Will be null if not initialized or if initialization failed.
+     */
+    db: AbstractPowerSyncDatabase | null;
+    /**
+     * Whether the PowerSync database is ready for use.
+     */
+    isReady: boolean;
+    /**
+     * Whether the provider is currently initializing.
+     */
+    isInitializing: boolean;
+    /**
+     * Error that occurred during initialization, if any.
+     */
+    error: Error | null;
+    /**
+     * The platform adapter instance.
+     */
+    platform: PlatformAdapter;
+}
+/**
+ * Value provided by the SyncStatusContext.
+ */
+interface SyncStatusContextValue {
+    /**
+     * Current sync status.
+     */
+    status: SyncStatus;
+    /**
+     * Timestamp of the last successful sync.
+     */
+    lastSyncedAt: Date | null;
+}
+/**
+ * Value provided by the AttachmentQueueContext.
+ */
+interface AttachmentQueueContextValue {
+    /**
+     * The attachment queue instance.
+     * Will be null if attachments are not configured or not initialized.
+     */
+    queue: PolAttachmentQueue | null;
+    /**
+     * Whether the attachment queue is ready for use.
+     */
+    isReady: boolean;
+}
+
+/**
+ * Slim PowerSyncProvider for @pol-studios/powersync
+ *
+ * A simplified, composable provider that:
+ * - Has zero @pol/db coupling
+ * - Uses AuthProvider interface for any auth backend
+ * - Delegates domain logic to callbacks
+ * - Is ~150 lines vs 1400+ in the legacy provider
+ *
+ * For backwards compatibility, the legacy OfflineDataProvider is still available.
+ */
+
+/**
+ * Slim PowerSyncProvider - minimal, composable, no domain coupling.
+ *
+ * This provider handles:
+ * - Database initialization via platform adapter
+ * - Connector setup using AuthProvider
+ * - Attachment queue initialization (if configured)
+ * - Sync status tracking
+ * - Error classification and callbacks
+ *
+ * @example
+ * ```tsx
+ * import { PowerSyncProvider, createSupabaseAuth, createSupabaseStorage } from '@pol-studios/powersync/react';
+ *
+ * function App() {
+ *   const auth = useMemo(() => createSupabaseAuth(supabase), [supabase]);
+ *   const storage = useMemo(() => createSupabaseStorage({
+ *     client: supabase,
+ *     defaultBucket: 'attachments',
+ *   }), [supabase]);
+ *
+ *   return (
+ *     <PowerSyncProvider
+ *       config={{ schema: AppSchema, powerSyncUrl: URL, dbFilename: 'app.db' }}
+ *       auth={auth}
+ *       storage={storage}
+ *       attachments={{ watch: { table: 'Media', idColumn: 'storagePath' } }}
+ *       onError={(error) => showToast(error.userMessage)}
+ *       onReady={() => console.log('Ready!')}
+ *     >
+ *       <MyApp />
+ *     </PowerSyncProvider>
+ *   );
+ * }
+ * ```
+ */
+declare function SlimPowerSyncProvider({ config, auth, storage, attachments, platform: customPlatform, onError, onReady, onSyncStatusChange, children, }: PowerSyncProviderProps): react__default.ReactElement;
+
+/**
+ * Main context for PowerSync database instance and initialization state.
+ *
+ * Provides access to:
+ * - PowerSync database instance
+ * - Initialization state (isReady, isInitializing, error)
+ * - Platform adapter
+ *
+ * @example
+ * ```typescript
+ * import { useContext } from 'react';
+ * import { PowerSyncContext } from '@pol-studios/powersync/react';
+ *
+ * function MyComponent() {
+ *   const { db, isReady, error } = useContext(PowerSyncContext);
+ *   if (!isReady) return <Loading />;
+ *   if (error) return <Error message={error.message} />;
+ *   // Use db...
+ * }
+ * ```
+ */
+declare const PowerSyncContext: react.Context<PowerSyncContextValue>;
+/**
+ * Context for sync status updates.
+ *
+ * Provides access to:
+ * - Current sync status (connected, syncing, etc.)
+ * - Last synced timestamp
+ *
+ * @example
+ * ```typescript
+ * import { useContext } from 'react';
+ * import { SyncStatusContext } from '@pol-studios/powersync/react';
+ *
+ * function SyncIndicator() {
+ *   const { status, lastSyncedAt } = useContext(SyncStatusContext);
+ *   return (
+ *     <View>
+ *       {status.connected ? 'Connected' : 'Offline'}
+ *       {lastSyncedAt && <Text>Last synced: {lastSyncedAt.toISOString()}</Text>}
+ *     </View>
+ *   );
+ * }
+ * ```
+ */
+declare const SyncStatusContext: react.Context<SyncStatusContextValue>;
+/**
+ * Context for the attachment queue (if configured).
+ *
+ * Provides access to:
+ * - AttachmentQueue instance for checking stats, pausing/resuming downloads
+ * - Ready state for the attachment queue
+ *
+ * @example
+ * ```typescript
+ * import { useContext } from 'react';
+ * import { AttachmentQueueContext } from '@pol-studios/powersync/react';
+ *
+ * function AttachmentStatus() {
+ *   const { queue, isReady } = useContext(AttachmentQueueContext);
+ *   if (!isReady || !queue) return null;
+ *
+ *   const stats = await queue.getStats();
+ *   return <Text>Downloaded: {stats.syncedCount}/{stats.totalExpected}</Text>;
+ * }
+ * ```
+ */
+declare const AttachmentQueueContext: react.Context<AttachmentQueueContextValue>;
+
+/**
+ * React Module for @pol-studios/powersync
+ *
+ * This module exports the new slim PowerSyncProvider and related contexts/types.
+ * For backwards compatibility, the legacy OfflineDataProvider is still available
+ * from the main package export.
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   PowerSyncProvider,
+ *   usePowerSyncContext,
+ *   useSyncStatusContext,
+ *   useAttachmentQueueContext,
+ * } from '@pol-studios/powersync/react';
+ * ```
+ */
+
+/**
+ * Hook to access the PowerSync context.
+ * Throws if used outside of a PowerSyncProvider.
+ *
+ * @example
+ * ```typescript
+ * function MyComponent() {
+ *   const { db, isReady, error } = usePowerSyncContext();
+ *   if (!isReady) return <Loading />;
+ *   if (error) return <Error message={error.message} />;
+ *   // Use db...
+ * }
+ * ```
+ */
+declare function usePowerSyncContext(): PowerSyncContextValue;
+/**
+ * Hook to access sync status.
+ * Throws if used outside of a PowerSyncProvider.
+ *
+ * @example
+ * ```typescript
+ * function SyncIndicator() {
+ *   const { status, lastSyncedAt } = useSyncStatusContext();
+ *   return <Text>{status.connected ? 'Online' : 'Offline'}</Text>;
+ * }
+ * ```
+ */
+declare function useSyncStatusContext(): SyncStatusContextValue;
+/**
+ * Hook to access the attachment queue.
+ * Throws if used outside of a PowerSyncProvider.
+ *
+ * @example
+ * ```typescript
+ * function AttachmentStatus() {
+ *   const { queue, isReady } = useAttachmentQueueContext();
+ *   if (!isReady || !queue) return null;
+ *   // Use queue...
+ * }
+ * ```
+ */
+declare function useAttachmentQueueContext(): AttachmentQueueContextValue;
+
+export { AttachmentQueueContext, type AttachmentQueueContextValue, type PowerSyncConfig, PowerSyncContext, type PowerSyncContextValue, SlimPowerSyncProvider as PowerSyncProvider, type PowerSyncProviderProps, SlimPowerSyncProvider, SyncStatusContext, type SyncStatusContextValue, useAttachmentQueueContext, usePowerSyncContext, useSyncStatusContext };

package/dist/react/index.js

@@ -0,0 +1,25 @@
+import {
+  AttachmentQueueContext,
+  PowerSyncContext,
+  SlimPowerSyncProvider,
+  SyncStatusContext,
+  useAttachmentQueueContext,
+  usePowerSyncContext,
+  useSyncStatusContext
+} from "../chunk-63PXSPIN.js";
+import "../chunk-4TXTAEF2.js";
+import "../chunk-24RDMMCL.js";
+import "../chunk-KN2IZERF.js";
+import "../chunk-FV2HXEIY.js";
+import "../chunk-VACPAAQZ.js";
+export {
+  AttachmentQueueContext,
+  PowerSyncContext,
+  SlimPowerSyncProvider as PowerSyncProvider,
+  SlimPowerSyncProvider,
+  SyncStatusContext,
+  useAttachmentQueueContext,
+  usePowerSyncContext,
+  useSyncStatusContext
+};
+//# sourceMappingURL=index.js.map

package/dist/storage/index.d.ts

@@ -1,6 +1,6 @@
-export { A as AttachmentUploadHandler, a as BucketConfig, B as BucketResolver, D as DownloadResult, P as PowerSyncStorageAdapter, R as RemoteStorageAdapter, S as StorageUploadHandler, b as SupabaseStorageAdapterOptions, U as UploadOptions, r as resolveBucketFromConfig } from '../types-Bgvx7-E8.js';
-export { a as CacheSettings, C as CacheSettingsManager, b as CacheSettingsManagerOptions, D as DEFAULT_CACHE_SETTINGS, S as SupabaseStorageAdapter, c as createSupabaseStorageAdapter } from '../CacheSettingsManager-1exbOC6S.js';
-export { D as DEFAULT_UPLOAD_NOTIFICATION, S as SupabaseUploadHandlerOptions, U as UploadEventHandlers, a as UploadNotificationConfig } from '../types-BVacP54t.js';
+export { D as DownloadResult, a as StorageBackend, b as StorageUploadOptions, d as SupabaseClient, S as SupabaseStorage, c as SupabaseStorageOptions, e as SupabaseTransformOptions, U as UploadProgress, r as resolveBucket } from '../types-D0WcHrq6.js';
+export { f as CacheSettings, C as CacheSettingsManager, h as CacheSettingsManagerOptions, D as DEFAULT_CACHE_SETTINGS, I as ImageTransformOptions, S as SupabaseStorageAdapter, e as SupabaseStorageAdapterOptions, c as createSupabaseStorage, d as createSupabaseStorageAdapter, g as getStorageErrorMessage, a as isBlobResult, i as isFileResult, b as isStorageAuthError, n as normalizeStoragePath } from '../CacheSettingsManager-uz-kbnRH.js';
+export { D as DEFAULT_UPLOAD_NOTIFICATION, S as SupabaseUploadHandlerOptions, U as UploadEventHandlers, a as UploadNotificationConfig } from '../types-CyvBaAl8.js';
 export { SupabaseUploadHandler, createSupabaseUploadHandler } from './upload/index.js';
 import '../platform/index.js';
 import '../types-CDqWh56B.js';

package/dist/storage/index.js

@@ -1,28 +1,42 @@
-import "../chunk-LNL64IJZ.js";
+import "../chunk-T4AO7JIG.js";
 import {
   CacheSettingsManager,
   DEFAULT_CACHE_SETTINGS,
+  createSupabaseStorage,
+  isBlobResult,
+  isFileResult
+} from "../chunk-XOY2CJ67.js";
+import {
   SupabaseStorageAdapter,
-  createSupabaseStorageAdapter
-} from "../chunk-WQ5MPAVC.js";
+  createSupabaseStorageAdapter,
+  getStorageErrorMessage,
+  isStorageAuthError,
+  normalizeStoragePath
+} from "../chunk-XAEII4ZX.js";
 import "../chunk-TGBT5XBE.js";
 import {
   SupabaseUploadHandler,
   createSupabaseUploadHandler
-} from "../chunk-UEYRTLKE.js";
+} from "../chunk-P4HZA6ZT.js";
 import {
   DEFAULT_UPLOAD_NOTIFICATION,
-  resolveBucketFromConfig
-} from "../chunk-MKD2VCX3.js";
-import "../chunk-DGUM43GV.js";
+  resolveBucket
+} from "../chunk-Z6VOBGTU.js";
+import "../chunk-FV2HXEIY.js";
 export {
   CacheSettingsManager,
   DEFAULT_CACHE_SETTINGS,
   DEFAULT_UPLOAD_NOTIFICATION,
   SupabaseStorageAdapter,
   SupabaseUploadHandler,
+  createSupabaseStorage,
   createSupabaseStorageAdapter,
   createSupabaseUploadHandler,
-  resolveBucketFromConfig
+  getStorageErrorMessage,
+  isBlobResult,
+  isFileResult,
+  isStorageAuthError,
+  normalizeStoragePath,
+  resolveBucket
 };
 //# sourceMappingURL=index.js.map

package/dist/storage/index.native.d.ts

@@ -1,6 +1,6 @@
-export { A as AttachmentUploadHandler, a as BucketConfig, B as BucketResolver, D as DownloadResult, P as PowerSyncStorageAdapter, R as RemoteStorageAdapter, S as StorageUploadHandler, b as SupabaseStorageAdapterOptions, U as UploadOptions, r as resolveBucketFromConfig } from '../types-Bgvx7-E8.js';
-export { a as CacheSettings, C as CacheSettingsManager, b as CacheSettingsManagerOptions, D as DEFAULT_CACHE_SETTINGS, S as SupabaseStorageAdapter, c as createSupabaseStorageAdapter } from '../CacheSettingsManager-1exbOC6S.js';
-export { D as DEFAULT_UPLOAD_NOTIFICATION, S as SupabaseUploadHandlerOptions, U as UploadEventHandlers, a as UploadNotificationConfig } from '../types-BVacP54t.js';
+export { D as DownloadResult, a as StorageBackend, b as StorageUploadOptions, d as SupabaseClient, S as SupabaseStorage, c as SupabaseStorageOptions, U as UploadProgress, r as resolveBucket } from '../types-D0WcHrq6.js';
+export { f as CacheSettings, C as CacheSettingsManager, h as CacheSettingsManagerOptions, D as DEFAULT_CACHE_SETTINGS, S as SupabaseStorageAdapter, c as createSupabaseStorage, d as createSupabaseStorageAdapter, g as getStorageErrorMessage, a as isBlobResult, i as isFileResult, b as isStorageAuthError, n as normalizeStoragePath } from '../CacheSettingsManager-uz-kbnRH.js';
+export { D as DEFAULT_UPLOAD_NOTIFICATION, S as SupabaseUploadHandlerOptions, U as UploadEventHandlers, a as UploadNotificationConfig } from '../types-CyvBaAl8.js';
 export { SupabaseUploadHandler, createSupabaseUploadHandler } from './upload/index.native.js';
 import '../platform/index.js';
 import '../types-CDqWh56B.js';