scrapely 1.2.23 → 1.2.24

package/dist/charging.d.ts

@@ -93,10 +93,22 @@ export declare class ChargingManager {
      */
     private platformOtherUsd;
     private lastRemainingBudgetNd;
+    /** True once the platform reported a remaining budget (its usage is then in the local budget). */
+    private platformBudgetSeen;
     /** maxTotalChargeUsd minus this SDK's charges and the platform's other run spend. */
     private remainingBudgetUsd;
     /** Fold the last charge response's remainingBudgetNd into the local budget (monotonic). */
     private syncPlatformBudget;
+    /**
+     * @internal Whole rows a multi-event retry can pay for after a short answer:
+     * what the voided attempt was accepted (budget the void gives back) at the
+     * full per-row cost, or the local remaining budget once the platform has
+     * reported it (then it includes the leftover after the short answer).
+     */
+    _rowsAfterShort(attempt: Array<{
+        name: string;
+        charged: number;
+    }>, perRow: Record<string, number>): number;
     /** @internal Platform spend outside this SDK's charges (tests). */
     _platformOtherUsd(): number;
     /** @internal Called by Actor shutdown before the final flush. */

package/dist/charging.js

@@ -172,6 +172,8 @@ class ChargingManager {
      */
     platformOtherUsd = 0;
     lastRemainingBudgetNd = null;
+    /** True once the platform reported a remaining budget (its usage is then in the local budget). */
+    platformBudgetSeen = false;
     /** maxTotalChargeUsd minus this SDK's charges and the platform's other run spend. */
     remainingBudgetUsd() {
         return this.maxTotalChargeUsd - this.calculateTotalChargedAmount() - this.platformOtherUsd;
@@ -182,10 +184,28 @@ class ChargingManager {
         this.lastRemainingBudgetNd = null;
         if (nd === null || nd < 0 || !Number.isFinite(this.maxTotalChargeUsd))
             return;
+        this.platformBudgetSeen = true;
         const other = Number((this.maxTotalChargeUsd - nd / 1e9 - this.calculateTotalChargedAmount()).toFixed(9));
         if (other > this.platformOtherUsd)
             this.platformOtherUsd = other;
     }
+    /**
+     * @internal Whole rows a multi-event retry can pay for after a short answer:
+     * what the voided attempt was accepted (budget the void gives back) at the
+     * full per-row cost, or the local remaining budget once the platform has
+     * reported it (then it includes the leftover after the short answer).
+     */
+    _rowsAfterShort(attempt, perRow) {
+        const rowCost = Object.entries(perRow).reduce((a, [n, c]) => a + (this.calculateEventPrice(n) ?? 0) * c, 0);
+        if (rowCost <= 0)
+            return 0;
+        const spent = attempt.reduce((a, op) => a + (this.calculateEventPrice(op.name) ?? 0) * op.charged, 0);
+        let fit = Math.floor(Number((spent / rowCost).toFixed(4)));
+        if (this.platformBudgetSeen && Number.isFinite(this.maxTotalChargeUsd)) {
+            fit = Math.max(fit, Math.floor(Number((this.remainingBudgetUsd() / rowCost).toFixed(4))));
+        }
+        return Math.max(0, fit);
+    }
     /** @internal Platform spend outside this SDK's charges (tests). */
     _platformOtherUsd() {
         return this.platformOtherUsd;
@@ -1361,7 +1381,7 @@ async function pushDataWithCharges({ chargingManager, items, charges, isDefaultD
         };
         const order = Object.entries(perRow).sort(([a], [b]) => Number(isSyntheticEvent(a)) - Number(isSyntheticEvent(b)) || a.localeCompare(b));
         let ops = [];
-        for (let attempt = 0; attempt < 4 && rows > 0; attempt++) {
+        for (let attempt = 0; attempt < 6 && rows > 0; attempt++) {
             ops = [];
             let shortTo = null;
             for (const [name, n] of order) {
@@ -1389,10 +1409,14 @@ async function pushDataWithCharges({ chargingManager, items, charges, isDefaultD
             }
             if (shortTo === null)
                 break;
-            // An event came back short: void this attempt and retry with the rows it pays for.
+            // An event came back short: void this attempt and retry with the whole
+            // rows the budget covers at the FULL per-row cost (sizing from the short
+            // event alone came back short again: appstore 64df0a3608d74af88, 0 saved).
+            // At least one single-row try: the last affordable row may still fit.
+            const attemptOps = ops.map((op) => ({ name: op.name, charged: op.charged }));
             await undo(ops);
             ops = [];
-            rows = shortTo;
+            rows = Math.min(rows - 1, Math.max(chargingManager._rowsAfterShort(attemptOps, perRow), 1));
         }
         if (rows <= 0 || ops.length === 0) {
             await undo(ops);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "scrapely",
-    "version": "1.2.23",
+    "version": "1.2.24",
     "description": "Scrapely SDK for building JavaScript and TypeScript Actors",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",