apify-client 3.0.0-beta.7 → 3.0.0-beta.71

package/dist/utils.js

@@ -4,7 +4,61 @@ import { parseArgument } from '@apify/validations';
 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;
+/**
+ * Smallest request body, in bytes, that is worth compressing. A smaller body already fits in a single network
+ * packet, so compressing it costs CPU time without saving a round trip, and the compression format itself can
+ * make it larger.
+ * @internal
+ */
+export 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. */
+const ALREADY_COMPRESSED_MEDIA_TYPES = new Set([
+    'application/epub+zip',
+    'application/gzip',
+    'application/java-archive',
+    'application/vnd.android.package-archive',
+    'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+    'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    'application/vnd.rar',
+    'application/x-7z-compressed',
+    'application/x-bzip',
+    'application/x-bzip2',
+    'application/x-gzip',
+    'application/x-rar-compressed',
+    'application/x-xz',
+    'application/x-zip-compressed',
+    'application/zip',
+    'application/zstd',
+    'font/woff',
+    'font/woff2',
+]);
+/** Uncompressed media types that sit under an already-compressed prefix, so compressing them still pays off. */
+const COMPRESSIBLE_MEDIA_TYPES = new Set([
+    'audio/aiff',
+    'audio/basic',
+    'audio/l16',
+    'audio/l24',
+    'audio/midi',
+    'audio/vnd.wave',
+    'audio/wav',
+    'audio/wave',
+    'audio/x-aiff',
+    'audio/x-wav',
+    'image/bmp',
+    'image/tiff',
+    'image/vnd.adobe.photoshop',
+    'image/vnd.microsoft.icon',
+    'image/x-icon',
+    'image/x-ms-bmp',
+]);
+/** Structured syntax suffixes marking a media type as text even under an already-compressed prefix (`image/svg+xml`). */
+const COMPRESSIBLE_MEDIA_TYPE_SUFFIXES = ['+json', '+xml'];
 export { parseArgument };
 /**
  * Accepts any non-null, non-array object as a predicate for `z.custom()`.
@@ -26,35 +80,30 @@ export const anyObjectSchema = z.custom(isNonArrayObject, {
 // any tree-shaking bundler drops it and every message degrades to a bare "Invalid input". Passing it
 // in per parse keeps them intact without reaching into the zod config the whole process shares.
 const { localeError } = z.locales.en();
+const RESPONSE_ENVELOPE_SCHEMA = z.object({ data: z.unknown() });
 /**
- * Turns a JSON API response into the value a resource method returns: unwraps the `data` envelope, converts the
- * date fields and validates the result against `schema`, one of the schemas generated from the OpenAPI
- * specification. The validated copy is what callers get, so it is exactly what the schema accepted -- unknown
- * fields and unknown enum values included, since the schemas let both through.
+ * Turns a JSON API response into the value a resource method returns: unwraps the `data` envelope and validates the
+ * result against `schema`, one of the schemas generated from the OpenAPI specification. The validated copy is what
+ * callers get, so it is the schema's output -- unknown fields and unknown enum values included, since the schemas let
+ * both through, date-time fields turned into `Date` objects, and URL fields normalized, since `z.url()` hands back the
+ * parsed URL's serialization.
  *
  * Throws {@link ResponseValidationError} when the response does not match the specification.
  * @internal
  */
