supastash 0.1.62 → 0.2.1

package/dist/native/utils/sync/pullFromRemote/updateLocalDb.js

@@ -0,0 +1,278 @@
+import { getSupastashConfig } from "../../../../shared/core/config";
+import { getSupastashDb } from "../../../../shared/db/dbInitializer";
+import { DEFAULT_RECEIVED_DATA_COMPLETED, RECEIVED_DATA_COMPLETED_MAP, } from "../../../../shared/store/syncStatus";
+import { generateUUIDv4 } from "../../../../shared/utils/genUUID";
+import { getTableSchema } from "../../../../shared/utils/getTableSchema";
+import log, { logError, logWarn } from "../../../../shared/utils/logs";
+import { refreshScreen } from "../../../../shared/utils/refreshScreenCalls";
+import { deleteReceivedDataCompleted } from "../../../../shared/utils/sync/pullFromRemote/helpers";
+import { stringifyValue } from "../../../../shared/utils/sync/pullFromRemote/stringifyFields";
+import { SyncInfoUpdater } from "../../../../shared/utils/sync/queryStatus";
+import { updateLocalSyncedAt } from "../../../../shared/utils/sync/status/syncUpdate";
+import { setSupastashSyncStatus } from "../status/services";
+import { pullData } from "./pullData";
+let isInSync = new Map();
+const DEFAULT_DATE = "1970-01-01T00:00:00Z";
+const BATCH_SIZE = 500;
+const CHUNK_SIZE = 999;
+/**
+ * Updates the local database with the remote changes
+ * @param table - The table to update
+ */
+export async function updateLocalDb(table, filters, onReceiveData) {
+    if (isInSync.get(table))
+        return;
+    const cfg = getSupastashConfig();
+    if (cfg.supastashMode === "ghost")
+        return;
+    isInSync.set(table, true);
+    const batchId = generateUUIDv4();
+    try {
+        const db = await getSupastashDb();
+        // Initialize the batch completed map
+        RECEIVED_DATA_COMPLETED_MAP[batchId] = {
+            arrived_at: DEFAULT_RECEIVED_DATA_COMPLETED,
+            updated_at: DEFAULT_RECEIVED_DATA_COMPLETED,
+        };
+        let refreshNeeded = false;
+        while (true) {
+            const dataResult = await pullData({ table, filters, batchId });
+            if (!dataResult)
+                break;
+            const data = dataResult?.data;
+            const timestamps = dataResult.timestamps;
+            const deletedIds = dataResult.deletedIds;
+            const deletedIdSet = new Set(deletedIds ?? []);
+            SyncInfoUpdater.setUnsyncedDataCount({
+                amount: data?.length ?? 0,
+                type: "pull",
+                table,
+            });
+            SyncInfoUpdater.setUnsyncedDeletedCount({
+                amount: deletedIds?.length ?? 0,
+                type: "pull",
+                table,
+            });
+            refreshNeeded = !!data?.length || !!deletedIds?.length;
+            // Delete records that are no longer in the remote data
+            await db.withTransaction(async (tx) => {
+                if (deletedIds && deletedIds.length > 0) {
+                    const ids = deletedIds;
+                    for (let i = 0; i < ids.length; i += CHUNK_SIZE) {
+                        const slice = ids.slice(i, i + CHUNK_SIZE);
+                        const placeholders = slice.map(() => "?").join(", ");
+                        await tx.runAsync(`DELETE FROM ${table} WHERE id IN (${placeholders})`, slice);
+                    }
+                }
+                // Get the local stamp of the records
+                let localStamp = new Map();
+                if (data?.length) {
+                    const ids = data.map((r) => r.id).filter(Boolean);
+                    for (let i = 0; i < ids.length; i += CHUNK_SIZE) {
+                        const slice = ids.slice(i, i + CHUNK_SIZE);
+                        const placeholders = slice.map(() => "?").join(", ");
+                        const rows = await db.getAllAsync(`SELECT id, updated_at FROM ${table} WHERE id IN (${placeholders})`, slice);
+                        for (const row of rows ?? []) {
+                            localStamp.set(row.id, row.updated_at ?? null);
+                        }
+                    }
+                }
+                // Update local database with remote changes
+                if (data?.length) {
+                    await upsertChunkData({
+                        tx,
+                        table,
+                        records: data,
+                    });
+                }
+            });
+            if (timestamps) {
+                await setSupastashSyncStatus(table, filters, {
+                    lastSyncedAt: timestamps.updatedMax,
+                    lastDeletedAt: timestamps.deletedMax,
+                    lastSyncedAtPk: timestamps.updatedMaxPk,
+                    filterNamespace: "global",
+                });
+            }
+            const completedSet = RECEIVED_DATA_COMPLETED_MAP[batchId];
+            if (Object.values(completedSet ?? {}).every(Boolean)) {
+                break;
+            }
+        }
+        if (refreshNeeded)
+            refreshScreen(table);
+    }
+    catch (error) {
+        logWarn(`[Supastash] Error updating local db for ${table}`, error);
+        throw error;
+    }
+    finally {
+        isInSync.delete(table);
+        deleteReceivedDataCompleted(batchId);
+    }
+}
+const warned = new Map();
+/**
+ * Upserts a record into the local database
+ * @param table - The table to upsert the record into
+ * @param record - The record to upsert
+ * @param exists - Whether the record already exists in the database
+ */
+export async function upsertData({ tx, table, record, doesExist, }) {
+    if (!record?.id)
+        return;
+    let itemExists = !!doesExist;
+    const cfg = getSupastashConfig();
+    if (cfg.supastashMode === "ghost")
+        return;
+    if (doesExist === undefined) {
+        const { doesExist: exists } = await checkIfRecordExistsAndIsNewer(table, record);
+        itemExists = exists;
+    }
+    try {
+        const db = tx ?? (await getSupastashDb());
+        const columns = await getTableSchema(table);
+        const recordToSave = {
+            ...record,
+            synced_at: new Date().toISOString(),
+        };
+        if (getSupastashConfig().debugMode) {
+            const unknownKeys = Object.keys(record).filter((key) => !columns.includes(key));
+            if (unknownKeys.length > 0 && !warned.get(table)) {
+                warned.set(table, true);
+                logWarn(`⚠️ [Supastash] '${table}' payload contains keys not in local schema: ${unknownKeys.join(", ")}. ` + `They will be ignored locally.`);
+            }
+        }
+        // Prep for upsert
+        const keys = columns;
+        const placeholders = keys.map(() => "?").join(", ");
+        const updateColumns = keys.filter((key) => key !== "id");
+        const updateParts = updateColumns.map((key) => `${key} = ?`);
+        const updatePlaceholders = updateParts.join(", ");
+        const values = keys.map((key) => stringifyValue(recordToSave[key]));
+        const updateValues = updateColumns.map((key) => stringifyValue(recordToSave[key]));
+        if (itemExists) {
+            // Update existing record
+            await db.runAsync(`UPDATE ${table} SET ${updatePlaceholders} WHERE id = ?`, [...updateValues, record.id]);
+        }
+        else {
+            // Insert new record
+            await db.runAsync(`INSERT INTO ${table} (${keys.join(", ")}) VALUES (${placeholders})`, values);
+        }
+        await updateLocalSyncedAt(table, [record.id]);
+    }
+    catch (error) {
+        logError(`[Supastash] Error upserting data for ${table}`, error);
+    }
+}
+/**
+    •	Bulk upserts records into a local SQLite table using a batched, conflict-aware strategy.
+    •
+    •	This function:
+    •		•	Fetches existing id and updated_at values in bulk to avoid per-row queries
+    •		•	Filters incoming records to only include new or more recent entries
+    •		•	Performs batched INSERT ... ON CONFLICT(id) DO UPDATE operations
+    •	while respecting SQLite parameter limits
+    •		•	Updates synced_at for successfully written records
+    •
+    •	Designed for high-performance sync scenarios in offline-first apps.
+    •
+    •	Key guarantees:
+    •		•	Avoids N+1 query patterns (no per-row existence checks)
+    •		•	Minimizes disk I/O pressure via batching
+    •		•	Safe for large datasets when used with chunking
+    •
+    •	Notes:
+    •		•	Assumes id is the primary or unique key
+    •		•	Requires updated_at for conflict resolution (falls back if missing)
+    •		•	Respects SQLite parameter limit (~999 variables per query)
+    •
+    •	@param tx Optional transaction instance. If not provided, a connection is used directly.
+    •	@param table Target table name
+    •	@param records Array of records to upsert
+*/
+export async function upsertChunkData({ tx, table, records, }) {
+    if (!records?.length)
+        return;
+    const cfg = getSupastashConfig();
+    if (cfg.supastashMode === "ghost")
+        return;
+    const db = tx ?? (await getSupastashDb());
+    const columns = await getTableSchema(table);
+    const syncedAt = new Date().toISOString();
+    if (cfg.debugMode) {
+        const unknownKeys = Object.keys(records[0]).filter((key) => !columns.includes(key));
+        if (unknownKeys.length > 0 && !warned.get(table)) {
+            warned.set(table, true);
+            logWarn(`⚠️ [Supastash] '${table}' payload contains keys not in local schema: ${unknownKeys.join(", ")}. ` + `They will be ignored locally.`);
+        }
+    }
+    // Step 1: Fetch existing id + updated_at for all incoming ids in bulk
+    const incomingIds = records.map((r) => r.id).filter(Boolean);
+    const localStamp = new Map();
+    for (let i = 0; i < incomingIds.length; i += CHUNK_SIZE) {
+        const slice = incomingIds.slice(i, i + CHUNK_SIZE);
+        const placeholders = slice.map(() => "?").join(", ");
+        const rows = await db.getAllAsync(`SELECT id, updated_at FROM ${table} WHERE id IN (${placeholders})`, slice);
+        for (const row of rows ?? []) {
+            localStamp.set(row.id, row.updated_at ?? null);
+        }
+    }
+    // Step 2: Keep only records that are new or have a newer remote updated_at
+    const toUpsert = records.filter((record) => {
+        if (!record?.id)
+            return false;
+        const localUpdated = localStamp.get(record.id) ?? DEFAULT_DATE;
+        const remoteUpdated = record.updated_at ?? DEFAULT_DATE;
+        return new Date(remoteUpdated) > new Date(localUpdated);
+    });
+    if (!toUpsert.length)
+        return;
+    // Step 3: Build INSERT … ON CONFLICT(id) DO UPDATE in param-limit-safe chunks
+    const colList = columns.join(", ");
+    const updateSet = columns
+        .filter((key) => key !== "id")
+        .map((key) => `${key} = excluded.${key}`)
+        .join(", ");
+    const paramsPerRow = columns.length;
+    const rowsPerChunk = Math.max(1, Math.floor(999 / paramsPerRow));
+    const successfulIds = [];
+    for (let i = 0; i < toUpsert.length; i += rowsPerChunk) {
+        const chunk = toUpsert.slice(i, i + rowsPerChunk);
+        const rowPlaceholders = chunk
+            .map(() => `(${columns.map(() => "?").join(", ")})`)
+            .join(", ");
+        const values = [];
+        for (const record of chunk) {
+            const recordToSave = { ...record, synced_at: syncedAt };
+            for (const col of columns) {
+                values.push(stringifyValue(recordToSave[col]));
+            }
+        }
+        try {
+            await db.runAsync(`INSERT INTO ${table} (${colList}) VALUES ${rowPlaceholders} ON CONFLICT(id) DO UPDATE SET ${updateSet}`, values);
+            for (const record of chunk) {
+                successfulIds.push(record.id);
+            }
+        }
+        catch (error) {
+            logError(`[Supastash] Error upserting chunk for ${table}`, error);
+        }
+    }
+    if (successfulIds.length) {
+        await updateLocalSyncedAt(table, successfulIds);
+    }
+}
+async function checkIfRecordExistsAndIsNewer(table, item) {
+    if (!item?.id)
+        return { doesExist: false, newer: false };
+    const db = await getSupastashDb();
+    const record = await db.getFirstAsync(`SELECT id, updated_at FROM ${table} WHERE id = ?`, [item.id]);
+    if (record &&
+        new Date(record.updated_at || DEFAULT_DATE) >=
+            new Date(item.updated_at || DEFAULT_DATE)) {
+        log(`Skipping ${table}:${record.id} - local is newer`);
+        return { doesExist: true, newer: false };
+    }
+    return { doesExist: !!record, newer: true };
+}

