@pol-studios/powersync 1.0.7 → 1.0.10

package/dist/chunk-XOY2CJ67.js

@@ -0,0 +1,289 @@
+import {
+  getStorageErrorMessage,
+  isStorageAuthError,
+  normalizeStoragePath
+} from "./chunk-XAEII4ZX.js";
+import {
+  resolveBucket
+} from "./chunk-Z6VOBGTU.js";
+
+// src/storage/supabase.ts
+function createSupabaseStorage(options) {
+  const {
+    client,
+    defaultBucket,
+    bucketMap,
+    bucketResolver,
+    signedUrlExpiry = 60,
+    fileSystem,
+    logger
+  } = options;
+  function getBucket(storagePath) {
+    return resolveBucket({
+      defaultBucket,
+      bucketMap,
+      bucketResolver
+    }, storagePath);
+  }
+  async function getSignedUrl(remotePath) {
+    const normalizedPath = normalizeStoragePath(remotePath);
+    const bucket = getBucket(normalizedPath);
+    logger?.debug?.(`[SupabaseStorage] Creating signed URL`, {
+      bucket,
+      path: normalizedPath,
+      originalPath: remotePath !== normalizedPath ? remotePath : void 0
+    });
+    const {
+      data,
+      error
+    } = await client.storage.from(bucket).createSignedUrl(normalizedPath, signedUrlExpiry);
+    if (error) {
+      const errorMessage = getStorageErrorMessage(error);
+      if (isStorageAuthError(error)) {
+        logger?.warn?.(`[SupabaseStorage] Auth error creating signed URL, refreshing session:`, {
+          path: normalizedPath,
+          bucket,
+          error: errorMessage
+        });
+        try {
+          await client.auth.refreshSession();
+          const {
+            data: retryData,
+            error: retryError
+          } = await client.storage.from(bucket).createSignedUrl(normalizedPath, signedUrlExpiry);
+          if (retryError) {
+            const retryErrorMessage = getStorageErrorMessage(retryError);
+            throw new Error(`Failed to create signed URL after session refresh: ${retryErrorMessage}`);
+          }
+          if (!retryData?.signedUrl) {
+            throw new Error("Failed to create signed URL after session refresh: No URL returned");
+          }
+          logger?.info?.(`[SupabaseStorage] Successfully created signed URL after session refresh`);
+          return retryData.signedUrl;
+        } catch (refreshError) {
+          throw new Error(`Failed to create signed URL: ${errorMessage} (session refresh also failed: ${refreshError instanceof Error ? refreshError.message : String(refreshError)})`);
+        }
+      }
+      throw new Error(`Failed to create signed URL for '${normalizedPath}' in bucket '${bucket}': ${errorMessage}`);
+    }
+    if (!data?.signedUrl) {
+      throw new Error(`Failed to create signed URL for '${normalizedPath}' in bucket '${bucket}': No URL returned`);
+    }
+    return data.signedUrl;
+  }
+  async function download(remotePath) {
+    const signedUrl = await getSignedUrl(remotePath);
+    if (fileSystem) {
+      const cacheDir = fileSystem.getCacheDirectory();
+      const tempFileName = `download_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+      const tempPath = `${cacheDir}/${tempFileName}`;
+      try {
+        await fileSystem.downloadFile(signedUrl, tempPath);
+        return {
+          type: "file",
+          uri: tempPath
+        };
+      } catch (downloadError) {
+        try {
+          const info = await fileSystem.getFileInfo(tempPath);
+          if (info?.exists) {
+            await fileSystem.deleteFile(tempPath);
+          }
+        } catch {
+        }
+        throw downloadError;
+      }
+    }
+    const response = await fetch(signedUrl);
+    if (!response.ok) {
+      throw new Error(`Download failed with status ${response.status}: ${remotePath}`);
+    }
+    const blob = await response.blob();
+    return {
+      type: "blob",
+      data: blob
+    };
+  }
+  async function upload(remotePath, localUri, contentType, options2) {
+    const normalizedPath = normalizeStoragePath(remotePath);
+    const bucket = getBucket(normalizedPath);
+    const {
+      signal,
+      onProgress
+    } = options2 ?? {};
+    let fileData;
+    if (fileSystem && localUri.startsWith("file://")) {
+      const base64Content = await fileSystem.readFile(localUri, "base64");
+      const binaryString = atob(base64Content);
+      const bytes = new Uint8Array(binaryString.length);
+      for (let i = 0; i < binaryString.length; i++) {
+        bytes[i] = binaryString.charCodeAt(i);
+      }
+      fileData = new Blob([bytes], {
+        type: contentType
+      });
+    } else if (localUri.startsWith("blob:") || localUri.startsWith("http")) {
+      const response = await fetch(localUri);
+      fileData = await response.blob();
+    } else {
+      throw new Error(`Unsupported URI format: ${localUri}`);
+    }
+    if (signal?.aborted) {
+      throw new Error("Upload cancelled");
+    }
+    onProgress?.({
+      loaded: 0,
+      total: fileData.size
+    });
+    const {
+      error
+    } = await client.storage.from(bucket).upload(normalizedPath, fileData, {
+      contentType,
+      upsert: true
+    });
+    if (error) {
+      const errorMessage = getStorageErrorMessage(error);
+      throw new Error(`Upload failed for '${normalizedPath}' in bucket '${bucket}': ${errorMessage}`);
+    }
+    onProgress?.({
+      loaded: fileData.size,
+      total: fileData.size
+    });
+  }
+  async function deleteFile(remotePath) {
+    const normalizedPath = normalizeStoragePath(remotePath);
+    const bucket = getBucket(normalizedPath);
+    const {
+      error
+    } = await client.storage.from(bucket).remove([normalizedPath]);
+    if (error) {
+      const errorMessage = getStorageErrorMessage(error);
+      throw new Error(`Delete failed for '${normalizedPath}' in bucket '${bucket}': ${errorMessage}`);
+    }
+  }
+  return {
+    download,
+    upload,
+    delete: deleteFile,
+    resolveBucket: getBucket
+  };
+}
+function isFileResult(result) {
+  return result.type === "file";
+}
+function isBlobResult(result) {
+  return result.type === "blob";
+}
+
+// src/storage/cache/types.ts
+var DEFAULT_CACHE_SETTINGS = {
+  maxCacheSizeMb: 5120,
+  // 5 GB
+  compressionQuality: 0.7
+  // 70% quality
+};
+
+// src/storage/cache/CacheSettingsManager.ts
+var STORAGE_KEYS = {
+  MAX_CACHE_SIZE_MB: "max-cache-size-mb",
+  COMPRESSION_QUALITY: "compression-quality"
+};
+var CacheSettingsManager = class {
+  storage;
+  keyPrefix;
+  defaults;
+  constructor(storage, options) {
+    this.storage = storage;
+    this.keyPrefix = options?.storageKeyPrefix ?? "@pol-studios/cache";
+    this.defaults = {
+      ...DEFAULT_CACHE_SETTINGS,
+      ...options?.defaults
+    };
+  }
+  /**
+   * Get the full storage key for a setting.
+   */
+  getKey(setting) {
+    return `${this.keyPrefix}/${STORAGE_KEYS[setting]}`;
+  }
+  /**
+   * Get all cache settings.
+   */
+  async getSettings() {
+    const keys = [this.getKey("MAX_CACHE_SIZE_MB"), this.getKey("COMPRESSION_QUALITY")];
+    const results = await this.storage.multiGet(keys);
+    const sizeValue = results.find(([k]) => k === keys[0])?.[1];
+    const qualityValue = results.find(([k]) => k === keys[1])?.[1];
+    return {
+      maxCacheSizeMb: sizeValue ? Number(sizeValue) : this.defaults.maxCacheSizeMb,
+      compressionQuality: qualityValue ? Number(qualityValue) : this.defaults.compressionQuality
+    };
+  }
+  /**
+   * Get the maximum cache size in megabytes.
+   * Returns 0 for unlimited.
+   */
+  async getMaxCacheSizeMb() {
+    const value = await this.storage.getItem(this.getKey("MAX_CACHE_SIZE_MB"));
+    return value ? Number(value) : this.defaults.maxCacheSizeMb;
+  }
+  /**
+   * Set the maximum cache size in megabytes.
+   * Use 0 for unlimited.
+   *
+   * @param mb - Maximum cache size in megabytes
+   */
+  async setMaxCacheSizeMb(mb) {
+    if (mb < 0) {
+      throw new Error("Cache size must be non-negative");
+    }
+    await this.storage.setItem(this.getKey("MAX_CACHE_SIZE_MB"), String(mb));
+  }
+  /**
+   * Get the maximum cache size in bytes.
+   * Returns Number.MAX_SAFE_INTEGER for unlimited.
+   */
+  async getMaxCacheSizeBytes() {
+    const mb = await this.getMaxCacheSizeMb();
+    return mb === 0 ? Number.MAX_SAFE_INTEGER : mb * 1024 * 1024;
+  }
+  /**
+   * Get the compression quality (0.0 to 1.0).
+   */
+  async getCompressionQuality() {
+    const value = await this.storage.getItem(this.getKey("COMPRESSION_QUALITY"));
+    return value ? Number(value) : this.defaults.compressionQuality;
+  }
+  /**
+   * Set the compression quality.
+   *
+   * @param quality - Compression quality (0.0 to 1.0)
+   */
+  async setCompressionQuality(quality) {
+    if (quality < 0 || quality > 1) {
+      throw new Error("Compression quality must be between 0 and 1");
+    }
+    await this.storage.setItem(this.getKey("COMPRESSION_QUALITY"), String(quality));
+  }
+  /**
+   * Reset all settings to defaults.
+   */
+  async resetToDefaults() {
+    await this.storage.multiSet([[this.getKey("MAX_CACHE_SIZE_MB"), String(this.defaults.maxCacheSizeMb)], [this.getKey("COMPRESSION_QUALITY"), String(this.defaults.compressionQuality)]]);
+  }
+  /**
+   * Clear all stored settings.
+   */
+  async clear() {
+    await Promise.all([this.storage.removeItem(this.getKey("MAX_CACHE_SIZE_MB")), this.storage.removeItem(this.getKey("COMPRESSION_QUALITY"))]);
+  }
+};
+
+export {
+  createSupabaseStorage,
+  isFileResult,
+  isBlobResult,
+  DEFAULT_CACHE_SETTINGS,
+  CacheSettingsManager
+};
+//# sourceMappingURL=chunk-XOY2CJ67.js.map

package/dist/chunk-XOY2CJ67.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/storage/supabase.ts","../src/storage/cache/types.ts","../src/storage/cache/CacheSettingsManager.ts"],"sourcesContent":["/**\n * Supabase Storage Backend for @pol-studios/powersync\n *\n * Unified storage implementation using Supabase Storage.\n * Handles both web (Blob) and native (file URI) downloads.\n *\n * @example\n * ```typescript\n * import { createSupabaseStorage } from '@pol-studios/powersync/storage';\n *\n * const storage = createSupabaseStorage({\n *   client: supabaseClient,\n *   defaultBucket: 'attachments',\n *   fileSystem: platform.fileSystem, // Required for native\n * });\n *\n * // Download\n * const result = await storage.download('photos/image.jpg');\n * if (result.type === 'file') {\n *   // Native: zero-copy file path\n *   console.log('Downloaded to:', result.uri);\n * } else {\n *   // Web: Blob in memory\n *   console.log('Downloaded blob:', result.data.size, 'bytes');\n * }\n *\n * // Upload with progress\n * await storage.upload('photos/new.jpg', 'file:///local/path.jpg', 'image/jpeg', {\n *   onProgress: ({ loaded, total }) => {\n *     console.log(`Progress: ${Math.round(loaded / total * 100)}%`);\n *   },\n * });\n * ```\n */\n\nimport type { StorageBackend, DownloadResult, StorageUploadOptions, SupabaseStorageOptions, SupabaseClient } from './types';\nimport { resolveBucket } from './types';\nimport { isStorageAuthError, getStorageErrorMessage, normalizeStoragePath } from './auth-error-utils';\n\n/**\n * Create a Supabase storage backend.\n *\n * @param options - Configuration options\n * @returns StorageBackend implementation\n */\nexport function createSupabaseStorage(options: SupabaseStorageOptions): StorageBackend {\n  const {\n    client,\n    defaultBucket,\n    bucketMap,\n    bucketResolver,\n    signedUrlExpiry = 60,\n    fileSystem,\n    logger\n  } = options;\n\n  /**\n   * Get the bucket for a storage path.\n   */\n  function getBucket(storagePath: string): string {\n    return resolveBucket({\n      defaultBucket,\n      bucketMap,\n      bucketResolver\n    }, storagePath);\n  }\n\n  /**\n   * Create a signed download URL with automatic session refresh on auth errors.\n   */\n  async function getSignedUrl(remotePath: string): Promise<string> {\n    // Normalize the path to remove any leading slashes\n    // Supabase Storage expects paths without leading slashes\n    const normalizedPath = normalizeStoragePath(remotePath);\n    const bucket = getBucket(normalizedPath);\n    logger?.debug?.(`[SupabaseStorage] Creating signed URL`, {\n      bucket,\n      path: normalizedPath,\n      originalPath: remotePath !== normalizedPath ? remotePath : undefined\n    });\n\n    // First attempt\n    const {\n      data,\n      error\n    } = await client.storage.from(bucket).createSignedUrl(normalizedPath, signedUrlExpiry);\n    if (error) {\n      const errorMessage = getStorageErrorMessage(error);\n\n      // Check if this is an auth error that might be fixed by refreshing the session\n      if (isStorageAuthError(error)) {\n        logger?.warn?.(`[SupabaseStorage] Auth error creating signed URL, refreshing session:`, {\n          path: normalizedPath,\n          bucket,\n          error: errorMessage\n        });\n        try {\n          // Refresh the session\n          await client.auth.refreshSession();\n\n          // Retry the request\n          const {\n            data: retryData,\n            error: retryError\n          } = await client.storage.from(bucket).createSignedUrl(normalizedPath, signedUrlExpiry);\n          if (retryError) {\n            const retryErrorMessage = getStorageErrorMessage(retryError);\n            throw new Error(`Failed to create signed URL after session refresh: ${retryErrorMessage}`);\n          }\n          if (!retryData?.signedUrl) {\n            throw new Error('Failed to create signed URL after session refresh: No URL returned');\n          }\n          logger?.info?.(`[SupabaseStorage] Successfully created signed URL after session refresh`);\n          return retryData.signedUrl;\n        } catch (refreshError) {\n          throw new Error(`Failed to create signed URL: ${errorMessage} (session refresh also failed: ${refreshError instanceof Error ? refreshError.message : String(refreshError)})`);\n        }\n      }\n\n      // Non-auth error, throw with normalized error message\n      throw new Error(`Failed to create signed URL for '${normalizedPath}' in bucket '${bucket}': ${errorMessage}`);\n    }\n    if (!data?.signedUrl) {\n      throw new Error(`Failed to create signed URL for '${normalizedPath}' in bucket '${bucket}': No URL returned`);\n    }\n    return data.signedUrl;\n  }\n\n  /**\n   * Download a file from remote storage.\n   *\n   * Returns a discriminated union:\n   * - Native (with fileSystem): `{ type: 'file', uri: string }` - zero-copy file path\n   * - Web (no fileSystem): `{ type: 'blob', data: Blob }` - blob in memory\n   */\n  async function download(remotePath: string): Promise<DownloadResult> {\n    const signedUrl = await getSignedUrl(remotePath);\n\n    // Native path: download directly to temp file\n    if (fileSystem) {\n      const cacheDir = fileSystem.getCacheDirectory();\n      const tempFileName = `download_${Date.now()}_${Math.random().toString(36).slice(2)}`;\n      const tempPath = `${cacheDir}/${tempFileName}`;\n      try {\n        await fileSystem.downloadFile(signedUrl, tempPath);\n        return {\n          type: 'file',\n          uri: tempPath\n        };\n      } catch (downloadError) {\n        // Clean up temp file on error\n        try {\n          const info = await fileSystem.getFileInfo(tempPath);\n          if (info?.exists) {\n            await fileSystem.deleteFile(tempPath);\n          }\n        } catch {\n          // Ignore cleanup errors\n        }\n        throw downloadError;\n      }\n    }\n\n    // Web path: fetch as blob\n    const response = await fetch(signedUrl);\n    if (!response.ok) {\n      throw new Error(`Download failed with status ${response.status}: ${remotePath}`);\n    }\n    const blob = await response.blob();\n    return {\n      type: 'blob',\n      data: blob\n    };\n  }\n\n  /**\n   * Upload a file to remote storage.\n   *\n   * Supports both native file URIs and web blob URLs.\n   */\n  async function upload(remotePath: string, localUri: string, contentType: string, options?: StorageUploadOptions): Promise<void> {\n    // Normalize the path to remove any leading slashes\n    const normalizedPath = normalizeStoragePath(remotePath);\n    const bucket = getBucket(normalizedPath);\n    const {\n      signal,\n      onProgress\n    } = options ?? {};\n\n    // Read file content\n    let fileData: Blob;\n    if (fileSystem && localUri.startsWith('file://')) {\n      // Native: read file as base64, convert to blob\n      const base64Content = await fileSystem.readFile(localUri, 'base64');\n      const binaryString = atob(base64Content);\n      const bytes = new Uint8Array(binaryString.length);\n      for (let i = 0; i < binaryString.length; i++) {\n        bytes[i] = binaryString.charCodeAt(i);\n      }\n      fileData = new Blob([bytes], {\n        type: contentType\n      });\n    } else if (localUri.startsWith('blob:') || localUri.startsWith('http')) {\n      // Web: fetch blob URL\n      const response = await fetch(localUri);\n      fileData = await response.blob();\n    } else {\n      throw new Error(`Unsupported URI format: ${localUri}`);\n    }\n\n    // Check for cancellation\n    if (signal?.aborted) {\n      throw new Error('Upload cancelled');\n    }\n\n    // Report initial progress\n    onProgress?.({\n      loaded: 0,\n      total: fileData.size\n    });\n\n    // Upload to Supabase\n    const {\n      error\n    } = await client.storage.from(bucket).upload(normalizedPath, fileData, {\n      contentType,\n      upsert: true\n    });\n    if (error) {\n      const errorMessage = getStorageErrorMessage(error);\n      throw new Error(`Upload failed for '${normalizedPath}' in bucket '${bucket}': ${errorMessage}`);\n    }\n\n    // Report completion\n    onProgress?.({\n      loaded: fileData.size,\n      total: fileData.size\n    });\n  }\n\n  /**\n   * Delete a file from remote storage.\n   */\n  async function deleteFile(remotePath: string): Promise<void> {\n    // Normalize the path to remove any leading slashes\n    const normalizedPath = normalizeStoragePath(remotePath);\n    const bucket = getBucket(normalizedPath);\n    const {\n      error\n    } = await client.storage.from(bucket).remove([normalizedPath]);\n    if (error) {\n      const errorMessage = getStorageErrorMessage(error);\n      throw new Error(`Delete failed for '${normalizedPath}' in bucket '${bucket}': ${errorMessage}`);\n    }\n  }\n  return {\n    download,\n    upload,\n    delete: deleteFile,\n    resolveBucket: getBucket\n  };\n}\n\n// ─── Type Guard Utilities ───────────────────────────────────────────────────\n\n/**\n * Type guard to check if download result is a file URI.\n */\nexport function isFileResult(result: DownloadResult): result is {\n  type: 'file';\n  uri: string;\n} {\n  return result.type === 'file';\n}\n\n/**\n * Type guard to check if download result is a blob.\n */\nexport function isBlobResult(result: DownloadResult): result is {\n  type: 'blob';\n  data: Blob;\n} {\n  return result.type === 'blob';\n}","/**\n * Cache Settings Types for @pol-studios/powersync\n *\n * Defines types for cache configuration storage.\n * Note: UI-specific options (labels, descriptions) should be defined in the app.\n */\n\n/**\n * Cache settings stored via AsyncStorageAdapter.\n */\nexport interface CacheSettings {\n  /**\n   * Maximum cache size in megabytes.\n   * A value of 0 indicates unlimited cache size.\n   */\n  maxCacheSizeMb: number;\n\n  /**\n   * Compression quality for cached images (0.0 to 1.0).\n   * Higher values mean better quality but larger file sizes.\n   */\n  compressionQuality: number;\n}\n\n/**\n * Options for creating a CacheSettingsManager.\n */\nexport interface CacheSettingsManagerOptions {\n  /**\n   * Prefix for storage keys.\n   * Useful for namespacing when multiple apps share storage.\n   * @default '@pol-studios/cache'\n   */\n  storageKeyPrefix?: string;\n\n  /**\n   * Default values for cache settings.\n   */\n  defaults?: Partial<CacheSettings>;\n}\n\n/**\n * Default cache settings values.\n */\nexport const DEFAULT_CACHE_SETTINGS: CacheSettings = {\n  maxCacheSizeMb: 5120,\n  // 5 GB\n  compressionQuality: 0.7 // 70% quality\n};","/**\n * Cache Settings Manager for @pol-studios/powersync\n *\n * Manages persistence of cache settings via AsyncStorageAdapter.\n * Uses platform-agnostic storage interface for cross-platform support.\n */\n\nimport type { AsyncStorageAdapter } from '../../platform/types';\nimport type { CacheSettings, CacheSettingsManagerOptions } from './types';\nimport { DEFAULT_CACHE_SETTINGS } from './types';\n\n/**\n * Storage keys used by the cache settings manager.\n */\nconst STORAGE_KEYS = {\n  MAX_CACHE_SIZE_MB: 'max-cache-size-mb',\n  COMPRESSION_QUALITY: 'compression-quality'\n} as const;\n\n/**\n * Manages cache settings persistence using AsyncStorageAdapter.\n *\n * @example\n * ```typescript\n * const manager = new CacheSettingsManager(platform.storage, {\n *   storageKeyPrefix: '@myapp/cache',\n *   defaults: { maxCacheSizeMb: 2048 },\n * });\n *\n * const settings = await manager.getSettings();\n * await manager.setMaxCacheSizeMb(1024);\n * ```\n */\nexport class CacheSettingsManager {\n  private storage: AsyncStorageAdapter;\n  private keyPrefix: string;\n  private defaults: CacheSettings;\n  constructor(storage: AsyncStorageAdapter, options?: CacheSettingsManagerOptions) {\n    this.storage = storage;\n    this.keyPrefix = options?.storageKeyPrefix ?? '@pol-studios/cache';\n    this.defaults = {\n      ...DEFAULT_CACHE_SETTINGS,\n      ...options?.defaults\n    };\n  }\n\n  /**\n   * Get the full storage key for a setting.\n   */\n  private getKey(setting: keyof typeof STORAGE_KEYS): string {\n    return `${this.keyPrefix}/${STORAGE_KEYS[setting]}`;\n  }\n\n  /**\n   * Get all cache settings.\n   */\n  async getSettings(): Promise<CacheSettings> {\n    const keys = [this.getKey('MAX_CACHE_SIZE_MB'), this.getKey('COMPRESSION_QUALITY')];\n    const results = await this.storage.multiGet(keys);\n\n    // Build settings object from stored values or defaults\n    const sizeValue = results.find(([k]) => k === keys[0])?.[1];\n    const qualityValue = results.find(([k]) => k === keys[1])?.[1];\n    return {\n      maxCacheSizeMb: sizeValue ? Number(sizeValue) : this.defaults.maxCacheSizeMb,\n      compressionQuality: qualityValue ? Number(qualityValue) : this.defaults.compressionQuality\n    };\n  }\n\n  /**\n   * Get the maximum cache size in megabytes.\n   * Returns 0 for unlimited.\n   */\n  async getMaxCacheSizeMb(): Promise<number> {\n    const value = await this.storage.getItem(this.getKey('MAX_CACHE_SIZE_MB'));\n    return value ? Number(value) : this.defaults.maxCacheSizeMb;\n  }\n\n  /**\n   * Set the maximum cache size in megabytes.\n   * Use 0 for unlimited.\n   *\n   * @param mb - Maximum cache size in megabytes\n   */\n  async setMaxCacheSizeMb(mb: number): Promise<void> {\n    if (mb < 0) {\n      throw new Error('Cache size must be non-negative');\n    }\n    await this.storage.setItem(this.getKey('MAX_CACHE_SIZE_MB'), String(mb));\n  }\n\n  /**\n   * Get the maximum cache size in bytes.\n   * Returns Number.MAX_SAFE_INTEGER for unlimited.\n   */\n  async getMaxCacheSizeBytes(): Promise<number> {\n    const mb = await this.getMaxCacheSizeMb();\n    return mb === 0 ? Number.MAX_SAFE_INTEGER : mb * 1024 * 1024;\n  }\n\n  /**\n   * Get the compression quality (0.0 to 1.0).\n   */\n  async getCompressionQuality(): Promise<number> {\n    const value = await this.storage.getItem(this.getKey('COMPRESSION_QUALITY'));\n    return value ? Number(value) : this.defaults.compressionQuality;\n  }\n\n  /**\n   * Set the compression quality.\n   *\n   * @param quality - Compression quality (0.0 to 1.0)\n   */\n  async setCompressionQuality(quality: number): Promise<void> {\n    if (quality < 0 || quality > 1) {\n      throw new Error('Compression quality must be between 0 and 1');\n    }\n    await this.storage.setItem(this.getKey('COMPRESSION_QUALITY'), String(quality));\n  }\n\n  /**\n   * Reset all settings to defaults.\n   */\n  async resetToDefaults(): Promise<void> {\n    await this.storage.multiSet([[this.getKey('MAX_CACHE_SIZE_MB'), String(this.defaults.maxCacheSizeMb)], [this.getKey('COMPRESSION_QUALITY'), String(this.defaults.compressionQuality)]]);\n  }\n\n  /**\n   * Clear all stored settings.\n   */\n  async clear(): Promise<void> {\n    await Promise.all([this.storage.removeItem(this.getKey('MAX_CACHE_SIZE_MB')), this.storage.removeItem(this.getKey('COMPRESSION_QUALITY'))]);\n  }\n}"],"mappings":"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","names":["options"]}

package/dist/chunk-YHTZ7VMV.js

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-YHTZ7VMV.js.map

package/dist/{chunk-MKD2VCX3.js → chunk-Z6VOBGTU.js}

@@ -1,19 +1,19 @@
 // src/storage/types.ts
-function resolveBucketFromConfig(config, storagePath) {
-  if (config.resolver) {
-    const resolved = config.resolver(storagePath);
+function resolveBucket(options, storagePath) {
+  if (options.bucketResolver) {
+    const resolved = options.bucketResolver(storagePath);
     if (resolved !== void 0) {
       return resolved;
     }
   }
-  if (config.bucketMap) {
-    for (const [prefix, bucket] of config.bucketMap) {
+  if (options.bucketMap) {
+    for (const [prefix, bucket] of options.bucketMap) {
       if (storagePath.startsWith(prefix)) {
         return bucket;
       }
     }
   }
-  return config.defaultBucket;
+  return options.defaultBucket;
 }
 
 // src/storage/upload/types.ts
@@ -26,7 +26,7 @@ var DEFAULT_UPLOAD_NOTIFICATION = {
 };
 
 export {
-  resolveBucketFromConfig,
+  resolveBucket,
   DEFAULT_UPLOAD_NOTIFICATION
 };
-//# sourceMappingURL=chunk-MKD2VCX3.js.map
+//# sourceMappingURL=chunk-Z6VOBGTU.js.map

package/dist/chunk-Z6VOBGTU.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/storage/types.ts","../src/storage/upload/types.ts"],"sourcesContent":["/**\n * Unified Storage Types for @pol-studios/powersync\n *\n * Single storage interface for all Supabase storage operations.\n * Consolidates the previous 6 fragmented interfaces into one:\n * - AttachmentStorageAdapter (attachments/types.ts)\n * - RemoteStorageAdapter (storage/types.ts - removed)\n * - StorageAdapter (@powersync/attachments)\n * - PowerSyncStorageAdapter (storage/types.ts - removed)\n * - StorageUploadHandler (storage/types.ts - removed)\n * - UploadHandler (attachments/types.ts)\n */\n\n// ─── Unified Storage Interface ──────────────────────────────────────────────\n\n/**\n * Unified storage interface for Supabase storage operations.\n * Handles both upload and download for attachments.\n *\n * This is the ONLY storage interface consumers need to implement.\n * It replaces all previous storage adapter interfaces.\n *\n * @example\n * ```typescript\n * const storage: SupabaseStorage = {\n *   async download(path) {\n *     const { data } = await supabase.storage\n *       .from('attachments')\n *       .createSignedUrl(path, 60);\n *     // Download to temp file and return URI\n *     return tempFileUri;\n *   },\n *\n *   async upload(path, localUri, mediaType) {\n *     const file = await readFile(localUri);\n *     await supabase.storage\n *       .from('attachments')\n *       .upload(path, file, { contentType: mediaType });\n *   },\n * };\n * ```\n */\nexport interface SupabaseStorage {\n  /**\n   * Download a file and return the local file:// URI.\n   *\n   * @param path - Remote storage path\n   * @returns Local file:// URI pointing to the downloaded file\n   */\n  download(path: string): Promise<string>;\n\n  /**\n   * Upload a local file to remote storage.\n   *\n   * @param path - Remote storage path\n   * @param localUri - Local file:// URI to upload from\n   * @param mediaType - MIME type of the file\n   * @param signal - Optional AbortSignal for cancellation\n   */\n  upload(path: string, localUri: string, mediaType: string, signal?: AbortSignal): Promise<void>;\n\n  /**\n   * Delete a file from remote storage.\n   * Optional - not all implementations need deletion.\n   *\n   * @param path - Remote storage path to delete\n   */\n  delete?(path: string): Promise<void>;\n\n  /**\n   * Resolve which bucket a path belongs to.\n   * Optional - useful for multi-bucket configurations.\n   *\n   * @param path - Remote storage path\n   * @returns The bucket name\n   */\n  resolveBucket?(path: string): string;\n}\n\n// ─── Storage Backend (Factory API) ──────────────────────────────────────────\n\n/**\n * Download result discriminated union.\n * Native platforms return file URIs, web returns blobs.\n */\nexport type DownloadResult = {\n  type: 'file';\n  uri: string;\n} | {\n  type: 'blob';\n  data: Blob;\n};\n\n/**\n * Storage backend returned by createSupabaseStorage factory.\n * This is a more flexible interface that returns discriminated unions\n * to handle both native (file URI) and web (blob) download results.\n *\n * For simpler use cases, use SupabaseStorage interface directly.\n */\nexport interface StorageBackend {\n  /** Download a file, returns discriminated union based on platform */\n  download(path: string): Promise<DownloadResult>;\n\n  /** Upload a local file to remote storage */\n  upload(path: string, localUri: string, contentType: string, options?: StorageUploadOptions): Promise<void>;\n\n  /** Delete a file from remote storage */\n  delete(path: string): Promise<void>;\n\n  /** Resolve which bucket a path belongs to */\n  resolveBucket(path: string): string;\n}\n\n// ─── Upload Progress ────────────────────────────────────────────────────────\n\n/**\n * Progress information for upload operations.\n */\nexport interface UploadProgress {\n  /** Bytes uploaded so far */\n  loaded: number;\n  /** Total bytes to upload */\n  total: number;\n}\n\n// ─── Upload Options ─────────────────────────────────────────────────────────\n\n/**\n * Options for upload operations.\n */\nexport interface StorageUploadOptions {\n  /** AbortSignal for cancellation support */\n  signal?: AbortSignal;\n  /** Progress callback */\n  onProgress?: (progress: UploadProgress) => void;\n}\n\n// ─── Supabase Storage Options ───────────────────────────────────────────────\n\nimport type { LoggerAdapter, FileSystemAdapter } from '../platform/types';\n\n/**\n * Options for creating a Supabase storage backend.\n */\nexport interface SupabaseStorageOptions {\n  /** Supabase client instance */\n  client: SupabaseClient;\n\n  /** Default storage bucket */\n  defaultBucket: string;\n\n  /**\n   * Map of path prefixes to bucket names.\n   * Checked in iteration order (use Map to preserve order).\n   *\n   * @example\n   * ```typescript\n   * bucketMap: new Map([\n   *   ['avatars/', 'user-avatars'],\n   *   ['docs/', 'documents'],\n   * ])\n   * ```\n   */\n  bucketMap?: Map<string, string>;\n\n  /**\n   * Custom bucket resolver function.\n   * Takes precedence over bucketMap.\n   * Return undefined to fall through to bucketMap/defaultBucket.\n   */\n  bucketResolver?: (storagePath: string) => string | undefined;\n\n  /**\n   * Signed URL expiry in seconds.\n   * @default 60 (short-lived for security)\n   */\n  signedUrlExpiry?: number;\n\n  /**\n   * File system adapter for native file operations.\n   * Required for native platforms to enable file-based downloads.\n   */\n  fileSystem?: FileSystemAdapter;\n\n  /**\n   * Optional logger for diagnostic messages.\n   */\n  logger?: LoggerAdapter;\n}\n\n// ─── Supabase Client Type ───────────────────────────────────────────────────\n\n/**\n * Transform options for Supabase image transformation.\n * See: https://supabase.com/docs/guides/storage/serving/image-transformations\n */\nexport interface SupabaseTransformOptions {\n  width?: number;\n  height?: number;\n  resize?: 'cover' | 'contain' | 'fill';\n  format?: 'origin' | 'avif' | 'webp';\n  quality?: number; // 1-100\n}\n\n/**\n * Minimal Supabase client interface for storage operations.\n * Using a minimal interface to avoid version conflicts with @supabase/supabase-js.\n */\nexport interface SupabaseClient {\n  storage: {\n    from(bucket: string): {\n      createSignedUrl(path: string, expiresIn: number, options?: {\n        download?: string | boolean;\n        transform?: SupabaseTransformOptions;\n      }): Promise<{\n        data: {\n          signedUrl: string;\n        } | null;\n        error: Error | null;\n      }>;\n      upload(path: string, file: Blob | ArrayBuffer | FormData, options?: {\n        contentType?: string;\n        upsert?: boolean;\n      }): Promise<{\n        data: {\n          path: string;\n        } | null;\n        error: Error | null;\n      }>;\n      remove(paths: string[]): Promise<{\n        data: {\n          name: string;\n        }[] | null;\n        error: Error | null;\n      }>;\n      list(path?: string, options?: {\n        search?: string;\n        limit?: number;\n      }): Promise<{\n        data: {\n          name: string;\n        }[] | null;\n        error: Error | null;\n      }>;\n    };\n  };\n  auth: {\n    refreshSession(): Promise<{\n      data: unknown;\n      error: Error | null;\n    }>;\n  };\n}\n\n// ─── Bucket Resolution Helpers ──────────────────────────────────────────────\n\n/**\n * Resolve bucket from storage path using SupabaseStorageOptions.\n *\n * Resolution order:\n * 1. Custom bucketResolver (if provided and returns a value)\n * 2. bucketMap prefix matching (if provided)\n * 3. defaultBucket\n */\nexport function resolveBucket(options: Pick<SupabaseStorageOptions, 'defaultBucket' | 'bucketMap' | 'bucketResolver'>, storagePath: string): string {\n  // Try custom resolver first\n  if (options.bucketResolver) {\n    const resolved = options.bucketResolver(storagePath);\n    if (resolved !== undefined) {\n      return resolved;\n    }\n  }\n\n  // Try bucket map prefix matching\n  if (options.bucketMap) {\n    for (const [prefix, bucket] of options.bucketMap) {\n      if (storagePath.startsWith(prefix)) {\n        return bucket;\n      }\n    }\n  }\n\n  // Fall back to default\n  return options.defaultBucket;\n}","/**\n * Upload Handler Types for @pol-studios/powersync\n *\n * Defines types for platform-specific upload handlers.\n */\n\n/**\n * Bucket configuration for multi-bucket routing.\n */\nexport interface BucketConfig {\n  /** Default bucket for storage operations */\n  defaultBucket: string;\n\n  /** Map of path prefixes to bucket names */\n  bucketMap?: Map<string, string>;\n\n  /** Custom bucket resolver function */\n  resolver?: (storagePath: string) => string | undefined;\n}\n\n/**\n * Options for creating a SupabaseUploadHandler.\n */\nexport interface SupabaseUploadHandlerOptions {\n  /** Supabase client instance */\n  supabaseClient: any; // SupabaseClient - using any to avoid version conflicts\n\n  /** Bucket configuration for multi-bucket routing */\n  bucketConfig: BucketConfig;\n}\n\n/**\n * Event handlers for upload progress tracking.\n */\nexport interface UploadEventHandlers {\n  /** Called with progress updates during upload */\n  onProgress?: (progress: {\n    loaded: number;\n    total: number;\n  }) => void;\n\n  /** Called when upload completes successfully */\n  onComplete?: () => void;\n\n  /** Called when upload fails */\n  onError?: (error: Error) => void;\n}\n\n/**\n * Configuration for native upload notifications (Android).\n */\nexport interface UploadNotificationConfig {\n  /** Whether to show upload notifications */\n  enabled: boolean;\n\n  /** Whether to auto-clear notification on completion */\n  autoClear: boolean;\n\n  /** Title shown during upload progress */\n  onProgressTitle: string;\n\n  /** Title shown when upload completes */\n  onCompleteTitle: string;\n\n  /** Title shown when upload fails */\n  onErrorTitle: string;\n}\n\n/**\n * Default notification configuration for Android uploads.\n */\nexport const DEFAULT_UPLOAD_NOTIFICATION: UploadNotificationConfig = {\n  enabled: true,\n  autoClear: true,\n  onProgressTitle: 'Uploading...',\n  onCompleteTitle: 'Upload complete',\n  onErrorTitle: 'Upload failed'\n};"],"mappings":";AAyQO,SAAS,cAAc,SAAyF,aAA6B;AAElJ,MAAI,QAAQ,gBAAgB;AAC1B,UAAM,WAAW,QAAQ,eAAe,WAAW;AACnD,QAAI,aAAa,QAAW;AAC1B,aAAO;AAAA,IACT;AAAA,EACF;AAGA,MAAI,QAAQ,WAAW;AACrB,eAAW,CAAC,QAAQ,MAAM,KAAK,QAAQ,WAAW;AAChD,UAAI,YAAY,WAAW,MAAM,GAAG;AAClC,eAAO;AAAA,MACT;AAAA,IACF;AAAA,EACF;AAGA,SAAO,QAAQ;AACjB;;;ACtNO,IAAM,8BAAwD;AAAA,EACnE,SAAS;AAAA,EACT,WAAW;AAAA,EACX,iBAAiB;AAAA,EACjB,iBAAiB;AAAA,EACjB,cAAc;AAChB;","names":[]}

package/dist/chunk-ZM4ENYMF.js

@@ -0,0 +1,230 @@
+// src/attachments/query-builder.ts
+var VALID_IDENTIFIER_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+var SQL_RESERVED_WORDS = /* @__PURE__ */ new Set(["SELECT", "FROM", "WHERE", "ORDER", "BY", "AND", "OR", "NOT", "NULL", "INSERT", "UPDATE", "DELETE", "DROP", "CREATE", "TABLE", "INDEX", "JOIN", "LEFT", "RIGHT", "INNER", "OUTER", "ON", "AS", "DISTINCT", "GROUP", "HAVING", "LIMIT", "OFFSET", "UNION", "EXCEPT", "INTERSECT", "IN", "BETWEEN", "LIKE", "IS", "TRUE", "FALSE", "CASE", "WHEN", "THEN", "ELSE", "END", "ASC", "DESC", "NULLS", "FIRST", "LAST"]);
+function validateSqlIdentifier(identifier, context) {
+  if (!identifier || typeof identifier !== "string") {
+    throw new Error(`Invalid ${context}: must be a non-empty string`);
+  }
+  if (!VALID_IDENTIFIER_PATTERN.test(identifier)) {
+    throw new Error(`Invalid ${context}: "${identifier}" contains invalid characters. Identifiers must start with a letter or underscore and contain only alphanumeric characters and underscores.`);
+  }
+  if (SQL_RESERVED_WORDS.has(identifier.toUpperCase())) {
+    throw new Error(`Invalid ${context}: "${identifier}" is a SQL reserved word. Use a different name or quote the identifier.`);
+  }
+  const dangerousPatterns = [
+    /--/,
+    // SQL comment
+    /;/,
+    // Statement terminator
+    /'/,
+    // String delimiter
+    /"/,
+    // Quote
+    /\\/
+    // Escape character
+  ];
+  for (const pattern of dangerousPatterns) {
+    if (pattern.test(identifier)) {
+      throw new Error(`Invalid ${context}: "${identifier}" contains potentially dangerous characters.`);
+    }
+  }
+}
+function validateWhereClause(whereClause) {
+  if (!whereClause || typeof whereClause !== "string") {
+    throw new Error("Invalid WHERE clause: must be a non-empty string");
+  }
+  const dangerousPatterns = [{
+    pattern: /;\s*(SELECT|INSERT|UPDATE|DELETE|DROP|CREATE)/i,
+    name: "SQL injection (statement)"
+  }, {
+    pattern: /UNION\s+(ALL\s+)?SELECT/i,
+    name: "UNION injection"
+  }, {
+    pattern: /--/,
+    name: "SQL comment"
+  }, {
+    pattern: /\/\*/,
+    name: "block comment"
+  }, {
+    pattern: /xp_|sp_|exec\s*\(/i,
+    name: "stored procedure"
+  }];
+  for (const {
+    pattern,
+    name
+  } of dangerousPatterns) {
+    if (pattern.test(whereClause)) {
+      throw new Error(`Invalid WHERE clause: contains ${name}`);
+    }
+  }
+}
+function buildWatchQuery(config) {
+  validateSqlIdentifier(config.table, "table");
+  validateSqlIdentifier(config.idColumn, "idColumn");
+  if (config.selectColumns) {
+    for (const col of config.selectColumns) {
+      validateSqlIdentifier(col, "selectColumns");
+    }
+  }
+  if (config.orderBy) {
+    validateSqlIdentifier(config.orderBy.column, "orderBy.column");
+    if (config.orderBy.direction !== "ASC" && config.orderBy.direction !== "DESC") {
+      throw new Error(`Invalid orderBy.direction: must be "ASC" or "DESC"`);
+    }
+  }
+  if (config.where) {
+    validateWhereClause(config.where);
+  }
+  const selectParts = [`${config.idColumn} AS id`];
+  if (config.selectColumns && config.selectColumns.length > 0) {
+    selectParts.push(...config.selectColumns);
+  }
+  const selectClause = selectParts.join(", ");
+  const fromClause = config.table;
+  let whereClause = `${config.idColumn} IS NOT NULL AND ${config.idColumn} != ''`;
+  if (config.where) {
+    whereClause = `${whereClause} AND (${config.where})`;
+  }
+  let orderByClause = "";
+  if (config.orderBy) {
+    orderByClause = `ORDER BY ${config.orderBy.column} ${config.orderBy.direction}`;
+  }
+  const parts = [`SELECT ${selectClause}`, `FROM ${fromClause}`, `WHERE ${whereClause}`];
+  if (orderByClause) {
+    parts.push(orderByClause);
+  }
+  return parts.join("\n");
+}
+function buildIdOnlyWatchQuery(config) {
+  return buildWatchQuery({
+    ...config,
+    selectColumns: void 0
+  });
+}
+function buildRecordFetchQuery(config, ids) {
+  validateSqlIdentifier(config.table, "table");
+  validateSqlIdentifier(config.idColumn, "idColumn");
+  if (config.selectColumns) {
+    for (const col of config.selectColumns) {
+      validateSqlIdentifier(col, "selectColumns");
+    }
+  }
+  const selectParts = [`${config.idColumn} AS id`];
+  if (config.selectColumns && config.selectColumns.length > 0) {
+    selectParts.push(...config.selectColumns);
+  }
+  const selectClause = selectParts.join(", ");
+  let query = `SELECT ${selectClause} FROM ${config.table}`;
+  const params = [];
+  if (ids && ids.length > 0) {
+    const placeholders = ids.map(() => "?").join(", ");
+    query += ` WHERE ${config.idColumn} IN (${placeholders})`;
+    params.push(...ids);
+  }
+  return {
+    query,
+    params
+  };
+}
+function watchConfigToSourceConfig(watchConfig) {
+  return {
+    table: watchConfig.table,
+    idColumn: watchConfig.idColumn,
+    orderByColumn: watchConfig.orderBy?.column ?? null
+  };
+}
+
+// src/attachments/migration.ts
+import { AttachmentState } from "@powersync/attachments";
+var STATE_MAPPING = /* @__PURE__ */ new Map([
+  // Official states (1:1 mapping)
+  [AttachmentState.QUEUED_SYNC, 0 /* QUEUED_SYNC */],
+  [AttachmentState.QUEUED_UPLOAD, 1 /* QUEUED_UPLOAD */],
+  [AttachmentState.QUEUED_DOWNLOAD, 2 /* QUEUED_DOWNLOAD */],
+  [AttachmentState.SYNCED, 3 /* SYNCED */],
+  [AttachmentState.ARCHIVED, 4 /* ARCHIVED */],
+  // POL extension states (identity mapping)
+  [5 /* FAILED_PERMANENT */, 5 /* FAILED_PERMANENT */],
+  [6 /* DOWNLOAD_SKIPPED */, 6 /* DOWNLOAD_SKIPPED */]
+]);
+var STATE_NAMES = /* @__PURE__ */ new Map([[0 /* QUEUED_SYNC */, "QUEUED_SYNC"], [1 /* QUEUED_UPLOAD */, "QUEUED_UPLOAD"], [2 /* QUEUED_DOWNLOAD */, "QUEUED_DOWNLOAD"], [3 /* SYNCED */, "SYNCED"], [4 /* ARCHIVED */, "ARCHIVED"], [5 /* FAILED_PERMANENT */, "FAILED_PERMANENT"], [6 /* DOWNLOAD_SKIPPED */, "DOWNLOAD_SKIPPED"]]);
+var VALID_STATES = /* @__PURE__ */ new Set([0 /* QUEUED_SYNC */, 1 /* QUEUED_UPLOAD */, 2 /* QUEUED_DOWNLOAD */, 3 /* SYNCED */, 4 /* ARCHIVED */, 5 /* FAILED_PERMANENT */, 6 /* DOWNLOAD_SKIPPED */]);
+var UPLOAD_WORKFLOW_STATES = /* @__PURE__ */ new Set([1 /* QUEUED_UPLOAD */, 5 /* FAILED_PERMANENT */]);
+var DOWNLOAD_WORKFLOW_STATES = /* @__PURE__ */ new Set([2 /* QUEUED_DOWNLOAD */, 0 /* QUEUED_SYNC */]);
+var TERMINAL_STATES = /* @__PURE__ */ new Set([3 /* SYNCED */, 4 /* ARCHIVED */, 6 /* DOWNLOAD_SKIPPED */]);
+function migrateAttachmentState(oldState) {
+  const newState = STATE_MAPPING.get(oldState);
+  if (newState === void 0) {
+    throw new Error(`Invalid attachment state: ${oldState}. Valid states are: ${Array.from(STATE_NAMES.entries()).map(([v, n]) => `${n}(${v})`).join(", ")}`);
+  }
+  return newState;
+}
+function migrateAttachmentStateSafe(oldState, fallback = 0 /* QUEUED_SYNC */) {
+  const newState = STATE_MAPPING.get(oldState);
+  return newState !== void 0 ? newState : fallback;
+}
+function isValidAttachmentState(value) {
+  return typeof value === "number" && VALID_STATES.has(value);
+}
+function isUploadWorkflowState(state) {
+  return UPLOAD_WORKFLOW_STATES.has(state);
+}
+function isDownloadWorkflowState(state) {
+  return DOWNLOAD_WORKFLOW_STATES.has(state);
+}
+function isTerminalState(state) {
+  return TERMINAL_STATES.has(state);
+}
+function getStateName(state) {
+  return STATE_NAMES.get(state) ?? "UNKNOWN";
+}
+function createMigrationStats() {
+  return {
+    total: 0,
+    migrated: 0,
+    invalid: 0,
+    byState: /* @__PURE__ */ new Map()
+  };
+}
+function recordMigration(stats, oldState, newState, wasValid) {
+  stats.total++;
+  if (wasValid) {
+    stats.migrated++;
+  } else {
+    stats.invalid++;
+  }
+  stats.byState.set(newState, (stats.byState.get(newState) ?? 0) + 1);
+}
+function formatMigrationStats(stats) {
+  const lines = ["Migration Summary:", `  Total: ${stats.total}`, `  Migrated: ${stats.migrated}`, `  Invalid (used fallback): ${stats.invalid}`, "  By State:"];
+  for (const [state, count] of stats.byState.entries()) {
+    lines.push(`    ${getStateName(state)}: ${count}`);
+  }
+  return lines.join("\n");
+}
+
+export {
+  validateSqlIdentifier,
+  validateWhereClause,
+  buildWatchQuery,
+  buildIdOnlyWatchQuery,
+  buildRecordFetchQuery,
+  watchConfigToSourceConfig,
+  STATE_MAPPING,
+  STATE_NAMES,
+  VALID_STATES,
+  UPLOAD_WORKFLOW_STATES,
+  DOWNLOAD_WORKFLOW_STATES,
+  TERMINAL_STATES,
+  migrateAttachmentState,
+  migrateAttachmentStateSafe,
+  isValidAttachmentState,
+  isUploadWorkflowState,
+  isDownloadWorkflowState,
+  isTerminalState,
+  getStateName,
+  createMigrationStats,
+  recordMigration,
+  formatMigrationStats
+};
+//# sourceMappingURL=chunk-ZM4ENYMF.js.map