apify-client 3.0.0-beta.20 → 3.0.0-beta.21

package/dist/http_client.js

@@ -4,8 +4,8 @@ import { APIFY_ENV_VARS } from '@apify/consts';
 import { concatStreamToBuffer } from '@apify/utilities';
 import { ApifyApiError } from './apify_api_error.js';
 import { InvalidResponseBodyError, requestInterceptors, responseInterceptors } from './interceptors.js';
-import { asArray, cast, getVersionData, isNode, isStream } from './utils.js';
-const { version } = getVersionData();
+import { runtime } from '#runtime';
+import { asArray, cast, getEnv, isStream, version } from './utils.js';
 const RATE_LIMIT_EXCEEDED_STATUS_CODE = 429;
 export class HttpClient {
     stats;
@@ -21,8 +21,7 @@ export class HttpClient {
     httpsAgent;
     axios;
     workflowKey;
-    #nodeInitPromise;
-    #userAgentSuffix;
+    #httpAgentsPromise;
     constructor(options) {
         const { token } = options;
         this.stats = options.apifyClientStats;
@@ -36,8 +35,7 @@ export class HttpClient {
         };
         this.timeoutMaxMillis = options.timeoutMaxSecs * 1000;
         this.logger = options.logger;
-        this.workflowKey = options.workflowKey || process.env[APIFY_ENV_VARS.WORKFLOW_KEY];
-        this.#userAgentSuffix = options.userAgentSuffix;
+        this.workflowKey = options.workflowKey || getEnv(APIFY_ENV_VARS.WORKFLOW_KEY);
         this.axios = axios.create({
             // Disable axios's built-in proxy handling since we're using custom agents
             proxy: false,
@@ -79,64 +77,34 @@ export class HttpClient {
         if (token) {
             this.axios.defaults.headers.Authorization = `Bearer ${token}`;
         }
+        // Browsers do not let a page set the header, so it is only sent where the runtime describes its platform.
+        if (runtime.platform) {
+            const isAtHome = !!getEnv(APIFY_ENV_VARS.IS_AT_HOME);
+            let userAgent = `ApifyClient/${version} (${runtime.platform}); isAtHome/${isAtHome}`;
+            if (options.userAgentSuffix) {
+                userAgent += `; ${asArray(options.userAgentSuffix).join('; ')}`;
+            }
+            this.axios.defaults.headers['User-Agent'] = userAgent;
+        }
         requestInterceptors.forEach((i) => this.axios.interceptors.request.use(i));
         this.userProvidedRequestInterceptors.forEach((i) => this.axios.interceptors.request.use(i));
         responseInterceptors.forEach((i) => this.axios.interceptors.response.use(i));
     }
-    async #ensureNodeInit() {
-        if (!isNode())
-            return;
-        this.#nodeInitPromise ??= this.#initNode();
-        return this.#nodeInitPromise;
+    async #ensureHttpAgents() {
+        this.#httpAgentsPromise ??= this.#initHttpAgents();
+        return this.#httpAgentsPromise;
     }
-    async #initNode() {
-        if (!isNode())
+    async #initHttpAgents() {
+        const agents = await runtime.createHttpAgents({ timeoutMillis: this.timeoutMaxMillis });
+        if (!agents)
             return;
-        const [{ ProxyAgent }, os] = await Promise.all([import('proxy-agent'), import('node:os')]);
-        // We want to keep sockets alive for better performance.
-        // Enhanced agent configuration based on agentkeepalive best practices:
-        // - Nagle's algorithm disabled for lower latency
-        // - Free socket timeout to prevent socket leaks
-        // - LIFO scheduling to reuse recent sockets
-        // - Socket TTL for connection freshness
-        const agentOptions = {
-            keepAlive: true,
-            // Timeout for inactive sockets
-            // Prevents socket leaks from idle connections
-            timeout: this.timeoutMaxMillis,
-            // Keep alive timeout for free sockets (15 seconds)
-            // Node.js will close unused sockets after this period
-            keepAliveMsecs: 15_000,
-            // Maximum number of sockets per host
-            maxSockets: 256,
-            maxFreeSockets: 256,
-            // LIFO scheduling - reuse most recently used sockets for better performance
-            scheduling: 'lifo',
-        };
-        // Use ProxyAgent which automatically detects proxy from environment variables
-        // and supports CONNECT tunneling
-        const proxyAgent = new ProxyAgent(agentOptions);
-        this.httpAgent = proxyAgent;
-        this.httpsAgent = proxyAgent;
-        // Disable Nagle's algorithm for lower latency
-        // This sends data immediately instead of buffering small packets
-        const setNoDelay = (socket) => {
-            socket.setNoDelay(true);
-        };
-        this.httpAgent.on('socket', setNoDelay);
-        this.httpsAgent.on('socket', setNoDelay);
+        this.httpAgent = agents.httpAgent;
+        this.httpsAgent = agents.httpsAgent;
         this.axios.defaults.httpAgent = this.httpAgent;
         this.axios.defaults.httpsAgent = this.httpsAgent;
-        // Works only in Node. Cannot be set in browser
-        const isAtHome = !!process.env[APIFY_ENV_VARS.IS_AT_HOME];
-        let userAgent = `ApifyClient/${version} (${os.platform()}; Node/${process.version}); isAtHome/${isAtHome}`;
-        if (this.#userAgentSuffix) {
-            userAgent += `; ${asArray(this.#userAgentSuffix).join('; ')}`;
-        }
-        this.axios.defaults.headers['User-Agent'] = userAgent;
     }
     async call(config) {
-        await this.#ensureNodeInit();
+        await this.#ensureHttpAgents();
         this.stats.calls++;
         const makeRequest = this.#createRequestHandler(config);
         return retry(makeRequest, {

package/dist/interceptors.js

@@ -1,7 +1,7 @@
 import axios, { AxiosHeaders } from 'axios';
 import contentTypeParser from 'content-type';
 import { maybeParseBody } from './body_parser.js';
-import { isCompressibleContentType, isNode, maybeCompressValue } from './utils.js';
+import { isCompressibleContentType, maybeCompressValue } from './utils.js';
 /**
  * This error exists for the quite common situation, where only a partial JSON response is received and
  * an attempt to parse the JSON throws an error. In most cases this can be resolved by retrying the
@@ -100,8 +100,8 @@ function parseResponseData(response) {
     ) {
         return response;
     }
-    const isBufferEmpty = isNode() ? !response.data.length : !response.data.byteLength;
-    if (isBufferEmpty) {
+    // A `Buffer` from the Node.js adapter and an `ArrayBuffer` from the browser ones both carry `byteLength`.
+    if (!response.data.byteLength) {
         // undefined is better than an empty buffer
         response.data = undefined;
         return response;

package/dist/resource_clients/key_value_store.js

@@ -4,7 +4,8 @@ import { createHmacSignatureAsync, createStorageContentSignatureAsync } from '@a
 import { ResourceClient } from '../base/resource_client.js';
 import * as schemas from '../schemas.js';
 import { timeoutOptionsSchema, timeoutOptionsShape } from '../timeouts.js';
-import { anyObjectSchema, applyQueryParamsToUrl, catchNotFoundOrThrow, isBuffer, isNode, isStream, parseArgument, parseResponse, } from '../utils.js';
+import { runtime } from '#runtime';
+import { anyObjectSchema, applyQueryParamsToUrl, catchNotFoundOrThrow, isBuffer, isStream, parseArgument, parseResponse, } from '../utils.js';
 const listKeysOptionsSchema = z.strictObject({
     limit: z.number().min(0).optional(),
     exclusiveStartKey: z.string().optional(),
@@ -310,7 +311,7 @@ export class KeyValueStoreClient extends ResourceClient {
     async getRecord(key, options = {}) {
         parseArgument(key, keySchema);
         const parsed = parseArgument(options, getRecordOptionsSchema, 'KeyValueClientGetRecordOptions');
-        if (parsed.stream && !isNode()) {
+        if (parsed.stream && !runtime.isNode) {
             throw new Error('The stream option can only be used in Node.js environment.');
         }
         if ('disableRedirect' in parsed) {

package/dist/resource_clients/log.js

@@ -3,7 +3,7 @@ import { z } from 'zod';
 import log, { Logger, LogLevel } from '@apify/log';
 import { ResourceClient } from '../base/resource_client.js';
 import { timeoutOptionsShape } from '../timeouts.js';
-import { cast, catchNotFoundForResourceOrThrow, parseArgument } from '../utils.js';
+import { cast, catchNotFoundForResourceOrThrow, concatBytes, parseArgument } from '../utils.js';
 const logOptionsSchema = z.strictObject({ raw: z.boolean().optional(), ...timeoutOptionsShape });
 /**
  * Client for accessing Actor run or build logs.
@@ -132,6 +132,7 @@ export class LoggerActorRedirect extends Logger {
 export class StreamedLog {
     #destinationLog;
     #streamBuffer = [];
+    #decoder = new TextDecoder();
     #splitMarker = /(?:\n|^)(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z)/g;
     #relevancyTimeLimit;
     #logClient;
@@ -184,7 +185,7 @@ export class StreamedLog {
             }
             const lastChunkRemainder = await this.#logStreamChunks(logStream);
             // Process whatever is left when exiting. Maybe it is incomplete, maybe it is last log without EOL.
-            const lastMessage = Buffer.from(lastChunkRemainder).toString().trim();
+            const lastMessage = this.#decoder.decode(lastChunkRemainder).trim();
             if (lastMessage.length) {
                 this.#destinationLog.info(lastMessage);
             }
@@ -205,7 +206,7 @@ export class StreamedLog {
             const lastCompleteMessageIndex = chunkWithPreviousRemainder.lastIndexOf(0x0a);
             previousChunkRemainder = chunkWithPreviousRemainder.slice(lastCompleteMessageIndex);
             // Push complete part of the chunk to the buffer
-            this.#streamBuffer.push(Buffer.from(chunkWithPreviousRemainder.slice(0, lastCompleteMessageIndex)));
+            this.#streamBuffer.push(chunkWithPreviousRemainder.slice(0, lastCompleteMessageIndex));
             this.#logBufferContent();
             // Keep processing the new data until stopped
             if (this.#stopLogging) {
@@ -218,7 +219,7 @@ export class StreamedLog {
      * Parse the buffer and log complete messages.
      */
     #logBufferContent() {
-        const allParts = Buffer.concat(this.#streamBuffer).toString().split(this.#splitMarker).slice(1);
+        const allParts = this.#decoder.decode(concatBytes(this.#streamBuffer)).split(this.#splitMarker).slice(1);
         // Parse the buffer parts into complete messages
         const messageMarkers = allParts.filter((_, i) => i % 2 === 0);
         const messageContents = allParts.filter((_, i) => i % 2 !== 0);

package/dist/resource_clients/run.js

@@ -3,7 +3,8 @@ import { LEVELS, Log } from '@apify/log';
 import { ResourceClient } from '../base/resource_client.js';
 import * as schemas from '../schemas.js';
 import { optionalTimeoutSchema, timeoutOptionsSchema, timeoutOptionsShape } from '../timeouts.js';
-import { anyObjectSchema, isNode, parseArgument, parseResponse } from '../utils.js';
+import { runtime } from '#runtime';
+import { anyObjectSchema, parseArgument, parseResponse } from '../utils.js';
 import { DatasetClient } from './dataset.js';
 import { KeyValueStoreClient } from './key_value_store.js';
 import { LogClient, LoggerActorRedirect, StreamedLog } from './log.js';
@@ -426,7 +427,7 @@ export class RunClient extends ResourceClient {
         parseArgument(options.timeoutSecs, optionalTimeoutSchema);
         const { fromStart = true, timeoutSecs = 'long' } = options;
         let { toLog } = options;
-        if (toLog === null || !isNode()) {
+        if (toLog === null || !runtime.isNode) {
             // Explicitly no logging or not in Node.js
             return undefined;
         }

package/dist/runtime/node.d.ts

@@ -0,0 +1,6 @@
+import type { Runtime } from './types.js';
+/**
+ * The Node.js implementation of {@link Runtime}. Deno and Bun resolve the `node` condition too and
+ * provide the built-ins it uses.
+ */
+export declare const runtime: Runtime;

package/dist/runtime/node.js

@@ -0,0 +1,58 @@
+import os from 'node:os';
+import { promisify } from 'node:util';
+import { brotliCompress, constants, gzip } from 'node:zlib';
+/**
+ * The Node.js implementation of {@link Runtime}. Deno and Bun resolve the `node` condition too and
+ * provide the built-ins it uses.
+ */
+export const runtime = {
+    isNode: true,
+    platform: `${os.platform()}; Node/${process.version}`,
+    async compress(data) {
+        try {
+            // `promisify()` belongs inside the fallback chain: a partial `node:zlib` can export
+            // `brotliCompress` without implementing it, and `promisify(undefined)` throws. At module scope
+            // that would fail the whole import instead of falling through to gzip.
+            const options = { params: { [constants.BROTLI_PARAM_QUALITY]: 6 } };
+            return { data: await promisify(brotliCompress)(data, options), encoding: 'br' };
+        }
+        catch {
+            // Runtimes that only provide a partial `node:zlib` (Node.js compatibility shims) may not implement
+            // brotli, but usually do implement gzip.
+        }
+        try {
+            return { data: await promisify(gzip)(data), encoding: 'gzip' };
+        }
+        catch {
+            return undefined;
+        }
+    },
+    async createHttpAgents({ timeoutMillis }) {
+        // Loaded on the first request rather than with the client: the proxy support pulls in a sizeable
+        // dependency tree that a client which never sends a request should not pay for.
+        const { ProxyAgent } = await import('proxy-agent');
+        // We want to keep sockets alive for better performance.
+        const agentOptions = {
+            keepAlive: true,
+            // Timeout for inactive sockets
+            // Prevents socket leaks from idle connections
+            timeout: timeoutMillis,
+            // Keep alive timeout for free sockets (15 seconds)
+            // Node.js will close unused sockets after this period
+            keepAliveMsecs: 15_000,
+            // Maximum number of sockets per host
+            maxSockets: 256,
+            maxFreeSockets: 256,
+            // LIFO scheduling - reuse most recently used sockets for better performance
+            scheduling: 'lifo',
+        };
+        // ProxyAgent picks the proxy up from the environment variables and supports CONNECT tunneling.
+        const agent = new ProxyAgent(agentOptions);
+        // Disable Nagle's algorithm for lower latency
+        // This sends data immediately instead of buffering small packets
+        agent.on('socket', (socket) => {
+            socket.setNoDelay(true);
+        });
+        return { httpAgent: agent, httpsAgent: agent };
+    },
+};

package/dist/runtime/types.d.ts

@@ -0,0 +1,50 @@
+import type http from 'node:http';
+import type https from 'node:https';
+/**
+ * A request body compressed for transport, with the `content-encoding` value that declares it.
+ * @internal
+ */
+export interface CompressedValue {
+    data: Uint8Array;
+    encoding: 'br' | 'gzip';
+}
+/**
+ * The agents axios's Node.js adapter sends requests through.
+ * @internal
+ */
+export interface HttpAgents {
+    httpAgent: http.Agent;
+    httpsAgent: https.Agent;
+}
+/**
+ * The runtime-specific part of the client. `#runtime` resolves to the Node.js implementation under the `node`
+ * condition and to the Web API one everywhere else (see the `imports` field of `package.json`), so a bundler
+ * targeting a browser or an edge runtime never sees the Node.js built-ins the Node.js one uses.
+ * @internal
+ */
+export interface Runtime {
+    /**
+     * Whether the Node.js implementation was selected, which the `node` condition settles when `#runtime` is
+     * resolved - so a Node.js application bundled for a browser or a neutral target reports `false`. The
+     * features that need a Node.js `Readable` response - log streaming and the `stream` record option - are
+     * gated on it.
+     */
+    isNode: boolean;
+    /**
+     * The platform part of the `User-Agent` header, or `undefined` where the runtime does not let a client
+     * set that header (browsers).
+     */
+    platform: string | undefined;
+    /**
+     * Compresses a request body, or resolves to `undefined` where compression is not available. Compression
+     * is a best-effort optimization, so it never throws.
+     */
+    compress(data: Uint8Array): Promise<CompressedValue | undefined>;
+    /**
+     * Creates the agents axios's Node.js adapter sends requests through, or resolves to `undefined` where
+     * axios does not use agents.
+     */
+    createHttpAgents(options: {
+        timeoutMillis: number;
+    }): Promise<HttpAgents | undefined>;
+}

package/dist/runtime/types.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/web.d.ts

@@ -0,0 +1,5 @@
+import type { Runtime } from './types.js';
+/**
+ * The {@link Runtime} for browsers and edge runtimes, built on Web APIs only.
+ */
+export declare const runtime: Runtime;

package/dist/runtime/web.js

@@ -0,0 +1,17 @@
+/**
+ * The {@link Runtime} for browsers and edge runtimes, built on Web APIs only.
+ */
+export const runtime = {
+    isNode: false,
+    // Browsers do not let a page set the `User-Agent` header.
+    platform: undefined,
+    // No request compression: brotli has no Web API, and a `content-encoding` request header is not on the
+    // list of headers the Apify API allows in a cross-origin request, so a browser would fail the preflight.
+    async compress() {
+        return undefined;
+    },
+    // The XHR and fetch adapters of axios do not use agents.
+    async createHttpAgents() {
+        return undefined;
+    },
+};

package/dist/utils.d.ts

@@ -4,8 +4,10 @@ import { z } from 'zod';
 import type { ApifyApiError } from './apify_api_error.js';
 import { parseArgument } from '@apify/validations';
 import type { ApifyResponse } from './http_client.js';
+import type { CompressedValue } from './runtime/types.js';
 import type { RequestQueueClientListRequestsOptions, RequestQueueClientListRequestsResult } from './resource_clients/request_queue.js';
 import type { WebhookUpdateData } from './resource_clients/webhook.js';
+export declare const version: any;
 export { parseArgument };
 /**
  * Accepts any non-null, non-array object as a predicate for `z.custom()`.
@@ -59,10 +61,16 @@ export declare function catchNotFoundForResourceOrThrow(err: ApifyApiError, reso
  * Helper function that converts array of webhooks to base64 string
  */
 export declare function stringifyWebhooksToBase64(webhooks?: readonly WebhookUpdateData[]): string | undefined;
-export interface CompressedValue {
-    data: Buffer;
-    encoding: 'br' | 'gzip';
-}
+/**
+ * Encodes bytes as base64. `btoa()` takes a binary string, and the bytes are turned into one in slices,
+ * because spreading them all into a single `String.fromCharCode()` call overflows the argument limit on
+ * inputs of a few tens of kilobytes.
+ */
+export declare function bytesToBase64(bytes: Uint8Array): string;
+/**
+ * Concatenates byte chunks into one array.
+ */
+export declare function concatBytes(chunks: Uint8Array[]): Uint8Array;
 /**
  * Decides whether a request body with the given content type is worth compressing.
  *
@@ -74,10 +82,14 @@ export interface CompressedValue {
  */
 export declare function isCompressibleContentType(contentType?: string): boolean;
 /**
- * Compress the passed value using brotli, falling back to gzip. Returns undefined if the data is
- * too small / wrong type, or if neither algorithm is available.
+ * Compresses the passed value with the runtime's best available algorithm. Returns `undefined` if the data
+ * is too small, is not a string or binary value, or if the runtime does not offer compression.
  */
 export declare function maybeCompressValue(value: unknown): Promise<CompressedValue | undefined>;
+/**
+ * Reads an environment variable, on runtimes that have them.
+ */
+export declare function getEnv(name: string): string | undefined;
 /**
  * Returns the UTF-8 byte length of a string.
  */
@@ -94,12 +106,8 @@ export declare function splitIntoJsonArrayBatches<T extends {
     maxCount: number;
     maxByteLength: number;
 }): T[][];
-export declare function isNode(): boolean;
 export declare function isBuffer(value: unknown): value is Buffer | ArrayBuffer | TypedArray;
 export declare function isStream(value: unknown): value is Readable;
-export declare function getVersionData(): {
-    version: string;
-};
 /**
  * Helper class to create async iterators from paginated list endpoints.
  */
@@ -108,10 +116,6 @@ export declare class RequestQueuePaginationIterator {
     constructor(options: RequestQueuePaginationIteratorOptions);
     [Symbol.asyncIterator](): AsyncIterator<RequestQueueClientListRequestsResult>;
 }
-declare global {
-    export const BROWSER_BUILD: boolean | undefined;
-    export const VERSION: string | undefined;
-}
 /**
  * Options for creating a pagination iterator.
  */

package/dist/utils.js

@@ -1,10 +1,14 @@
 import { z } from 'zod';
 import { NotFoundError } from './apify_api_error.js';
 import { parseArgument } from '@apify/validations';
+import { runtime } from '#runtime';
 import { ResponseValidationError } from './response_validation_error.js';
 // @ts-ignore if we enable `resolveJsonModule`, we end up with a `src` folder in `dist`
 import packageJson from '../package.json' with { type: 'json' };
 const MIN_COMPRESS_BYTES = 1024;
+const textEncoder = new TextEncoder();
+// Only the version, so a bundler can drop the rest of the manifest.
+export const { version } = packageJson;
 /** Media type prefixes whose payloads carry their own compression, so compressing the request body is wasted work. */
 const ALREADY_COMPRESSED_MEDIA_TYPE_PREFIXES = ['audio/', 'image/', 'video/'];
 /** Exact media types whose payloads carry their own compression. */
@@ -126,39 +130,45 @@ export function catchNotFoundForResourceOrThrow(err, resourceId) {
 export function stringifyWebhooksToBase64(webhooks) {
     if (!webhooks)
         return;
-    const webhooksJson = JSON.stringify(webhooks);
-    if (isNode()) {
-        return Buffer.from(webhooksJson, 'utf8').toString('base64');
-    }
-    const encoder = new TextEncoder();
-    const uint8Array = encoder.encode(webhooksJson);
-    return btoa(String.fromCharCode(...uint8Array));
+    return bytesToBase64(textEncoder.encode(JSON.stringify(webhooks)));
 }
-let brotliCompressPromisified;
 /**
- * Brotli-compress the provided value.
+ * Encodes bytes as base64. `btoa()` takes a binary string, and the bytes are turned into one in slices,
+ * because spreading them all into a single `String.fromCharCode()` call overflows the argument limit on
+ * inputs of a few tens of kilobytes.
  */
-async function brotliValue(value) {
-    if (!brotliCompressPromisified) {
-        const { promisify } = await import('node:util');
-        const { brotliCompress, constants } = await import('node:zlib');
-        const compress = promisify(brotliCompress);
-        const options = { params: { [constants.BROTLI_PARAM_QUALITY]: 6 } };
-        brotliCompressPromisified = async (input) => compress(input, options);
+export function bytesToBase64(bytes) {
+    const SLICE_LENGTH = 0x8000;
+    let binary = '';
+    for (let i = 0; i < bytes.length; i += SLICE_LENGTH) {
+        binary += String.fromCharCode(...bytes.subarray(i, i + SLICE_LENGTH));
     }
-    return brotliCompressPromisified(value);
+    return btoa(binary);
 }
-let gzipPromisified;
 /**
- * Gzip-compress the provided value.
+ * Concatenates byte chunks into one array.
  */
-async function gzipValue(value) {
-    if (!gzipPromisified) {
-        const { promisify } = await import('node:util');
-        const { gzip } = await import('node:zlib');
-        gzipPromisified = promisify(gzip);
+export function concatBytes(chunks) {
+    const result = new Uint8Array(chunks.reduce((length, chunk) => length + chunk.length, 0));
+    let offset = 0;
+    for (const chunk of chunks) {
+        result.set(chunk, offset);
+        offset += chunk.length;
     }
-    return gzipPromisified(value);
+    return result;
+}
+/**
+ * Views a request body as bytes: a string is UTF-8 encoded, binary values are viewed in place. Anything else
+ * - a stream, a `Blob`, form data - is `undefined`.
+ */
+function toBytes(value) {
+    if (typeof value === 'string')
+        return textEncoder.encode(value);
+    if (!isBuffer(value))
+        return undefined;
+    return ArrayBuffer.isView(value)
+        ? new Uint8Array(value.buffer, value.byteOffset, value.byteLength)
+        : new Uint8Array(value);
 }
 /**
  * Decides whether a request body with the given content type is worth compressing.
@@ -183,40 +193,28 @@ export function isCompressibleContentType(contentType) {
     return !ALREADY_COMPRESSED_MEDIA_TYPE_PREFIXES.some((prefix) => mediaType.startsWith(prefix));
 }
 /**
- * Compress the passed value using brotli, falling back to gzip. Returns undefined if the data is
- * too small / wrong type, or if neither algorithm is available.
+ * Compresses the passed value with the runtime's best available algorithm. Returns `undefined` if the data
+ * is too small, is not a string or binary value, or if the runtime does not offer compression.
  */
 export async function maybeCompressValue(value) {
-    if (!isNode())
-        return undefined;
     // Request compression is not that important so let's
     // skip it instead of throwing for unsupported types.
-    if (typeof value !== 'string' && !Buffer.isBuffer(value))
-        return undefined;
-    const areDataLargeEnough = Buffer.byteLength(value) >= MIN_COMPRESS_BYTES;
-    if (!areDataLargeEnough)
+    const bytes = toBytes(value);
+    if (!bytes || bytes.byteLength < MIN_COMPRESS_BYTES)
         return undefined;
-    try {
-        return { data: await brotliValue(value), encoding: 'br' };
-    }
-    catch {
-        // Runtimes that only provide a partial `node:zlib` (bundler polyfills, edge runtimes with
-        // Node compatibility shims) may not implement brotli, but usually do implement gzip.
-    }
-    try {
-        return { data: await gzipValue(value), encoding: 'gzip' };
-    }
-    catch {
-        // Same reasoning as above: compression is a best-effort optimization, so skip it instead
-        // of failing the request.
-        return undefined;
-    }
+    return runtime.compress(bytes);
+}
+/**
+ * Reads an environment variable, on runtimes that have them.
+ */
+export function getEnv(name) {
+    return typeof process !== 'undefined' ? process.env?.[name] : undefined;
 }
 /**
  * Returns the UTF-8 byte length of a string.
  */
 export function utf8ByteLength(value) {
-    return isNode() ? Buffer.byteLength(value) : new Blob([value]).size;
+    return textEncoder.encode(value).byteLength;
 }
 /**
  * Splits JSON-serialized items into consecutive batches of at most `maxCount` items, each of which fits into a JSON
@@ -243,11 +241,6 @@ export function splitIntoJsonArrayBatches(items, { maxCount, maxByteLength }) {
         batches.push(batch);
     return batches;
 }
-export function isNode() {
-    if (typeof BROWSER_BUILD !== 'undefined')
-        return false;
-    return !!(typeof process !== 'undefined' && process.versions && process.versions.node);
-}
 export function isBuffer(value) {
     // Tag checks rather than `instanceof`, to also match buffers from another realm. `isView()`
     // additionally covers `DataView`, which is not raw binary content.
@@ -264,12 +257,6 @@ export function isStream(value) {
     const { on, pipe } = value;
     return typeof on === 'function' && typeof pipe === 'function';
 }
-export function getVersionData() {
-    if (typeof BROWSER_BUILD !== 'undefined') {
-        return { version: VERSION };
-    }
-    return packageJson;
-}
 /**
  * Helper class to create async iterators from paginated list endpoints.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apify-client",
-  "version": "3.0.0-beta.20",
+  "version": "3.0.0-beta.21",
   "description": "Apify API client for JavaScript",
   "engines": {
     "node": ">=22.0.0"
@@ -10,6 +10,12 @@
   "types": "dist/index.d.ts",
   "browser": "dist/bundle.js",
   "unpkg": "dist/bundle.js",
+  "imports": {
+    "#runtime": {
+      "node": "./dist/runtime/node.js",
+      "default": "./dist/runtime/web.js"
+    }
+  },
   "exports": {
     "./package.json": "./package.json",
     "./browser": "./dist/bundle.js",