scrapely 1.2.21 → 1.2.23

package/dist/actor.d.ts

@@ -19,6 +19,11 @@ import { Configuration, type ConfigurationOptions } from './configuration.js';
 import type { StorageClient } from '@crawlee/types';
 import { type ApiStorageConfig } from './storage/api-storage-client.js';
 import { ChargingManager, type ChargeOptions as ChargingChargeOptions, type ChargeResult as ChargingChargeResult } from './charging.js';
+/** Options for a multi-event charged push (`Actor.pushData(row, { charges })`). */
+export interface PushDataChargeOptions {
+    /** Events per row, e.g. `{ result: 1, page: 3 }`. */
+    charges: Record<string, number>;
+}
 import { createProxyConfiguration, type CreateProxyConfigurationOptions } from './proxy-configuration.js';
 import { type BrowserConfiguration, type BrowserConfigurationOptions } from './browser-configuration.js';
 import { type Clearance, type SolveOptions, type SolverVendorStatus } from './solver.js';
@@ -405,7 +410,14 @@ export declare class Actor {
      * @returns ChargeResult indicating if the user's spending limit was reached
      */
     static pushData<Data extends Record<string, any>>(item: Data | Data[], eventName: string): Promise<ChargeResult>;
-    pushData<Data extends Record<string, any>>(item: Data | Data[], eventName?: string): Promise<void | ChargeResult>;
+    /**
+     * Stores rows that each cost several pay-per-event events, charged atomically:
+     * `pushData(row, { charges: { result: 1, page: 3 } })` charges 1 `result` and 3 `page`
+     * events per row. A row is stored only when all of its events were charged; rows the
+     * spending limit cannot pay for in full are not stored.
+     */
+    static pushData<Data extends Record<string, any>>(item: Data | Data[], options: PushDataChargeOptions): Promise<ChargeResult>;
+    pushData<Data extends Record<string, any>>(item: Data | Data[], eventNameOrOptions?: string | PushDataChargeOptions): Promise<void | ChargeResult>;
     private usesPushDataInterception;
     private pushDataViaInterceptedClient;
     private pushDataWithExplicitCharging;

package/dist/actor.js

@@ -29,6 +29,7 @@ const events_client_js_1 = require("./events/events-client.js");
 const scrapely_event_manager_js_1 = require("./events/scrapely-event-manager.js");
 const secrets_js_1 = require("./crypto/secrets.js");
 const charging_js_1 = require("./charging.js");
+const charging_js_2 = require("./charging.js");
 const charging_client_js_1 = require("./charging_client.js");
 const proxy_configuration_js_1 = require("./proxy-configuration.js");
 const browser_configuration_js_1 = require("./browser-configuration.js");
@@ -513,11 +514,23 @@ class Actor {
         }
         return cachedInput ?? undefined;
     }
