@pol-studios/powersync 1.0.6 → 1.0.10

package/dist/{chunk-62J2DPKX.js → chunk-KN2IZERF.js}

@@ -1,9 +1,10 @@
 import {
-  failedUploadStore
-} from "./chunk-PAFBKNL3.js";
+  withExponentialBackoff
+} from "./chunk-FV2HXEIY.js";
 import {
-  classifySupabaseError
-} from "./chunk-FPTDATY5.js";
+  classifySupabaseError,
+  isRlsError
+} from "./chunk-VACPAAQZ.js";
 
 // src/connector/types.ts
 var defaultSchemaRouter = () => "public";
@@ -11,18 +12,70 @@ var DEFAULT_RETRY_CONFIG = {
   transient: {
     maxRetries: 3,
     baseDelayMs: 1e3,
-    maxDelayMs: 3e4,
+    // 1 second initial delay
+    maxDelayMs: 4e3,
+    // 4 second cap
     backoffMultiplier: 2
+    // 1s → 2s → 4s
   },
   permanent: {
-    maxRetries: 2,
-    baseDelayMs: 5e3,
-    maxDelayMs: 3e5,
-    backoffMultiplier: 3
+    maxRetries: 0,
+    // No retries - permanent errors won't succeed
+    baseDelayMs: 1e3,
+    // Irrelevant with 0 retries, but needed for type
+    maxDelayMs: 1e3,
+    // Irrelevant with 0 retries
+    backoffMultiplier: 1
+    // Irrelevant with 0 retries
+  },
+  rls: {
+    maxRetries: 5,
+    // Extended retries for RLS errors
+    baseDelayMs: 3e4,
+    // 30 seconds initial delay
+    maxDelayMs: 12e4,
+    // 2 minutes max delay
+    backoffMultiplier: 2
+    // 30s → 60s → 120s → 120s → 120s
   }
 };
 
 // src/conflicts/detect.ts