package/dist/native/utils/sync/pushLocal/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Pushes the local data to the remote database
+ */
+export declare function pushLocalData(): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/dist/native/utils/sync/pushLocal/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/native/utils/sync/pushLocal/index.ts"],"names":[],"mappings":"AAaA;;GAEG;AACH,wBAAsB,aAAa,kBAiGlC"}

package/dist/native/utils/sync/pushLocal/index.js

@@ -0,0 +1,101 @@
+import { getSupastashConfig } from "../../../../shared/core/config";
+import { syncCalls } from "../../../../shared/store/syncCalls";
+import log from "../../../../shared/utils/logs";
+import { getAllTables } from "../../../../shared/utils/sync/getAllTables";
+import { runLimitedConcurrency } from "../../../../shared/utils/sync/pullFromRemote/runLimitedConcurrency";
+import { SyncInfoUpdater } from "../../../../shared/utils/sync/queryStatus";
+import { pushLocalDataToRemote } from "./sendUnsyncedToSupabase";
+let emptyPassCount = 0;
+let lastEmptyPassAt = 0;
+const tablePushLock = new Map();
+/**
+ * Pushes the local data to the remote database
+ */
+export async function pushLocalData() {
+    let tablesCompleted = 0;
+    let numberOfTables = 0;
+    try {
+        const tables = await getAllTables();
+        if (!tables) {
+            log("[Supastash] No tables found");
+            return;
+        }
+        const excludeTables = getSupastashConfig()?.excludeTables?.push || [];
+        const tablesToPush = tables.filter((table) => !excludeTables?.includes(table));
+        numberOfTables = tablesToPush.length;
+        SyncInfoUpdater.setInProgress({
+            action: "start",
+            type: "push",
+        });
+        SyncInfoUpdater.setNumberOfTables({
+            amount: numberOfTables,
+            type: "push",
+        });
+        const results = [];
+        const jobs = tablesToPush.map((table) => async () => {
+            SyncInfoUpdater.setCurrentTable({
+                table,
+                type: "push",
+            });
+            if (tablePushLock.get(table)) {
+                results.push({ table, hadWork: false });
+                return;
+            }
+            tablePushLock.set(table, true);
+            try {
+                const onPush = syncCalls.get(table)?.push;
+                SyncInfoUpdater.markLogStart({
+                    type: "push",
+                    table,
+                });
+                const hadWork = await pushLocalDataToRemote(table, onPush);
+                results.push({ table, hadWork: !!hadWork });
+                SyncInfoUpdater.markLogSuccess({
+                    type: "push",
+                    table,
+                });
+            }
+            catch (e) {
+                const msg = e?.message ?? e?.code ?? e?.name ?? String(e);
+                SyncInfoUpdater.markLogError({
+                    type: "push",
+                    table,
+                    lastError: e,
+                    errorCount: 1,
+                });
+                results.push({ table, hadWork: false, error: msg });
+                log(`[Supastash] Push table failed: ${table} — ${msg}`);
+            }
+            finally {
+                tablesCompleted++;
+                SyncInfoUpdater.setTablesCompleted({
+                    amount: tablesCompleted,
+                    type: "push",
+                });
+                tablePushLock.set(table, false);
+            }
+        });
+        await runLimitedConcurrency(jobs, 3);
+        const hadAnyWork = results.some((r) => r.hadWork);
+        if (!hadAnyWork) {
+            emptyPassCount += 1;
+            if (emptyPassCount % 150 === 0) {
+                const now = Date.now();
+                const gap = lastEmptyPassAt ? now - lastEmptyPassAt : 0;
+                lastEmptyPassAt = now;
+                const noSyncTables = results.map((r) => r.table).join(", ");
+                log(`[Supastash] No pushable data for: ${noSyncTables} (empty passes: ${emptyPassCount})${gap ? ` in the last ${gap}ms` : ""}`);
+            }
+        }
+        else {
+            emptyPassCount = 0;
+            lastEmptyPassAt = Date.now();
+        }
+    }
+    catch (error) {
+        log(`[Supastash] Error pushing local data to remote database: ${error}`);
+    }
+    finally {
+        SyncInfoUpdater.reset({ type: "push" });
+    }
+}

