@pol-studios/powersync 1.0.4 → 1.0.7

package/dist/{chunk-C2RSTGDC.js → chunk-HFOFLW5F.js}

@@ -1,11 +1,70 @@
+import {
+  withExponentialBackoff
+} from "./chunk-FV2HXEIY.js";
 import {
   classifySupabaseError
-} from "./chunk-FPTDATY5.js";
+} from "./chunk-XQAJM2MW.js";
 
 // src/connector/types.ts
 var defaultSchemaRouter = () => "public";
+var DEFAULT_RETRY_CONFIG = {
+  transient: {
+    maxRetries: 3,
+    baseDelayMs: 1e3,
+    // 1 second initial delay
+    maxDelayMs: 4e3,
+    // 4 second cap
+    backoffMultiplier: 2
+    // 1s → 2s → 4s
+  },
+  permanent: {
+    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
+  }
+};
 
 // 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)) {
@@ -37,14 +96,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 ?? []) {
@@ -53,7 +107,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,
@@ -113,6 +167,62 @@ async function getLocalVersion(table, recordId, db) {
 }
 
 // src/connector/supabase-connector.ts
+var ValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ValidationError";
+  }
+};
+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;
+    }
+    const code = error.code;
+    if (code === "401" || code === "403" || code === "42501") {
+      return true;
+    }
+  }
+  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 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]);
+    }
+  }
+  return grouped;
+}
 var SupabaseConnector = class {
   supabase;
   powerSyncUrl;
@@ -136,6 +246,13 @@ 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;
+  autoRetryPaused = false;
   constructor(options) {
     this.supabase = options.supabaseClient;
     this.powerSyncUrl = options.powerSyncUrl;
@@ -149,6 +266,16 @@ var SupabaseConnector = class {
     this.conflictDetection = options.conflictDetection;
     this.conflictHandler = options.conflictHandler;
     this.conflictBus = options.conflictBus;
+    this.retryConfig = {
+      transient: {
+        ...DEFAULT_RETRY_CONFIG.transient,
+        ...options.retryConfig?.transient
+      },
+      permanent: {
+        ...DEFAULT_RETRY_CONFIG.permanent,
+        ...options.retryConfig?.permanent
+      }
+    };
     if (this.conflictBus) {
       this.unsubscribeResolution = this.conflictBus.onResolution((table, recordId, resolution) => {
         const key = `${table}:${recordId}`;
@@ -169,11 +296,153 @@ 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();
+  }
+  // ─── Retry Control Methods ─────────────────────────────────────────────────
+  /**
+   * Pause automatic retry of failed uploads.
+   * Use this when the user goes offline intentionally or wants manual control.
+   */
+  pauseAutoRetry() {
+    this.autoRetryPaused = true;
+    if (__DEV__) {
+      console.log("[Connector] Auto-retry paused");
+    }
+  }
+  /**
+   * Resume automatic retry of failed uploads.
+   */
+  resumeAutoRetry() {
+    this.autoRetryPaused = false;
+    if (__DEV__) {
+      console.log("[Connector] Auto-retry resumed");
+    }
+  }
+  // ─── 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 classified = {
+      isPermanent: false,
+      pgCode: void 0,
+      userMessage: ""
+    };
+    let lastError;
+    try {
+      await this.processCrudEntry(entry);
+      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);
+          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 selectedConfig = classified.isPermanent ? this.retryConfig.permanent : this.retryConfig.transient;
+    try {
+      await withExponentialBackoff(async () => {
+        await this.processCrudEntry(entry);
+      }, selectedConfig, {
+        onRetry: (attempt, delay, error) => {
+          this.logger?.debug("[Connector] Retry attempt:", {
+            table: entry.table,
+            op: entry.op,
+            id: entry.id,
+            attempt,
+            delay,
+            error: error.message
+          });
+          if (__DEV__) {
+            console.log("[Connector] Retry attempt:", {
+              table: entry.table,
+              op: entry.op,
+              id: entry.id,
+              attempt,
+              maxRetries: selectedConfig.maxRetries,
+              delayMs: delay,
+              errorMessage: error.message
+            });
+          }
+        }
+      });
+    } catch (error) {
+      const finalError = error instanceof Error ? error : new Error(String(error));
+      const category = classified.isPermanent ? "permanent" : classified.pgCode ? "transient" : "unknown";
+      if (__DEV__) {
+        console.log("[Connector] CRUD entry failed after retries, leaving in ps_crud:", {
+          table: entry.table,
+          op: entry.op,
+          id: entry.id,
+          category,
+          error: finalError.message
+        });
+      }
+      this.logger?.error("[Connector] CRUD entry failed after retries:", {
+        table: entry.table,
+        op: entry.op,
+        id: entry.id,
+        error: finalError.message,
+        category
+      });
+      throw finalError;
+    }
   }
   /**
    * Set the active project IDs for scoped sync.
@@ -230,20 +499,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()) {
+      this.logger?.debug("[Connector] Upload blocked - not currently permitted, will retry");
+      throw new Error("Upload not permitted - will retry on next sync cycle");
+    }
+    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.log("[Connector] Upload skipped - sync mode does not allow uploads");
+        console.error("[Connector] uploadData failed: no session");
       }
-      this.logger?.debug("[Connector] Upload skipped - sync mode does not allow uploads");
-      return;
+      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;
     }
@@ -300,6 +582,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)
@@ -354,6 +639,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)
@@ -366,7 +654,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
@@ -383,7 +671,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__) {
@@ -400,28 +688,62 @@ var SupabaseConnector = class {
       }
       return;
     }
-    try {
-      for (const entry of entriesToProcess) {
-        if (__DEV__) {
-          console.log("[Connector] Processing CRUD entry:", {
-            table: entry.table,
-            op: entry.op,
-            id: entry.id,
-            opData: entry.opData
-          });
-        }
-        await this.processCrudEntry(entry);
-      }
+    const successfulEntries = [];
+    for (const entry of entriesToProcess) {
       if (__DEV__) {
-        console.log("[Connector] All CRUD entries processed, completing transaction...");
+        console.log("[Connector] Processing CRUD entry with retry:", {
+          table: entry.table,
+          op: entry.op,
+          id: entry.id,
+          opData: entry.opData
+        });
       }
-      await transaction.complete();
+      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.
+   *
+   * @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...");
+    }
+    try {
+      await withTimeout(transaction.complete(), 3e4, "Transaction complete timeout");
       if (__DEV__) {
         console.log("[Connector] Transaction completed successfully:", {
-          entriesCount: entriesToProcess.length,
-          discardedCount: entriesDiscarded.length
+          entriesCount: successfulEntries.length,
+          discardedCount: discardedEntries.length
         });
       }
+      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,
@@ -448,100 +770,210 @@ var SupabaseConnector = class {
           }
         }
       }
-      this.onTransactionSuccess?.(entriesToProcess);
-      this.onTransactionComplete?.(entriesToProcess);
+      this.onTransactionSuccess?.(successfulEntries);
+      this.onTransactionComplete?.(successfulEntries);
     } catch (error) {
       const classified = classifySupabaseError(error);
-      console.error("[PowerSync Connector] Upload FAILED:", {
+      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,
-        entries: entriesToProcess.map((e) => ({
+        entries: successfulEntries.map((e) => ({
           table: e.table,
           op: e.op,
           id: e.id
         }))
       });
-      this.logger?.error("[Connector] Upload error:", {
+      if (__DEV__) {
+        console.error("[Connector] Transaction completion error details:", {
+          errorKeys: error && typeof error === "object" ? Object.keys(error) : [],
+          errorObject: JSON.stringify(error, null, 2)
+        });
+      }
+      this.logger?.error("[Connector] Transaction completion error:", {
         error,
         classified,
-        entries: entriesToProcess.map((e) => ({
+        entries: successfulEntries.map((e) => ({
           table: e.table,
           op: e.op,
           id: e.id
         }))
       });
-      this.onTransactionFailure?.(entriesToProcess, error instanceof Error ? error : new Error(String(error)), classified);
+      this.onTransactionFailure?.(successfulEntries, error instanceof Error ? error : new Error(String(error)), classified);
       throw error;
     }
   }
   /**
    * 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) {
-    try {
-      for (const entry of transaction.crud) {
+    const successfulEntries = [];
+    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;
+      }
+      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 CRUD entry:", {
+          console.log("[Connector] Processing PATCH entry individually:", {
             table: entry.table,
             op: entry.op,
             id: entry.id,
             opData: entry.opData
           });
         }
-        await this.processCrudEntry(entry);
+        await this.processWithRetry(entry);
+        successfulEntries.push(entry);
       }
+    }
+    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
+      });
+    }
+    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.log("[Connector] All CRUD entries processed, completing transaction...");
+        console.warn("[Connector] Batched PUT failed, falling back to individual processing:", {
+          schema,
+          table,
+          error: error.message
+        });
       }
-      await transaction.complete();
+      for (const entry of entries) {
+        await this.processWithRetry(entry);
+        successful.push(entry);
+      }
+    } else {
       if (__DEV__) {
-        console.log("[Connector] Transaction completed successfully:", {
-          entriesCount: transaction.crud.length
+        console.log("[Connector] Batched PUT successful:", {
+          schema,
+          table,
+          count: entries.length
         });
       }
-      this.onTransactionSuccess?.(transaction.crud);
-      this.onTransactionComplete?.(transaction.crud);
-    } catch (error) {
-      const classified = classifySupabaseError(error);
-      console.error("[PowerSync Connector] Upload 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: transaction.crud.map((e) => ({
-          table: e.table,
-          op: e.op,
-          id: e.id
-        }))
-      });
-      this.logger?.error("[Connector] Upload error:", {
-        error,
-        classified,
-        entries: transaction.crud.map((e) => ({
-          table: e.table,
-          op: e.op,
-          id: e.id
-        }))
+      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] Processing batched DELETEs:", {
+        schema,
+        table,
+        count: entries.length
       });
-      this.onTransactionFailure?.(transaction.crud, error instanceof Error ? error : new Error(String(error)), classified);
-      throw error;
     }
+    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.warn("[Connector] Batched DELETE 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 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.
@@ -557,12 +989,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.
    *
@@ -572,6 +998,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) {
@@ -717,10 +1153,12 @@ var SupabaseConnector = class {
 
 export {
   defaultSchemaRouter,
+  DEFAULT_RETRY_CONFIG,
+  ConflictDetectionError,
   detectConflicts,
   hasVersionColumn,
   fetchServerVersion,
   getLocalVersion,
   SupabaseConnector
 };
-//# sourceMappingURL=chunk-C2RSTGDC.js.map
+//# sourceMappingURL=chunk-HFOFLW5F.js.map