-    static async pushData(item, eventName) {
-        return Actor.getDefaultInstance().pushData(item, eventName);
+    static async pushData(item, eventNameOrOptions) {
+        return Actor.getDefaultInstance().pushData(item, eventNameOrOptions);
     }
-    async pushData(item, eventName) {
+    async pushData(item, eventNameOrOptions) {
         Actor._ensureActorInit('pushData');
+        if (eventNameOrOptions !== undefined && typeof eventNameOrOptions === 'object') {
+            const { Dataset } = await import('crawlee');
+            const dataset = await Dataset.open();
+            return (0, charging_js_2.pushDataWithCharges)({
+                chargingManager: this.chargingManager,
+                items: item,
+                charges: eventNameOrOptions.charges,
+                isDefaultDataset: dataset.id === this.config.get('defaultDatasetId'),
+                pushFn: async (rows) => { await dataset.pushData(rows); },
+            });
+        }
+        const eventName = eventNameOrOptions;
         // Exact synthetic names only — prefix would block real priced events like apify-foo.
         if (eventName === 'apify-default-dataset-item' ||
             eventName === 'scrapely-default-dataset-item') {

package/dist/charging.d.ts

@@ -86,6 +86,19 @@ 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;
+    /** 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 Platform spend outside this SDK's charges (tests). */
+    _platformOtherUsd(): number;
     /** @internal Called by Actor shutdown before the final flush. */
     close(): void;
     /**
@@ -110,6 +123,15 @@ export declare class ChargingManager {
     _notePrepaidCharge(eventName: string, chargedCount: number): void;
     /** @internal */
     _isPayPerEvent(): boolean;
+    /**
+     * @internal The priced part of a multi-event row (`charges`), plus the
+     * default-dataset-item event on the default dataset when it is priced, and
+     * how many rows the remaining budget pays for in full.
+     */
+    _rowCharges(charges: Record<string, number>, isDefaultDataset: boolean, rowCount: number): {
+        perRow: Record<string, number>;
+        rows: number;
+    };
     /** @internal Current prepaid-row balance (tests). */
     _prepaidRowBalance(): number;
     /**
@@ -252,6 +274,23 @@ export declare function pushDataAndCharge<T>({ chargingManager, items, eventName
     isDefaultDataset: boolean;
     pushFn: (limitedItems: T | T[]) => Promise<void>;
 }): Promise<ChargeResult>;
+/** Validate `{ eventName: eventsPerRow }` for a multi-event push. */
+export declare function validateRowCharges(charges: unknown): Record<string, number>;
+/**
+ * Push rows that each cost several events, atomically per row
+ * (`charges = { result: 1, page: 3 }`). A row is stored only when every one of
+ * its events was charged: rows the budget cannot pay for in full are not
+ * stored, and an operation that came back short is voided and re-charged for
+ * the rows that are kept, so no row is stored part-paid and no event is billed
+ * for a row that was not stored. Unpriced events are ignored.
+ */
+export declare function pushDataWithCharges<T>({ chargingManager, items, charges, isDefaultDataset, pushFn, }: {
+    chargingManager: ChargingManager;
+    items: T | T[];
+    charges: Record<string, number>;
+    isDefaultDataset: boolean;
+    pushFn: (rows: T | T[]) => Promise<void>;
+}): Promise<ChargeResult>;
 /**
  * @internal True when a dataset push certainly stored nothing: the storage API
  * answered with an error status, or the request never reached it. Timeouts and

package/dist/charging.js

@@ -9,6 +9,8 @@ exports.resolveDefaultDatasetItemEventName = resolveDefaultDatasetItemEventName;
 exports.hasDefaultDatasetItemEventInPricing = hasDefaultDatasetItemEventInPricing;
 exports.mergeChargeResults = mergeChargeResults;
 exports.pushDataAndCharge = pushDataAndCharge;
+exports.validateRowCharges = validateRowCharges;
+exports.pushDataWithCharges = pushDataWithCharges;
 exports.pushCertainlyFailed = pushCertainlyFailed;
 // SPDX-License-Identifier: Apache-2.0
 // Derived from apify-sdk-js (src/charging.ts),
@@ -163,6 +165,31 @@ 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;
+    /** 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;
+        const other = Number((this.maxTotalChargeUsd - nd / 1e9 - this.calculateTotalChargedAmount()).toFixed(9));
+        if (other > this.platformOtherUsd)
+            this.platformOtherUsd = other;
+    }
+    /** @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;
@@ -234,6 +261,30 @@ class ChargingManager {
     _isPayPerEvent() {
         return this.chargingState !== undefined && this.isPayPerEvent;
     }
+    /**
+     * @internal The priced part of a multi-event row (`charges`), plus the
+     * default-dataset-item event on the default dataset when it is priced, and
+     * how many rows the remaining budget pays for in full.
+     */
+    _rowCharges(charges, isDefaultDataset, rowCount) {
+        const perRow = {};
+        for (const [name, n] of Object.entries(charges)) {
+            if ((this.calculateEventPrice(name) ?? 0) > 0)
+                perRow[name] = n;
+        }
+        if (isDefaultDataset) {
+            const def = resolveDefaultDatasetItemEventName(this.pricingInfo);
+            if (!(def in perRow) && (this.calculateEventPrice(def) ?? 0) > 0)
+                perRow[def] = 1;
+        }
+        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.remainingBudgetUsd() / rowCost).toFixed(4)));
+            rows = Math.min(rows, Math.max(0, fit));
+        }
+        return { perRow, rows };
+    }
     /** @internal Current prepaid-row balance (tests). */
     _prepaidRowBalance() {
         return this.prepaidRowBalance;
@@ -517,7 +568,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);
     }
