scrapely 1.2.22 → 1.2.24

package/dist/charging.d.ts

@@ -86,6 +86,31 @@ export declare class ChargingManager {
      * Actors never go positive, so they get nothing extra for free.
      */
     private prepaidRowBalance;
+    /**
+     * Run spend the platform counts against maxTotalChargeUsd that this SDK does
+     * not charge itself (compute/proxy/browser usage, server-billed events).
+     * Learnt from the charge endpoint's remainingBudgetNd; only ever grows.
+     */
+    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. */
     close(): void;
     /**

package/dist/charging.js

@@ -165,6 +165,51 @@ class ChargingManager {
      * Actors never go positive, so they get nothing extra for free.
      */
     prepaidRowBalance = 0;
+    /**
+     * Run spend the platform counts against maxTotalChargeUsd that this SDK does
+     * not charge itself (compute/proxy/browser usage, server-billed events).
+     * Learnt from the charge endpoint's remainingBudgetNd; only ever grows.
+     */
+    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;
+    }
+    /** Fold the last charge response's remainingBudgetNd into the local budget (monotonic). */
+    syncPlatformBudget() {
+        const nd = this.lastRemainingBudgetNd;
+        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;
+    }
     /** @internal Called by Actor shutdown before the final flush. */
     close() {
         this._closed = true;
@@ -255,7 +300,7 @@ class ChargingManager {
         const rowCost = Object.entries(perRow).reduce((a, [name, n]) => a + (this.calculateEventPrice(name) ?? 0) * n, 0);
         let rows = rowCount;
         if (rowCost > 0 && Number.isFinite(this.maxTotalChargeUsd)) {
-            const fit = Math.floor(Number(((this.maxTotalChargeUsd - this.calculateTotalChargedAmount()) / rowCost).toFixed(4)));
+            const fit = Math.floor(Number((this.remainingBudgetUsd() / rowCost).toFixed(4)));
             rows = Math.min(rows, Math.max(0, fit));
         }
         return { perRow, rows };
@@ -543,7 +588,7 @@ class ChargingManager {
         return eventName;
     }
     calculateMaxChargesByPrice(price) {
-        const unroundedResult = (this.maxTotalChargeUsd - this.calculateTotalChargedAmount()) / price;
+        const unroundedResult = this.remainingBudgetUsd() / price;
         const roundedResult = Math.floor(Number(unroundedResult.toFixed(4)));
         return Math.max(0, roundedResult);
     }
@@ -651,6 +696,8 @@ class ChargingManager {
                 });
                 const body = extractChargeResponseBody(response);
                 const accepted = readAcceptedCount(body, intent.count);
+                const remaining = body.remainingBudgetNd;
+                this.lastRemainingBudgetNd = typeof remaining === 'number' && Number.isFinite(remaining) && remaining >= 0 ? remaining : null;
                 return accepted;
             }
             catch (err) {
@@ -956,6 +1003,7 @@ class ChargingManager {
                 if (accepted < chargedCount)
                     this.markChargeLimitHit();
                 chargedCount = this.applyAcceptedCount(normalizedEventName, chargedCount, accepted, eventPricing.price);
+                this.syncPlatformBudget();
             }
             else {
                 throw new ChargeUncertainError(`Charge for event '${normalizedEventName}' (count=${chargedCount}) was not confirmed by the platform; operationId=${intent.idempotencyKey}`, {
@@ -1333,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) {
@@ -1361,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.22",
+    "version": "1.2.24",
     "description": "Scrapely SDK for building JavaScript and TypeScript Actors",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
@@ -24,6 +24,7 @@
         "test:charging": "npx tsx --test tests/charging-pending.test.ts",
         "test:charge-limit-guard": "npx tsx --test tests/charge-limit-guard.test.ts",
         "test:charge-multi-event": "npx tsx --test tests/charge-multi-event.test.ts",
+        "test:charge-platform-budget": "npx tsx --test tests/charge-platform-budget.test.ts",
         "test:storage-retries": "npx tsx --test tests/storage-retries.test.ts",
         "test:push-idempotency": "npx tsx --test tests/push-idempotency.test.ts",
         "test:stdio-drain": "npx tsx --test tests/stdio-drain.test.ts",