@pol-studios/powersync 1.0.7 → 1.0.11

package/dist/chunk-4TXTAEF2.js

@@ -0,0 +1,2060 @@
+import {
+  AbortError,
+  addJitter,
+  calculateBackoffDelay
+} from "./chunk-FV2HXEIY.js";
+
+// src/attachments/pol-storage-adapter.ts
+import { EncodingType } from "@powersync/attachments";
+var PolStorageAdapter = class {
+  platform;
+  remoteStorage;
+  attachmentDirectoryName;
+  userStorageDirectory;
+  logger;
+  constructor(options) {
+    this.platform = options.platform;
+    this.remoteStorage = options.remoteStorage;
+    this.attachmentDirectoryName = options.attachmentDirectoryName ?? "attachments";
+    this.logger = options.logger;
+    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.
+   *
+   * NOTE: This method implements the official @powersync/attachments StorageAdapter
+   * interface which requires returning Promise<Blob>. For the memory-optimized
+   * file path passthrough, PolAttachmentQueue.downloadRecord() calls
+   * remoteStorage.downloadFile() directly to get the file:// path.
+   *
+   * This method handles base64 string → Blob conversion for backward compatibility.
+   */
+  async downloadFile(filePath) {
+    const result = await this.remoteStorage.downloadFile(filePath);
+    if (typeof result === "string") {
+      if (result.startsWith("file://")) {
+        this.logger?.warn(`[PolStorageAdapter] PERFORMANCE WARNING: file:// path hit in downloadFile() - reading entire file into memory. This should be avoided; use direct file copy instead. File: ${filePath}`);
+        const base64Content = await this.platform.fileSystem.readFile(result, "base64");
+        const binaryString2 = atob(base64Content);
+        const bytes2 = new Uint8Array(binaryString2.length);
+        for (let i = 0; i < binaryString2.length; i++) {
+          bytes2[i] = binaryString2.charCodeAt(i);
+        }
+        return new Blob([bytes2]);
+      }
+      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 { ATTACHMENT_TABLE, AttachmentState, AttachmentTable } from "@powersync/attachments";
+import { EncodingType as EncodingType2 } from "@powersync/attachments";
+import { AbstractAttachmentQueue, DEFAULT_ATTACHMENT_QUEUE_OPTIONS } 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";
+  PolAttachmentState2[PolAttachmentState2["DOWNLOAD_SKIPPED"] = 6] = "DOWNLOAD_SKIPPED";
+  return PolAttachmentState2;
+})(PolAttachmentState || {});
+var DEFAULT_COMPRESSION_CONFIG = {
+  enabled: true,
+  quality: 0.7,
+  maxWidth: 2048,
+  skipSizeBytes: 1e5,
+  targetSizeBytes: 3e5
+};
+var DEFAULT_UPLOAD_CONFIG = {
+  concurrency: 5,
+  timeoutMs: 12e4,
+  baseRetryDelayMs: 3e4,
+  // 30 seconds base delay for battery efficiency
+  maxRetryDelayMs: 36e5,
+  // 1 hour max
+  staleDaysThreshold: 7,
+  maxRetryCount: 100
+};
+var DEFAULT_DOWNLOAD_CONFIG = {
+  concurrency: 3,
+  timeoutMs: 12e4
+};
+var DEFAULT_CACHE_CONFIG = {
+  maxSize: Number.MAX_SAFE_INTEGER,
+  // Unlimited by default
+  downloadStopThreshold: 0.95,
+  evictionTriggerThreshold: 1
+};
+var CACHE_SIZE_PRESETS = {
+  /** 250 MB */
+  MB_250: 250 * 1024 * 1024,
+  /** 500 MB */
+  MB_500: 500 * 1024 * 1024,
+  /** 1 GB */
+  GB_1: 1 * 1024 * 1024 * 1024,
+  /** 2 GB */
+  GB_2: 2 * 1024 * 1024 * 1024,
+  /** 5 GB */
+  GB_5: 5 * 1024 * 1024 * 1024,
+  /** Unlimited (no cache eviction) */
+  UNLIMITED: Number.MAX_SAFE_INTEGER
+};
+function formatCacheSize(bytes) {
+  if (bytes === Number.MAX_SAFE_INTEGER) return "Unlimited";
+  if (bytes >= 1024 * 1024 * 1024) {
+    const gb = bytes / (1024 * 1024 * 1024);
+    return `${gb % 1 === 0 ? gb : gb.toFixed(1)} GB`;
+  }
+  if (bytes >= 1024 * 1024) {
+    const mb = bytes / (1024 * 1024);
+    return `${mb % 1 === 0 ? mb : mb.toFixed(1)} MB`;
+  }
+  if (bytes >= 1024) {
+    const kb = bytes / 1024;
+    return `${kb % 1 === 0 ? kb : kb.toFixed(1)} KB`;
+  }
+  return `${bytes} bytes`;
+}
+
+// src/attachments/state-machine.ts
+import { AttachmentState as AttachmentState2 } from "@powersync/attachments";
+var PROTECTED_UPLOAD_STATES = /* @__PURE__ */ new Set([AttachmentState2.QUEUED_UPLOAD, 5 /* FAILED_PERMANENT */]);
+var PENDING_DOWNLOAD_STATES = /* @__PURE__ */ new Set([AttachmentState2.QUEUED_DOWNLOAD, AttachmentState2.QUEUED_SYNC]);
+var LOCALLY_AVAILABLE_STATES = /* @__PURE__ */ new Set([AttachmentState2.SYNCED, AttachmentState2.QUEUED_UPLOAD]);
+function isProtectedUploadState(state) {
+  return PROTECTED_UPLOAD_STATES.has(state);
+}
+function isPendingDownloadState(state) {
+  return PENDING_DOWNLOAD_STATES.has(state);
+}
+function isLocallyAvailable(state) {
+  return LOCALLY_AVAILABLE_STATES.has(state);
+}
+function isStateTransitionAllowed(currentState, newState) {
+  if (isProtectedUploadState(currentState) && isPendingDownloadState(newState)) {
+    return false;
+  }
+  return true;
+}
+function determineAttachmentState(hasLocalUri, hasUploadSourceUri, currentState) {
+  if (currentState !== void 0 && isProtectedUploadState(currentState)) {
+    return currentState;
+  }
+  if (hasUploadSourceUri) {
+    return AttachmentState2.QUEUED_UPLOAD;
+  }
+  if (hasLocalUri) {
+    return AttachmentState2.SYNCED;
+  }
+  return AttachmentState2.QUEUED_DOWNLOAD;
+}
+function 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_]*$/`);
+  }
+}
+function getProtectedStatesInClause() {
+  return `(${AttachmentState2.QUEUED_UPLOAD}, ${5 /* FAILED_PERMANENT */})`;
+}
+function getExcludeProtectedStatesCondition(stateColumn = "state") {
+  return `${stateColumn} NOT IN ${getProtectedStatesInClause()}`;
+}
+
+// src/utils/mimeTypes.ts
+var MIME_TYPES = {
+  // Images
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  png: "image/png",
+  gif: "image/gif",
+  webp: "image/webp",
+  heic: "image/heic",
+  heif: "image/heic",
+  svg: "image/svg+xml",
+  bmp: "image/bmp",
+  tiff: "image/tiff",
+  tif: "image/tiff",
+  ico: "image/x-icon",
+  avif: "image/avif",
+  // Videos
+  mp4: "video/mp4",
+  mov: "video/quicktime",
+  avi: "video/x-msvideo",
+  webm: "video/webm",
+  mkv: "video/x-matroska",
+  m4v: "video/x-m4v",
+  "3gp": "video/3gpp",
+  flv: "video/x-flv",
+  // Audio
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  ogg: "audio/ogg",
+  m4a: "audio/mp4",
+  aac: "audio/aac",
+  flac: "audio/flac",
+  wma: "audio/x-ms-wma",
+  // Documents
+  pdf: "application/pdf",
+  doc: "application/msword",
+  docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  xls: "application/vnd.ms-excel",
+  xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ppt: "application/vnd.ms-powerpoint",
+  pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  txt: "text/plain",
+  csv: "text/csv",
+  rtf: "application/rtf",
+  odt: "application/vnd.oasis.opendocument.text",
+  ods: "application/vnd.oasis.opendocument.spreadsheet",
+  odp: "application/vnd.oasis.opendocument.presentation",
+  // Data formats
+  json: "application/json",
+  xml: "application/xml",
+  yaml: "application/x-yaml",
+  yml: "application/x-yaml",
+  // Archives
+  zip: "application/zip",
+  rar: "application/vnd.rar",
+  "7z": "application/x-7z-compressed",
+  tar: "application/x-tar",
+  gz: "application/gzip",
+  // Code
+  js: "text/javascript",
+  ts: "text/typescript",
+  jsx: "text/jsx",
+  tsx: "text/tsx",
+  css: "text/css",
+  html: "text/html",
+  htm: "text/html",
+  md: "text/markdown",
+  // Other
+  woff: "font/woff",
+  woff2: "font/woff2",
+  ttf: "font/ttf",
+  otf: "font/otf",
+  eot: "application/vnd.ms-fontobject"
+};
+var DEFAULT_MIME_TYPE = "application/octet-stream";
+function getMimeType(extension) {
+  if (!extension) {
+    return DEFAULT_MIME_TYPE;
+  }
+  const ext = extension.replace(/^\./, "").toLowerCase();
+  return MIME_TYPES[ext] ?? DEFAULT_MIME_TYPE;
+}
+function getMimeTypeFromPath(filePath) {
+  if (!filePath) {
+    return DEFAULT_MIME_TYPE;
+  }
+  const ext = filePath.split(".").pop();
+  return getMimeType(ext);
+}
+function isImageMimeType(mimeType) {
+  return mimeType.startsWith("image/");
+}
+function isVideoMimeType(mimeType) {
+  return mimeType.startsWith("video/");
+}
+function isAudioMimeType(mimeType) {
+  return mimeType.startsWith("audio/");
+}
+function isDocumentMimeType(mimeType) {
+  return mimeType === "application/pdf" || mimeType.includes("wordprocessingml") || mimeType.includes("spreadsheetml") || mimeType.includes("presentationml") || mimeType.includes("msword") || mimeType.includes("ms-excel") || mimeType.includes("ms-powerpoint") || mimeType.includes("opendocument");
+}
+function getExtensionFromMimeType(mimeType) {
+  for (const [ext, mime] of Object.entries(MIME_TYPES)) {
+    if (mime === mimeType) {
+      return ext;
+    }
+  }
+  return void 0;
+}
+
+// src/attachments/download-manager.ts
+import { AttachmentState as AttachmentState3, EncodingType as EncodingType3 } from "@powersync/attachments";
+async function blobToArrayBuffer(blob) {
+  if (typeof blob.arrayBuffer === "function") {
+    return blob.arrayBuffer();
+  }
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onloadend = () => {
+      if (reader.result instanceof ArrayBuffer) {
+        resolve(reader.result);
+      } else {
+        reject(new Error("FileReader did not return ArrayBuffer"));
+      }
+    };
+    reader.onerror = () => reject(reader.error ?? new Error("FileReader.readAsArrayBuffer failed - blob conversion error"));
+    reader.readAsArrayBuffer(blob);
+  });
+}
+async function downloadRecord(deps, record) {
+  const {
+    logger,
+    storage,
+    remoteStorage,
+    platform
+  } = deps;
+  if (!deps.downloadAttachments) {
+    return false;
+  }
+  if (!record.local_uri) {
+    record.local_uri = deps.getLocalFilePathSuffix(record.filename);
+  }
+  const localFilePathUri = deps.getLocalUri(record.local_uri);
+  if (await storage.fileExists(localFilePathUri)) {
+    logger.debug(`[DownloadManager] Local file already downloaded, marking "${record.id}" as synced`);
+    await deps.update({
+      ...record,
+      state: AttachmentState3.SYNCED
+    });
+    return true;
+  }
+  try {
+    const downloadResult = await remoteStorage.downloadFile(record.filename);
+    const lastSlash = localFilePathUri.lastIndexOf("/");
+    const dirPath = lastSlash >= 0 ? localFilePathUri.substring(0, lastSlash + 1) : localFilePathUri;
+    await storage.makeDir(dirPath);
+    if (typeof downloadResult === "string" && downloadResult.startsWith("file://")) {
+      const tempFilePath = downloadResult;
+      try {
+        logger.debug(`[DownloadManager] Using direct file copy for "${record.id}"`);
+        await storage.copyFile(tempFilePath, localFilePathUri);
+        const fileInfo = await platform.fileSystem.getFileInfo(localFilePathUri);
+        const fileSize = fileInfo?.exists ? fileInfo.size ?? 0 : 0;
+        const ext = record.filename.split(".").pop()?.toLowerCase();
+        const mediaType = getMimeType(ext);
+        await deps.update({
+          ...record,
+          media_type: mediaType,
+          size: fileSize,
+          state: AttachmentState3.SYNCED
+        });
+        logger.debug(`[DownloadManager] Downloaded attachment "${record.id}" (direct copy)`);
+        deps.invalidateStatsCache();
+        deps.notify(true);
+        return true;
+      } finally {
+        try {
+          await platform.fileSystem.deleteFile(tempFilePath);
+        } catch {
+        }
+      }
+    }
+    let fileBlob;
+    if (typeof downloadResult === "string") {
+      const binaryString = atob(downloadResult);
+      const bytes2 = new Uint8Array(binaryString.length);
+      for (let i = 0; i < binaryString.length; i++) {
+        bytes2[i] = binaryString.charCodeAt(i);
+      }
+      fileBlob = new Blob([bytes2]);
+    } else {
+      fileBlob = downloadResult;
+    }
+    const BLOB_TIMEOUT_MS = 3e4;
+    const arrayBuffer = await Promise.race([blobToArrayBuffer(fileBlob), new Promise((_, reject) => setTimeout(() => reject(new Error("Blob conversion timeout - file too large")), BLOB_TIMEOUT_MS))]);
+    const bytes = new Uint8Array(arrayBuffer);
+    const CHUNK_SIZE = 32768;
+    const chunks = [];
+    for (let i = 0; i < bytes.length; i += CHUNK_SIZE) {
+      chunks.push(String.fromCharCode(...bytes.subarray(i, i + CHUNK_SIZE)));
+    }
+    const base64Data = btoa(chunks.join(""));
+    await storage.writeFile(localFilePathUri, base64Data, {
+      encoding: EncodingType3.Base64
+    });
+    await deps.update({
+      ...record,
+      media_type: fileBlob.type,
+      size: bytes.length,
+      state: AttachmentState3.SYNCED
+    });
+    logger.debug(`[DownloadManager] Downloaded attachment "${record.id}"`);
+    deps.invalidateStatsCache();
+    deps.notify(true);
+    return true;
+  } catch (e) {
+    if (deps.onDownloadError) {
+      const {
+        retry
+      } = await deps.onDownloadError(record, e);
+      if (!retry) {
+        await deps.update({
+          ...record,
+          state: AttachmentState3.ARCHIVED
+        });
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+// src/attachments/upload-manager.ts
+import { AttachmentState as AttachmentState4 } from "@powersync/attachments";
+var UPLOAD_PROCESSING_DELAY_MS = 1e3;
+var MIN_POLL_INTERVAL_MS = 5e3;
+function isPermanentError(error) {
+  const message = error.message.toLowerCase();
+  const code = 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;
+}
+function 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 function getPendingUploads(powersync, tableName) {
+  const now = Date.now();
+  return powersync.getAll(`SELECT * FROM ${tableName}
+     WHERE state = ? AND (upload_next_retry_at IS NULL OR upload_next_retry_at <= ?)
+     ORDER BY timestamp ASC`, [AttachmentState4.QUEUED_UPLOAD, now]);
+}
+async function getSoonestRetryTime(powersync, tableName) {
+  const now = Date.now();
+  const result = await powersync.getOptional(`SELECT MIN(upload_next_retry_at) as soonest FROM ${tableName}
+     WHERE state = ? AND upload_next_retry_at > ?`, [AttachmentState4.QUEUED_UPLOAD, now]);
+  return result?.soonest ?? null;
+}
+async function getFailedPermanentUploads(powersync, tableName) {
+  return powersync.getAll(`SELECT * FROM ${tableName} WHERE state = ?`, [5 /* FAILED_PERMANENT */]);
+}
+async function getStaleUploads(powersync, tableName, staleDaysThreshold) {
+  const threshold = Date.now() - staleDaysThreshold * 24 * 60 * 60 * 1e3;
+  return powersync.getAll(`SELECT * FROM ${tableName}
+     WHERE state = ? AND timestamp < ?`, [AttachmentState4.QUEUED_UPLOAD, threshold]);
+}
+async function getSyncedUploadsWithPendingCallback(powersync, tableName) {
+  return powersync.getAll(`SELECT * FROM ${tableName}
+     WHERE state = ? AND upload_metadata LIKE '%"onCompleteCallback":true%'`, [AttachmentState4.SYNCED]);
+}
+async function clearUploadCallback(powersync, tableName, id, uploadMetadata) {
+  if (!uploadMetadata) return;
+  try {
+    const metadata = JSON.parse(uploadMetadata);
+    delete metadata.onCompleteCallback;
+    await powersync.execute(`UPDATE ${tableName} SET upload_metadata = ? WHERE id = ?`, [JSON.stringify(metadata), id]);
+  } catch {
+    await powersync.execute(`UPDATE ${tableName} SET upload_metadata = NULL WHERE id = ?`, [id]);
+  }
+}
+async function markUploadSynced(deps, record) {
+  const {
+    powersync,
+    tableName,
+    logger,
+    onUploadComplete
+  } = deps;
+  await powersync.execute(`UPDATE ${tableName}
+     SET state = ?, local_uri = ?, upload_error = NULL, upload_error_code = NULL
+     WHERE id = ?`, [AttachmentState4.SYNCED, record.upload_source_uri, record.id]);
+  logger.info(`[UploadManager] Upload complete: ${record.id}`);
+  if (onUploadComplete) {
+    try {
+      await onUploadComplete(record);
+    } catch (error) {
+      logger.error(`[UploadManager] onUploadComplete failed for ${record.id}:`, error);
+    }
+  }
+}
+async function markUploadPermanentFailure(deps, record, errorMessage, errorCode) {
+  const {
+    powersync,
+    tableName,
+    logger,
+    onUploadFailed
+  } = deps;
+  await powersync.execute(`UPDATE ${tableName}
+     SET state = ?, upload_error = ?, upload_error_code = ?
+     WHERE id = ?`, [5 /* FAILED_PERMANENT */, errorMessage, errorCode || null, record.id]);
+  logger.warn(`[UploadManager] Permanent failure: ${record.id} - ${errorMessage}`);
+  if (onUploadFailed) {
+    onUploadFailed(record, new Error(errorMessage));
+  }
+}
+async function scheduleUploadRetry(deps, record, error) {
+  const {
+    powersync,
+    tableName,
+    logger,
+    uploadConfig
+  } = deps;
+  const retryCount = (record.upload_retry_count || 0) + 1;
+  if (retryCount > uploadConfig.maxRetryCount) {
+    logger.warn(`[UploadManager] Max retry count (${uploadConfig.maxRetryCount}) exceeded for ${record.id}`);
+    await markUploadPermanentFailure(deps, record, `Max retry count exceeded after ${retryCount - 1} attempts. Last error: ${error.message}`, "MAX_RETRIES");
+    return;
+  }
+  const baseDelay = calculateBackoffDelay(retryCount - 1, {
+    baseDelayMs: uploadConfig.baseRetryDelayMs,
+    maxDelayMs: uploadConfig.maxRetryDelayMs,
+    backoffMultiplier: 2
+  });
+  const nextRetryAt = Date.now() + addJitter(baseDelay);
+  await powersync.execute(`UPDATE ${tableName}
+     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);
+  logger.info(`[UploadManager] Scheduled retry ${retryCount}/${uploadConfig.maxRetryCount} for ${record.id} in ${delaySeconds}s`);
+}
+async function uploadOne(deps, state, record) {
+  const {
+    platform,
+    logger,
+    uploadHandler,
+    uploadConfig
+  } = deps;
+  const signal = state.abortController.signal;
+  if (signal.aborted) return;
+  if (!uploadHandler) {
+    await markUploadPermanentFailure(deps, record, "No upload handler configured");
+    return;
+  }
+  state.activeUploads.set(record.id, {
+    id: record.id,
+    filename: record.filename,
+    phase: "uploading"
+  });
+  try {
+    if (!record.upload_source_uri) {
+      await markUploadPermanentFailure(deps, record, "No source file URI");
+      return;
+    }
+    const fileInfo = await platform.fileSystem.getFileInfo(record.upload_source_uri);
+    if (!fileInfo || !fileInfo.exists) {
+      await markUploadPermanentFailure(deps, record, "Source file no longer available");
+      return;
+    }
+    await withTimeout(uploadHandler.uploadFile(record.id, record.upload_source_uri, record.media_type || "application/octet-stream", signal), uploadConfig.timeoutMs, "Upload timed out", signal);
+    await markUploadSynced(deps, record);
+  } catch (error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    const isAbortError = err.name === "AbortError" || typeof DOMException !== "undefined" && err instanceof DOMException && err.name === "AbortError";
+    if (isAbortError) {
+      logger.debug?.("[UploadManager] Upload aborted (pause/dispose), will retry on resume", {
+        id: record.id
+      });
+      return;
+    }
+    logger.error(`[UploadManager] Upload failed for ${record.id}:`, err.message);
+    if (isPermanentError(err)) {
+      await markUploadPermanentFailure(deps, record, err.message, extractErrorCode(err));
+    } else {
+      await scheduleUploadRetry(deps, record, err);
+    }
+  } finally {
+    state.activeUploads.delete(record.id);
+    deps.notify(false);
+  }
+}
+async function startUploadProcessing(deps, state) {
+  const {
+    logger,
+    uploadHandler,
+    uploadConfig,
+    tableName,
+    powersync
+  } = deps;
+  if (state.paused || state.processing || !uploadHandler) return;
+  logger.info("[UploadManager] Starting upload processing");
+  state.processing = true;
+  try {
+    while (!state.abortController.signal.aborted) {
+      const pending = await getPendingUploads(powersync, tableName);
+      if (pending.length > 0) {
+        for (let i = 0; i < pending.length; i += uploadConfig.concurrency) {
+          if (state.abortController.signal.aborted) break;
+          const batch = pending.slice(i, i + uploadConfig.concurrency);
+          const uploadPromises = batch.map((record) => {
+            const promise = uploadOne(deps, state, record);
+            state.activePromises.add(promise);
+            promise.finally(() => state.activePromises.delete(promise));
+            return promise;
+          });
+          await Promise.allSettled(uploadPromises);
+        }
+        await sleep(UPLOAD_PROCESSING_DELAY_MS, state.abortController.signal);
+      } else {
+        const soonestRetry = await getSoonestRetryTime(powersync, tableName);
+        if (soonestRetry === null) {
+          logger.info("[UploadManager] No pending uploads, stopping processing");
+          break;
+        }
+        const allQueued = await powersync.getAll(`SELECT id, upload_error, upload_retry_count, upload_next_retry_at FROM ${tableName} WHERE state = ?`, [AttachmentState4.QUEUED_UPLOAD]);
+        for (const upload of allQueued) {
+          const retryIn = upload.upload_next_retry_at ? Math.round((upload.upload_next_retry_at - Date.now()) / 1e3) : 0;
+          logger.error(`[UploadManager] Upload in backoff: ${upload.id} (retry ${upload.upload_retry_count}, in ${retryIn}s) - Error: ${upload.upload_error || "unknown"}`);
+        }
+        const now = Date.now();
+        const sleepDuration = Math.max(MIN_POLL_INTERVAL_MS, Math.min(soonestRetry - now, uploadConfig.maxRetryDelayMs));
+        logger.info(`[UploadManager] All uploads in backoff, sleeping ${Math.round(sleepDuration / 1e3)}s until next retry`);
+        await sleep(sleepDuration, state.abortController.signal);
+      }
+    }
+  } catch (error) {
+    logger.error("[UploadManager] Upload loop error:", error);
+  } finally {
+    state.processing = false;
+    logger.info("[UploadManager] Upload processing stopped");
+    deps.notify(true);
+  }
+}
+function sleep(ms, signal) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(resolve, ms);
+    if (signal) {
+      signal.addEventListener("abort", () => {
+        clearTimeout(timer);
+        resolve();
+      }, {
+        once: true
+      });
+    }
+  });
+}
+function withTimeout(promise, ms, message, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(new AbortError());
+      return;
+    }
+    const timer = setTimeout(() => {
+      reject(new Error(message));
+    }, ms);
+    const abortHandler = () => {
+      clearTimeout(timer);
+      reject(new 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 createUploadManagerState() {
+  return {
+    processing: false,
+    paused: false,
+    abortController: new AbortController(),
+    activeUploads: /* @__PURE__ */ new Map(),
+    activePromises: /* @__PURE__ */ new Set()
+  };
+}
+function createUploadManagerDeps(partial) {
+  return {
+    ...partial,
+    uploadConfig: {
+      ...DEFAULT_UPLOAD_CONFIG,
+      ...partial.uploadConfig
+    }
+  };
+}
+
+// src/attachments/cache-manager.ts
+import { AttachmentState as AttachmentState5 } from "@powersync/attachments";
+function sanitizePathForCache(storagePath) {
+  return storagePath.replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+function ensureFileUri(path) {
+  return path.startsWith("file://") ? path : `file://${path}`;
+}
+function stripFileUri(uri) {
+  return uri.replace(/^file:\/\//, "");
+}
+async function getCachedSize(powersync, tableName) {
+  const result = await powersync.getOptional(`SELECT COALESCE(SUM(size), 0) as total FROM ${tableName}
+     WHERE state = ? AND local_uri IS NOT NULL`, [AttachmentState5.SYNCED]);
+  return result?.total ?? 0;
+}
+async function getEvictionCandidates(powersync, tableName) {
+  return powersync.getAll(`SELECT id, local_uri, size FROM ${tableName}
+     WHERE state = ? AND local_uri IS NOT NULL
+     ORDER BY timestamp ASC`, [AttachmentState5.SYNCED]);
+}
+async function enforceCacheLimit(deps) {
+  const {
+    powersync,
+    platform,
+    logger,
+    tableName,
+    cacheConfig,
+    getLocalUri
+  } = deps;
+  if (cacheConfig.maxSize === Number.MAX_SAFE_INTEGER) {
+    return {
+      evictedCount: 0,
+      freedBytes: 0
+    };
+  }
+  const currentSize = await getCachedSize(powersync, tableName);
+  const targetSize = cacheConfig.maxSize * cacheConfig.evictionTriggerThreshold;
+  if (currentSize <= targetSize) {
+    return {
+      evictedCount: 0,
+      freedBytes: 0
+    };
+  }
+  logger.info(`[CacheManager] Cache size ${formatBytes(currentSize)} exceeds limit ${formatBytes(cacheConfig.maxSize)}, starting eviction...`);
+  const candidates = await getEvictionCandidates(powersync, tableName);
+  let evictedCount = 0;
+  let freedBytes = 0;
+  let remainingSize = currentSize;
+  for (const candidate of candidates) {
+    if (remainingSize <= cacheConfig.maxSize) {
+      break;
+    }
+    if (candidate.local_uri) {
+      try {
+        const fullPath = getLocalUri(candidate.local_uri);
+        await platform.fileSystem.deleteFile(fullPath);
+      } catch {
+      }
+    }
+    await powersync.execute(`UPDATE ${tableName}
+       SET state = ?, local_uri = NULL, size = 0
+       WHERE id = ?`, [AttachmentState5.QUEUED_DOWNLOAD, candidate.id]);
+    evictedCount++;
+    freedBytes += candidate.size || 0;
+    remainingSize -= candidate.size || 0;
+  }
+  if (evictedCount > 0) {
+    deps.invalidateStatsCache();
+    deps.notify(true);
+    logger.info(`[CacheManager] Evicted ${evictedCount} files, freed ${formatBytes(freedBytes)} (cache now ${formatBytes(remainingSize)})`);
+  }
+  return {
+    evictedCount,
+    freedBytes
+  };
+}
+async function isCacheNearCapacity(deps) {
+  const {
+    powersync,
+    tableName,
+    cacheConfig
+  } = deps;
+  if (cacheConfig.maxSize === Number.MAX_SAFE_INTEGER) {
+    return false;
+  }
+  const currentSize = await getCachedSize(powersync, tableName);
+  const stopThreshold = cacheConfig.maxSize * cacheConfig.downloadStopThreshold;
+  return currentSize >= stopThreshold;
+}
+function formatBytes(bytes) {
+  if (bytes >= 1024 * 1024 * 1024) {
+    return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+  }
+  if (bytes >= 1024 * 1024) {
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  }
+  if (bytes >= 1024) {
+    return `${(bytes / 1024).toFixed(1)} KB`;
+  }
+  return `${bytes} bytes`;
+}
+async function clearCache(deps) {
+  const {
+    powersync,
+    platform,
+    logger,
+    tableName,
+    getLocalUri
+  } = deps;
+  logger.info("[CacheManager] Clearing cache...");
+  const records = await powersync.getAll(`SELECT id, local_uri FROM ${tableName}
+     WHERE local_uri IS NOT NULL
+     AND state IN (?, ?, ?)`, [AttachmentState5.QUEUED_DOWNLOAD, AttachmentState5.SYNCED, AttachmentState5.QUEUED_SYNC]);
+  for (const record of records) {
+    if (record.local_uri) {
+      try {
+        const fullPath = getLocalUri(record.local_uri);
+        await platform.fileSystem.deleteFile(fullPath);
+      } catch {
+      }
+    }
+  }
+  await powersync.execute(`UPDATE ${tableName}
+     SET state = ?, local_uri = NULL, size = 0
+     WHERE state IN (?, ?, ?)`, [AttachmentState5.QUEUED_DOWNLOAD, AttachmentState5.QUEUED_DOWNLOAD, AttachmentState5.SYNCED, AttachmentState5.QUEUED_SYNC]);
+  deps.invalidateStatsCache();
+  deps.notify(true);
+  logger.info("[CacheManager] Cache cleared");
+}
+async function cacheLocalFile(deps, storagePath, sourceUri) {
+  const {
+    powersync,
+    platform,
+    logger,
+    tableName,
+    getLocalUri
+  } = deps;
+  try {
+    const sourceInfo = await platform.fileSystem.getFileInfo(sourceUri);
+    if (!sourceInfo || !sourceInfo.exists) {
+      logger.warn(`[CacheManager] Source file does not exist: ${sourceUri}`);
+      return;
+    }
+    const localPath = sanitizePathForCache(storagePath);
+    const localUri = getLocalUri(localPath);
+    const dir = localUri.substring(0, localUri.lastIndexOf("/"));
+    await platform.fileSystem.makeDirectory(dir, {
+      intermediates: true
+    });
+    await platform.fileSystem.copyFile(sourceUri, localUri);
+    const info = await 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 powersync.execute(`INSERT INTO ${tableName} (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, AttachmentState5.SYNCED, localPath, size, Date.now()]);
+    deps.invalidateStatsCache();
+    deps.notify(true);
+    logger.info(`[CacheManager] Cached local file: ${storagePath} (${Math.round(size / 1024)}KB)`);
+  } catch (err) {
+    logger.warn(`[CacheManager] Failed to cache local file: ${storagePath}`, err);
+  }
+}
+async function getLocalUriForStoragePath(deps, storagePath, storage) {
+  const {
+    powersync,
+    logger,
+    tableName,
+    getLocalUri
+  } = deps;
+  let result = null;
+  try {
+    result = await powersync.getOptional(`SELECT local_uri, upload_source_uri, state FROM ${tableName}
+       WHERE id = ? AND (
+         (state = ? AND local_uri IS NOT NULL) OR
+         (state = ? AND upload_source_uri IS NOT NULL)
+       )`, [storagePath, AttachmentState5.SYNCED, AttachmentState5.QUEUED_UPLOAD]);
+  } catch (queryError) {
+    logger.error(`[CacheManager] getLocalUriForStoragePath query failed:`, {
+      storagePath,
+      syncedState: AttachmentState5.SYNCED,
+      queuedUploadState: AttachmentState5.QUEUED_UPLOAD,
+      error: queryError
+    });
+    throw queryError;
+  }
+  if (!result) return null;
+  let localPath = null;
+  if (result.state === AttachmentState5.SYNCED && result.local_uri) {
+    localPath = result.local_uri;
+  } else if (result.state === AttachmentState5.QUEUED_UPLOAD && result.upload_source_uri) {
+    const uri2 = ensureFileUri(result.upload_source_uri);
+    try {
+      const exists = await storage.fileExists(stripFileUri(uri2));
+      if (!exists) {
+        logger.warn(`[CacheManager] Upload source file missing: ${storagePath}`);
+        return null;
+      }
+    } catch (e) {
+      logger.warn(`[CacheManager] Failed to verify upload source exists: ${storagePath}`, e);
+    }
+    return uri2;
+  }
+  if (!localPath) return null;
+  const fullPath = getLocalUri(localPath);
+  const uri = ensureFileUri(fullPath);
+  try {
+    const exists = await storage.fileExists(stripFileUri(uri));
+    if (!exists) {
+      logger.warn(`[CacheManager] Cached file missing from disk, re-queuing: ${storagePath}`);
+      await powersync.execute(`UPDATE ${tableName} SET state = ?, local_uri = NULL WHERE id = ?`, [AttachmentState5.QUEUED_DOWNLOAD, storagePath]);
+      return null;
+    }
+  } catch (e) {
+    logger.warn(`[CacheManager] Failed to verify file exists: ${storagePath}`, e);
+  }
+  return uri;
+}
+async function copyToManagedCache(platform, logger, sourceUri, storagePath) {
+  const localPath = storagePath.replace(/[^a-zA-Z0-9._-]/g, "_");
+  const cacheDir = platform.fileSystem.getCacheDirectory();
+  const targetUri = `${cacheDir}upload_queue/${localPath}`;
+  const dir = targetUri.substring(0, targetUri.lastIndexOf("/"));
+  await platform.fileSystem.makeDirectory(dir, {
+    intermediates: true
+  });
+  await platform.fileSystem.copyFile(sourceUri, targetUri);
+  logger.info(`[CacheManager] Copied to managed cache: ${targetUri}`);
+  return targetUri;
+}
+function createCacheManagerDeps(partial) {
+  return {
+    ...partial,
+    cacheConfig: {
+      ...DEFAULT_CACHE_CONFIG,
+      ...partial.cacheConfig
+    }
+  };
+}
+
+// src/attachments/pol-attachment-queue.ts
+import { AbstractAttachmentQueue as AbstractAttachmentQueue2, AttachmentState as AttachmentState6 } from "@powersync/attachments";
+var NOTIFY_THROTTLE_MS = 500;
+var STATS_CACHE_TTL_MS = 500;
+var PolAttachmentQueue = class extends AbstractAttachmentQueue2 {
+  // ─── Private State ─────────────────────────────────────────────────────────
+  platform;
+  polLogger;
+  source;
+  remoteStorage;
+  uploadHandler;
+  uploadConfig;
+  downloadConfig;
+  compressionConfig;
+  cacheConfig;
+  // Upload manager state
+  _uploadState;
+  // Lifecycle state
+  _disposed = false;
+  _initialized = false;
+  _watchGeneration = 0;
+  _watchIdsCleanup = void 0;
+  _watchMutex = Promise.resolve();
+  _networkListenerCleanup = void 0;
+  _wasConnected = null;
+  // 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,
+      logger: options.platform.logger
+    });
+    super({
+      ...options,
+      storage,
+      syncInterval: 0,
+      cacheLimit: Number.MAX_SAFE_INTEGER
+    });
+    this.platform = options.platform;
+    this.polLogger = options.platform.logger;
+    this.source = options.source;
+    this.remoteStorage = options.remoteStorage;
+    this.uploadHandler = options.uploadHandler;
+    this.uploadConfig = {
+      ...DEFAULT_UPLOAD_CONFIG,
+      ...options.uploadConfig
+    };
+    this.downloadConfig = {
+      ...DEFAULT_DOWNLOAD_CONFIG,
+      ...options.downloadConfig
+    };
+    this.compressionConfig = {
+      ...DEFAULT_COMPRESSION_CONFIG,
+      ...options.compression
+    };
+    this.cacheConfig = {
+      ...DEFAULT_CACHE_CONFIG,
+      ...options.cache
+    };
+    this._uploadState = createUploadManagerState();
+  }
+  // ─── Parent Overrides ──────────────────────────────────────────────────────
+  watchUploads() {
+    this.polLogger?.debug?.("[PolAttachmentQueue] Parent watchUploads disabled - using custom upload engine");
+  }
+  /**
+   * Override parent's expireCache to disable count-based cache eviction.
+   *
+   * The parent implementation deletes SYNCED/ARCHIVED records beyond cacheLimit,
+   * which caused a bug where downloads would reset because:
+   * 1. expireCache deleted records beyond cacheLimit (default 100)
+   * 2. watchIds still emitted those IDs
+   * 3. They got re-created as QUEUED_DOWNLOAD
+   * 4. Downloads restarted in an infinite loop
+   *
+   * Our implementation uses size-based cache limits only (via clearCache/cacheConfig.maxSize).
+   */
+  async expireCache() {
+  }
+  /**
+   * Override parent's watchDownloads to use concurrent downloads.
+   *
+   * The parent implementation downloads one file at a time.
+   * This override processes downloads in parallel batches for faster sync.
+   */
+  watchDownloads() {
+    if (!this.options.downloadAttachments) {
+      return;
+    }
+    this.idsToDownload(async (ids) => {
+      ids.forEach((id) => this.downloadQueue.add(id));
+      this._downloadRecordsConcurrent();
+    });
+  }
+  /**
+   * Process pending downloads with concurrency control.
+   * Downloads multiple files in parallel based on downloadConfig.concurrency.
+   * Enforces cache size limits after each batch completes.
+   */
+  async _downloadRecordsConcurrent() {
+    if (!this.options.downloadAttachments || this.downloading || this._disposed) {
+      return;
+    }
+    this.downloading = true;
+    const concurrency = this.downloadConfig.concurrency;
+    const hasMaxSize = this.cacheConfig.maxSize !== Number.MAX_SAFE_INTEGER;
+    try {
+      while (this.downloadQueue.size > 0 && !this._disposed) {
+        if (hasMaxSize) {
+          const nearCapacity = await isCacheNearCapacity(this._getCacheManagerDeps());
+          if (nearCapacity) {
+            this.polLogger?.warn?.(`[PolAttachmentQueue] Cache at ${Math.round(this.cacheConfig.downloadStopThreshold * 100)}% capacity, pausing downloads`);
+            break;
+          }
+        }
+        const batch = [];
+        for (const id of this.downloadQueue) {
+          batch.push(id);
+          if (batch.length >= concurrency) break;
+        }
+        if (batch.length === 0) break;
+        batch.forEach((id) => this.downloadQueue.delete(id));
+        const downloadPromises = batch.map(async (id) => {
+          try {
+            const record = await this.record(id);
+            if (record && record.state !== AttachmentState6.SYNCED) {
+              await this.downloadRecord(record);
+            }
+          } catch (err) {
+            this.polLogger?.warn?.(`[PolAttachmentQueue] Download failed for ${id}:`, err);
+          }
+        });
+        await Promise.all(downloadPromises);
+        if (hasMaxSize) {
+          await enforceCacheLimit(this._getCacheManagerDeps());
+        }
+      }
+    } finally {
+      this.downloading = false;
+    }
+  }
+  async uploadAttachment(record) {
+    throw new Error(`uploadAttachment() is disabled in PolAttachmentQueue. Use queueUpload() for uploads. Record ID: ${record.id}`);
+  }
+  async watchAttachmentIds() {
+    this.onAttachmentIdsChange(async (ids) => {
+      const generation = ++this._watchGeneration;
+      this.polLogger?.debug?.(`[PolAttachmentQueue] Received ${ids.length} attachment IDs from watch`);
+      let filteredIds = ids;
+      let skippedIds = [];
+      if (this.source.skipDownload && ids.length > 0) {
+        try {
+          const context = {
+            ids,
+            db: this.powersync
+          };
+          skippedIds = await this.source.skipDownload(context);
+          if (generation !== this._watchGeneration) {
+            this.polLogger?.debug?.("[PolAttachmentQueue] Stale watch callback, ignoring");
+            return;
+          }
+          const skipSet = new Set(skippedIds);
+          filteredIds = ids.filter((id) => !skipSet.has(id));
+          this.polLogger?.info?.(`[PolAttachmentQueue] Pre-filtered: ${ids.length} total, ${skippedIds.length} skipped, ${filteredIds.length} to sync`);
+        } catch (error) {
+          this.polLogger?.warn?.("[PolAttachmentQueue] skipDownload filter failed, using all IDs:", error);
+          filteredIds = ids;
+          skippedIds = [];
+        }
+      }
+      this.polLogger?.debug?.(`[PolAttachmentQueue] Syncing attachment IDs: [${filteredIds.length} items]`);
+      if (this.initialSync) {
+        this.initialSync = false;
+        if (filteredIds.length > 0) {
+          const placeholders = filteredIds.map(() => "?").join(",");
+          await this.powersync.execute(`UPDATE ${this.table}
+             SET state = ${AttachmentState6.QUEUED_SYNC}
+             WHERE state < ${AttachmentState6.SYNCED}
+               AND state NOT IN (${AttachmentState6.QUEUED_UPLOAD}, ${5 /* FAILED_PERMANENT */}, ${6 /* DOWNLOAD_SKIPPED */})
+               AND id IN (${placeholders})`, filteredIds);
+        }
+      }
+      const attachmentsInDatabase = await this.powersync.getAll(`SELECT * FROM ${this.table} WHERE state < ${AttachmentState6.ARCHIVED}`);
+      for (const id of filteredIds) {
+        const record = attachmentsInDatabase.find((r) => r.id === id);
+        if (!record) {
+          const newRecord = await this.newAttachmentRecord({
+            id,
+            state: AttachmentState6.QUEUED_SYNC
+          });
+          await this.saveToQueue(newRecord);
+          continue;
+        }
+        if (PROTECTED_UPLOAD_STATES.has(record.state)) continue;
+        if (record.upload_source_uri) continue;
+        if (record.state === 6 /* DOWNLOAD_SKIPPED */) continue;
+        if (record.local_uri == null || !await this.storage.fileExists(this.getLocalUri(record.local_uri))) {
+          await this.update({
+            ...record,
+            state: AttachmentState6.QUEUED_DOWNLOAD
+          });
+        }
+      }
+      if (skippedIds.length > 0) {
+        const placeholders = skippedIds.map(() => "?").join(",");
+        await this.powersync.execute(`UPDATE ${this.table}
+           SET state = ${6 /* DOWNLOAD_SKIPPED */}
+           WHERE id IN (${placeholders})
+             AND state NOT IN (${AttachmentState6.QUEUED_UPLOAD}, ${5 /* FAILED_PERMANENT */}, ${AttachmentState6.SYNCED})`, skippedIds);
+      }
+      const allValidIds = [.../* @__PURE__ */ new Set([...filteredIds, ...skippedIds])];
+      if (allValidIds.length > 0) {
+        const placeholders = allValidIds.map(() => "?").join(",");
+        await this.powersync.execute(`UPDATE ${this.table}
+           SET state = ${AttachmentState6.ARCHIVED}
+           WHERE state < ${AttachmentState6.ARCHIVED}
+             AND state NOT IN (${AttachmentState6.QUEUED_UPLOAD}, ${5 /* FAILED_PERMANENT */})
+             AND upload_source_uri IS NULL
+             AND id NOT IN (${placeholders})`, allValidIds);
+      }
+      this._invalidateStatsCache();
+      this._notify(true);
+    });
+  }
+  async saveToQueue(record) {
+    const updatedRecord = {
+      ...record,
+      timestamp: Date.now()
+    };
+    const existing = await this.powersync.getOptional(`SELECT id, timestamp, filename, local_uri, media_type, size, state FROM ${this.table} WHERE id = ?`, [record.id]);
+    if (existing && PROTECTED_UPLOAD_STATES.has(existing.state)) {
+      return existing;
+    }
+    await this.powersync.execute(`INSERT INTO ${this.table} (id, timestamp, filename, local_uri, media_type, size, state)
+       VALUES (?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         timestamp = excluded.timestamp,
+         filename = excluded.filename,
+         local_uri = COALESCE(excluded.local_uri, local_uri),
+         media_type = COALESCE(excluded.media_type, media_type),
+         size = COALESCE(excluded.size, size),
+         state = CASE
+           WHEN state IN (${AttachmentState6.QUEUED_UPLOAD}, ${5 /* FAILED_PERMANENT */})
+           THEN state
+           ELSE excluded.state
+         END`, [updatedRecord.id, updatedRecord.timestamp, updatedRecord.filename, updatedRecord.local_uri || null, updatedRecord.media_type || null, updatedRecord.size || null, updatedRecord.state]);
+    return updatedRecord;
+  }
+  // ─── Abstract Method Implementations ───────────────────────────────────────
+  onAttachmentIdsChange(onUpdate) {
+    this._watchMutex = this._watchMutex.then(async () => {
+      if (this._disposed) return;
+      if (this._watchIdsCleanup) {
+        try {
+          this._watchIdsCleanup();
+        } catch (error) {
+          this.polLogger?.warn?.("[PolAttachmentQueue] Watch cleanup failed:", error);
+        }
+        this._watchIdsCleanup = void 0;
+      }
+      try {
+        const cleanup = this.source.watchIds(this.powersync, onUpdate);
+        if (typeof cleanup === "function") {
+          this._watchIdsCleanup = cleanup;
+        }
+      } catch (error) {
+        this.polLogger?.warn?.("[PolAttachmentQueue] watchIds failed:", error);
+      }
+    }).catch((err) => {
+      this.polLogger?.warn?.("[PolAttachmentQueue] Watch mutex error:", err);
+    });
+  }
+  async downloadRecord(record) {
+    return downloadRecord(this._getDownloadManagerDeps(), record);
+  }
+  async newAttachmentRecord(record) {
+    if (!record?.id) {
+      throw new Error("[PolAttachmentQueue] newAttachmentRecord requires a non-empty record.id");
+    }
+    return {
+      id: record.id,
+      filename: record.filename ?? record.id,
+      state: record.state ?? AttachmentState6.QUEUED_SYNC,
+      local_uri: record.local_uri,
+      size: record.size,
+      media_type: record.media_type,
+      timestamp: record.timestamp ?? Date.now()
+    };
+  }
+  // ─── Lifecycle ─────────────────────────────────────────────────────────────
+  async init() {
+    await this._createTableIfNotExists();
+    await super.init();
+    this._initialized = true;
+    await this._migrateUploadColumns();
+    if (this.uploadHandler && !this._uploadState.paused) {
+      this._startUploadProcessing();
+    }
+    this.repairAttachmentSizes().catch((err) => {
+      this.polLogger.warn("[PolAttachmentQueue] Failed to repair attachment sizes:", err);
+    });
+    this.platform.network.isConnected().then(async (isConnected) => {
+      if (isConnected && !this._disposed) {
+        const resetCount = await this.resetUploadRetries();
+        if (resetCount > 0) {
+          this.polLogger.info(`[PolAttachmentQueue] Reset ${resetCount} upload retries on startup (network connected)`);
+        }
+      }
+    }).catch((err) => {
+      this.polLogger.warn("[PolAttachmentQueue] Failed to check network connectivity on startup:", err);
+    });
+    this._networkListenerCleanup = this.platform.network.addConnectionListener(async (isConnected) => {
+      const wasConnected = this._wasConnected;
+      this._wasConnected = isConnected;
+      if (this._disposed) return;
+      const isReconnection = wasConnected === false && isConnected === true;
+      if (!isConnected) {
+        this.polLogger.debug?.("[PolAttachmentQueue] Network disconnected");
+        return;
+      }
+      if (isReconnection) {
+        this.polLogger.info("[PolAttachmentQueue] Network reconnected, triggering upload/download retry");
+      } else if (wasConnected === null) {
+        this.polLogger.debug?.("[PolAttachmentQueue] Initial network state: connected");
+        return;
+      } else {
+        this.polLogger.debug?.("[PolAttachmentQueue] Network still connected");
+        return;
+      }
+      if (this.uploadHandler) {
+        await this.retryUploads();
+      }
+      if (this.options.downloadAttachments && !this.downloading) {
+        const pendingDownloads = await this.powersync.getAll(`SELECT id FROM ${this.table} WHERE state IN (?, ?)`, [AttachmentState6.QUEUED_DOWNLOAD, AttachmentState6.QUEUED_SYNC]);
+        if (pendingDownloads.length > 0) {
+          this.polLogger.info(`[PolAttachmentQueue] Resuming ${pendingDownloads.length} pending downloads`);
+          pendingDownloads.forEach((r) => this.downloadQueue.add(r.id));
+          this._downloadRecordsConcurrent();
+        }
+      }
+    });
+    this.polLogger.info("[PolAttachmentQueue] Initialized");
+  }
+  /**
+   * Dispose the attachment queue and clean up resources.
+   * This method is synchronous to ensure callers don't need to await it,
+   * but it fires off async cleanup in the background for graceful shutdown.
+   */
+  dispose() {
+    this._disposed = true;
+    this._uploadState.abortController.abort();
+    if (this._watchIdsCleanup) {
+      try {
+        this._watchIdsCleanup();
+      } catch (error) {
+        this.polLogger?.warn?.("[PolAttachmentQueue] watchIds cleanup failed:", error);
+      }
+      this._watchIdsCleanup = void 0;
+    }
+    if (this._networkListenerCleanup) {
+      try {
+        this._networkListenerCleanup();
+      } catch (error) {
+        this.polLogger?.warn?.("[PolAttachmentQueue] network listener cleanup failed:", error);
+      }
+      this._networkListenerCleanup = void 0;
+    }
+    if (this._notifyTimer) {
+      clearTimeout(this._notifyTimer);
+      this._notifyTimer = null;
+    }
+    this._progressCallbacks.clear();
+    this._uploadState.activeUploads.clear();
+    const parentProto = Object.getPrototypeOf(Object.getPrototypeOf(this));
+    if (parentProto && typeof parentProto.dispose === "function") {
+      parentProto.dispose.call(this);
+    }
+    this._asyncCleanup().catch((err) => {
+      this.polLogger?.warn?.("[PolAttachmentQueue] Async cleanup failed:", err);
+    });
+  }
+  /**
+   * Async cleanup that runs in the background after dispose().
+   * Waits for active upload promises to settle gracefully.
+   */
+  async _asyncCleanup() {
+    if (this._uploadState.activePromises.size > 0) {
+      this.polLogger?.debug?.(`[PolAttachmentQueue] Waiting for ${this._uploadState.activePromises.size} active uploads to finish`);
+      await Promise.allSettled([...this._uploadState.activePromises]);
+    }
+    this._uploadState.activePromises.clear();
+  }
+  // ─── Upload API ────────────────────────────────────────────────────────────
+  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.");
+    }
+    const managedUri = await copyToManagedCache(this.platform, this.polLogger, options.sourceUri, options.storagePath);
+    const fileInfo = await this.platform.fileSystem.getFileInfo(managedUri);
+    const size = fileInfo?.exists ? fileInfo.size : 0;
+    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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [options.storagePath, options.filename, options.mediaType, AttachmentState6.QUEUED_UPLOAD, null, size, Date.now(), managedUri, 0, Date.now(), options.metadata ? JSON.stringify(options.metadata) : null, options.bucketId || null]);
+    this.polLogger.info(`[PolAttachmentQueue] Queued upload: ${options.storagePath}`);
+    if (!this._uploadState.paused && !this._uploadState.processing) {
+      this._startUploadProcessing();
+    }
+    this._notify(true);
+  }
+  async getPendingUploads() {
+    return getPendingUploads(this.powersync, this.table);
+  }
+  async getSoonestRetryTime() {
+    return getSoonestRetryTime(this.powersync, this.table);
+  }
+  async getFailedPermanentUploads() {
+    return getFailedPermanentUploads(this.powersync, this.table);
+  }
+  async getStaleUploads() {
+    return getStaleUploads(this.powersync, this.table, this.uploadConfig.staleDaysThreshold);
+  }
+  async getSyncedUploadsWithPendingCallback() {
+    return getSyncedUploadsWithPendingCallback(this.powersync, this.table);
+  }
+  async clearUploadCallback(id) {
+    const record = await this.record(id);
+    if (!record) return;
+    const polRecord = record;
+    await clearUploadCallback(this.powersync, this.table, id, polRecord.upload_metadata);
+  }
+  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 = ?`, [AttachmentState6.QUEUED_UPLOAD, Date.now(), id]);
+    if (!this._uploadState.paused && !this._uploadState.processing) {
+      this._startUploadProcessing();
+    }
+    this._notify(true);
+  }
+  /**
+   * Reset all uploads in QUEUED_UPLOAD state so they retry immediately.
+   * This clears retry counts and errors, allowing uploads to be retried fresh.
+   *
+   * @returns The number of uploads that were reset
+   */
+  async resetUploadRetries() {
+    const result = await this.powersync.execute(`UPDATE ${this.table}
+       SET upload_retry_count = 0,
+           upload_next_retry_at = ?,
+           upload_error = NULL
+       WHERE state = ?`, [Date.now(), AttachmentState6.QUEUED_UPLOAD]);
+    const resetCount = result.rowsAffected ?? 0;
+    if (resetCount > 0) {
+      this.polLogger.info(`[PolAttachmentQueue] Reset ${resetCount} upload retries`);
+      if (!this._uploadState.paused && !this._uploadState.processing) {
+        this._startUploadProcessing();
+      }
+      this._notify(true);
+    }
+    return resetCount;
+  }
+  /**
+   * Trigger immediate retry of uploads WITHOUT resetting their retry count.
+   * This preserves backoff state for truly failing uploads while allowing
+   * uploads that were waiting for network to retry immediately.
+   *
+   * Only affects uploads that:
+   * - Are past their retry time (upload_next_retry_at <= now), OR
+   * - Have no retry time set (upload_next_retry_at IS NULL)
+   *
+   * @returns The number of uploads that will be retried
+   */
+  async retryUploads() {
+    const now = Date.now();
+    const result = await this.powersync.execute(`UPDATE ${this.table}
+       SET upload_next_retry_at = ?
+       WHERE state = ?
+         AND (upload_next_retry_at IS NULL OR upload_next_retry_at <= ?)`, [now, AttachmentState6.QUEUED_UPLOAD, now]);
+    const retryCount = result.rowsAffected ?? 0;
+    if (retryCount > 0) {
+      this.polLogger.info(`[PolAttachmentQueue] Triggering retry for ${retryCount} uploads`);
+      if (!this._uploadState.paused && !this._uploadState.processing) {
+        this._startUploadProcessing();
+      }
+      this._notify(true);
+    } else {
+      this.polLogger.debug?.("[PolAttachmentQueue] No uploads eligible for immediate retry");
+    }
+    return retryCount;
+  }
+  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);
+  }
+  /**
+   * Re-queue an upload for an orphaned attachment.
+   * Use this when a database record exists with a storagePath but the file was never uploaded.
+   *
+   * This handles the case where:
+   * - User took a photo and the database record was created with a storagePath
+   * - The attachment queue record was created but disappeared before upload completed
+   * - The photo shows locally but was never uploaded to storage
+   *
+   * @param options.storagePath - The storage path (e.g., "projectId/fileId.jpg")
+   * @param options.localFileUri - URI to the local file to upload
+   * @param options.mediaType - MIME type of the file
+   * @param options.bucketId - Optional bucket ID for multi-bucket setups
+   * @returns true if upload was queued, false if already exists in valid state
+   */
+  async requeueOrphanedUpload(options) {
+    const {
+      storagePath,
+      localFileUri,
+      mediaType,
+      bucketId
+    } = options;
+    this.polLogger.info(`[PolAttachmentQueue] requeueOrphanedUpload called for: ${storagePath}`);
+    if (!this.uploadHandler) {
+      this.polLogger.warn("[PolAttachmentQueue] requeueOrphanedUpload: No upload handler configured");
+      throw new Error("[PolAttachmentQueue] Upload not configured. Provide uploadHandler in options.");
+    }
+    if (!this._initialized) {
+      this.polLogger.warn("[PolAttachmentQueue] requeueOrphanedUpload: Queue not initialized");
+      throw new Error("[PolAttachmentQueue] Queue not initialized. Call init() first.");
+    }
+    const existingRecord = await this.powersync.getOptional(`SELECT id, state, upload_source_uri FROM ${this.table} WHERE id = ?`, [storagePath]);
+    if (existingRecord) {
+      this.polLogger.debug(`[PolAttachmentQueue] requeueOrphanedUpload: Found existing record with state=${existingRecord.state}`);
+      if (existingRecord.state === AttachmentState6.QUEUED_UPLOAD) {
+        this.polLogger.info(`[PolAttachmentQueue] requeueOrphanedUpload: Already QUEUED_UPLOAD, skipping: ${storagePath}`);
+        return false;
+      }
+      if (existingRecord.state === 5 /* FAILED_PERMANENT */) {
+        this.polLogger.info(`[PolAttachmentQueue] requeueOrphanedUpload: Already FAILED_PERMANENT, skipping: ${storagePath}`);
+        return false;
+      }
+      if (existingRecord.state === AttachmentState6.SYNCED) {
+        this.polLogger.info(`[PolAttachmentQueue] requeueOrphanedUpload: Already SYNCED, skipping: ${storagePath}`);
+        return false;
+      }
+      this.polLogger.info(`[PolAttachmentQueue] requeueOrphanedUpload: Existing record in state=${existingRecord.state}, will re-queue`);
+    } else {
+      this.polLogger.info(`[PolAttachmentQueue] requeueOrphanedUpload: No existing record found, will create new`);
+    }
+    const fileInfo = await this.platform.fileSystem.getFileInfo(localFileUri);
+    if (!fileInfo?.exists) {
+      this.polLogger.error(`[PolAttachmentQueue] requeueOrphanedUpload: Source file not found: ${localFileUri}`);
+      throw new Error(`Source file not found: ${localFileUri}`);
+    }
+    this.polLogger.debug(`[PolAttachmentQueue] requeueOrphanedUpload: Source file exists, size=${fileInfo.size}`);
+    const managedUri = await copyToManagedCache(this.platform, this.polLogger, localFileUri, storagePath);
+    this.polLogger.debug(`[PolAttachmentQueue] requeueOrphanedUpload: Copied to managed cache: ${managedUri}`);
+    const managedFileInfo = await this.platform.fileSystem.getFileInfo(managedUri);
+    const size = managedFileInfo?.exists ? managedFileInfo.size : fileInfo.size;
+    const filename = storagePath.split("/").pop() || storagePath;
+    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, upload_error, upload_error_code)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+      storagePath,
+      filename,
+      mediaType,
+      AttachmentState6.QUEUED_UPLOAD,
+      null,
+      size,
+      Date.now(),
+      managedUri,
+      0,
+      // Reset retry count
+      Date.now(),
+      // Can retry immediately
+      null,
+      // No metadata
+      bucketId || null,
+      null,
+      // Clear any previous error
+      null
+    ]);
+    this.polLogger.info(`[PolAttachmentQueue] requeueOrphanedUpload: Queued upload: ${storagePath}`);
+    if (!this._uploadState.paused && !this._uploadState.processing) {
+      this._startUploadProcessing();
+    }
+    this._notify(true);
+    return true;
+  }
+  // Compatibility aliases
+  async getRecord(id) {
+    return await this.record(id);
+  }
+  async getFailedUploads() {
+    return this.getFailedPermanentUploads();
+  }
+  async retryFailedUpload(id) {
+    return this.retryUpload(id);
+  }
+  async deleteFailedUpload(id) {
+    return this.deleteUpload(id);
+  }
+  get activeUploads() {
+    return [...this._uploadState.activeUploads.values()];
+  }
+  pauseUploads() {
+    this.polLogger.info("[PolAttachmentQueue] Pausing uploads");
+    this._uploadState.paused = true;
+    this._uploadState.abortController.abort();
+    this._uploadState.abortController = new AbortController();
+    this._notify(true);
+  }
+  resumeUploads() {
+    this.polLogger.info("[PolAttachmentQueue] Resuming uploads");
+    this._uploadState.paused = false;
+    this._uploadState.abortController = new AbortController();
+    if (!this._uploadState.processing) {
+      this._startUploadProcessing();
+    }
+    this._notify(true);
+  }
+  // ─── Cache API ─────────────────────────────────────────────────────────────
+  async clearCache() {
+    return clearCache(this._getCacheManagerDeps());
+  }
+  async cacheLocalFile(storagePath, sourceUri) {
+    return cacheLocalFile(this._getCacheManagerDeps(), storagePath, sourceUri);
+  }
+  async getLocalUriForStoragePath(storagePath) {
+    return getLocalUriForStoragePath(this._getCacheManagerDeps(), storagePath, this.storage);
+  }
+  /**
+   * Purge attachments by their IDs.
+   * Archives and deletes local files for the specified attachment IDs.
+   * Useful for edge cases where external code needs to force-remove attachments.
+   *
+   * @param ids - Array of attachment IDs to purge
+   */
+  async purgeAttachments(ids) {
+    if (ids.length === 0) return;
+    const placeholders = ids.map(() => "?").join(",");
+    const records = await this.powersync.getAll(`SELECT id, local_uri FROM ${this.table} WHERE id IN (${placeholders})`, ids);
+    for (const record of records) {
+      if (record.local_uri) {
+        try {
+          await this.platform.fileSystem.deleteFile(this.getLocalUri(record.local_uri));
+        } catch {
+        }
+      }
+    }
+    await this.powersync.execute(`UPDATE ${this.table}
+       SET state = ${AttachmentState6.ARCHIVED}
+       WHERE id IN (${placeholders})`, ids);
+    this._invalidateStatsCache();
+    this._notify(true);
+    this.polLogger.info(`[PolAttachmentQueue] Purged ${ids.length} attachments`);
+  }
+  // ─── Progress Subscription ─────────────────────────────────────────────────
+  onProgress(callback) {
+    this._progressCallbacks.add(callback);
+    this._notify(true);
+    return () => {
+      this._progressCallbacks.delete(callback);
+    };
+  }
+  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._uploadState.paused,
+        isProcessing: this.uploading || this.downloading || this._uploadState.processing,
+        // TODO: activeDownloads tracking not yet implemented - downloads are handled by
+        // the parent AbstractAttachmentQueue which doesn't expose per-download progress.
+        // For now, return empty array. Future: implement download tracking similar to uploads.
+        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, syncedSize = 0, pending = 0, pendingUpload = 0, failedPermanent = 0, skippedDownloadCount = 0;
+    for (const r of rows) {
+      if (r.state === AttachmentState6.SYNCED) {
+        synced = r.cnt;
+        syncedSize = r.sz;
+      }
+      if (r.state === AttachmentState6.QUEUED_DOWNLOAD || r.state === AttachmentState6.QUEUED_SYNC) pending += r.cnt;
+      if (r.state === AttachmentState6.QUEUED_UPLOAD) pendingUpload = r.cnt;
+      if (r.state === 5 /* FAILED_PERMANENT */) failedPermanent = r.cnt;
+      if (r.state === 6 /* DOWNLOAD_SKIPPED */) skippedDownloadCount = 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._uploadState.paused,
+      isProcessing: this.uploading || this.downloading || this._uploadState.processing,
+      // TODO: activeDownloads tracking not yet implemented - downloads are handled by
+      // the parent AbstractAttachmentQueue which doesn't expose per-download progress.
+      // For now, return empty array. Future: implement download tracking similar to uploads.
+      activeDownloads: [],
+      pendingUploadCount: pendingUpload,
+      failedPermanentCount: failedPermanent,
+      staleUploadCount: staleUploads.length,
+      activeUploads: this.activeUploads,
+      skippedDownloadCount
+    };
+    this._cachedStats = stats;
+    this._cachedStatsTimestamp = now;
+    return stats;
+  }
+  /**
+   * Repair attachment sizes for synced records that have size=0.
+   * This backfills sizes from the actual file system for existing downloads.
+   * @returns Number of records repaired
+   */
+  async repairAttachmentSizes() {
+    const records = await this.powersync.getAll(`SELECT id, local_uri FROM ${this.table} WHERE state = ? AND (size IS NULL OR size = 0) AND local_uri IS NOT NULL`, [AttachmentState6.SYNCED]);
+    let repaired = 0;
+    for (const record of records) {
+      if (!record.local_uri) continue;
+      const localUri = this.getLocalUri(record.local_uri);
+      const fileInfo = await this.platform.fileSystem.getFileInfo(localUri);
+      if (fileInfo?.exists && fileInfo.size && fileInfo.size > 0) {
+        await this.powersync.execute(`UPDATE ${this.table} SET size = ? WHERE id = ?`, [fileInfo.size, record.id]);
+        repaired++;
+      }
+    }
+    if (repaired > 0) {
+      this._invalidateStatsCache();
+      this._notify(true);
+      this.polLogger.info(`[PolAttachmentQueue] Repaired sizes for ${repaired} attachments`);
+    }
+    return repaired;
+  }
+  // ─── Private Helpers ───────────────────────────────────────────────────────
+  _getDownloadManagerDeps() {
+    return {
+      powersync: this.powersync,
+      platform: this.platform,
+      logger: this.polLogger,
+      remoteStorage: this.remoteStorage,
+      storage: this.storage,
+      tableName: this.table,
+      getLocalUri: (p) => this.getLocalUri(p),
+      getLocalFilePathSuffix: (f) => this.getLocalFilePathSuffix(f),
+      update: (r) => this.update(r),
+      downloadAttachments: this.options.downloadAttachments,
+      onDownloadError: this.options.onDownloadError,
+      notify: (imm) => this._notify(imm),
+      invalidateStatsCache: () => this._invalidateStatsCache()
+    };
+  }
+  _getUploadManagerDeps() {
+    return {
+      powersync: this.powersync,
+      platform: this.platform,
+      logger: this.polLogger,
+      tableName: this.table,
+      uploadHandler: this.uploadHandler,
+      uploadConfig: this.uploadConfig,
+      onUploadComplete: this.options.onUploadComplete,
+      onUploadFailed: this.options.onUploadFailed,
+      notify: (imm) => this._notify(imm)
+    };
+  }
+  _getCacheManagerDeps() {
+    return {
+      powersync: this.powersync,
+      platform: this.platform,
+      logger: this.polLogger,
+      tableName: this.table,
+      cacheConfig: this.cacheConfig,
+      getLocalUri: (p) => this.getLocalUri(p),
+      notify: (imm) => this._notify(imm),
+      invalidateStatsCache: () => this._invalidateStatsCache()
+    };
+  }
+  async _startUploadProcessing() {
+    const deps = this._getUploadManagerDeps();
+    await startUploadProcessing(deps, this._uploadState);
+  }
+  async _createTableIfNotExists() {
+    const result = await this.powersync.getOptional(`SELECT name FROM sqlite_master WHERE type='table' AND name=?`, [this.table]);
+    if (result) return;
+    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
+      )
+    `);
+  }
+  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)) {
+        await this.powersync.execute(`ALTER TABLE ${this.table} ADD COLUMN ${col.name} ${col.type}`);
+      }
+    }
+  }
+  _invalidateStatsCache() {
+    this._cachedStats = null;
+    this._cachedStatsTimestamp = 0;
+  }
+  _getStatus(_pendingCount) {
+    if (this.uploading || this.downloading || this._uploadState.processing) return "syncing";
+    if (this._uploadState.paused) return "paused";
+    return "complete";
+  }
+  _notify(forceImmediate = false) {
+    if (this._disposed) return;
+    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) => {
+      if (this._disposed) return;
+      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) => {
+        if (this._disposed) return;
+        this.polLogger.warn("[PolAttachmentQueue] Stats error:", err);
+      });
+    } else {
+      const delay = NOTIFY_THROTTLE_MS - timeSinceLastNotify;
+      this._notifyTimer = setTimeout(() => {
+        if (this._disposed) return;
+        this._notifyTimer = null;
+        this._lastNotifyTime = Date.now();
+        this.getStats().then(notifyAll).catch((err) => {
+          if (this._disposed) return;
+          this.polLogger.warn("[PolAttachmentQueue] Stats error:", err);
+        });
+      }, delay);
+    }
+  }
+};
+function createPolAttachmentQueue(powersync, platform, config) {
+  return new PolAttachmentQueue({
+    powersync,
+    storage: void 0,
+    platform,
+    remoteStorage: config.remoteStorage,
+    source: {
+      bucket: config.bucket,
+      watchIds: config.watchIds,
+      skipDownload: config.skipDownload
+    },
+    attachmentDirectoryName: "attachments",
+    attachmentTableName: "attachments",
+    performInitialSync: true,
+    downloadAttachments: true,
+    uploadHandler: config.uploadHandler,
+    uploadConfig: config.uploadConfig,
+    downloadConfig: config.downloadConfig ?? config.download,
+    onUploadComplete: config.onUploadComplete ? async (record) => config.onUploadComplete(record) : void 0,
+    onUploadFailed: config.onUploadFailed,
+    compression: config.compression,
+    cache: config.cache ? {
+      maxSize: config.maxCacheBytes,
+      ...config.cache
+    } : config.maxCacheBytes ? {
+      maxSize: config.maxCacheBytes
+    } : void 0
+  });
+}
+
+export {
+  PolStorageAdapter,
+  PolAttachmentState,
+  DEFAULT_COMPRESSION_CONFIG,
+  DEFAULT_UPLOAD_CONFIG,
+  DEFAULT_DOWNLOAD_CONFIG,
+  DEFAULT_CACHE_CONFIG,
+  CACHE_SIZE_PRESETS,
+  formatCacheSize,
+  ATTACHMENT_TABLE,
+  AttachmentState,
+  AttachmentTable,
+  EncodingType2 as EncodingType,
+  AbstractAttachmentQueue,
+  DEFAULT_ATTACHMENT_QUEUE_OPTIONS,
+  PROTECTED_UPLOAD_STATES,
+  PENDING_DOWNLOAD_STATES,
+  LOCALLY_AVAILABLE_STATES,
+  isProtectedUploadState,
+  isPendingDownloadState,
+  isLocallyAvailable,
+  isStateTransitionAllowed,
+  determineAttachmentState,
+  validateSqlIdentifier,
+  getProtectedStatesInClause,
+  getExcludeProtectedStatesCondition,
+  getMimeType,
+  getMimeTypeFromPath,
+  isImageMimeType,
+  isVideoMimeType,
+  isAudioMimeType,
+  isDocumentMimeType,
+  getExtensionFromMimeType,
+  blobToArrayBuffer,
+  downloadRecord,
+  isPermanentError,
+  extractErrorCode,
+  getPendingUploads,
+  getSoonestRetryTime,
+  getFailedPermanentUploads,
+  getStaleUploads,
+  getSyncedUploadsWithPendingCallback,
+  clearUploadCallback,
+  markUploadSynced,
+  markUploadPermanentFailure,
+  scheduleUploadRetry,
+  uploadOne,
+  startUploadProcessing,
+  createUploadManagerState,
+  createUploadManagerDeps,
+  ensureFileUri,
+  stripFileUri,
+  getCachedSize,
+  getEvictionCandidates,
+  enforceCacheLimit,
+  isCacheNearCapacity,
+  clearCache,
+  cacheLocalFile,
+  getLocalUriForStoragePath,
+  copyToManagedCache,
+  createCacheManagerDeps,
+  PolAttachmentQueue,
+  createPolAttachmentQueue
+};
+//# sourceMappingURL=chunk-4TXTAEF2.js.map