+var ConflictDetectionError = class extends Error {
+  constructor(message, options) {
+    super(message);
+    this.name = "ConflictDetectionError";
+    this.cause = options?.cause;
+  }
+};
+function deepEqual(a, b, maxDepth = 10) {
+  if (a === b) return true;
+  if (typeof a === "number" && typeof b === "number") {
+    if (Number.isNaN(a) && Number.isNaN(b)) return true;
+  }
+  if (a === null || a === void 0 || b === null || b === void 0) return false;
+  if (typeof a !== typeof b) return false;
+  if (typeof a !== "object") return false;
+  if (maxDepth <= 0) {
+    console.warn("[deepEqual] Max depth reached, falling back to reference equality");
+    return a === b;
+  }
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() === b.getTime();
+  }
+  if (a instanceof Date || b instanceof Date) return false;
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) return false;
+  for (const key of keysA) {
+    if (!keysB.includes(key)) return false;
+    if (!deepEqual(a[key], b[key], maxDepth - 1)) {
+      return false;
+    }
+  }
+  return true;
+}
 var TABLE_NAME_REGEX = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
 function validateTableName(table) {
   if (!TABLE_NAME_REGEX.test(table)) {
@@ -54,14 +107,9 @@ async function detectConflicts(table, recordId, localVersion, serverVersion, pen
     ascending: false
   }).limit(20);
   if (error) {
-    console.warn("[detectConflicts] Failed to query AuditLog:", error);
-    return {
-      hasConflict: false,
-      conflicts: [],
-      nonConflictingChanges: Object.keys(filteredPendingChanges),
-      table,
-      recordId
-    };
+    throw new ConflictDetectionError(`AuditLog query failed for ${table}/${recordId}`, {
+      cause: error
+    });
   }
   const serverChanges = /* @__PURE__ */ new Map();
   for (const log of auditLogs ?? []) {
@@ -70,7 +118,7 @@ async function detectConflicts(table, recordId, localVersion, serverVersion, pen
     if (!oldRec || !newRec) continue;
     for (const [field, newValue] of Object.entries(newRec)) {
       if (ignoredFields.has(field)) continue;
-      if (oldRec[field] !== newValue && !serverChanges.has(field)) {
+      if (!deepEqual(oldRec[field], newValue) && !serverChanges.has(field)) {
         serverChanges.set(field, {
           newValue,
           changedBy: log.changeBy,
@@ -129,122 +177,64 @@ async function getLocalVersion(table, recordId, db) {
   return result?._version ?? null;
 }
 
-// src/utils/retry.ts
-var AbortError = class extends Error {
-  constructor(message = "Operation aborted") {
+// src/connector/supabase-connector.ts
+var ValidationError = class extends Error {
+  constructor(message) {
     super(message);
-    this.name = "AbortError";
-  }
-};
-var RetryExhaustedError = class extends Error {
-  /** The last error that caused the final retry to fail */
-  cause;
-  /** Total number of attempts made */
-  attempts;
-  constructor(cause, attempts) {
-    super(`Retry exhausted after ${attempts} attempt(s): ${cause.message}`);
-    this.name = "RetryExhaustedError";
-    this.cause = cause;
-    this.attempts = attempts;
+    this.name = "ValidationError";
   }
 };
-function calculateBackoffDelay(attempt, config) {
-  const {
-    baseDelayMs,
-    maxDelayMs,
-    backoffMultiplier
-  } = config;
-  const safeAttempt = Math.max(0, attempt);
-  const exponentialDelay = baseDelayMs * Math.pow(backoffMultiplier, safeAttempt);
-  return Math.min(exponentialDelay, maxDelayMs);
-}
-function addJitter(delay) {
-  const jitterFactor = 0.9 + Math.random() * 0.2;
-  return Math.round(delay * jitterFactor);
-}
-function sleep(ms, signal) {
-  return new Promise((resolve, reject) => {
-    if (signal?.aborted) {
-      reject(new AbortError());
-      return;
+function isAuthError(error) {
+  if (!error) return false;
+  if (typeof error === "object" && error !== null) {
+    const statusCode = error.status ?? error.statusCode;
+    if (statusCode === 401 || statusCode === 403) {
+      return true;
     }
-    if (ms <= 0) {
-      resolve();
-      return;
+    const code = error.code;
+    if (code === "401" || code === "403" || code === "42501") {
+      return true;
     }
-    let timeoutId;
-    const handleAbort = () => {
-      if (timeoutId !== void 0) {
-        clearTimeout(timeoutId);
-      }
-      reject(new AbortError());
-    };
-    if (signal) {
-      signal.addEventListener("abort", handleAbort, {
-        once: true
-      });
-    }
-    timeoutId = setTimeout(() => {
-      if (signal) {
-        signal.removeEventListener("abort", handleAbort);
-      }
-      resolve();
-    }, ms);
+  }
+  const message = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
+  const authPatterns = [
+    /\bjwt\s+(expired|invalid|malformed)\b/,
+    /\btoken\s+(expired|invalid|revoked)\b/,
+    /\bsession\s+(expired|invalid)\b/,
+    /\bunauthorized\s*(access|request|error)?\b/,
+    /\baccess\s+(denied|forbidden)\b/,
+    /\bnot\s+authorized\b/,
+    /\bauth(entication)?\s+(failed|error|required)\b/,
+    /\bpermission\s+denied\b/,
+    /\binvalid\s+(credentials|api[_\s]?key)\b/,
+    /\brls\b.*\bpolicy\b/,
+    /\brow[_\s]?level[_\s]?security\b/,
+    /\b42501\b/
+    // PostgreSQL insufficient privilege error code
+  ];
+  return authPatterns.some((pattern) => pattern.test(message));
+}
+function withTimeout(promise, ms, message) {
+  let timeoutId;
+  const timeoutPromise = new Promise((_, reject) => {
+    timeoutId = setTimeout(() => reject(new Error(message)), ms);
   });
+  return Promise.race([promise, timeoutPromise]).finally(() => clearTimeout(timeoutId));
 }
-var DEFAULT_BACKOFF_CONFIG = {
-  maxRetries: 3,
-  baseDelayMs: 1e3,
-  maxDelayMs: 3e4,
-  backoffMultiplier: 2
-};
-async function withExponentialBackoff(fn, config, options) {
-  const {
-    maxRetries,
-    baseDelayMs,
-    maxDelayMs,
-    backoffMultiplier
-  } = config;
-  const {
-    signal,
-    onRetry
-  } = options ?? {};
-  if (signal?.aborted) {
-    throw new AbortError();
-  }
-  const safeMaxRetries = Math.max(0, Math.floor(maxRetries));
-  const totalAttempts = safeMaxRetries + 1;
-  let lastError;
-  for (let attempt = 0; attempt < totalAttempts; attempt++) {
-    if (signal?.aborted) {
-      throw new AbortError();
-    }
-    try {
-      return await fn();
-    } catch (error) {
-      lastError = error instanceof Error ? error : new Error(String(error));
-      const isLastAttempt = attempt === totalAttempts - 1;
-      if (isLastAttempt) {
-        break;
-      }
-      if (signal?.aborted) {
-        throw new AbortError();
-      }
-      const baseDelay = calculateBackoffDelay(attempt, {
-        baseDelayMs,
-        maxDelayMs,
-        backoffMultiplier
-      });
-      const delayWithJitter = addJitter(baseDelay);
-      onRetry?.(attempt + 1, delayWithJitter, lastError);
-      await sleep(delayWithJitter, signal);
+var MAX_PAYLOAD_SIZE = 900 * 1024;
+function groupEntriesByTable(entries) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const existing = grouped.get(entry.table);
+    if (existing) {
+      existing.push(entry);
+    } else {
+      grouped.set(entry.table, [entry]);
     }
   }
-  throw new RetryExhaustedError(lastError, totalAttempts);
+  return grouped;
 }
-
-// src/connector/supabase-connector.ts
-var SupabaseConnector = class {
+var SupabaseConnector = class _SupabaseConnector {
   supabase;
   powerSyncUrl;
   schemaRouter;
@@ -267,9 +257,24 @@ var SupabaseConnector = class {
   resolvedConflicts = /* @__PURE__ */ new Map();
   // Cleanup function for resolution listener subscription
   unsubscribeResolution;
+  // Promise-based locking for version column checks to prevent duplicate queries
+  versionColumnPromises = /* @__PURE__ */ new Map();
+  // Flag to track if connector has been destroyed
+  isDestroyed = false;
   // Retry configuration
   retryConfig;
+  // Track completion failures for circuit breaker logic
+  // Maps transaction fingerprint (hash of entry IDs) to failure tracking info
+  completionFailures = /* @__PURE__ */ new Map();
+  static COMPLETION_MAX_FAILURES = 3;
+  static COMPLETION_EXTENDED_TIMEOUT_MS = 6e4;
+  // 60s timeout for retry
   autoRetryPaused = false;
+  // Per-entry cooldown tracking for failed operations
+  // Maps entry key (table:id) to the timestamp when it can be retried
+  entryCooldowns = /* @__PURE__ */ new Map();
+  static COOLDOWN_DURATION_MS = 6e4;
+  // 1 minute cooldown after exhausting retries
   constructor(options) {
     this.supabase = options.supabaseClient;
     this.powerSyncUrl = options.powerSyncUrl;
@@ -291,6 +296,10 @@ var SupabaseConnector = class {
       permanent: {
         ...DEFAULT_RETRY_CONFIG.permanent,
         ...options.retryConfig?.permanent
+      },
+      rls: {
+        ...DEFAULT_RETRY_CONFIG.rls,
+        ...options.retryConfig?.rls
       }
     };
     if (this.conflictBus) {
@@ -313,11 +322,22 @@ var SupabaseConnector = class {
    * Call this when the connector is no longer needed.
    */
   destroy() {
+    this.isDestroyed = true;
     if (this.unsubscribeResolution) {
       this.unsubscribeResolution();
       this.unsubscribeResolution = void 0;
     }
     this.resolvedConflicts.clear();
+    this.versionColumnPromises.clear();
+    this.completionFailures.clear();
+  }
+  /**
+   * Generate a fingerprint for a set of entries to track completion failures.
+   * Uses sorted entry IDs to create a consistent fingerprint regardless of order.
+   */
+  generateTransactionFingerprint(entries) {
+    const sortedIds = entries.map((e) => `${e.table}:${e.id}`).sort();
+    return sortedIds.join("|");
   }
   // ─── Retry Control Methods ─────────────────────────────────────────────────
   /**
@@ -339,113 +359,107 @@ var SupabaseConnector = class {
       console.log("[Connector] Auto-retry resumed");
     }
   }
-  /**
-   * Manually retry all failed uploads that are ready for retry.
-   * This processes entries from the failed upload store.
-   */
-  async retryFailedUploads() {
-    const retryableUploads = failedUploadStore.getRetryable();
-    if (retryableUploads.length === 0) {
-      if (__DEV__) {
-        console.log("[Connector] No failed uploads ready for retry");
-      }
-      return;
-    }
-    if (__DEV__) {
-      console.log("[Connector] Manually retrying failed uploads:", {
-        count: retryableUploads.length,
-        entries: retryableUploads.map((u) => ({
-          table: u.table,
-          id: u.id,
-          operation: u.operation
-        }))
-      });
-    }
-    for (const upload of retryableUploads) {
-      try {
-        const entry = {
-          table: upload.table,
-          op: upload.operation,
-          id: upload.id,
-          clientId: Date.now(),
-          // Synthetic clientId for retry
-          opData: upload.data
-        };
-        await this.processWithRetry(entry);
-        failedUploadStore.remove(upload.id);
-        if (__DEV__) {
-          console.log("[Connector] Retry succeeded for:", {
-            table: upload.table,
-            id: upload.id
-          });
-        }
-      } catch (error) {
-        if (__DEV__) {
-          console.log("[Connector] Retry failed again for:", {
-            table: upload.table,
-            id: upload.id,
-            error: error instanceof Error ? error.message : String(error)
-          });
-        }
-      }
-    }
-  }
-  /**
-   * Clear all failed uploads from the store.
-   * Use with caution - this discards all pending retries.
-   */
-  clearFailedUploads() {
-    failedUploadStore.clear();
-    if (__DEV__) {
-      console.log("[Connector] Failed uploads cleared");
-    }
-  }
-  /**
-   * Get all failed uploads from the store.
-   */
-  getFailedUploads() {
-    return failedUploadStore.getAll();
-  }
   // ─── Private Retry Logic ───────────────────────────────────────────────────
   /**
    * Process a single CRUD entry with exponential backoff retry.
    *
+   * This method uses a two-phase approach:
+   * 1. First attempt - try the operation to classify the error type
+   * 2. Retry phase - use the appropriate config (transient vs permanent) based on classification
+   *
+   * This fixes the issue where reassigning selectedConfig inside withExponentialBackoff's
+   * callback had no effect because the config was already destructured at call time.
+   *
    * @param entry - The CRUD entry to process
    * @throws Error if all retries exhausted (for critical failures)
    */
   async processWithRetry(entry) {
+    if (this.isDestroyed) {
+      throw new Error("Connector destroyed");
+    }
+    const entryKey = `${entry.table}:${entry.id}`;
+    const cooldownUntil = this.entryCooldowns.get(entryKey);
+    if (cooldownUntil && Date.now() < cooldownUntil) {
+      const remainingMs = cooldownUntil - Date.now();
+      if (__DEV__) {
+        console.log("[Connector] Entry in cooldown, skipping:", {
+          table: entry.table,
+          id: entry.id,
+          remainingSec: Math.round(remainingMs / 1e3)
+        });
+      }
+      throw new Error(`Entry in cooldown for ${Math.round(remainingMs / 1e3)}s`);
+    }
     const classified = {
       isPermanent: false,
       pgCode: void 0,
       userMessage: ""
     };
-    let selectedConfig = this.retryConfig.transient;
     let lastError;
     try {
-      await withExponentialBackoff(async () => {
+      await this.processCrudEntry(entry);
+      this.entryCooldowns.delete(entryKey);
+      return;
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      const classifiedError = classifySupabaseError(error);
+      classified.isPermanent = classifiedError.isPermanent;
+      classified.pgCode = classifiedError.pgCode;
+      classified.userMessage = classifiedError.userMessage;
+      if (isAuthError(error)) {
+        if (__DEV__) {
+          console.log("[Connector] Auth error detected, refreshing session before retry:", {
+            table: entry.table,
+            op: entry.op,
+            id: entry.id
+          });
+        }
         try {
+          await this.supabase.auth.refreshSession();
           await this.processCrudEntry(entry);
-        } catch (error) {
-          const classifiedError = classifySupabaseError(error);
-          classified.isPermanent = classifiedError.isPermanent;
-          classified.pgCode = classifiedError.pgCode;
-          classified.userMessage = classifiedError.userMessage;
-          if (classifiedError.isPermanent) {
-            selectedConfig = this.retryConfig.permanent;
-          }
-          lastError = error instanceof Error ? error : new Error(String(error));
-          if (__DEV__) {
-            console.log("[Connector] CRUD operation failed, will retry:", {
-              table: entry.table,
-              op: entry.op,
-              id: entry.id,
-              isPermanent: classifiedError.isPermanent,
-              pgCode: classifiedError.pgCode,
-              userMessage: classifiedError.userMessage
-            });
-          }
-          throw error;
+          this.entryCooldowns.delete(entryKey);
+          return;
+        } catch (retryError) {
+          lastError = retryError instanceof Error ? retryError : new Error(String(retryError));
+          const retriedClassification = classifySupabaseError(retryError);
+          classified.isPermanent = retriedClassification.isPermanent;
+          classified.pgCode = retriedClassification.pgCode;
+          classified.userMessage = retriedClassification.userMessage;
         }
+      }
+      if (__DEV__) {
+        console.log("[Connector] Initial attempt failed, will retry with appropriate config:", {
+          table: entry.table,
+          op: entry.op,
+          id: entry.id,
+          isPermanent: classified.isPermanent,
+          pgCode: classified.pgCode,
+          userMessage: classified.userMessage
+        });
+      }
+      this.logger?.warn("[Connector] Initial attempt failed:", {
+        table: entry.table,
+        op: entry.op,
+        id: entry.id,
+        error: lastError.message,
+        isPermanent: classified.isPermanent
+      });
+    }
+    const isRlsPermissionError = lastError && isRlsError(lastError);
+    const selectedConfig = isRlsPermissionError ? this.retryConfig.rls : classified.isPermanent ? this.retryConfig.permanent : this.retryConfig.transient;
+    if (__DEV__ && isRlsPermissionError) {
+      console.log("[Connector] RLS/permission error detected, using extended retry config:", {
+        table: entry.table,
+        op: entry.op,
+        id: entry.id,
+        maxRetries: selectedConfig.maxRetries,
+        baseDelayMs: selectedConfig.baseDelayMs,
+        maxDelayMs: selectedConfig.maxDelayMs
+      });
+    }
+    try {
+      await withExponentialBackoff(async () => {
+        await this.processCrudEntry(entry);
       }, selectedConfig, {
         onRetry: (attempt, delay, error) => {
           this.logger?.debug("[Connector] Retry attempt:", {
@@ -462,38 +476,24 @@ var SupabaseConnector = class {
               op: entry.op,
               id: entry.id,
               attempt,
+              maxRetries: selectedConfig.maxRetries,
               delayMs: delay,
               errorMessage: error.message
             });
           }
         }
       });
+      this.entryCooldowns.delete(entryKey);
     } catch (error) {
-      const finalError = lastError ?? (error instanceof Error ? error : new Error(String(error)));
+      const finalError = error instanceof Error ? error : new Error(String(error));
       const category = classified.isPermanent ? "permanent" : classified.pgCode ? "transient" : "unknown";
-      const retryConfig = classified.isPermanent ? this.retryConfig.permanent : this.retryConfig.transient;
-      const nextRetryDelay = calculateBackoffDelay(retryConfig.maxRetries, retryConfig);
-      const nextRetryAt = Date.now() + nextRetryDelay;
-      failedUploadStore.add({
-        table: entry.table,
-        operation: entry.op,
-        data: entry.opData ?? {},
-        error: {
-          message: finalError.message,
-          code: classified.pgCode,
-          category
-        },
-        retryCount: retryConfig.maxRetries,
-        lastAttempt: Date.now(),
-        nextRetryAt
-      });
       if (__DEV__) {
-        console.log("[Connector] Entry added to failed upload store:", {
+        console.log("[Connector] CRUD entry failed after retries, leaving in ps_crud:", {
           table: entry.table,
           op: entry.op,
           id: entry.id,
           category,
-          nextRetryAt: new Date(nextRetryAt).toISOString()
+          error: finalError.message
         });
       }
       this.logger?.error("[Connector] CRUD entry failed after retries:", {
@@ -501,12 +501,18 @@ var SupabaseConnector = class {
         op: entry.op,
         id: entry.id,
         error: finalError.message,
-        category,
-        nextRetryAt
+        category
       });
-      if (classified.isPermanent) {
-        throw finalError;
+      const cooldownMs = _SupabaseConnector.COOLDOWN_DURATION_MS;
+      this.entryCooldowns.set(entryKey, Date.now() + cooldownMs);
+      if (__DEV__) {
+        console.log("[Connector] Entry placed in cooldown:", {
+          table: entry.table,
+          id: entry.id,
+          cooldownSec: cooldownMs / 1e3
+        });
       }
+      throw finalError;
     }
   }
   /**
@@ -564,58 +570,33 @@ var SupabaseConnector = class {
    * 5. Applies resolution or skips entry based on handler response
    */
   async uploadData(database) {
+    if (this.isDestroyed) {
+      throw new Error("Connector destroyed - aborting upload");
+    }
     if (this.shouldUploadFn && !this.shouldUploadFn()) {
-      if (__DEV__) {
-        console.log("[Connector] Upload skipped - sync mode does not allow uploads");
-      }
-      this.logger?.debug("[Connector] Upload skipped - sync mode does not allow uploads");
-      return;
+      this.logger?.debug("[Connector] Upload blocked - not currently permitted, will retry");
+      throw new Error("Upload not permitted - will retry on next sync cycle");
     }
-    if (!this.autoRetryPaused) {
-      const retryableUploads = failedUploadStore.getRetryable();
-      if (retryableUploads.length > 0) {
-        if (__DEV__) {
-          console.log("[Connector] Processing retryable failed uploads:", {
-            count: retryableUploads.length
-          });
-        }
-        for (const upload of retryableUploads) {
-          try {
-            const entry = {
-              table: upload.table,
-              op: upload.operation,
-              id: upload.id,
-              clientId: Date.now(),
-              // Synthetic clientId for retry
-              opData: upload.data
-            };
-            await this.processWithRetry(entry);
-            failedUploadStore.remove(upload.id);
-            if (__DEV__) {
-              console.log("[Connector] Retried upload succeeded:", {
-                table: upload.table,
-                id: upload.id
-              });
-            }
-          } catch (error) {
-            if (__DEV__) {
-              console.log("[Connector] Retried upload failed again:", {
-                table: upload.table,
-                id: upload.id,
-                error: error instanceof Error ? error.message : String(error)
-              });
-            }
-          }
-        }
+    const {
+      data: {
+        session
+      },
+      error: sessionError
+    } = await this.supabase.auth.getSession();
+    if (sessionError || !session) {
+      const noSessionError = new Error("No active session - cannot upload data");
+      if (__DEV__) {
+        console.error("[Connector] uploadData failed: no session");
       }
+      throw noSessionError;
     }
     if (__DEV__) {
       console.log("[Connector] uploadData called, fetching next CRUD transaction...");
     }
     const transaction = await database.getNextCrudTransaction();
-    if (!transaction) {
+    if (!transaction || transaction.crud.length === 0) {
       if (__DEV__) {
-        console.log("[Connector] No pending CRUD transaction found");
+        console.log("[Connector] No pending CRUD transaction found or transaction is empty");
       }
       return;
     }
@@ -672,6 +653,9 @@ var SupabaseConnector = class {
             entriesDiscarded.push(entry);
             break;
           case "partial":
+            if (!existingResolution.fields || existingResolution.fields.length === 0) {
+              throw new Error("Partial resolution requires at least one field");
+            }
             const partialEntry = {
               ...entry,
               opData: this.filterFields(entry.opData ?? {}, existingResolution.fields)
@@ -726,6 +710,9 @@ var SupabaseConnector = class {
             }
             break;
           case "partial":
+            if (!resolution.fields || resolution.fields.length === 0) {
+              throw new Error("Partial resolution requires at least one field");
+            }
             const partialEntry = {
               ...entry,
               opData: this.filterFields(entry.opData ?? {}, resolution.fields)
@@ -738,7 +725,7 @@ var SupabaseConnector = class {
             break;
         }
       } else {
-        console.warn("[Connector] Conflict detected but no handler:", {
+        this.logger?.warn("[Connector] Conflict detected but no handler:", {
           table: entry.table,
           id: entry.id,
           conflicts: conflictResult.conflicts
@@ -755,7 +742,7 @@ var SupabaseConnector = class {
         });
       }
       this.onTransactionComplete?.(entriesQueuedForUI);
-      return;
+      throw new Error("Entries queued for UI resolution - retry will occur on next sync cycle");
     }
     if (entriesToProcess.length === 0 && entriesDiscarded.length > 0) {
       if (__DEV__) {
@@ -772,7 +759,6 @@ var SupabaseConnector = class {
       }
       return;
     }
-    const criticalFailures = [];
     const successfulEntries = [];
     for (const entry of entriesToProcess) {
       if (__DEV__) {
@@ -783,54 +769,77 @@ var SupabaseConnector = class {
           opData: entry.opData
         });
       }
-      try {
-        await this.processWithRetry(entry);
-        successfulEntries.push(entry);
-      } catch (error) {
-        criticalFailures.push({
-          entry,
-          error: error instanceof Error ? error : new Error(String(error))
-        });
-      }
-    }
-    if (criticalFailures.length > 0) {
-      const firstFailure = criticalFailures[0];
-      const classified = classifySupabaseError(firstFailure.error);
-      console.error("[PowerSync Connector] Critical upload failure:", {
-        errorMessage: firstFailure.error.message,
-        classified,
-        isPermanent: classified.isPermanent,
-        criticalCount: criticalFailures.length,
-        successCount: successfulEntries.length,
-        entries: criticalFailures.map((f) => ({
-          table: f.entry.table,
-          op: f.entry.op,
-          id: f.entry.id
-        }))
-      });
-      this.logger?.error("[Connector] Critical upload failure:", {
-        error: firstFailure.error,
-        classified,
-        entries: criticalFailures.map((f) => ({
-          table: f.entry.table,
-          op: f.entry.op,
-          id: f.entry.id
-        }))
-      });
-      this.onTransactionFailure?.(criticalFailures.map((f) => f.entry), firstFailure.error, classified);
-      throw firstFailure.error;
+      await this.processWithRetry(entry);
+      successfulEntries.push(entry);
     }
+    await this.finalizeTransaction({
+      transaction,
+      successfulEntries,
+      discardedEntries: entriesDiscarded,
+      partialResolutions
+    });
+  }
+  /**
+   * Finalize a transaction by completing it after all entries processed successfully.
+   * Extracted to eliminate duplication between uploadData and processTransaction.
+   *
+   * Implements circuit breaker logic for completion failures:
+   * - On first failure: retry once with extended timeout (60s)
+   * - After 3 failures for same entries: log and return without throwing
+   *   (data is safely in Supabase via idempotent upserts, preventing infinite retry loop)
+   *
+   * @param context - The finalization context containing results and transaction
+   */
+  async finalizeTransaction(context) {
+    const {
+      transaction,
+      successfulEntries,
+      discardedEntries = [],
+      partialResolutions = []
+    } = context;
     if (__DEV__) {
       console.log("[Connector] All CRUD entries processed, completing transaction...");
     }
+    const allEntries = [...successfulEntries, ...discardedEntries];
+    const fingerprint = this.generateTransactionFingerprint(allEntries);
+    const failureInfo = this.completionFailures.get(fingerprint);
+    const currentFailureCount = failureInfo?.count ?? 0;
+    if (currentFailureCount >= _SupabaseConnector.COMPLETION_MAX_FAILURES) {
+      this.logger?.warn("[Connector] Circuit breaker triggered - completion failed too many times, bypassing throw:", {
+        fingerprint: fingerprint.substring(0, 50) + "...",
+        failureCount: currentFailureCount,
+        entriesCount: allEntries.length,
+        message: "Data is safely in Supabase. Returning without throw to prevent infinite retry loop."
+      });
+      if (__DEV__) {
+        console.warn("[Connector] CIRCUIT BREAKER: Completion failed", currentFailureCount, "times. Data is in Supabase - returning without throw to break retry loop.");
+      }
+      this.completionFailures.delete(fingerprint);
+      this.onTransactionSuccess?.(successfulEntries);
+      this.onTransactionComplete?.(successfulEntries);
+      return;
+    }
     try {
-      await transaction.complete();
+      await withTimeout(transaction.complete(), 3e4, "Transaction complete timeout");
       if (__DEV__) {
         console.log("[Connector] Transaction completed successfully:", {
           entriesCount: successfulEntries.length,
-          discardedCount: entriesDiscarded.length
+          discardedCount: discardedEntries.length
         });
       }
+      this.completionFailures.delete(fingerprint);
+      for (const entry of successfulEntries) {
+        this.resolvedConflicts.delete(`${entry.table}:${entry.id}`);
+      }
+      for (const entry of discardedEntries) {
+        this.resolvedConflicts.delete(`${entry.table}:${entry.id}`);
+      }
+      if (this.resolvedConflicts.size > 100) {
+        const oldest = [...this.resolvedConflicts.keys()][0];
+        if (oldest) {
+          this.resolvedConflicts.delete(oldest);
+        }
+      }
       if (this.conflictBus && partialResolutions.length > 0) {
         for (const {
           originalConflict,
@@ -861,21 +870,62 @@ var SupabaseConnector = class {
       this.onTransactionComplete?.(successfulEntries);
     } catch (error) {
       const classified = classifySupabaseError(error);
-      console.error("[PowerSync Connector] Transaction completion FAILED:", {
+      const newFailureCount = currentFailureCount + 1;
+      this.logger?.error("[Connector] Transaction completion FAILED:", {
         errorMessage: error instanceof Error ? error.message : String(error),
-        errorKeys: error && typeof error === "object" ? Object.keys(error) : [],
-        errorObject: JSON.stringify(error, null, 2),
         classified,
         isPermanent: classified.isPermanent,
+        failureCount: newFailureCount,
+        maxFailures: _SupabaseConnector.COMPLETION_MAX_FAILURES,
         entries: successfulEntries.map((e) => ({
           table: e.table,
           op: e.op,
           id: e.id
         }))
       });
+      if (__DEV__) {
+        console.error("[Connector] Transaction completion error details:", {
+          errorKeys: error && typeof error === "object" ? Object.keys(error) : [],
+          errorObject: JSON.stringify(error, null, 2),
+          failureCount: newFailureCount
+        });
+      }
+      if (currentFailureCount === 0) {
+        if (__DEV__) {
+          console.log("[Connector] First completion failure - retrying with extended timeout (60s)...");
+        }
+        try {
+          await withTimeout(transaction.complete(), _SupabaseConnector.COMPLETION_EXTENDED_TIMEOUT_MS, "Transaction complete extended timeout");
+          if (__DEV__) {
+            console.log("[Connector] Transaction completed on extended retry");
+          }
+          this.completionFailures.delete(fingerprint);
+          this.onTransactionSuccess?.(successfulEntries);
+          this.onTransactionComplete?.(successfulEntries);
+          return;
+        } catch (retryError) {
+          if (__DEV__) {
+            console.warn("[Connector] Extended retry also failed:", {
+              error: retryError instanceof Error ? retryError.message : String(retryError)
+            });
+          }
+        }
+      }
+      this.completionFailures.set(fingerprint, {
+        count: newFailureCount,
+        lastAttempt: /* @__PURE__ */ new Date()
+      });
+      if (this.completionFailures.size > 50) {
+        const oldestKey = [...this.completionFailures.keys()][0];
+        if (oldestKey) {
+          this.completionFailures.delete(oldestKey);
+        }
+      }
       this.logger?.error("[Connector] Transaction completion error:", {
         error,
         classified,
+        failureCount: newFailureCount,
+        willRetry: newFailureCount < _SupabaseConnector.COMPLETION_MAX_FAILURES,
         entries: successfulEntries.map((e) => ({
           table: e.table,
           op: e.op,
@@ -888,106 +938,175 @@ var SupabaseConnector = class {
   }
   /**
    * Process a transaction without conflict detection.
-   * Used when conflict detection is disabled.
+   * Uses batched operations for PUT and DELETE, individual processing for PATCH.
    */
   async processTransaction(transaction, _database) {
-    const criticalFailures = [];
     const successfulEntries = [];
-    for (const entry of transaction.crud) {
-      if (__DEV__) {
-        console.log("[Connector] Processing CRUD entry with retry:", {
-          table: entry.table,
-          op: entry.op,
-          id: entry.id,
-          opData: entry.opData
-        });
+    const entriesByTable = groupEntriesByTable(transaction.crud);
+    if (__DEV__) {
+      console.log("[Connector] Processing transaction with batching:", {
+        totalEntries: transaction.crud.length,
+        tables: Array.from(entriesByTable.keys()),
+        entriesPerTable: Object.fromEntries(Array.from(entriesByTable.entries()).map(([table, entries]) => [table, {
+          total: entries.length,
+          put: entries.filter((e) => e.op === "PUT" /* PUT */).length,
+          patch: entries.filter((e) => e.op === "PATCH" /* PATCH */).length,
+          delete: entries.filter((e) => e.op === "DELETE" /* DELETE */).length
+        }]))
+      });
+    }
+    for (const [table, entries] of entriesByTable) {
+      const schema = this.schemaRouter(table);
+      const putEntries = entries.filter((e) => e.op === "PUT" /* PUT */);
+      const patchEntries = entries.filter((e) => e.op === "PATCH" /* PATCH */);
+      const deleteEntries = entries.filter((e) => e.op === "DELETE" /* DELETE */);
+      if (this.crudHandler) {
+        for (const entry of entries) {
+          await this.processWithRetry(entry);
+          successfulEntries.push(entry);
+        }
+        continue;
       }
-      try {
+      if (putEntries.length > 0) {
+        const successful = await this.processBatchedPuts(table, schema, putEntries);
+        successfulEntries.push(...successful);
+      }
+      if (deleteEntries.length > 0) {
+        const successful = await this.processBatchedDeletes(table, schema, deleteEntries);
+        successfulEntries.push(...successful);
+      }
+      for (const entry of patchEntries) {
+        if (__DEV__) {
+          console.log("[Connector] Processing PATCH entry individually:", {
+            table: entry.table,
+            op: entry.op,
+            id: entry.id,
+            opData: entry.opData
+          });
+        }
         await this.processWithRetry(entry);
         successfulEntries.push(entry);
-      } catch (error) {
-        criticalFailures.push({
-          entry,
-          error: error instanceof Error ? error : new Error(String(error))
-        });
       }
     }
-    if (criticalFailures.length > 0) {
-      const firstFailure = criticalFailures[0];
-      const classified = classifySupabaseError(firstFailure.error);
-      console.error("[PowerSync Connector] Critical upload failure:", {
-        errorMessage: firstFailure.error.message,
-        classified,
-        isPermanent: classified.isPermanent,
-        criticalCount: criticalFailures.length,
-        successCount: successfulEntries.length,
-        entries: criticalFailures.map((f) => ({
-          table: f.entry.table,
-          op: f.entry.op,
-          id: f.entry.id
-        }))
-      });
-      this.logger?.error("[Connector] Critical upload failure:", {
-        error: firstFailure.error,
-        classified,
-        entries: criticalFailures.map((f) => ({
-          table: f.entry.table,
-          op: f.entry.op,
-          id: f.entry.id
-        }))
+    await this.finalizeTransaction({
+      transaction,
+      successfulEntries
+    });
+  }
+  /**
+   * Process batched PUT (upsert) operations for a single table.
+   * Falls back to individual processing if batch fails.
+   * CRITICAL: Throws on first failure to maintain transaction atomicity.
+   * @returns Array of successfully processed entries
+   * @throws Error on first failure - keeps entire transaction in ps_crud
+   */
+  async processBatchedPuts(table, schema, entries) {
+    const successful = [];
+    if (__DEV__) {
+      console.log("[Connector] Processing batched PUTs:", {
+        schema,
+        table,
+        count: entries.length
       });
-      this.onTransactionFailure?.(criticalFailures.map((f) => f.entry), firstFailure.error, classified);
-      throw firstFailure.error;
     }
+    const rows = entries.map((entry) => ({
+      id: entry.id,
+      ...entry.opData
+    }));
+    const query = schema === "public" ? this.supabase.from(table) : this.supabase.schema(schema).from(table);
+    const {
+      error
+    } = await query.upsert(rows, {
+      onConflict: "id"
+    });
+    if (error) {
+      if (__DEV__) {
+        console.warn("[Connector] Batched PUT failed, falling back to individual processing:", {
+          schema,
+          table,
+          error: error.message
+        });
+      }
+      for (const entry of entries) {
+        await this.processWithRetry(entry);
+        successful.push(entry);
+      }
+    } else {
+      if (__DEV__) {
+        console.log("[Connector] Batched PUT successful:", {
+          schema,
+          table,
+          count: entries.length
+        });
+      }
+      successful.push(...entries);
+    }
+    return successful;
+  }
+  /**
+   * Process batched DELETE operations for a single table.
+   * Falls back to individual processing if batch fails.
+   * CRITICAL: Throws on first failure to maintain transaction atomicity.
+   * @returns Array of successfully processed entries
+   * @throws Error on first failure - keeps entire transaction in ps_crud
+   */
+  async processBatchedDeletes(table, schema, entries) {
+    const successful = [];
     if (__DEV__) {
-      console.log("[Connector] All CRUD entries processed, completing transaction...");
+      console.log("[Connector] Processing batched DELETEs:", {
+        schema,
+        table,
+        count: entries.length
+      });
     }
-    try {
-      await transaction.complete();
+    const ids = entries.map((entry) => entry.id);
+    const query = schema === "public" ? this.supabase.from(table) : this.supabase.schema(schema).from(table);
+    const {
+      error
+    } = await query.delete().in("id", ids);
+    if (error) {
       if (__DEV__) {
-        console.log("[Connector] Transaction completed successfully:", {
-          entriesCount: successfulEntries.length
+        console.warn("[Connector] Batched DELETE failed, falling back to individual processing:", {
+          schema,
+          table,
+          error: error.message
         });
       }
-      this.onTransactionSuccess?.(successfulEntries);
-      this.onTransactionComplete?.(successfulEntries);
-    } catch (error) {
-      const classified = classifySupabaseError(error);
-      console.error("[PowerSync Connector] Transaction completion FAILED:", {
-        errorMessage: error instanceof Error ? error.message : String(error),
-        errorKeys: error && typeof error === "object" ? Object.keys(error) : [],
-        errorObject: JSON.stringify(error, null, 2),
-        classified,
-        isPermanent: classified.isPermanent,
-        entries: successfulEntries.map((e) => ({
-          table: e.table,
-          op: e.op,
-          id: e.id
-        }))
-      });
-      this.logger?.error("[Connector] Transaction completion error:", {
-        error,
-        classified,
-        entries: successfulEntries.map((e) => ({
-          table: e.table,
-          op: e.op,
-          id: e.id
-        }))
-      });
-      this.onTransactionFailure?.(successfulEntries, error instanceof Error ? error : new Error(String(error)), classified);
-      throw error;
+      for (const entry of entries) {
+        await this.processWithRetry(entry);
+        successful.push(entry);
+      }
+    } else {
+      if (__DEV__) {
+        console.log("[Connector] Batched DELETE successful:", {
+          schema,
+          table,
+          count: entries.length
+        });
+      }
+      successful.push(...entries);
     }
+    return successful;
   }
   /**
    * Check if a table has a _version column (cached).
+   * P4.1: Uses Promise-based locking to prevent duplicate concurrent queries.
    */
   async checkVersionColumn(table, db) {
     if (this.versionColumnCache.has(table)) {
       return this.versionColumnCache.get(table);
     }
-    const hasVersion = await hasVersionColumn(table, db);
-    this.versionColumnCache.set(table, hasVersion);
-    return hasVersion;
+    if (!this.versionColumnPromises.has(table)) {
+      this.versionColumnPromises.set(table, hasVersionColumn(table, db).then((result) => {
+        this.versionColumnCache.set(table, result);
+        this.versionColumnPromises.delete(table);
+        return result;
+      }).catch((error) => {
+        this.versionColumnPromises.delete(table);
+        throw error;
+      }));
+    }
+    return this.versionColumnPromises.get(table);
   }
   /**
    * Filter opData to only include specified fields.
@@ -1003,12 +1122,6 @@ var SupabaseConnector = class {
     }
     return filtered;
   }
-  /**
-   * Process a single CRUD operation.
-   *
-   * UUID-native tables (public schema, post-migration) use `id` as the UUID column.
-   * Core schema tables (Profile, Comment, CommentSection) still use a separate `uuid` column.
-   */
   /**
    * Process a single CRUD operation.
    *
@@ -1018,6 +1131,16 @@ var SupabaseConnector = class {
     const table = entry.table;
     const id = entry.id;
     const schema = this.schemaRouter(table);
+    if (entry.op === "PATCH" /* PATCH */ && Object.keys(entry.opData ?? {}).length === 0) {
+      this.logger?.debug(`[Connector] Skipping empty PATCH for ${entry.table}:${entry.id}`);
+      return;
+    }
+    if (entry.opData) {
+      const payloadSize = JSON.stringify(entry.opData).length;
+      if (payloadSize > MAX_PAYLOAD_SIZE) {
+        throw new ValidationError(`Payload too large (${(payloadSize / 1024).toFixed(0)}KB > 900KB) for ${schema}.${table}`);
+      }
+    }
     if (this.crudHandler) {
       let handled = false;
       switch (entry.op) {
@@ -1164,17 +1287,11 @@ var SupabaseConnector = class {
 export {
   defaultSchemaRouter,
   DEFAULT_RETRY_CONFIG,
+  ConflictDetectionError,
   detectConflicts,
   hasVersionColumn,
   fetchServerVersion,
   getLocalVersion,
-  AbortError,
-  RetryExhaustedError,
-  calculateBackoffDelay,
-  addJitter,
-  sleep,
-  DEFAULT_BACKOFF_CONFIG,
-  withExponentialBackoff,
   SupabaseConnector
 };
-//# sourceMappingURL=chunk-62J2DPKX.js.map
+//# sourceMappingURL=chunk-KN2IZERF.js.map