@pol-studios/powersync 1.0.7 → 1.0.10

package/dist/chunk-ZEOKPWUC.js

@@ -1,1165 +0,0 @@
-import {
-  addJitter,
-  calculateBackoffDelay
-} from "./chunk-FV2HXEIY.js";
-
-// src/attachments/pol-storage-adapter.ts
-import { EncodingType } from "@powersync/attachments";
-var PolStorageAdapter = class {
-  platform;
-  remoteStorage;
-  attachmentDirectoryName;
-  userStorageDirectory;
-  constructor(options) {
-    this.platform = options.platform;
-    this.remoteStorage = options.remoteStorage;
-    this.attachmentDirectoryName = options.attachmentDirectoryName ?? "attachments";
-    const cacheDir = this.platform.fileSystem.getCacheDirectory();
-    this.userStorageDirectory = cacheDir.endsWith("/") ? `${cacheDir}${this.attachmentDirectoryName}/` : `${cacheDir}/${this.attachmentDirectoryName}/`;
-  }
-  // ─── Remote Operations ──────────────────────────────────────────────────────
-  /**
-   * Upload a file to remote storage.
-   */
-  async uploadFile(filePath, data, options) {
-    if (!this.remoteStorage.uploadFile) {
-      throw new Error("Remote storage adapter does not support uploads");
-    }
-    const base64 = this._arrayBufferToBase64(data);
-    await this.remoteStorage.uploadFile(filePath, base64);
-  }
-  /**
-   * Download a file from remote storage.
-   */
-  async downloadFile(filePath) {
-    const result = await this.remoteStorage.downloadFile(filePath);
-    if (typeof result === "string") {
-      const binaryString = atob(result);
-      const bytes = new Uint8Array(binaryString.length);
-      for (let i = 0; i < binaryString.length; i++) {
-        bytes[i] = binaryString.charCodeAt(i);
-      }
-      return new Blob([bytes]);
-    }
-    return result;
-  }
-  // ─── Local File Operations ──────────────────────────────────────────────────
-  /**
-   * Write data to a local file.
-   */
-  async writeFile(fileUri, base64Data, options) {
-    const encoding = options?.encoding === EncodingType.UTF8 ? "utf8" : "base64";
-    await this.platform.fileSystem.writeFile(fileUri, base64Data, encoding);
-  }
-  /**
-   * Read a local file's contents.
-   */
-  async readFile(fileUri, options) {
-    const encoding = options?.encoding === EncodingType.UTF8 ? "utf8" : "base64";
-    const content = await this.platform.fileSystem.readFile(fileUri, encoding);
-    if (encoding === "base64") {
-      return this._base64ToArrayBuffer(content);
-    } else {
-      const encoder = new TextEncoder();
-      return encoder.encode(content).buffer;
-    }
-  }
-  /**
-   * Delete a local file.
-   */
-  async deleteFile(uri, _options) {
-    try {
-      await this.platform.fileSystem.deleteFile(uri);
-    } catch (error) {
-      const info = await this.platform.fileSystem.getFileInfo(uri);
-      if (info?.exists) {
-        throw error;
-      }
-    }
-  }
-  /**
-   * Check if a local file exists.
-   */
-  async fileExists(fileUri) {
-    const info = await this.platform.fileSystem.getFileInfo(fileUri);
-    return info?.exists ?? false;
-  }
-  /**
-   * Create a directory (with intermediate directories).
-   */
-  async makeDir(uri) {
-    await this.platform.fileSystem.makeDirectory(uri, {
-      intermediates: true
-    });
-  }
-  /**
-   * Copy a file from source to destination.
-   */
-  async copyFile(sourceUri, targetUri) {
-    await this.platform.fileSystem.copyFile(sourceUri, targetUri);
-  }
-  /**
-   * Get the user's storage directory for attachments.
-   * Returns the cache directory path ending with '/'.
-   */
-  getUserStorageDirectory() {
-    return this.userStorageDirectory;
-  }
-  // ─── Helpers ────────────────────────────────────────────────────────────────
-  /**
-   * Warning 8: Optimized base64 encoding using batch processing.
-   * Processes in chunks of 1024 bytes for better performance with large files.
-   */
-  _arrayBufferToBase64(buffer) {
-    const bytes = new Uint8Array(buffer);
-    const chunkSize = 1024;
-    const chunks = [];
-    for (let i = 0; i < bytes.length; i += chunkSize) {
-      const chunk = bytes.subarray(i, Math.min(i + chunkSize, bytes.length));
-      chunks.push(String.fromCharCode.apply(null, Array.from(chunk)));
-    }
-    return btoa(chunks.join(""));
-  }
-  _base64ToArrayBuffer(base64) {
-    const binaryString = atob(base64);
-    const bytes = new Uint8Array(binaryString.length);
-    for (let i = 0; i < binaryString.length; i++) {
-      bytes[i] = binaryString.charCodeAt(i);
-    }
-    return bytes.buffer;
-  }
-};
-
-// src/attachments/types.ts
-import { AttachmentState, ATTACHMENT_TABLE, AttachmentTable } from "@powersync/attachments";
-import { EncodingType as EncodingType2 } from "@powersync/attachments";
-import { DEFAULT_ATTACHMENT_QUEUE_OPTIONS, AbstractAttachmentQueue } from "@powersync/attachments";
-var PolAttachmentState = /* @__PURE__ */ ((PolAttachmentState2) => {
-  PolAttachmentState2[PolAttachmentState2["QUEUED_SYNC"] = 0] = "QUEUED_SYNC";
-  PolAttachmentState2[PolAttachmentState2["QUEUED_UPLOAD"] = 1] = "QUEUED_UPLOAD";
-  PolAttachmentState2[PolAttachmentState2["QUEUED_DOWNLOAD"] = 2] = "QUEUED_DOWNLOAD";
-  PolAttachmentState2[PolAttachmentState2["SYNCED"] = 3] = "SYNCED";
-  PolAttachmentState2[PolAttachmentState2["ARCHIVED"] = 4] = "ARCHIVED";
-  PolAttachmentState2[PolAttachmentState2["FAILED_PERMANENT"] = 5] = "FAILED_PERMANENT";
-  return PolAttachmentState2;
-})(PolAttachmentState || {});
-var DEFAULT_COMPRESSION_CONFIG = {
-  enabled: true,
-  quality: 0.7,
-  maxWidth: 2048,
-  skipSizeBytes: 1e5,
-  targetSizeBytes: 3e5
-};
-var DEFAULT_UPLOAD_CONFIG = {
-  concurrency: 3,
-  timeoutMs: 12e4,
-  baseRetryDelayMs: 3e4,
-  // 30 seconds base delay for battery efficiency
-  maxRetryDelayMs: 36e5,
-  // 1 hour max
-  staleDaysThreshold: 7,
-  maxRetryCount: 100
-};
-var DEFAULT_CACHE_CONFIG = {
-  maxSize: 5 * 1024 * 1024 * 1024,
-  // 5 GB
-  downloadStopThreshold: 0.95,
-  evictionTriggerThreshold: 1
-};
-
-// src/attachments/pol-attachment-queue.ts
-import { AbstractAttachmentQueue as AbstractAttachmentQueue2, AttachmentState as AttachmentState2 } from "@powersync/attachments";
-var WATCH_INTERVAL_MS = 3e4;
-var NOTIFY_THROTTLE_MS = 500;
-var STATS_CACHE_TTL_MS = 500;
-var UPLOAD_PROCESSING_DELAY_MS = 1e3;
-var MIN_POLL_INTERVAL_MS = 5e3;
-var PolAttachmentQueue = class extends AbstractAttachmentQueue2 {
-  // ─── Parent Override ──────────────────────────────────────────────────────
-  /**
-   * Override parent's watchUploads to prevent dual upload engines.
-   * POL uses custom _startUploadProcessing() for uploads with:
-   * - Exponential backoff retry
-   * - Compression support
-   * - Custom metadata handling
-   *
-   * The parent's simple upload watcher would conflict and fail
-   * because POL records use upload_source_uri instead of local_uri.
-   */
-  watchUploads() {
-    this.polLogger?.debug?.("[PolAttachmentQueue] Parent watchUploads disabled - using custom upload engine");
-  }
-  /**
-   * Override parent's uploadAttachment to prevent misuse.
-   * POL uploads use upload_source_uri, not local_uri.
-   * External code should use queueUpload() instead.
-   */
-  async uploadAttachment(record) {
-    throw new Error(`uploadAttachment() is disabled in PolAttachmentQueue. Use queueUpload() for uploads. Record ID: ${record.id}`);
-  }
-  // ─── Additional State ──────────────────────────────────────────────────────
-  platform;
-  polLogger;
-  source;
-  uploadHandler;
-  uploadConfig;
-  compressionConfig;
-  cacheConfig;
-  // Upload engine state
-  _uploadProcessing = false;
-  _uploadPaused = false;
-  _uploadAbort = new AbortController();
-  _activeUploads = /* @__PURE__ */ new Map();
-  // Watch state
-  _watchInterval = null;
-  _disposed = false;
-  _initialized = false;
-  // Notification state
-  _progressCallbacks = /* @__PURE__ */ new Set();
-  _lastNotifyTime = 0;
-  _notifyTimer = null;
-  // Stats cache
-  _cachedStats = null;
-  _cachedStatsTimestamp = 0;
-  constructor(options) {
-    const storage = new PolStorageAdapter({
-      platform: options.platform,
-      remoteStorage: options.remoteStorage,
-      attachmentDirectoryName: options.attachmentDirectoryName
-    });
-    super({
-      ...options,
-      storage
-    });
-    this._validateSqlIdentifier(options.source.table, "source.table");
-    this._validateSqlIdentifier(options.source.idColumn, "source.idColumn");
-    if (options.source.orderByColumn) {
-      this._validateSqlIdentifier(options.source.orderByColumn, "source.orderByColumn");
-    }
-    if (options.source.projectFilter) {
-      this._validateSqlIdentifier(options.source.projectFilter.foreignKey, "projectFilter.foreignKey");
-      this._validateSqlIdentifier(options.source.projectFilter.intermediaryTable, "projectFilter.intermediaryTable");
-      this._validateSqlIdentifier(options.source.projectFilter.projectForeignKey, "projectFilter.projectForeignKey");
-    }
-    this.platform = options.platform;
-    this.polLogger = options.platform.logger;
-    this.source = options.source;
-    this.uploadHandler = options.uploadHandler;
-    this.uploadConfig = {
-      ...DEFAULT_UPLOAD_CONFIG,
-      ...options.uploadConfig
-    };
-    this.compressionConfig = {
-      ...DEFAULT_COMPRESSION_CONFIG,
-      ...options.compression
-    };
-    this.cacheConfig = {
-      ...DEFAULT_CACHE_CONFIG,
-      ...options.cache
-    };
-  }
-  /**
-   * Validate that a string is a safe SQL identifier (Warning 5).
-   * Prevents SQL injection via config values.
-   */
-  _validateSqlIdentifier(value, name) {
-    if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(value)) {
-      throw new Error(`[PolAttachmentQueue] Invalid SQL identifier for ${name}: "${value}". Must match /^[a-zA-Z_][a-zA-Z0-9_]*$/`);
-    }
-  }
-  // ─── Abstract Method Implementations ───────────────────────────────────────
-  /**
-   * Watch the source table for attachment IDs and notify when they change.
-   *
-   * This implementation uses our configurable source table pattern rather
-   * than a hardcoded query, supporting project filtering for multi-tenant apps.
-   */
-  onAttachmentIdsChange(onUpdate) {
-    const {
-      table,
-      idColumn,
-      projectFilter
-    } = this.source;
-    let query;
-    if (projectFilter) {
-      const {
-        foreignKey,
-        intermediaryTable,
-        projectForeignKey
-      } = projectFilter;
-      query = `
-        SELECT m.${idColumn} as id
-        FROM ${table} m
-        JOIN ${intermediaryTable} u ON m.${foreignKey} = u.id
-        JOIN ProjectDatabase p ON u.${projectForeignKey} = p.id
-        WHERE m.${idColumn} IS NOT NULL AND m.${idColumn} != ''
-      `;
-    } else {
-      query = `
-        SELECT ${idColumn} as id
-        FROM ${table}
-        WHERE ${idColumn} IS NOT NULL AND ${idColumn} != ''
-      `;
-    }
-    try {
-      this.powersync.watch(query, [], {
-        onResult: (result) => {
-          const ids = result.rows?._array?.map((r) => r.id) ?? [];
-          onUpdate(ids);
-        },
-        onError: (error) => {
-          const errorMessage = String(error);
-          if (errorMessage.includes("no such table") || errorMessage.includes("SQLITE_EMPTY")) {
-            this.polLogger.debug("[PolAttachmentQueue] Source table not ready yet");
-            return;
-          }
-          this.polLogger.warn("[PolAttachmentQueue] Watch error:", error);
-        }
-      });
-    } catch (error) {
-      this.polLogger.warn("[PolAttachmentQueue] Watch failed, falling back to polling:", error);
-      this._startPolling(query, onUpdate);
-    }
-  }
-  /**
-   * Create a new attachment record with POL-specific defaults.
-   */
-  async newAttachmentRecord(record) {
-    if (!record?.id) {
-      throw new Error("[PolAttachmentQueue] newAttachmentRecord requires a non-empty record.id");
-    }
-    const id = record.id;
-    const filename = record?.filename ?? id;
-    return {
-      id,
-      filename,
-      state: record?.state ?? AttachmentState2.QUEUED_SYNC,
-      local_uri: record?.local_uri,
-      size: record?.size,
-      media_type: record?.media_type,
-      timestamp: record?.timestamp ?? Date.now()
-    };
-  }
-  // ─── Lifecycle ─────────────────────────────────────────────────────────────
-  /**
-   * Initialize the attachment queue.
-   *
-   * Extends parent init() to also:
-   * - Create the attachment table (since we don't use AttachmentTable in Schema)
-   * - Add upload-specific columns to the table
-   * - Start upload processing if handler is configured
-   */
-  async init() {
-    await this._createTableIfNotExists();
-    await super.init();
-    this._initialized = true;
-    await this._migrateUploadColumns();
-    if (this.uploadHandler && !this._uploadPaused) {
-      this._startUploadProcessing();
-    }
-    this.polLogger.info("[PolAttachmentQueue] Initialized");
-  }
-  /**
-   * Create the attachment table if it doesn't exist.
-   * This creates a REAL SQLite table (not a view) that supports all SQL operations.
-   */
-  async _createTableIfNotExists() {
-    const result = await this.powersync.getOptional(`SELECT name FROM sqlite_master WHERE type='table' AND name=?`, [this.table]);
-    if (result) {
-      this.polLogger.debug(`[PolAttachmentQueue] Table ${this.table} already exists`);
-      return;
-    }
-    this.polLogger.info(`[PolAttachmentQueue] Creating table ${this.table}`);
-    await this.powersync.execute(`
-      CREATE TABLE IF NOT EXISTS ${this.table} (
-        id TEXT PRIMARY KEY NOT NULL,
-        filename TEXT,
-        local_uri TEXT,
-        timestamp INTEGER,
-        media_type TEXT,
-        size INTEGER,
-        state INTEGER DEFAULT 0,
-        upload_source_uri TEXT,
-        upload_error TEXT,
-        upload_error_code TEXT,
-        upload_retry_count INTEGER DEFAULT 0,
-        upload_next_retry_at INTEGER,
-        upload_metadata TEXT,
-        upload_bucket_id TEXT
-      )
-    `);
-    this.polLogger.info(`[PolAttachmentQueue] Table ${this.table} created`);
-  }
-  /**
-   * Dispose the attachment queue, cleaning up all resources.
-   */
-  dispose() {
-    this._disposed = true;
-    this._uploadAbort.abort();
-    if (this._watchInterval) {
-      clearInterval(this._watchInterval);
-      this._watchInterval = null;
-    }
-    if (this._notifyTimer) {
-      clearTimeout(this._notifyTimer);
-      this._notifyTimer = null;
-    }
-    this._progressCallbacks.clear();
-    this._activeUploads.clear();
-    const parentProto = Object.getPrototypeOf(Object.getPrototypeOf(this));
-    if (parentProto && typeof parentProto.dispose === "function") {
-      parentProto.dispose.call(this);
-    }
-  }
-  // ─── Upload API ────────────────────────────────────────────────────────────
-  /**
-   * Queue a file for upload.
-   *
-   * The file is immediately copied to managed cache for durability.
-   * Upload will retry indefinitely for transient errors until marked
-   * as FAILED_PERMANENT for unrecoverable errors.
-   */
-  async queueUpload(options) {
-    if (!this.uploadHandler) {
-      throw new Error("[PolAttachmentQueue] Upload not configured. Provide uploadHandler in options.");
-    }
-    if (!this._initialized) {
-      throw new Error("[PolAttachmentQueue] Queue not initialized. Call init() first or wait for attachmentQueueReady.");
-    }
-    const managedUri = await this._copyToManagedCache(options.sourceUri, options.storagePath);
-    const fileInfo = await this.platform.fileSystem.getFileInfo(managedUri);
-    const size = fileInfo?.exists ? fileInfo.size : 0;
-    const insertParams = [
-      options.storagePath,
-      // id = storage path
-      options.filename,
-      options.mediaType,
-      AttachmentState2.QUEUED_UPLOAD,
-      null,
-      // local_uri is for downloads (preserved on conflict)
-      size,
-      Date.now(),
-      managedUri,
-      // upload_source_uri
-      0,
-      // upload_retry_count
-      Date.now(),
-      // upload_next_retry_at (ready now)
-      options.metadata ? JSON.stringify(options.metadata) : null,
-      options.bucketId || null
-    ];
-    this.polLogger.info(`[PolAttachmentQueue] queueUpload params:`, {
-      storagePath: options.storagePath,
-      filename: options.filename,
-      mediaType: options.mediaType,
-      size,
-      managedUri,
-      bucketId: options.bucketId,
-      metadataLength: options.metadata ? JSON.stringify(options.metadata).length : 0
-    });
-    try {
-      await this.powersync.execute(`INSERT OR REPLACE INTO ${this.table}
-         (id, filename, media_type, state, local_uri, size, timestamp,
-          upload_source_uri, upload_retry_count, upload_next_retry_at,
-          upload_metadata, upload_bucket_id)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, insertParams);
-    } catch (insertError) {
-      this.polLogger.error(`[PolAttachmentQueue] queueUpload INSERT failed:`, insertError);
-      throw insertError;
-    }
-    this.polLogger.info(`[PolAttachmentQueue] Queued upload: ${options.storagePath}`);
-    if (!this._uploadPaused && !this._uploadProcessing) {
-      this._startUploadProcessing();
-    }
-    this._notify(true);
-  }
-  /**
-   * Get pending uploads that need retry.
-   */
-  async getPendingUploads() {
-    const now = Date.now();
-    return this.powersync.getAll(`SELECT * FROM ${this.table}
-       WHERE state = ? AND (upload_next_retry_at IS NULL OR upload_next_retry_at <= ?)
-       ORDER BY timestamp ASC`, [AttachmentState2.QUEUED_UPLOAD, now]);
-  }
-  /**
-   * Get the soonest retry time for all uploads currently in backoff.
-   * Returns null if there are no uploads waiting for retry.
-   */
-  async getSoonestRetryTime() {
-    const now = Date.now();
-    const result = await this.powersync.getOptional(`SELECT MIN(upload_next_retry_at) as soonest FROM ${this.table}
-       WHERE state = ? AND upload_next_retry_at > ?`, [AttachmentState2.QUEUED_UPLOAD, now]);
-    return result?.soonest ?? null;
-  }
-  /**
-   * Get uploads that have permanently failed.
-   */
-  async getFailedPermanentUploads() {
-    return this.powersync.getAll(`SELECT * FROM ${this.table} WHERE state = ?`, [5 /* FAILED_PERMANENT */]);
-  }
-  /**
-   * Get stale uploads (failing for > staleDaysThreshold).
-   */
-  async getStaleUploads() {
-    const threshold = Date.now() - this.uploadConfig.staleDaysThreshold * 24 * 60 * 60 * 1e3;
-    return this.powersync.getAll(`SELECT * FROM ${this.table}
-       WHERE state = ? AND timestamp < ?`, [AttachmentState2.QUEUED_UPLOAD, threshold]);
-  }
-  /**
-   * Get SYNCED uploads that have pending onComplete callbacks.
-   * Used by useQueuedUpload to recover callbacks after unmount/remount.
-   *
-   * Records are identified by having 'onCompleteCallback' flag in their upload_metadata.
-   * Once the callback is invoked, the hook should call clearUploadCallback() to remove the flag.
-   */
-  async getSyncedUploadsWithPendingCallback() {
-    return this.powersync.getAll(`SELECT * FROM ${this.table}
-       WHERE state = ? AND upload_metadata LIKE '%"onCompleteCallback":true%'`, [AttachmentState2.SYNCED]);
-  }
-  /**
-   * Clear the onCompleteCallback flag from a record's metadata after callback invocation.
-   */
-  async clearUploadCallback(id) {
-    const record = await this.record(id);
-    if (!record) return;
-    const polRecord = record;
-    if (!polRecord.upload_metadata) return;
-    try {
-      const metadata = JSON.parse(polRecord.upload_metadata);
-      delete metadata.onCompleteCallback;
-      await this.powersync.execute(`UPDATE ${this.table} SET upload_metadata = ? WHERE id = ?`, [JSON.stringify(metadata), id]);
-    } catch {
-      await this.powersync.execute(`UPDATE ${this.table} SET upload_metadata = NULL WHERE id = ?`, [id]);
-    }
-  }
-  /**
-   * Retry a failed upload.
-   */
-  async retryUpload(id) {
-    await this.powersync.execute(`UPDATE ${this.table}
-       SET state = ?, upload_retry_count = 0, upload_next_retry_at = ?, upload_error = NULL
-       WHERE id = ?`, [AttachmentState2.QUEUED_UPLOAD, Date.now(), id]);
-    if (!this._uploadPaused && !this._uploadProcessing) {
-      this._startUploadProcessing();
-    }
-    this._notify(true);
-  }
-  /**
-   * Delete an upload from the queue.
-   */
-  async deleteUpload(id) {
-    const record = await this.record(id);
-    if (record) {
-      const polRecord = record;
-      if (polRecord.upload_source_uri) {
-        try {
-          await this.platform.fileSystem.deleteFile(polRecord.upload_source_uri);
-        } catch {
-        }
-      }
-    }
-    await this.powersync.execute(`DELETE FROM ${this.table} WHERE id = ?`, [id]);
-    this._notify(true);
-  }
-  // ─── Compatibility Aliases ────────────────────────────────────────────────────
-  /**
-   * Alias for record() for backward compatibility.
-   * Returns an attachment record by ID.
-   */
-  async getRecord(id) {
-    const record = await this.record(id);
-    return record;
-  }
-  /**
-   * Alias for getFailedPermanentUploads() for backward compatibility.
-   */
-  async getFailedUploads() {
-    return this.getFailedPermanentUploads();
-  }
-  /**
-   * Alias for retryUpload() for backward compatibility.
-   */
-  async retryFailedUpload(id) {
-    return this.retryUpload(id);
-  }
-  /**
-   * Alias for deleteUpload() for backward compatibility.
-   */
-  async deleteFailedUpload(id) {
-    return this.deleteUpload(id);
-  }
-  /**
-   * Get currently active uploads.
-   */
-  get activeUploads() {
-    return [...this._activeUploads.values()];
-  }
-  /**
-   * Pause upload processing.
-   */
-  pauseUploads() {
-    this.polLogger.info("[PolAttachmentQueue] Pausing uploads");
-    this._uploadPaused = true;
-    this._uploadAbort.abort();
-    this._uploadAbort = new AbortController();
-    this._notify(true);
-  }
-  /**
-   * Resume upload processing.
-   */
-  resumeUploads() {
-    this.polLogger.info("[PolAttachmentQueue] Resuming uploads");
-    this._uploadPaused = false;
-    this._uploadAbort = new AbortController();
-    if (!this._uploadProcessing) {
-      this._startUploadProcessing();
-    }
-    this._notify(true);
-  }
-  // ─── Cache Management ──────────────────────────────────────────────────────
-  /**
-   * Clear all cached files and re-queue for download.
-   */
-  async clearCache() {
-    this.polLogger.info("[PolAttachmentQueue] Clearing cache...");
-    const records = await this.powersync.getAll(`SELECT id, local_uri FROM ${this.table}
-       WHERE local_uri IS NOT NULL
-       AND state IN (?, ?, ?)`, [AttachmentState2.QUEUED_DOWNLOAD, AttachmentState2.SYNCED, AttachmentState2.QUEUED_SYNC]);
-    for (const record of records) {
-      if (record.local_uri) {
-        try {
-          const fullPath = this.getLocalUri(record.local_uri);
-          await this.platform.fileSystem.deleteFile(fullPath);
-        } catch {
-        }
-      }
-    }
-    await this.powersync.execute(`UPDATE ${this.table}
-       SET state = ?, local_uri = NULL, size = 0
-       WHERE state IN (?, ?, ?)`, [AttachmentState2.QUEUED_DOWNLOAD, AttachmentState2.QUEUED_DOWNLOAD, AttachmentState2.SYNCED, AttachmentState2.QUEUED_SYNC]);
-    this._cachedStats = null;
-    this._cachedStatsTimestamp = 0;
-    this._notify(true);
-    this.polLogger.info("[PolAttachmentQueue] Cache cleared");
-  }
-  /**
-   * Cache a local file (e.g., one just uploaded) into the attachment cache.
-   * This avoids a redundant download by copying the source file directly
-   * into the cache directory and marking it as SYNCED.
-   */
-  async cacheLocalFile(storagePath, sourceUri) {
-    try {
-      const sourceInfo = await this.platform.fileSystem.getFileInfo(sourceUri);
-      if (!sourceInfo || !sourceInfo.exists) {
-        this.polLogger.warn(`[PolAttachmentQueue] Source file does not exist: ${sourceUri}`);
-        return;
-      }
-      const localPath = storagePath.replace(/[^a-zA-Z0-9._-]/g, "_");
-      const localUri = this.getLocalUri(localPath);
-      const dir = localUri.substring(0, localUri.lastIndexOf("/"));
-      await this.platform.fileSystem.makeDirectory(dir, {
-        intermediates: true
-      });
-      await this.platform.fileSystem.copyFile(sourceUri, localUri);
-      const info = await this.platform.fileSystem.getFileInfo(localUri);
-      const size = info && info.exists ? info.size : 0;
-      const ext = storagePath.split(".").pop()?.toLowerCase() ?? "";
-      const mediaTypeMap = {
-        jpg: "image/jpeg",
-        jpeg: "image/jpeg",
-        png: "image/png",
-        webp: "image/webp",
-        heic: "image/heic",
-        heif: "image/heif",
-        gif: "image/gif",
-        mp4: "video/mp4",
-        mov: "video/quicktime"
-      };
-      const mediaType = mediaTypeMap[ext] ?? "application/octet-stream";
-      await this.powersync.execute(`INSERT INTO ${this.table} (id, filename, media_type, state, local_uri, size, timestamp)
-         VALUES (?, ?, ?, ?, ?, ?, ?)
-         ON CONFLICT(id) DO UPDATE SET
-           local_uri = excluded.local_uri,
-           size = excluded.size,
-           state = excluded.state,
-           timestamp = excluded.timestamp`, [storagePath, storagePath, mediaType, AttachmentState2.SYNCED, localPath, size, Date.now()]);
-      this._cachedStats = null;
-      this._cachedStatsTimestamp = 0;
-      this._notify(true);
-      this.polLogger.info(`[PolAttachmentQueue] Cached local file: ${storagePath} (${Math.round(size / 1024)}KB)`);
-    } catch (err) {
-      this.polLogger.warn(`[PolAttachmentQueue] Failed to cache local file: ${storagePath}`, err);
-    }
-  }
-  /**
-   * Get the local file URI for a storage path.
-   * Checks both downloaded files (SYNCED state, local_uri) and
-   * pending uploads (QUEUED_UPLOAD state, upload_source_uri).
-   *
-   * @param storagePath - The storage path (e.g., "14/uuid.jpg")
-   * @returns Full file:// URI if available locally, null otherwise
-   */
-  async getLocalUriForStoragePath(storagePath) {
-    let result = null;
-    try {
-      result = await this.powersync.getOptional(`SELECT local_uri, upload_source_uri, state FROM ${this.table}
-         WHERE id = ? AND (
-           (state = ? AND local_uri IS NOT NULL) OR
-           (state = ? AND upload_source_uri IS NOT NULL)
-         )`, [storagePath, AttachmentState2.SYNCED, AttachmentState2.QUEUED_UPLOAD]);
-    } catch (queryError) {
-      this.polLogger.error(`[PolAttachmentQueue] getLocalUriForStoragePath query failed:`, {
-        storagePath,
-        syncedState: AttachmentState2.SYNCED,
-        queuedUploadState: AttachmentState2.QUEUED_UPLOAD,
-        error: queryError
-      });
-      throw queryError;
-    }
-    if (!result) return null;
-    let localPath = null;
-    if (result.state === AttachmentState2.SYNCED && result.local_uri) {
-      localPath = result.local_uri;
-    } else if (result.state === AttachmentState2.QUEUED_UPLOAD && result.upload_source_uri) {
-      const uri2 = result.upload_source_uri.startsWith("file://") ? result.upload_source_uri : `file://${result.upload_source_uri}`;
-      try {
-        const exists = await this.storage.fileExists(uri2.replace("file://", ""));
-        if (!exists) {
-          this.polLogger.warn(`[PolAttachmentQueue] Upload source file missing: ${storagePath}`);
-          return null;
-        }
-      } catch (e) {
-        this.polLogger.warn(`[PolAttachmentQueue] Failed to verify upload source exists: ${storagePath}`, e);
-      }
-      return uri2;
-    }
-    if (!localPath) return null;
-    const fullPath = this.getLocalUri(localPath);
-    const uri = fullPath.startsWith("file://") ? fullPath : `file://${fullPath}`;
-    try {
-      const exists = await this.storage.fileExists(uri.replace("file://", ""));
-      if (!exists) {
-        this.polLogger.warn(`[PolAttachmentQueue] Cached file missing from disk, re-queuing: ${storagePath}`);
-        await this.powersync.execute(`UPDATE ${this.table} SET state = ?, local_uri = NULL WHERE id = ?`, [AttachmentState2.QUEUED_DOWNLOAD, storagePath]);
-        return null;
-      }
-    } catch (e) {
-      this.polLogger.warn(`[PolAttachmentQueue] Failed to verify file exists: ${storagePath}`, e);
-    }
-    return uri;
-  }
-  // ─── Progress Subscription ─────────────────────────────────────────────────
-  /**
-   * Subscribe to real-time progress updates.
-   * Returns an unsubscribe function.
-   */
-  onProgress(callback) {
-    this._progressCallbacks.add(callback);
-    this._notify(true);
-    return () => {
-      this._progressCallbacks.delete(callback);
-    };
-  }
-  /**
-   * Get current sync statistics.
-   */
-  async getStats() {
-    const now = Date.now();
-    if (this._cachedStats && now - this._cachedStatsTimestamp < STATS_CACHE_TTL_MS) {
-      return {
-        ...this._cachedStats,
-        status: this._getStatus(this._cachedStats.pendingCount),
-        isPaused: this._uploadPaused,
-        isProcessing: this.uploading || this.downloading || this._uploadProcessing,
-        activeDownloads: [],
-        activeUploads: this.activeUploads
-      };
-    }
-    const rows = await this.powersync.getAll(`SELECT state, COUNT(*) as cnt, COALESCE(SUM(size), 0) as sz
-       FROM ${this.table} GROUP BY state`);
-    let synced = 0;
-    let syncedSize = 0;
-    let pending = 0;
-    let pendingUpload = 0;
-    let failedPermanent = 0;
-    for (const r of rows) {
-      if (r.state === AttachmentState2.SYNCED) {
-        synced = r.cnt;
-        syncedSize = r.sz;
-      }
-      if (r.state === AttachmentState2.QUEUED_DOWNLOAD || r.state === AttachmentState2.QUEUED_SYNC) {
-        pending += r.cnt;
-      }
-      if (r.state === AttachmentState2.QUEUED_UPLOAD) {
-        pendingUpload = r.cnt;
-      }
-      if (r.state === 5 /* FAILED_PERMANENT */) {
-        failedPermanent = r.cnt;
-      }
-    }
-    const staleUploads = await this.getStaleUploads();
-    const stats = {
-      syncedCount: synced,
-      syncedSize,
-      pendingCount: pending,
-      totalExpected: synced + pending,
-      maxCacheSize: this.cacheConfig.maxSize,
-      compressionQuality: this.compressionConfig.quality,
-      status: this._getStatus(pending),
-      isPaused: this._uploadPaused,
-      isProcessing: this.uploading || this.downloading || this._uploadProcessing,
-      activeDownloads: [],
-      pendingUploadCount: pendingUpload,
-      failedPermanentCount: failedPermanent,
-      staleUploadCount: staleUploads.length,
-      activeUploads: this.activeUploads
-    };
-    this._cachedStats = stats;
-    this._cachedStatsTimestamp = now;
-    return stats;
-  }
-  // ─── Upload Processing ─────────────────────────────────────────────────────
-  async _startUploadProcessing() {
-    if (this._uploadPaused || this._uploadProcessing || !this.uploadHandler) return;
-    this.polLogger.info("[PolAttachmentQueue] Starting upload processing");
-    this._uploadProcessing = true;
-    try {
-      while (!this._uploadAbort.signal.aborted) {
-        const pending = await this.getPendingUploads();
-        if (pending.length > 0) {
-          for (let i = 0; i < pending.length; i += this.uploadConfig.concurrency) {
-            if (this._uploadAbort.signal.aborted) break;
-            const batch = pending.slice(i, i + this.uploadConfig.concurrency);
-            await Promise.allSettled(batch.map((record) => this._uploadOne(record)));
-          }
-          await this._sleep(UPLOAD_PROCESSING_DELAY_MS);
-        } else {
-          const soonestRetry = await this.getSoonestRetryTime();
-          if (soonestRetry === null) {
-            this.polLogger.info("[PolAttachmentQueue] No pending uploads, stopping processing");
-            break;
-          }
-          const now = Date.now();
-          const sleepDuration = Math.max(MIN_POLL_INTERVAL_MS, Math.min(soonestRetry - now, this.uploadConfig.maxRetryDelayMs));
-          this.polLogger.info(`[PolAttachmentQueue] All uploads in backoff, sleeping ${Math.round(sleepDuration / 1e3)}s until next retry`);
-          await this._sleep(sleepDuration);
-        }
-      }
-    } catch (error) {
-      this.polLogger.error("[PolAttachmentQueue] Upload loop error:", error);
-    } finally {
-      this._uploadProcessing = false;
-      this.polLogger.info("[PolAttachmentQueue] Upload processing stopped");
-      this._notify(true);
-    }
-  }
-  async _uploadOne(record) {
-    const signal = this._uploadAbort.signal;
-    if (signal.aborted) return;
-    this._activeUploads.set(record.id, {
-      id: record.id,
-      filename: record.filename,
-      phase: "uploading"
-    });
-    try {
-      if (!record.upload_source_uri) {
-        await this._markUploadPermanentFailure(record, "No source file URI");
-        return;
-      }
-      const fileInfo = await this.platform.fileSystem.getFileInfo(record.upload_source_uri);
-      if (!fileInfo || !fileInfo.exists) {
-        await this._markUploadPermanentFailure(record, "Source file no longer available");
-        return;
-      }
-      await this._withTimeout(this.uploadHandler.uploadFile(record.id, record.upload_source_uri, record.media_type || "application/octet-stream", signal), this.uploadConfig.timeoutMs, "Upload timed out", signal);
-      await this._markUploadSynced(record);
-    } catch (error) {
-      const err = error instanceof Error ? error : new Error(String(error));
-      if (err.name === "AbortError" || err instanceof DOMException && err.name === "AbortError") {
-        this.polLogger?.debug?.("[PolAttachmentQueue] Upload aborted (pause/dispose), will retry on resume", {
-          id: record.id
-        });
-        return;
-      }
-      if (this._isPermanentError(err)) {
-        await this._markUploadPermanentFailure(record, err.message, this._extractErrorCode(err));
-      } else {
-        await this._scheduleUploadRetry(record, err);
-      }
-    } finally {
-      this._activeUploads.delete(record.id);
-      this._notify(false);
-    }
-  }
-  _isPermanentError(error) {
-    const message = error.message.toLowerCase();
-    const code = this._extractErrorCode(error);
-    const permanentCodes = ["400", "401", "403", "404", "413", "415", "422"];
-    if (code && permanentCodes.includes(code)) {
-      return true;
-    }
-    if (message.includes("not found") || message.includes("unauthorized") || message.includes("forbidden") || message.includes("access denied")) {
-      return true;
-    }
-    return false;
-  }
-  /**
-   * Extract HTTP status code from error message.
-   * Uses specific patterns to avoid false positives from numbers in other contexts.
-   */
-  _extractErrorCode(error) {
-    const message = error.message;
-    const patterns = [
-      /\bstatus[:\s]+(\d{3})\b/i,
-      // "status: 404" or "status 404"
-      /\bHTTP[\/\s]+\d+(?:\.\d+)?\s+(\d{3})/i,
-      // "HTTP/1.1 404" or "HTTP 404"
-      /\b(\d{3})\s+(?:error|failed|forbidden|unauthorized|not\s+found)/i,
-      // "404 not found"
-      /\berror[:\s]+(\d{3})\b/i
-      // "error: 500" or "error 500"
-    ];
-    for (const pattern of patterns) {
-      const match = message.match(pattern);
-      if (match) {
-        return match[1];
-      }
-    }
-    if ("status" in error && typeof error.status === "number") {
-      return String(error.status);
-    }
-    return void 0;
-  }
-  async _markUploadSynced(record) {
-    await this.powersync.execute(`UPDATE ${this.table}
-       SET state = ?, local_uri = ?, upload_error = NULL, upload_error_code = NULL
-       WHERE id = ?`, [AttachmentState2.SYNCED, record.upload_source_uri, record.id]);
-    this.polLogger.info(`[PolAttachmentQueue] Upload complete: ${record.id}`);
-    if (this.options.onUploadComplete) {
-      try {
-        await this.options.onUploadComplete(record);
-      } catch (error) {
-        this.polLogger.error(`[PolAttachmentQueue] onUploadComplete failed for ${record.id}:`, error);
-      }
-    }
-  }
-  async _markUploadPermanentFailure(record, errorMessage, errorCode) {
-    await this.powersync.execute(`UPDATE ${this.table}
-       SET state = ?, upload_error = ?, upload_error_code = ?
-       WHERE id = ?`, [5 /* FAILED_PERMANENT */, errorMessage, errorCode || null, record.id]);
-    this.polLogger.warn(`[PolAttachmentQueue] Permanent failure: ${record.id} - ${errorMessage}`);
-    if (this.options.onUploadFailed) {
-      this.options.onUploadFailed(record, new Error(errorMessage));
-    }
-  }
-  async _scheduleUploadRetry(record, error) {
-    const retryCount = (record.upload_retry_count || 0) + 1;
-    if (retryCount > this.uploadConfig.maxRetryCount) {
-      this.polLogger.warn(`[PolAttachmentQueue] Max retry count (${this.uploadConfig.maxRetryCount}) exceeded for ${record.id}`);
-      await this._markUploadPermanentFailure(record, `Max retry count exceeded after ${retryCount - 1} attempts. Last error: ${error.message}`, "MAX_RETRIES");
-      return;
-    }
-    const baseDelay = calculateBackoffDelay(retryCount - 1, {
-      baseDelayMs: this.uploadConfig.baseRetryDelayMs,
-      maxDelayMs: this.uploadConfig.maxRetryDelayMs,
-      backoffMultiplier: 2
-    });
-    const nextRetryAt = Date.now() + addJitter(baseDelay);
-    await this.powersync.execute(`UPDATE ${this.table}
-       SET upload_retry_count = ?, upload_next_retry_at = ?, upload_error = ?
-       WHERE id = ?`, [retryCount, nextRetryAt, error.message, record.id]);
-    const delaySeconds = Math.round((nextRetryAt - Date.now()) / 1e3);
-    this.polLogger.info(`[PolAttachmentQueue] Scheduled retry ${retryCount}/${this.uploadConfig.maxRetryCount} for ${record.id} in ${delaySeconds}s`);
-  }
-  // ─── Helpers ───────────────────────────────────────────────────────────────
-  _startPolling(query, onUpdate) {
-    const poll = async () => {
-      if (this._disposed) return;
-      try {
-        const result = await this.powersync.getAll(query);
-        const ids = result?.map((r) => r.id) ?? [];
-        onUpdate(ids);
-      } catch (error) {
-        const errorMessage = String(error);
-        if (!errorMessage.includes("no such table") && !errorMessage.includes("SQLITE_EMPTY")) {
-          this.polLogger.warn("[PolAttachmentQueue] Poll error:", error);
-        }
-      }
-    };
-    poll();
-    this._watchInterval = setInterval(poll, WATCH_INTERVAL_MS);
-  }
-  async _migrateUploadColumns() {
-    const tableInfo = await this.powersync.getAll(`PRAGMA table_info(${this.table})`);
-    const existingColumns = new Set(tableInfo.map((r) => r.name));
-    const uploadColumns = [{
-      name: "upload_source_uri",
-      type: "TEXT"
-    }, {
-      name: "upload_error",
-      type: "TEXT"
-    }, {
-      name: "upload_error_code",
-      type: "TEXT"
-    }, {
-      name: "upload_retry_count",
-      type: "INTEGER DEFAULT 0"
-    }, {
-      name: "upload_next_retry_at",
-      type: "INTEGER"
-    }, {
-      name: "upload_metadata",
-      type: "TEXT"
-    }, {
-      name: "upload_bucket_id",
-      type: "TEXT"
-    }];
-    for (const col of uploadColumns) {
-      if (!existingColumns.has(col.name)) {
-        this.polLogger.info(`[PolAttachmentQueue] Adding column: ${col.name}`);
-        await this.powersync.execute(`ALTER TABLE ${this.table} ADD COLUMN ${col.name} ${col.type}`);
-      }
-    }
-  }
-  async _copyToManagedCache(sourceUri, storagePath) {
-    const localPath = storagePath.replace(/[^a-zA-Z0-9._-]/g, "_");
-    const cacheDir = this.platform.fileSystem.getCacheDirectory();
-    const targetUri = `${cacheDir}upload_queue/${localPath}`;
-    const dir = targetUri.substring(0, targetUri.lastIndexOf("/"));
-    await this.platform.fileSystem.makeDirectory(dir, {
-      intermediates: true
-    });
-    await this.platform.fileSystem.copyFile(sourceUri, targetUri);
-    this.polLogger.info(`[PolAttachmentQueue] Copied to managed cache: ${targetUri}`);
-    return targetUri;
-  }
-  _getStatus(pendingCount) {
-    if (this.uploading || this.downloading || this._uploadProcessing) return "syncing";
-    if (this._uploadPaused) return "paused";
-    return "complete";
-  }
-  _notify(forceImmediate = false) {
-    if (this._progressCallbacks.size === 0) return;
-    const now = Date.now();
-    const timeSinceLastNotify = now - this._lastNotifyTime;
-    if (this._notifyTimer) {
-      clearTimeout(this._notifyTimer);
-      this._notifyTimer = null;
-    }
-    const notifyAll = (stats) => {
-      for (const cb of this._progressCallbacks) {
-        try {
-          cb(stats);
-        } catch (err) {
-          this.polLogger.warn("[PolAttachmentQueue] Callback error:", err);
-        }
-      }
-    };
-    if (forceImmediate || timeSinceLastNotify >= NOTIFY_THROTTLE_MS) {
-      this._lastNotifyTime = now;
-      this.getStats().then(notifyAll).catch((err) => {
-        this.polLogger.warn("[PolAttachmentQueue] Stats error:", err);
-      });
-    } else {
-      const delay = NOTIFY_THROTTLE_MS - timeSinceLastNotify;
-      this._notifyTimer = setTimeout(() => {
-        this._notifyTimer = null;
-        this._lastNotifyTime = Date.now();
-        this.getStats().then(notifyAll).catch((err) => {
-          this.polLogger.warn("[PolAttachmentQueue] Stats error:", err);
-        });
-      }, delay);
-    }
-  }
-  _sleep(ms) {
-    return new Promise((resolve) => {
-      const timer = setTimeout(resolve, ms);
-      this._uploadAbort.signal.addEventListener("abort", () => {
-        clearTimeout(timer);
-        resolve();
-      }, {
-        once: true
-      });
-    });
-  }
-  /**
-   * Warning 6: Enhanced timeout that supports AbortSignal for actual cancellation.
-   * When signal is provided and aborts, the promise rejects with an AbortError.
-   */
-  _withTimeout(promise, ms, message, signal) {
-    return new Promise((resolve, reject) => {
-      if (signal?.aborted) {
-        reject(new DOMException("Operation aborted", "AbortError"));
-        return;
-      }
-      const timer = setTimeout(() => {
-        reject(new Error(message));
-      }, ms);
-      const abortHandler = () => {
-        clearTimeout(timer);
-        reject(new DOMException("Operation aborted", "AbortError"));
-      };
-      if (signal) {
-        signal.addEventListener("abort", abortHandler, {
-          once: true
-        });
-      }
-      promise.then((result) => {
-        clearTimeout(timer);
-        if (signal) {
-          signal.removeEventListener("abort", abortHandler);
-        }
-        resolve(result);
-      }, (err) => {
-        clearTimeout(timer);
-        if (signal) {
-          signal.removeEventListener("abort", abortHandler);
-        }
-        reject(err);
-      });
-    });
-  }
-};
-function createPolAttachmentQueue(powersync, platform, config) {
-  return new PolAttachmentQueue({
-    powersync,
-    // storage is created internally by the constructor using platform + remoteStorage + attachmentDirectoryName
-    storage: void 0,
-    // Will be overridden by constructor
-    platform,
-    remoteStorage: config.remoteStorage,
-    source: config.source,
-    attachmentDirectoryName: config.attachmentTableName ?? "attachments",
-    attachmentTableName: config.attachmentTableName ?? "attachments",
-    performInitialSync: config.performInitialSync,
-    downloadAttachments: true,
-    onDownloadError: config.onDownloadError ? async (attachment, error) => {
-      const result = await config.onDownloadError(attachment, error);
-      return result;
-    } : void 0,
-    uploadHandler: config.upload?.handler,
-    uploadConfig: config.upload?.config,
-    onUploadComplete: config.onUploadComplete,
-    onUploadFailed: config.onUploadFailed,
-    compression: config.compression,
-    cache: config.cache
-  });
-}
-
-export {
-  PolStorageAdapter,
-  PolAttachmentState,
-  DEFAULT_COMPRESSION_CONFIG,
-  DEFAULT_UPLOAD_CONFIG,
-  DEFAULT_CACHE_CONFIG,
-  AttachmentState,
-  ATTACHMENT_TABLE,
-  AttachmentTable,
-  EncodingType2 as EncodingType,
-  DEFAULT_ATTACHMENT_QUEUE_OPTIONS,
-  AbstractAttachmentQueue,
-  PolAttachmentQueue,
-  createPolAttachmentQueue
-};
-//# sourceMappingURL=chunk-ZEOKPWUC.js.map