scrapely 1.2.20 → 1.2.22

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

@@ -77,6 +77,15 @@ export declare class ChargingManager {
     private chargeLimitHit;
     /** Default-dataset rows refused after the limit (one warning, then a count). */
     private refusedDefaultDatasetItems;
+    /**
+     * Prepaid-row balance: priced events charged through charge() minus rows
+     * pushed to the default dataset without a per-row charge. An Actor that
+     * charges first and then pushes plainly (charge('product'); pushData(row))
+     * has a positive balance after the charge, so the row it already paid for is
+     * still saved when that charge used up the spending limit. Push-then-charge
+     * Actors never go positive, so they get nothing extra for free.
+     */
+    private prepaidRowBalance;
     /** @internal Called by Actor shutdown before the final flush. */
     close(): void;
     /**
@@ -98,6 +107,27 @@ export declare class ChargingManager {
     /** @internal Whether every row of a push with these events is charged a positive price. */
     _isPaidPerItem(eventName: string | undefined, isDefaultDataset: boolean): boolean;
     /** @internal */
+    _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;
+    /**
+     * @internal Account for rows pushed without a per-row charge. Returns how
+     * many may be stored: all while the limit is not reached, afterwards only
+     * the rows earlier charges already paid for (the positive balance).
+     */
+    _takeUnpaidRows(itemCount: number): number;
+    /** @internal */
     _refuseDefaultDatasetPush(itemCount: number): boolean;
     /** @internal Whether shutdown has closed this manager to new charges. */
     isClosed(): boolean;
@@ -231,6 +261,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),
@@ -154,6 +156,15 @@ class ChargingManager {
     chargeLimitHit = false;
     /** Default-dataset rows refused after the limit (one warning, then a count). */
     refusedDefaultDatasetItems = 0;
+    /**
+     * Prepaid-row balance: priced events charged through charge() minus rows
+     * pushed to the default dataset without a per-row charge. An Actor that
+     * charges first and then pushes plainly (charge('product'); pushData(row))
+     * has a positive balance after the charge, so the row it already paid for is
+     * still saved when that charge used up the spending limit. Push-then-charge
+     * Actors never go positive, so they get nothing extra for free.
+     */
+    prepaidRowBalance = 0;
     /** @internal Called by Actor shutdown before the final flush. */
     close() {
         this._closed = true;
@@ -216,9 +227,73 @@ class ChargingManager {
         return names.some((name) => (this.calculateEventPrice(name) ?? 0) > 0);
     }
     /** @internal */
+    _notePrepaidCharge(eventName, chargedCount) {
+        if (chargedCount > 0 && !isSyntheticEvent(eventName) && (this.pricingInfo[eventName]?.price ?? 0) > 0) {
+            this.prepaidRowBalance += chargedCount;
+        }
+    }
+    /** @internal */
+    _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.maxTotalChargeUsd - this.calculateTotalChargedAmount()) / rowCost).toFixed(4)));
+            rows = Math.min(rows, Math.max(0, fit));
+        }
+        return { perRow, rows };
+    }
+    /** @internal Current prepaid-row balance (tests). */
+    _prepaidRowBalance() {
+        return this.prepaidRowBalance;
+    }
+    /**
+     * @internal Account for rows pushed without a per-row charge. Returns how
+     * many may be stored: all while the limit is not reached, afterwards only
+     * the rows earlier charges already paid for (the positive balance).
+     */
+    _takeUnpaidRows(itemCount) {
+        if (itemCount <= 0)
+            return 0;
+        if (!this.isChargeLimitReached()) {
+            this.prepaidRowBalance -= itemCount;
+            return itemCount;
+        }
+        const allowed = Math.max(0, Math.min(itemCount, this.prepaidRowBalance));
+        this.prepaidRowBalance -= allowed;
+        return allowed;
+    }
+    /** @internal */
     _refuseDefaultDatasetPush(itemCount) {
-        if (itemCount <= 0 || !this.isChargeLimitReached())
+        if (itemCount <= 0 || !this.isPayPerEvent)
+            return false;
+        if (!this.isChargeLimitReached()) {
+            this._takeUnpaidRows(itemCount);
+            return false;
+        }
+        // All-or-nothing here (storage clients cannot store a slice): store the
+        // batch only when earlier charges paid for every row of it.
+        if (this.prepaidRowBalance >= itemCount) {
+            this.prepaidRowBalance -= itemCount;
             return false;
+        }
         this._noteRefusedDefaultDatasetItems(itemCount);
         return true;
     }
@@ -771,7 +846,11 @@ class ChargingManager {
         }
     }
     async charge({ eventName, count = 1 }) {
-        return this._withOperationLock(() => this._chargeExclusive({ eventName, count }));
+        return this._withOperationLock(async () => {
+            const result = await this._chargeExclusive({ eventName, count });
+            this._notePrepaidCharge(eventName, result.chargedCount);
+            return result;
+        });
     }
     /** @internal Caller must hold the operation lock. */
     async _chargeExclusive({ eventName, count = 1 }) {
@@ -983,16 +1062,28 @@ async function pushDataAndCharge({ chargingManager, items, eventName, isDefaultD
         // default-dataset push that does not pay per row (no event, or only free
         // events) stores nothing. Paid pushes go on below, where the budget cap
         // stores only the rows that are actually charged.
+        // Rows the Actor already paid for with an earlier charge() (charge first,
+        // then a plain push) are still stored: see ChargingManager._takeUnpaidRows.
+        // The result still reports the limit, so the Actor stops after them.
+        let unpaidPastLimit = false;
         if (isDefaultDataset &&
             requested > 0 &&
-            chargingManager.isChargeLimitReached?.() &&
-            !chargingManager._isPaidPerItem(eventName, isDefaultDataset)) {
-            chargingManager._noteRefusedDefaultDatasetItems(requested);
-            return {
-                eventChargeLimitReached: true,
-                chargedCount: 0,
-                chargeableWithinLimit: chargingManager._chargeableWithinLimit?.() ?? {},
-            };
+            // 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) {
+                chargingManager._noteRefusedDefaultDatasetItems(requested - allowed);
+                if (allowed === 0) {
+                    return {
+                        eventChargeLimitReached: true,
+                        chargedCount: 0,
+                        chargeableWithinLimit: chargingManager._chargeableWithinLimit?.() ?? {},
+                    };
+                }
+                items = (Array.isArray(items) ? items.slice(0, allowed) : items);
+            }
         }
         const { limitedItems, eventsToCharge } = chargingManager.calculatePushDataLimits({
             items,
@@ -1161,17 +1252,148 @@ async function pushDataAndCharge({ chargingManager, items, eventName, isDefaultD
                 }
                 throw pushErr;
             }
-            return chargeResult;
+            return unpaidPastLimit ? { ...chargeResult, eventChargeLimitReached: true } : chargeResult;
         }
         // No billable events — still persist the budget-limited items.
         await chargeGatedPush.run(true, () => pushFn(Array.isArray(items) ? limitedItems : limitedItems[0]));
         return {
-            eventChargeLimitReached: false,
+            eventChargeLimitReached: unpaidPastLimit,
             chargedCount: 0,
             chargeableWithinLimit: {},
         };
     });
 }
+/** 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.20",
+    "version": "1.2.22",
     "description": "Scrapely SDK for building JavaScript and TypeScript Actors",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
@@ -23,6 +23,7 @@
         "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: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",