@@ -625,6 +676,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) {
@@ -930,6 +983,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}`, {
@@ -1042,8 +1096,9 @@ async function pushDataAndCharge({ chargingManager, items, eventName, isDefaultD
         let unpaidPastLimit = false;
         if (isDefaultDataset &&
             requested > 0 &&
-            chargingManager._isPayPerEvent() &&
-            !chargingManager._isPaidPerItem(eventName, isDefaultDataset)) {
+            // Optional calls: partial managers (tests, older shims) skip the net, as before.
+            chargingManager._isPayPerEvent?.() === true &&
+            !chargingManager._isPaidPerItem?.(eventName, isDefaultDataset)) {
             unpaidPastLimit = chargingManager.isChargeLimitReached?.() ?? false;
             const allowed = chargingManager._takeUnpaidRows(requested);
             if (allowed < requested) {
@@ -1236,6 +1291,137 @@ async function pushDataAndCharge({ chargingManager, items, eventName, isDefaultD
         };
     });
 }
+/** Validate `{ eventName: eventsPerRow }` for a multi-event push. */
+function validateRowCharges(charges) {
+    if (!charges || typeof charges !== 'object' || Array.isArray(charges) || Object.keys(charges).length === 0) {
+        throw new Error('charges must be a non-empty object of { eventName: countPerRow }');
+    }
+    const out = {};
+    for (const [name, count] of Object.entries(charges)) {
+        if (!name)
+            throw new Error('charges keys must be event names');
+        if (isSyntheticEvent(name))
+            throw new Error(`Cannot charge for synthetic event '${name}' manually`);
+        if (typeof count !== 'number' || !Number.isInteger(count) || count < 1) {
+            throw new Error(`charges['${name}'] must be a positive integer (events per row)`);
+        }
+        out[name] = count;
+    }
+    return out;
+}
+/**
+ * Push rows that each cost several events, atomically per row
+ * (`charges = { result: 1, page: 3 }`). A row is stored only when every one of
+ * its events was charged: rows the budget cannot pay for in full are not
+ * stored, and an operation that came back short is voided and re-charged for
+ * the rows that are kept, so no row is stored part-paid and no event is billed
+ * for a row that was not stored. Unpriced events are ignored.
+ */
+async function pushDataWithCharges({ chargingManager, items, charges, isDefaultDataset, pushFn, }) {
+    const perRowIn = validateRowCharges(charges);
+    const rowsIn = Array.isArray(items) ? items : [items];
+    const single = !Array.isArray(items);
+    const store = (rows) => chargeGatedPush.run(true, () => pushFn(single ? rows[0] : rows));
+    if (rowsIn.length === 0)
+        return { eventChargeLimitReached: false, chargedCount: 0, chargeableWithinLimit: {} };
+    return chargingManager._withOperationLock(async () => {
+        if (chargingManager.isClosed()) {
+            throw new Error('ChargingManager is closed (actor is shutting down); charge rejected');
+        }
+        const voidsConfirmed = (await chargingManager._retryPendingVoids?.()) !== false;
+        if (!chargingManager._isPayPerEvent()) {
+            await store(rowsIn);
+            return { eventChargeLimitReached: false, chargedCount: 0, chargeableWithinLimit: {} };
+        }
+        let { perRow, rows } = chargingManager._rowCharges(perRowIn, isDefaultDataset, rowsIn.length);
+        if (Object.keys(perRow).length === 0) {
+            // Only free events: an unpaid push (prepaid-row rules apply).
+            const pastLimit = chargingManager.isChargeLimitReached();
+            const allowed = isDefaultDataset ? chargingManager._takeUnpaidRows(rowsIn.length) : rowsIn.length;
+            if (allowed < rowsIn.length)
+                chargingManager._noteRefusedDefaultDatasetItems(rowsIn.length - allowed);
+            if (allowed > 0)
+                await store(rowsIn.slice(0, allowed));
+            return { eventChargeLimitReached: pastLimit, chargedCount: 0, chargeableWithinLimit: chargingManager._chargeableWithinLimit() };
+        }
+        if (!voidsConfirmed && Object.keys(perRow).some((n) => !isSyntheticEvent(n))) {
+            throw new Error('[Scrapely] An earlier charge for a failed dataset push could not be voided yet; retry the push');
+        }
+        const undo = async (ops) => {
+            for (const op of ops) {
+                if (op.charged <= 0)
+                    continue;
+                if (!op.operationId)
+                    chargingManager.applyAcceptedCount(op.name, op.charged, 0);
+                else if (op.uncertain)
+                    await chargingManager._cancelUncertainCharge(op.name, op.operationId, op.charged);
+                else
+                    await chargingManager._voidCharge(op.name, op.operationId, op.charged);
+            }
+        };
+        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++) {
+            ops = [];
+            let shortTo = null;
+            for (const [name, n] of order) {
+                const want = n * rows;
+                chargingManager._takeLastAcceptedOperationId?.();
+                let got;
+                try {
+                    const r = await chargingManager._chargeExclusive({ eventName: name, count: want });
+                    got = r.chargedCount;
+                    ops.push({ name, charged: got, operationId: chargingManager._takeLastAcceptedOperationId?.(), uncertain: false });
+                }
+                catch (err) {
+                    if (!(err instanceof ChargeUncertainError)) {
+                        await undo(ops);
+                        throw err;
+                    }
+                    // Not confirmed: stays pending and is re-posted at exit, so it counts as accepted.
+                    got = err.count;
+                    ops.push({ name, charged: got, operationId: err.operationId, uncertain: true });
+                }
+                if (got < want) {
+                    shortTo = Math.floor(got / n);
+                    break;
+                }
+            }
+            if (shortTo === null)
+                break;
+            // An event came back short: void this attempt and retry with the rows it pays for.
+            await undo(ops);
+            ops = [];
+            rows = shortTo;
+        }
+        if (rows <= 0 || ops.length === 0) {
+            await undo(ops);
+            chargingManager._markChargeLimitHit();
+            if (isDefaultDataset)
+                chargingManager._noteRefusedDefaultDatasetItems(rowsIn.length);
+            return { eventChargeLimitReached: true, chargedCount: 0, chargeableWithinLimit: chargingManager._chargeableWithinLimit() };
+        }
+        if (rows < rowsIn.length) {
+            chargingManager._markChargeLimitHit();
+            if (isDefaultDataset)
+                chargingManager._noteRefusedDefaultDatasetItems(rowsIn.length - rows);
+        }
+        try {
+            await store(rowsIn.slice(0, rows));
+        }
+        catch (pushErr) {
+            console.error(`[Scrapely] Dataset push failed after charges accepted (rows=${rows}): ${pushErr.message}; voiding the charges`);
+            if (pushCertainlyFailed(pushErr))
+                await undo(ops);
+            throw pushErr;
+        }
+        return {
+            eventChargeLimitReached: rows < rowsIn.length || chargingManager.isChargeLimitReached(),
+            chargedCount: rows,
+            chargeableWithinLimit: chargingManager._chargeableWithinLimit(),
+        };
+    });
+}
 /** HTTP status of an API/client error, if the server answered. */
 function httpStatusOf(err) {
     const e = err;

package/dist/index.d.ts

@@ -1,12 +1,12 @@
 import './log-env.js';
 export { setCdpUrl } from './patch-browser-pool.js';
-export { Actor, ACTOR_PERMISSION_LEVEL, type ActorInput, type InitOptions, type MainOptions, type ExitOptions, type RebootOptions, type AbortOptions, type MetamorphOptions, type RecordOptions, type OpenStorageOptions, type CallOptions, type CallTaskOptions, type StartOptions, type SetStatusMessageOptions, type WebhookOptions, type ApifyEnv, type UserFunc, type Token, type Timeout, EXIT_CODES, } from './actor';
+export { Actor, ACTOR_PERMISSION_LEVEL, type ActorInput, type InitOptions, type MainOptions, type ExitOptions, type RebootOptions, type AbortOptions, type PushDataChargeOptions, type MetamorphOptions, type RecordOptions, type OpenStorageOptions, type CallOptions, type CallTaskOptions, type StartOptions, type SetStatusMessageOptions, type WebhookOptions, type ApifyEnv, type UserFunc, type Token, type Timeout, EXIT_CODES, } from './actor';
 export type { StorageAlias, StorageId, StorageName, StorageIdentifier, StorageIdentifierWithoutAlias, } from './storage-identifiers.js';
 export { ApifyClient, type ApifyClientOptions, type ActorRun } from 'scrapely-client';
 export { Configuration, type ConfigurationOptions } from './configuration.js';
 export { DEGRADED_STATUS_MESSAGE, IpBanned, SolveAttemptError, SolverAuthError, SolverRateLimited, VendorUnavailable, degradedStatusMessage, detectVendor, isBlocked, reportSolveOutcome, solve, solverConfigured, solverStatus, stepAllowed, type Clearance, type SolveCookie, type SolveOptions, type SolverStepRequest, type SolverVendorStatus, } from './solver.js';
 export { ScrapelyEventManager as PlatformEventManager } from './events/scrapely-event-manager.js';
-export { ChargingManager, ChargeUncertainError, ChargeRejectedError, DEFAULT_DATASET_ITEM_EVENT, APIFY_DEFAULT_DATASET_ITEM_EVENT, SCRAPELY_DEFAULT_DATASET_ITEM_EVENT, hasDefaultDatasetItemEventInPricing, isDefaultDatasetItemEvent, resolveDefaultDatasetItemEventName, mergeChargeResults, pushDataAndCharge, type ChargeOptions, type ChargeResult, type ActorPricingInfo, } from './charging.js';
+export { ChargingManager, ChargeUncertainError, ChargeRejectedError, DEFAULT_DATASET_ITEM_EVENT, APIFY_DEFAULT_DATASET_ITEM_EVENT, SCRAPELY_DEFAULT_DATASET_ITEM_EVENT, hasDefaultDatasetItemEventInPricing, isDefaultDatasetItemEvent, resolveDefaultDatasetItemEventName, mergeChargeResults, pushDataAndCharge, pushDataWithCharges, validateRowCharges, type ChargeOptions, type ChargeResult, type ActorPricingInfo, } from './charging.js';
 export { createChargingClient, pushDataChargingContext, USES_PUSH_DATA_INTERCEPTION, type PpeAwarePushDataContext, } from './charging_client.js';
 export { BillingTracker, type BillingClient } from './storage/billing-tracker.js';
 export { ApiStorageClientFactory, type ApiStorageConfig } from './storage/api-storage-client.js';

package/dist/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LogLevel = exports.Log = exports.log = exports.RequestQueue = exports.KeyValueStore = exports.Dataset = exports.createBrowserConfiguration = exports.BrowserConfiguration = exports.getPlatformProxyEnv = exports.createProxyConfiguration = exports.validateProxySessionId = exports.isPlatformProxySentinel = exports.ProxyConfiguration = exports.ApiStorageClientFactory = exports.BillingTracker = exports.USES_PUSH_DATA_INTERCEPTION = exports.pushDataChargingContext = exports.createChargingClient = exports.pushDataAndCharge = exports.mergeChargeResults = exports.resolveDefaultDatasetItemEventName = exports.isDefaultDatasetItemEvent = exports.hasDefaultDatasetItemEventInPricing = exports.SCRAPELY_DEFAULT_DATASET_ITEM_EVENT = exports.APIFY_DEFAULT_DATASET_ITEM_EVENT = exports.DEFAULT_DATASET_ITEM_EVENT = exports.ChargeRejectedError = exports.ChargeUncertainError = exports.ChargingManager = exports.PlatformEventManager = exports.stepAllowed = exports.solverStatus = exports.solverConfigured = exports.solve = exports.reportSolveOutcome = exports.isBlocked = exports.detectVendor = exports.degradedStatusMessage = exports.VendorUnavailable = exports.SolverRateLimited = exports.SolverAuthError = exports.SolveAttemptError = exports.IpBanned = exports.DEGRADED_STATUS_MESSAGE = exports.Configuration = exports.ApifyClient = exports.EXIT_CODES = exports.ACTOR_PERMISSION_LEVEL = exports.Actor = exports.setCdpUrl = void 0;
-exports.puppeteerUtils = exports.playwrightUtils = exports.LinkeDOMCrawler = exports.JSDOMCrawler = exports.BrowserCrawler = exports.BasicCrawler = exports.HttpCrawler = exports.CheerioCrawler = exports.PuppeteerCrawler = exports.PlaywrightCrawler = exports.ScrapelyRequestList = exports.enqueueLinks = exports.utils = exports.LoggerText = exports.LoggerJson = exports.Logger = void 0;
+exports.log = exports.RequestQueue = exports.KeyValueStore = exports.Dataset = exports.createBrowserConfiguration = exports.BrowserConfiguration = exports.getPlatformProxyEnv = exports.createProxyConfiguration = exports.validateProxySessionId = exports.isPlatformProxySentinel = exports.ProxyConfiguration = exports.ApiStorageClientFactory = exports.BillingTracker = exports.USES_PUSH_DATA_INTERCEPTION = exports.pushDataChargingContext = exports.createChargingClient = exports.validateRowCharges = exports.pushDataWithCharges = exports.pushDataAndCharge = exports.mergeChargeResults = exports.resolveDefaultDatasetItemEventName = exports.isDefaultDatasetItemEvent = exports.hasDefaultDatasetItemEventInPricing = exports.SCRAPELY_DEFAULT_DATASET_ITEM_EVENT = exports.APIFY_DEFAULT_DATASET_ITEM_EVENT = exports.DEFAULT_DATASET_ITEM_EVENT = exports.ChargeRejectedError = exports.ChargeUncertainError = exports.ChargingManager = exports.PlatformEventManager = exports.stepAllowed = exports.solverStatus = exports.solverConfigured = exports.solve = exports.reportSolveOutcome = exports.isBlocked = exports.detectVendor = exports.degradedStatusMessage = exports.VendorUnavailable = exports.SolverRateLimited = exports.SolverAuthError = exports.SolveAttemptError = exports.IpBanned = exports.DEGRADED_STATUS_MESSAGE = exports.Configuration = exports.ApifyClient = exports.EXIT_CODES = exports.ACTOR_PERMISSION_LEVEL = exports.Actor = exports.setCdpUrl = void 0;
+exports.puppeteerUtils = exports.playwrightUtils = exports.LinkeDOMCrawler = exports.JSDOMCrawler = exports.BrowserCrawler = exports.BasicCrawler = exports.HttpCrawler = exports.CheerioCrawler = exports.PuppeteerCrawler = exports.PlaywrightCrawler = exports.ScrapelyRequestList = exports.enqueueLinks = exports.utils = exports.LoggerText = exports.LoggerJson = exports.Logger = exports.LogLevel = exports.Log = void 0;
 require("./log-env.js");
 var patch_browser_pool_js_1 = require("./patch-browser-pool.js");
 Object.defineProperty(exports, "setCdpUrl", { enumerable: true, get: function () { return patch_browser_pool_js_1.setCdpUrl; } });
@@ -43,6 +43,8 @@ Object.defineProperty(exports, "isDefaultDatasetItemEvent", { enumerable: true,
 Object.defineProperty(exports, "resolveDefaultDatasetItemEventName", { enumerable: true, get: function () { return charging_js_1.resolveDefaultDatasetItemEventName; } });
 Object.defineProperty(exports, "mergeChargeResults", { enumerable: true, get: function () { return charging_js_1.mergeChargeResults; } });
 Object.defineProperty(exports, "pushDataAndCharge", { enumerable: true, get: function () { return charging_js_1.pushDataAndCharge; } });
+Object.defineProperty(exports, "pushDataWithCharges", { enumerable: true, get: function () { return charging_js_1.pushDataWithCharges; } });
+Object.defineProperty(exports, "validateRowCharges", { enumerable: true, get: function () { return charging_js_1.validateRowCharges; } });
 var charging_client_js_1 = require("./charging_client.js");
 Object.defineProperty(exports, "createChargingClient", { enumerable: true, get: function () { return charging_client_js_1.createChargingClient; } });
 Object.defineProperty(exports, "pushDataChargingContext", { enumerable: true, get: function () { return charging_client_js_1.pushDataChargingContext; } });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "scrapely",
-    "version": "1.2.21",
+    "version": "1.2.23",
     "description": "Scrapely SDK for building JavaScript and TypeScript Actors",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
@@ -23,6 +23,8 @@
         "test": "npx tsx tests/test-mvp.ts",
         "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",