@pol-studios/powersync 1.0.0

package/dist/chunk-GBGATW2S.js

@@ -0,0 +1,749 @@
+// src/attachments/types.ts
+var AttachmentState = /* @__PURE__ */ ((AttachmentState2) => {
+  AttachmentState2[AttachmentState2["QUEUED_DOWNLOAD"] = 0] = "QUEUED_DOWNLOAD";
+  AttachmentState2[AttachmentState2["QUEUED_SYNC"] = 1] = "QUEUED_SYNC";
+  AttachmentState2[AttachmentState2["QUEUED_UPLOAD"] = 2] = "QUEUED_UPLOAD";
+  AttachmentState2[AttachmentState2["SYNCED"] = 3] = "SYNCED";
+  AttachmentState2[AttachmentState2["ARCHIVED"] = 4] = "ARCHIVED";
+  return AttachmentState2;
+})(AttachmentState || {});
+var DEFAULT_COMPRESSION_CONFIG = {
+  enabled: true,
+  quality: 0.7,
+  maxWidth: 2048,
+  skipSizeBytes: 1e5,
+  targetSizeBytes: 3e5
+};
+var DEFAULT_DOWNLOAD_CONFIG = {
+  concurrency: 50,
+  timeoutMs: 6e4,
+  retryDelayMs: 5e3
+};
+var DEFAULT_CACHE_CONFIG = {
+  maxSize: 5 * 1024 * 1024 * 1024,
+  // 5 GB
+  downloadStopThreshold: 0.95,
+  evictionTriggerThreshold: 1
+};
+
+// src/attachments/attachment-queue.ts
+var NOTIFY_THROTTLE_MS = 500;
+var STATS_CACHE_TTL_MS = 500;
+var CACHE_SIZE_TTL_MS = 5e3;
+var AttachmentQueue = class {
+  // ─── Dependencies ──────────────────────────────────────────────────────────
+  powersync;
+  platform;
+  config;
+  logger;
+  tableName;
+  // ─── Configuration ─────────────────────────────────────────────────────────
+  concurrency;
+  downloadTimeoutMs;
+  retryDelayMs;
+  downloadStopThreshold;
+  evictionTriggerThreshold;
+  // ─── State ─────────────────────────────────────────────────────────────────
+  _initialized = false;
+  _paused = false;
+  _processing = false;
+  _cacheFull = false;
+  _resumeRequested = false;
+  _maxCacheSize;
+  _compressionQuality;
+  _abort = new AbortController();
+  _downloads = /* @__PURE__ */ new Map();
+  // ─── Caching ───────────────────────────────────────────────────────────────
+  _cachedSize = 0;
+  _cachedSizeTimestamp = 0;
+  _cachedStats = null;
+  _cachedStatsTimestamp = 0;
+  // ─── Notification ──────────────────────────────────────────────────────────
+  _lastNotifyTime = 0;
+  _notifyTimer = null;
+  _progressCallbacks = /* @__PURE__ */ new Set();
+  _watcherInterval = null;
+  // ─── Constructor ───────────────────────────────────────────────────────────
+  constructor(options) {
+    this.powersync = options.powersync;
+    this.platform = options.platform;
+    this.config = options.config;
+    this.logger = options.platform.logger;
+    this.tableName = options.config.attachmentTableName ?? "photo_attachments";
+    const downloadConfig = { ...DEFAULT_DOWNLOAD_CONFIG, ...options.config.download };
+    const cacheConfig = { ...DEFAULT_CACHE_CONFIG, ...options.config.cache };
+    const compressionConfig = { ...DEFAULT_COMPRESSION_CONFIG, ...options.config.compression };
+    this.concurrency = downloadConfig.concurrency;
+    this.downloadTimeoutMs = downloadConfig.timeoutMs;
+    this.retryDelayMs = downloadConfig.retryDelayMs;
+    this.downloadStopThreshold = cacheConfig.downloadStopThreshold;
+    this.evictionTriggerThreshold = cacheConfig.evictionTriggerThreshold;
+    this._maxCacheSize = cacheConfig.maxSize;
+    this._compressionQuality = compressionConfig.quality;
+  }
+  // ─── Initialization ────────────────────────────────────────────────────────
+  /**
+   * Initialize the attachment queue.
+   * Creates the attachment table if needed and starts watching for downloads.
+   */
+  async init() {
+    if (this._initialized) return;
+    this.logger.info("[AttachmentQueue] Initializing...");
+    await this.powersync.execute(`
+      CREATE TABLE IF NOT EXISTS ${this.tableName} (
+        id TEXT PRIMARY KEY,
+        filename TEXT NOT NULL,
+        media_type TEXT,
+        state INTEGER NOT NULL DEFAULT ${0 /* QUEUED_DOWNLOAD */},
+        local_uri TEXT,
+        size INTEGER DEFAULT 0,
+        timestamp INTEGER
+      )
+    `);
+    this._initialized = true;
+    if (this.config.performInitialSync !== false) {
+      this._startDownloadWatcher();
+    }
+    this.logger.info("[AttachmentQueue] Initialized");
+  }
+  /**
+   * Dispose the attachment queue.
+   */
+  dispose() {
+    this._abort.abort();
+    if (this._watcherInterval) {
+      clearInterval(this._watcherInterval);
+      this._watcherInterval = null;
+    }
+    if (this._notifyTimer) {
+      clearTimeout(this._notifyTimer);
+    }
+    this._progressCallbacks.clear();
+    this._initialized = false;
+  }
+  // ─── Public API ────────────────────────────────────────────────────────────
+  /**
+   * Subscribe to real-time progress updates.
+   * Returns an unsubscribe function.
+   */
+  onProgress(callback) {
+    this._progressCallbacks.add(callback);
+    this._notify(true);
+    return () => {
+      this._progressCallbacks.delete(callback);
+    };
+  }
+  /** Whether downloads are paused */
+  get paused() {
+    return this._paused;
+  }
+  /** Whether currently processing downloads */
+  get processing() {
+    return this._processing;
+  }
+  /**
+   * Set the maximum cache size.
+   */
+  async setMaxCacheSize(bytes) {
+    const oldLimit = this._maxCacheSize;
+    this._maxCacheSize = bytes;
+    this.logger.info(
+      `[AttachmentQueue] Cache limit changed: ${Math.round(oldLimit / 1024 / 1024)}MB \u2192 ${Math.round(bytes / 1024 / 1024)}MB`
+    );
+    if (bytes < oldLimit) {
+      const currentSize = await this._getCachedSizeWithCache();
+      const downloadStopLimit = bytes * this.downloadStopThreshold;
+      if (currentSize >= downloadStopLimit) {
+        this._cacheFull = true;
+        this._abort.abort();
+        this._abort = new AbortController();
+        this._notify(true);
+        await this._evictIfNeeded();
+      } else {
+        this._notify(true);
+      }
+    } else if (bytes > oldLimit && this._cacheFull) {
+      this._cacheFull = false;
+      this._notify(true);
+      if (!this._paused && !this._processing) {
+        this._startDownloads();
+      }
+    } else {
+      this._notify(true);
+    }
+  }
+  /**
+   * Set the compression quality (0.1 to 1.0).
+   */
+  setCompressionQuality(quality) {
+    this._compressionQuality = Math.max(0.1, Math.min(1, quality));
+    this._notify(true);
+  }
+  /** Get the current compression quality */
+  getCompressionQuality() {
+    return this._compressionQuality;
+  }
+  /**
+   * Pause downloads.
+   */
+  pause() {
+    this.logger.info("[AttachmentQueue] Pausing downloads");
+    this._paused = true;
+    this._abort.abort();
+    this._abort = new AbortController();
+    this._notify(true);
+  }
+  /**
+   * Resume downloads.
+   */
+  resume() {
+    this.logger.info("[AttachmentQueue] Resuming downloads");
+    this._paused = false;
+    this._abort = new AbortController();
+    this._notify(true);
+    if (this._processing) {
+      this._resumeRequested = true;
+    } else {
+      this._startDownloads();
+    }
+  }
+  /**
+   * Get current sync statistics.
+   */
+  async getStats() {
+    const now = Date.now();
+    if (this._cachedStats && now - this._cachedStatsTimestamp < STATS_CACHE_TTL_MS) {
+      return {
+        ...this._cachedStats,
+        compressionQuality: this._compressionQuality,
+        status: this._getStatus(this._cachedStats.pendingCount),
+        isPaused: this._paused,
+        isProcessing: this._processing,
+        activeDownloads: [...this._downloads.values()]
+      };
+    }
+    const rows = await this.powersync.getAll(
+      `SELECT state, COUNT(*) as cnt, COALESCE(SUM(size), 0) as sz
+       FROM ${this.tableName} GROUP BY state`
+    );
+    let synced = 0;
+    let syncedSize = 0;
+    let pending = 0;
+    for (const r of rows) {
+      if (r.state === 3 /* SYNCED */) {
+        synced = r.cnt;
+        syncedSize = r.sz;
+      }
+      if (r.state === 0 /* QUEUED_DOWNLOAD */ || r.state === 1 /* QUEUED_SYNC */) {
+        pending += r.cnt;
+      }
+    }
+    this._cachedSize = syncedSize;
+    this._cachedSizeTimestamp = now;
+    const stats = {
+      syncedCount: synced,
+      syncedSize,
+      pendingCount: pending,
+      totalExpected: synced + pending,
+      maxCacheSize: this._maxCacheSize,
+      compressionQuality: this._compressionQuality,
+      status: this._getStatus(pending),
+      isPaused: this._paused,
+      isProcessing: this._processing,
+      activeDownloads: [...this._downloads.values()]
+    };
+    this._cachedStats = stats;
+    this._cachedStatsTimestamp = now;
+    return stats;
+  }
+  /**
+   * Clear all cached files and re-queue for download.
+   */
+  async clearCache() {
+    const wasPaused = this._paused;
+    if (!wasPaused) this.pause();
+    try {
+      let attempts = 0;
+      while (this._processing && attempts < 50) {
+        await this._sleep(100, this._abort.signal);
+        attempts++;
+      }
+      const withFiles = await this.powersync.getAll(
+        `SELECT id, local_uri FROM ${this.tableName} WHERE local_uri IS NOT NULL`
+      );
+      for (const row of withFiles) {
+        try {
+          await this.platform.fileSystem.deleteFile(row.local_uri);
+        } catch {
+        }
+      }
+      await this.powersync.execute(
+        `UPDATE ${this.tableName} SET state = ?, local_uri = NULL, size = 0`,
+        [0 /* QUEUED_DOWNLOAD */]
+      );
+    } finally {
+      this._cachedSize = 0;
+      this._cachedSizeTimestamp = 0;
+      this._cachedStats = null;
+      this._cachedStatsTimestamp = 0;
+      this._cacheFull = false;
+      if (!wasPaused) {
+        this.resume();
+      } else {
+        this._notify(true);
+      }
+    }
+  }
+  /**
+   * Get an attachment record by ID.
+   */
+  async getRecord(id) {
+    return this.powersync.get(
+      `SELECT * FROM ${this.tableName} WHERE id = ?`,
+      [id]
+    );
+  }
+  /**
+   * Get the local file URI for an attachment.
+   */
+  getLocalUri(localPath) {
+    const cacheDir = this.platform.fileSystem.getCacheDirectory();
+    return `${cacheDir}attachments/${localPath}`;
+  }
+  /**
+   * 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) {
+    if (!this._initialized) {
+      this.logger.warn("[AttachmentQueue] cacheLocalFile called before init");
+      return;
+    }
+    try {
+      const sourceInfo = await this.platform.fileSystem.getFileInfo(sourceUri);
+      if (!sourceInfo || !sourceInfo.exists) {
+        this.logger.warn(`[AttachmentQueue] 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 OR REPLACE INTO ${this.tableName} (id, filename, media_type, state, local_uri, size, timestamp)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`,
+        [storagePath, storagePath, mediaType, 3 /* SYNCED */, localPath, size, Date.now()]
+      );
+      this._cachedStats = null;
+      this._cachedStatsTimestamp = 0;
+      this._cachedSizeTimestamp = 0;
+      this._notify(true);
+      this.logger.info(`[AttachmentQueue] Cached local file: ${storagePath} (${Math.round(size / 1024)}KB)`);
+    } catch (err) {
+      this.logger.warn(`[AttachmentQueue] Failed to cache local file: ${storagePath}`, err);
+    }
+  }
+  // ─── Download Watcher ──────────────────────────────────────────────────────
+  _startDownloadWatcher() {
+    const { table, idColumn, projectFilter } = this.config.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} != ''`;
+    }
+    const checkForNewAttachments = async () => {
+      if (this._abort.signal.aborted || !this._initialized) {
+        return;
+      }
+      try {
+        const result = await this.powersync.getAll(query);
+        const ids = (result ?? []).map((r) => r.id);
+        if (ids.length === 0) {
+          return;
+        }
+        await this._syncAttachmentIds(ids);
+        if (!this._paused && !this._processing) {
+          this._startDownloads();
+        }
+      } catch (err) {
+        const errorMessage = String(err);
+        if (errorMessage.includes("Result set is empty") || errorMessage.includes("no such table") || errorMessage.includes("SQLITE_EMPTY")) {
+          this.logger.debug("[AttachmentQueue] No attachments found in source table (expected for new projects)");
+          return;
+        }
+        this.logger.warn("[AttachmentQueue] Watch error:", err);
+      }
+    };
+    checkForNewAttachments();
+    this._watcherInterval = setInterval(checkForNewAttachments, 3e4);
+  }
+  async _syncAttachmentIds(ids) {
+    for (const id of ids) {
+      const existing = await this.getRecord(id);
+      if (!existing) {
+        await this.powersync.execute(
+          `INSERT OR IGNORE INTO ${this.tableName} (id, filename, state, timestamp)
+           VALUES (?, ?, ?, ?)`,
+          [id, id, 0 /* QUEUED_DOWNLOAD */, Date.now()]
+        );
+      }
+    }
+  }
+  // ─── Download Engine ───────────────────────────────────────────────────────
+  async _startDownloads() {
+    if (this._paused || this._processing) {
+      if (this._processing) {
+        this._resumeRequested = true;
+      }
+      return;
+    }
+    this.logger.info("[AttachmentQueue] Starting downloads");
+    this._processing = true;
+    this._resumeRequested = false;
+    const signal = this._abort.signal;
+    try {
+      let toProcess = await this._getIdsToDownload();
+      let prevQueueSize = 0;
+      while (toProcess.length > 0 && !signal.aborted) {
+        const ordered = await this._orderByNewest(toProcess);
+        let currentCachedSize = await this._getCachedSizeWithCache();
+        const downloadStopLimit = this._maxCacheSize * this.downloadStopThreshold;
+        if (currentCachedSize >= downloadStopLimit) {
+          this._cacheFull = true;
+          this.logger.info("[AttachmentQueue] Cache at capacity, stopping downloads");
+          break;
+        }
+        this._cacheFull = false;
+        for (let i = 0; i < ordered.length; i += this.concurrency) {
+          if (signal.aborted) break;
+          if (currentCachedSize >= downloadStopLimit) {
+            this._cacheFull = true;
+            break;
+          }
+          const chunk = ordered.slice(i, i + this.concurrency);
+          const results = await Promise.allSettled(
+            chunk.map((id) => this._downloadOne(id, signal))
+          );
+          const successful = [];
+          for (const result of results) {
+            if (result.status === "fulfilled" && result.value) {
+              successful.push(result.value);
+            }
+          }
+          if (successful.length > 0) {
+            await this._batchUpdateSizes(successful);
+            currentCachedSize = await this._getCachedSizeWithCache(true);
+          }
+        }
+        if (signal.aborted) break;
+        toProcess = await this._getIdsToDownload();
+        if (toProcess.length > 0 && toProcess.length >= prevQueueSize) {
+          await this._sleep(this.retryDelayMs, signal);
+        }
+        prevQueueSize = toProcess.length;
+      }
+    } catch (err) {
+      this.logger.error("[AttachmentQueue] Download loop error:", err);
+    } finally {
+      this._processing = false;
+      this._notify(true);
+      if (this._resumeRequested && !this._paused) {
+        this._resumeRequested = false;
+        this._startDownloads();
+      }
+    }
+  }
+  async _downloadOne(id, signal) {
+    if (signal.aborted) return null;
+    const record = await this.getRecord(id);
+    if (!record || signal.aborted) return null;
+    this._downloads.set(id, {
+      id,
+      filename: record.filename,
+      phase: "downloading"
+    });
+    try {
+      const data = await this._withTimeout(
+        this.config.storage.downloadFile(record.filename),
+        this.downloadTimeoutMs,
+        `Download timeout: ${record.filename}`
+      );
+      if (signal.aborted) return null;
+      const localPath = `${id.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 });
+      const content = data instanceof Blob ? await this._blobToBase64(data) : data;
+      await this.platform.fileSystem.writeFile(localUri, content, "base64");
+      await this._compressImage(localUri, id, record.filename);
+      const info = await this.platform.fileSystem.getFileInfo(localUri);
+      if (info && info.exists) {
+        await this.powersync.execute(
+          `UPDATE ${this.tableName}
+           SET state = ?, local_uri = ?, size = ?
+           WHERE id = ?`,
+          [3 /* SYNCED */, localPath, info.size, id]
+        );
+        return { id, size: info.size };
+      }
+      return null;
+    } catch (err) {
+      this.logger.warn(`[AttachmentQueue] Failed: ${record.filename}`, err);
+      return null;
+    } finally {
+      this._downloads.delete(id);
+      this._notify();
+    }
+  }
+  async _batchUpdateSizes(results) {
+    if (results.length === 0) return;
+    for (const { id, size } of results) {
+      await this.powersync.execute(
+        `UPDATE ${this.tableName} SET size = ? WHERE id = ? AND state = ?`,
+        [size, id, 3 /* SYNCED */]
+      );
+    }
+    this._cachedSizeTimestamp = 0;
+  }
+  async _getIdsToDownload() {
+    const result = await this.powersync.getAll(
+      `SELECT id FROM ${this.tableName}
+       WHERE state IN (?, ?)`,
+      [0 /* QUEUED_DOWNLOAD */, 1 /* QUEUED_SYNC */]
+    );
+    return result.map((r) => r.id);
+  }
+  // ─── Eviction ──────────────────────────────────────────────────────────────
+  async _evictIfNeeded() {
+    const evictionTrigger = this._maxCacheSize * this.evictionTriggerThreshold;
+    const targetSize = this._maxCacheSize * this.downloadStopThreshold;
+    let currentSize = await this._getCachedSizeWithCache(true);
+    if (currentSize <= evictionTrigger) return;
+    this.logger.info("[AttachmentQueue] Starting eviction...");
+    while (currentSize > targetSize) {
+      const toEvict = await this.powersync.getAll(
+        `SELECT id, local_uri, size FROM ${this.tableName}
+         WHERE state = ${3 /* SYNCED */} AND size > 0 LIMIT 100`
+      );
+      if (toEvict.length === 0) break;
+      for (const row of toEvict) {
+        if (currentSize <= targetSize) break;
+        if (row.local_uri) {
+          try {
+            await this.platform.fileSystem.deleteFile(this.getLocalUri(row.local_uri));
+            await this.powersync.execute(
+              `UPDATE ${this.tableName}
+               SET state = ?, local_uri = NULL, size = 0 WHERE id = ?`,
+              [0 /* QUEUED_DOWNLOAD */, row.id]
+            );
+            currentSize -= row.size;
+          } catch {
+          }
+        }
+      }
+      this._cachedSizeTimestamp = 0;
+      currentSize = await this._getCachedSizeWithCache(true);
+    }
+    this._cacheFull = currentSize > targetSize;
+    this._notify(true);
+    if (!this._cacheFull && !this._paused && !this._processing) {
+      this._startDownloads();
+    }
+  }
+  // ─── Compression ───────────────────────────────────────────────────────────
+  async _compressImage(localUri, id, filename) {
+    if (!this._isImage(filename)) return;
+    if (!this.platform.imageProcessor) return;
+    const compressionConfig = { ...DEFAULT_COMPRESSION_CONFIG, ...this.config.compression };
+    if (!compressionConfig.enabled) return;
+    try {
+      const info = await this.platform.fileSystem.getFileInfo(localUri);
+      if (!info || !info.exists) return;
+      const originalSize = info.size;
+      if (originalSize < compressionConfig.skipSizeBytes) return;
+      if (originalSize < compressionConfig.targetSizeBytes) return;
+      const existing = this._downloads.get(id);
+      if (existing) {
+        this._downloads.set(id, { ...existing, phase: "compressing" });
+        this._notify(false);
+      }
+      const result = await this.platform.imageProcessor.compress(localUri, {
+        quality: this._compressionQuality,
+        maxWidth: originalSize > 1e6 ? compressionConfig.maxWidth : void 0,
+        format: "jpeg"
+      });
+      const compressedInfo = await this.platform.fileSystem.getFileInfo(result.uri);
+      if (!compressedInfo || !compressedInfo.exists) return;
+      if (compressedInfo.size >= originalSize) {
+        await this.platform.fileSystem.deleteFile(result.uri);
+        return;
+      }
+      await this.platform.fileSystem.deleteFile(localUri);
+      await this.platform.fileSystem.moveFile(result.uri, localUri);
+      this.logger.info(
+        `[AttachmentQueue] Compressed ${filename}: ${Math.round(originalSize / 1024)}KB \u2192 ${Math.round(compressedInfo.size / 1024)}KB`
+      );
+    } catch (err) {
+      this.logger.warn(`[AttachmentQueue] Compression failed for ${filename}:`, err);
+    }
+  }
+  // ─── Helpers ───────────────────────────────────────────────────────────────
+  _isImage(filename) {
+    const ext = filename.split(".").pop()?.toLowerCase();
+    return ["jpg", "jpeg", "png", "webp", "heic", "heif"].includes(ext ?? "");
+  }
+  _getStatus(pendingCount) {
+    if (this._processing) return "syncing";
+    if (this._paused) return "paused";
+    if (this._cacheFull && pendingCount > 0) return "cache_full";
+    return "complete";
+  }
+  async _getCachedSizeWithCache(forceRefresh = false) {
+    const now = Date.now();
+    if (!forceRefresh && this._cachedSizeTimestamp > 0 && now - this._cachedSizeTimestamp < CACHE_SIZE_TTL_MS) {
+      return this._cachedSize;
+    }
+    const result = await this.powersync.get(
+      `SELECT COALESCE(SUM(size), 0) as total FROM ${this.tableName}
+       WHERE state = ${3 /* SYNCED */}`
+    );
+    this._cachedSize = result?.total ?? 0;
+    this._cachedSizeTimestamp = now;
+    return this._cachedSize;
+  }
+  async _orderByNewest(ids) {
+    if (ids.length <= 3) return ids;
+    const { table, idColumn, orderByColumn } = this.config.source;
+    if (!orderByColumn) return ids;
+    try {
+      const idSet = new Set(ids);
+      const ordered = await this.powersync.getAll(
+        `SELECT ${idColumn} as id FROM ${table}
+         WHERE ${idColumn} IS NOT NULL AND ${idColumn} != ''
+         ORDER BY ${orderByColumn} DESC NULLS LAST
+         LIMIT ?`,
+        [ids.length * 2]
+      );
+      const result = [];
+      for (const row of ordered) {
+        if (idSet.has(row.id)) {
+          result.push(row.id);
+          idSet.delete(row.id);
+        }
+      }
+      for (const id of ids) {
+        if (idSet.has(id)) {
+          result.push(id);
+        }
+      }
+      return result;
+    } catch {
+      return ids;
+    }
+  }
+  _sleep(ms, signal) {
+    return new Promise((resolve) => {
+      const onAbort = () => {
+        clearTimeout(timer);
+        resolve();
+      };
+      const timer = setTimeout(() => {
+        signal.removeEventListener("abort", onAbort);
+        resolve();
+      }, ms);
+      signal.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+  _withTimeout(promise, ms, message) {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => reject(new Error(message)), ms);
+      promise.then(
+        (result) => {
+          clearTimeout(timer);
+          resolve(result);
+        },
+        (err) => {
+          clearTimeout(timer);
+          reject(err);
+        }
+      );
+    });
+  }
+  async _blobToBase64(blob) {
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onloadend = () => {
+        const base64 = reader.result.split(",")[1];
+        resolve(base64);
+      };
+      reader.onerror = reject;
+      reader.readAsDataURL(blob);
+    });
+  }
+  _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.logger.warn("[AttachmentQueue] Callback error:", err);
+        }
+      }
+    };
+    if (forceImmediate || timeSinceLastNotify >= NOTIFY_THROTTLE_MS) {
+      this._lastNotifyTime = now;
+      this.getStats().then(notifyAll).catch(() => {
+      });
+    } else {
+      const delay = NOTIFY_THROTTLE_MS - timeSinceLastNotify;
+      this._notifyTimer = setTimeout(() => {
+        this._notifyTimer = null;
+        this._lastNotifyTime = Date.now();
+        this.getStats().then(notifyAll).catch(() => {
+        });
+      }, delay);
+    }
+  }
+};
+
+export {
+  AttachmentState,
+  DEFAULT_COMPRESSION_CONFIG,
+  DEFAULT_DOWNLOAD_CONFIG,
+  DEFAULT_CACHE_CONFIG,
+  AttachmentQueue
+};
+//# sourceMappingURL=chunk-GBGATW2S.js.map