package/dist/native/utils/sync/pushLocal/sendUnsyncedToSupabase.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Sends unsynced data to the remote database for a given table.
+ * Returns true if it pushed anything (creates/updates OR deletes), else false.
+ */
+export declare function pushLocalDataToRemote(table: string, onPushToRemote?: (payload: any[]) => Promise<boolean>, noSync?: string[]): Promise<boolean | undefined>;
+//# sourceMappingURL=sendUnsyncedToSupabase.d.ts.map

package/dist/native/utils/sync/pushLocal/sendUnsyncedToSupabase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sendUnsyncedToSupabase.d.ts","sourceRoot":"","sources":["../../../../../src/native/utils/sync/pushLocal/sendUnsyncedToSupabase.ts"],"names":[],"mappings":"AAYA;;;GAGG;AACH,wBAAsB,qBAAqB,CACzC,KAAK,EAAE,MAAM,EACb,cAAc,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,OAAO,CAAC,EACrD,MAAM,CAAC,EAAE,MAAM,EAAE,gCA+ClB"}

package/dist/native/utils/sync/pushLocal/sendUnsyncedToSupabase.js

@@ -0,0 +1,57 @@
+import { getSupastashConfig } from "../../../../shared/core/config";
+import { refreshScreen } from "../../../../shared/utils/refreshScreenCalls";
+import { deleteData } from "../../../../shared/utils/sync/pushLocal/deleteChunks";
+import { getAllDeletedData, getAllUnsyncedData, } from "../../../../shared/utils/sync/pushLocal/getAllUnsyncedData";
+import { SyncInfoUpdater } from "../../../../shared/utils/sync/queryStatus";
+import { uploadData } from "./uploadChunk";
+let isInSync = new Map();
+/**
+ * Sends unsynced data to the remote database for a given table.
+ * Returns true if it pushed anything (creates/updates OR deletes), else false.
+ */
+export async function pushLocalDataToRemote(table, onPushToRemote, noSync) {
+    if (isInSync.get(table))
+        return;
+    const cfg = getSupastashConfig();
+    if (cfg.supastashMode === "ghost")
+        return false;
+    isInSync.set(table, true);
+    try {
+        const data = await getAllUnsyncedData(table);
+        const deletedData = await getAllDeletedData(table);
+        SyncInfoUpdater.setUnsyncedDataCount({
+            amount: data?.length ?? 0,
+            type: "push",
+            table,
+        });
+        SyncInfoUpdater.setUnsyncedDeletedCount({
+            amount: deletedData?.length ?? 0,
+            type: "push",
+            table,
+        });
+        const hasData = !!data?.length;
+        const hasDeletes = !!deletedData?.length;
+        if (!hasData && !hasDeletes) {
+            noSync?.push?.(table);
+            return false;
+        }
+        let didWork = false;
+        if (hasData) {
+            await uploadData(table, data, onPushToRemote);
+            didWork = true;
+        }
+        if (hasDeletes) {
+            await deleteData(table, deletedData);
+            didWork = true;
+        }
+        if (didWork)
+            refreshScreen(table);
+        return didWork;
+    }
+    catch (error) {
+        throw error;
+    }
+    finally {
+        isInSync.delete(table);
+    }
+}