-export function parseResponse(response, schema, shouldParseField = null) {
-    const data = parseDateFields(pluckData(response.data), shouldParseField);
+export function parseResponse(response, schema) {
+    const { method = 'GET', url = '' } = response.config;
+    const envelope = RESPONSE_ENVELOPE_SCHEMA.safeParse(response.data, { error: localeError });
+    if (!envelope.success) {
+        throw new ResponseValidationError(envelope.error, response.data, { method, url });
+    }
+    const { data } = envelope.data;
     const result = schema.safeParse(data, { error: localeError });
     if (!result.success) {
-        const { method = 'GET', url = '' } = response.config;
         throw new ResponseValidationError(result.error, data, { method, url });
     }
     return result.data;
 }
-/**
- * Returns object's 'data' property or throws if parameter is not an object,
- * or an object without a 'data' property.
- */
-export function pluckData(obj) {
-    if (typeof obj === 'object' && obj) {
-        if (typeof obj.data !== 'undefined')
-            return obj.data;
-    }
-    throw new Error(`Expected response object with a "data" property, but received: ${obj}`);
-}
 /**
  * Swallows a 404 Not Found API error and rethrows anything else.
  */
@@ -63,51 +112,16 @@ export function catchNotFoundOrThrow(err) {
         throw err;
 }
 /**
- * Traverses JSON structure and converts fields that end with "At" to a Date object (fields such as "modifiedAt" or
- * "createdAt").
- *
- * If you want parse other fields as well, you can provide a custom matcher function shouldParseField(). This
- * admittedly awkward approach allows this function to be reused for various purposes without introducing potential
- * breaking changes.
+ * Like `catchNotFoundOrThrow()`, but swallows the 404 only when the client names its resource by ID.
  *
- * If the field cannot be converted to Date, it is left as is.
+ * A chained client without an ID, such as `run.dataset()` or `run.log()`, requests a path where a 404 can mean either
+ * the parent or the default sub-resource is missing. The response cannot tell the two apart, so the error propagates.
+ * @internal
  */
-export function parseDateFields(input, shouldParseField = null, depth = 0) {
-    // Don't go too deep to avoid stack overflows (especially if there is a circular reference). The depth of 4
-    // corresponds to obj.items.[x].someArrayField.[y].field, which is what a list response looks like: it
-    // nests one level deeper than the single resource it wraps, because both the item array and the nested
-    // array spend a level.
-    //
-    // In a list response it also reaches one level into caller-owned blobs the API stores verbatim, so a
-    // listed request's `userData.foo.somethingAt` comes back as a `Date` rather than the string it was
-    // written as.
-    // TODO: Consider removing this limitation. It might came across as an annoying surprise as it's not communicated.
-    if (depth > 4) {
-        return input;
-    }
-    if (Array.isArray(input))
-        return input.map((child) => parseDateFields(child, shouldParseField, depth + 1));
-    if (!input || typeof input !== 'object')
-        return input;
-    return Object.entries(input).reduce((output, [k, v]) => {
-        const isValObject = !!v && typeof v === 'object';
-        if (k.endsWith('At') || (shouldParseField && shouldParseField(k))) {
-            if (v) {
-                const d = new Date(v);
-                output[k] = Number.isNaN(d.getTime()) ? v : d;
-            }
-            else {
-                output[k] = v;
-            }
-        }
-        else if (isValObject || Array.isArray(v)) {
-            output[k] = parseDateFields(v, shouldParseField, depth + 1);
-        }
-        else {
-            output[k] = v;
-        }
-        return output;
-    }, {});
+export function catchNotFoundForResourceOrThrow(err, resourceId) {
+    if (!resourceId)
+        throw err;
+    catchNotFoundOrThrow(err);
 }
 /**
  * Helper function that converts array of webhooks to base64 string
@@ -115,98 +129,105 @@ export function parseDateFields(input, shouldParseField = null, depth = 0) {
 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;
 }
 /**
- * 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.
+ * 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`.
+ * @internal
  */
-export async function maybeCompressValue(value) {
-    if (!isNode())
+export function toBytes(value) {
+    if (typeof value === 'string')
+        return textEncoder.encode(value);
+    if (!isBuffer(value))
         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)
-        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 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.
+ *
+ * Images, audio, video and archives already carry their own compression. Running them through brotli or gzip
+ * burns CPU, holds a second full copy of the body in memory, and usually produces output slightly larger than
+ * the input. Formats that are raw despite such a media type, for example `image/bmp` or `audio/wav`, are still
+ * compressed. A body with no content type is assumed to be compressible.
+ * @internal
+ */
+export function isCompressibleContentType(contentType) {
+    if (!contentType)
+        return true;
+    // `Content-Type` is case-insensitive and may carry parameters, for example `text/plain; charset=utf-8`.
+    const mediaType = contentType.split(';', 1)[0].trim().toLowerCase();
+    if (COMPRESSIBLE_MEDIA_TYPES.has(mediaType))
+        return true;
+    if (COMPRESSIBLE_MEDIA_TYPE_SUFFIXES.some((suffix) => mediaType.endsWith(suffix)))
+        return true;
+    if (ALREADY_COMPRESSED_MEDIA_TYPES.has(mediaType))
+        return false;
+    return !ALREADY_COMPRESSED_MEDIA_TYPE_PREFIXES.some((prefix) => mediaType.startsWith(prefix));
+}
+/**
+ * Reads an environment variable, on runtimes that have them.
+ */
+export function getEnv(name) {
+    return typeof process !== 'undefined' ? process.env?.[name] : undefined;
 }
 /**
- * Helper function slice the items from array to fit the max byte length.
+ * Returns the UTF-8 byte length of a string.
  */
-export function sliceArrayByByteLength(array, maxByteLength, startIndex) {
-    const stringByteLength = (str) => (isNode() ? Buffer.byteLength(str) : new Blob([str]).size);
-    const arrayByteLength = stringByteLength(JSON.stringify(array));
-    if (arrayByteLength < maxByteLength)
-        return array;
-    const slicedArray = [];
-    let byteLength = 2; // 2 bytes for the empty array []
-    for (let i = 0; i < array.length; i++) {
-        const item = array[i];
-        const itemByteSize = stringByteLength(JSON.stringify(item));
-        if (itemByteSize > maxByteLength) {
-            throw new Error(`RequestQueueClient.batchAddRequests: The size of the request with index: ${startIndex + i} ` +
-                `exceeds the maximum allowed size (${maxByteLength} bytes).`);
+export function utf8ByteLength(value) {
+    return textEncoder.encode(value).byteLength;
+}
+/**
+ * Splits JSON-serialized items into consecutive batches of at most `maxCount` items, each of which fits into a JSON
+ * array body - the items joined by commas between brackets - of at most `maxByteLength` bytes. The `byteLength` of an
+ * item is the UTF-8 byte length of its serialization. An item too large for a body of its own still gets one, so a
+ * caller that cannot send such an item has to reject it beforehand.
+ */
+export function splitIntoJsonArrayBatches(items, { maxCount, maxByteLength }) {
+    const batches = [];
+    let batch = [];
+    // One byte for the opening bracket; each item then adds its own bytes plus one for the comma or the closing
+    // bracket that follows it.
+    let byteLength = 1;
+    for (const item of items) {
+        if (batch.length > 0 && (batch.length >= maxCount || byteLength + item.byteLength + 1 > maxByteLength)) {
+            batches.push(batch);
+            batch = [];
+            byteLength = 1;
         }
-        if (byteLength + itemByteSize >= maxByteLength)
-            break;
-        byteLength += itemByteSize;
-        slicedArray.push(item);
+        batch.push(item);
+        byteLength += item.byteLength + 1;
     }
-    return slicedArray;
-}
-export function isNode() {
-    if (typeof BROWSER_BUILD !== 'undefined')
-        return false;
-    return !!(typeof process !== 'undefined' && process.versions && process.versions.node);
+    if (batch.length > 0)
+        batches.push(batch);
+    return batches;
 }
 export function isBuffer(value) {
     // Tag checks rather than `instanceof`, to also match buffers from another realm. `isView()`
@@ -224,34 +245,28 @@ 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.
  */
 export class RequestQueuePaginationIterator {
-    maxPageLimit;
-    getPage;
-    limit;
-    cursor;
+    #maxPageLimit;
+    #getPage;
+    #limit;
+    #cursor;
     constructor(options) {
-        this.maxPageLimit = options.maxPageLimit;
-        this.limit = options.limit;
-        this.cursor = options.cursor;
-        this.getPage = options.getPage;
+        this.#maxPageLimit = options.maxPageLimit;
+        this.#limit = options.limit;
+        this.#cursor = options.cursor;
+        this.#getPage = options.getPage;
     }
     async *[Symbol.asyncIterator]() {
-        let nextCursor = this.cursor;
+        let nextCursor = this.#cursor;
         let iterateItemCount = 0;
         while (true) {
-            const pageLimit = this.limit
-                ? Math.min(this.maxPageLimit, this.limit - iterateItemCount)
-                : this.maxPageLimit;
-            const page = await this.getPage({
+            const pageLimit = this.#limit
+                ? Math.min(this.#maxPageLimit, this.#limit - iterateItemCount)
+                : this.#maxPageLimit;
+            const page = await this.#getPage({
                 limit: pageLimit,
                 cursor: nextCursor,
             });
@@ -261,12 +276,28 @@ export class RequestQueuePaginationIterator {
             yield page;
             iterateItemCount += page.items.length;
             // Limit reached stopping to iterate
-            if ((this.limit && iterateItemCount >= this.limit) || !page.nextCursor)
+            if ((this.#limit && iterateItemCount >= this.#limit) || !page.nextCursor)
                 return;
             nextCursor = page.nextCursor;
         }
     }
 }
+/**
+ * The smaller of two page limits, for the `limit` query parameter. The API treats a `limit` of 0 as unset, so 0 here
+ * means no limit and loses to any other value.
+ * @internal
+ */
+export function minForLimitParam(a, b) {
+    if (a === 0)
+        a = undefined;
+    if (b === 0)
+        b = undefined;
+    if (a === undefined)
+        return b;
+    if (b === undefined)
+        return a;
+    return Math.min(a, b);
+}
 /**
  * Schema shape of {@link PaginationOptions}, to spread into every paginating client's list schema. One
  * copy stops it drifting from the interface.
@@ -277,6 +308,16 @@ export const paginationOptionsShape = {
     offset: z.number().min(0).optional(),
     chunkSize: z.number().positive().optional(),
 };
+/**
+ * Key under which a page of dataset items carries the number of rows the API scanned to produce it, as a
+ * non-enumerable property that stays out of the page's public shape. The API applies `offset` and `limit` to the
+ * dataset's rows first and shapes the result afterwards: filters (`clean`, `skipEmpty`, `skipHidden`) drop items and
+ * `unwind` splits or drops them, so `items.length` can land on either side of the rows scanned. The
+ * `x-apify-pagination-count` header reports the scanned number, and the offset iterator advances and terminates by it
+ * alone. A page without the property falls back to `items.length`.
+ * @internal
+ */
+export const SCANNED_COUNT = Symbol('scannedCount');
 export function cast(input) {
     return input;
 }
@@ -324,3 +365,24 @@ export function toPathSegment(value) {
 export function toPath(path) {
     return Array.isArray(path) ? path.map(toPathSegment).join('/') : path;
 }
+/**
+ * Resolves after `millis`, or right away once `signal` aborts.
+ * @internal
+ */
+export async function sleep(millis, signal) {
+    return new Promise((resolve) => {
+        if (signal?.aborted) {
+            resolve();
+            return;
+        }
+        const onAbort = () => {
+            clearTimeout(timer);
+            resolve();
+        };
+        const timer = setTimeout(() => {
+            signal?.removeEventListener('abort', onAbort);
+            resolve();
+        }, millis);
+        signal?.addEventListener('abort', onAbort, { once: true });
+    });
+}

package/dist/wait_for_resources.d.ts

@@ -0,0 +1,8 @@
+import type { Log } from '@apify/log';
+/**
+ * Makes the `start` request, retrying it every {@link WAIT_FOR_RESOURCES_COOLDOWN_MILLIS} while it fails with one of
+ * {@link RESOURCE_LIMIT_ERROR_TYPES}. `true` retries until the request succeeds, a number of seconds bounds the
+ * retrying, after which the last error is thrown. Any other error is thrown right away.
+ * @internal
+ */
+export declare function startWaitingForResources<T>(start: () => Promise<T>, waitForResources: boolean | number | undefined, logger: Log, signal?: AbortSignal): Promise<T>;

package/dist/wait_for_resources.js

@@ -0,0 +1,39 @@
+import { ApifyApiError } from './apify_api_error.js';
+import { sleep } from './utils.js';
+/**
+ * Error types the API rejects a run start with while the account has no free memory or concurrent-run slot for it.
+ * Both clear as other runs or builds finish.
+ */
+const RESOURCE_LIMIT_ERROR_TYPES = new Set([
+    'actor-memory-limit-exceeded',
+    'concurrent-runs-limit-exceeded',
+]);
+/** Cooldown between two attempts to start a run that was rejected for lack of resources. */
+const WAIT_FOR_RESOURCES_COOLDOWN_MILLIS = 10_000;
+/**
+ * Makes the `start` request, retrying it every {@link WAIT_FOR_RESOURCES_COOLDOWN_MILLIS} while it fails with one of
+ * {@link RESOURCE_LIMIT_ERROR_TYPES}. `true` retries until the request succeeds, a number of seconds bounds the
+ * retrying, after which the last error is thrown. Any other error is thrown right away.
+ * @internal
+ */
+export async function startWaitingForResources(start, waitForResources, logger, signal) {
+    if (!waitForResources)
+        return start();
+    const deadline = waitForResources === true ? Infinity : Date.now() + waitForResources * 1000;
+    for (;;) {
+        try {
+            return await start();
+        }
+        catch (err) {
+            if (!(err instanceof ApifyApiError) || !RESOURCE_LIMIT_ERROR_TYPES.has(err.type ?? ''))
+                throw err;
+            const remainingMillis = deadline - Date.now();
+            if (remainingMillis <= 0)
+                throw err;
+            const delayMillis = Math.min(WAIT_FOR_RESOURCES_COOLDOWN_MILLIS, remainingMillis);
+            logger.info(`Not enough resources to start the run, retrying in ${Number((delayMillis / 1000).toPrecision(3))}s: ${err.message}`);
+            await sleep(delayMillis, signal);
+            signal?.throwIfAborted();
+        }
+    }
+}

package/package.json

@@ -1,15 +1,21 @@
 {
   "name": "apify-client",
-  "version": "3.0.0-beta.7",
+  "version": "3.0.0-beta.71",
   "description": "Apify API client for JavaScript",
   "engines": {
-    "node": ">=22.0.0"
+    "node": ">=22.13.0"
   },
   "type": "module",
   "main": "dist/index.js",
   "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",
@@ -53,58 +59,54 @@
   ],
   "apify": {
     "openapiSpec": {
-      "version": "v2-2026-08-31T125154Z"
+      "version": "v2-2026-10-08T073338Z"
     }
   },
   "dependencies": {
     "@apify/consts": "^3.0.1",
     "@apify/log": "^3.0.1",
-    "@apify/utilities": "^3.0.1",
-    "@apify/validations": "^1.1.0",
-    "@crawlee/types": "^3.18.1",
+    "@apify/utilities": "^3.1.0",
+    "@apify/validations": "^1.1.1",
     "ansi-colors": "^4.1.3",
-    "async-retry": "^1.3.3",
     "axios": "^1.20.0",
-    "content-type": "^1.0.5",
-    "proxy-agent": "^6.5.0",
+    "content-type": "^3.1.1",
+    "proxy-agent": "^8.0.2",
     "tslib": "^2.8.1",
-    "type-fest": "^4.41.0",
-    "zod": "^4.5.4"
+    "type-fest": "^5.10.0",
+    "zod": "^4.6.5"
   },
   "devDependencies": {
     "@apify/oxlint-config": "^0.3.0",
     "@apify/tsconfig": "^0.2.0",
-    "@crawlee/puppeteer": "4.0.0-beta.165",
-    "@rsbuild/core": "^2.2.3",
+    "@crawlee/puppeteer": "4.0.0-rc.1",
+    "@rsbuild/core": "^2.2.10",
     "@rsbuild/plugin-node-polyfill": "^1.4.6",
-    "@rspack/cli": "^2.2.2",
-    "@rspack/core": "^2.2.2",
-    "@types/async-retry": "^1.4.9",
+    "@rspack/cli": "^2.2.8",
+    "@rspack/core": "^2.2.8",
     "@types/compression": "^1.8.1",
-    "@types/content-type": "^1.1.9",
     "@types/express": "^5.0.6",
-    "@types/node": "^24.13.3",
+    "@types/node": "^24.19.0",
     "ajv": "^8.20.0",
     "body-parser": "^2.3.0",
-    "compression": "^1.8.1",
+    "compression": "^1.8.2",
     "esbuild": "0.28.2",
     "express": "^5.2.1",
-    "openapi-typescript": "7.13.0",
-    "oxfmt": "0.66.0",
-    "oxlint": "1.81.0",
-    "oxlint-tsgolint": "7.0.2001",
-    "puppeteer": "^25.10.0",
+    "oxfmt": "0.73.0",
+    "oxlint": "1.88.0",
+    "oxlint-tsgolint": "7.0.2004",
+    "puppeteer": "^25.12.0",
     "rimraf": "^6.1.3",
-    "rolldown": "^1.2.7",
-    "typescript": "^6.0.3",
-    "vitest": "^5.0.0",
-    "webpack": "^5.110.3",
+    "rolldown": "^1.2.11",
+    "typescript": "^7.0.2",
+    "typescript-v6": "npm:typescript@^6.0.3",
+    "vitest": "^5.0.2",
+    "webpack": "^5.111.1",
     "webpack-cli": "^7.2.3"
   },
   "devEngines": {
     "packageManager": {
       "name": "pnpm",
-      "version": "10.33.4",
+      "version": "12.14.0",
       "onFail": "warn"
     }
   },
@@ -119,6 +121,7 @@
     "lint:fix": "oxlint --type-aware --fix",
     "tsc-check-tests": "tsc --noEmit --project test/tsconfig.json",
     "tsc-check-scripts": "tsc --noEmit --project tsconfig.scripts.json",
+    "tsc-check-docs": "tsc --noEmit --project docs/tsconfig.json",
     "format": "oxfmt",
     "format:check": "oxfmt --check",
     "api:extract": "pnpm build && pnpm dlx github:apify/api-extractor-report --packages=. --extract-command='pnpm api:extract'",