package/dist/native/utils/sync/pushLocal/uploadChunk.d.ts

@@ -0,0 +1,8 @@
+import { PayloadData } from "../../../../shared/types/query.types";
+/**
+ * Uploads a chunk of data to the remote database
+ * @param table - The table to upload to
+ * @param unsyncedRecords - The unsynced records to upload
+ */
+export declare function uploadData(table: string, unsyncedRecords: PayloadData[], onPushToRemote?: (payload: any[]) => Promise<boolean>): Promise<void>;
+//# sourceMappingURL=uploadChunk.d.ts.map

package/dist/native/utils/sync/pushLocal/uploadChunk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uploadChunk.d.ts","sourceRoot":"","sources":["../../../../../src/native/utils/sync/pushLocal/uploadChunk.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,sCAAsC,CAAC;AAmMnE;;;;GAIG;AACH,wBAAsB,UAAU,CAC9B,KAAK,EAAE,MAAM,EACb,eAAe,EAAE,WAAW,EAAE,EAC9B,cAAc,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,OAAO,CAAC,iBAetD"}

package/dist/native/utils/sync/pushLocal/uploadChunk.js

@@ -0,0 +1,173 @@
+import { DEFAULT_CHUNK_SIZE } from "../../../../shared/constants/syncDefaults";
+import { getSupastashConfig } from "../../../../shared/core/config";
+import { isOnline } from "../../../../shared/utils/connection";
+import { normalizeForSupabase } from "../../../../shared/utils/getSafeValues";
+import log from "../../../../shared/utils/logs";
+import { supabaseClientErr } from "../../../../shared/utils/supabaseClientErr";
+import { enforceTimestamps } from "../../../../shared/utils/sync/pushLocal/normalize";
+import { setQueryStatus, SyncInfoUpdater, } from "../../../../shared/utils/sync/queryStatus";
+import { backoff, batchUpsert, fetchRemoteHeadsChunked, filterRowsByUpdatedAt, handleRowFailure, markSynced, rpcUpsert, rpcUpsertSingle, singleUpsert, } from "./uploadHelpers";
+/**
+ * Uploads a chunk of data to the remote database
+ *
+ * It will check if the data in the remote database is more recent than the data in the local database.
+ * If it is, it will skip it.
+ * If it is not, it will upsert it.
+ *
+ * @param table - The table to upload to
+ * @param chunk - The chunk of data to upload
+ */
+async function uploadChunk(table, chunk, onPushToRemote) {
+    const config = getSupastashConfig();
+    const supabase = config.supabaseClient;
+    if (!supabase) {
+        throw new Error(supabaseClientErr);
+    }
+    const online = await isOnline();
+    if (!online)
+        return;
+    let errorCount = 0;
+    let lastError = null;
+    let pending = [];
+    const hasRPCPath = !!config.pushRPCPath;
+    const ids = chunk.map((row) => row.id);
+    const toPush = [];
+    // If we have a RPC path, we can push the whole chunk. Server validates freshness.
+    if (hasRPCPath) {
+        toPush.push(...chunk);
+    }
+    else {
+        // Fetch remote data for the current chunk
+        const remoteIds = await fetchRemoteHeadsChunked(table, ids, supabase);
+        // Loop through the initial chunk and check if the id is in the remote data
+        const filtered = filterRowsByUpdatedAt(table, chunk, remoteIds);
+        toPush.push(...filtered);
+    }
+    if (toPush.length === 0)
+        return;
+    const preflightOK = [];
+    if (config.syncPolicy?.ensureParents) {
+        for (const r of toPush) {
+            try {
+                const status = await config.syncPolicy.ensureParents(table, r);
+                if (status === "blocked") {
+                    setQueryStatus(r.id, table, "error");
+                    continue;
+                }
+                preflightOK.push(r);
+            }
+            catch (e) {
+                setQueryStatus(r.id, table, "error");
+                log(`[Supastash] ensureParents failed for ${table}:${r.id}`, e);
+            }
+        }
+    }
+    else {
+        preflightOK.push(...toPush);
+    }
+    if (preflightOK.length === 0)
+        return;
+    pending.push(...preflightOK);
+    const maxBatchAttempts = config.syncPolicy?.maxBatchAttempts ?? 5;
+    let attempts = 0;
+    while (attempts < maxBatchAttempts && pending.length > 0) {
+        let batchOk = false;
+        // RPC return values
+        let completed = [];
+        let existsMap = new Map();
+        if (onPushToRemote) {
+            const ok = await onPushToRemote(pending);
+            if (ok)
+                batchOk = true;
+        }
+        else if (hasRPCPath) {
+            const res = await rpcUpsert({ table, rows: pending, supabase });
+            completed = res.data.completed;
+            pending = [...res.data.skipped];
+            existsMap = res.data.existsMap;
+            batchOk = res.error == null && pending.length === 0;
+            // If there was an RPC error, we need to retry the main function
+            if (res.error) {
+                attempts++;
+                await backoff(attempts);
+                pending = [...preflightOK];
+                continue;
+            }
+        }
+        else {
+            const { error } = await batchUpsert(table, pending, supabase);
+            if (!error)
+                batchOk = true;
+        }
+        if (batchOk) {
+            await markSynced(table, pending.map((r) => r.id));
+            return;
+        }
+        if (completed.length > 0) {
+            await markSynced(table, completed.map((r) => r.id));
+        }
+        //Batch failed -> isolate per-row offenders
+        const keep = [];
+        const syncedNow = [];
+        for (const row of pending) {
+            let res = null;
+            if (onPushToRemote) {
+                const ok = await onPushToRemote([row]);
+                res = { error: ok ? null : { code: "ROW_FAILED" } };
+            }
+            else if (hasRPCPath) {
+                res = await rpcUpsertSingle({ table, row, supabase, existsMap });
+            }
+            else {
+                res = await singleUpsert(table, row, supabase);
+            }
+            if (!res.error) {
+                syncedNow.push(row.id);
+                continue;
+            }
+            errorCount++;
+            lastError = res.error;
+            const decision = await handleRowFailure(config, table, row, res.error, supabase);
+            if (decision === "DROP" || decision === "REPLACED") {
+                continue;
+            }
+            keep.push(row); // retry later
+        }
+        if (syncedNow.length)
+            await markSynced(table, syncedNow);
+        if (keep.length === 0)
+            return;
+        // Backoff before next batch round (exponential, bounded by policy)
+        attempts++;
+        await backoff(attempts);
+        pending = keep;
+    }
+    if (pending.length > 0) {
+        SyncInfoUpdater.markLogError({
+            type: "push",
+            table,
+            lastError: lastError ?? new Error("Unknown error"),
+            errorCount: errorCount ?? 0,
+            rowsFailed: pending.length,
+        });
+    }
+    // Gave up this pass — rows left in `pending` will be retried by outer scheduler
+    for (const r of pending)
+        setQueryStatus(r.id, table, "error");
+}
+/**
+ * Uploads a chunk of data to the remote database
+ * @param table - The table to upload to
+ * @param unsyncedRecords - The unsynced records to upload
+ */
+export async function uploadData(table, unsyncedRecords, onPushToRemote) {
+    const cfg = getSupastashConfig();
+    const supabase = cfg.supabaseClient;
+    if (!supabase)
+        throw new Error("[Supastash] Supabase client not configured");
+    const cleaned = unsyncedRecords.map(({ synced_at, deleted_at, arrived_at, ...rest }) => enforceTimestamps(normalizeForSupabase(rest)));
+    for (let i = 0; i < cleaned.length; i += DEFAULT_CHUNK_SIZE) {
+        const chunk = cleaned.slice(i, i + DEFAULT_CHUNK_SIZE);
+        await uploadChunk(table, chunk, onPushToRemote);
+    }
+}