From 026a190b54ca935d02bd224034350a51df8b0075 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Wed, 23 Sep 2026 13:22:34 +0000
Subject: [PATCH 1/5] feat: Emulate single-tenant Actor Standby

Serve Standby-enabled Actors over HTTP on the API port, at their standbyUrl
(/actor-runtime/standby/<username>--<actor-name>, or <label>.localhost).
Requests are proxied to STANDBY-origin runs that the runtime starts, scales by
desired/max requests per run, and winds down gracefully (SUCCEEDED) after
idleTimeoutSecs, as on the platform. Actors accept and return the actorStandby
settings, and `usesStandbyMode` in .actor/actor.json enables Standby on push.
Adds sample_actor_standby, integration, unit and e2e tests, and updates the
requirements, README and Agent Skill. Multi-tenant Standby stays unsupported.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01W6t3FkairFVeCRTVXrJfTw
---
 .github/workflows/ci.yml                     |   1 +
 README.md                                    |  15 +
 requirements/actor-driver.md                 |  36 +-
 requirements/api.md                          |  21 +
 requirements/console.md                      |   6 +
 requirements/system.md                       |   5 +-
 requirements/test.md                         |   8 +
 requirements/unsupported.md                  |   6 +-
 sample_actor_standby/.actor/actor.json       |  11 +
 sample_actor_standby/.dockerignore           |   1 +
 sample_actor_standby/Dockerfile              |   6 +
 sample_actor_standby/README.md               |  14 +
 sample_actor_standby/package.json            |  13 +
 sample_actor_standby/src/main.js             |  37 ++
 skills/actor-runtime/SKILL.md                |  34 +-
 src/api/dto/actors.ts                        |   4 +
 src/api/events-ws.ts                         |   7 +-
 src/api/routes/actors.ts                     |  45 +-
 src/api/server.ts                            |   3 +
 src/api/standby-proxy.ts                     | 235 ++++++++++
 src/console/server.ts                        |  40 +-
 src/driver/docker-driver.ts                  | 102 +++-
 src/driver/types.ts                          |  13 +
 src/index.ts                                 |   6 +-
 src/services/actors.ts                       |   4 +-
 src/services/runs.ts                         |  56 ++-
 src/services/standby-config.ts               | 122 +++++
 src/services/standby-finish.ts               |  18 +
 src/services/standby.ts                      | 357 ++++++++++++++
 src/storage/entities.ts                      |  16 +
 test/e2e/standby.test.ts                     | 146 ++++++
 test/integration/actors-builds-runs.test.ts  |   3 +
 test/integration/api-fallback.test.ts        |   3 +
 test/integration/browser-view.test.ts        |   3 +
 test/integration/cli-log-stream-race.test.ts |   9 +
 test/integration/debug-mode.test.ts          |   6 +
 test/integration/dev-folder.test.ts          |   6 +
 test/integration/graceful-abort.test.ts      |   3 +
 test/integration/helpers/test-server.ts      |  27 +-
 test/integration/identity-resolution.test.ts |   3 +
 test/integration/job-lifecycle.test.ts       |   6 +
 test/integration/run-env-vars.test.ts        |   3 +
 test/integration/standby.test.ts             | 469 +++++++++++++++++++
 test/unit/docker-driver-standby.test.ts      | 131 ++++++
 test/unit/standby-config.test.ts             |  95 ++++
 45 files changed, 2113 insertions(+), 42 deletions(-)
 create mode 100644 sample_actor_standby/.actor/actor.json
 create mode 100644 sample_actor_standby/.dockerignore
 create mode 100644 sample_actor_standby/Dockerfile
 create mode 100644 sample_actor_standby/README.md
 create mode 100644 sample_actor_standby/package.json
 create mode 100644 sample_actor_standby/src/main.js
 create mode 100644 src/api/standby-proxy.ts
 create mode 100644 src/services/standby-config.ts
 create mode 100644 src/services/standby-finish.ts
 create mode 100644 src/services/standby.ts
 create mode 100644 test/e2e/standby.test.ts
 create mode 100644 test/integration/standby.test.ts
 create mode 100644 test/unit/docker-driver-standby.test.ts
 create mode 100644 test/unit/standby-config.test.ts

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 5d6098e2..2dbf1939 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -53,6 +53,7 @@ jobs:
                     - browser-view-py
                     - all-modes
                     - pay-per-event
+                    - standby
         steps:
             - uses: actions/checkout@v4
             - uses: pnpm/action-setup@v4
diff --git a/README.md b/README.md
index 61ad86cb..dbe163a0 100644
--- a/README.md
+++ b/README.md
@@ -72,6 +72,21 @@ and a schema the Apify meta-schema rejects fails the build with the defect in it
 not checked locally, and encrypted secret input fields stay unsupported - see
 `requirements/actor-driver.md`'s "Input schema, validation and defaults".
 
+## Actor Standby
+
+An Actor with Standby enabled - `"usesStandbyMode": true` in `.actor/actor.json`, or `actorStandby` set
+through the API - is served over HTTP at its `standbyUrl`, on the API port:
+
+```bash
+cd sample_actor_standby
+apify push
+curl "http://localhost:3333/actor-runtime/standby/<username>--my-standby-actor/hello?name=Ada&token=<token>"
+```
+
+Requests are handed to standby runs the runtime starts, scales by `desiredRequestsPerActorRun` /
+`maxRequestsPerActorRun` and winds down after `idleTimeoutSecs` without a request, as on the platform.
+Single-tenant only - see `requirements/actor-driver.md`'s "Actor Standby".
+
 ## Running with Podman instead of Docker
 
 The runtime talks to the container engine only through its Docker-compatible API socket, and Podman
diff --git a/requirements/actor-driver.md b/requirements/actor-driver.md
index a688894c..aa4063f8 100644
--- a/requirements/actor-driver.md
+++ b/requirements/actor-driver.md
@@ -233,6 +233,35 @@ start`, ...) is refused by name, naming both the `CMD` fix and how to clear debu
   leaves it to be discovered on the bill.
 - The pricing can also be set from the console (`console.md`).
 
+# Actor Standby
+
+- An Actor with Actor Standby enabled is served as an HTTP server, as on the platform: requests sent to its
+  standby URL (`api.md`) are handled by runs the runtime starts, reuses and stops on its own. Single-tenant
+  only: every standby run belongs to the Actor's owner.
+- Standby is enabled by the Actor's `actorStandby` settings, or by `usesStandbyMode: true` in the pushed
+  `.actor/actor.json` - `apify push` sends the flag either way.
+- The settings are the platform's, with its defaults and validation: `desiredRequestsPerActorRun` (3),
+  `maxRequestsPerActorRun` (4), `idleTimeoutSecs` (300), `build` (`latest`), `memoryMbytes` (1024),
+  `shouldPassActorInput` (false), `disableStandbyFieldsOverride`.
+- A standby run is an ordinary run with origin `STANDBY`: the standby build and memory, no timeout, and
+  input only when `shouldPassActorInput` is set (the input schema's defaults). Its container is sent
+  requests on its standby port once any HTTP request to `/` carrying the header
+  `x-apify-container-server-readiness-probe` gets an answer.
+- A request goes to the least loaded run below `maxRequestsPerActorRun`; with none, a new run is started
+  and the request waits for it. Once every run is above `desiredRequestsPerActorRun`, one more is started
+  ahead of demand.
+- A run with no request for `idleTimeoutSecs` is wound down gracefully like on the platform: `aborting` and
+  `persistState` events, a stop signal 15 seconds later, a kill 15 seconds after that. It ends
+  `SUCCEEDED` and its log says why. A run that crashes or is aborted just leaves the pool.
+- After a new build of the standby build tag, runs of the older build take no new requests and are wound
+  down once their last one completes. A dev-folder edit reaches the next standby run, not a running one.
+- The runtime reaches the run's server without publishing any port, except when the runtime itself is not
+  on the `apify-local` network (run outside a container, rootless Podman, Podman 3.x): the port is then
+  published on an engine-picked host port - on `127.0.0.1` for a runtime on the host itself.
+- The standby run pool lives in memory; a runtime restart aborts standby runs like every other run.
+- Not emulated: multi-tenant Standby, Standby for tasks, and the Console-auth and tokenless options
+  (`unsupported.md`).
+
 # Users
 
 - Users are created adhoc by the runtime for each new token used in the API call (`cli.md`'s User bootstrap).
@@ -245,8 +274,11 @@ start`, ...) is refused by name, naming both the `CMD` fix and how to clear debu
   default storage ids, or any other contract var the runtime itself sets.
 - `APIFY_IS_AT_HOME=1` (mirrors the real platform; an SDK/client instantiated
   in the container reports `isAtHome`/`is_at_home = true`).
-- `APIFY_META_ORIGIN` — `API` for ordinary runs (every local run arrives via
-  the API, apify-cli included)
+- `APIFY_META_ORIGIN` — the run's origin: `STANDBY` for a standby run, `API` for every other run (every
+  local run arrives via the API, apify-cli included)
+- `ACTOR_STANDBY_PORT` — the port an Actor server listens on: a version-level `ACTOR_WEB_SERVER_PORT` or
+  `ACTOR_STANDBY_PORT`, else `4321`, as on the platform.
+- `ACTOR_STANDBY_URL` — the Actor's standby URL (`api.md`).
 - `APIFY_API_BASE_URL` — the runtime's own API, reachable by name from any
   Actor container on the shared Docker network (see "Networking" above).
 - `APIFY_TOKEN` — the run owner's token
diff --git a/requirements/api.md b/requirements/api.md
index aa39b93d..3b5f036e 100644
--- a/requirements/api.md
+++ b/requirements/api.md
@@ -150,6 +150,27 @@
   miss; only a request naming an Actor unknown here is eligible for the upstream fallback (below), and
   then as the caller's original request, which the platform resolves end to end.
 
+# Actor Standby
+
+- The Actor object carries the platform's `actorStandby` settings (`actor-driver.md`) and `standbyUrl`,
+  `null` while Standby is off. `POST` and `PUT /v2/actors` accept `actorStandby`; a partial object is merged
+  over the stored settings, over the defaults. An invalid one is `400` `invalid-request`, changing nothing;
+  a `tenancy` other than `SINGLE_TENANT` is invalid.
+- The standby URL is `http://localhost:3333/actor-runtime/standby/<username>--<actor-name>`; the Actor id
+  also works in place of `<username>--<actor-name>`. Everything after it - path, query, method, headers,
+  body, websocket upgrades - reaches the Actor's server unchanged, the token included.
+- The platform's host-based shape, `http://<username>--<actor-name>.localhost:3333/<path>`, is served too,
+  for clients that resolve `*.localhost`; its whole path reaches the Actor.
+- Authenticated like the API (`Authorization: Bearer`, `?token=`), plus the platform's
+  `x-apify-authorization` header; only the Actor's owner is served.
+- Errors, as `{ "error": { "type", "message" } }`: no token `401` `user-not-authenticated`; no such Actor of
+  the caller's `404` `record-not-found`; Standby off `400` `standby-not-enabled`; no build under the
+  standby build tag `404` `record-not-found`; a run that ended before its server was ready `503`
+  `standby-run-finished`; a server not ready within 180 seconds `504` `standby-run-not-ready`; a server
+  that drops the request `502` `standby-bad-gateway`. None is relayed by the upstream fallback.
+- A standby run's object has `meta.origin` `STANDBY`, `options.timeoutSecs` `0` and
+  `standby: { deployment: "SINGLE_TENANT" }`.
+
 # Actor runtime API
 
 - `/actor-runtime/*` is the API controlling functions specific to the local Actor runtime
diff --git a/requirements/console.md b/requirements/console.md
index d10d1a0b..cbbd358a 100644
--- a/requirements/console.md
+++ b/requirements/console.md
@@ -114,3 +114,9 @@
   the other, and via the API's own `GET`, with no restart needed either way.
 - The console has no login, so anyone who can reach it can flip either toggle for every caller of the
   API.
+
+## Actor Standby (Actor detail view)
+
+- The Actor detail view shows whether Actor Standby is on and, when it is, the standby URL, the settings and
+  the Actor's live standby runs with their open requests. Read-only: the settings are changed through the
+  API (`api.md`). The run detail view shows each run's origin.
diff --git a/requirements/system.md b/requirements/system.md
index 7b843ec0..4b4442f4 100644
--- a/requirements/system.md
+++ b/requirements/system.md
@@ -24,13 +24,16 @@
   with a clear status message, while every other endpoint (storages, actor/build/run records,
   console) still works.
 - Both ports are fixed and not configurable.
-- Port 3333 also serves the per-run events websocket (`api.md`); no additional port is published for it.
+- Port 3333 also serves the per-run events websocket and every standby Actor (`api.md`); no additional
+  port is published for either.
 - **Debug mode is the one exception to "no other Actor container port is ever published"**
   (`actor-driver.md`'s "Debug mode" section): when debug mode is on for an Actor, that Actor's runs get a
   port published on the host, bound to `127.0.0.1` (`5678` Python / `9229` Node by default, per-Actor
   overridable) - the runtime's own two ports above are unaffected, and no port is published for an Actor
   that never turned debug mode on.
 - Browser view (`actor-driver.md`) publishes no port on the host; the view is served on the console's port 3000.
+- A standby run publishes its server's port only when the runtime cannot reach it otherwise
+  (`actor-driver.md`'s "Actor Standby").
 - Required `docker run` flags: mount the host's Docker-Engine-API socket read-write
   (`-v /var/run/docker.sock:/var/run/docker.sock`) so the runtime can build and run Actor containers,
   and mount a persistent data directory (`-v <host-dir>:/data`, e.g. `-v "$(pwd)/data:/data"`) so
diff --git a/requirements/test.md b/requirements/test.md
index 5af7c7d7..2ec51349 100644
--- a/requirements/test.md
+++ b/requirements/test.md
@@ -17,6 +17,8 @@
 - **A second narrow exception of the same kind**: the browser-view e2e test may open the console's viewer
   page and its websocket directly, to emulate a developer's browser opening the view. Everything else in it
   goes through `apify` commands.
+- **A third narrow exception**: the Actor Standby e2e test sends plain HTTP requests to the Actor's standby
+  URL, since no `apify` command can. Everything else in it goes through `apify` commands.
 - For asserting the test results, the tests must inspect the return values of the Apify cli commands.
 - The e2e suite requires a reachable Docker daemon (it builds and runs real Actor containers) and
   detects its absence, failing in such case.
@@ -43,3 +45,9 @@ Test case must verify full Actor development flow:
 - For each Playwright sample Actor (`sample_actor_playwright`, `sample_actor_playwright_py`): push, turn browser view on, start a run
 - Assert the run log names the viewer URL, the view is reachable while the run is going, the run finishes `SUCCEEDED` with an input-dependent `itemCount`, and the view is gone once the run has ended
 - With the toggle cleared, a plain `apify call` of the same Actor runs with no browser-view line in its log
+
+## Actor Standby
+
+- Push `sample_actor_standby`, whose `.actor/actor.json` enables Standby, and shorten its idle timeout
+- Assert that several requests to its standby URL are answered by one `STANDBY` run, that the run ends
+  `SUCCEEDED` once idle with one dataset item per request, and that the next request starts a new run
diff --git a/requirements/unsupported.md b/requirements/unsupported.md
index 10296783..3855c71d 100644
--- a/requirements/unsupported.md
+++ b/requirements/unsupported.md
@@ -12,12 +12,12 @@ real account, not in the runtime.
 
 ## Running Actors
 
-- Actor server (Actor Standby)
+- Multi-tenant Actor Standby, Standby for tasks, and Standby's Console-auth and tokenless options
 - Run web server and live view (`containerUrl`)
 - Metamorph
 - Resurrecting finished runs
 - Restart on error
-- Infinite runs (timeout `0`)
+- Infinite runs (timeout `0`), other than standby runs
 - Synchronous runs returning output (`run-sync`)
 - Actor-set run status messages
 - Result cap (`maxItems`)
@@ -92,7 +92,7 @@ real account, not in the runtime.
 ## Inside the Actor container
 
 - Run metadata env vars (input key, build, task, user, timestamps)
-- Web server, Standby and proxy env vars
+- Web server and proxy env vars
 - Input secrets private key
 - Log rate limiting, line truncation and size cap
 - Secret redaction in logs
diff --git a/sample_actor_standby/.actor/actor.json b/sample_actor_standby/.actor/actor.json
new file mode 100644
index 00000000..309d0bdf
--- /dev/null
+++ b/sample_actor_standby/.actor/actor.json
@@ -0,0 +1,11 @@
+{
+	"$schema": "https://apify.com/schemas/v1/actor.ide.json",
+	"actorSpecification": 1,
+	"name": "my-standby-actor",
+	"title": "Standby sample actor for actor-runtime",
+	"description": "An Actor server: answers HTTP requests in Standby mode, pushing one dataset item per request.",
+	"version": "0.0",
+	"buildTag": "latest",
+	"usesStandbyMode": true,
+	"dockerfile": "../Dockerfile"
+}
diff --git a/sample_actor_standby/.dockerignore b/sample_actor_standby/.dockerignore
new file mode 100644
index 00000000..3c3629e6
--- /dev/null
+++ b/sample_actor_standby/.dockerignore
@@ -0,0 +1 @@
+node_modules
diff --git a/sample_actor_standby/Dockerfile b/sample_actor_standby/Dockerfile
new file mode 100644
index 00000000..002fb792
--- /dev/null
+++ b/sample_actor_standby/Dockerfile
@@ -0,0 +1,6 @@
+# The base image already carries the Apify SDK, so the build needs no npm install.
+FROM apify/actor-node:24
+
+COPY --chown=myuser:myuser . ./
+
+CMD ["node", "src/main.js"]
diff --git a/sample_actor_standby/README.md b/sample_actor_standby/README.md
new file mode 100644
index 00000000..0acde6f0
--- /dev/null
+++ b/sample_actor_standby/README.md
@@ -0,0 +1,14 @@
+# Standby sample Actor
+
+An Actor server for trying Actor Standby against the local runtime. `.actor/actor.json` sets
+`usesStandbyMode`, so `apify push` enables Standby for the Actor.
+
+```bash
+apify push
+curl "http://localhost:3333/actor-runtime/standby/<username>--my-standby-actor/hello?name=Ada&token=<token>"
+```
+
+The first request starts a standby run; later ones reuse it. Each request pushes one item to that run's
+default dataset. After `idleTimeoutSecs` (300 by default) without requests the run is wound down and
+ends `SUCCEEDED`; the next request starts a fresh one. `apify call` starts an ordinary run instead,
+which says where to send requests and exits.
diff --git a/sample_actor_standby/package.json b/sample_actor_standby/package.json
new file mode 100644
index 00000000..3fa53b53
--- /dev/null
+++ b/sample_actor_standby/package.json
@@ -0,0 +1,13 @@
+{
+	"name": "my-standby-actor",
+	"version": "0.0.1",
+	"type": "module",
+	"description": "A sample Actor Standby server for actor-runtime.",
+	"dependencies": {
+		"apify": "^3.7.0"
+	},
+	"scripts": {
+		"start": "node src/main.js"
+	},
+	"license": "ISC"
+}
diff --git a/sample_actor_standby/src/main.js b/sample_actor_standby/src/main.js
new file mode 100644
index 00000000..4d479ae9
--- /dev/null
+++ b/sample_actor_standby/src/main.js
@@ -0,0 +1,37 @@
+import { createServer } from 'node:http';
+import { URL } from 'node:url';
+
+import { Actor, log } from 'apify';
+
+await Actor.init();
+
+if (Actor.config.get('metaOrigin') !== 'STANDBY') {
+	log.info(`Not started in Standby mode - send HTTP requests to ${Actor.config.get('standbyUrl')} instead.`);
+	await Actor.exit();
+} else {
+	const port = Actor.config.get('standbyPort');
+	let served = 0;
+
+	const server = createServer(async (req, res) => {
+		// The platform's readiness probe; any answer tells it the server is up.
+		if (req.headers['x-apify-container-server-readiness-probe']) {
+			res.end('ready\n');
+			return;
+		}
+		const url = new URL(req.url, 'http://localhost');
+		const name = url.searchParams.get('name') ?? 'world';
+		served += 1;
+		await Actor.pushData({ path: url.pathname, name, servedAt: new Date().toISOString() });
+		log.info(`Served ${req.method} ${url.pathname} (request #${served} of this run)`);
+		res.writeHead(200, { 'content-type': 'application/json' });
+		res.end(JSON.stringify({ greeting: `Hello, ${name}!`, runId: Actor.config.get('actorRunId'), served }));
+	});
+
+	// An idle standby run is wound down with an `aborting` event; the SDK then exits on its own.
+	Actor.on('aborting', () => {
+		log.info(`Shutting down after serving ${served} requests.`);
+		server.close();
+	});
+
+	server.listen(port, () => log.info(`Standby server listening on port ${port}`));
+}
diff --git a/skills/actor-runtime/SKILL.md b/skills/actor-runtime/SKILL.md
index 4ba84e5e..a51cfb5b 100644
--- a/skills/actor-runtime/SKILL.md
+++ b/skills/actor-runtime/SKILL.md
@@ -1,6 +1,6 @@
 ---
 name: apify-actor-runtime
-description: Drive the local Apify Actor runtime - a self-contained local Apify platform that emulates the Apify API and console so Actors can be developed, run and debugged without the cloud. Covers pointing the Apify CLI at it, the no-rebuild dev-folder loop, IDE debugging, watching a Playwright/Puppeteer browser, migration testing, pay-per-event pricing and run cost estimates, and relaying unimplemented calls to the real platform.
+description: Drive the local Apify Actor runtime - a self-contained local Apify platform that emulates the Apify API and console so Actors can be developed, run and debugged without the cloud. Covers pointing the Apify CLI at it, the no-rebuild dev-folder loop, IDE debugging, watching a Playwright/Puppeteer browser, Actor Standby servers, migration testing, pay-per-event pricing and run cost estimates, and relaying unimplemented calls to the real platform.
 ---
 
 # Local Apify Actor runtime
@@ -178,6 +178,36 @@ Read the outcome off the run object, `apify api GET actor-runs/<runId>`, or the
   transfer and proxy are not metered. On the platform a user of a pay-per-event Actor pays only the
   events unless the pricing sets `isPPEPlatformUsagePaidByUser`.
 
+## Run an Actor server (Actor Standby)
+
+An Actor with Standby enabled is served over HTTP, as on the platform. `"usesStandbyMode": true` in
+`.actor/actor.json` makes `apify push` enable it; `apify api GET v2/actors/<actorId>` then shows the
+`actorStandby` settings and the Actor's `standbyUrl`:
+
+```sh
+apify push
+curl "http://localhost:3333/actor-runtime/standby/<username>--<actor-name>/some/path?token=<token>"
+```
+
+- The first request starts a standby run (origin `STANDBY`, no timeout, the standby build and memory) and
+  waits until its server answers on `ACTOR_STANDBY_PORT` (4321); later requests reuse it. More runs start
+  once concurrent requests exceed `desiredRequestsPerActorRun` / `maxRequestsPerActorRun`.
+- Everything after the standby URL - path, query, headers, body, websockets - reaches the Actor unchanged.
+  The token (`?token=`, `Authorization: Bearer`) is required, and only the Actor's owner is served.
+  `http://<username>--<actor-name>.localhost:3333/` works too, where `*.localhost` resolves (browsers);
+  the Actor id can stand in for `<username>--<actor-name>` in either form.
+- A run idle for `idleTimeoutSecs` (300 by default) gets the `aborting` event, is stopped 15 s later and
+  ends `SUCCEEDED`. Shorten it while developing:
+  `apify api PUT v2/actors/<actorId> --body '{"actorStandby":{"idleTimeoutSecs":10}}'`.
+- After `apify push` the next request is served by a run of the new build; older runs finish once idle. A
+  dev-folder edit reaches only the next standby run - abort the current one (`apify runs abort <runId>`)
+  to pick it up sooner.
+- A request that cannot be served says why: `standby-not-enabled`, `standby-run-finished` (the run
+  crashed before its server came up - read its log), `standby-run-not-ready` (nothing listened on the port
+  within 180 s).
+- `apify call` still starts an ordinary `API` run of the same Actor. `sample_actor_standby` is a minimal
+  Actor server to start from. Multi-tenant Standby and Standby for tasks are not emulated.
+
 ## Test how an Actor handles a platform migration
 
 While a run is `RUNNING`:
@@ -233,7 +263,7 @@ a later step misses. Only a call naming an Actor this runtime does not know is r
   `/key-value-store/records/OUTPUT`, `/request-queue`, `/abort`. Add `?status=SUCCEEDED` to skip
   failed runs. `client.actor(id).lastRun()` in the SDKs uses these.
 - The console at `http://localhost:3000` shows the same objects, plus the pricing and dev-folder forms,
-  each run's usage and cost, the Migrate button and the browser view.
+  each run's usage and cost, the Migrate button, the browser view and an Actor's standby runs.
 - The runtime's data directory holds every storage, build and run record on disk. Read it freely;
   write to it only through the API, never by editing the files.
 
diff --git a/src/api/dto/actors.ts b/src/api/dto/actors.ts
index fcab710a..b1f9cede 100644
--- a/src/api/dto/actors.ts
+++ b/src/api/dto/actors.ts
@@ -1,6 +1,7 @@
 import type { ActorRecord, BuildRecord, RunRecord } from '../../storage/entities.js';
 import { getRunTelemetry } from '../../services/events-channel.js';
 import { computeRunUsage } from '../../services/run-usage.js';
+import { standbyUrl } from '../../services/standby-config.js';
 
 /** Matches `services/actors.ts`'s `DEFAULT_BUILD_TAG` - backfilled here only for run records that
  * predate `options.build` (directly-seeded test fixtures); every real run always has it set already. */
@@ -24,6 +25,8 @@ export function actorDto(actor: ActorRecord, username: string) {
 		defaultRunOptions: { build: 'latest', timeoutSecs: 300, memoryMbytes: 1024 },
 		deploymentKey: actor.id,
 		pricingInfos: actor.pricingInfos ?? [],
+		...(actor.actorStandby ? { actorStandby: actor.actorStandby } : {}),
+		standbyUrl: actor.actorStandby?.isEnabled ? standbyUrl(actor, username) : null,
 		taggedBuilds: Object.fromEntries(
 			Object.entries(actor.taggedBuilds).map(([tag, info]) => [
 				tag,
@@ -87,6 +90,7 @@ export function runDto(run: RunRecord) {
 		},
 		generalAccess: run.generalAccess ?? 'FOLLOW_USER_SETTING',
 		meta: run.meta,
+		...(run.meta.origin === 'STANDBY' ? { standby: { deployment: 'SINGLE_TENANT' } } : {}),
 		stats: usage.stats,
 		usage: usage.usage,
 		usageUsd: usage.usageUsd,
diff --git a/src/api/events-ws.ts b/src/api/events-ws.ts
index d96393c6..28fdc0c1 100644
--- a/src/api/events-ws.ts
+++ b/src/api/events-ws.ts
@@ -73,10 +73,15 @@ async function handleConnection(ws: WebSocket, runId: string): Promise<void> {
 }
 
 /** Registers the upgrade handler on the API server and returns a handle shutdown can close. */
-export function attachEventsWebSocket(server: Server): EventsWebSocketServer {
+export function attachEventsWebSocket(
+	server: Server,
+	/** Tried first for every upgrade; returns `true` when it took the connection (the standby router). */
+	otherUpgrade?: (req: IncomingMessage, socket: Duplex, head: Buffer) => boolean,
+): EventsWebSocketServer {
 	const wss = new WebSocketServer({ noServer: true });
 
 	server.on('upgrade', (req: IncomingMessage, socket: Duplex, head: Buffer) => {
+		if (otherUpgrade?.(req, socket, head)) return;
 		const pathname = req.url ? new URL(req.url, 'http://localhost').pathname : undefined;
 		const runId = pathname ? extractRunId(pathname) : undefined;
 		if (!runId) {
diff --git a/src/api/routes/actors.ts b/src/api/routes/actors.ts
index 418e3365..e0aa2059 100644
--- a/src/api/routes/actors.ts
+++ b/src/api/routes/actors.ts
@@ -32,12 +32,38 @@ import {
 import { listOwnedRuns, startRun, waitForRunFinish } from '../../services/runs.js';
 import { getRegistries } from '../../storage/registries.js';
 import { actorDto, buildDto, runDto } from '../dto/actors.js';
-import type { ActorPricingInfoRecord, ActorRecord, ActorVersionRecord } from '../../storage/entities.js';
+import type {
+	ActorPricingInfoRecord,
+	ActorRecord,
+	ActorStandbyRecord,
+	ActorVersionRecord,
+} from '../../storage/entities.js';
 import type { ApiServerDeps } from '../server.js';
 import { CONTAINER_API_BASE_URL } from '../../config.js';
 import { resolveProxyPassword } from '../../services/users.js';
 import { validatePricingInfosUpdate } from '../../services/pricing.js';
 import { resolveBuildInput } from '../../services/input-schema.js';
+import { declaresStandbyMode, mergeStandbyUpdate, standbyUrl } from '../../services/standby-config.js';
+
+/** `undefined` when the body does not mention the field; an invalid one throws. */
+function actorStandbyFromBody(body: { actorStandby?: unknown }, actor?: ActorRecord): ActorStandbyRecord | undefined {
+	if (body.actorStandby === undefined || body.actorStandby === null) return undefined;
+	const result = mergeStandbyUpdate(body.actorStandby, actor?.actorStandby);
+	if (result.kind === 'invalid') throw invalidRequest(result.message);
+	return result.actorStandby;
+}
+
+/** The platform enables standby, never disables it, for a version whose `.actor/actor.json` asks for it;
+ * `undefined` when that changes nothing. */
+function standbyEnabledByVersions(
+	current: ActorStandbyRecord | undefined,
+	versions: ActorVersionRecord[],
+): ActorStandbyRecord | undefined {
+	if (current?.isEnabled) return undefined;
+	if (!versions.some((version) => declaresStandbyMode(version.sourceFiles ?? []))) return undefined;
+	const result = mergeStandbyUpdate({ isEnabled: true }, current);
+	return result.kind === 'ok' ? result.actorStandby : undefined;
+}
 
 /**
  * `undefined` when the body does not mention the field; a body that does but is invalid throws, with the
@@ -77,10 +103,13 @@ export function mountActors(router: Router, deps: ApiServerDeps): void {
 				title?: string;
 				versions?: ActorVersionRecord[];
 				pricingInfos?: unknown;
+				actorStandby?: unknown;
 			}>(req);
 			if (!body.name) throw invalidRequest('Actor "name" is required');
 			if (body.pricingInfos !== undefined) throw cannotSetPricingOnCreate();
-			const actor = await createActor(requireUser(req).id, body);
+			// An explicit `actorStandby` wins over `usesStandbyMode`, even one that disables it.
+			const actorStandby = actorStandbyFromBody(body) ?? standbyEnabledByVersions(undefined, body.versions ?? []);
+			const actor = await createActor(requireUser(req).id, { ...body, actorStandby });
 			sendData(res, actorDto(actor, requireUser(req).username), 201);
 		}),
 	);
@@ -99,13 +128,17 @@ export function mountActors(router: Router, deps: ApiServerDeps): void {
 		h(async (req, res) => {
 			const actor = await resolveActorParam(req);
 			if (!actor) throw recordNotFound();
-			const body = jsonBody<{ name?: string; title?: string; pricingInfos?: unknown }>(req);
+			const body = jsonBody<{ name?: string; title?: string; pricingInfos?: unknown; actorStandby?: unknown }>(
+				req,
+			);
 			const pricingInfos = pricingInfosFromBody(body, actor);
+			const actorStandby = actorStandbyFromBody(body, actor);
 			const updated = await updateActor(actor.id, (current) => ({
 				...current,
 				name: body.name ?? current.name,
 				title: body.title ?? current.title,
 				...(pricingInfos !== undefined ? { pricingInfos } : {}),
+				...(actorStandby !== undefined ? { actorStandby } : {}),
 			}));
 			sendData(res, actorDto(updated ?? actor, requireUser(req).username));
 		}),
@@ -146,7 +179,10 @@ export function mountActors(router: Router, deps: ApiServerDeps): void {
 				sourceFiles: body.sourceFiles ?? [],
 				envVars: body.envVars,
 			};
-			await updateActor(actor.id, (current) => addOrReplaceVersion(current, version));
+			await updateActor(actor.id, (current) => {
+				const actorStandby = standbyEnabledByVersions(current.actorStandby, [version]);
+				return { ...addOrReplaceVersion(current, version), ...(actorStandby ? { actorStandby } : {}) };
+			});
 			sendData(res, version, 201);
 		}),
 	);
@@ -306,6 +342,7 @@ export function mountActors(router: Router, deps: ApiServerDeps): void {
 				build: tag,
 				// Runtime-only extension (`api.md`): `?devFolder=false` skips the dev-folder mount for this run.
 				devFolder: queryBoolean(req, 'devFolder'),
+				standbyUrl: standbyUrl(actor, requireUser(req).username),
 				proxyPassword: resolveProxyPassword(requireUser(req)),
 				apiBaseUrl: CONTAINER_API_BASE_URL,
 				token: requireUser(req).token,
diff --git a/src/api/server.ts b/src/api/server.ts
index 182b7ae3..5e22aa1f 100644
--- a/src/api/server.ts
+++ b/src/api/server.ts
@@ -20,6 +20,7 @@ import { mountBrowserView } from './routes/browser-view.js';
 import { mountMigrate } from './routes/migrate.js';
 import { mountApiFallback } from './routes/api-fallback.js';
 import { mountSkill } from './routes/skill.js';
+import { standbyProxy } from './standby-proxy.js';
 import { attemptFallback, type LocalError } from '../services/api-fallback.js';
 import type { Driver } from '../driver/types.js';
 
@@ -39,6 +40,8 @@ async function respondWithLocalError(req: Request, res: Response, localError: Lo
 export function createApiServer(deps: ApiServerDeps): Express {
 	const app = express();
 	app.disable('x-powered-by');
+	// Ahead of the body parser below: a standby request's body streams through to the Actor untouched.
+	app.use(standbyProxy(deps.driver));
 	// Every body arrives as a raw Buffer regardless of Content-Type: KV records need byte-exact
 	// round-tripping, run/build inputs carry arbitrary content types, and everything else is JSON we
 	// parse ourselves (see `api/handler.ts`).
diff --git a/src/api/standby-proxy.ts b/src/api/standby-proxy.ts
new file mode 100644
index 00000000..9a86fbdc
--- /dev/null
+++ b/src/api/standby-proxy.ts
@@ -0,0 +1,235 @@
+/**
+ * The standby router (`api.md`'s "Actor Standby"): forwards a request addressed to a standby Actor to
+ * one of its standby runs, starting runs as `services/standby.ts` decides. Two addressings, both on the
+ * API port: `/actor-runtime/standby/<label>/<path>` (the Actor's `standbyUrl`, resolvable everywhere)
+ * and `http://<label>.localhost:3333/<path>` (the platform's host-based shape, for browsers that
+ * resolve `*.localhost`). `<label>` is the platform's `<username>--<actor-name>`, or the Actor id.
+ *
+ * Mounted ahead of the API's body parser, so a request body is streamed through untouched.
+ */
+import http, { type IncomingHttpHeaders, type IncomingMessage, type ServerResponse } from 'node:http';
+import net from 'node:net';
+import type { Duplex } from 'node:stream';
+
+import type { Driver } from '../driver/types.js';
+import type { ActorRecord, UserRecord } from '../storage/entities.js';
+import { getOrCreateUserForToken } from '../services/users.js';
+import { listOwnedActors } from '../services/actors.js';
+import { STANDBY_PATH_PREFIX, labelFromHost, standbyLabel } from '../services/standby-config.js';
+import { StandbyUnavailableError, acquireStandbyRun, type StandbyLease } from '../services/standby.js';
+
+/** Hop-by-hop headers (RFC 9110 7.6.1) never cross a proxy. */
+const HOP_BY_HOP_HEADERS = [
+	'connection',
+	'keep-alive',
+	'proxy-connection',
+	'proxy-authenticate',
+	'proxy-authorization',
+	'te',
+	'trailer',
+	'upgrade',
+];
+
+interface StandbyTarget {
+	label: string;
+	/** Path plus query string, as the Actor's server is to see it. */
+	forwardPath: string;
+}
+
+/** `undefined` for a request not addressed to a standby Actor at all. */
+export function standbyTargetOf(req: IncomingMessage): StandbyTarget | undefined {
+	const url = req.url ?? '/';
+	const hostLabel = labelFromHost(req.headers.host);
+	if (hostLabel) return { label: hostLabel, forwardPath: url.startsWith('/') ? url : `/${url}` };
+	if (!url.startsWith(`${STANDBY_PATH_PREFIX}/`)) return undefined;
+	const rest = url.slice(STANDBY_PATH_PREFIX.length + 1);
+	const end = rest.search(/[/?]/);
+	const label = decodeURIComponent(end === -1 ? rest : rest.slice(0, end));
+	if (!label) return undefined;
+	const remainder = end === -1 ? '' : rest.slice(end);
+	return { label: label.toLowerCase(), forwardPath: remainder.startsWith('/') ? remainder : `/${remainder}` };
+}
+
+/** Same token sources as the API (`auth.ts`), plus the platform's standby-specific header. Forwarded
+ * to the Actor unchanged: an Actor may use its caller's token itself. */
+function tokenOf(req: IncomingMessage): string | undefined {
+	for (const header of [req.headers.authorization, req.headers['x-apify-authorization']]) {
+		const value = Array.isArray(header) ? header[0] : header;
+		if (value?.toLowerCase().startsWith('bearer ')) {
+			const token = value.slice('bearer '.length).trim();
+			if (token) return token;
+		}
+	}
+	const token = new URL(req.url ?? '/', 'http://localhost').searchParams.get('token');
+	return token || undefined;
+}
+
+async function resolveStandbyActor(user: UserRecord, label: string): Promise<ActorRecord | undefined> {
+	const owned = await listOwnedActors(user.id);
+	return owned.find((actor) => actor.id.toLowerCase() === label || standbyLabel(actor, user.username) === label);
+}
+
+type Resolution =
+	{ kind: 'ok'; lease: StandbyLease } | { kind: 'error'; status: number; type: string; message: string };
+
+async function resolveLease(driver: Driver, req: IncomingMessage, target: StandbyTarget): Promise<Resolution> {
+	const token = tokenOf(req);
+	if (!token) {
+		return {
+			kind: 'error',
+			status: 401,
+			type: 'user-not-authenticated',
+			message: 'Authentication token is not provided',
+		};
+	}
+	try {
+		const user = await getOrCreateUserForToken(token);
+		const actor = await resolveStandbyActor(user, target.label);
+		if (!actor) {
+			return {
+				kind: 'error',
+				status: 404,
+				type: 'record-not-found',
+				message: `No Actor of yours is served at standby address "${target.label}"`,
+			};
+		}
+		return { kind: 'ok', lease: await acquireStandbyRun(driver, actor, user) };
+	} catch (error) {
+		if (error instanceof StandbyUnavailableError) {
+			return { kind: 'error', status: error.status, type: error.type, message: error.message };
+		}
+		console.error('standby router: unexpected error', error);
+		return {
+			kind: 'error',
+			status: 500,
+			type: 'internal-error',
+			message: error instanceof Error ? error.message : 'Internal error',
+		};
+	}
+}
+
+function forwardedHeaders(headers: IncomingHttpHeaders): IncomingHttpHeaders {
+	const forwarded: IncomingHttpHeaders = { ...headers };
+	for (const name of HOP_BY_HOP_HEADERS) delete forwarded[name];
+	return forwarded;
+}
+
+function sendJsonError(res: ServerResponse, status: number, type: string, message: string): void {
+	if (res.headersSent) {
+		res.destroy();
+		return;
+	}
+	res.writeHead(status, { 'content-type': 'application/json; charset=utf-8' });
+	res.end(JSON.stringify({ error: { type, message } }));
+}
+
+/** Express-compatible middleware; passes everything not addressed to a standby Actor on to `next`. */
+export function standbyProxy(driver: Driver) {
+	return (req: IncomingMessage, res: ServerResponse, next: () => void): void => {
+		const target = standbyTargetOf(req);
+		if (!target) {
+			next();
+			return;
+		}
+		// Held until a run is ready; nothing is read from the body before then.
+		req.pause();
+		void resolveLease(driver, req, target).then((resolution) => {
+			if (resolution.kind === 'error') {
+				req.resume();
+				sendJsonError(res, resolution.status, resolution.type, resolution.message);
+				return;
+			}
+			forwardRequest(req, res, target, resolution.lease);
+		});
+	};
+}
+
+function forwardRequest(req: IncomingMessage, res: ServerResponse, target: StandbyTarget, lease: StandbyLease): void {
+	res.once('close', () => lease.release());
+	const upstream = http.request(
+		{
+			host: lease.address.host,
+			port: lease.address.port,
+			method: req.method,
+			path: target.forwardPath,
+			headers: forwardedHeaders(req.headers),
+		},
+		(upstreamRes) => {
+			const headers = { ...upstreamRes.headers };
+			for (const name of HOP_BY_HOP_HEADERS) delete headers[name];
+			res.writeHead(upstreamRes.statusCode ?? 502, upstreamRes.statusMessage, headers);
+			upstreamRes.pipe(res);
+		},
+	);
+	upstream.on('error', (error: NodeJS.ErrnoException) => {
+		if (error.code === 'ECONNREFUSED') lease.markUnreachable();
+		sendJsonError(
+			res,
+			502,
+			'standby-bad-gateway',
+			`The Actor's standby run ${lease.runId} did not answer: ${error.message}`,
+		);
+	});
+	// A client that goes away takes its upstream request with it (and so frees the run's slot).
+	res.once('close', () => {
+		if (!res.writableFinished) upstream.destroy();
+	});
+	req.pipe(upstream);
+	req.resume();
+}
+
+/** Upgraded sockets are not HTTP connections any more, so `closeAllConnections()` cannot end them. */
+const upgradedSockets = new Set<Duplex>();
+
+/** Ends every proxied websocket; a graceful shutdown would otherwise wait on them indefinitely. */
+export function closeStandbyUpgrades(): void {
+	for (const socket of upgradedSockets) socket.destroy();
+	upgradedSockets.clear();
+}
+
+/** The websocket counterpart of `standbyProxy`, for the API server's `upgrade` event. Returns `false`
+ * for an upgrade not addressed to a standby Actor, leaving it to the next handler. */
+export function handleStandbyUpgrade(driver: Driver, req: IncomingMessage, socket: Duplex, head: Buffer): boolean {
+	const target = standbyTargetOf(req);
+	if (!target) return false;
+	socket.on('error', () => socket.destroy());
+	upgradedSockets.add(socket);
+	socket.once('close', () => upgradedSockets.delete(socket));
+	void resolveLease(driver, req, target).then((resolution) => {
+		if (resolution.kind === 'error') {
+			const body = JSON.stringify({ error: { type: resolution.type, message: resolution.message } });
+			socket.end(
+				`HTTP/1.1 ${resolution.status} ${http.STATUS_CODES[resolution.status] ?? 'Error'}\r\n` +
+					`content-type: application/json; charset=utf-8\r\ncontent-length: ${Buffer.byteLength(body)}\r\n` +
+					`connection: close\r\n\r\n${body}`,
+			);
+			return;
+		}
+		const { lease } = resolution;
+		const upstream = net.connect(lease.address.port, lease.address.host, () => {
+			const lines = [`${req.method ?? 'GET'} ${target.forwardPath} HTTP/1.1`];
+			for (let i = 0; i < req.rawHeaders.length; i += 2)
+				lines.push(`${req.rawHeaders[i]}: ${req.rawHeaders[i + 1]}`);
+			upstream.write(`${lines.join('\r\n')}\r\n\r\n`);
+			if (head.length > 0) upstream.write(head);
+			upstream.pipe(socket);
+			socket.pipe(upstream);
+		});
+		let released = false;
+		const close = () => {
+			if (!released) {
+				released = true;
+				lease.release();
+			}
+			upstream.destroy();
+			socket.destroy();
+		};
+		upstream.on('error', (error: NodeJS.ErrnoException) => {
+			if (error.code === 'ECONNREFUSED') lease.markUnreachable();
+			close();
+		});
+		upstream.on('close', close);
+		socket.on('close', close);
+	});
+	return true;
+}
diff --git a/src/console/server.ts b/src/console/server.ts
index cf8bcb4c..8e4ff869 100644
--- a/src/console/server.ts
+++ b/src/console/server.ts
@@ -34,6 +34,9 @@ import { debugStatus, setDebugMode } from '../services/debug-mode.js';
 import { browserViewStatus, setBrowserView } from '../services/browser-view.js';
 import { getBuildById, listAllBuilds } from '../services/builds.js';
 import { getRunById, listAllRuns } from '../services/runs.js';
+import { standbyUrl } from '../services/standby-config.js';
+import { standbyPoolSnapshot } from '../services/standby.js';
+import { getUserById } from '../services/users.js';
 import { migrateRun } from '../services/migrations.js';
 import { isTerminalJobStatus } from '../services/job-status.js';
 import { isBrowserViewPending } from './browser-view-ws.js';
@@ -187,6 +190,39 @@ export function createConsoleServer(deps: ConsoleServerDeps): Express {
 		);
 	});
 
+	/** Read-only: the settings are changed through the API, as on the platform. */
+	async function standbySection(actor: ActorRecord): Promise<string> {
+		const config = actor.actorStandby;
+		if (!config?.isEnabled) {
+			return '<h2>Actor Standby</h2><p class="empty">(Actor Standby is off)</p>';
+		}
+		const owner = await getUserById(actor.userId);
+		const url = owner ? standbyUrl(actor, owner.username) : '';
+		const pool = standbyPoolSnapshot(actor.id);
+		return (
+			'<h2>Actor Standby</h2>' +
+			definitionList([
+				['standbyUrl', url],
+				['build', config.build],
+				['memoryMbytes', config.memoryMbytes],
+				['desiredRequestsPerActorRun', config.desiredRequestsPerActorRun],
+				['maxRequestsPerActorRun', config.maxRequestsPerActorRun],
+				['idleTimeoutSecs', config.idleTimeoutSecs],
+				['shouldPassActorInput', String(config.shouldPassActorInput)],
+			]) +
+			table(
+				['runId', 'open requests', 'ready'],
+				pool.map((entry) => [
+					entry.runId
+						? { text: entry.runId, href: `/runs/${encodeURIComponent(entry.runId)}` }
+						: '(starting)',
+					String(entry.openRequests),
+					entry.ready ? 'yes' : 'no',
+				]),
+			)
+		);
+	}
+
 	app.get('/actors/:id', async (req, res) => {
 		const actor = await getActorById(req.params.id);
 		if (!actor) {
@@ -222,7 +258,8 @@ export function createConsoleServer(deps: ConsoleServerDeps): Express {
 			pricingSection(actor.id, actor.pricingInfos, pricingError) +
 			devFolderSection(actor.id, devFolderStatus(actor), devFolderError) +
 			debugModeSection(actor.id, actor.localDebug, debugModeError) +
-			browserViewSection(actor.id, actor.localBrowserView, browserViewError);
+			browserViewSection(actor.id, actor.localBrowserView, browserViewError) +
+			(await standbySection(actor));
 		res.send(layout(`Actor ${actor.name}`, body));
 	});
 
@@ -471,6 +508,7 @@ export function createConsoleServer(deps: ConsoleServerDeps): Express {
 			['startedAt', run.startedAt],
 			['finishedAt', run.finishedAt ?? ''],
 			['statusMessage', run.statusMessage ?? ''],
+			['origin', run.meta.origin],
 			['migrationCount', run.stats?.migrationCount ?? 0],
 			['rebootCount', run.stats?.rebootCount ?? 0],
 			['defaultDatasetId', storageLink('/datasets', run.defaultDatasetId)],
diff --git a/src/driver/docker-driver.ts b/src/driver/docker-driver.ts
index 10d57341..7ac39985 100644
--- a/src/driver/docker-driver.ts
+++ b/src/driver/docker-driver.ts
@@ -72,6 +72,7 @@ import {
 	type BrowserViewerTarget,
 	type BuildContext,
 	type BuildOutcome,
+	type ContainerServerAddress,
 	type DevFolderMount,
 	type DevFolderProbeFailureReason,
 	type DevFolderProbeOutcome,
@@ -698,6 +699,8 @@ export class DockerDriver implements Driver {
 	/** Shared by concurrent callers; cleared on failure so a later call retries (like `probeImageBuild`). */
 	private browserViewerImport: Promise<string> | undefined;
 	private readonly browserViewers = new Map<string, { container: Docker.Container; volumeName: string }>();
+	/** A started standby container's server address, keyed by run id; gone with the container. */
+	private readonly containerServers = new Map<string, ContainerServerAddress>();
 
 	available = false;
 	unavailableReason: string | undefined;
@@ -1123,6 +1126,29 @@ export class DockerDriver implements Driver {
 				: []),
 		];
 
+		const serverRoute = ctx.containerServerPort ? this.containerServerRoute() : undefined;
+		// Only a server this process cannot reach on `apify-local` is published, on an engine-picked port.
+		const serverPublish =
+			ctx.containerServerPort && serverRoute !== 'network'
+				? {
+						port: `${ctx.containerServerPort}/tcp`,
+						// A process on the host reaches loopback; one in a container off the network reaches the host.
+						binding: { HostIp: serverRoute === 'loopback' ? '127.0.0.1' : '', HostPort: '' },
+					}
+				: undefined;
+		const exposedPorts: Record<string, object> = {
+			...(ctx.debug ? { [`${ctx.debug.port}/tcp`]: {} } : {}),
+			...(serverPublish ? { [serverPublish.port]: {} } : {}),
+		};
+		const portBindings: Record<string, Array<{ HostIp: string; HostPort: string }>> = {
+			// Fixed 127.0.0.1-bound publish - lands on the developer's own host, not wherever the
+			// runtime process itself runs.
+			...(ctx.debug
+				? { [`${ctx.debug.port}/tcp`]: [{ HostIp: '127.0.0.1', HostPort: String(ctx.debug.port) }] }
+				: {}),
+			...(serverPublish ? { [serverPublish.port]: [serverPublish.binding] } : {}),
+		};
+
 		const container = await this.docker.createContainer({
 			Image: ctx.imageId,
 			Env: env,
@@ -1133,7 +1159,7 @@ export class DockerDriver implements Driver {
 						...(preservedEntrypoint.cmd ? { Cmd: preservedEntrypoint.cmd } : {}),
 					}
 				: {}),
-			...(ctx.debug ? { ExposedPorts: { [`${ctx.debug.port}/tcp`]: {} } } : {}),
+			...(Object.keys(exposedPorts).length > 0 ? { ExposedPorts: exposedPorts } : {}),
 			HostConfig: {
 				...(await this.actorNetworkHostConfig()),
 				...(this.resourceLimits.memory ? { Memory: ctx.memoryMbytes * 1024 * 1024 } : {}),
@@ -1145,15 +1171,7 @@ export class DockerDriver implements Driver {
 					: {}),
 				AutoRemove: false,
 				...(mounts.length > 0 ? { Mounts: mounts } : {}),
-				// Fixed 127.0.0.1-bound publish - lands on the developer's own host, not wherever the
-				// runtime process itself runs.
-				...(ctx.debug
-					? {
-							PortBindings: {
-								[`${ctx.debug.port}/tcp`]: [{ HostIp: '127.0.0.1', HostPort: String(ctx.debug.port) }],
-							},
-						}
-					: {}),
+				...(Object.keys(portBindings).length > 0 ? { PortBindings: portBindings } : {}),
 			},
 			Tty: false,
 		});
@@ -1189,6 +1207,17 @@ export class DockerDriver implements Driver {
 			// removes the container.
 			sampler = onSample ? startResourceSampler(container, ctx.memoryMbytes * 1024 * 1024, onSample) : undefined;
 
+			if (ctx.containerServerPort && serverRoute) {
+				const address = await this.resolveContainerServer(container, ctx.containerServerPort, serverRoute);
+				if (address) this.containerServers.set(ctx.runId, address);
+				else
+					onLog(
+						formatRuntimeLog(
+							`Could not determine where the Actor's server on port ${ctx.containerServerPort} is reachable.`,
+						),
+					);
+			}
+
 			const logStream = (await container.logs({
 				follow: true,
 				stdout: true,
@@ -1229,10 +1258,12 @@ export class DockerDriver implements Driver {
 				logStream.once('close', finish);
 			});
 
-			timeout = setTimeout(() => {
-				this.timedOutRuns.add(ctx.runId);
-				void container.stop().catch(() => undefined);
-			}, ctx.timeoutSecs * 1000);
+			if (ctx.timeoutSecs > 0) {
+				timeout = setTimeout(() => {
+					this.timedOutRuns.add(ctx.runId);
+					void container.stop().catch(() => undefined);
+				}, ctx.timeoutSecs * 1000);
+			}
 
 			const result = (await container.wait()) as { StatusCode: number };
 			// `container.wait()` resolves the same way whether the process exited on its own or was
@@ -1272,6 +1303,7 @@ export class DockerDriver implements Driver {
 			await sampler?.stop();
 			this.timedOutRuns.delete(ctx.runId);
 			this.runContainers.delete(ctx.runId);
+			this.containerServers.delete(ctx.runId);
 			// `{ v: true }` also removes any anonymous volumes; the named per-run `node_modules` volume of a
 			// `devMount` run (`buildDevMounts`) is not covered by it and goes separately, after the container.
 			await container.remove({ v: true }).catch(() => undefined);
@@ -1279,6 +1311,40 @@ export class DockerDriver implements Driver {
 		}
 	}
 
+	async containerServerAddress(runId: string): Promise<ContainerServerAddress | undefined> {
+		return this.containerServers.get(runId);
+	}
+
+	/**
+	 * How this process reaches a standby container's server: directly on `apify-local` when this process
+	 * sits there too; otherwise through a published port - on loopback for a process running on the host
+	 * itself, on the host's address for one in a container off the network (rootless Podman, Podman 3.x).
+	 */
+	private containerServerRoute(): 'network' | 'loopback' | 'host' {
+		if (this.onActorNetwork && !this.actorsOnDefaultNetwork) return 'network';
+		return process.env.HOSTNAME ? 'host' : 'loopback';
+	}
+
+	private async resolveContainerServer(
+		container: Docker.Container,
+		port: number,
+		route: 'network' | 'loopback' | 'host',
+	): Promise<ContainerServerAddress | undefined> {
+		const info = await container.inspect().catch(() => undefined);
+		if (!info) return undefined;
+		if (route === 'network') {
+			const host = containerAddress(info, NETWORK_NAME);
+			return host ? { host, port } : undefined;
+		}
+		const hostPort = Number(info.NetworkSettings?.Ports?.[`${port}/tcp`]?.[0]?.HostPort);
+		if (!Number.isInteger(hostPort) || hostPort <= 0) return undefined;
+		if (route === 'loopback') return { host: '127.0.0.1', port: hostPort };
+		const host =
+			(await engineHostEntry(this.hostsFile)) ??
+			defaultGatewayFromRouteTable(await readFile(this.routeFile, 'utf8').catch(() => ''));
+		return host ? { host, port: hostPort } : undefined;
+	}
+
 	/** `startRun`'s pre-container check that a registered dev folder is still a directory on the host -
 	 * the same probe registration used (`probeDevFolder`), so the two can never disagree on what counts as
 	 * present. Throws (failing the run, with this as its status message) on every non-ok outcome, including
@@ -1429,9 +1495,11 @@ export class DockerDriver implements Driver {
 			`Debug mode: this run is paused before its first line, waiting for a debugger. ${tool} is listening ` +
 			`inside the container on 0.0.0.0:${port}, published on the host at 127.0.0.1:${port} - ${attach}. Set ` +
 			`your breakpoints as part of that attach - the runtime does not stop synthetically beyond the initial ` +
-			`wait, so code runs to your first breakpoint once the IDE delivers it. The run's ${timeoutSecs}s timeout ` +
-			`is already running and is NOT extended for debugging; pass a larger \`apify call --timeout\` when you ` +
-			`expect a long session.\n`
+			`wait, so code runs to your first breakpoint once the IDE delivers it. ` +
+			(timeoutSecs > 0
+				? `The run's ${timeoutSecs}s timeout is already running and is NOT extended for debugging; pass a ` +
+					`larger \`apify call --timeout\` when you expect a long session.\n`
+				: `The run has no timeout.\n`)
 		);
 	}
 
diff --git a/src/driver/types.ts b/src/driver/types.ts
index ef2fff70..96a6d384 100644
--- a/src/driver/types.ts
+++ b/src/driver/types.ts
@@ -32,7 +32,10 @@ export interface RunContext {
 	imageId: string;
 	env: Record<string, string>;
 	memoryMbytes: number;
+	/** `0` means no timeout. */
 	timeoutSecs: number;
+	/** Set for a standby run: the port its HTTP server listens on, which the runtime must be able to reach. */
+	containerServerPort?: number;
 	devMount?: DevFolderMount;
 	debug?: DebugRunTarget;
 	/** Volume from `BrowserViewerHandle`, mounted over the Actor container's `/tmp/.X11-unix`. */
@@ -116,6 +119,12 @@ export interface RunOutcome {
 	timedOut: boolean;
 }
 
+/** Where this process reaches a run's HTTP server. */
+export interface ContainerServerAddress {
+	host: string;
+	port: number;
+}
+
 /**
  * Thrown by `Driver.startBuild` when the driver itself killed the build because `timeoutSecs` elapsed
  * (as opposed to any other build failure, which surfaces as a plain `Error`). The caller maps this to
@@ -207,4 +216,8 @@ export interface Driver {
 
 	/** Removes the run's sidecar and volume. Idempotent; never rejects. */
 	stopBrowserViewer(runId: string): Promise<void>;
+
+	/** Where the run's current container serves `RunContext.containerServerPort`, or `undefined` while
+	 * the run has no started container with one. Changes when a migration restarts the container. */
+	containerServerAddress(runId: string): Promise<ContainerServerAddress | undefined>;
 }
diff --git a/src/index.ts b/src/index.ts
index 9e56a685..e4bff536 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -4,6 +4,7 @@ import { reconcileOrphanedJobs } from './services/runs.js';
 import { createDriver } from './driver/index.js';
 import { createApiServer } from './api/server.js';
 import { attachEventsWebSocket } from './api/events-ws.js';
+import { closeStandbyUpgrades, handleStandbyUpgrade } from './api/standby-proxy.js';
 import { createConsoleServer } from './console/server.js';
 import { attachBrowserViewWebSocket } from './console/browser-view-ws.js';
 import { startLogFlusher } from './services/logs.js';
@@ -29,7 +30,9 @@ async function main(): Promise<void> {
 	// Upgrades on the same API server/port - no second port (`system.md`'s fixed-ports contract); see
 	// `api/events-ws.ts`'s own doc comment for why this attaches here rather than inside `createApiServer`
 	// (Express never sees an `upgrade` event, so this needs the actual `http.Server` `listen()` returned).
-	const eventsWebSocketServer = attachEventsWebSocket(apiServer);
+	const eventsWebSocketServer = attachEventsWebSocket(apiServer, (req, socket, head) =>
+		handleStandbyUpgrade(driver, req, socket, head),
+	);
 	const browserViewWebSocketServer = attachBrowserViewWebSocket(consoleServer);
 
 	console.log(`actor-runtime API listening on port ${API_PORT}`);
@@ -45,6 +48,7 @@ async function main(): Promise<void> {
 	}
 
 	const shutdown = async () => {
+		closeStandbyUpgrades();
 		await gracefulShutdown({ apiServer, consoleServer, eventsWebSocketServer, browserViewWebSocketServer });
 		process.exit(0);
 	};
diff --git a/src/services/actors.ts b/src/services/actors.ts
index 95441acd..e855a1cb 100644
--- a/src/services/actors.ts
+++ b/src/services/actors.ts
@@ -1,5 +1,5 @@
 import { generateId } from '../storage/ids.js';
-import type { ActorRecord, ActorVersionRecord, UserRecord } from '../storage/entities.js';
+import type { ActorRecord, ActorStandbyRecord, ActorVersionRecord, UserRecord } from '../storage/entities.js';
 import { getRegistries } from '../storage/registries.js';
 import { validatePricingInfosUpdate, type InvalidPricingInfos } from './pricing.js';
 import { isCallerOwner, normalizeName, type ResolvableReference } from './resource-reference.js';
@@ -12,6 +12,7 @@ export interface CreateActorInput {
 	name: string;
 	title?: string;
 	versions?: ActorVersionRecord[];
+	actorStandby?: ActorStandbyRecord;
 }
 
 export async function createActor(userId: string, input: CreateActorInput): Promise<ActorRecord> {
@@ -25,6 +26,7 @@ export async function createActor(userId: string, input: CreateActorInput): Prom
 		modifiedAt: now,
 		versions: input.versions ?? [],
 		taggedBuilds: {},
+		...(input.actorStandby ? { actorStandby: input.actorStandby } : {}),
 	};
 	await getRegistries().actors.set(record.id, record);
 	return record;
diff --git a/src/services/runs.ts b/src/services/runs.ts
index 42362526..214563e2 100644
--- a/src/services/runs.ts
+++ b/src/services/runs.ts
@@ -23,6 +23,7 @@ import { CONTAINER_EVENTS_WS_BASE_URL } from '../config.js';
 import { formatRuntimeLogLines } from '../runtime-log.js';
 import { getRunTelemetry } from './events-channel.js';
 import { initialChargedEventCounts, resolveRunPricingInfo } from './pricing.js';
+import { consumeStandbyRunFinishing } from './standby-finish.js';
 import {
 	actorStartChargeMessage,
 	registerDefaultDatasetForCharging,
@@ -31,6 +32,8 @@ import {
 
 const DEFAULT_MEMORY_MBYTES = 1024;
 const DEFAULT_TIMEOUT_SECS = 300;
+/** `@apify/consts`' `DEFAULT_CONTAINER_PORT`. */
+const DEFAULT_CONTAINER_SERVER_PORT = 4321;
 /** The public API docs don't state a separate disk default; this mirrors the 2x ratio the public
  * OpenAPI examples use for the pair (`memoryMbytes: 1024` paired with `diskMbytes: 2048`), also the
  * exact ratio in `apify-client`'s `RunOptions` pydantic model examples. */
@@ -101,11 +104,36 @@ export interface StartRunOptions {
 	devFolder?: boolean;
 	/** Absent means no cap. */
 	maxTotalChargeUsd?: number;
+	/** `STANDBY` for a run the standby router starts; `API` otherwise. */
+	origin?: 'API' | 'STANDBY';
+	/** The Actor's standby URL, given to every run as `ACTOR_STANDBY_URL`, as on the platform. */
+	standbyUrl?: string;
 	proxyPassword?: string;
 	apiBaseUrl: string;
 	token: string;
 }
 
+function versionEnvOf(version: ActorVersionRecord | undefined): Record<string, string> {
+	const versionEnv: Record<string, string> = {};
+	for (const entry of version?.envVars ?? []) {
+		versionEnv[entry.name] = entry.value;
+	}
+	return versionEnv;
+}
+
+/**
+ * The port the Actor's HTTP server listens on: the platform reads a version-level
+ * `ACTOR_WEB_SERVER_PORT`, then `ACTOR_STANDBY_PORT`, then defaults to 4321.
+ */
+export function containerServerPortFor(version: ActorVersionRecord | undefined): number {
+	const versionEnv = versionEnvOf(version);
+	for (const name of ['ACTOR_WEB_SERVER_PORT', 'ACTOR_STANDBY_PORT']) {
+		const port = Number(versionEnv[name]);
+		if (Number.isInteger(port) && port > 0 && port < 65536) return port;
+	}
+	return DEFAULT_CONTAINER_SERVER_PORT;
+}
+
 /**
  * Version-level `envVars` (accepted and stored on `POST`/`PUT .../versions`, `actor-driver.md`) are
  * applied to the run's container environment, merged in *below* the platform-owned vars so a version
@@ -119,10 +147,7 @@ function buildEnv(
 	options: StartRunOptions,
 	debugPlan: DebugPlan | undefined,
 ): Record<string, string> {
-	const versionEnv: Record<string, string> = {};
-	for (const entry of version?.envVars ?? []) {
-		versionEnv[entry.name] = entry.value;
-	}
+	const versionEnv = versionEnvOf(version);
 
 	// Both names in each pair are byte-identical, deliberately: apify-sdk-js's `ENV_MAP` and pydantic's
 	// `AliasChoices` resolve `ACTOR_*`-vs-`APIFY_*` in OPPOSITE precedence order, so letting the two ever
@@ -143,7 +168,7 @@ function buildEnv(
 		// Below every platform-owned var so a debug run can never shadow one.
 		...debugEnv,
 		APIFY_IS_AT_HOME: '1',
-		APIFY_META_ORIGIN: 'API',
+		APIFY_META_ORIGIN: run.meta.origin,
 		APIFY_API_BASE_URL: options.apiBaseUrl,
 		APIFY_TOKEN: options.token,
 		APIFY_DEFAULT_KEY_VALUE_STORE_ID: run.defaultKeyValueStoreId,
@@ -160,7 +185,9 @@ function buildEnv(
 		APIFY_MEMORY_MBYTES: memoryMbytes,
 		// No `ACTOR_`-prefixed counterpart exists; only the Python SDK reads this.
 		APIFY_DEDICATED_CPUS: String(dedicatedCpusFor(run.options.memoryMbytes)),
+		ACTOR_STANDBY_PORT: String(containerServerPortFor(version)),
 	};
+	if (options.standbyUrl) env.ACTOR_STANDBY_URL = options.standbyUrl;
 	if (options.proxyPassword) env.APIFY_PROXY_PASSWORD = options.proxyPassword;
 	// Deliberately not accompanied by `APIFY_ACTOR_PRICING_INFO`/`APIFY_CHARGED_ACTOR_EVENT_COUNTS`: with
 	// both set the SDKs skip their fetch of the run object, and a container restarted by a migration would
@@ -212,7 +239,7 @@ export async function startRun(
 			diskMbytes: memoryMbytes * DISK_MBYTES_PER_MEMORY_MBYTE,
 			...(options.maxTotalChargeUsd !== undefined ? { maxTotalChargeUsd: options.maxTotalChargeUsd } : {}),
 		},
-		meta: { origin: 'API' },
+		meta: { origin: options.origin ?? 'API' },
 		// Same zeros the platform writes at run creation (see `RunRecord.stats`).
 		stats: {
 			migrationCount: 0,
@@ -415,6 +442,9 @@ export async function runInBackground(
 					memoryMbytes: record.options.memoryMbytes,
 					// The timeout budget is per run, not per container - a restart gets only what is left.
 					timeoutSecs: remainingTimeoutSecs(record),
+					...(record.meta.origin === 'STANDBY'
+						? { containerServerPort: containerServerPortFor(version) }
+						: {}),
 					devMount,
 					debug: debugPlan ? { language: debugPlan.language, port: debugPlan.port } : undefined,
 					// The sidecar outlives a migration/reboot restart; the new container mounts the same volume.
@@ -439,7 +469,14 @@ export async function runInBackground(
 				}
 			}
 
-			const status: JobStatus = outcome.timedOut ? 'TIMED-OUT' : outcome.exitCode === 0 ? 'SUCCEEDED' : 'FAILED';
+			// A standby run the runtime wound down ends `SUCCEEDED` whatever its exit code, as on the platform.
+			const status: JobStatus = consumeStandbyRunFinishing(record.id)
+				? 'SUCCEEDED'
+				: outcome.timedOut
+					? 'TIMED-OUT'
+					: outcome.exitCode === 0
+						? 'SUCCEEDED'
+						: 'FAILED';
 			// Flush before writing the terminal status, not after: `driver.startRun` resolving is the signal
 			// that every `onLog` call for this run has already happened (the Docker driver waits for its log
 			// capture stream to fully drain before resolving - see `docker-driver.ts`'s doc comment on
@@ -491,6 +528,7 @@ export async function runInBackground(
 		if (browserViewer) await driver.stopBrowserViewer(record.id);
 		// A run that ends for real must not leave an armed migration-stop timer behind.
 		clearRunRestartState(record.id);
+		consumeStandbyRunFinishing(record.id);
 		markLogTerminal(record.id);
 		// Also what actually drives the events websocket's `1000` close (`api/events-ws.ts` polls this
 		// exact flag, mirroring `api/routes/logs.ts`'s `?stream=true` handling of `isLogTerminal`).
@@ -507,8 +545,10 @@ async function persistRunTelemetry(runId: string): Promise<void> {
 	);
 }
 
-/** Clamped to at least 1s so a run migrated at the edge of its budget still starts and times out. */
+/** Clamped to at least 1s so a run migrated at the edge of its budget still starts and times out. A
+ * run with no timeout (`0`) keeps having none. */
 function remainingTimeoutSecs(record: RunRecord): number {
+	if (record.options.timeoutSecs === 0) return 0;
 	const elapsedSecs = (Date.now() - Date.parse(record.startedAt)) / 1000;
 	return Math.max(1, Math.ceil(record.options.timeoutSecs - elapsedSecs));
 }
diff --git a/src/services/standby-config.ts b/src/services/standby-config.ts
new file mode 100644
index 00000000..1b5870f4
--- /dev/null
+++ b/src/services/standby-config.ts
@@ -0,0 +1,122 @@
+/**
+ * An Actor's `actorStandby` settings (`actor-driver.md`'s "Actor Standby"): the platform's field set,
+ * defaults and validation rules (apify-core's `ActorStandbySchema`), single-tenant only.
+ */
+import type { ActorRecord, ActorStandbyRecord, SourceFile } from '../storage/entities.js';
+import { API_PORT } from '../config.js';
+import { parseActorJson } from './actor-source-files.js';
+import { DEFAULT_BUILD_TAG } from './actors.js';
+
+export const STANDBY_DEFAULTS: ActorStandbyRecord = {
+	isEnabled: false,
+	disableStandbyFieldsOverride: false,
+	tenancy: 'SINGLE_TENANT',
+	desiredRequestsPerActorRun: 3,
+	maxRequestsPerActorRun: 4,
+	idleTimeoutSecs: 300,
+	build: DEFAULT_BUILD_TAG,
+	memoryMbytes: 1024,
+	shouldPassActorInput: false,
+};
+
+const MIN_IDLE_TIMEOUT_SECS = 5;
+
+/** Where a standby Actor is served: `/actor-runtime/standby/<label>/...` on the API port. */
+export const STANDBY_PATH_PREFIX = '/actor-runtime/standby';
+
+export type StandbyUpdateResult =
+	{ kind: 'ok'; actorStandby: ActorStandbyRecord } | { kind: 'invalid'; message: string };
+
+const BOOLEAN_FIELDS = ['isEnabled', 'disableStandbyFieldsOverride', 'shouldPassActorInput'] as const;
+const INTEGER_FIELDS = [
+	'desiredRequestsPerActorRun',
+	'maxRequestsPerActorRun',
+	'idleTimeoutSecs',
+	'memoryMbytes',
+] as const;
+/** Accepted and dropped: the platform lets only admins set them. */
+const ADMIN_ONLY_FIELDS = ['isConsoleAuthEnabled', 'isTokenlessEnabled'];
+
+/**
+ * Merges `raw` over `current` (itself over the defaults), as the platform does for both create and a
+ * partial update, then validates the result.
+ */
+export function mergeStandbyUpdate(raw: unknown, current: ActorStandbyRecord | undefined): StandbyUpdateResult {
+	if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
+		return { kind: 'invalid', message: '"actorStandby" must be an object' };
+	}
+	const body = raw as Record<string, unknown>;
+	const merged: ActorStandbyRecord = { ...STANDBY_DEFAULTS, ...current };
+
+	for (const [key, value] of Object.entries(body)) {
+		if (value === undefined || value === null) continue;
+		if ((BOOLEAN_FIELDS as readonly string[]).includes(key)) {
+			if (typeof value !== 'boolean')
+				return { kind: 'invalid', message: `actorStandby.${key} must be a boolean` };
+			merged[key as (typeof BOOLEAN_FIELDS)[number]] = value;
+		} else if ((INTEGER_FIELDS as readonly string[]).includes(key)) {
+			if (typeof value !== 'number' || !Number.isInteger(value)) {
+				return { kind: 'invalid', message: `actorStandby.${key} must be an integer` };
+			}
+			merged[key as (typeof INTEGER_FIELDS)[number]] = value;
+		} else if (key === 'build') {
+			if (typeof value !== 'string' || value.trim() === '') {
+				return { kind: 'invalid', message: 'actorStandby.build must be a build tag or build number' };
+			}
+			merged.build = value;
+		} else if (key === 'tenancy') {
+			if (value !== 'SINGLE_TENANT') {
+				return { kind: 'invalid', message: 'Only SINGLE_TENANT Actor Standby is supported by this runtime' };
+			}
+		} else if (!ADMIN_ONLY_FIELDS.includes(key)) {
+			return { kind: 'invalid', message: `Unknown field actorStandby.${key}` };
+		}
+	}
+
+	if (merged.desiredRequestsPerActorRun < 1) {
+		return { kind: 'invalid', message: 'actorStandby.desiredRequestsPerActorRun must be >= 1' };
+	}
+	if (merged.maxRequestsPerActorRun < 1) {
+		return { kind: 'invalid', message: 'actorStandby.maxRequestsPerActorRun must be >= 1' };
+	}
+	if (merged.maxRequestsPerActorRun < merged.desiredRequestsPerActorRun) {
+		return { kind: 'invalid', message: 'Max requests must be greater than or equal to desired requests.' };
+	}
+	if (merged.idleTimeoutSecs < MIN_IDLE_TIMEOUT_SECS) {
+		return { kind: 'invalid', message: `actorStandby.idleTimeoutSecs must be >= ${MIN_IDLE_TIMEOUT_SECS}` };
+	}
+	if (merged.memoryMbytes < 1) return { kind: 'invalid', message: 'actorStandby.memoryMbytes must be >= 1' };
+	return { kind: 'ok', actorStandby: merged };
+}
+
+/** `usesStandbyMode: true` in the pushed `.actor/actor.json`; an unparseable file says nothing. */
+export function declaresStandbyMode(sourceFiles: SourceFile[]): boolean {
+	const parsed = parseActorJson(sourceFiles);
+	if (parsed.outcome !== 'parsed') return false;
+	const specification = parsed.specification as { usesStandbyMode?: unknown } | null;
+	return typeof specification === 'object' && specification !== null && specification.usesStandbyMode === true;
+}
+
+/** The platform's `dnsFriendlyUsername`: what a DNS label can carry. */
+function dnsFriendly(value: string): string {
+	return value
+		.toLowerCase()
+		.replace(/[^a-z0-9-]+/g, '-')
+		.replace(/^-+|-+$/g, '');
+}
+
+/** The platform's `<username>--<actor-name>` hostname label. */
+export function standbyLabel(actor: ActorRecord, username: string): string {
+	return `${dnsFriendly(username)}--${actor.name.toLowerCase()}`;
+}
+
+/** Host-facing: the runtime's own API port, which is what every client of the Actor reaches. */
+export function standbyUrl(actor: ActorRecord, username: string): string {
+	return `http://localhost:${API_PORT}${STANDBY_PATH_PREFIX}/${standbyLabel(actor, username)}`;
+}
+
+/** The label, or `undefined` for a Host header not of the `<label>.localhost` form. */
+export function labelFromHost(host: string | undefined): string | undefined {
+	const match = host?.toLowerCase().match(/^([a-z0-9-]+)\.localhost(?::\d+)?$/);
+	return match?.[1];
+}
diff --git a/src/services/standby-finish.ts b/src/services/standby-finish.ts
new file mode 100644
index 00000000..9be1fee1
--- /dev/null
+++ b/src/services/standby-finish.ts
@@ -0,0 +1,18 @@
+/**
+ * Standby runs the runtime itself is winding down (idle, or replaced by a newer build). Such a run ends
+ * `SUCCEEDED` however its container exits, as on the platform. Kept apart from `services/standby.ts` so
+ * `services/runs.ts` can read it without importing the pool that starts runs.
+ */
+const finishingRuns = new Set<string>();
+
+export function markStandbyRunFinishing(runId: string): void {
+	finishingRuns.add(runId);
+}
+
+export function consumeStandbyRunFinishing(runId: string): boolean {
+	return finishingRuns.delete(runId);
+}
+
+export function resetStandbyFinishingForTests(): void {
+	finishingRuns.clear();
+}
diff --git a/src/services/standby.ts b/src/services/standby.ts
new file mode 100644
index 00000000..3065080c
--- /dev/null
+++ b/src/services/standby.ts
@@ -0,0 +1,357 @@
+/**
+ * The standby run pool (`actor-driver.md`'s "Actor Standby"): which run of a standby Actor serves the
+ * next request, when another run is started, and when an idle one is wound down. Single-tenant only -
+ * every run belongs to the Actor's owner, who is the only caller the router lets through.
+ *
+ * In memory only: a runtime restart aborts every run anyway (`reconcileOrphanedJobs`).
+ */
+import http from 'node:http';
+
+import type { ActorRecord, ActorStandbyRecord, BuildRecord, UserRecord } from '../storage/entities.js';
+import type { ContainerServerAddress, Driver } from '../driver/types.js';
+import { getRegistries } from '../storage/registries.js';
+import { CONTAINER_API_BASE_URL } from '../config.js';
+import { appendRuntimeLog } from './logs.js';
+import { publishAborting, publishPersistState } from './events-channel.js';
+import { isTerminalJobStatus } from './job-status.js';
+import { resolveTaggedBuild } from './builds.js';
+import { resolveBuildInput } from './input-schema.js';
+import { resolveProxyPassword } from './users.js';
+import { containerServerPortFor, startRun } from './runs.js';
+import { findVersion } from './actors.js';
+import { markStandbyRunFinishing } from './standby-finish.js';
+import { standbyUrl } from './standby-config.js';
+
+/** The platform's readiness probe: a `GET /` carrying this header; any HTTP response means ready. */
+export const READINESS_PROBE_HEADER = 'x-apify-container-server-readiness-probe';
+const READINESS_POLL_MS = 500;
+const READINESS_PROBE_TIMEOUT_MS = 2_000;
+/** How long a request waits for a starting run's server before giving up on it. */
+const DEFAULT_READY_TIMEOUT_MS = 180_000;
+/** Between the `aborting` frame and the stop signal, then again before the kill - the platform's 15 s + 15 s. */
+const FINISH_WARNING_MS = 15_000;
+const FINISH_GRACE_SECS = 15;
+
+/** A request that could not be given a run; the router answers with this status and message. */
+export class StandbyUnavailableError extends Error {
+	constructor(
+		readonly status: number,
+		readonly type: string,
+		message: string,
+	) {
+		super(message);
+	}
+}
+
+interface PooledRun {
+	/** Resolves once the run record exists; the entry is in the pool before that, so concurrent
+	 * requests count against it instead of each starting a run of their own. */
+	readonly runId: Promise<string>;
+	knownRunId?: string;
+	readonly buildId: string;
+	openRequests: number;
+	/** The address last seen answering the readiness probe; a restarted container has a new one. */
+	readyAddress?: string;
+	idleTimer?: ReturnType<typeof setTimeout>;
+	/** Retired from the pool: takes no new requests and is wound down once its last one completes. */
+	retiring?: string;
+}
+
+export interface StandbyLease {
+	runId: string;
+	address: ContainerServerAddress;
+	/** The request reached a container that refused it: re-probe before the next request uses it. */
+	markUnreachable(): void;
+	release(): void;
+}
+
+const pools = new Map<string, PooledRun[]>();
+let readyTimeoutMs = DEFAULT_READY_TIMEOUT_MS;
+let finishWarningMs = FINISH_WARNING_MS;
+
+function poolOf(actorId: string): PooledRun[] {
+	let pool = pools.get(actorId);
+	if (!pool) {
+		pool = [];
+		pools.set(actorId, pool);
+	}
+	return pool;
+}
+
+function removeFromPool(actorId: string, entry: PooledRun): void {
+	const pool = pools.get(actorId);
+	if (!pool) return;
+	const index = pool.indexOf(entry);
+	if (index !== -1) pool.splice(index, 1);
+	if (entry.idleTimer) clearTimeout(entry.idleTimer);
+	entry.idleTimer = undefined;
+}
+
+/** Drops runs that ended on their own (crashed, aborted, finished) since the pool last looked. */
+async function pruneEndedRuns(actorId: string): Promise<void> {
+	const { runs } = getRegistries();
+	for (const entry of [...poolOf(actorId)]) {
+		if (!entry.knownRunId) continue;
+		const record = await runs.get(entry.knownRunId);
+		if (!record || isTerminalJobStatus(record.status) || record.status === 'ABORTING') {
+			removeFromPool(actorId, entry);
+		}
+	}
+}
+
+async function resolveStandbyBuild(actor: ActorRecord, config: ActorStandbyRecord): Promise<BuildRecord> {
+	const lookup = await resolveTaggedBuild(actor, config.build);
+	if (lookup.found) return lookup.build;
+	throw new StandbyUnavailableError(
+		404,
+		'record-not-found',
+		`Actor has no build tagged "${config.build}" for Actor Standby - push the Actor, or change actorStandby.build.`,
+	);
+}
+
+/** The run the platform's controller would start: standby build and memory, no timeout, input only on request. */
+async function startStandbyRun(driver: Driver, actor: ActorRecord, build: BuildRecord, user: UserRecord) {
+	const config = actor.actorStandby!;
+	let input: { body: Buffer; contentType: string } | undefined;
+	if (config.shouldPassActorInput) {
+		const processed = resolveBuildInput(build, undefined);
+		if (processed.kind !== 'ok') {
+			throw new StandbyUnavailableError(400, processed.kind, processed.message);
+		}
+		input = processed.input;
+	}
+	return startRun(driver, actor, build, {
+		origin: 'STANDBY',
+		input,
+		memoryMbytes: config.memoryMbytes,
+		timeoutSecs: 0,
+		build: config.build,
+		standbyUrl: standbyUrl(actor, user.username),
+		proxyPassword: resolveProxyPassword(user),
+		apiBaseUrl: CONTAINER_API_BASE_URL,
+		token: user.token,
+	});
+}
+
+function addRun(
+	driver: Driver,
+	actor: ActorRecord,
+	build: BuildRecord,
+	user: UserRecord,
+	onStarted: (entry: PooledRun, runId: string) => void,
+): PooledRun {
+	const pool = poolOf(actor.id);
+	const started = startStandbyRun(driver, actor, build, user).then((run) => run.id);
+	const entry: PooledRun = { runId: started, buildId: build.id, openRequests: 0 };
+	pool.push(entry);
+	started.then(
+		(runId) => {
+			entry.knownRunId = runId;
+			onStarted(entry, runId);
+		},
+		() => removeFromPool(actor.id, entry),
+	);
+	return entry;
+}
+
+/**
+ * Picks the least loaded run below `maxRequestsPerActorRun`, starting one when there is none, and
+ * starts one more ahead of demand once every run is above `desiredRequestsPerActorRun`. Resolves once the
+ * picked run's server answers; the caller must `release()` the lease when its request is done.
+ */
+export async function acquireStandbyRun(driver: Driver, actor: ActorRecord, user: UserRecord): Promise<StandbyLease> {
+	const config = actor.actorStandby;
+	if (!config?.isEnabled) {
+		throw new StandbyUnavailableError(400, 'standby-not-enabled', "This Actor doesn't have Standby mode enabled.");
+	}
+	const build = await resolveStandbyBuild(actor, config);
+	await pruneEndedRuns(actor.id);
+
+	// Synchronous from here to the reservation, so two concurrent requests can never both see an empty pool.
+	const pool = poolOf(actor.id);
+	for (const entry of [...pool]) {
+		if (entry.buildId !== build.id && !entry.retiring) {
+			retire(driver, actor.id, entry, `a newer build (${build.buildNumber}) now serves Actor Standby`);
+		}
+	}
+	const onStarted = (entry: PooledRun, runId: string) => {
+		appendRuntimeLog(
+			runId,
+			`Actor Standby: this run serves requests to ${standbyUrl(actor, user.username)}; waiting for the ` +
+				`Actor's server on port ${containerServerPortFor(findVersion(actor, build.versionNumber))}.`,
+		);
+		if (entry.openRequests === 0) armIdleTimer(driver, actor.id, entry, config);
+	};
+	const candidates = () => pool.filter((entry) => !entry.retiring);
+	let picked: PooledRun | undefined;
+	for (const entry of candidates()) {
+		if (entry.openRequests >= config.maxRequestsPerActorRun) continue;
+		if (!picked || entry.openRequests < picked.openRequests) picked = entry;
+	}
+	picked ??= addRun(driver, actor, build, user, onStarted);
+	picked.openRequests++;
+	if (picked.idleTimer) clearTimeout(picked.idleTimer);
+	picked.idleTimer = undefined;
+	if (candidates().every((entry) => entry.openRequests > config.desiredRequestsPerActorRun)) {
+		addRun(driver, actor, build, user, onStarted);
+	}
+
+	const entry = picked;
+	let released = false;
+	const release = () => {
+		if (released) return;
+		released = true;
+		entry.openRequests--;
+		if (entry.openRequests > 0) return;
+		if (entry.retiring) void finishRun(driver, entry, entry.retiring);
+		else armIdleTimer(driver, actor.id, entry, config);
+	};
+
+	try {
+		const runId = await entry.runId.catch((error: unknown) => {
+			if (error instanceof StandbyUnavailableError) throw error;
+			throw new StandbyUnavailableError(
+				503,
+				'standby-run-failed',
+				`Could not start a standby run of the Actor: ${error instanceof Error ? error.message : String(error)}`,
+			);
+		});
+		const address = await waitForServer(driver, entry, runId);
+		return {
+			runId,
+			address,
+			markUnreachable: () => {
+				entry.readyAddress = undefined;
+			},
+			release,
+		};
+	} catch (error) {
+		release();
+		throw error;
+	}
+}
+
+async function waitForServer(driver: Driver, entry: PooledRun, runId: string): Promise<ContainerServerAddress> {
+	const deadline = Date.now() + readyTimeoutMs;
+	for (;;) {
+		const record = await getRegistries().runs.get(runId);
+		if (!record || isTerminalJobStatus(record.status) || record.status === 'ABORTING') {
+			const status = record?.status ?? 'deleted';
+			const reason = record?.statusMessage ? `: ${record.statusMessage}` : '';
+			throw new StandbyUnavailableError(
+				503,
+				'standby-run-finished',
+				`The Actor's standby run ${runId} finished (${status}${reason}) before serving the request; see its log.`,
+			);
+		}
+		const address = await driver.containerServerAddress(runId);
+		if (address) {
+			const key = `${address.host}:${address.port}`;
+			if (entry.readyAddress === key) return address;
+			if (await answersReadinessProbe(address)) {
+				if (entry.readyAddress === undefined) {
+					appendRuntimeLog(runId, "Actor Standby: the Actor's server is ready.");
+				}
+				entry.readyAddress = key;
+				return address;
+			}
+		}
+		if (Date.now() >= deadline) {
+			throw new StandbyUnavailableError(
+				504,
+				'standby-run-not-ready',
+				`The Actor's standby run ${runId} did not start listening on its standby port (ACTOR_STANDBY_PORT) ` +
+					`within ${Math.round(readyTimeoutMs / 1000)} s; see its log.`,
+			);
+		}
+		await new Promise((resolve) => setTimeout(resolve, READINESS_POLL_MS));
+	}
+}
+
+function answersReadinessProbe(address: ContainerServerAddress): Promise<boolean> {
+	return new Promise((resolve) => {
+		const request = http.get(
+			{
+				host: address.host,
+				port: address.port,
+				path: '/',
+				headers: { [READINESS_PROBE_HEADER]: '1' },
+				timeout: READINESS_PROBE_TIMEOUT_MS,
+			},
+			(response) => {
+				response.resume();
+				resolve(true);
+			},
+		);
+		request.on('timeout', () => request.destroy());
+		request.on('error', () => resolve(false));
+	});
+}
+
+function armIdleTimer(driver: Driver, actorId: string, entry: PooledRun, config: ActorStandbyRecord): void {
+	if (entry.idleTimer) clearTimeout(entry.idleTimer);
+	entry.idleTimer = setTimeout(() => {
+		entry.idleTimer = undefined;
+		if (entry.openRequests > 0 || !pools.get(actorId)?.includes(entry)) return;
+		removeFromPool(actorId, entry);
+		void finishRun(driver, entry, 'Actor Standby server was idle for too long, finishing run.');
+	}, config.idleTimeoutSecs * 1000);
+}
+
+function retire(driver: Driver, actorId: string, entry: PooledRun, reason: string): void {
+	entry.retiring = `Actor Standby: ${reason}, finishing this run.`;
+	if (entry.idleTimer) clearTimeout(entry.idleTimer);
+	entry.idleTimer = undefined;
+	removeFromPool(actorId, entry);
+	if (entry.openRequests === 0) void finishRun(driver, entry, entry.retiring);
+}
+
+/**
+ * The platform's graceful finish: the `aborting` + `persistState` frames, the stop signal 15 s later
+ * and the kill 15 s after that. The run ends `SUCCEEDED` either way (`standby-finish.ts`).
+ */
+async function finishRun(driver: Driver, entry: PooledRun, message: string): Promise<void> {
+	const runId = await entry.runId.catch(() => undefined);
+	if (!runId) return;
+	// A run still starting is waited for: stopping it before its container exists would stop nothing.
+	let record = await getRegistries().runs.get(runId);
+	while (record?.status === 'READY') {
+		await new Promise((resolve) => setTimeout(resolve, READINESS_POLL_MS));
+		record = await getRegistries().runs.get(runId);
+	}
+	if (!record || record.status !== 'RUNNING') return;
+	markStandbyRunFinishing(runId);
+	appendRuntimeLog(runId, message);
+	publishAborting(runId);
+	publishPersistState(runId, false);
+	setTimeout(() => {
+		void driver.abortRun(runId, { graceSecs: FINISH_GRACE_SECS }).catch((error: unknown) => {
+			console.error(`run ${runId}: could not stop a finishing standby run`, error);
+		});
+	}, finishWarningMs);
+}
+
+/** For the console: the pool's live view of an Actor's standby runs. */
+export function standbyPoolSnapshot(actorId: string): Array<{ runId?: string; openRequests: number; ready: boolean }> {
+	return (pools.get(actorId) ?? []).map((entry) => ({
+		runId: entry.knownRunId,
+		openRequests: entry.openRequests,
+		ready: entry.readyAddress !== undefined,
+	}));
+}
+
+/** Test-only. */
+export function configureStandbyForTests(options: { readyTimeoutMs?: number; finishWarningMs?: number }): void {
+	if (options.readyTimeoutMs !== undefined) readyTimeoutMs = options.readyTimeoutMs;
+	if (options.finishWarningMs !== undefined) finishWarningMs = options.finishWarningMs;
+}
+
+/** Test-only: no timer may outlive the test that armed it. */
+export function resetStandbyForTests(): void {
+	for (const pool of pools.values()) {
+		for (const entry of pool) if (entry.idleTimer) clearTimeout(entry.idleTimer);
+	}
+	pools.clear();
+	readyTimeoutMs = DEFAULT_READY_TIMEOUT_MS;
+	finishWarningMs = FINISH_WARNING_MS;
+}
diff --git a/src/storage/entities.ts b/src/storage/entities.ts
index 538fa0fe..6056dcbd 100644
--- a/src/storage/entities.ts
+++ b/src/storage/entities.ts
@@ -125,6 +125,19 @@ export interface RunPricingInfoRecord {
 	};
 }
 
+/** The platform's `actorStandby` Actor field, single-tenant only (`services/standby-config.ts`). */
+export interface ActorStandbyRecord {
+	isEnabled: boolean;
+	disableStandbyFieldsOverride: boolean;
+	tenancy: 'SINGLE_TENANT';
+	desiredRequestsPerActorRun: number;
+	maxRequestsPerActorRun: number;
+	idleTimeoutSecs: number;
+	build: string;
+	memoryMbytes: number;
+	shouldPassActorInput: boolean;
+}
+
 export interface ActorRecord {
 	id: string;
 	userId: string;
@@ -136,6 +149,8 @@ export interface ActorRecord {
 	/** The Actor's pricing history (`actor-driver.md`). Unlike the `local*` fields below, it is exposed
 	 * on `/v2`. Absent or empty means the Actor is free. */
 	pricingInfos?: ActorPricingInfoRecord[];
+	/** Exposed on `/v2`; absent until the Actor is first given one. */
+	actorStandby?: ActorStandbyRecord;
 	/** tag -> latest successful build for that tag; `apify push` polls this after a build. */
 	taggedBuilds: Record<string, { buildId: string; buildNumber: string }>;
 	/** Host path bind-mounted over the image's working directory at run start (`actor-driver.md`). Set or
@@ -201,6 +216,7 @@ export interface RunRecord {
 	defaultRequestQueueId: string;
 	options: {
 		memoryMbytes: number;
+		/** `0` means no timeout - only a standby run has none. */
 		timeoutSecs: number;
 		/** Which build tag or build number this run used - the real platform's `options.build`
 		 * (the public API's `ActorRunOptions.build`). Optional here (unlike the always-populated real
diff --git a/test/e2e/standby.test.ts b/test/e2e/standby.test.ts
new file mode 100644
index 00000000..3edbaa26
--- /dev/null
+++ b/test/e2e/standby.test.ts
@@ -0,0 +1,146 @@
+/**
+ * Actor Standby end to end (`test.md`'s "Actor Standby"): `apify push` of `sample_actor_standby` enables
+ * Standby from its `.actor/actor.json`, requests to the Actor's standby URL are served by a standby run,
+ * and an idle run is wound down. The requests themselves are plain HTTP - the narrow exception `test.md`
+ * allows, since no `apify` command sends one; every other assertion reads `apify` output.
+ */
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+
+import {
+	buildRuntimeImage,
+	isDockerAvailable,
+	pullBaseImages,
+	startRuntimeContainer,
+	stopRuntimeContainer,
+	waitForHttpOk,
+} from './helpers/docker.js';
+import {
+	apify,
+	apifyEnv,
+	createIsolatedApifyHome,
+	loginApifyCli,
+	removeIsolatedApifyHome,
+	type ApiEnvelope,
+	type DatasetInfoResult,
+	type PushResult,
+} from './helpers/apify-cli.js';
+import { waitFor } from './helpers/wait.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = join(__dirname, '..', '..');
+const ACTOR_DIR = join(REPO_ROOT, 'sample_actor_standby');
+const CONTAINER_NAME = 'actor-runtime-e2e-standby';
+const IMAGE_TAG = 'actor-runtime:e2e';
+/** `helpers/apify-cli.ts`' login token. */
+const TOKEN = 'anything';
+
+interface RunSummary {
+	id: string;
+	status: string;
+	meta: { origin: string };
+	defaultDatasetId: string;
+	options: { timeoutSecs: number };
+}
+
+describe('Actor Standby via apify-cli (requires Docker)', () => {
+	let isolatedApifyHome: string;
+
+	beforeAll(
+		async () => {
+			if (!isDockerAvailable()) {
+				throw new Error(
+					'Docker daemon is not reachable - the e2e suite requires one (see requirements/test.md)',
+				);
+			}
+			pullBaseImages();
+			buildRuntimeImage(REPO_ROOT, IMAGE_TAG);
+			startRuntimeContainer(IMAGE_TAG, CONTAINER_NAME);
+			await waitForHttpOk('http://localhost:3333/v2/users/me?token=x');
+			isolatedApifyHome = createIsolatedApifyHome();
+			loginApifyCli(REPO_ROOT, isolatedApifyHome);
+		},
+		10 * 60 * 1000,
+	);
+
+	afterAll(() => {
+		stopRuntimeContainer(CONTAINER_NAME);
+		if (isolatedApifyHome) removeIsolatedApifyHome(isolatedApifyHome);
+	});
+
+	it(
+		'push enables Standby; requests share one STANDBY run, which is wound down SUCCEEDED once idle',
+		async () => {
+			const env = apifyEnv(isolatedApifyHome);
+			const push = JSON.parse(apify(['push', '--json'], { cwd: ACTOR_DIR, env })) as PushResult;
+			expect(push.build.status).toBe('SUCCEEDED');
+
+			const actorId = push.actor.id;
+			apify(
+				[
+					'api',
+					'PUT',
+					`actors/${actorId}`,
+					'--body',
+					JSON.stringify({ actorStandby: { idleTimeoutSecs: 10 } }),
+				],
+				{
+					cwd: ACTOR_DIR,
+					env,
+				},
+			);
+			const actor = JSON.parse(
+				apify(['api', 'GET', `actors/${actorId}`], { cwd: ACTOR_DIR, env }),
+			) as ApiEnvelope<{
+				actorStandby: { isEnabled: boolean; idleTimeoutSecs: number };
+				standbyUrl: string;
+			}>;
+			expect(actor.data.actorStandby).toMatchObject({ isEnabled: true, idleTimeoutSecs: 10 });
+
+			const greetings: Array<{ greeting: string; runId: string }> = [];
+			for (const name of ['Ada', 'Grace', 'Linus']) {
+				const res = await fetch(`${actor.data.standbyUrl}/hello?name=${name}`, {
+					headers: { authorization: `Bearer ${TOKEN}` },
+				});
+				expect(res.status).toBe(200);
+				greetings.push((await res.json()) as { greeting: string; runId: string });
+			}
+			expect(greetings.map((g) => g.greeting)).toEqual(['Hello, Ada!', 'Hello, Grace!', 'Hello, Linus!']);
+			expect(new Set(greetings.map((g) => g.runId)).size).toBe(1);
+			const runId = greetings[0]!.runId;
+
+			const runOf = () =>
+				(
+					JSON.parse(
+						apify(['api', 'GET', `actor-runs/${runId}`], { cwd: ACTOR_DIR, env }),
+					) as ApiEnvelope<RunSummary>
+				).data;
+			expect(runOf()).toMatchObject({
+				status: 'RUNNING',
+				meta: { origin: 'STANDBY' },
+				options: { timeoutSecs: 0 },
+			});
+
+			const finished = await waitFor(
+				() => {
+					const run = runOf();
+					return run.status === 'SUCCEEDED' ? run : undefined;
+				},
+				90_000,
+				'the idle standby run to finish',
+			);
+			const info = JSON.parse(
+				apify(['datasets', 'info', finished.defaultDatasetId, '--json'], { cwd: ACTOR_DIR, env }),
+			) as DatasetInfoResult;
+			expect(info.itemCount).toBe(3);
+			const log = apify(['api', 'GET', `logs/${runId}`], { cwd: ACTOR_DIR, env });
+			expect(log).toContain('Actor Standby server was idle for too long, finishing run.');
+
+			// The next request starts a fresh run.
+			const next = (await (await fetch(`${actor.data.standbyUrl}/?token=${TOKEN}`)).json()) as { runId: string };
+			expect(next.runId).not.toBe(runId);
+		},
+		5 * 60 * 1000,
+	);
+});
diff --git a/test/integration/actors-builds-runs.test.ts b/test/integration/actors-builds-runs.test.ts
index 77bae829..6162e4ec 100644
--- a/test/integration/actors-builds-runs.test.ts
+++ b/test/integration/actors-builds-runs.test.ts
@@ -31,6 +31,9 @@ function availableDriverWithNoImage(): Driver {
 			throw new Error('not used by this stub');
 		},
 		async stopBrowserViewer() {},
+		async containerServerAddress() {
+			return undefined;
+		},
 		async inspectDebugTarget() {
 			throw new Error('not used by this stub');
 		},
diff --git a/test/integration/api-fallback.test.ts b/test/integration/api-fallback.test.ts
index 450cfa38..f7019bfe 100644
--- a/test/integration/api-fallback.test.ts
+++ b/test/integration/api-fallback.test.ts
@@ -1090,6 +1090,9 @@ describe('api-fallback: dev-folder-* and internal-error types never forward', ()
 			throw new Error('not used by this stub');
 		},
 		async stopBrowserViewer() {},
+		async containerServerAddress() {
+			return undefined;
+		},
 		async inspectDebugTarget() {
 			throw new Error('not used by this stub');
 		},
diff --git a/test/integration/browser-view.test.ts b/test/integration/browser-view.test.ts
index f005d1ca..90498c1e 100644
--- a/test/integration/browser-view.test.ts
+++ b/test/integration/browser-view.test.ts
@@ -64,6 +64,9 @@ function viewerCapturingDriver(
 		async stopBrowserViewer(runId) {
 			events.push(`stopBrowserViewer:${runId}`);
 		},
+		async containerServerAddress() {
+			return undefined;
+		},
 		async inspectDebugTarget() {
 			return { env: {} };
 		},
diff --git a/test/integration/cli-log-stream-race.test.ts b/test/integration/cli-log-stream-race.test.ts
index 8c4c3cd6..5ff25939 100644
--- a/test/integration/cli-log-stream-race.test.ts
+++ b/test/integration/cli-log-stream-race.test.ts
@@ -92,6 +92,9 @@ function timedDriver(resolveAfterMs: number): Driver {
 			throw new Error('not used by this stub');
 		},
 		async stopBrowserViewer() {},
+		async containerServerAddress() {
+			return undefined;
+		},
 		async inspectDebugTarget() {
 			throw new Error('not used by this stub');
 		},
@@ -246,6 +249,9 @@ describe('CLI log-stream race: apify-cli outputJobLog must always settle (regres
 						throw new Error('not used by this stub');
 					},
 					async stopBrowserViewer() {},
+					async containerServerAddress() {
+						return undefined;
+					},
 					async inspectDebugTarget() {
 						throw new Error('not used by this stub');
 					},
@@ -382,6 +388,9 @@ describe('CLI log-stream race: apify-cli outputJobLog must always settle (regres
 						throw new Error('not used by this stub');
 					},
 					async stopBrowserViewer() {},
+					async containerServerAddress() {
+						return undefined;
+					},
 					async inspectDebugTarget() {
 						throw new Error('not used by this stub');
 					},
diff --git a/test/integration/debug-mode.test.ts b/test/integration/debug-mode.test.ts
index 1edaa5f0..e764e03f 100644
--- a/test/integration/debug-mode.test.ts
+++ b/test/integration/debug-mode.test.ts
@@ -62,6 +62,9 @@ function debugCapturingDriver(
 			throw new Error('not used by this stub');
 		},
 		async stopBrowserViewer() {},
+		async containerServerAddress() {
+			return undefined;
+		},
 		async inspectDebugTarget() {
 			return target;
 		},
@@ -748,6 +751,9 @@ describe('run-start debug-plan resolution (services/runs.ts, through the real st
 				throw new Error('not used by this stub');
 			},
 			async stopBrowserViewer() {},
+			async containerServerAddress() {
+				return undefined;
+			},
 			async inspectDebugTarget() {
 				return { cmd: ['node', 'dist/main.js'], env: {} };
 			},
diff --git a/test/integration/dev-folder.test.ts b/test/integration/dev-folder.test.ts
index e128a30b..c332ab90 100644
--- a/test/integration/dev-folder.test.ts
+++ b/test/integration/dev-folder.test.ts
@@ -66,6 +66,9 @@ function devFolderDriver(
 			throw new Error('not used by this stub');
 		},
 		async stopBrowserViewer() {},
+		async containerServerAddress() {
+			return undefined;
+		},
 		async inspectDebugTarget() {
 			throw new Error('not used by this stub');
 		},
@@ -803,6 +806,9 @@ function devMountCapturingDriver(): {
 			throw new Error('not used by this stub');
 		},
 		async stopBrowserViewer() {},
+		async containerServerAddress() {
+			return undefined;
+		},
 		async inspectDebugTarget() {
 			throw new Error('not used by this stub');
 		},
diff --git a/test/integration/graceful-abort.test.ts b/test/integration/graceful-abort.test.ts
index f621d621..8906b446 100644
--- a/test/integration/graceful-abort.test.ts
+++ b/test/integration/graceful-abort.test.ts
@@ -104,6 +104,9 @@ function neverStartDriver(): Driver & { abortRunCalls: string[]; abortBuildCalls
 			throw new Error('not used by this stub');
 		},
 		async stopBrowserViewer() {},
+		async containerServerAddress() {
+			return undefined;
+		},
 		async inspectDebugTarget() {
 			throw new Error('not used by this stub');
 		},
diff --git a/test/integration/helpers/test-server.ts b/test/integration/helpers/test-server.ts
index 902201f9..fbf85582 100644
--- a/test/integration/helpers/test-server.ts
+++ b/test/integration/helpers/test-server.ts
@@ -17,6 +17,9 @@ import { resetEventsChannelForTests } from '../../../src/services/events-channel
 import { resetMigrationsForTests } from '../../../src/services/migrations.js';
 import { resetGracefulAbortsForTests } from '../../../src/services/runs.js';
 import { resetChargingForTests } from '../../../src/services/charging.js';
+import { resetStandbyForTests } from '../../../src/services/standby.js';
+import { resetStandbyFinishingForTests } from '../../../src/services/standby-finish.js';
+import { handleStandbyUpgrade } from '../../../src/api/standby-proxy.js';
 import type {
 	BuildContext,
 	BuildOutcome,
@@ -51,6 +54,9 @@ export function unavailableDriver(): Driver {
 			throw new Error('not used by this stub');
 		},
 		async stopBrowserViewer() {},
+		async containerServerAddress() {
+			return undefined;
+		},
 		async inspectDebugTarget() {
 			throw new Error('not used by this stub');
 		},
@@ -85,6 +91,9 @@ export function fixedRunOutcomeDriver(outcome: RunOutcome): Driver {
 			throw new Error('not used by this stub');
 		},
 		async stopBrowserViewer() {},
+		async containerServerAddress() {
+			return undefined;
+		},
 		async inspectDebugTarget() {
 			throw new Error('not used by this stub');
 		},
@@ -123,6 +132,9 @@ export function fixedBuildOutcomeDriver(
 			throw new Error('not used by this stub');
 		},
 		async stopBrowserViewer() {},
+		async containerServerAddress() {
+			return undefined;
+		},
 		async inspectDebugTarget() {
 			throw new Error('not used by this stub');
 		},
@@ -190,6 +202,9 @@ export function deferredRunDriver(): DeferredRunDriver {
 			throw new Error('not used by this stub');
 		},
 		async stopBrowserViewer() {},
+		async containerServerAddress() {
+			return undefined;
+		},
 		async inspectDebugTarget() {
 			throw new Error('not used by this stub');
 		},
@@ -250,6 +265,9 @@ export function deferredBuildDriver(): DeferredBuildDriver {
 			throw new Error('not used by this stub');
 		},
 		async stopBrowserViewer() {},
+		async containerServerAddress() {
+			return undefined;
+		},
 		async inspectDebugTarget() {
 			throw new Error('not used by this stub');
 		},
@@ -337,6 +355,9 @@ export function multiRunDriver(): MultiRunDriver {
 			throw new Error('not used by this stub');
 		},
 		async stopBrowserViewer() {},
+		async containerServerAddress() {
+			return undefined;
+		},
 		async inspectDebugTarget() {
 			throw new Error('not used by this stub');
 		},
@@ -456,7 +477,9 @@ export async function startTestServer(
 	const wsBaseUrl = `ws://127.0.0.1:${port}`;
 	// Same server, same upgrade path as production (`index.ts`) - a real `ws` client against this handle
 	// exercises the actual `api/events-ws.ts` code, not a stand-in.
-	const eventsWebSocketServer = attachEventsWebSocket(server);
+	const eventsWebSocketServer = attachEventsWebSocket(server, (req, socket, head) =>
+		handleStandbyUpgrade(driver, req, socket, head),
+	);
 
 	// maxRetries: 0 - real apify-client retries 5xx (so a deliberate 501 from the request-deletion
 	// endpoints would otherwise burn ~8 exponential-backoff retries per test); production behaviour is
@@ -485,6 +508,8 @@ export async function startTestServer(
 			resetMigrationsForTests();
 			resetGracefulAbortsForTests();
 			resetChargingForTests();
+			resetStandbyForTests();
+			resetStandbyFinishingForTests();
 			await shutdownStorage();
 			resetStorageForTests();
 			resetRegistriesForTests();
diff --git a/test/integration/identity-resolution.test.ts b/test/integration/identity-resolution.test.ts
index d9b5799d..d3bb5a35 100644
--- a/test/integration/identity-resolution.test.ts
+++ b/test/integration/identity-resolution.test.ts
@@ -209,6 +209,9 @@ function envCapturingDriver(): { driver: Driver; getCapturedEnv: () => Record<st
 			throw new Error('not used by this stub');
 		},
 		async stopBrowserViewer() {},
+		async containerServerAddress() {
+			return undefined;
+		},
 		async inspectDebugTarget() {
 			throw new Error('not used by this stub');
 		},
diff --git a/test/integration/job-lifecycle.test.ts b/test/integration/job-lifecycle.test.ts
index e3eab033..b3089d16 100644
--- a/test/integration/job-lifecycle.test.ts
+++ b/test/integration/job-lifecycle.test.ts
@@ -133,6 +133,9 @@ function neverStartDriver(): Driver & { abortRunCalls: string[]; abortBuildCalls
 			throw new Error('not used by this stub');
 		},
 		async stopBrowserViewer() {},
+		async containerServerAddress() {
+			return undefined;
+		},
 		async inspectDebugTarget() {
 			throw new Error('not used by this stub');
 		},
@@ -815,6 +818,9 @@ describe('reconcileOrphanedJobs (startup reconciliation)', () => {
 				throw new Error('not used by this stub');
 			},
 			async stopBrowserViewer() {},
+			async containerServerAddress() {
+				return undefined;
+			},
 			async inspectDebugTarget() {
 				throw new Error('not used by this stub');
 			},
diff --git a/test/integration/run-env-vars.test.ts b/test/integration/run-env-vars.test.ts
index a67041ee..23ae27ea 100644
--- a/test/integration/run-env-vars.test.ts
+++ b/test/integration/run-env-vars.test.ts
@@ -37,6 +37,9 @@ function envCapturingDriver(): { driver: Driver; getCapturedEnv: () => Record<st
 			throw new Error('not used by this stub');
 		},
 		async stopBrowserViewer() {},
+		async containerServerAddress() {
+			return undefined;
+		},
 		async inspectDebugTarget() {
 			throw new Error('not used by this stub');
 		},
diff --git a/test/integration/standby.test.ts b/test/integration/standby.test.ts
new file mode 100644
index 00000000..6ba535e1
--- /dev/null
+++ b/test/integration/standby.test.ts
@@ -0,0 +1,469 @@
+/**
+ * Actor Standby (`actor-driver.md`, `api.md`): the `actorStandby` Actor field, and the standby router
+ * forwarding requests to standby runs it starts, scales and winds down. The driver stub runs each
+ * "container" as a real local HTTP server, so every request crosses a real proxy hop.
+ */
+import http, { type IncomingMessage, type Server } from 'node:http';
+import type { AddressInfo } from 'node:net';
+import { afterEach, describe, expect, it } from 'vitest';
+import { WebSocket, WebSocketServer } from 'ws';
+
+import { startTestServer, type TestServerHandle } from './helpers/test-server.js';
+import { getRegistries } from '../../src/storage/registries.js';
+import { generateId } from '../../src/storage/ids.js';
+import { recordTaggedBuild, updateActor } from '../../src/services/actors.js';
+import { configureStandbyForTests, READINESS_PROBE_HEADER } from '../../src/services/standby.js';
+import { subscribeEvents } from '../../src/services/events-channel.js';
+import { getFullLog } from '../../src/services/logs.js';
+import { createConsoleServer } from '../../src/console/server.js';
+import type { ContainerServerAddress, Driver, RunContext, RunOutcome } from '../../src/driver/types.js';
+import type { ActorRecord, BuildRecord } from '../../src/storage/entities.js';
+
+interface FakeContainer {
+	ctx: RunContext;
+	server?: Server;
+	address?: ContainerServerAddress;
+	probes: number;
+	finish(outcome: RunOutcome): void;
+}
+
+interface ServerDriver extends Driver {
+	containers: FakeContainer[];
+	abortRunCalls: Array<{ runId: string; graceSecs?: number }>;
+	/** Each started container listens only after this many ms; `Infinity` never listens. */
+	listenDelayMs: number;
+	/** Each request waits this long before being answered. */
+	responseDelayMs: number;
+}
+
+/** Every started "container" echoes each request back as JSON, and answers websocket upgrades. */
+function serverDriver(): ServerDriver {
+	const containers: FakeContainer[] = [];
+	const abortRunCalls: Array<{ runId: string; graceSecs?: number }> = [];
+	const driver: ServerDriver = {
+		available: true,
+		containers,
+		abortRunCalls,
+		listenDelayMs: 0,
+		responseDelayMs: 0,
+		async init() {},
+		async startBuild() {
+			throw new Error('not used by this stub');
+		},
+		async abortBuild() {},
+		startRun(ctx) {
+			return new Promise<RunOutcome>((resolve) => {
+				const container: FakeContainer = {
+					ctx,
+					probes: 0,
+					finish: (outcome) => {
+						container.server?.closeAllConnections();
+						container.server?.close();
+						container.address = undefined;
+						resolve(outcome);
+					},
+				};
+				containers.push(container);
+				const listen = () => {
+					const server = http.createServer((req, res) => {
+						if (req.headers[READINESS_PROBE_HEADER]) {
+							container.probes++;
+							res.end('ready');
+							return;
+						}
+						const chunks: Buffer[] = [];
+						req.on('data', (chunk: Buffer) => chunks.push(chunk));
+						req.on('end', () => {
+							setTimeout(() => {
+								res.setHeader('content-type', 'application/json');
+								res.setHeader('x-from-actor', 'yes');
+								res.end(
+									JSON.stringify({
+										runId: ctx.runId,
+										method: req.method,
+										url: req.url,
+										headers: req.headers,
+										body: Buffer.concat(chunks).toString('utf8'),
+									}),
+								);
+							}, driver.responseDelayMs);
+						});
+					});
+					const wss = new WebSocketServer({ server });
+					wss.on('connection', (ws, req: IncomingMessage) => {
+						ws.on('message', (data) => ws.send(`${req.url} ${String(data)}`));
+					});
+					server.listen(0, '127.0.0.1', () => {
+						container.server = server;
+						container.address = { host: '127.0.0.1', port: (server.address() as AddressInfo).port };
+					});
+				};
+				if (Number.isFinite(driver.listenDelayMs)) setTimeout(listen, driver.listenDelayMs);
+			});
+		},
+		async abortRun(runId, options) {
+			abortRunCalls.push({ runId, graceSecs: options?.graceSecs });
+			containers.find((c) => c.ctx.runId === runId && c.address)?.finish({ exitCode: 137, timedOut: false });
+		},
+		async reconcileOrphans() {},
+		async probeDevFolder() {
+			throw new Error('not used by this stub');
+		},
+		async ensureProbeImage() {
+			throw new Error('not used by this stub');
+		},
+		async startBrowserViewer() {
+			throw new Error('not used by this stub');
+		},
+		async stopBrowserViewer() {},
+		async inspectDebugTarget() {
+			throw new Error('not used by this stub');
+		},
+		async containerServerAddress(runId) {
+			return containers.find((c) => c.ctx.runId === runId && c.address)?.address;
+		},
+	};
+	return driver;
+}
+
+async function seedBuild(actor: ActorRecord, buildNumber = '0.0.1'): Promise<BuildRecord> {
+	const build: BuildRecord = {
+		id: generateId(),
+		userId: actor.userId,
+		actorId: actor.id,
+		versionNumber: '0.0',
+		buildNumber,
+		tag: 'latest',
+		status: 'SUCCEEDED',
+		startedAt: new Date().toISOString(),
+		finishedAt: new Date().toISOString(),
+		imageId: 'fake-image',
+	};
+	await getRegistries().builds.set(build.id, build);
+	await updateActor(actor.id, (current) => recordTaggedBuild(current, 'latest', build.id, build.buildNumber));
+	return build;
+}
+
+async function waitUntil<T>(probe: () => Promise<T | undefined> | T | undefined, timeoutMs = 10_000): Promise<T> {
+	const deadline = Date.now() + timeoutMs;
+	for (;;) {
+		const value = await probe();
+		if (value) return value;
+		if (Date.now() > deadline) throw new Error('timed out waiting');
+		await new Promise((resolve) => setTimeout(resolve, 50));
+	}
+}
+
+describe('actorStandby on the Actor object', () => {
+	let server: TestServerHandle;
+	afterEach(async () => server?.close());
+
+	it('is absent with a null standbyUrl until set, and fills the platform defaults on create', async () => {
+		server = await startTestServer();
+		const plain = await server.client.actors().create({ name: 'plain' });
+		expect(plain.actorStandby).toBeUndefined();
+		expect((plain as unknown as { standbyUrl: unknown }).standbyUrl).toBeNull();
+
+		const created = await server.client.actors().create({ name: 'My-Server', actorStandby: { isEnabled: true } });
+		expect(created.actorStandby).toEqual({
+			isEnabled: true,
+			disableStandbyFieldsOverride: false,
+			tenancy: 'SINGLE_TENANT',
+			desiredRequestsPerActorRun: 3,
+			maxRequestsPerActorRun: 4,
+			idleTimeoutSecs: 300,
+			build: 'latest',
+			memoryMbytes: 1024,
+			shouldPassActorInput: false,
+		});
+		const me = await server.client.user('me').get();
+		expect((created as unknown as { standbyUrl: string }).standbyUrl).toBe(
+			`http://localhost:3333/actor-runtime/standby/${me!.username}--my-server`,
+		);
+	});
+
+	it('merges a partial update over the stored settings, and rejects invalid ones unchanged', async () => {
+		server = await startTestServer();
+		const created = await server.client.actors().create({ name: 'a', actorStandby: { isEnabled: true } });
+		const updated = await server.client
+			.actor(created.id)
+			.update({ actorStandby: { idleTimeoutSecs: 60 } } as never);
+		expect(updated.actorStandby).toMatchObject({ isEnabled: true, idleTimeoutSecs: 60, maxRequestsPerActorRun: 4 });
+
+		for (const actorStandby of [
+			{ desiredRequestsPerActorRun: 10 },
+			{ idleTimeoutSecs: 1 },
+			{ tenancy: 'MULTI_TENANT' },
+			{ isEnabled: 'yes' },
+			{ unknown: true },
+		]) {
+			const res = await fetch(`${server.baseUrl}/v2/actors/${created.id}?token=${server.token}`, {
+				method: 'PUT',
+				headers: { 'content-type': 'application/json' },
+				body: JSON.stringify({ actorStandby }),
+			});
+			expect(res.status).toBe(400);
+			expect(((await res.json()) as { error: { type: string } }).error.type).toBe('invalid-request');
+		}
+		expect((await server.client.actor(created.id).get())!.actorStandby!.idleTimeoutSecs).toBe(60);
+	});
+
+	it('is enabled by a pushed version whose .actor/actor.json declares usesStandbyMode', async () => {
+		server = await startTestServer();
+		const created = await server.client.actors().create({ name: 'b' });
+		await server.client
+			.actor(created.id)
+			.versions()
+			.create({
+				versionNumber: '0.0',
+				sourceType: 'SOURCE_FILES',
+				buildTag: 'latest',
+				sourceFiles: [
+					{ name: '.actor/actor.json', format: 'TEXT', content: '{ usesStandbyMode: true, name: "b" }' },
+				],
+			} as never);
+		expect((await server.client.actor(created.id).get())!.actorStandby?.isEnabled).toBe(true);
+	});
+});
+
+describe('standby router', () => {
+	let server: TestServerHandle;
+	let driver: ServerDriver;
+	afterEach(async () => {
+		for (const container of driver?.containers ?? []) container.finish({ exitCode: 0, timedOut: false });
+		// Every run must be finalized before the storage it writes to is torn down.
+		await waitUntil(async () =>
+			(await getRegistries().runs.list()).every((run) => ['SUCCEEDED', 'FAILED', 'ABORTED'].includes(run.status)),
+		);
+		await server?.close();
+	});
+
+	async function standbyActor(standby: Record<string, unknown> = {}): Promise<{ actor: ActorRecord; url: string }> {
+		const created = await server.client
+			.actors()
+			.create({ name: 'standby-actor', actorStandby: { isEnabled: true, ...standby } } as never);
+		const actor = (await getRegistries().actors.get(created.id))!;
+		await seedBuild(actor);
+		return {
+			actor,
+			url: (created as unknown as { standbyUrl: string }).standbyUrl.replace(
+				'http://localhost:3333',
+				server.baseUrl,
+			),
+		};
+	}
+
+	it('starts a STANDBY run and forwards method, path, query, headers and body to its server', async () => {
+		driver = serverDriver();
+		server = await startTestServer(driver);
+		const { actor, url } = await standbyActor({ memoryMbytes: 2048 });
+
+		const res = await fetch(`${url}/search/items?q=1`, {
+			method: 'POST',
+			headers: { authorization: `Bearer ${server.token}`, 'content-type': 'text/plain', 'x-custom': 'c' },
+			body: 'hello',
+		});
+		expect(res.status).toBe(200);
+		expect(res.headers.get('x-from-actor')).toBe('yes');
+		const echoed = (await res.json()) as {
+			runId: string;
+			method: string;
+			url: string;
+			headers: Record<string, string>;
+			body: string;
+		};
+		expect(echoed).toMatchObject({ method: 'POST', url: '/search/items?q=1', body: 'hello' });
+		expect(echoed.headers['x-custom']).toBe('c');
+		expect(echoed.headers.authorization).toBe(`Bearer ${server.token}`);
+
+		const run = await server.client.run(echoed.runId).get();
+		expect(run).toMatchObject({ actId: actor.id, status: 'RUNNING', meta: { origin: 'STANDBY' } });
+		expect(run!.options).toMatchObject({ timeoutSecs: 0, memoryMbytes: 2048, build: 'latest' });
+		const ctx = driver.containers[0]!.ctx;
+		expect(ctx.containerServerPort).toBe(4321);
+		expect(ctx.timeoutSecs).toBe(0);
+		expect(ctx.env).toMatchObject({ APIFY_META_ORIGIN: 'STANDBY', ACTOR_STANDBY_PORT: '4321' });
+		expect(ctx.env.ACTOR_STANDBY_URL).toMatch(/\/actor-runtime\/standby\/.+--standby-actor$/);
+		expect(driver.containers[0]!.probes).toBeGreaterThan(0);
+
+		// The next request lands on the same run, without starting another.
+		const again = (await (await fetch(`${url}?token=${server.token}`)).json()) as { runId: string; url: string };
+		expect(again.runId).toBe(echoed.runId);
+		expect(again.url).toBe(`/?token=${server.token}`);
+		expect(driver.containers).toHaveLength(1);
+	});
+
+	it('also answers on the <label>.localhost host and by Actor id', async () => {
+		driver = serverDriver();
+		server = await startTestServer(driver);
+		const { actor, url } = await standbyActor();
+		const label = url.split('/').pop()!;
+
+		const byHost = await new Promise<{ status: number; body: string }>((resolve, reject) => {
+			const port = new URL(server.baseUrl).port;
+			http.get(
+				{
+					host: '127.0.0.1',
+					port,
+					path: `/deep/path?token=${server.token}`,
+					headers: { host: `${label}.localhost:${port}` },
+				},
+				(res) => {
+					let body = '';
+					res.on('data', (chunk) => (body += chunk));
+					res.on('end', () => resolve({ status: res.statusCode!, body }));
+				},
+			).on('error', reject);
+		});
+		expect(byHost.status).toBe(200);
+		expect(JSON.parse(byHost.body).url).toBe(`/deep/path?token=${server.token}`);
+
+		const byId = await fetch(`${server.baseUrl}/actor-runtime/standby/${actor.id}/x?token=${server.token}`);
+		expect(((await byId.json()) as { url: string }).url).toBe(`/x?token=${server.token}`);
+	});
+
+	it('rejects a missing token, an unknown address, and an Actor without standby', async () => {
+		driver = serverDriver();
+		server = await startTestServer(driver);
+		const { url } = await standbyActor();
+		const plain = await server.client.actors().create({ name: 'plain' });
+
+		const cases: Array<[string, number, string]> = [
+			[url, 401, 'user-not-authenticated'],
+			[`${server.baseUrl}/actor-runtime/standby/nobody--nothing?token=${server.token}`, 404, 'record-not-found'],
+			[`${url}?token=someone-else`, 404, 'record-not-found'],
+			[`${server.baseUrl}/actor-runtime/standby/${plain.id}?token=${server.token}`, 400, 'standby-not-enabled'],
+		];
+		for (const [target, status, type] of cases) {
+			const res = await fetch(target);
+			expect(res.status).toBe(status);
+			expect(((await res.json()) as { error: { type: string } }).error.type).toBe(type);
+		}
+		expect(driver.containers).toHaveLength(0);
+	});
+
+	it('starts another run once concurrent requests exceed maxRequestsPerActorRun', async () => {
+		driver = serverDriver();
+		driver.responseDelayMs = 500;
+		server = await startTestServer(driver);
+		const { url } = await standbyActor({ desiredRequestsPerActorRun: 1, maxRequestsPerActorRun: 1 });
+
+		const responses = await Promise.all(
+			[1, 2, 3].map(
+				async () => ((await (await fetch(`${url}?token=${server.token}`)).json()) as { runId: string }).runId,
+			),
+		);
+		expect(new Set(responses).size).toBe(3);
+	});
+
+	it('starts a run ahead of demand once every run is above desiredRequestsPerActorRun', async () => {
+		driver = serverDriver();
+		driver.responseDelayMs = 800;
+		server = await startTestServer(driver);
+		const { url } = await standbyActor({ desiredRequestsPerActorRun: 1, maxRequestsPerActorRun: 4 });
+
+		const first = fetch(`${url}?token=${server.token}`);
+		await waitUntil(() => driver.containers.length === 1);
+		const second = fetch(`${url}?token=${server.token}`);
+		const ids = await Promise.all(
+			[first, second].map(async (r) => ((await (await r).json()) as { runId: string }).runId),
+		);
+		// Both are served by the first run (below max), but a second run was already started for what comes next.
+		expect(ids[0]).toBe(ids[1]);
+		await waitUntil(() => driver.containers.length === 2);
+	});
+
+	it('winds an idle run down gracefully and reports it SUCCEEDED; the next request starts a fresh run', async () => {
+		driver = serverDriver();
+		server = await startTestServer(driver);
+		configureStandbyForTests({ finishWarningMs: 100 });
+		const { url } = await standbyActor({ idleTimeoutSecs: 5 });
+
+		const first = (await (await fetch(`${url}?token=${server.token}`)).json()) as { runId: string };
+		const frames: string[] = [];
+		subscribeEvents(first.runId, (frame) => frames.push(frame));
+
+		const finished = await waitUntil(async () => {
+			const run = await server.client.run(first.runId).get();
+			return run?.status === 'SUCCEEDED' ? run : undefined;
+		}, 15_000);
+		expect(finished.exitCode).toBe(137);
+		expect(frames.map((frame) => JSON.parse(frame).name)).toEqual(['aborting', 'persistState']);
+		expect(driver.abortRunCalls).toEqual([{ runId: first.runId, graceSecs: 15 }]);
+		expect(await getFullLog(first.runId)).toContain('Actor Standby server was idle for too long, finishing run.');
+
+		const next = (await (await fetch(`${url}?token=${server.token}`)).json()) as { runId: string };
+		expect(next.runId).not.toBe(first.runId);
+	}, 20_000);
+
+	it('answers 503 when the run ends before its server is ready, and 504 when it never listens', async () => {
+		driver = serverDriver();
+		driver.listenDelayMs = Infinity;
+		server = await startTestServer(driver);
+		configureStandbyForTests({ readyTimeoutMs: 1_500 });
+		const { url } = await standbyActor();
+
+		const notReady = await fetch(`${url}?token=${server.token}`);
+		expect(notReady.status).toBe(504);
+		expect(((await notReady.json()) as { error: { type: string } }).error.type).toBe('standby-run-not-ready');
+
+		const pending = fetch(`${url}?token=${server.token}`);
+		await new Promise((resolve) => setTimeout(resolve, 300));
+		driver.containers[0]!.finish({ exitCode: 1, timedOut: false });
+		const crashed = await pending;
+		expect(crashed.status).toBe(503);
+		const body = (await crashed.json()) as { error: { type: string; message: string } };
+		expect(body.error.type).toBe('standby-run-finished');
+		expect(body.error.message).toContain('FAILED');
+	});
+
+	it('retires runs of an older build once a newer one is pushed', async () => {
+		driver = serverDriver();
+		server = await startTestServer(driver);
+		configureStandbyForTests({ finishWarningMs: 50 });
+		const { actor, url } = await standbyActor();
+		const first = (await (await fetch(`${url}?token=${server.token}`)).json()) as { runId: string };
+
+		await seedBuild(actor, '0.0.2');
+		const second = (await (await fetch(`${url}?token=${server.token}`)).json()) as { runId: string };
+		expect(second.runId).not.toBe(first.runId);
+		await waitUntil(async () => (await server.client.run(first.runId).get())?.status === 'SUCCEEDED');
+	});
+
+	it("shows the Actor's standby settings and live runs on its console page", async () => {
+		driver = serverDriver();
+		server = await startTestServer(driver);
+		const { actor, url } = await standbyActor();
+		const served = (await (await fetch(`${url}?token=${server.token}`)).json()) as { runId: string };
+
+		const consoleServer = await new Promise<Server>((resolve) => {
+			const s = createConsoleServer({ driver }).listen(0, () => resolve(s));
+		});
+		try {
+			const { port } = consoleServer.address() as AddressInfo;
+			const html = await (await fetch(`http://127.0.0.1:${port}/actors/${actor.id}`)).text();
+			expect(html).toContain('Actor Standby');
+			expect(html).toContain('/actor-runtime/standby/');
+			expect(html).toContain(`/runs/${served.runId}`);
+			const runHtml = await (await fetch(`http://127.0.0.1:${port}/runs/${served.runId}`)).text();
+			expect(runHtml).toContain('STANDBY');
+		} finally {
+			await new Promise((resolve) => consoleServer.close(resolve));
+		}
+	});
+
+	it('proxies websocket upgrades to the run', async () => {
+		driver = serverDriver();
+		server = await startTestServer(driver);
+		const { url } = await standbyActor();
+
+		const ws = new WebSocket(`${url.replace('http', 'ws')}/socket?token=${server.token}`);
+		const reply = await new Promise<string>((resolve, reject) => {
+			ws.on('open', () => ws.send('ping'));
+			ws.on('message', (data) => resolve(String(data)));
+			ws.on('error', reject);
+		});
+		ws.close();
+		expect(reply).toBe(`/socket?token=${server.token} ping`);
+	});
+});
diff --git a/test/unit/docker-driver-standby.test.ts b/test/unit/docker-driver-standby.test.ts
new file mode 100644
index 00000000..52a5c7e3
--- /dev/null
+++ b/test/unit/docker-driver-standby.test.ts
@@ -0,0 +1,131 @@
+/** `DockerDriver.startRun`'s standby surface: how a standby container's server is made reachable. */
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { DockerDriver } from '../../src/driver/docker-driver.js';
+import { stubDockerForRun } from './helpers/docker-stubs.js';
+
+function stubWithInspect(info: Record<string, unknown>) {
+	const stub = stubDockerForRun();
+	Object.assign(stub.container, { inspect: vi.fn(async () => info) });
+	return stub;
+}
+
+async function settle(): Promise<void> {
+	for (let i = 0; i < 5; i++) await new Promise((resolve) => setImmediate(resolve));
+}
+
+describe('DockerDriver.startRun - containerServerPort', () => {
+	const ORIGINAL_HOSTNAME = process.env.HOSTNAME;
+	let dir: string;
+
+	beforeEach(() => {
+		dir = mkdtempSync(join(tmpdir(), 'actor-runtime-standby-driver-'));
+	});
+
+	afterEach(() => {
+		rmSync(dir, { recursive: true, force: true });
+		if (ORIGINAL_HOSTNAME === undefined) delete process.env.HOSTNAME;
+		else process.env.HOSTNAME = ORIGINAL_HOSTNAME;
+	});
+
+	it('publishes nothing on apify-local and reaches the container at its network address', async () => {
+		const stub = stubWithInspect({ NetworkSettings: { Networks: { 'apify-local': { IPAddress: '10.1.2.3' } } } });
+		const driver = new DockerDriver(stub.docker);
+		driver.available = true;
+		(driver as unknown as { onActorNetwork: boolean }).onActorNetwork = true;
+
+		const outcome = driver.startRun(
+			{ runId: 'r1', imageId: 'img', env: {}, memoryMbytes: 128, timeoutSecs: 0, containerServerPort: 4321 },
+			() => {},
+		);
+		await settle();
+
+		const [options] = stub.createContainer.mock.calls[0]!;
+		expect(options.ExposedPorts).toBeUndefined();
+		expect(options.HostConfig?.PortBindings).toBeUndefined();
+		expect(await driver.containerServerAddress('r1')).toEqual({ host: '10.1.2.3', port: 4321 });
+
+		stub.triggerContainerExit(0);
+		stub.endLogStream();
+		await outcome;
+		expect(await driver.containerServerAddress('r1')).toBeUndefined();
+	});
+
+	it('from a process on the host itself, publishes the port on loopback at an engine-picked port', async () => {
+		delete process.env.HOSTNAME;
+		const stub = stubWithInspect({
+			NetworkSettings: { Ports: { '4321/tcp': [{ HostIp: '127.0.0.1', HostPort: '49153' }] } },
+		});
+		const driver = new DockerDriver(stub.docker);
+		driver.available = true;
+
+		const outcome = driver.startRun(
+			{ runId: 'r2', imageId: 'img', env: {}, memoryMbytes: 128, timeoutSecs: 0, containerServerPort: 4321 },
+			() => {},
+		);
+		await settle();
+
+		const [options] = stub.createContainer.mock.calls[0]!;
+		expect(options.ExposedPorts).toEqual({ '4321/tcp': {} });
+		expect(options.HostConfig?.PortBindings).toEqual({ '4321/tcp': [{ HostIp: '127.0.0.1', HostPort: '' }] });
+		expect(await driver.containerServerAddress('r2')).toEqual({ host: '127.0.0.1', port: 49153 });
+
+		stub.triggerContainerExit(0);
+		stub.endLogStream();
+		await outcome;
+	});
+
+	it("from a container off apify-local, publishes on the host and reaches it at the engine's host address", async () => {
+		process.env.HOSTNAME = 'self';
+		const hostsFile = join(dir, 'hosts');
+		writeFileSync(hostsFile, '127.0.0.1 localhost\n169.254.1.2 host.containers.internal\n');
+		const stub = stubWithInspect({
+			NetworkSettings: { Ports: { '4321/tcp': [{ HostIp: '0.0.0.0', HostPort: '40000' }] } },
+		});
+		const driver = new DockerDriver(stub.docker, { hostsFile });
+		driver.available = true;
+
+		const outcome = driver.startRun(
+			{ runId: 'r3', imageId: 'img', env: {}, memoryMbytes: 128, timeoutSecs: 0, containerServerPort: 4321 },
+			() => {},
+		);
+		await settle();
+
+		const [options] = stub.createContainer.mock.calls[0]!;
+		expect(options.HostConfig?.PortBindings).toEqual({ '4321/tcp': [{ HostIp: '', HostPort: '' }] });
+		// The hosts file is read from disk, which outlasts a few event-loop turns.
+		await vi.waitFor(async () =>
+			expect(await driver.containerServerAddress('r3')).toEqual({ host: '169.254.1.2', port: 40000 }),
+		);
+
+		stub.triggerContainerExit(0);
+		stub.endLogStream();
+		await outcome;
+	});
+
+	it('arms no timeout for a run with timeoutSecs 0', async () => {
+		vi.useFakeTimers({ toFake: ['setTimeout'] });
+		try {
+			const stub = stubWithInspect({});
+			const driver = new DockerDriver(stub.docker);
+			driver.available = true;
+			const outcome = driver.startRun(
+				{ runId: 'r4', imageId: 'img', env: {}, memoryMbytes: 128, timeoutSecs: 0 },
+				() => {},
+			);
+			await settle();
+			await vi.advanceTimersByTimeAsync(10 * 24 * 3600 * 1000);
+			expect(stub.container.stop).not.toHaveBeenCalled();
+			stub.triggerContainerExit(0);
+			stub.endLogStream();
+			await vi.advanceTimersByTimeAsync(10);
+			expect((await outcome).timedOut).toBe(false);
+		} finally {
+			vi.useRealTimers();
+		}
+	});
+});
diff --git a/test/unit/standby-config.test.ts b/test/unit/standby-config.test.ts
new file mode 100644
index 00000000..c93b2a59
--- /dev/null
+++ b/test/unit/standby-config.test.ts
@@ -0,0 +1,95 @@
+import { describe, expect, it } from 'vitest';
+import type { IncomingMessage } from 'node:http';
+
+import {
+	STANDBY_DEFAULTS,
+	declaresStandbyMode,
+	labelFromHost,
+	mergeStandbyUpdate,
+	standbyLabel,
+} from '../../src/services/standby-config.js';
+import { standbyTargetOf } from '../../src/api/standby-proxy.js';
+import type { ActorRecord } from '../../src/storage/entities.js';
+
+describe('mergeStandbyUpdate', () => {
+	it('fills the platform defaults under a partial body, and keeps stored values under a later one', () => {
+		const created = mergeStandbyUpdate({ isEnabled: true }, undefined);
+		expect(created).toEqual({ kind: 'ok', actorStandby: { ...STANDBY_DEFAULTS, isEnabled: true } });
+		const updated = mergeStandbyUpdate(
+			{ memoryMbytes: 256, build: '0.1' },
+			created.kind === 'ok' ? created.actorStandby : undefined,
+		);
+		expect(updated).toMatchObject({
+			kind: 'ok',
+			actorStandby: { isEnabled: true, memoryMbytes: 256, build: '0.1' },
+		});
+	});
+
+	it('accepts desired == max and drops the admin-only fields', () => {
+		const result = mergeStandbyUpdate(
+			{ desiredRequestsPerActorRun: 4, maxRequestsPerActorRun: 4, isTokenlessEnabled: true },
+			undefined,
+		);
+		expect(result.kind).toBe('ok');
+		expect(result.kind === 'ok' && 'isTokenlessEnabled' in result.actorStandby).toBe(false);
+	});
+
+	it.each([
+		[[], '"actorStandby" must be an object'],
+		[{ maxRequestsPerActorRun: 2 }, 'Max requests must be greater than or equal to desired requests.'],
+		[{ desiredRequestsPerActorRun: 0 }, 'actorStandby.desiredRequestsPerActorRun must be >= 1'],
+		[{ idleTimeoutSecs: 4 }, 'actorStandby.idleTimeoutSecs must be >= 5'],
+		[{ idleTimeoutSecs: 5.5 }, 'actorStandby.idleTimeoutSecs must be an integer'],
+		[{ build: '' }, 'actorStandby.build must be a build tag or build number'],
+		[{ tenancy: 'MULTI_TENANT' }, 'Only SINGLE_TENANT Actor Standby is supported by this runtime'],
+		[{ foo: 1 }, 'Unknown field actorStandby.foo'],
+	])('rejects %j', (body, message) => {
+		expect(mergeStandbyUpdate(body, undefined)).toEqual({ kind: 'invalid', message });
+	});
+});
+
+describe('declaresStandbyMode', () => {
+	const file = (content: string) => [{ name: '.actor/actor.json', format: 'TEXT' as const, content }];
+	it('reads usesStandbyMode from .actor/actor.json, JSON5 included', () => {
+		expect(declaresStandbyMode(file('{ usesStandbyMode: true }'))).toBe(true);
+		expect(declaresStandbyMode(file('{ "usesStandbyMode": false }'))).toBe(false);
+		expect(declaresStandbyMode(file('{ not json'))).toBe(false);
+		expect(declaresStandbyMode([])).toBe(false);
+	});
+});
+
+describe('standby addressing', () => {
+	const actor = { name: 'My-Actor' } as ActorRecord;
+
+	it("builds the platform's <username>--<name> label, DNS-safe", () => {
+		expect(standbyLabel(actor, 'john.doe')).toBe('john-doe--my-actor');
+	});
+
+	it('reads a label only from a <label>.localhost host', () => {
+		expect(labelFromHost('john-doe--my-actor.localhost:3333')).toBe('john-doe--my-actor');
+		expect(labelFromHost('localhost:3333')).toBeUndefined();
+		expect(labelFromHost('apify-api:3333')).toBeUndefined();
+		expect(labelFromHost(undefined)).toBeUndefined();
+	});
+
+	const req = (url: string, host = 'localhost:3333') => ({ url, headers: { host } }) as unknown as IncomingMessage;
+
+	it.each([
+		['/actor-runtime/standby/a--b', { label: 'a--b', forwardPath: '/' }],
+		['/actor-runtime/standby/a--b/', { label: 'a--b', forwardPath: '/' }],
+		['/actor-runtime/standby/A--B/mcp?x=1', { label: 'a--b', forwardPath: '/mcp?x=1' }],
+		['/actor-runtime/standby/a--b?token=t', { label: 'a--b', forwardPath: '/?token=t' }],
+		['/actor-runtime/standby/', undefined],
+		['/actor-runtime/standbyx/a', undefined],
+		['/v2/actors', undefined],
+	])('maps %s', (url, expected) => {
+		expect(standbyTargetOf(req(url))).toEqual(expected);
+	});
+
+	it('forwards the whole path of a host-addressed request', () => {
+		expect(standbyTargetOf(req('/v2/anything?q=1', 'a--b.localhost:3333'))).toEqual({
+			label: 'a--b',
+			forwardPath: '/v2/anything?q=1',
+		});
+	});
+});

From 2a22c3fbf3e712ebe83753e20e6e5af9c81bd85f Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Thu, 24 Sep 2026 06:16:28 +0000
Subject: [PATCH 2/5] feat: Add TypeScript and Python Actor Standby samples

Replace the minimal sample_actor_standby with sample_actor_standby_ts and
sample_actor_standby_py: the same Actor server in both languages, with JSON
endpoints, a request body echo, a Server-Sent Events stream, a websocket,
request stats kept across runs in a named key-value store, and graceful
shutdown on the idle `aborting` event. The standby e2e test now drives both.

Standby runs also get ACTOR_WEB_SERVER_PORT, as on the platform: the Python
SDK reads the server port from it rather than ACTOR_STANDBY_PORT.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01W6t3FkairFVeCRTVXrJfTw
---
 README.md                                 |    7 +-
 eslint.config.js                          |    1 +
 requirements/actor-driver.md              |    5 +-
 requirements/test.md                      |   12 +-
 requirements/unsupported.md               |    2 +-
 sample_actor_standby/.actor/actor.json    |   11 -
 sample_actor_standby/.dockerignore        |    1 -
 sample_actor_standby/Dockerfile           |    6 -
 sample_actor_standby/README.md            |   14 -
 sample_actor_standby/package.json         |   13 -
 sample_actor_standby/src/main.js          |   37 -
 sample_actor_standby_py/.actor/actor.json |   11 +
 sample_actor_standby_py/.dockerignore     |    4 +
 sample_actor_standby_py/Dockerfile        |    8 +
 sample_actor_standby_py/README.md         |   26 +
 sample_actor_standby_py/requirements.txt  |    2 +
 sample_actor_standby_py/src/__init__.py   |    0
 sample_actor_standby_py/src/__main__.py   |    6 +
 sample_actor_standby_py/src/main.py       |  153 ++
 sample_actor_standby_ts/.actor/actor.json |   11 +
 sample_actor_standby_ts/.dockerignore     |   18 +
 sample_actor_standby_ts/Dockerfile        |   20 +
 sample_actor_standby_ts/README.md         |   26 +
 sample_actor_standby_ts/package-lock.json | 2290 +++++++++++++++++++++
 sample_actor_standby_ts/package.json      |   24 +
 sample_actor_standby_ts/src/main.ts       |  139 ++
 sample_actor_standby_ts/tsconfig.json     |   15 +
 skills/actor-runtime/SKILL.md             |    5 +-
 src/services/runs.ts                      |    5 +-
 test/e2e/standby.test.ts                  |  182 +-
 test/integration/standby.test.ts          |    6 +-
 31 files changed, 2887 insertions(+), 173 deletions(-)
 delete mode 100644 sample_actor_standby/.actor/actor.json
 delete mode 100644 sample_actor_standby/.dockerignore
 delete mode 100644 sample_actor_standby/Dockerfile
 delete mode 100644 sample_actor_standby/README.md
 delete mode 100644 sample_actor_standby/package.json
 delete mode 100644 sample_actor_standby/src/main.js
 create mode 100644 sample_actor_standby_py/.actor/actor.json
 create mode 100644 sample_actor_standby_py/.dockerignore
 create mode 100644 sample_actor_standby_py/Dockerfile
 create mode 100644 sample_actor_standby_py/README.md
 create mode 100644 sample_actor_standby_py/requirements.txt
 create mode 100644 sample_actor_standby_py/src/__init__.py
 create mode 100644 sample_actor_standby_py/src/__main__.py
 create mode 100644 sample_actor_standby_py/src/main.py
 create mode 100644 sample_actor_standby_ts/.actor/actor.json
 create mode 100644 sample_actor_standby_ts/.dockerignore
 create mode 100644 sample_actor_standby_ts/Dockerfile
 create mode 100644 sample_actor_standby_ts/README.md
 create mode 100644 sample_actor_standby_ts/package-lock.json
 create mode 100644 sample_actor_standby_ts/package.json
 create mode 100644 sample_actor_standby_ts/src/main.ts
 create mode 100644 sample_actor_standby_ts/tsconfig.json

diff --git a/README.md b/README.md
index dbe163a0..08c95831 100644
--- a/README.md
+++ b/README.md
@@ -78,11 +78,14 @@ An Actor with Standby enabled - `"usesStandbyMode": true` in `.actor/actor.json`
 through the API - is served over HTTP at its `standbyUrl`, on the API port:
 
 ```bash
-cd sample_actor_standby
+cd sample_actor_standby_ts     # or sample_actor_standby_py
 apify push
-curl "http://localhost:3333/actor-runtime/standby/<username>--my-standby-actor/hello?name=Ada&token=<token>"
+curl "http://localhost:3333/actor-runtime/standby/<username>--my-standby-actor-ts/hello?name=Ada&token=<token>"
 ```
 
+The two samples are the same server in TypeScript and Python - JSON endpoints, a request body echo, a
+Server-Sent Events stream, a websocket and stats kept across runs; each README lists the calls.
+
 Requests are handed to standby runs the runtime starts, scales by `desiredRequestsPerActorRun` /
 `maxRequestsPerActorRun` and winds down after `idleTimeoutSecs` without a request, as on the platform.
 Single-tenant only - see `requirements/actor-driver.md`'s "Actor Standby".
diff --git a/eslint.config.js b/eslint.config.js
index 3500df2d..7912a8ec 100644
--- a/eslint.config.js
+++ b/eslint.config.js
@@ -9,6 +9,7 @@ export default tseslint.config(
 			'dist/**',
 			'node_modules/**',
 			'sample_actor_ts/**',
+			'sample_actor_standby_ts/**',
 			'sample_actor_py/**',
 			'sample_actor_playwright/**',
 			'data/**',
diff --git a/requirements/actor-driver.md b/requirements/actor-driver.md
index aa4063f8..6df62fb7 100644
--- a/requirements/actor-driver.md
+++ b/requirements/actor-driver.md
@@ -276,8 +276,9 @@ start`, ...) is refused by name, naming both the `CMD` fix and how to clear debu
   in the container reports `isAtHome`/`is_at_home = true`).
 - `APIFY_META_ORIGIN` — the run's origin: `STANDBY` for a standby run, `API` for every other run (every
   local run arrives via the API, apify-cli included)
-- `ACTOR_STANDBY_PORT` — the port an Actor server listens on: a version-level `ACTOR_WEB_SERVER_PORT` or
-  `ACTOR_STANDBY_PORT`, else `4321`, as on the platform.
+- `ACTOR_STANDBY_PORT` / `ACTOR_WEB_SERVER_PORT` — the port an Actor server listens on, both set to the same
+  value (the JavaScript SDK reads the first, the Python SDK the second): a version-level
+  `ACTOR_WEB_SERVER_PORT` or `ACTOR_STANDBY_PORT`, else `4321`, as on the platform.
 - `ACTOR_STANDBY_URL` — the Actor's standby URL (`api.md`).
 - `APIFY_API_BASE_URL` — the runtime's own API, reachable by name from any
   Actor container on the shared Docker network (see "Networking" above).
diff --git a/requirements/test.md b/requirements/test.md
index 2ec51349..37150f76 100644
--- a/requirements/test.md
+++ b/requirements/test.md
@@ -17,8 +17,8 @@
 - **A second narrow exception of the same kind**: the browser-view e2e test may open the console's viewer
   page and its websocket directly, to emulate a developer's browser opening the view. Everything else in it
   goes through `apify` commands.
-- **A third narrow exception**: the Actor Standby e2e test sends plain HTTP requests to the Actor's standby
-  URL, since no `apify` command can. Everything else in it goes through `apify` commands.
+- **A third narrow exception**: the Actor Standby e2e test sends plain HTTP requests and opens a websocket
+  to the Actor's standby URL, since no `apify` command can. Everything else in it goes through `apify` commands.
 - For asserting the test results, the tests must inspect the return values of the Apify cli commands.
 - The e2e suite requires a reachable Docker daemon (it builds and runs real Actor containers) and
   detects its absence, failing in such case.
@@ -48,6 +48,8 @@ Test case must verify full Actor development flow:
 
 ## Actor Standby
 
-- Push `sample_actor_standby`, whose `.actor/actor.json` enables Standby, and shorten its idle timeout
-- Assert that several requests to its standby URL are answered by one `STANDBY` run, that the run ends
-  `SUCCEEDED` once idle with one dataset item per request, and that the next request starts a new run
+- For each standby sample (`sample_actor_standby_ts`, `sample_actor_standby_py`), whose `.actor/actor.json`
+  enables Standby: push, and shorten its idle timeout
+- Assert that plain, body-carrying, streamed and websocket requests to its standby URL are all answered by
+  one `STANDBY` run, that the run ends `SUCCEEDED` once idle with one dataset item per greeting, and that
+  the next request starts a new run
diff --git a/requirements/unsupported.md b/requirements/unsupported.md
index 3855c71d..ed802440 100644
--- a/requirements/unsupported.md
+++ b/requirements/unsupported.md
@@ -92,7 +92,7 @@ real account, not in the runtime.
 ## Inside the Actor container
 
 - Run metadata env vars (input key, build, task, user, timestamps)
-- Web server and proxy env vars
+- Web server URL (`ACTOR_WEB_SERVER_URL`) and proxy env vars
 - Input secrets private key
 - Log rate limiting, line truncation and size cap
 - Secret redaction in logs
diff --git a/sample_actor_standby/.actor/actor.json b/sample_actor_standby/.actor/actor.json
deleted file mode 100644
index 309d0bdf..00000000
--- a/sample_actor_standby/.actor/actor.json
+++ /dev/null
@@ -1,11 +0,0 @@
-{
-	"$schema": "https://apify.com/schemas/v1/actor.ide.json",
-	"actorSpecification": 1,
-	"name": "my-standby-actor",
-	"title": "Standby sample actor for actor-runtime",
-	"description": "An Actor server: answers HTTP requests in Standby mode, pushing one dataset item per request.",
-	"version": "0.0",
-	"buildTag": "latest",
-	"usesStandbyMode": true,
-	"dockerfile": "../Dockerfile"
-}
diff --git a/sample_actor_standby/.dockerignore b/sample_actor_standby/.dockerignore
deleted file mode 100644
index 3c3629e6..00000000
--- a/sample_actor_standby/.dockerignore
+++ /dev/null
@@ -1 +0,0 @@
-node_modules
diff --git a/sample_actor_standby/Dockerfile b/sample_actor_standby/Dockerfile
deleted file mode 100644
index 002fb792..00000000
--- a/sample_actor_standby/Dockerfile
+++ /dev/null
@@ -1,6 +0,0 @@
-# The base image already carries the Apify SDK, so the build needs no npm install.
-FROM apify/actor-node:24
-
-COPY --chown=myuser:myuser . ./
-
-CMD ["node", "src/main.js"]
diff --git a/sample_actor_standby/README.md b/sample_actor_standby/README.md
deleted file mode 100644
index 0acde6f0..00000000
--- a/sample_actor_standby/README.md
+++ /dev/null
@@ -1,14 +0,0 @@
-# Standby sample Actor
-
-An Actor server for trying Actor Standby against the local runtime. `.actor/actor.json` sets
-`usesStandbyMode`, so `apify push` enables Standby for the Actor.
-
-```bash
-apify push
-curl "http://localhost:3333/actor-runtime/standby/<username>--my-standby-actor/hello?name=Ada&token=<token>"
-```
-
-The first request starts a standby run; later ones reuse it. Each request pushes one item to that run's
-default dataset. After `idleTimeoutSecs` (300 by default) without requests the run is wound down and
-ends `SUCCEEDED`; the next request starts a fresh one. `apify call` starts an ordinary run instead,
-which says where to send requests and exits.
diff --git a/sample_actor_standby/package.json b/sample_actor_standby/package.json
deleted file mode 100644
index 3fa53b53..00000000
--- a/sample_actor_standby/package.json
+++ /dev/null
@@ -1,13 +0,0 @@
-{
-	"name": "my-standby-actor",
-	"version": "0.0.1",
-	"type": "module",
-	"description": "A sample Actor Standby server for actor-runtime.",
-	"dependencies": {
-		"apify": "^3.7.0"
-	},
-	"scripts": {
-		"start": "node src/main.js"
-	},
-	"license": "ISC"
-}
diff --git a/sample_actor_standby/src/main.js b/sample_actor_standby/src/main.js
deleted file mode 100644
index 4d479ae9..00000000
--- a/sample_actor_standby/src/main.js
+++ /dev/null
@@ -1,37 +0,0 @@
-import { createServer } from 'node:http';
-import { URL } from 'node:url';
-
-import { Actor, log } from 'apify';
-
-await Actor.init();
-
-if (Actor.config.get('metaOrigin') !== 'STANDBY') {
-	log.info(`Not started in Standby mode - send HTTP requests to ${Actor.config.get('standbyUrl')} instead.`);
-	await Actor.exit();
-} else {
-	const port = Actor.config.get('standbyPort');
-	let served = 0;
-
-	const server = createServer(async (req, res) => {
-		// The platform's readiness probe; any answer tells it the server is up.
-		if (req.headers['x-apify-container-server-readiness-probe']) {
-			res.end('ready\n');
-			return;
-		}
-		const url = new URL(req.url, 'http://localhost');
-		const name = url.searchParams.get('name') ?? 'world';
-		served += 1;
-		await Actor.pushData({ path: url.pathname, name, servedAt: new Date().toISOString() });
-		log.info(`Served ${req.method} ${url.pathname} (request #${served} of this run)`);
-		res.writeHead(200, { 'content-type': 'application/json' });
-		res.end(JSON.stringify({ greeting: `Hello, ${name}!`, runId: Actor.config.get('actorRunId'), served }));
-	});
-
-	// An idle standby run is wound down with an `aborting` event; the SDK then exits on its own.
-	Actor.on('aborting', () => {
-		log.info(`Shutting down after serving ${served} requests.`);
-		server.close();
-	});
-
-	server.listen(port, () => log.info(`Standby server listening on port ${port}`));
-}
diff --git a/sample_actor_standby_py/.actor/actor.json b/sample_actor_standby_py/.actor/actor.json
new file mode 100644
index 00000000..f65438bb
--- /dev/null
+++ b/sample_actor_standby_py/.actor/actor.json
@@ -0,0 +1,11 @@
+{
+	"$schema": "https://apify.com/schemas/v1/actor.ide.json",
+	"actorSpecification": 1,
+	"name": "my-standby-actor-py",
+	"title": "Python Standby sample actor for actor-runtime",
+	"description": "An Actor server: JSON endpoints, a request body echo, a Server-Sent Events stream and a websocket, all served in Standby mode.",
+	"version": "0.0",
+	"buildTag": "latest",
+	"usesStandbyMode": true,
+	"dockerfile": "../Dockerfile"
+}
diff --git a/sample_actor_standby_py/.dockerignore b/sample_actor_standby_py/.dockerignore
new file mode 100644
index 00000000..01fb0e7e
--- /dev/null
+++ b/sample_actor_standby_py/.dockerignore
@@ -0,0 +1,4 @@
+.venv
+__pycache__
+*.pyc
+.git
diff --git a/sample_actor_standby_py/Dockerfile b/sample_actor_standby_py/Dockerfile
new file mode 100644
index 00000000..c5743154
--- /dev/null
+++ b/sample_actor_standby_py/Dockerfile
@@ -0,0 +1,8 @@
+FROM apify/actor-python:3.13
+
+COPY --chown=myuser:myuser requirements.txt ./
+RUN pip install -r requirements.txt
+
+COPY --chown=myuser:myuser . ./
+
+CMD ["python3", "-m", "src"]
diff --git a/sample_actor_standby_py/README.md b/sample_actor_standby_py/README.md
new file mode 100644
index 00000000..6be1d660
--- /dev/null
+++ b/sample_actor_standby_py/README.md
@@ -0,0 +1,26 @@
+# Python Standby sample Actor
+
+An Actor server for trying Actor Standby against the local runtime; `sample_actor_standby_ts` is the same
+server in TypeScript. `.actor/actor.json` sets `usesStandbyMode`, so `apify push` enables Standby.
+
+```bash
+apify push
+URL=http://localhost:3333/actor-runtime/standby/<username>--my-standby-actor-py
+TOKEN=<your token>
+
+curl "$URL/?token=$TOKEN"                                   # what the server offers
+curl "$URL/hello?name=Ada&token=$TOKEN"                     # a greeting; one dataset item per call
+curl -X POST -H 'content-type: application/json' -d '{"a":1}' "$URL/echo?token=$TOKEN"
+curl "$URL/stats?token=$TOKEN"                              # this run's and every run's request count
+curl -N "$URL/stream?count=5&token=$TOKEN"                  # Server-Sent Events, one every 0.5 s
+npx wscat -c "${URL/http/ws}/ws?token=$TOKEN"               # a websocket echo
+```
+
+- The first request starts a standby run and waits until the server answers the readiness probe; later
+  requests reuse that run. Each `/hello` pushes one item to the run's default dataset.
+- `/stats` keeps a running total across runs in the named key-value store `standby-sample-py-stats`, saved on
+  every `persistState` event and when the run is wound down.
+- After `idleTimeoutSecs` without a request (300 by default; shorten it with
+  `apify api PUT v2/actors/<actorId> --body '{"actorStandby":{"idleTimeoutSecs":10}}'`) the run gets the
+  `aborting` event, stops serving and ends `SUCCEEDED`. The next request starts a fresh run.
+- `apify call` starts an ordinary run instead, which says where to send requests and exits.
diff --git a/sample_actor_standby_py/requirements.txt b/sample_actor_standby_py/requirements.txt
new file mode 100644
index 00000000..b79f77e3
--- /dev/null
+++ b/sample_actor_standby_py/requirements.txt
@@ -0,0 +1,2 @@
+apify
+aiohttp
diff --git a/sample_actor_standby_py/src/__init__.py b/sample_actor_standby_py/src/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/sample_actor_standby_py/src/__main__.py b/sample_actor_standby_py/src/__main__.py
new file mode 100644
index 00000000..8c4ab0b8
--- /dev/null
+++ b/sample_actor_standby_py/src/__main__.py
@@ -0,0 +1,6 @@
+import asyncio
+
+from .main import main
+
+if __name__ == '__main__':
+    asyncio.run(main())
diff --git a/sample_actor_standby_py/src/main.py b/sample_actor_standby_py/src/main.py
new file mode 100644
index 00000000..55268aaa
--- /dev/null
+++ b/sample_actor_standby_py/src/main.py
@@ -0,0 +1,153 @@
+"""Python Actor Standby sample for actor-runtime.
+
+An HTTP server that the platform (or the runtime) starts on demand and sends requests to. Mirrors
+`sample_actor_standby_ts` endpoint for endpoint:
+
+    GET  /                 what this server offers, and which run is answering
+    GET  /hello?name=Ada   a greeting; pushes one item to the run's default dataset
+    POST /echo             the request's JSON (or text) body, echoed back
+    GET  /stats            requests served by this run, and by every run so far (a named key-value store)
+    GET  /stream?count=5   a Server-Sent Events stream, one event every half second
+    WS   /ws               a websocket that echoes every message
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from datetime import datetime, timezone
+from typing import Any
+
+from aiohttp import WSMsgType, web
+from apify import Actor, Event
+
+# Sent by the platform (and the runtime) until the server answers; any response means "ready".
+READINESS_PROBE_HEADER = 'x-apify-container-server-readiness-probe'
+STATS_STORE = 'standby-sample-py-stats'
+STATS_KEY = 'STATS'
+
+
+def now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+class StandbyServer:
+    def __init__(self, run_id: str | None, standby_url: str, before: dict[str, int]) -> None:
+        self.run_id = run_id
+        self.standby_url = standby_url
+        # The totals of every earlier run; this run's own count is added on top whenever they are saved.
+        self.before = before
+        self.served = 0
+
+    def all_runs(self) -> dict[str, int]:
+        return {'served': self.before['served'] + self.served, 'runs': self.before['runs'] + 1}
+
+    @web.middleware
+    async def count_requests(self, request: web.Request, handler: Any) -> web.StreamResponse:
+        if request.headers.get(READINESS_PROBE_HEADER):
+            return web.Response(text='ok\n')
+        if request.path != '/':
+            self.served += 1
+            Actor.log.info(f'{request.method} {request.path} (request #{self.served} of this run)')
+        return await handler(request)
+
+    async def index(self, _request: web.Request) -> web.Response:
+        return web.json_response(
+            {
+                'actor': 'Python Standby sample',
+                'runId': self.run_id,
+                'standbyUrl': self.standby_url,
+                'endpoints': ['GET /hello?name=', 'POST /echo', 'GET /stats', 'GET /stream?count=', 'WS /ws'],
+            }
+        )
+
+    async def hello(self, request: web.Request) -> web.Response:
+        name = request.query.get('name', 'world')
+        await Actor.push_data({'name': name, 'servedAt': now()})
+        return web.json_response({'greeting': f'Hello, {name}!', 'runId': self.run_id, 'served': self.served})
+
+    async def echo(self, request: web.Request) -> web.Response:
+        body: Any = await request.text()
+        if request.content_type == 'application/json':
+            try:
+                body = json.loads(body)
+            except json.JSONDecodeError:
+                return web.json_response({'error': 'The body is not valid JSON.'}, status=400)
+        return web.json_response({'runId': self.run_id, 'query': dict(request.query), 'body': body})
+
+    async def stats(self, _request: web.Request) -> web.Response:
+        return web.json_response(
+            {'runId': self.run_id, 'thisRun': {'served': self.served}, 'allRuns': self.all_runs()}
+        )
+
+    async def stream(self, request: web.Request) -> web.StreamResponse:
+        try:
+            count = min(int(request.query.get('count', '5')), 50)
+        except ValueError:
+            count = 5
+        response = web.StreamResponse(headers={'content-type': 'text/event-stream', 'cache-control': 'no-cache'})
+        await response.prepare(request)
+        for n in range(1, count + 1):
+            data = json.dumps({'n': n, 'of': count, 'at': now()})
+            await response.write(f'event: tick\ndata: {data}\n\n'.encode())
+            await asyncio.sleep(0.5)
+        await response.write(b'event: done\ndata: {}\n\n')
+        await response.write_eof()
+        return response
+
+    async def websocket(self, request: web.Request) -> web.WebSocketResponse:
+        socket = web.WebSocketResponse()
+        await socket.prepare(request)
+        await socket.send_json({'hello': 'Send me anything and I will echo it.', 'runId': self.run_id})
+        async for message in socket:
+            if message.type == WSMsgType.TEXT:
+                await socket.send_json({'echo': message.data})
+        return socket
+
+    def app(self) -> web.Application:
+        app = web.Application(middlewares=[self.count_requests])
+        app.router.add_get('/', self.index)
+        app.router.add_get('/hello', self.hello)
+        app.router.add_post('/echo', self.echo)
+        app.router.add_get('/stats', self.stats)
+        app.router.add_get('/stream', self.stream)
+        app.router.add_get('/ws', self.websocket)
+        return app
+
+
+async def main() -> None:
+    async with Actor:
+        config = Actor.configuration
+        if config.meta_origin != 'STANDBY':
+            # `apify call` lands here: an Actor server has nothing to do without requests.
+            Actor.log.info(f'This Actor is an HTTP server. Send requests to {config.standby_url}/ instead.')
+            return
+
+        stats_store = await Actor.open_key_value_store(name=STATS_STORE)
+        before = await stats_store.get_value(STATS_KEY) or {'served': 0, 'runs': 0}
+        server = StandbyServer(config.actor_run_id, config.standby_url, before)
+
+        async def save_stats(*_args: Any) -> None:
+            await stats_store.set_value(STATS_KEY, server.all_runs())
+
+        # An idle standby run is wound down with an `aborting` event: stop serving, save, and exit.
+        stopping = asyncio.Event()
+
+        async def on_aborting(*_args: Any) -> None:
+            Actor.log.info(f'Shutting down after serving {server.served} requests.')
+            stopping.set()
+
+        # Saved whenever the platform asks (periodically, and before a migration), so no count is lost.
+        Actor.on(Event.PERSIST_STATE, save_stats)
+        Actor.on(Event.ABORTING, on_aborting)
+
+        # The Python SDK reads the server port from ACTOR_WEB_SERVER_PORT (4321 unless set otherwise).
+        port = config.web_server_port
+        runner = web.AppRunner(server.app())
+        await runner.setup()
+        await web.TCPSite(runner, '0.0.0.0', port).start()
+        Actor.log.info(f'Standby server listening on port {port}')
+
+        await stopping.wait()
+        await runner.cleanup()
+        await save_stats()
diff --git a/sample_actor_standby_ts/.actor/actor.json b/sample_actor_standby_ts/.actor/actor.json
new file mode 100644
index 00000000..a8c51075
--- /dev/null
+++ b/sample_actor_standby_ts/.actor/actor.json
@@ -0,0 +1,11 @@
+{
+	"$schema": "https://apify.com/schemas/v1/actor.ide.json",
+	"actorSpecification": 1,
+	"name": "my-standby-actor-ts",
+	"title": "TypeScript Standby sample actor for actor-runtime",
+	"description": "An Actor server: JSON endpoints, a request body echo, a Server-Sent Events stream and a websocket, all served in Standby mode.",
+	"version": "0.0",
+	"buildTag": "latest",
+	"usesStandbyMode": true,
+	"dockerfile": "../Dockerfile"
+}
diff --git a/sample_actor_standby_ts/.dockerignore b/sample_actor_standby_ts/.dockerignore
new file mode 100644
index 00000000..3bbdbb77
--- /dev/null
+++ b/sample_actor_standby_ts/.dockerignore
@@ -0,0 +1,18 @@
+# configurations
+.idea
+.vscode
+.zed
+
+# crawlee and apify storage folders
+apify_storage
+crawlee_storage
+storage
+
+# installed files
+node_modules
+
+# git folder
+.git
+
+# dist folder
+dist
diff --git a/sample_actor_standby_ts/Dockerfile b/sample_actor_standby_ts/Dockerfile
new file mode 100644
index 00000000..cd75e644
--- /dev/null
+++ b/sample_actor_standby_ts/Dockerfile
@@ -0,0 +1,20 @@
+FROM apify/actor-node:24 AS builder
+
+COPY --chown=myuser:myuser package*.json ./
+RUN npm install --include=dev --audit=false
+
+COPY --chown=myuser:myuser . ./
+RUN npm run build
+
+FROM apify/actor-node:24
+
+COPY --chown=myuser:myuser package*.json ./
+RUN npm --quiet set progress=false \
+    && npm install --omit=dev --omit=optional --audit=false \
+    && rm -r ~/.npm
+
+COPY --from=builder --chown=myuser:myuser /usr/src/app/dist ./dist
+COPY --chown=myuser:myuser . ./
+
+# The interpreter itself, not `npm start`, so the runtime's debug mode can attach too.
+CMD ["node", "dist/main.js"]
diff --git a/sample_actor_standby_ts/README.md b/sample_actor_standby_ts/README.md
new file mode 100644
index 00000000..1652d3ec
--- /dev/null
+++ b/sample_actor_standby_ts/README.md
@@ -0,0 +1,26 @@
+# TypeScript Standby sample Actor
+
+An Actor server for trying Actor Standby against the local runtime; `sample_actor_standby_py` is the same
+server in Python. `.actor/actor.json` sets `usesStandbyMode`, so `apify push` enables Standby.
+
+```bash
+apify push
+URL=http://localhost:3333/actor-runtime/standby/<username>--my-standby-actor-ts
+TOKEN=<your token>
+
+curl "$URL/?token=$TOKEN"                                   # what the server offers
+curl "$URL/hello?name=Ada&token=$TOKEN"                     # a greeting; one dataset item per call
+curl -X POST -H 'content-type: application/json' -d '{"a":1}' "$URL/echo?token=$TOKEN"
+curl "$URL/stats?token=$TOKEN"                              # this run's and every run's request count
+curl -N "$URL/stream?count=5&token=$TOKEN"                  # Server-Sent Events, one every 0.5 s
+npx wscat -c "${URL/http/ws}/ws?token=$TOKEN"               # a websocket echo
+```
+
+- The first request starts a standby run and waits until the server answers the readiness probe; later
+  requests reuse that run. Each `/hello` pushes one item to the run's default dataset.
+- `/stats` keeps a running total across runs in the named key-value store `standby-sample-ts-stats`, saved on
+  every `persistState` event and when the run is wound down.
+- After `idleTimeoutSecs` without a request (300 by default; shorten it with
+  `apify api PUT v2/actors/<actorId> --body '{"actorStandby":{"idleTimeoutSecs":10}}'`) the run gets the
+  `aborting` event, stops serving and ends `SUCCEEDED`. The next request starts a fresh run.
+- `apify call` starts an ordinary run instead, which says where to send requests and exits.
diff --git a/sample_actor_standby_ts/package-lock.json b/sample_actor_standby_ts/package-lock.json
new file mode 100644
index 00000000..50ea97a7
--- /dev/null
+++ b/sample_actor_standby_ts/package-lock.json
@@ -0,0 +1,2290 @@
+{
+	"name": "my-standby-actor-ts",
+	"version": "0.0.1",
+	"lockfileVersion": 3,
+	"requires": true,
+	"packages": {
+		"": {
+			"name": "my-standby-actor-ts",
+			"version": "0.0.1",
+			"license": "ISC",
+			"dependencies": {
+				"apify": "^3.7.0",
+				"ws": "^8.18.0"
+			},
+			"devDependencies": {
+				"@apify/tsconfig": "^0.2.0",
+				"@types/node": "^24.0.0",
+				"@types/ws": "^8.18.1",
+				"typescript": "^6.0.0"
+			},
+			"engines": {
+				"node": ">=18.0.0"
+			}
+		},
+		"node_modules/@apify/consts": {
+			"version": "2.58.1",
+			"resolved": "https://registry.npmjs.org/@apify/consts/-/consts-2.58.1.tgz",
+			"integrity": "sha512-pKnoPincN2eqiSANmX2u19FihJATX3f1ucMhxss7t2epUmB/UhSjGM7G4immjC7Q/CXrNmbETBbOGmR0/EH4/Q==",
+			"license": "Apache-2.0"
+		},
+		"node_modules/@apify/datastructures": {
+			"version": "2.0.6",
+			"resolved": "https://registry.npmjs.org/@apify/datastructures/-/datastructures-2.0.6.tgz",
+			"integrity": "sha512-hI/Q5cCjXXI/g4OPwX+/xuk+JsOtXRhKNXl2wnq/nKmdrji3nYCc9vGsAEc1iXVbs16xQMZy5uRhoY3XTABovA==",
+			"license": "Apache-2.0"
+		},
+		"node_modules/@apify/input_secrets": {
+			"version": "1.2.60",
+			"resolved": "https://registry.npmjs.org/@apify/input_secrets/-/input_secrets-1.2.60.tgz",
+			"integrity": "sha512-KfrnFFTy7pozNxgX6MBdeCbVIhxM/t6t8gDroRbADJyYmaGtkqsxk9t4/xw9ri+ZObiWdWQrlU10xF+NUqDQBg==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"@apify/log": "^2.5.54",
+				"@apify/utilities": "^2.35.11",
+				"ow": "^0.28.2"
+			}
+		},
+		"node_modules/@apify/log": {
+			"version": "2.5.54",
+			"resolved": "https://registry.npmjs.org/@apify/log/-/log-2.5.54.tgz",
+			"integrity": "sha512-EZRHrKCWnet0+6WaTx14Mpjxrn/PRudmRk6/N1dCTz+jtHN+Pbdvw5FFtIrCUngPhm4+bdI+kKVYUBmvTwrjvg==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"@apify/consts": "^2.58.1",
+				"ansi-colors": "^4.1.3"
+			}
+		},
+		"node_modules/@apify/ps-tree": {
+			"version": "1.2.0",
+			"resolved": "https://registry.npmjs.org/@apify/ps-tree/-/ps-tree-1.2.0.tgz",
+			"integrity": "sha512-VHIswI7rD/R4bToeIDuJ9WJXt+qr5SdhfoZ9RzdjmCs9mgy7l0P4RugQEUCcU+WB4sfImbd4CKwzXcn0uYx1yw==",
+			"license": "MIT",
+			"dependencies": {
+				"event-stream": "3.3.4"
+			},
+			"bin": {
+				"ps-tree": "bin/ps-tree.js"
+			},
+			"engines": {
+				"node": ">= 0.10"
+			}
+		},
+		"node_modules/@apify/pseudo_url": {
+			"version": "2.0.95",
+			"resolved": "https://registry.npmjs.org/@apify/pseudo_url/-/pseudo_url-2.0.95.tgz",
+			"integrity": "sha512-VZJ8cfXFAKIfCSk4EzlZwwXW6WESLMvDP9NHhB7nCsg6zskv0I/81V/liX5wOs3FjjipLegkx0AWw7lkyk3gEA==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"@apify/log": "^2.5.54"
+			}
+		},
+		"node_modules/@apify/timeout": {
+			"version": "0.3.5",
+			"resolved": "https://registry.npmjs.org/@apify/timeout/-/timeout-0.3.5.tgz",
+			"integrity": "sha512-3nuQXwxh2sKxBo5tgDoZWuZHiSpqrKg1+sJHjFSk8blhyX6I2FZzpfW7UaCELeYLZiSjWUPh2rXNrc3zLmJGJg==",
+			"license": "Apache-2.0"
+		},
+		"node_modules/@apify/tsconfig": {
+			"version": "0.2.0",
+			"resolved": "https://registry.npmjs.org/@apify/tsconfig/-/tsconfig-0.2.0.tgz",
+			"integrity": "sha512-0i6rF+hgXw6mQXhENYNTnP+Yo4WY38d698k/pk4rIpdCx/sSuEprR2N5WdtMaN628vCB+aZjff0jPN2EnQYtjQ==",
+			"dev": true,
+			"license": "Apache-2.0"
+		},
+		"node_modules/@apify/utilities": {
+			"version": "2.35.11",
+			"resolved": "https://registry.npmjs.org/@apify/utilities/-/utilities-2.35.11.tgz",
+			"integrity": "sha512-od9Axa/+OSZB5JO8aljAnN7lS8vDb5KqUEAkUiZZh95K5xIrC0GzN45DNcK8oItnJ3QT/oqtHdaa22TipinDvQ==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"@apify/consts": "^2.58.1",
+				"@apify/log": "^2.5.54"
+			}
+		},
+		"node_modules/@borewit/text-codec": {
+			"version": "0.2.2",
+			"resolved": "https://registry.npmjs.org/@borewit/text-codec/-/text-codec-0.2.2.tgz",
+			"integrity": "sha512-DDaRehssg1aNrH4+2hnj1B7vnUGEjU6OIlyRdkMd0aUdIUvKXrJfXsy8LVtXAy7DRvYVluWbMspsRhz2lcW0mQ==",
+			"license": "MIT",
+			"funding": {
+				"type": "github",
+				"url": "https://github.com/sponsors/Borewit"
+			}
+		},
+		"node_modules/@crawlee/core": {
+			"version": "3.18.1",
+			"resolved": "https://registry.npmjs.org/@crawlee/core/-/core-3.18.1.tgz",
+			"integrity": "sha512-f8bQBBfRxRf5RvUErI6K5xhxN9vWsZajT3XdQmCjjPfqp4Oa20Vsi2DarQE9FAFZpy/djncJH+tn24HlZMaBig==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"@apify/consts": "^2.20.0",
+				"@apify/datastructures": "^2.0.0",
+				"@apify/log": "^2.4.0",
+				"@apify/pseudo_url": "^2.0.30",
+				"@apify/timeout": "^0.4.0",
+				"@apify/utilities": "^2.7.10",
+				"@crawlee/memory-storage": "3.18.1",
+				"@crawlee/types": "3.18.1",
+				"@crawlee/utils": "3.18.1",
+				"@sapphire/async-queue": "^1.5.1",
+				"@standard-schema/spec": "^1.0.0",
+				"@vladfrangu/async_event_emitter": "^2.2.2",
+				"csv-stringify": "^6.2.0",
+				"fs-extra": "^11.0.0",
+				"got-scraping": "^4.2.1",
+				"json5": "^2.2.3",
+				"minimatch": "^9.0.0",
+				"ow": "^0.28.1",
+				"stream-json": "^1.8.0",
+				"tldts": "^7.0.0",
+				"tough-cookie": "^6.0.0",
+				"tslib": "^2.4.0",
+				"type-fest": "^4.0.0"
+			},
+			"engines": {
+				"node": ">=16.0.0"
+			}
+		},
+		"node_modules/@crawlee/core/node_modules/@apify/timeout": {
+			"version": "0.4.14",
+			"resolved": "https://registry.npmjs.org/@apify/timeout/-/timeout-0.4.14.tgz",
+			"integrity": "sha512-Wn3Y49JfbwwlNSzOlQ9PIux3DeMKHhkQSEppaoPGxoZFq1YZQWx+Td9BCWNXyYmM2K+WUa1iHQtNPgqewbNYGw==",
+			"license": "Apache-2.0"
+		},
+		"node_modules/@crawlee/memory-storage": {
+			"version": "3.18.1",
+			"resolved": "https://registry.npmjs.org/@crawlee/memory-storage/-/memory-storage-3.18.1.tgz",
+			"integrity": "sha512-uzyBuSwfwNCFRcJlNOoJ5UMVYGWQE7UlnMsMULzRrs1YnkqLzZ7ldeyXfRwGxJUNo4KJ6o3IxDpGCIj8dkuzrQ==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"@apify/log": "^2.4.0",
+				"@crawlee/types": "3.18.1",
+				"@sapphire/async-queue": "^1.5.0",
+				"@sapphire/shapeshift": "^3.0.0",
+				"content-type": "^1.0.4",
+				"fs-extra": "^11.0.0",
+				"json5": "^2.2.3",
+				"mime-types": "^2.1.35",
+				"p-limit": "^3.1.0",
+				"proper-lockfile": "^4.1.2",
+				"tslib": "^2.4.0"
+			},
+			"engines": {
+				"node": ">= 16"
+			}
+		},
+		"node_modules/@crawlee/types": {
+			"version": "3.18.1",
+			"resolved": "https://registry.npmjs.org/@crawlee/types/-/types-3.18.1.tgz",
+			"integrity": "sha512-jmV7HN4b1vEzriGcKhCRa8A5rv5HaqBPPfneGRxPpZtbmnEcusHTmEOOyG393lUBmv0yaM03da0hy+PZnR35vw==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"tslib": "^2.4.0"
+			},
+			"engines": {
+				"node": ">=16.0.0"
+			}
+		},
+		"node_modules/@crawlee/utils": {
+			"version": "3.18.1",
+			"resolved": "https://registry.npmjs.org/@crawlee/utils/-/utils-3.18.1.tgz",
+			"integrity": "sha512-NS9eCmaH+jcjLHfq2WIKp5yfKxQGEcuLOAwzugFcnH38D/EwCgYXYtnDxidFZB8qbuuONFfDpVfyHohc4mNDhw==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"@apify/log": "^2.4.0",
+				"@apify/ps-tree": "^1.2.0",
+				"@crawlee/types": "3.18.1",
+				"@types/sax": "^1.2.7",
+				"cheerio": "1.0.0-rc.12",
+				"file-type": "^21.3.1",
+				"got-scraping": "^4.2.1",
+				"ow": "^0.28.1",
+				"robots-parser": "^3.0.1",
+				"sax": "^1.4.1",
+				"tldts": "^7.0.0",
+				"tslib": "^2.4.0",
+				"whatwg-mimetype": "^4.0.0"
+			},
+			"engines": {
+				"node": ">=16.0.0"
+			}
+		},
+		"node_modules/@keyv/serialize": {
+			"version": "1.1.1",
+			"resolved": "https://registry.npmjs.org/@keyv/serialize/-/serialize-1.1.1.tgz",
+			"integrity": "sha512-dXn3FZhPv0US+7dtJsIi2R+c7qWYiReoEh5zUntWCf4oSpMNib8FDhSoed6m3QyZdx5hK7iLFkYk3rNxwt8vTA==",
+			"license": "MIT"
+		},
+		"node_modules/@sapphire/async-queue": {
+			"version": "1.5.5",
+			"resolved": "https://registry.npmjs.org/@sapphire/async-queue/-/async-queue-1.5.5.tgz",
+			"integrity": "sha512-cvGzxbba6sav2zZkH8GPf2oGk9yYoD5qrNWdu9fRehifgnFZJMV+nuy2nON2roRO4yQQ+v7MK/Pktl/HgfsUXg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=v14.0.0",
+				"npm": ">=7.0.0"
+			}
+		},
+		"node_modules/@sapphire/shapeshift": {
+			"version": "3.9.7",
+			"resolved": "https://registry.npmjs.org/@sapphire/shapeshift/-/shapeshift-3.9.7.tgz",
+			"integrity": "sha512-4It2mxPSr4OGn4HSQWGmhFMsNFGfFVhWeRPCRwbH972Ek2pzfGRZtb0pJ4Ze6oIzcyh2jw7nUDa6qGlWofgd9g==",
+			"license": "MIT",
+			"dependencies": {
+				"fast-deep-equal": "^3.1.3",
+				"lodash": "^4.17.21"
+			},
+			"engines": {
+				"node": ">=v16"
+			}
+		},
+		"node_modules/@sec-ant/readable-stream": {
+			"version": "0.4.1",
+			"resolved": "https://registry.npmjs.org/@sec-ant/readable-stream/-/readable-stream-0.4.1.tgz",
+			"integrity": "sha512-831qok9r2t8AlxLko40y2ebgSDhenenCatLVeW/uBtnHPyhHOvG0C7TvfgecV+wHzIm5KUICgzmVpWS+IMEAeg==",
+			"license": "MIT"
+		},
+		"node_modules/@sindresorhus/is": {
+			"version": "7.2.0",
+			"resolved": "https://registry.npmjs.org/@sindresorhus/is/-/is-7.2.0.tgz",
+			"integrity": "sha512-P1Cz1dWaFfR4IR+U13mqqiGsLFf1KbayybWwdd2vfctdV6hDpUkgCY0nKOLLTMSoRd/jJNjtbqzf13K8DCCXQw==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=18"
+			},
+			"funding": {
+				"url": "https://github.com/sindresorhus/is?sponsor=1"
+			}
+		},
+		"node_modules/@standard-schema/spec": {
+			"version": "1.1.0",
+			"resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.1.0.tgz",
+			"integrity": "sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==",
+			"license": "MIT"
+		},
+		"node_modules/@tokenizer/inflate": {
+			"version": "0.4.1",
+			"resolved": "https://registry.npmjs.org/@tokenizer/inflate/-/inflate-0.4.1.tgz",
+			"integrity": "sha512-2mAv+8pkG6GIZiF1kNg1jAjh27IDxEPKwdGul3snfztFerfPGI1LjDezZp3i7BElXompqEtPmoPx6c2wgtWsOA==",
+			"license": "MIT",
+			"dependencies": {
+				"debug": "^4.4.3",
+				"token-types": "^6.1.1"
+			},
+			"engines": {
+				"node": ">=18"
+			},
+			"funding": {
+				"type": "github",
+				"url": "https://github.com/sponsors/Borewit"
+			}
+		},
+		"node_modules/@tokenizer/token": {
+			"version": "0.3.0",
+			"resolved": "https://registry.npmjs.org/@tokenizer/token/-/token-0.3.0.tgz",
+			"integrity": "sha512-OvjF+z51L3ov0OyAU0duzsYuvO01PH7x4t6DJx+guahgTnBHkhJdG7soQeTSFLWN3efnHyibZ4Z8l2EuWwJN3A==",
+			"license": "MIT"
+		},
+		"node_modules/@tootallnate/quickjs-emscripten": {
+			"version": "0.23.0",
+			"resolved": "https://registry.npmjs.org/@tootallnate/quickjs-emscripten/-/quickjs-emscripten-0.23.0.tgz",
+			"integrity": "sha512-C5Mc6rdnsaJDjO3UpGW/CQTHtCKaYlScZTly4JIu97Jxo/odCiH0ITnDXSJPTOrEKk/ycSZ0AOgTmkDtkOsvIA==",
+			"license": "MIT"
+		},
+		"node_modules/@types/http-cache-semantics": {
+			"version": "4.2.0",
+			"resolved": "https://registry.npmjs.org/@types/http-cache-semantics/-/http-cache-semantics-4.2.0.tgz",
+			"integrity": "sha512-L3LgimLHXtGkWikKnsPg0/VFx9OGZaC+eN1u4r+OB1XRqH3meBIAVC2zr1WdMH+RHmnRkqliQAOHNJ/E0j/e0Q==",
+			"license": "MIT"
+		},
+		"node_modules/@types/node": {
+			"version": "24.13.6",
+			"resolved": "https://registry.npmjs.org/@types/node/-/node-24.13.6.tgz",
+			"integrity": "sha512-SGrw/h3KPFshy3OE6ZL53LMBG5vGQQ8/gIpiqz/kRZhPJ7HgwCEs8LBuNtWLa8dvGZVpSF7+Bf+c11HUrCb/yg==",
+			"license": "MIT",
+			"dependencies": {
+				"undici-types": "~7.18.0"
+			}
+		},
+		"node_modules/@types/sax": {
+			"version": "1.2.7",
+			"resolved": "https://registry.npmjs.org/@types/sax/-/sax-1.2.7.tgz",
+			"integrity": "sha512-rO73L89PJxeYM3s3pPPjiPgVVcymqU490g0YO5n5By0k2Erzj6tay/4lr1CHAAU4JyOWd1rpQ8bCf6cZfHU96A==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/node": "*"
+			}
+		},
+		"node_modules/@types/ws": {
+			"version": "8.18.1",
+			"resolved": "https://registry.npmjs.org/@types/ws/-/ws-8.18.1.tgz",
+			"integrity": "sha512-ThVF6DCVhA8kUGy+aazFQ4kXQ7E1Ty7A3ypFOe0IcJV8O/M511G99AW24irKrW56Wt44yG9+ij8FaqoBGkuBXg==",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"@types/node": "*"
+			}
+		},
+		"node_modules/@vladfrangu/async_event_emitter": {
+			"version": "2.4.7",
+			"resolved": "https://registry.npmjs.org/@vladfrangu/async_event_emitter/-/async_event_emitter-2.4.7.tgz",
+			"integrity": "sha512-Xfe6rpCTxSxfbswi/W/Pz7zp1WWSNn4A0eW4mLkQUewCrXXtMj31lCg+iQyTkh/CkusZSq9eDflu7tjEDXUY6g==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=v14.0.0",
+				"npm": ">=7.0.0"
+			}
+		},
+		"node_modules/adm-zip": {
+			"version": "0.6.1",
+			"resolved": "https://registry.npmjs.org/adm-zip/-/adm-zip-0.6.1.tgz",
+			"integrity": "sha512-Xwrja8nx9e5o2N1my4DsKCeKpdrnACyr1wtbPxBDgGzKzKyE9kRtBFA8mWldI+RVlD7CBZNWY/wQ2+ydwOR6kQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=14.0"
+			}
+		},
+		"node_modules/agent-base": {
+			"version": "6.0.2",
+			"resolved": "https://registry.npmjs.org/agent-base/-/agent-base-6.0.2.tgz",
+			"integrity": "sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==",
+			"license": "MIT",
+			"dependencies": {
+				"debug": "4"
+			},
+			"engines": {
+				"node": ">= 6.0.0"
+			}
+		},
+		"node_modules/ansi-colors": {
+			"version": "4.1.3",
+			"resolved": "https://registry.npmjs.org/ansi-colors/-/ansi-colors-4.1.3.tgz",
+			"integrity": "sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=6"
+			}
+		},
+		"node_modules/apify": {
+			"version": "3.7.2",
+			"resolved": "https://registry.npmjs.org/apify/-/apify-3.7.2.tgz",
+			"integrity": "sha512-I4R5Qd1X11vk5/1U0CxKSsMhNwER/3MntePEQb9Pbtf942OhQLh5IURrJZufqtpimkqRy44SlQMU6UhPdoFXhA==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"@apify/consts": "^2.51.0",
+				"@apify/input_secrets": "^1.2.0",
+				"@apify/log": "^2.4.3",
+				"@apify/timeout": "^0.3.0",
+				"@apify/utilities": "^2.13.0",
+				"@crawlee/core": "^3.14.1",
+				"@crawlee/types": "^3.14.1",
+				"@crawlee/utils": "^3.14.1",
+				"apify-client": "^2.17.0",
+				"fs-extra": "^11.2.0",
+				"ow": "^0.28.2",
+				"semver": "^7.5.4",
+				"tslib": "^2.6.2",
+				"ws": "^8.18.0"
+			},
+			"engines": {
+				"node": ">=16.0.0"
+			}
+		},
+		"node_modules/apify-client": {
+			"version": "2.25.0",
+			"resolved": "https://registry.npmjs.org/apify-client/-/apify-client-2.25.0.tgz",
+			"integrity": "sha512-g6ttHJ4Au/Gg0iDHIevN3CvTbJfey9DUXUXJxe0ORF6JIYaVVfKdyJjINGb6/49gOpt/62ZFPw+HSEVIzrwR5w==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"@apify/consts": "^2.50.0",
+				"@apify/log": "^2.2.6",
+				"@apify/utilities": "^2.23.2",
+				"@crawlee/types": "^3.3.0",
+				"ansi-colors": "^4.1.1",
+				"async-retry": "^1.3.3",
+				"axios": "^1.16.0",
+				"content-type": "^1.0.5",
+				"ow": "^0.28.2",
+				"proxy-agent": "^6.5.0",
+				"tslib": "^2.5.0",
+				"type-fest": "^4.0.0"
+			}
+		},
+		"node_modules/ast-types": {
+			"version": "0.13.4",
+			"resolved": "https://registry.npmjs.org/ast-types/-/ast-types-0.13.4.tgz",
+			"integrity": "sha512-x1FCFnFifvYDDzTaLII71vG5uvDwgtmDTEVWAxrgeiR8VjMONcCXJx7E+USjDtHlwFmt9MysbqgF9b9Vjr6w+w==",
+			"license": "MIT",
+			"dependencies": {
+				"tslib": "^2.0.1"
+			},
+			"engines": {
+				"node": ">=4"
+			}
+		},
+		"node_modules/async-retry": {
+			"version": "1.3.3",
+			"resolved": "https://registry.npmjs.org/async-retry/-/async-retry-1.3.3.tgz",
+			"integrity": "sha512-wfr/jstw9xNi/0teMHrRW7dsz3Lt5ARhYNZ2ewpadnhaIp5mbALhOAP+EAdsC7t4Z6wqsDVv9+W6gm1Dk9mEyw==",
+			"license": "MIT",
+			"dependencies": {
+				"retry": "0.13.1"
+			}
+		},
+		"node_modules/asynckit": {
+			"version": "0.4.0",
+			"resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
+			"integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==",
+			"license": "MIT"
+		},
+		"node_modules/axios": {
+			"version": "1.20.0",
+			"resolved": "https://registry.npmjs.org/axios/-/axios-1.20.0.tgz",
+			"integrity": "sha512-r8aOh8j9cGKpgQAqpzrUHnSIc6a59Y3Xf/cv8sy1DrHCkZHzQGEuoq1tARk6qSyDdtQGSDgpb9kFlruzPvrgwg==",
+			"license": "MIT",
+			"dependencies": {
+				"follow-redirects": "^1.16.0",
+				"form-data": "^4.0.6",
+				"https-proxy-agent": "^5.0.1",
+				"proxy-from-env": "^2.1.0"
+			}
+		},
+		"node_modules/balanced-match": {
+			"version": "1.0.2",
+			"resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+			"integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+			"license": "MIT"
+		},
+		"node_modules/baseline-browser-mapping": {
+			"version": "2.11.25",
+			"resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.11.25.tgz",
+			"integrity": "sha512-gMmEShwwq7FJqMwvfRwvCl00v4kN+KOfJqXn+f4nrufak5gNHJOksd/60Dvjuz7sI8Y5WiSFBa8FEYr+zoyqCw==",
+			"license": "Apache-2.0",
+			"bin": {
+				"baseline-browser-mapping": "dist/cli.cjs"
+			},
+			"engines": {
+				"node": ">=6.0.0"
+			}
+		},
+		"node_modules/basic-ftp": {
+			"version": "5.3.1",
+			"resolved": "https://registry.npmjs.org/basic-ftp/-/basic-ftp-5.3.1.tgz",
+			"integrity": "sha512-bopVNp6ugyA150DDuZfPFdt1KZ5a94ZDiwX4hMgZDzF+GttD80lEy8kj98kbyhLXnPvhtIo93mdnLIjpCAeeOw==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=10.0.0"
+			}
+		},
+		"node_modules/boolbase": {
+			"version": "1.0.0",
+			"resolved": "https://registry.npmjs.org/boolbase/-/boolbase-1.0.0.tgz",
+			"integrity": "sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww==",
+			"license": "ISC"
+		},
+		"node_modules/brace-expansion": {
+			"version": "2.1.7",
+			"resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.1.7.tgz",
+			"integrity": "sha512-uZbew1NqdmPDTMJ8ah1y+b+9QEJrfkXFk3RcTQw3X0jW/xRUvFKsg1CfQdSYGdTbXZWExtU3J3ccxtnfw1Fi0g==",
+			"license": "MIT",
+			"dependencies": {
+				"balanced-match": "^1.0.0"
+			}
+		},
+		"node_modules/browserslist": {
+			"version": "4.29.0",
+			"resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.29.0.tgz",
+			"integrity": "sha512-3GSvyjvDI4Dur1Meg2BekJquu5uF+9R9a1+5M1Mde192eZoXbeXjzgOsgqPS2V8D5wrrip0gR5Hf/GhWQ9ZzaA==",
+			"funding": [
+				{
+					"type": "opencollective",
+					"url": "https://opencollective.com/browserslist"
+				},
+				{
+					"type": "tidelift",
+					"url": "https://tidelift.com/funding/github/npm/browserslist"
+				},
+				{
+					"type": "github",
+					"url": "https://github.com/sponsors/ai"
+				}
+			],
+			"license": "MIT",
+			"dependencies": {
+				"baseline-browser-mapping": "^2.11.23",
+				"caniuse-lite": "^1.0.30001810",
+				"electron-to-chromium": "^1.5.427",
+				"node-releases": "^2.0.55",
+				"update-browserslist-db": "^1.3.3"
+			},
+			"bin": {
+				"browserslist": "cli.js"
+			},
+			"engines": {
+				"node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
+			}
+		},
+		"node_modules/byte-counter": {
+			"version": "0.1.0",
+			"resolved": "https://registry.npmjs.org/byte-counter/-/byte-counter-0.1.0.tgz",
+			"integrity": "sha512-jheRLVMeUKrDBjVw2O5+k4EvR4t9wtxHL+bo/LxfkxsVeuGMy3a5SEGgXdAFA4FSzTrU8rQXQIrsZ3oBq5a0pQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=20"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/cacheable-lookup": {
+			"version": "7.0.0",
+			"resolved": "https://registry.npmjs.org/cacheable-lookup/-/cacheable-lookup-7.0.0.tgz",
+			"integrity": "sha512-+qJyx4xiKra8mZrcwhjMRMUhD5NR1R8esPkzIYxX96JiecFoxAXFuz/GpR3+ev4PE1WamHip78wV0vcmPQtp8w==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=14.16"
+			}
+		},
+		"node_modules/cacheable-request": {
+			"version": "13.0.19",
+			"resolved": "https://registry.npmjs.org/cacheable-request/-/cacheable-request-13.0.19.tgz",
+			"integrity": "sha512-SVXGH037+Mo1aIMO5B2UcleR43FGjFdN+M8JObSyEoQ2Mn4CODRWx28gN5jiTF0n5ItsgtIZfyargMNs8GX4kg==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/http-cache-semantics": "^4.2.0",
+				"get-stream": "^9.0.1",
+				"http-cache-semantics": "^4.2.0",
+				"keyv": "^5.6.0",
+				"mimic-response": "^4.0.0",
+				"normalize-url": "^8.1.1",
+				"responselike": "^4.0.2"
+			},
+			"engines": {
+				"node": ">=18"
+			}
+		},
+		"node_modules/call-bind-apply-helpers": {
+			"version": "1.0.2",
+			"resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
+			"integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
+			"license": "MIT",
+			"dependencies": {
+				"es-errors": "^1.3.0",
+				"function-bind": "^1.1.2"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			}
+		},
+		"node_modules/callsites": {
+			"version": "3.1.0",
+			"resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
+			"integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=6"
+			}
+		},
+		"node_modules/caniuse-lite": {
+			"version": "1.0.30001810",
+			"resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001810.tgz",
+			"integrity": "sha512-TITQPUkaz+aVk5GL6NhOdwk1aEaNTSDPsGFWrTuhKGtjTF70jL/Oht2W4c6rXUe5fu7Ie19VIahAXHIIiWWNeg==",
+			"funding": [
+				{
+					"type": "opencollective",
+					"url": "https://opencollective.com/browserslist"
+				},
+				{
+					"type": "tidelift",
+					"url": "https://tidelift.com/funding/github/npm/caniuse-lite"
+				},
+				{
+					"type": "github",
+					"url": "https://github.com/sponsors/ai"
+				}
+			],
+			"license": "CC-BY-4.0"
+		},
+		"node_modules/cheerio": {
+			"version": "1.0.0-rc.12",
+			"resolved": "https://registry.npmjs.org/cheerio/-/cheerio-1.0.0-rc.12.tgz",
+			"integrity": "sha512-VqR8m68vM46BNnuZ5NtnGBKIE/DfN0cRIzg9n40EIq9NOv90ayxLBXA8fXC5gquFRGJSTRqBq25Jt2ECLR431Q==",
+			"license": "MIT",
+			"dependencies": {
+				"cheerio-select": "^2.1.0",
+				"dom-serializer": "^2.0.0",
+				"domhandler": "^5.0.3",
+				"domutils": "^3.0.1",
+				"htmlparser2": "^8.0.1",
+				"parse5": "^7.0.0",
+				"parse5-htmlparser2-tree-adapter": "^7.0.0"
+			},
+			"engines": {
+				"node": ">= 6"
+			},
+			"funding": {
+				"url": "https://github.com/cheeriojs/cheerio?sponsor=1"
+			}
+		},
+		"node_modules/cheerio-select": {
+			"version": "2.1.0",
+			"resolved": "https://registry.npmjs.org/cheerio-select/-/cheerio-select-2.1.0.tgz",
+			"integrity": "sha512-9v9kG0LvzrlcungtnJtpGNxY+fzECQKhK4EGJX2vByejiMX84MFNQw4UxPJl3bFbTMw+Dfs37XaIkCwTZfLh4g==",
+			"license": "BSD-2-Clause",
+			"dependencies": {
+				"boolbase": "^1.0.0",
+				"css-select": "^5.1.0",
+				"css-what": "^6.1.0",
+				"domelementtype": "^2.3.0",
+				"domhandler": "^5.0.3",
+				"domutils": "^3.0.1"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/fb55"
+			}
+		},
+		"node_modules/combined-stream": {
+			"version": "1.0.8",
+			"resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
+			"integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
+			"license": "MIT",
+			"dependencies": {
+				"delayed-stream": "~1.0.0"
+			},
+			"engines": {
+				"node": ">= 0.8"
+			}
+		},
+		"node_modules/content-type": {
+			"version": "1.0.5",
+			"resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz",
+			"integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.6"
+			}
+		},
+		"node_modules/css-select": {
+			"version": "5.2.2",
+			"resolved": "https://registry.npmjs.org/css-select/-/css-select-5.2.2.tgz",
+			"integrity": "sha512-TizTzUddG/xYLA3NXodFM0fSbNizXjOKhqiQQwvhlspadZokn1KDy0NZFS0wuEubIYAV5/c1/lAr0TaaFXEXzw==",
+			"license": "BSD-2-Clause",
+			"dependencies": {
+				"boolbase": "^1.0.0",
+				"css-what": "^6.1.0",
+				"domhandler": "^5.0.2",
+				"domutils": "^3.0.1",
+				"nth-check": "^2.0.1"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/fb55"
+			}
+		},
+		"node_modules/css-what": {
+			"version": "6.2.2",
+			"resolved": "https://registry.npmjs.org/css-what/-/css-what-6.2.2.tgz",
+			"integrity": "sha512-u/O3vwbptzhMs3L1fQE82ZSLHQQfto5gyZzwteVIEyeaY5Fc7R4dapF/BvRoSYFeqfBk4m0V1Vafq5Pjv25wvA==",
+			"license": "BSD-2-Clause",
+			"engines": {
+				"node": ">= 6"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/fb55"
+			}
+		},
+		"node_modules/csv-stringify": {
+			"version": "6.8.3",
+			"resolved": "https://registry.npmjs.org/csv-stringify/-/csv-stringify-6.8.3.tgz",
+			"integrity": "sha512-gIeSCvq5F4VtXV3naV3VAewLhBkiZBz+PPhTOA8H3Y8h/ELa+R1ml0GZck/4/Nzo9ep2lvOluilJ6MJlbZsKMA==",
+			"license": "MIT"
+		},
+		"node_modules/data-uri-to-buffer": {
+			"version": "6.0.2",
+			"resolved": "https://registry.npmjs.org/data-uri-to-buffer/-/data-uri-to-buffer-6.0.2.tgz",
+			"integrity": "sha512-7hvf7/GW8e86rW0ptuwS3OcBGDjIi6SZva7hCyWC0yYry2cOPmLIjXAUHI6DK2HsnwJd9ifmt57i8eV2n4YNpw==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 14"
+			}
+		},
+		"node_modules/debug": {
+			"version": "4.4.3",
+			"resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
+			"integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+			"license": "MIT",
+			"dependencies": {
+				"ms": "^2.1.3"
+			},
+			"engines": {
+				"node": ">=6.0"
+			},
+			"peerDependenciesMeta": {
+				"supports-color": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/decompress-response": {
+			"version": "10.0.0",
+			"resolved": "https://registry.npmjs.org/decompress-response/-/decompress-response-10.0.0.tgz",
+			"integrity": "sha512-oj7KWToJuuxlPr7VV0vabvxEIiqNMo+q0NueIiL3XhtwC6FVOX7Hr1c0C4eD0bmf7Zr+S/dSf2xvkH3Ad6sU3Q==",
+			"license": "MIT",
+			"dependencies": {
+				"mimic-response": "^4.0.0"
+			},
+			"engines": {
+				"node": ">=20"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/degenerator": {
+			"version": "5.0.1",
+			"resolved": "https://registry.npmjs.org/degenerator/-/degenerator-5.0.1.tgz",
+			"integrity": "sha512-TllpMR/t0M5sqCXfj85i4XaAzxmS5tVA16dqvdkMwGmzI+dXLXnw3J+3Vdv7VKw+ThlTMboK6i9rnZ6Nntj5CQ==",
+			"license": "MIT",
+			"dependencies": {
+				"ast-types": "^0.13.4",
+				"escodegen": "^2.1.0",
+				"esprima": "^4.0.1"
+			},
+			"engines": {
+				"node": ">= 14"
+			}
+		},
+		"node_modules/delayed-stream": {
+			"version": "1.0.0",
+			"resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
+			"integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=0.4.0"
+			}
+		},
+		"node_modules/dom-serializer": {
+			"version": "2.0.0",
+			"resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-2.0.0.tgz",
+			"integrity": "sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg==",
+			"license": "MIT",
+			"dependencies": {
+				"domelementtype": "^2.3.0",
+				"domhandler": "^5.0.2",
+				"entities": "^4.2.0"
+			},
+			"funding": {
+				"url": "https://github.com/cheeriojs/dom-serializer?sponsor=1"
+			}
+		},
+		"node_modules/domelementtype": {
+			"version": "2.3.0",
+			"resolved": "https://registry.npmjs.org/domelementtype/-/domelementtype-2.3.0.tgz",
+			"integrity": "sha512-OLETBj6w0OsagBwdXnPdN0cnMfF9opN69co+7ZrbfPGrdpPVNBUj02spi6B1N7wChLQiPn4CSH/zJvXw56gmHw==",
+			"funding": [
+				{
+					"type": "github",
+					"url": "https://github.com/sponsors/fb55"
+				}
+			],
+			"license": "BSD-2-Clause"
+		},
+		"node_modules/domhandler": {
+			"version": "5.0.3",
+			"resolved": "https://registry.npmjs.org/domhandler/-/domhandler-5.0.3.tgz",
+			"integrity": "sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w==",
+			"license": "BSD-2-Clause",
+			"dependencies": {
+				"domelementtype": "^2.3.0"
+			},
+			"engines": {
+				"node": ">= 4"
+			},
+			"funding": {
+				"url": "https://github.com/fb55/domhandler?sponsor=1"
+			}
+		},
+		"node_modules/domutils": {
+			"version": "3.2.2",
+			"resolved": "https://registry.npmjs.org/domutils/-/domutils-3.2.2.tgz",
+			"integrity": "sha512-6kZKyUajlDuqlHKVX1w7gyslj9MPIXzIFiz/rGu35uC1wMi+kMhQwGhl4lt9unC9Vb9INnY9Z3/ZA3+FhASLaw==",
+			"license": "BSD-2-Clause",
+			"dependencies": {
+				"dom-serializer": "^2.0.0",
+				"domelementtype": "^2.3.0",
+				"domhandler": "^5.0.3"
+			},
+			"funding": {
+				"url": "https://github.com/fb55/domutils?sponsor=1"
+			}
+		},
+		"node_modules/dot-prop": {
+			"version": "6.0.1",
+			"resolved": "https://registry.npmjs.org/dot-prop/-/dot-prop-6.0.1.tgz",
+			"integrity": "sha512-tE7ztYzXHIeyvc7N+hR3oi7FIbf/NIjVP9hmAt3yMXzrQ072/fpjGLx2GxNxGxUl5V73MEqYzioOMoVhGMJ5cA==",
+			"license": "MIT",
+			"dependencies": {
+				"is-obj": "^2.0.0"
+			},
+			"engines": {
+				"node": ">=10"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/dunder-proto": {
+			"version": "1.0.1",
+			"resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
+			"integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
+			"license": "MIT",
+			"dependencies": {
+				"call-bind-apply-helpers": "^1.0.1",
+				"es-errors": "^1.3.0",
+				"gopd": "^1.2.0"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			}
+		},
+		"node_modules/duplexer": {
+			"version": "0.1.2",
+			"resolved": "https://registry.npmjs.org/duplexer/-/duplexer-0.1.2.tgz",
+			"integrity": "sha512-jtD6YG370ZCIi/9GTaJKQxWTZD045+4R4hTk/x1UyoqadyJ9x9CgSi1RlVDQF8U2sxLLSnFkCaMihqljHIWgMg==",
+			"license": "MIT"
+		},
+		"node_modules/electron-to-chromium": {
+			"version": "1.5.438",
+			"resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.438.tgz",
+			"integrity": "sha512-AN9xMU1hJiT65LkCUPL1DZm5TCbOPb2Qsm5pYwFLEXp6/qj9SdT4yMiqs7Qqstwvkn1zF7l36SRGt+s6XcJ0FA==",
+			"license": "ISC"
+		},
+		"node_modules/entities": {
+			"version": "4.5.0",
+			"resolved": "https://registry.npmjs.org/entities/-/entities-4.5.0.tgz",
+			"integrity": "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==",
+			"license": "BSD-2-Clause",
+			"engines": {
+				"node": ">=0.12"
+			},
+			"funding": {
+				"url": "https://github.com/fb55/entities?sponsor=1"
+			}
+		},
+		"node_modules/es-define-property": {
+			"version": "1.0.1",
+			"resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
+			"integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.4"
+			}
+		},
+		"node_modules/es-errors": {
+			"version": "1.3.0",
+			"resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
+			"integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.4"
+			}
+		},
+		"node_modules/es-object-atoms": {
+			"version": "1.1.2",
+			"resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.2.tgz",
+			"integrity": "sha512-HWcBoN6NileqtSydK2FqHbS/LoDd2pqrnQHLyJzBj4kOp/ky2MWMN694xOfkK8/SnUsW2DH7EfyVlydKCsm1Zw==",
+			"license": "MIT",
+			"dependencies": {
+				"es-errors": "^1.3.0"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			}
+		},
+		"node_modules/es-set-tostringtag": {
+			"version": "2.1.0",
+			"resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz",
+			"integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==",
+			"license": "MIT",
+			"dependencies": {
+				"es-errors": "^1.3.0",
+				"get-intrinsic": "^1.2.6",
+				"has-tostringtag": "^1.0.2",
+				"hasown": "^2.0.2"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			}
+		},
+		"node_modules/escalade": {
+			"version": "3.2.0",
+			"resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+			"integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=6"
+			}
+		},
+		"node_modules/escodegen": {
+			"version": "2.1.0",
+			"resolved": "https://registry.npmjs.org/escodegen/-/escodegen-2.1.0.tgz",
+			"integrity": "sha512-2NlIDTwUWJN0mRPQOdtQBzbUHvdGY2P1VXSyU83Q3xKxM7WHX2Ql8dKq782Q9TgQUNOLEzEYu9bzLNj1q88I5w==",
+			"license": "BSD-2-Clause",
+			"dependencies": {
+				"esprima": "^4.0.1",
+				"estraverse": "^5.2.0",
+				"esutils": "^2.0.2"
+			},
+			"bin": {
+				"escodegen": "bin/escodegen.js",
+				"esgenerate": "bin/esgenerate.js"
+			},
+			"engines": {
+				"node": ">=6.0"
+			},
+			"optionalDependencies": {
+				"source-map": "~0.6.1"
+			}
+		},
+		"node_modules/esprima": {
+			"version": "4.0.1",
+			"resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz",
+			"integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==",
+			"license": "BSD-2-Clause",
+			"bin": {
+				"esparse": "bin/esparse.js",
+				"esvalidate": "bin/esvalidate.js"
+			},
+			"engines": {
+				"node": ">=4"
+			}
+		},
+		"node_modules/estraverse": {
+			"version": "5.3.0",
+			"resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz",
+			"integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==",
+			"license": "BSD-2-Clause",
+			"engines": {
+				"node": ">=4.0"
+			}
+		},
+		"node_modules/esutils": {
+			"version": "2.0.3",
+			"resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
+			"integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==",
+			"license": "BSD-2-Clause",
+			"engines": {
+				"node": ">=0.10.0"
+			}
+		},
+		"node_modules/event-stream": {
+			"version": "3.3.4",
+			"resolved": "https://registry.npmjs.org/event-stream/-/event-stream-3.3.4.tgz",
+			"integrity": "sha512-QHpkERcGsR0T7Qm3HNJSyXKEEj8AHNxkY3PK8TS2KJvQ7NiSHe3DDpwVKKtoYprL/AreyzFBeIkBIWChAqn60g==",
+			"license": "MIT",
+			"dependencies": {
+				"duplexer": "~0.1.1",
+				"from": "~0",
+				"map-stream": "~0.1.0",
+				"pause-stream": "0.0.11",
+				"split": "0.3",
+				"stream-combiner": "~0.0.4",
+				"through": "~2.3.1"
+			}
+		},
+		"node_modules/fast-deep-equal": {
+			"version": "3.1.3",
+			"resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
+			"integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
+			"license": "MIT"
+		},
+		"node_modules/file-type": {
+			"version": "21.3.4",
+			"resolved": "https://registry.npmjs.org/file-type/-/file-type-21.3.4.tgz",
+			"integrity": "sha512-Ievi/yy8DS3ygGvT47PjSfdFoX+2isQueoYP1cntFW1JLYAuS4GD7NUPGg4zv2iZfV52uDyk5w5Z0TdpRS6Q1g==",
+			"license": "MIT",
+			"dependencies": {
+				"@tokenizer/inflate": "^0.4.1",
+				"strtok3": "^10.3.4",
+				"token-types": "^6.1.1",
+				"uint8array-extras": "^1.4.0"
+			},
+			"engines": {
+				"node": ">=20"
+			},
+			"funding": {
+				"url": "https://github.com/sindresorhus/file-type?sponsor=1"
+			}
+		},
+		"node_modules/follow-redirects": {
+			"version": "1.16.0",
+			"resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.16.0.tgz",
+			"integrity": "sha512-y5rN/uOsadFT/JfYwhxRS5R7Qce+g3zG97+JrtFZlC9klX/W5hD7iiLzScI4nZqUS7DNUdhPgw4xI8W2LuXlUw==",
+			"funding": [
+				{
+					"type": "individual",
+					"url": "https://github.com/sponsors/RubenVerborgh"
+				}
+			],
+			"license": "MIT",
+			"engines": {
+				"node": ">=4.0"
+			},
+			"peerDependenciesMeta": {
+				"debug": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/form-data": {
+			"version": "4.0.6",
+			"resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.6.tgz",
+			"integrity": "sha512-vKatAh4SlVfgbv+YtmhiRjhEMJsYpsG1Y2rMQtR+SVSbytsSD1YGzDIcrAJmdFec88u/+VoGmxnl+80gL1tRCQ==",
+			"license": "MIT",
+			"dependencies": {
+				"asynckit": "^0.4.0",
+				"combined-stream": "^1.0.8",
+				"es-set-tostringtag": "^2.1.0",
+				"hasown": "^2.0.4",
+				"mime-types": "^2.1.35"
+			},
+			"engines": {
+				"node": ">= 6"
+			}
+		},
+		"node_modules/form-data-encoder": {
+			"version": "4.1.0",
+			"resolved": "https://registry.npmjs.org/form-data-encoder/-/form-data-encoder-4.1.0.tgz",
+			"integrity": "sha512-G6NsmEW15s0Uw9XnCg+33H3ViYRyiM0hMrMhhqQOR8NFc5GhYrI+6I3u7OTw7b91J2g8rtvMBZJDbcGb2YUniw==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 18"
+			}
+		},
+		"node_modules/from": {
+			"version": "0.1.7",
+			"resolved": "https://registry.npmjs.org/from/-/from-0.1.7.tgz",
+			"integrity": "sha512-twe20eF1OxVxp/ML/kq2p1uc6KvFK/+vs8WjEbeKmV2He22MKm7YF2ANIt+EOqhJ5L3K/SuuPhk0hWQDjOM23g==",
+			"license": "MIT"
+		},
+		"node_modules/fs-extra": {
+			"version": "11.4.1",
+			"resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.4.1.tgz",
+			"integrity": "sha512-KYAb4c9BJQI6QqGKthV68OHe0badztdXJWKo0WtBA9IuCFPTKvE5ZdUBglP833aMjhaSPNO4A5j/EkzZtGlKjA==",
+			"license": "MIT",
+			"dependencies": {
+				"graceful-fs": "^4.2.0",
+				"jsonfile": "^6.0.1",
+				"universalify": "^2.0.0"
+			},
+			"engines": {
+				"node": ">=14.14"
+			}
+		},
+		"node_modules/function-bind": {
+			"version": "1.1.2",
+			"resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
+			"integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
+			"license": "MIT",
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/generative-bayesian-network": {
+			"version": "2.1.88",
+			"resolved": "https://registry.npmjs.org/generative-bayesian-network/-/generative-bayesian-network-2.1.88.tgz",
+			"integrity": "sha512-kxbW6CCsiEAVdBYPont/6ZVOa47Pyfv5ldYFIvj8wmOx9uQOZ4c8wdR0jEf2pE6DeVuIAfmolm+91bYne6/3uA==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"adm-zip": "^0.6.0",
+				"tslib": "^2.4.0"
+			}
+		},
+		"node_modules/get-intrinsic": {
+			"version": "1.3.0",
+			"resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
+			"integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
+			"license": "MIT",
+			"dependencies": {
+				"call-bind-apply-helpers": "^1.0.2",
+				"es-define-property": "^1.0.1",
+				"es-errors": "^1.3.0",
+				"es-object-atoms": "^1.1.1",
+				"function-bind": "^1.1.2",
+				"get-proto": "^1.0.1",
+				"gopd": "^1.2.0",
+				"has-symbols": "^1.1.0",
+				"hasown": "^2.0.2",
+				"math-intrinsics": "^1.1.0"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/get-proto": {
+			"version": "1.0.1",
+			"resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
+			"integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
+			"license": "MIT",
+			"dependencies": {
+				"dunder-proto": "^1.0.1",
+				"es-object-atoms": "^1.0.0"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			}
+		},
+		"node_modules/get-stream": {
+			"version": "9.0.1",
+			"resolved": "https://registry.npmjs.org/get-stream/-/get-stream-9.0.1.tgz",
+			"integrity": "sha512-kVCxPF3vQM/N0B1PmoqVUqgHP+EeVjmZSQn+1oCRPxd2P21P2F19lIgbR3HBosbB1PUhOAoctJnfEn2GbN2eZA==",
+			"license": "MIT",
+			"dependencies": {
+				"@sec-ant/readable-stream": "^0.4.1",
+				"is-stream": "^4.0.1"
+			},
+			"engines": {
+				"node": ">=18"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/get-uri": {
+			"version": "6.0.5",
+			"resolved": "https://registry.npmjs.org/get-uri/-/get-uri-6.0.5.tgz",
+			"integrity": "sha512-b1O07XYq8eRuVzBNgJLstU6FYc1tS6wnMtF1I1D9lE8LxZSOGZ7LhxN54yPP6mGw5f2CkXY2BQUL9Fx41qvcIg==",
+			"license": "MIT",
+			"dependencies": {
+				"basic-ftp": "^5.0.2",
+				"data-uri-to-buffer": "^6.0.2",
+				"debug": "^4.3.4"
+			},
+			"engines": {
+				"node": ">= 14"
+			}
+		},
+		"node_modules/gopd": {
+			"version": "1.2.0",
+			"resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
+			"integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/got": {
+			"version": "14.6.6",
+			"resolved": "https://registry.npmjs.org/got/-/got-14.6.6.tgz",
+			"integrity": "sha512-QLV1qeYSo5l13mQzWgP/y0LbMr5Plr5fJilgAIwgnwseproEbtNym8xpLsDzeZ6MWXgNE6kdWGBjdh3zT/Qerg==",
+			"license": "MIT",
+			"dependencies": {
+				"@sindresorhus/is": "^7.0.1",
+				"byte-counter": "^0.1.0",
+				"cacheable-lookup": "^7.0.0",
+				"cacheable-request": "^13.0.12",
+				"decompress-response": "^10.0.0",
+				"form-data-encoder": "^4.0.2",
+				"http2-wrapper": "^2.2.1",
+				"keyv": "^5.5.3",
+				"lowercase-keys": "^3.0.0",
+				"p-cancelable": "^4.0.1",
+				"responselike": "^4.0.2",
+				"type-fest": "^4.26.1"
+			},
+			"engines": {
+				"node": ">=20"
+			},
+			"funding": {
+				"url": "https://github.com/sindresorhus/got?sponsor=1"
+			}
+		},
+		"node_modules/got-scraping": {
+			"version": "4.2.1",
+			"resolved": "https://registry.npmjs.org/got-scraping/-/got-scraping-4.2.1.tgz",
+			"integrity": "sha512-rhOlO1L4H4Cm31smHJqPtAaXOUrhSKsiTrbZSHKFQW1E/mkTDopnHHpRnXJpqzE0faj+zPsVQnyifIqO+K+cLQ==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"got": "^14.2.1",
+				"header-generator": "^2.1.41",
+				"http2-wrapper": "^2.2.0",
+				"mimic-response": "^4.0.0",
+				"ow": "^1.1.1",
+				"quick-lru": "^7.0.0",
+				"tslib": "^2.6.2"
+			},
+			"engines": {
+				"node": ">=16"
+			}
+		},
+		"node_modules/got-scraping/node_modules/@sindresorhus/is": {
+			"version": "5.6.0",
+			"resolved": "https://registry.npmjs.org/@sindresorhus/is/-/is-5.6.0.tgz",
+			"integrity": "sha512-TV7t8GKYaJWsn00tFDqBw8+Uqmr8A0fRU1tvTQhyZzGv0sJCGRQL3JGMI3ucuKo3XIZdUP+Lx7/gh2t3lewy7g==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=14.16"
+			},
+			"funding": {
+				"url": "https://github.com/sindresorhus/is?sponsor=1"
+			}
+		},
+		"node_modules/got-scraping/node_modules/callsites": {
+			"version": "4.2.0",
+			"resolved": "https://registry.npmjs.org/callsites/-/callsites-4.2.0.tgz",
+			"integrity": "sha512-kfzR4zzQtAE9PC7CzZsjl3aBNbXWuXiSeOCdLcPpBfGW8YuCqQHcRPFDbr/BPVmd3EEPVpuFzLyuT/cUhPr4OQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=12.20"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/got-scraping/node_modules/dot-prop": {
+			"version": "7.2.0",
+			"resolved": "https://registry.npmjs.org/dot-prop/-/dot-prop-7.2.0.tgz",
+			"integrity": "sha512-Ol/IPXUARn9CSbkrdV4VJo7uCy1I3VuSiWCaFSg+8BdUOzF9n3jefIpcgAydvUZbTdEBZs2vEiTiS9m61ssiDA==",
+			"license": "MIT",
+			"dependencies": {
+				"type-fest": "^2.11.2"
+			},
+			"engines": {
+				"node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/got-scraping/node_modules/ow": {
+			"version": "1.1.1",
+			"resolved": "https://registry.npmjs.org/ow/-/ow-1.1.1.tgz",
+			"integrity": "sha512-sJBRCbS5vh1Jp9EOgwp1Ws3c16lJrUkJYlvWTYC03oyiYVwS/ns7lKRWow4w4XjDyTrA2pplQv4B2naWSR6yDA==",
+			"license": "MIT",
+			"dependencies": {
+				"@sindresorhus/is": "^5.3.0",
+				"callsites": "^4.0.0",
+				"dot-prop": "^7.2.0",
+				"lodash.isequal": "^4.5.0",
+				"vali-date": "^1.0.0"
+			},
+			"engines": {
+				"node": ">=14.16"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/got-scraping/node_modules/type-fest": {
+			"version": "2.19.0",
+			"resolved": "https://registry.npmjs.org/type-fest/-/type-fest-2.19.0.tgz",
+			"integrity": "sha512-RAH822pAdBgcNMAfWnCBU3CFZcfZ/i1eZjwFU/dsLKumyuuP3niueg2UAukXYF0E2AAoc82ZSSf9J0WQBinzHA==",
+			"license": "(MIT OR CC0-1.0)",
+			"engines": {
+				"node": ">=12.20"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/graceful-fs": {
+			"version": "4.2.11",
+			"resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz",
+			"integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==",
+			"license": "ISC"
+		},
+		"node_modules/has-symbols": {
+			"version": "1.1.0",
+			"resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
+			"integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/has-tostringtag": {
+			"version": "1.0.2",
+			"resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz",
+			"integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==",
+			"license": "MIT",
+			"dependencies": {
+				"has-symbols": "^1.0.3"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/hasown": {
+			"version": "2.0.4",
+			"resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.4.tgz",
+			"integrity": "sha512-T2UbfbBEF32wiepXIsMlTW9+dDYC6wMh/t/vYA4tuOMKqWz/n3vr1NFSxQiyP+zk2mXsoMA/i/7qV6LKut1t1A==",
+			"license": "MIT",
+			"dependencies": {
+				"function-bind": "^1.1.2"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			}
+		},
+		"node_modules/header-generator": {
+			"version": "2.1.88",
+			"resolved": "https://registry.npmjs.org/header-generator/-/header-generator-2.1.88.tgz",
+			"integrity": "sha512-12GkTL1CDaPTQ6gkd8TPwxNtn7t3wSExnWU9qgWfEDh8IqpD1NAVcvzfHphIzULez8WP2DK9YQsDegajjDdTKQ==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"browserslist": "^4.21.1",
+				"generative-bayesian-network": "2.1.88",
+				"ow": "^0.28.1",
+				"tslib": "^2.4.0"
+			},
+			"engines": {
+				"node": ">=16.0.0"
+			}
+		},
+		"node_modules/htmlparser2": {
+			"version": "8.0.2",
+			"resolved": "https://registry.npmjs.org/htmlparser2/-/htmlparser2-8.0.2.tgz",
+			"integrity": "sha512-GYdjWKDkbRLkZ5geuHs5NY1puJ+PXwP7+fHPRz06Eirsb9ugf6d8kkXav6ADhcODhFFPMIXyxkxSuMf3D6NCFA==",
+			"funding": [
+				"https://github.com/fb55/htmlparser2?sponsor=1",
+				{
+					"type": "github",
+					"url": "https://github.com/sponsors/fb55"
+				}
+			],
+			"license": "MIT",
+			"dependencies": {
+				"domelementtype": "^2.3.0",
+				"domhandler": "^5.0.3",
+				"domutils": "^3.0.1",
+				"entities": "^4.4.0"
+			}
+		},
+		"node_modules/http-cache-semantics": {
+			"version": "4.2.0",
+			"resolved": "https://registry.npmjs.org/http-cache-semantics/-/http-cache-semantics-4.2.0.tgz",
+			"integrity": "sha512-dTxcvPXqPvXBQpq5dUr6mEMJX4oIEFv6bwom3FDwKRDsuIjjJGANqhBuoAn9c1RQJIdAKav33ED65E2ys+87QQ==",
+			"license": "BSD-2-Clause"
+		},
+		"node_modules/http-proxy-agent": {
+			"version": "7.0.2",
+			"resolved": "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-7.0.2.tgz",
+			"integrity": "sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==",
+			"license": "MIT",
+			"dependencies": {
+				"agent-base": "^7.1.0",
+				"debug": "^4.3.4"
+			},
+			"engines": {
+				"node": ">= 14"
+			}
+		},
+		"node_modules/http-proxy-agent/node_modules/agent-base": {
+			"version": "7.1.4",
+			"resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz",
+			"integrity": "sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 14"
+			}
+		},
+		"node_modules/http2-wrapper": {
+			"version": "2.2.1",
+			"resolved": "https://registry.npmjs.org/http2-wrapper/-/http2-wrapper-2.2.1.tgz",
+			"integrity": "sha512-V5nVw1PAOgfI3Lmeaj2Exmeg7fenjhRUgz1lPSezy1CuhPYbgQtbQj4jZfEAEMlaL+vupsvhjqCyjzob0yxsmQ==",
+			"license": "MIT",
+			"dependencies": {
+				"quick-lru": "^5.1.1",
+				"resolve-alpn": "^1.2.0"
+			},
+			"engines": {
+				"node": ">=10.19.0"
+			}
+		},
+		"node_modules/http2-wrapper/node_modules/quick-lru": {
+			"version": "5.1.1",
+			"resolved": "https://registry.npmjs.org/quick-lru/-/quick-lru-5.1.1.tgz",
+			"integrity": "sha512-WuyALRjWPDGtt/wzJiadO5AXY+8hZ80hVpe6MyivgraREW751X3SbhRvG3eLKOYN+8VEvqLcf3wdnt44Z4S4SA==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=10"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/https-proxy-agent": {
+			"version": "5.0.1",
+			"resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-5.0.1.tgz",
+			"integrity": "sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==",
+			"license": "MIT",
+			"dependencies": {
+				"agent-base": "6",
+				"debug": "4"
+			},
+			"engines": {
+				"node": ">= 6"
+			}
+		},
+		"node_modules/ieee754": {
+			"version": "1.2.1",
+			"resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz",
+			"integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==",
+			"funding": [
+				{
+					"type": "github",
+					"url": "https://github.com/sponsors/feross"
+				},
+				{
+					"type": "patreon",
+					"url": "https://www.patreon.com/feross"
+				},
+				{
+					"type": "consulting",
+					"url": "https://feross.org/support"
+				}
+			],
+			"license": "BSD-3-Clause"
+		},
+		"node_modules/ip-address": {
+			"version": "10.7.2",
+			"resolved": "https://registry.npmjs.org/ip-address/-/ip-address-10.7.2.tgz",
+			"integrity": "sha512-7H/2gFSIitxc0hG3nOI1glS8QLo/EHBFFLk8vEUjXY/xu0AdL8jZ9U1IzO2PUm0d2D/ofQcAifb0g6OBkt8U7w==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 12"
+			}
+		},
+		"node_modules/is-obj": {
+			"version": "2.0.0",
+			"resolved": "https://registry.npmjs.org/is-obj/-/is-obj-2.0.0.tgz",
+			"integrity": "sha512-drqDG3cbczxxEJRoOXcOjtdp1J/lyp1mNn0xaznRs8+muBhgQcrnbspox5X5fOw0HnMnbfDzvnEMEtqDEJEo8w==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=8"
+			}
+		},
+		"node_modules/is-stream": {
+			"version": "4.0.1",
+			"resolved": "https://registry.npmjs.org/is-stream/-/is-stream-4.0.1.tgz",
+			"integrity": "sha512-Dnz92NInDqYckGEUJv689RbRiTSEHCQ7wOVeALbkOz999YpqT46yMRIGtSNl2iCL1waAZSx40+h59NV/EwzV/A==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=18"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/json5": {
+			"version": "2.2.3",
+			"resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz",
+			"integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==",
+			"license": "MIT",
+			"bin": {
+				"json5": "lib/cli.js"
+			},
+			"engines": {
+				"node": ">=6"
+			}
+		},
+		"node_modules/jsonfile": {
+			"version": "6.2.1",
+			"resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.1.tgz",
+			"integrity": "sha512-zwOTdL3rFQ/lRdBnntKVOX6k5cKJwEc1HdilT71BWEu7J41gXIB2MRp+vxduPSwZJPWBxEzv4yH1wYLJGUHX4Q==",
+			"license": "MIT",
+			"dependencies": {
+				"universalify": "^2.0.0"
+			},
+			"optionalDependencies": {
+				"graceful-fs": "^4.1.6"
+			}
+		},
+		"node_modules/keyv": {
+			"version": "5.6.0",
+			"resolved": "https://registry.npmjs.org/keyv/-/keyv-5.6.0.tgz",
+			"integrity": "sha512-CYDD3SOtsHtyXeEORYRx2qBtpDJFjRTGXUtmNEMGyzYOKj1TE3tycdlho7kA1Ufx9OYWZzg52QFBGALTirzDSw==",
+			"license": "MIT",
+			"dependencies": {
+				"@keyv/serialize": "^1.1.1"
+			}
+		},
+		"node_modules/lodash": {
+			"version": "4.18.1",
+			"resolved": "https://registry.npmjs.org/lodash/-/lodash-4.18.1.tgz",
+			"integrity": "sha512-dMInicTPVE8d1e5otfwmmjlxkZoUpiVLwyeTdUsi/Caj/gfzzblBcCE5sRHV/AsjuCmxWrte2TNGSYuCeCq+0Q==",
+			"license": "MIT"
+		},
+		"node_modules/lodash.isequal": {
+			"version": "4.5.0",
+			"resolved": "https://registry.npmjs.org/lodash.isequal/-/lodash.isequal-4.5.0.tgz",
+			"integrity": "sha512-pDo3lu8Jhfjqls6GkMgpahsF9kCyayhgykjyLMNFTKWrpVdAQtYyB4muAMWozBB4ig/dtWAmsMxLEI8wuz+DYQ==",
+			"deprecated": "This package is deprecated. Use require('node:util').isDeepStrictEqual instead.",
+			"license": "MIT"
+		},
+		"node_modules/lowercase-keys": {
+			"version": "3.0.0",
+			"resolved": "https://registry.npmjs.org/lowercase-keys/-/lowercase-keys-3.0.0.tgz",
+			"integrity": "sha512-ozCC6gdQ+glXOQsveKD0YsDy8DSQFjDTz4zyzEHNV5+JP5D62LmfDZ6o1cycFx9ouG940M5dE8C8CTewdj2YWQ==",
+			"license": "MIT",
+			"engines": {
+				"node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/lru-cache": {
+			"version": "7.18.3",
+			"resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-7.18.3.tgz",
+			"integrity": "sha512-jumlc0BIUrS3qJGgIkWZsyfAM7NCWiBcCDhnd+3NNM5KbBmLTgHVfWBcg6W+rLUsIpzpERPsvwUP7CckAQSOoA==",
+			"license": "ISC",
+			"engines": {
+				"node": ">=12"
+			}
+		},
+		"node_modules/map-stream": {
+			"version": "0.1.0",
+			"resolved": "https://registry.npmjs.org/map-stream/-/map-stream-0.1.0.tgz",
+			"integrity": "sha512-CkYQrPYZfWnu/DAmVCpTSX/xHpKZ80eKh2lAkyA6AJTef6bW+6JpbQZN5rofum7da+SyN1bi5ctTm+lTfcCW3g=="
+		},
+		"node_modules/math-intrinsics": {
+			"version": "1.1.0",
+			"resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
+			"integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.4"
+			}
+		},
+		"node_modules/mime-db": {
+			"version": "1.52.0",
+			"resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
+			"integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.6"
+			}
+		},
+		"node_modules/mime-types": {
+			"version": "2.1.35",
+			"resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",
+			"integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
+			"license": "MIT",
+			"dependencies": {
+				"mime-db": "1.52.0"
+			},
+			"engines": {
+				"node": ">= 0.6"
+			}
+		},
+		"node_modules/mimic-response": {
+			"version": "4.0.0",
+			"resolved": "https://registry.npmjs.org/mimic-response/-/mimic-response-4.0.0.tgz",
+			"integrity": "sha512-e5ISH9xMYU0DzrT+jl8q2ze9D6eWBto+I8CNpe+VI+K2J/F/k3PdkdTdz4wvGVH4NTpo+NRYTVIuMQEMMcsLqg==",
+			"license": "MIT",
+			"engines": {
+				"node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/minimatch": {
+			"version": "9.0.9",
+			"resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.9.tgz",
+			"integrity": "sha512-OBwBN9AL4dqmETlpS2zasx+vTeWclWzkblfZk7KTA5j3jeOONz/tRCnZomUyvNg83wL5Zv9Ss6HMJXAgL8R2Yg==",
+			"license": "ISC",
+			"dependencies": {
+				"brace-expansion": "^2.0.2"
+			},
+			"engines": {
+				"node": ">=16 || 14 >=14.17"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/isaacs"
+			}
+		},
+		"node_modules/ms": {
+			"version": "2.1.3",
+			"resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+			"integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+			"license": "MIT"
+		},
+		"node_modules/netmask": {
+			"version": "2.1.1",
+			"resolved": "https://registry.npmjs.org/netmask/-/netmask-2.1.1.tgz",
+			"integrity": "sha512-eonl3sLUha+S1GzTPxychyhnUzKyeQkZ7jLjKrBagJgPla13F+uQ71HgpFefyHgqrjEbCPkDArxYsjY8/+gLKA==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.4.0"
+			}
+		},
+		"node_modules/node-releases": {
+			"version": "2.0.57",
+			"resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.57.tgz",
+			"integrity": "sha512-kQK9LGGFiHtrWiNhZtA7Qbw17AQz+dmsEKODRIVTXA9+e5MS/2gZEBhYJt13GrAz5/IOZKddH/0Z3TP/Zgo+yw==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=18"
+			}
+		},
+		"node_modules/normalize-url": {
+			"version": "8.1.1",
+			"resolved": "https://registry.npmjs.org/normalize-url/-/normalize-url-8.1.1.tgz",
+			"integrity": "sha512-JYc0DPlpGWB40kH5g07gGTrYuMqV653k3uBKY6uITPWds3M0ov3GaWGp9lbE3Bzngx8+XkfzgvASb9vk9JDFXQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=14.16"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/nth-check": {
+			"version": "2.1.1",
+			"resolved": "https://registry.npmjs.org/nth-check/-/nth-check-2.1.1.tgz",
+			"integrity": "sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w==",
+			"license": "BSD-2-Clause",
+			"dependencies": {
+				"boolbase": "^1.0.0"
+			},
+			"funding": {
+				"url": "https://github.com/fb55/nth-check?sponsor=1"
+			}
+		},
+		"node_modules/ow": {
+			"version": "0.28.2",
+			"resolved": "https://registry.npmjs.org/ow/-/ow-0.28.2.tgz",
+			"integrity": "sha512-dD4UpyBh/9m4X2NVjA+73/ZPBRF+uF4zIMFvvQsabMiEK8x41L3rQ8EENOi35kyyoaJwNxEeJcP6Fj1H4U409Q==",
+			"license": "MIT",
+			"dependencies": {
+				"@sindresorhus/is": "^4.2.0",
+				"callsites": "^3.1.0",
+				"dot-prop": "^6.0.1",
+				"lodash.isequal": "^4.5.0",
+				"vali-date": "^1.0.0"
+			},
+			"engines": {
+				"node": ">=12"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/ow/node_modules/@sindresorhus/is": {
+			"version": "4.6.0",
+			"resolved": "https://registry.npmjs.org/@sindresorhus/is/-/is-4.6.0.tgz",
+			"integrity": "sha512-t09vSN3MdfsyCHoFcTRCH/iUtG7OJ0CsjzB8cjAmKc/va/kIgeDI/TxsigdncE/4be734m0cvIYwNaV4i2XqAw==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=10"
+			},
+			"funding": {
+				"url": "https://github.com/sindresorhus/is?sponsor=1"
+			}
+		},
+		"node_modules/p-cancelable": {
+			"version": "4.0.1",
+			"resolved": "https://registry.npmjs.org/p-cancelable/-/p-cancelable-4.0.1.tgz",
+			"integrity": "sha512-wBowNApzd45EIKdO1LaU+LrMBwAcjfPaYtVzV3lmfM3gf8Z4CHZsiIqlM8TZZ8okYvh5A1cP6gTfCRQtwUpaUg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=14.16"
+			}
+		},
+		"node_modules/p-limit": {
+			"version": "3.1.0",
+			"resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz",
+			"integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==",
+			"license": "MIT",
+			"dependencies": {
+				"yocto-queue": "^0.1.0"
+			},
+			"engines": {
+				"node": ">=10"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/pac-proxy-agent": {
+			"version": "7.2.0",
+			"resolved": "https://registry.npmjs.org/pac-proxy-agent/-/pac-proxy-agent-7.2.0.tgz",
+			"integrity": "sha512-TEB8ESquiLMc0lV8vcd5Ql/JAKAoyzHFXaStwjkzpOpC5Yv+pIzLfHvjTSdf3vpa2bMiUQrg9i6276yn8666aA==",
+			"license": "MIT",
+			"dependencies": {
+				"@tootallnate/quickjs-emscripten": "^0.23.0",
+				"agent-base": "^7.1.2",
+				"debug": "^4.3.4",
+				"get-uri": "^6.0.1",
+				"http-proxy-agent": "^7.0.0",
+				"https-proxy-agent": "^7.0.6",
+				"pac-resolver": "^7.0.1",
+				"socks-proxy-agent": "^8.0.5"
+			},
+			"engines": {
+				"node": ">= 14"
+			}
+		},
+		"node_modules/pac-proxy-agent/node_modules/agent-base": {
+			"version": "7.1.4",
+			"resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz",
+			"integrity": "sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 14"
+			}
+		},
+		"node_modules/pac-proxy-agent/node_modules/https-proxy-agent": {
+			"version": "7.0.6",
+			"resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz",
+			"integrity": "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==",
+			"license": "MIT",
+			"dependencies": {
+				"agent-base": "^7.1.2",
+				"debug": "4"
+			},
+			"engines": {
+				"node": ">= 14"
+			}
+		},
+		"node_modules/pac-resolver": {
+			"version": "7.0.1",
+			"resolved": "https://registry.npmjs.org/pac-resolver/-/pac-resolver-7.0.1.tgz",
+			"integrity": "sha512-5NPgf87AT2STgwa2ntRMr45jTKrYBGkVU36yT0ig/n/GMAa3oPqhZfIQ2kMEimReg0+t9kZViDVZ83qfVUlckg==",
+			"license": "MIT",
+			"dependencies": {
+				"degenerator": "^5.0.0",
+				"netmask": "^2.0.2"
+			},
+			"engines": {
+				"node": ">= 14"
+			}
+		},
+		"node_modules/parse5": {
+			"version": "7.3.0",
+			"resolved": "https://registry.npmjs.org/parse5/-/parse5-7.3.0.tgz",
+			"integrity": "sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw==",
+			"license": "MIT",
+			"dependencies": {
+				"entities": "^6.0.0"
+			},
+			"funding": {
+				"url": "https://github.com/inikulin/parse5?sponsor=1"
+			}
+		},
+		"node_modules/parse5-htmlparser2-tree-adapter": {
+			"version": "7.1.0",
+			"resolved": "https://registry.npmjs.org/parse5-htmlparser2-tree-adapter/-/parse5-htmlparser2-tree-adapter-7.1.0.tgz",
+			"integrity": "sha512-ruw5xyKs6lrpo9x9rCZqZZnIUntICjQAd0Wsmp396Ul9lN/h+ifgVV1x1gZHi8euej6wTfpqX8j+BFQxF0NS/g==",
+			"license": "MIT",
+			"dependencies": {
+				"domhandler": "^5.0.3",
+				"parse5": "^7.0.0"
+			},
+			"funding": {
+				"url": "https://github.com/inikulin/parse5?sponsor=1"
+			}
+		},
+		"node_modules/parse5/node_modules/entities": {
+			"version": "6.0.1",
+			"resolved": "https://registry.npmjs.org/entities/-/entities-6.0.1.tgz",
+			"integrity": "sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g==",
+			"license": "BSD-2-Clause",
+			"engines": {
+				"node": ">=0.12"
+			},
+			"funding": {
+				"url": "https://github.com/fb55/entities?sponsor=1"
+			}
+		},
+		"node_modules/pause-stream": {
+			"version": "0.0.11",
+			"resolved": "https://registry.npmjs.org/pause-stream/-/pause-stream-0.0.11.tgz",
+			"integrity": "sha512-e3FBlXLmN/D1S+zHzanP4E/4Z60oFAa3O051qt1pxa7DEJWKAyil6upYVXCWadEnuoqa4Pkc9oUx9zsxYeRv8A==",
+			"license": [
+				"MIT",
+				"Apache2"
+			],
+			"dependencies": {
+				"through": "~2.3"
+			}
+		},
+		"node_modules/picocolors": {
+			"version": "1.1.1",
+			"resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+			"integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+			"license": "ISC"
+		},
+		"node_modules/proper-lockfile": {
+			"version": "4.1.2",
+			"resolved": "https://registry.npmjs.org/proper-lockfile/-/proper-lockfile-4.1.2.tgz",
+			"integrity": "sha512-TjNPblN4BwAWMXU8s9AEz4JmQxnD1NNL7bNOY/AKUzyamc379FWASUhc/K1pL2noVb+XmZKLL68cjzLsiOAMaA==",
+			"license": "MIT",
+			"dependencies": {
+				"graceful-fs": "^4.2.4",
+				"retry": "^0.12.0",
+				"signal-exit": "^3.0.2"
+			}
+		},
+		"node_modules/proper-lockfile/node_modules/retry": {
+			"version": "0.12.0",
+			"resolved": "https://registry.npmjs.org/retry/-/retry-0.12.0.tgz",
+			"integrity": "sha512-9LkiTwjUh6rT555DtE9rTX+BKByPfrMzEAtnlEtdEwr3Nkffwiihqe2bWADg+OQRjt9gl6ICdmB/ZFDCGAtSow==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 4"
+			}
+		},
+		"node_modules/proxy-agent": {
+			"version": "6.5.0",
+			"resolved": "https://registry.npmjs.org/proxy-agent/-/proxy-agent-6.5.0.tgz",
+			"integrity": "sha512-TmatMXdr2KlRiA2CyDu8GqR8EjahTG3aY3nXjdzFyoZbmB8hrBsTyMezhULIXKnC0jpfjlmiZ3+EaCzoInSu/A==",
+			"license": "MIT",
+			"dependencies": {
+				"agent-base": "^7.1.2",
+				"debug": "^4.3.4",
+				"http-proxy-agent": "^7.0.1",
+				"https-proxy-agent": "^7.0.6",
+				"lru-cache": "^7.14.1",
+				"pac-proxy-agent": "^7.1.0",
+				"proxy-from-env": "^1.1.0",
+				"socks-proxy-agent": "^8.0.5"
+			},
+			"engines": {
+				"node": ">= 14"
+			}
+		},
+		"node_modules/proxy-agent/node_modules/agent-base": {
+			"version": "7.1.4",
+			"resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz",
+			"integrity": "sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 14"
+			}
+		},
+		"node_modules/proxy-agent/node_modules/https-proxy-agent": {
+			"version": "7.0.6",
+			"resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz",
+			"integrity": "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==",
+			"license": "MIT",
+			"dependencies": {
+				"agent-base": "^7.1.2",
+				"debug": "4"
+			},
+			"engines": {
+				"node": ">= 14"
+			}
+		},
+		"node_modules/proxy-agent/node_modules/proxy-from-env": {
+			"version": "1.1.0",
+			"resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz",
+			"integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==",
+			"license": "MIT"
+		},
+		"node_modules/proxy-from-env": {
+			"version": "2.1.0",
+			"resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-2.1.0.tgz",
+			"integrity": "sha512-cJ+oHTW1VAEa8cJslgmUZrc+sjRKgAKl3Zyse6+PV38hZe/V6Z14TbCuXcan9F9ghlz4QrFr2c92TNF82UkYHA==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=10"
+			}
+		},
+		"node_modules/quick-lru": {
+			"version": "7.3.0",
+			"resolved": "https://registry.npmjs.org/quick-lru/-/quick-lru-7.3.0.tgz",
+			"integrity": "sha512-k9lSsjl36EJdK7I06v7APZCbyGT2vMTsYSRX1Q2nbYmnkBqgUhRkAuzH08Ciotteu/PLJmIF2+tti7o3C/ts2g==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=18"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/resolve-alpn": {
+			"version": "1.2.1",
+			"resolved": "https://registry.npmjs.org/resolve-alpn/-/resolve-alpn-1.2.1.tgz",
+			"integrity": "sha512-0a1F4l73/ZFZOakJnQ3FvkJ2+gSTQWz/r2KE5OdDY0TxPm5h4GkqkWWfM47T7HsbnOtcJVEF4epCVy6u7Q3K+g==",
+			"license": "MIT"
+		},
+		"node_modules/responselike": {
+			"version": "4.0.2",
+			"resolved": "https://registry.npmjs.org/responselike/-/responselike-4.0.2.tgz",
+			"integrity": "sha512-cGk8IbWEAnaCpdAt1BHzJ3Ahz5ewDJa0KseTsE3qIRMJ3C698W8psM7byCeWVpd/Ha7FUYzuRVzXoKoM6nRUbA==",
+			"license": "MIT",
+			"dependencies": {
+				"lowercase-keys": "^3.0.0"
+			},
+			"engines": {
+				"node": ">=20"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/retry": {
+			"version": "0.13.1",
+			"resolved": "https://registry.npmjs.org/retry/-/retry-0.13.1.tgz",
+			"integrity": "sha512-XQBQ3I8W1Cge0Seh+6gjj03LbmRFWuoszgK9ooCpwYIrhhoO80pfq4cUkU5DkknwfOfFteRwlZ56PYOGYyFWdg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 4"
+			}
+		},
+		"node_modules/robots-parser": {
+			"version": "3.0.1",
+			"resolved": "https://registry.npmjs.org/robots-parser/-/robots-parser-3.0.1.tgz",
+			"integrity": "sha512-s+pyvQeIKIZ0dx5iJiQk1tPLJAWln39+MI5jtM8wnyws+G5azk+dMnMX0qfbqNetKKNgcWWOdi0sfm+FbQbgdQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=10.0.0"
+			}
+		},
+		"node_modules/sax": {
+			"version": "1.6.1",
+			"resolved": "https://registry.npmjs.org/sax/-/sax-1.6.1.tgz",
+			"integrity": "sha512-42tBVwLWnaQvW5zc4HbZrTuWccECCZfBi92FDuwtqxasH+JbPB3/FOKb1m222K42R4WxuxzzMsTswfzgtSu64Q==",
+			"license": "BlueOak-1.0.0",
+			"engines": {
+				"node": ">=11.0.0"
+			}
+		},
+		"node_modules/semver": {
+			"version": "7.8.5",
+			"resolved": "https://registry.npmjs.org/semver/-/semver-7.8.5.tgz",
+			"integrity": "sha512-Y7/KDsb8LjooZpwaqGyulO6DQlksgCncchHGk+sZIY4SBvUocMBEFH5Ur1fI4dV+Jvl0w6cjvucaIi40puRioA==",
+			"license": "ISC",
+			"bin": {
+				"semver": "bin/semver.js"
+			},
+			"engines": {
+				"node": ">=10"
+			}
+		},
+		"node_modules/signal-exit": {
+			"version": "3.0.7",
+			"resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz",
+			"integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==",
+			"license": "ISC"
+		},
+		"node_modules/smart-buffer": {
+			"version": "4.2.0",
+			"resolved": "https://registry.npmjs.org/smart-buffer/-/smart-buffer-4.2.0.tgz",
+			"integrity": "sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 6.0.0",
+				"npm": ">= 3.0.0"
+			}
+		},
+		"node_modules/socks": {
+			"version": "2.8.10",
+			"resolved": "https://registry.npmjs.org/socks/-/socks-2.8.10.tgz",
+			"integrity": "sha512-e0VyvkVTwVYViNovRkZ9aodhxVlyoMn7eJhVUPxZ+eK9P/7CBkxvvsBOHqFPEH416726W8tLXXXjKwqgTErrCQ==",
+			"license": "MIT",
+			"dependencies": {
+				"ip-address": "^10.1.1",
+				"smart-buffer": "^4.2.0"
+			},
+			"engines": {
+				"node": ">= 10.0.0",
+				"npm": ">= 3.0.0"
+			}
+		},
+		"node_modules/socks-proxy-agent": {
+			"version": "8.0.5",
+			"resolved": "https://registry.npmjs.org/socks-proxy-agent/-/socks-proxy-agent-8.0.5.tgz",
+			"integrity": "sha512-HehCEsotFqbPW9sJ8WVYB6UbmIMv7kUUORIF2Nncq4VQvBfNBLibW9YZR5dlYCSUhwcD628pRllm7n+E+YTzJw==",
+			"license": "MIT",
+			"dependencies": {
+				"agent-base": "^7.1.2",
+				"debug": "^4.3.4",
+				"socks": "^2.8.3"
+			},
+			"engines": {
+				"node": ">= 14"
+			}
+		},
+		"node_modules/socks-proxy-agent/node_modules/agent-base": {
+			"version": "7.1.4",
+			"resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz",
+			"integrity": "sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 14"
+			}
+		},
+		"node_modules/source-map": {
+			"version": "0.6.1",
+			"resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
+			"integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
+			"license": "BSD-3-Clause",
+			"optional": true,
+			"engines": {
+				"node": ">=0.10.0"
+			}
+		},
+		"node_modules/split": {
+			"version": "0.3.3",
+			"resolved": "https://registry.npmjs.org/split/-/split-0.3.3.tgz",
+			"integrity": "sha512-wD2AeVmxXRBoX44wAycgjVpMhvbwdI2aZjCkvfNcH1YqHQvJVa1duWc73OyVGJUc05fhFaTZeQ/PYsrmyH0JVA==",
+			"license": "MIT",
+			"dependencies": {
+				"through": "2"
+			},
+			"engines": {
+				"node": "*"
+			}
+		},
+		"node_modules/stream-chain": {
+			"version": "2.2.5",
+			"resolved": "https://registry.npmjs.org/stream-chain/-/stream-chain-2.2.5.tgz",
+			"integrity": "sha512-1TJmBx6aSWqZ4tx7aTpBDXK0/e2hhcNSTV8+CbFJtDjbb+I1mZ8lHit0Grw9GRT+6JbIrrDd8esncgBi8aBXGA==",
+			"license": "BSD-3-Clause"
+		},
+		"node_modules/stream-combiner": {
+			"version": "0.0.4",
+			"resolved": "https://registry.npmjs.org/stream-combiner/-/stream-combiner-0.0.4.tgz",
+			"integrity": "sha512-rT00SPnTVyRsaSz5zgSPma/aHSOic5U1prhYdRy5HS2kTZviFpmDgzilbtsJsxiroqACmayynDN/9VzIbX5DOw==",
+			"license": "MIT",
+			"dependencies": {
+				"duplexer": "~0.1.1"
+			}
+		},
+		"node_modules/stream-json": {
+			"version": "1.9.1",
+			"resolved": "https://registry.npmjs.org/stream-json/-/stream-json-1.9.1.tgz",
+			"integrity": "sha512-uWkjJ+2Nt/LO9Z/JyKZbMusL8Dkh97uUBTv3AJQ74y07lVahLY4eEFsPsE97pxYBwr8nnjMAIch5eqI0gPShyw==",
+			"license": "BSD-3-Clause",
+			"dependencies": {
+				"stream-chain": "^2.2.5"
+			}
+		},
+		"node_modules/strtok3": {
+			"version": "10.3.5",
+			"resolved": "https://registry.npmjs.org/strtok3/-/strtok3-10.3.5.tgz",
+			"integrity": "sha512-ki4hZQfh5rX0QDLLkOCj+h+CVNkqmp/CMf8v8kZpkNVK6jGQooMytqzLZYUVYIZcFZ6yDB70EfD8POcFXiF5oA==",
+			"license": "MIT",
+			"dependencies": {
+				"@tokenizer/token": "^0.3.0"
+			},
+			"engines": {
+				"node": ">=18"
+			},
+			"funding": {
+				"type": "github",
+				"url": "https://github.com/sponsors/Borewit"
+			}
+		},
+		"node_modules/through": {
+			"version": "2.3.8",
+			"resolved": "https://registry.npmjs.org/through/-/through-2.3.8.tgz",
+			"integrity": "sha512-w89qg7PI8wAdvX60bMDP+bFoD5Dvhm9oLheFp5O4a2QF0cSBGsBX4qZmadPMvVqlLJBBci+WqGGOAPvcDeNSVg==",
+			"license": "MIT"
+		},
+		"node_modules/tldts": {
+			"version": "7.4.15",
+			"resolved": "https://registry.npmjs.org/tldts/-/tldts-7.4.15.tgz",
+			"integrity": "sha512-SJVBeHOxDbNoq14CvpAoA2mLEWdbldGK8nR+yumpjY5nrlZxOflcA7p1Qj1gbTGmbu9DY9qLj/bENSWhBzjxRQ==",
+			"license": "MIT",
+			"dependencies": {
+				"tldts-core": "^7.4.15"
+			},
+			"bin": {
+				"tldts": "bin/cli.js"
+			}
+		},
+		"node_modules/tldts-core": {
+			"version": "7.4.15",
+			"resolved": "https://registry.npmjs.org/tldts-core/-/tldts-core-7.4.15.tgz",
+			"integrity": "sha512-ERuv0p98XgSzmlSLJr8vDNxX+uATGInlN97V3R+JpYWaSqn5IG3ewWgCwczk4bkOpgth/o8Nt5FOi4B4w0n/1A==",
+			"license": "MIT"
+		},
+		"node_modules/token-types": {
+			"version": "6.1.2",
+			"resolved": "https://registry.npmjs.org/token-types/-/token-types-6.1.2.tgz",
+			"integrity": "sha512-dRXchy+C0IgK8WPC6xvCHFRIWYUbqqdEIKPaKo/AcTUNzwLTK6AH7RjdLWsEZcAN/TBdtfUw3PYEgPr5VPr6ww==",
+			"license": "MIT",
+			"dependencies": {
+				"@borewit/text-codec": "^0.2.1",
+				"@tokenizer/token": "^0.3.0",
+				"ieee754": "^1.2.1"
+			},
+			"engines": {
+				"node": ">=14.16"
+			},
+			"funding": {
+				"type": "github",
+				"url": "https://github.com/sponsors/Borewit"
+			}
+		},
+		"node_modules/tough-cookie": {
+			"version": "6.0.2",
+			"resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-6.0.2.tgz",
+			"integrity": "sha512-exgYmnmL/sJpR3upZfXG5PoatXQii55xAiXGXzY+sROLZ/Y+SLcp9PgJNI9Vz37HpQ74WvDcLT8eqm+kV3FzrA==",
+			"license": "BSD-3-Clause",
+			"dependencies": {
+				"tldts": "^7.0.5"
+			},
+			"engines": {
+				"node": ">=16"
+			}
+		},
+		"node_modules/tslib": {
+			"version": "2.8.1",
+			"resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+			"integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+			"license": "0BSD"
+		},
+		"node_modules/type-fest": {
+			"version": "4.41.0",
+			"resolved": "https://registry.npmjs.org/type-fest/-/type-fest-4.41.0.tgz",
+			"integrity": "sha512-TeTSQ6H5YHvpqVwBRcnLDCBnDOHWYu7IvGbHT6N8AOymcr9PJGjc1GTtiWZTYg0NCgYwvnYWEkVChQAr9bjfwA==",
+			"license": "(MIT OR CC0-1.0)",
+			"engines": {
+				"node": ">=16"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/typescript": {
+			"version": "6.0.3",
+			"resolved": "https://registry.npmjs.org/typescript/-/typescript-6.0.3.tgz",
+			"integrity": "sha512-y2TvuxSZPDyQakkFRPZHKFm+KKVqIisdg9/CZwm9ftvKXLP8NRWj38/ODjNbr43SsoXqNuAisEf1GdCxqWcdBw==",
+			"dev": true,
+			"license": "Apache-2.0",
+			"bin": {
+				"tsc": "bin/tsc",
+				"tsserver": "bin/tsserver"
+			},
+			"engines": {
+				"node": ">=14.17"
+			}
+		},
+		"node_modules/uint8array-extras": {
+			"version": "1.5.0",
+			"resolved": "https://registry.npmjs.org/uint8array-extras/-/uint8array-extras-1.5.0.tgz",
+			"integrity": "sha512-rvKSBiC5zqCCiDZ9kAOszZcDvdAHwwIKJG33Ykj43OKcWsnmcBRL09YTU4nOeHZ8Y2a7l1MgTd08SBe9A8Qj6A==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=18"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/undici-types": {
+			"version": "7.18.2",
+			"resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.18.2.tgz",
+			"integrity": "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w==",
+			"license": "MIT"
+		},
+		"node_modules/universalify": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+			"integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 10.0.0"
+			}
+		},
+		"node_modules/update-browserslist-db": {
+			"version": "1.3.3",
+			"resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.3.3.tgz",
+			"integrity": "sha512-pJ2sYawQS0R/WI928Gj5GlPhTGzbMelq0+4INtSYNDV9ErKJcX6xjGWkoG/VnB3dpUm00zALaqkrUD77pO5TDQ==",
+			"funding": [
+				{
+					"type": "opencollective",
+					"url": "https://opencollective.com/browserslist"
+				},
+				{
+					"type": "tidelift",
+					"url": "https://tidelift.com/funding/github/npm/browserslist"
+				},
+				{
+					"type": "github",
+					"url": "https://github.com/sponsors/ai"
+				}
+			],
+			"license": "MIT",
+			"dependencies": {
+				"escalade": "^3.2.0",
+				"picocolors": "^1.1.1"
+			},
+			"bin": {
+				"update-browserslist-db": "cli.js"
+			},
+			"peerDependencies": {
+				"browserslist": ">= 4.21.0"
+			}
+		},
+		"node_modules/vali-date": {
+			"version": "1.0.0",
+			"resolved": "https://registry.npmjs.org/vali-date/-/vali-date-1.0.0.tgz",
+			"integrity": "sha512-sgECfZthyaCKW10N0fm27cg8HYTFK5qMWgypqkXMQ4Wbl/zZKx7xZICgcoxIIE+WFAP/MBL2EFwC/YvLxw3Zeg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=0.10.0"
+			}
+		},
+		"node_modules/whatwg-mimetype": {
+			"version": "4.0.0",
+			"resolved": "https://registry.npmjs.org/whatwg-mimetype/-/whatwg-mimetype-4.0.0.tgz",
+			"integrity": "sha512-QaKxh0eNIi2mE9p2vEdzfagOKHCcj1pJ56EEHGQOVxp8r9/iszLUUV7v89x9O1p/T+NlTM5W7jW6+cz4Fq1YVg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=18"
+			}
+		},
+		"node_modules/ws": {
+			"version": "8.21.3",
+			"resolved": "https://registry.npmjs.org/ws/-/ws-8.21.3.tgz",
+			"integrity": "sha512-201TZ/kPWxoPr/OKWjquZR1SWKXcvxdH+e1xrx89b3YbmzLMFCLfnaG1HFIgWzJOEWZ7MvpK++odZufgYR50Rw==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=10.0.0"
+			},
+			"peerDependencies": {
+				"bufferutil": "^4.0.1",
+				"utf-8-validate": ">=5.0.2"
+			},
+			"peerDependenciesMeta": {
+				"bufferutil": {
+					"optional": true
+				},
+				"utf-8-validate": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/yocto-queue": {
+			"version": "0.1.0",
+			"resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz",
+			"integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=10"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		}
+	}
+}
diff --git a/sample_actor_standby_ts/package.json b/sample_actor_standby_ts/package.json
new file mode 100644
index 00000000..48069a3e
--- /dev/null
+++ b/sample_actor_standby_ts/package.json
@@ -0,0 +1,24 @@
+{
+	"name": "my-standby-actor-ts",
+	"version": "0.0.1",
+	"type": "module",
+	"description": "A TypeScript Actor Standby server for actor-runtime.",
+	"engines": {
+		"node": ">=18.0.0"
+	},
+	"dependencies": {
+		"apify": "^3.7.0",
+		"ws": "^8.18.0"
+	},
+	"devDependencies": {
+		"@apify/tsconfig": "^0.2.0",
+		"@types/node": "^24.0.0",
+		"@types/ws": "^8.18.1",
+		"typescript": "^6.0.0"
+	},
+	"scripts": {
+		"start": "node dist/main.js",
+		"build": "tsc"
+	},
+	"license": "ISC"
+}
diff --git a/sample_actor_standby_ts/src/main.ts b/sample_actor_standby_ts/src/main.ts
new file mode 100644
index 00000000..dc11ece2
--- /dev/null
+++ b/sample_actor_standby_ts/src/main.ts
@@ -0,0 +1,139 @@
+/**
+ * TypeScript Actor Standby sample for actor-runtime: an HTTP server that the platform (or the runtime)
+ * starts on demand and sends requests to. Mirrored endpoint for endpoint by `sample_actor_standby_py`.
+ *
+ *   GET  /                 what this server offers, and which run is answering
+ *   GET  /hello?name=Ada   a greeting; pushes one item to the run's default dataset
+ *   POST /echo             the request's JSON (or text) body, echoed back
+ *   GET  /stats            requests served by this run, and by every run so far (a named key-value store)
+ *   GET  /stream?count=5   a Server-Sent Events stream, one event every half second
+ *   WS   /ws               a websocket that echoes every message
+ */
+import { createServer, type IncomingMessage, type ServerResponse } from 'node:http';
+import { URL } from 'node:url';
+
+import { Actor, log } from 'apify';
+import { WebSocketServer } from 'ws';
+
+/** Sent by the platform (and the runtime) until the server answers; any response means "ready". */
+const READINESS_PROBE_HEADER = 'x-apify-container-server-readiness-probe';
+const STATS_STORE = 'standby-sample-ts-stats';
+const STATS_KEY = 'STATS';
+
+interface Stats {
+	served: number;
+	runs: number;
+}
+
+await Actor.init();
+
+if (Actor.config.get('metaOrigin') !== 'STANDBY') {
+	// `apify call` lands here: an Actor server has nothing to do without requests.
+	log.info(`This Actor is an HTTP server. Send requests to ${Actor.config.get('standbyUrl')}/ instead.`);
+	await Actor.exit(); // Ends the process.
+}
+
+const runId = Actor.config.get('actorRunId');
+const port = Actor.config.get('standbyPort');
+const statsStore = await Actor.openKeyValueStore(STATS_STORE);
+// The totals of every earlier run; this run's own count is added on top whenever they are saved.
+const before = (await statsStore.getValue<Stats>(STATS_KEY)) ?? { served: 0, runs: 0 };
+let served = 0;
+
+const allRuns = (): Stats => ({ served: before.served + served, runs: before.runs + 1 });
+const saveStats = async () => statsStore.setValue(STATS_KEY, allRuns());
+
+function sendJson(res: ServerResponse, status: number, body: unknown): void {
+	res.writeHead(status, { 'content-type': 'application/json; charset=utf-8' });
+	res.end(`${JSON.stringify(body, null, 2)}\n`);
+}
+
+async function readBody(req: IncomingMessage): Promise<string> {
+	const chunks: Buffer[] = [];
+	for await (const chunk of req) chunks.push(chunk as Buffer);
+	return Buffer.concat(chunks).toString('utf8');
+}
+
+async function streamEvents(res: ServerResponse, count: number): Promise<void> {
+	res.writeHead(200, { 'content-type': 'text/event-stream', 'cache-control': 'no-cache' });
+	for (let n = 1; n <= count && !res.destroyed; n++) {
+		res.write(`event: tick\ndata: ${JSON.stringify({ n, of: count, at: new Date().toISOString() })}\n\n`);
+		await new Promise((resolve) => setTimeout(resolve, 500));
+	}
+	res.end('event: done\ndata: {}\n\n');
+}
+
+async function handle(req: IncomingMessage, res: ServerResponse): Promise<void> {
+	const url = new URL(req.url ?? '/', 'http://localhost');
+	const route = `${req.method} ${url.pathname}`;
+
+	if (route === 'GET /') {
+		sendJson(res, 200, {
+			actor: 'TypeScript Standby sample',
+			runId,
+			standbyUrl: Actor.config.get('standbyUrl'),
+			endpoints: ['GET /hello?name=', 'POST /echo', 'GET /stats', 'GET /stream?count=', 'WS /ws'],
+		});
+		return;
+	}
+
+	served += 1;
+	log.info(`${route} (request #${served} of this run)`);
+
+	if (route === 'GET /hello') {
+		const name = url.searchParams.get('name') ?? 'world';
+		await Actor.pushData({ name, servedAt: new Date().toISOString() });
+		sendJson(res, 200, { greeting: `Hello, ${name}!`, runId, served });
+	} else if (route === 'POST /echo') {
+		const text = await readBody(req);
+		let body: unknown = text;
+		if (req.headers['content-type']?.startsWith('application/json')) {
+			try {
+				body = JSON.parse(text);
+			} catch {
+				sendJson(res, 400, { error: 'The body is not valid JSON.' });
+				return;
+			}
+		}
+		sendJson(res, 200, { runId, query: Object.fromEntries(url.searchParams), body });
+	} else if (route === 'GET /stats') {
+		sendJson(res, 200, { runId, thisRun: { served }, allRuns: allRuns() });
+	} else if (route === 'GET /stream') {
+		await streamEvents(res, Math.min(Number(url.searchParams.get('count')) || 5, 50));
+	} else {
+		sendJson(res, 404, { error: `No endpoint ${route} - see GET / for the list.` });
+	}
+}
+
+const server = createServer((req, res) => {
+	if (req.headers[READINESS_PROBE_HEADER]) {
+		res.end('ok\n');
+		return;
+	}
+	handle(req, res).catch((error: Error) => {
+		log.exception(error, `${req.method} ${req.url} failed`);
+		if (!res.headersSent) sendJson(res, 500, { error: error.message });
+		else res.destroy();
+	});
+});
+
+const sockets = new WebSocketServer({ server, path: '/ws' });
+sockets.on('connection', (socket) => {
+	served += 1;
+	socket.send(JSON.stringify({ hello: 'Send me anything and I will echo it.', runId }));
+	socket.on('message', (data) => socket.send(JSON.stringify({ echo: String(data) })));
+});
+
+// Saved whenever the platform asks (periodically, and before a migration), so no count is lost.
+Actor.on('persistState', saveStats);
+
+// An idle standby run is wound down with an `aborting` event; the SDK exits by itself right after
+// its listeners finish, so this only has to stop taking requests and save the totals.
+Actor.on('aborting', async () => {
+	log.info(`Shutting down after serving ${served} requests.`);
+	sockets.close();
+	server.close();
+	await saveStats();
+});
+
+server.listen(port, () => log.info(`Standby server listening on port ${port}`));
diff --git a/sample_actor_standby_ts/tsconfig.json b/sample_actor_standby_ts/tsconfig.json
new file mode 100644
index 00000000..971ad9fe
--- /dev/null
+++ b/sample_actor_standby_ts/tsconfig.json
@@ -0,0 +1,15 @@
+{
+	"extends": "@apify/tsconfig",
+	"compilerOptions": {
+		"module": "NodeNext",
+		"moduleResolution": "NodeNext",
+		"target": "ES2022",
+		"outDir": "dist",
+		"rootDir": "./src",
+		"incremental": false,
+		"noUnusedLocals": false,
+		"skipLibCheck": true,
+		"lib": ["DOM"]
+	},
+	"include": ["./src/**/*"]
+}
diff --git a/skills/actor-runtime/SKILL.md b/skills/actor-runtime/SKILL.md
index a51cfb5b..7a32f85b 100644
--- a/skills/actor-runtime/SKILL.md
+++ b/skills/actor-runtime/SKILL.md
@@ -205,8 +205,9 @@ curl "http://localhost:3333/actor-runtime/standby/<username>--<actor-name>/some/
 - A request that cannot be served says why: `standby-not-enabled`, `standby-run-finished` (the run
   crashed before its server came up - read its log), `standby-run-not-ready` (nothing listened on the port
   within 180 s).
-- `apify call` still starts an ordinary `API` run of the same Actor. `sample_actor_standby` is a minimal
-  Actor server to start from. Multi-tenant Standby and Standby for tasks are not emulated.
+- `apify call` still starts an ordinary `API` run of the same Actor. `sample_actor_standby_ts` and
+  `sample_actor_standby_py` are complete Actor servers (JSON, request body, Server-Sent Events, websocket,
+  graceful shutdown) to start from. Multi-tenant Standby and Standby for tasks are not emulated.
 
 ## Test how an Actor handles a platform migration
 
diff --git a/src/services/runs.ts b/src/services/runs.ts
index 214563e2..678551d6 100644
--- a/src/services/runs.ts
+++ b/src/services/runs.ts
@@ -154,6 +154,7 @@ function buildEnv(
 	// diverge would size the run differently depending on which SDK happens to read it.
 	const eventsWebSocketUrl = `${CONTAINER_EVENTS_WS_BASE_URL}/actor-runtime/events/${run.id}`;
 	const memoryMbytes = String(run.options.memoryMbytes);
+	const containerServerPort = String(containerServerPortFor(version));
 
 	// Prepend, never clobber, a version-level envVars entry of the same name.
 	const debugEnv: Record<string, string> = {};
@@ -185,7 +186,9 @@ function buildEnv(
 		APIFY_MEMORY_MBYTES: memoryMbytes,
 		// No `ACTOR_`-prefixed counterpart exists; only the Python SDK reads this.
 		APIFY_DEDICATED_CPUS: String(dedicatedCpusFor(run.options.memoryMbytes)),
-		ACTOR_STANDBY_PORT: String(containerServerPortFor(version)),
+		// Both, as on the platform: the JavaScript SDK reads the first, the Python SDK the second.
+		ACTOR_STANDBY_PORT: containerServerPort,
+		ACTOR_WEB_SERVER_PORT: containerServerPort,
 	};
 	if (options.standbyUrl) env.ACTOR_STANDBY_URL = options.standbyUrl;
 	if (options.proxyPassword) env.APIFY_PROXY_PASSWORD = options.proxyPassword;
diff --git a/test/e2e/standby.test.ts b/test/e2e/standby.test.ts
index 3edbaa26..9bfcc8ee 100644
--- a/test/e2e/standby.test.ts
+++ b/test/e2e/standby.test.ts
@@ -1,12 +1,14 @@
 /**
- * Actor Standby end to end (`test.md`'s "Actor Standby"): `apify push` of `sample_actor_standby` enables
- * Standby from its `.actor/actor.json`, requests to the Actor's standby URL are served by a standby run,
- * and an idle run is wound down. The requests themselves are plain HTTP - the narrow exception `test.md`
+ * Actor Standby end to end (`test.md`'s "Actor Standby"), for both standby samples: `apify push` enables
+ * Standby from `.actor/actor.json`, requests to the Actor's standby URL are served by one standby run,
+ * an idle run is wound down, and the next request starts a fresh one that sees the previous run's
+ * totals. The requests themselves are plain HTTP and a websocket - the narrow exception `test.md`
  * allows, since no `apify` command sends one; every other assertion reads `apify` output.
  */
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
 import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { WebSocket } from 'ws';
 
 import {
 	buildRuntimeImage,
@@ -30,7 +32,6 @@ import { waitFor } from './helpers/wait.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const REPO_ROOT = join(__dirname, '..', '..');
-const ACTOR_DIR = join(REPO_ROOT, 'sample_actor_standby');
 const CONTAINER_NAME = 'actor-runtime-e2e-standby';
 const IMAGE_TAG = 'actor-runtime:e2e';
 /** `helpers/apify-cli.ts`' login token. */
@@ -44,6 +45,26 @@ interface RunSummary {
 	options: { timeoutSecs: number };
 }
 
+async function getJson<T>(url: string, init?: RequestInit): Promise<T> {
+	const res = await fetch(url, { ...init, headers: { authorization: `Bearer ${TOKEN}`, ...init?.headers } });
+	expect(res.status, `${url} answered ${res.status}: ${await res.clone().text()}`).toBe(200);
+	return (await res.json()) as T;
+}
+
+function websocketRoundTrip(url: string): Promise<string[]> {
+	return new Promise((resolve, reject) => {
+		const frames: string[] = [];
+		const socket = new WebSocket(url);
+		socket.on('message', (data) => {
+			frames.push(String(data));
+			if (frames.length === 1) socket.send('ping');
+			else socket.close();
+		});
+		socket.on('close', () => resolve(frames));
+		socket.on('error', reject);
+	});
+}
+
 describe('Actor Standby via apify-cli (requires Docker)', () => {
 	let isolatedApifyHome: string;
 
@@ -69,78 +90,85 @@ describe('Actor Standby via apify-cli (requires Docker)', () => {
 		if (isolatedApifyHome) removeIsolatedApifyHome(isolatedApifyHome);
 	});
 
-	it(
-		'push enables Standby; requests share one STANDBY run, which is wound down SUCCEEDED once idle',
-		async () => {
-			const env = apifyEnv(isolatedApifyHome);
-			const push = JSON.parse(apify(['push', '--json'], { cwd: ACTOR_DIR, env })) as PushResult;
-			expect(push.build.status).toBe('SUCCEEDED');
-
-			const actorId = push.actor.id;
-			apify(
-				[
-					'api',
-					'PUT',
-					`actors/${actorId}`,
-					'--body',
-					JSON.stringify({ actorStandby: { idleTimeoutSecs: 10 } }),
-				],
-				{
-					cwd: ACTOR_DIR,
-					env,
-				},
-			);
-			const actor = JSON.parse(
-				apify(['api', 'GET', `actors/${actorId}`], { cwd: ACTOR_DIR, env }),
-			) as ApiEnvelope<{
-				actorStandby: { isEnabled: boolean; idleTimeoutSecs: number };
-				standbyUrl: string;
-			}>;
-			expect(actor.data.actorStandby).toMatchObject({ isEnabled: true, idleTimeoutSecs: 10 });
-
-			const greetings: Array<{ greeting: string; runId: string }> = [];
-			for (const name of ['Ada', 'Grace', 'Linus']) {
-				const res = await fetch(`${actor.data.standbyUrl}/hello?name=${name}`, {
-					headers: { authorization: `Bearer ${TOKEN}` },
+	for (const sample of ['sample_actor_standby_ts', 'sample_actor_standby_py']) {
+		it(
+			`${sample}: push enables Standby; one STANDBY run serves every endpoint and is wound down once idle`,
+			async () => {
+				const actorDir = join(REPO_ROOT, sample);
+				const env = apifyEnv(isolatedApifyHome);
+				const push = JSON.parse(apify(['push', '--json'], { cwd: actorDir, env })) as PushResult;
+				expect(push.build.status).toBe('SUCCEEDED');
+
+				const actorId = push.actor.id;
+				const body = JSON.stringify({ actorStandby: { idleTimeoutSecs: 10 } });
+				apify(['api', 'PUT', `actors/${actorId}`, '--body', body], { cwd: actorDir, env });
+				const actor = JSON.parse(
+					apify(['api', 'GET', `actors/${actorId}`], { cwd: actorDir, env }),
+				) as ApiEnvelope<{ actorStandby: { isEnabled: boolean; idleTimeoutSecs: number }; standbyUrl: string }>;
+				expect(actor.data.actorStandby).toMatchObject({ isEnabled: true, idleTimeoutSecs: 10 });
+				const url = actor.data.standbyUrl;
+
+				const index = await getJson<{ runId: string; endpoints: string[] }>(`${url}/`);
+				expect(index.endpoints).toContain('GET /hello?name=');
+				const runId = index.runId;
+
+				for (const name of ['Ada', 'Grace', 'Linus']) {
+					const hello = await getJson<{ greeting: string; runId: string }>(`${url}/hello?name=${name}`);
+					expect(hello).toMatchObject({ greeting: `Hello, ${name}!`, runId });
+				}
+
+				const echo = await getJson<{ query: Record<string, string>; body: unknown }>(`${url}/echo?x=1`, {
+					method: 'POST',
+					headers: { 'content-type': 'application/json' },
+					body: JSON.stringify({ nested: { ok: true } }),
 				});
-				expect(res.status).toBe(200);
-				greetings.push((await res.json()) as { greeting: string; runId: string });
-			}
-			expect(greetings.map((g) => g.greeting)).toEqual(['Hello, Ada!', 'Hello, Grace!', 'Hello, Linus!']);
-			expect(new Set(greetings.map((g) => g.runId)).size).toBe(1);
-			const runId = greetings[0]!.runId;
-
-			const runOf = () =>
-				(
-					JSON.parse(
-						apify(['api', 'GET', `actor-runs/${runId}`], { cwd: ACTOR_DIR, env }),
-					) as ApiEnvelope<RunSummary>
-				).data;
-			expect(runOf()).toMatchObject({
-				status: 'RUNNING',
-				meta: { origin: 'STANDBY' },
-				options: { timeoutSecs: 0 },
-			});
-
-			const finished = await waitFor(
-				() => {
-					const run = runOf();
-					return run.status === 'SUCCEEDED' ? run : undefined;
-				},
-				90_000,
-				'the idle standby run to finish',
-			);
-			const info = JSON.parse(
-				apify(['datasets', 'info', finished.defaultDatasetId, '--json'], { cwd: ACTOR_DIR, env }),
-			) as DatasetInfoResult;
-			expect(info.itemCount).toBe(3);
-			const log = apify(['api', 'GET', `logs/${runId}`], { cwd: ACTOR_DIR, env });
-			expect(log).toContain('Actor Standby server was idle for too long, finishing run.');
-
-			// The next request starts a fresh run.
-			const next = (await (await fetch(`${actor.data.standbyUrl}/?token=${TOKEN}`)).json()) as { runId: string };
-			expect(next.runId).not.toBe(runId);
-		},
-		5 * 60 * 1000,
-	);
+				expect(echo).toMatchObject({ query: { x: '1' }, body: { nested: { ok: true } } });
+
+				const stream = await fetch(`${url}/stream?count=3&token=${TOKEN}`);
+				expect(stream.headers.get('content-type')).toMatch(/^text\/event-stream/);
+				const events = (await stream.text()).match(/^event: \w+$/gm);
+				expect(events).toEqual(['event: tick', 'event: tick', 'event: tick', 'event: done']);
+
+				const frames = await websocketRoundTrip(`${url.replace(/^http/, 'ws')}/ws?token=${TOKEN}`);
+				expect(JSON.parse(frames[0]!)).toMatchObject({ runId });
+				expect(JSON.parse(frames[1]!)).toEqual({ echo: 'ping' });
+
+				const runOf = () =>
+					(
+						JSON.parse(
+							apify(['api', 'GET', `actor-runs/${runId}`], { cwd: actorDir, env }),
+						) as ApiEnvelope<RunSummary>
+					).data;
+				expect(runOf()).toMatchObject({
+					status: 'RUNNING',
+					meta: { origin: 'STANDBY' },
+					options: { timeoutSecs: 0 },
+				});
+
+				const finished = await waitFor(
+					() => {
+						const run = runOf();
+						return run.status === 'SUCCEEDED' ? run : undefined;
+					},
+					120_000,
+					'the idle standby run to finish',
+				);
+				const info = JSON.parse(
+					apify(['datasets', 'info', finished.defaultDatasetId, '--json'], { cwd: actorDir, env }),
+				) as DatasetInfoResult;
+				expect(info.itemCount).toBe(3);
+				const log = apify(['api', 'GET', `logs/${runId}`], { cwd: actorDir, env });
+				expect(log).toContain('Actor Standby server was idle for too long, finishing run.');
+
+				// A fresh run, which reads the totals the finished one saved: 3 greetings, an echo, a stream,
+				// a websocket, and now this request.
+				const stats = await getJson<{ runId: string; allRuns: { served: number; runs: number } }>(
+					`${url}/stats`,
+				);
+				expect(stats.runId).not.toBe(runId);
+				expect(stats.allRuns).toEqual({ served: 7, runs: 2 });
+			},
+			8 * 60 * 1000,
+		);
+	}
 });
diff --git a/test/integration/standby.test.ts b/test/integration/standby.test.ts
index 6ba535e1..8ee56da8 100644
--- a/test/integration/standby.test.ts
+++ b/test/integration/standby.test.ts
@@ -282,7 +282,11 @@ describe('standby router', () => {
 		const ctx = driver.containers[0]!.ctx;
 		expect(ctx.containerServerPort).toBe(4321);
 		expect(ctx.timeoutSecs).toBe(0);
-		expect(ctx.env).toMatchObject({ APIFY_META_ORIGIN: 'STANDBY', ACTOR_STANDBY_PORT: '4321' });
+		expect(ctx.env).toMatchObject({
+			APIFY_META_ORIGIN: 'STANDBY',
+			ACTOR_STANDBY_PORT: '4321',
+			ACTOR_WEB_SERVER_PORT: '4321',
+		});
 		expect(ctx.env.ACTOR_STANDBY_URL).toMatch(/\/actor-runtime\/standby\/.+--standby-actor$/);
 		expect(driver.containers[0]!.probes).toBeGreaterThan(0);
 

From a0d4e3e94da71d8e4b3b867a8a6d817ef276dc31 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Thu, 24 Sep 2026 08:44:57 +0000
Subject: [PATCH 3/5] feat: Offer a ready-to-use standby link on the Actor's
 console page

The Actor Standby section now links to the standby URL with the owner's token
already in it, masked in the text shown, plus a button that copies the full
link - so a standby Actor can be tried in a browser with one click.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01W6t3FkairFVeCRTVXrJfTw
---
 requirements/console.md          |  4 +++-
 skills/actor-runtime/SKILL.md    |  2 ++
 src/console/server.ts            | 28 +++++++++++++++++----------
 src/console/templates.ts         | 33 ++++++++++++++++++++++++++++++++
 test/integration/standby.test.ts |  7 +++++++
 5 files changed, 63 insertions(+), 11 deletions(-)

diff --git a/requirements/console.md b/requirements/console.md
index cbbd358a..b57fb276 100644
--- a/requirements/console.md
+++ b/requirements/console.md
@@ -118,5 +118,7 @@
 ## Actor Standby (Actor detail view)
 
 - The Actor detail view shows whether Actor Standby is on and, when it is, the standby URL, the settings and
-  the Actor's live standby runs with their open requests. Read-only: the settings are changed through the
+  the Actor's live standby runs with their open requests.
+- It also offers the standby URL with the owner's token in it, as a link to open and a button that copies
+  it; the token is masked in the text shown on the page. Read-only: the settings are changed through the
   API (`api.md`). The run detail view shows each run's origin.
diff --git a/skills/actor-runtime/SKILL.md b/skills/actor-runtime/SKILL.md
index 7a32f85b..deed036d 100644
--- a/skills/actor-runtime/SKILL.md
+++ b/skills/actor-runtime/SKILL.md
@@ -189,6 +189,8 @@ apify push
 curl "http://localhost:3333/actor-runtime/standby/<username>--<actor-name>/some/path?token=<token>"
 ```
 
+- The Actor's console page has the same URL with your token already in it (masked on screen), as a link
+  to click and a Copy link button - the quickest way to try it in a browser.
 - The first request starts a standby run (origin `STANDBY`, no timeout, the standby build and memory) and
   waits until its server answers on `ACTOR_STANDBY_PORT` (4321); later requests reuse it. More runs start
   once concurrent requests exceed `desiredRequestsPerActorRun` / `maxRequestsPerActorRun`.
diff --git a/src/console/server.ts b/src/console/server.ts
index 8e4ff869..0eda5863 100644
--- a/src/console/server.ts
+++ b/src/console/server.ts
@@ -61,6 +61,7 @@ import {
 	migrateRunForm,
 	pricingSection,
 	settingsForm,
+	standbyLink,
 	table,
 	usageSection,
 	type LinkedCell,
@@ -201,6 +202,10 @@ export function createConsoleServer(deps: ConsoleServerDeps): Express {
 		const pool = standbyPoolSnapshot(actor.id);
 		return (
 			'<h2>Actor Standby</h2>' +
+			(owner
+				? "<p>Open or copy the standby URL with the owner's token already in it:</p>" +
+					standbyLink(url, owner.token)
+				: '') +
 			definitionList([
 				['standbyUrl', url],
 				['build', config.build],
@@ -210,16 +215,19 @@ export function createConsoleServer(deps: ConsoleServerDeps): Express {
 				['idleTimeoutSecs', config.idleTimeoutSecs],
 				['shouldPassActorInput', String(config.shouldPassActorInput)],
 			]) +
-			table(
-				['runId', 'open requests', 'ready'],
-				pool.map((entry) => [
-					entry.runId
-						? { text: entry.runId, href: `/runs/${encodeURIComponent(entry.runId)}` }
-						: '(starting)',
-					String(entry.openRequests),
-					entry.ready ? 'yes' : 'no',
-				]),
-			)
+			'<h3>Standby runs</h3>' +
+			(pool.length === 0
+				? '<p class="empty">(none running - the next request starts one)</p>'
+				: table(
+						['runId', 'open requests', 'ready'],
+						pool.map((entry) => [
+							entry.runId
+								? { text: entry.runId, href: `/runs/${encodeURIComponent(entry.runId)}` }
+								: '(starting)',
+							String(entry.openRequests),
+							entry.ready ? 'yes' : 'no',
+						]),
+					))
 		);
 	}
 
diff --git a/src/console/templates.ts b/src/console/templates.ts
index 4b41599a..82b8c313 100644
--- a/src/console/templates.ts
+++ b/src/console/templates.ts
@@ -377,3 +377,36 @@ export function definitionList(fields: Array<[string, unknown]>): string {
 	const rows = fields.map(([key, value]) => `<dt>${escapeHtml(key)}</dt><dd>${renderValue(value)}</dd>`).join('');
 	return `<dl>${rows}</dl>`;
 }
+
+/**
+ * The standby URL with the owner's token in it, ready to open or copy. The token is masked on screen
+ * only, so it does not end up in a screenshot or a screen share; the link and the copied text carry it.
+ */
+export function standbyLink(standbyUrl: string, token: string): string {
+	const full = `${standbyUrl}/?token=${encodeURIComponent(token)}`;
+	return (
+		'<p class="standby-link">' +
+		`<a href="${escapeHtml(full)}" target="_blank" rel="noopener">${escapeHtml(standbyUrl)}/?token=••••••••</a> ` +
+		`<button type="button" data-copy="${escapeHtml(full)}">Copy link</button>` +
+		'</p>' +
+		`<script>
+for (const button of document.querySelectorAll('button[data-copy]')) {
+	button.addEventListener('click', async () => {
+		const text = button.dataset.copy;
+		try {
+			await navigator.clipboard.writeText(text);
+		} catch {
+			// No clipboard API outside a secure context (the console opened by a non-localhost address).
+			const field = Object.assign(document.createElement('textarea'), { value: text });
+			document.body.append(field);
+			field.select();
+			document.execCommand('copy');
+			field.remove();
+		}
+		button.textContent = 'Copied';
+		setTimeout(() => (button.textContent = 'Copy link'), 1500);
+	});
+}
+</script>`
+	);
+}
diff --git a/test/integration/standby.test.ts b/test/integration/standby.test.ts
index 8ee56da8..c29107fd 100644
--- a/test/integration/standby.test.ts
+++ b/test/integration/standby.test.ts
@@ -449,6 +449,13 @@ describe('standby router', () => {
 			expect(html).toContain('Actor Standby');
 			expect(html).toContain('/actor-runtime/standby/');
 			expect(html).toContain(`/runs/${served.runId}`);
+			// A ready-to-use link carries the owner's token, masked on screen.
+			const label = url.split('/').pop()!;
+			const withToken = `http://localhost:3333/actor-runtime/standby/${label}/?token=${server.token}`;
+			expect(html).toContain(`href="${withToken}"`);
+			expect(html).toContain(`data-copy="${withToken}"`);
+			expect(html).toContain(`/actor-runtime/standby/${label}/?token=••••••••</a>`);
+			expect(html).not.toMatch(new RegExp(`>[^<]*${server.token}[^<]*<`));
 			const runHtml = await (await fetch(`http://127.0.0.1:${port}/runs/${served.runId}`)).text();
 			expect(runHtml).toContain('STANDBY');
 		} finally {

From 170676b0ae67cac7767864521d298f9f260b28fd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Josef=20Proch=C3=A1zka?= <josef.prochazka@apify.com>
Date: Thu, 24 Sep 2026 11:59:29 +0200
Subject: [PATCH 4/5] fix: Serve standby Actors at the platform-shaped
 *.localhost URL (#75)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- `standbyUrl` is now `http://<username>--<actor-name>.localhost:3333`,
the local counterpart of `https://<username>--<actor-name>.apify.actor`:
the Actor owns `/` of its own origin, one hostname per Actor.
- Fixes Actor web UIs with root-relative links (e.g.
`fetch('/api/...')`), which under `/actor-runtime/standby/<label>/`
escaped to the runtime's own API and broke Actors that work on the
platform.
- `/actor-runtime/standby/<label>/...` stays for clients that do not
resolve `*.localhost`; the Actor object read from an Actor container
carries `http://apify-api:3333/actor-runtime/standby/<label>`, which
other Actors can reach.
- Standby Actors now also work under rootless Podman 3.x, where the
runtime could not reach a standby run's server.
- Storage lists (`GET /v2/datasets`, `/v2/key-value-stores`,
`/v2/request-queues`) return only named storages unless `?unnamed=true`,
as on the platform.
- Adds `sample_actor_standby_web` and e2e tests for an external client
calling its standby endpoint, and another Actor's run calling it from
its container.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

https://claude.ai/code/session_013KAxkpoSLVQvpEJUANjWdp

---------

Co-authored-by: Claude <noreply@anthropic.com>
---
 README.md                                     |    9 +-
 requirements/api.md                           |   12 +-
 requirements/test.md                          |    2 +
 sample_actor_standby_web/.actor/actor.json    |   12 +
 .../.actor/input_schema.json                  |   20 +
 sample_actor_standby_web/.dockerignore        |   18 +
 sample_actor_standby_web/Dockerfile           |   20 +
 sample_actor_standby_web/README.md            |   24 +
 sample_actor_standby_web/package-lock.json    | 2278 +++++++++++++++++
 sample_actor_standby_web/package.json         |   22 +
 sample_actor_standby_web/src/main.ts          |  103 +
 sample_actor_standby_web/tsconfig.json        |   15 +
 skills/actor-runtime/SKILL.md                 |   15 +-
 src/api/dto/actors.ts                         |    6 +-
 src/api/routes/actors.ts                      |   20 +-
 src/api/routes/datasets.ts                    |    4 +-
 src/api/routes/key-value-stores.ts            |   14 +-
 src/api/routes/request-queues.ts              |    4 +-
 src/api/standby-proxy.ts                      |    7 +-
 src/driver/docker-driver.ts                   |   46 +-
 src/services/standby-config.ts                |   22 +-
 src/services/storages.ts                      |   11 +-
 test/e2e/all-modes.test.ts                    |    4 +-
 test/e2e/helpers/browser-view-suite.ts        |   10 +-
 test/e2e/helpers/console-view.ts              |   14 +
 test/e2e/standby.test.ts                      |  138 +-
 test/integration/datasets.test.ts             |   25 +
 test/integration/standby.test.ts              |   46 +-
 test/integration/storages-concurrency.test.ts |    2 +-
 test/unit/docker-driver-standby.test.ts       |   44 +
 test/unit/standby-config.test.ts              |   13 +
 31 files changed, 2913 insertions(+), 67 deletions(-)
 create mode 100644 sample_actor_standby_web/.actor/actor.json
 create mode 100644 sample_actor_standby_web/.actor/input_schema.json
 create mode 100644 sample_actor_standby_web/.dockerignore
 create mode 100644 sample_actor_standby_web/Dockerfile
 create mode 100644 sample_actor_standby_web/README.md
 create mode 100644 sample_actor_standby_web/package-lock.json
 create mode 100644 sample_actor_standby_web/package.json
 create mode 100644 sample_actor_standby_web/src/main.ts
 create mode 100644 sample_actor_standby_web/tsconfig.json

diff --git a/README.md b/README.md
index 08c95831..ca31a47e 100644
--- a/README.md
+++ b/README.md
@@ -80,11 +80,18 @@ through the API - is served over HTTP at its `standbyUrl`, on the API port:
 ```bash
 cd sample_actor_standby_ts     # or sample_actor_standby_py
 apify push
-curl "http://localhost:3333/actor-runtime/standby/<username>--my-standby-actor-ts/hello?name=Ada&token=<token>"
+curl "http://<username>--my-standby-actor-ts.localhost:3333/hello?name=Ada&token=<token>"
 ```
 
+The `standbyUrl` has the platform's shape, one `*.localhost` hostname per Actor, so a web UI served by the
+Actor works as on `*.apify.actor`. Clients that do not resolve `*.localhost` use
+`http://localhost:3333/actor-runtime/standby/<username>--<actor-name>`, and other Actors
+`http://apify-api:3333/actor-runtime/standby/<username>--<actor-name>`.
+
 The two samples are the same server in TypeScript and Python - JSON endpoints, a request body echo, a
 Server-Sent Events stream, a websocket and stats kept across runs; each README lists the calls.
+`sample_actor_standby_web` serves a web page with root-relative links, and in an ordinary run calls a
+standby Actor from inside its container.
 
 Requests are handed to standby runs the runtime starts, scales by `desiredRequestsPerActorRun` /
 `maxRequestsPerActorRun` and winds down after `idleTimeoutSecs` without a request, as on the platform.
diff --git a/requirements/api.md b/requirements/api.md
index 3b5f036e..15754be6 100644
--- a/requirements/api.md
+++ b/requirements/api.md
@@ -156,11 +156,13 @@
   `null` while Standby is off. `POST` and `PUT /v2/actors` accept `actorStandby`; a partial object is merged
   over the stored settings, over the defaults. An invalid one is `400` `invalid-request`, changing nothing;
   a `tenancy` other than `SINGLE_TENANT` is invalid.
-- The standby URL is `http://localhost:3333/actor-runtime/standby/<username>--<actor-name>`; the Actor id
-  also works in place of `<username>--<actor-name>`. Everything after it - path, query, method, headers,
-  body, websocket upgrades - reaches the Actor's server unchanged, the token included.
-- The platform's host-based shape, `http://<username>--<actor-name>.localhost:3333/<path>`, is served too,
-  for clients that resolve `*.localhost`; its whole path reaches the Actor.
+- The standby URL is `http://<username>--<actor-name>.localhost:3333`, the local `*.apify.actor`: each
+  Actor has its own origin and owns its whole path, so web UIs served by Actors work as on the platform.
+- Clients that do not resolve `*.localhost` use `http://localhost:3333/actor-runtime/standby/<username>--<actor-name>`;
+  other Actors use `http://apify-api:3333/actor-runtime/standby/<username>--<actor-name>`, which is the
+  `standbyUrl` they read through the API.
+- The Actor id can replace `<username>--<actor-name>`. Path, query, method, headers, body and websockets
+  reach the Actor's server unchanged.
 - Authenticated like the API (`Authorization: Bearer`, `?token=`), plus the platform's
   `x-apify-authorization` header; only the Actor's owner is served.
 - Errors, as `{ "error": { "type", "message" } }`: no token `401` `user-not-authenticated`; no such Actor of
diff --git a/requirements/test.md b/requirements/test.md
index 37150f76..29c7110c 100644
--- a/requirements/test.md
+++ b/requirements/test.md
@@ -53,3 +53,5 @@ Test case must verify full Actor development flow:
 - Assert that plain, body-carrying, streamed and websocket requests to its standby URL are all answered by
   one `STANDBY` run, that the run ends `SUCCEEDED` once idle with one dataset item per greeting, and that
   the next request starts a new run
+- For `sample_actor_standby_web`: assert that an external client and another Actor's run can both call its
+  standby endpoint
diff --git a/sample_actor_standby_web/.actor/actor.json b/sample_actor_standby_web/.actor/actor.json
new file mode 100644
index 00000000..42d73dac
--- /dev/null
+++ b/sample_actor_standby_web/.actor/actor.json
@@ -0,0 +1,12 @@
+{
+	"$schema": "https://apify.com/schemas/v1/actor.ide.json",
+	"actorSpecification": 1,
+	"name": "my-standby-web-actor",
+	"title": "Standby web page sample actor for actor-runtime",
+	"description": "In Standby mode, a web page and the JSON endpoint it calls with a root-relative URL. An ordinary run calls a standby Actor's endpoint from inside its container.",
+	"version": "0.0",
+	"buildTag": "latest",
+	"usesStandbyMode": true,
+	"input": "./input_schema.json",
+	"dockerfile": "../Dockerfile"
+}
diff --git a/sample_actor_standby_web/.actor/input_schema.json b/sample_actor_standby_web/.actor/input_schema.json
new file mode 100644
index 00000000..444fb15c
--- /dev/null
+++ b/sample_actor_standby_web/.actor/input_schema.json
@@ -0,0 +1,20 @@
+{
+	"title": "Standby web sample input",
+	"type": "object",
+	"schemaVersion": 1,
+	"properties": {
+		"standbyActor": {
+			"title": "Standby Actor",
+			"type": "string",
+			"description": "The standby Actor an ordinary run calls, as an id or `username/name`. Empty means this Actor itself.",
+			"editor": "textfield"
+		},
+		"name": {
+			"title": "Name",
+			"type": "string",
+			"description": "Sent to the standby Actor's `/api/greeting` endpoint.",
+			"editor": "textfield",
+			"default": "Actor"
+		}
+	}
+}
diff --git a/sample_actor_standby_web/.dockerignore b/sample_actor_standby_web/.dockerignore
new file mode 100644
index 00000000..3bbdbb77
--- /dev/null
+++ b/sample_actor_standby_web/.dockerignore
@@ -0,0 +1,18 @@
+# configurations
+.idea
+.vscode
+.zed
+
+# crawlee and apify storage folders
+apify_storage
+crawlee_storage
+storage
+
+# installed files
+node_modules
+
+# git folder
+.git
+
+# dist folder
+dist
diff --git a/sample_actor_standby_web/Dockerfile b/sample_actor_standby_web/Dockerfile
new file mode 100644
index 00000000..cd75e644
--- /dev/null
+++ b/sample_actor_standby_web/Dockerfile
@@ -0,0 +1,20 @@
+FROM apify/actor-node:24 AS builder
+
+COPY --chown=myuser:myuser package*.json ./
+RUN npm install --include=dev --audit=false
+
+COPY --chown=myuser:myuser . ./
+RUN npm run build
+
+FROM apify/actor-node:24
+
+COPY --chown=myuser:myuser package*.json ./
+RUN npm --quiet set progress=false \
+    && npm install --omit=dev --omit=optional --audit=false \
+    && rm -r ~/.npm
+
+COPY --from=builder --chown=myuser:myuser /usr/src/app/dist ./dist
+COPY --chown=myuser:myuser . ./
+
+# The interpreter itself, not `npm start`, so the runtime's debug mode can attach too.
+CMD ["node", "dist/main.js"]
diff --git a/sample_actor_standby_web/README.md b/sample_actor_standby_web/README.md
new file mode 100644
index 00000000..fc8771c3
--- /dev/null
+++ b/sample_actor_standby_web/README.md
@@ -0,0 +1,24 @@
+# Standby web sample Actor
+
+A small Actor for trying Actor Standby callers against the local runtime. `.actor/actor.json` sets
+`usesStandbyMode`, so `apify push` enables Standby.
+
+- **Standby run**: serves a web page whose script calls `GET /api/greeting` with a root-relative URL, as most
+  web UIs do. That works because the Actor owns `/` of its standby URL, as on `*.apify.actor`.
+- **Ordinary run** (`apify call`): a client of a standby Actor, this one unless the `standbyActor` input
+  names another. It reads that Actor's `standbyUrl` through the API - from inside a container that is
+  `http://apify-api:3333/actor-runtime/standby/<username>--<actor-name>` - calls `/api/greeting` there and
+  pushes the answer to its default dataset.
+
+```bash
+apify push
+TOKEN=<your token>
+
+# In a browser:
+#   http://<username>--my-standby-web-actor.localhost:3333/?token=<your token>
+curl "http://<username>--my-standby-web-actor.localhost:3333/api/greeting?name=Ada&token=$TOKEN"
+# The same endpoint, for clients that do not resolve *.localhost:
+curl "http://localhost:3333/actor-runtime/standby/<username>--my-standby-web-actor/api/greeting?name=Ada&token=$TOKEN"
+
+apify call --input '{"name":"Actor"}'   # another run calls the standby endpoint from its container
+```
diff --git a/sample_actor_standby_web/package-lock.json b/sample_actor_standby_web/package-lock.json
new file mode 100644
index 00000000..f8102d5e
--- /dev/null
+++ b/sample_actor_standby_web/package-lock.json
@@ -0,0 +1,2278 @@
+{
+	"name": "my-standby-web-actor",
+	"version": "0.0.1",
+	"lockfileVersion": 3,
+	"requires": true,
+	"packages": {
+		"": {
+			"name": "my-standby-web-actor",
+			"version": "0.0.1",
+			"license": "ISC",
+			"dependencies": {
+				"apify": "^3.7.0"
+			},
+			"devDependencies": {
+				"@apify/tsconfig": "^0.2.0",
+				"@types/node": "^24.0.0",
+				"typescript": "^6.0.0"
+			},
+			"engines": {
+				"node": ">=18.0.0"
+			}
+		},
+		"node_modules/@apify/consts": {
+			"version": "2.58.1",
+			"resolved": "https://registry.npmjs.org/@apify/consts/-/consts-2.58.1.tgz",
+			"integrity": "sha512-pKnoPincN2eqiSANmX2u19FihJATX3f1ucMhxss7t2epUmB/UhSjGM7G4immjC7Q/CXrNmbETBbOGmR0/EH4/Q==",
+			"license": "Apache-2.0"
+		},
+		"node_modules/@apify/datastructures": {
+			"version": "2.0.6",
+			"resolved": "https://registry.npmjs.org/@apify/datastructures/-/datastructures-2.0.6.tgz",
+			"integrity": "sha512-hI/Q5cCjXXI/g4OPwX+/xuk+JsOtXRhKNXl2wnq/nKmdrji3nYCc9vGsAEc1iXVbs16xQMZy5uRhoY3XTABovA==",
+			"license": "Apache-2.0"
+		},
+		"node_modules/@apify/input_secrets": {
+			"version": "1.2.60",
+			"resolved": "https://registry.npmjs.org/@apify/input_secrets/-/input_secrets-1.2.60.tgz",
+			"integrity": "sha512-KfrnFFTy7pozNxgX6MBdeCbVIhxM/t6t8gDroRbADJyYmaGtkqsxk9t4/xw9ri+ZObiWdWQrlU10xF+NUqDQBg==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"@apify/log": "^2.5.54",
+				"@apify/utilities": "^2.35.11",
+				"ow": "^0.28.2"
+			}
+		},
+		"node_modules/@apify/log": {
+			"version": "2.5.54",
+			"resolved": "https://registry.npmjs.org/@apify/log/-/log-2.5.54.tgz",
+			"integrity": "sha512-EZRHrKCWnet0+6WaTx14Mpjxrn/PRudmRk6/N1dCTz+jtHN+Pbdvw5FFtIrCUngPhm4+bdI+kKVYUBmvTwrjvg==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"@apify/consts": "^2.58.1",
+				"ansi-colors": "^4.1.3"
+			}
+		},
+		"node_modules/@apify/ps-tree": {
+			"version": "1.2.0",
+			"resolved": "https://registry.npmjs.org/@apify/ps-tree/-/ps-tree-1.2.0.tgz",
+			"integrity": "sha512-VHIswI7rD/R4bToeIDuJ9WJXt+qr5SdhfoZ9RzdjmCs9mgy7l0P4RugQEUCcU+WB4sfImbd4CKwzXcn0uYx1yw==",
+			"license": "MIT",
+			"dependencies": {
+				"event-stream": "3.3.4"
+			},
+			"bin": {
+				"ps-tree": "bin/ps-tree.js"
+			},
+			"engines": {
+				"node": ">= 0.10"
+			}
+		},
+		"node_modules/@apify/pseudo_url": {
+			"version": "2.0.95",
+			"resolved": "https://registry.npmjs.org/@apify/pseudo_url/-/pseudo_url-2.0.95.tgz",
+			"integrity": "sha512-VZJ8cfXFAKIfCSk4EzlZwwXW6WESLMvDP9NHhB7nCsg6zskv0I/81V/liX5wOs3FjjipLegkx0AWw7lkyk3gEA==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"@apify/log": "^2.5.54"
+			}
+		},
+		"node_modules/@apify/timeout": {
+			"version": "0.3.5",
+			"resolved": "https://registry.npmjs.org/@apify/timeout/-/timeout-0.3.5.tgz",
+			"integrity": "sha512-3nuQXwxh2sKxBo5tgDoZWuZHiSpqrKg1+sJHjFSk8blhyX6I2FZzpfW7UaCELeYLZiSjWUPh2rXNrc3zLmJGJg==",
+			"license": "Apache-2.0"
+		},
+		"node_modules/@apify/tsconfig": {
+			"version": "0.2.0",
+			"resolved": "https://registry.npmjs.org/@apify/tsconfig/-/tsconfig-0.2.0.tgz",
+			"integrity": "sha512-0i6rF+hgXw6mQXhENYNTnP+Yo4WY38d698k/pk4rIpdCx/sSuEprR2N5WdtMaN628vCB+aZjff0jPN2EnQYtjQ==",
+			"dev": true,
+			"license": "Apache-2.0"
+		},
+		"node_modules/@apify/utilities": {
+			"version": "2.35.11",
+			"resolved": "https://registry.npmjs.org/@apify/utilities/-/utilities-2.35.11.tgz",
+			"integrity": "sha512-od9Axa/+OSZB5JO8aljAnN7lS8vDb5KqUEAkUiZZh95K5xIrC0GzN45DNcK8oItnJ3QT/oqtHdaa22TipinDvQ==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"@apify/consts": "^2.58.1",
+				"@apify/log": "^2.5.54"
+			}
+		},
+		"node_modules/@borewit/text-codec": {
+			"version": "0.2.2",
+			"resolved": "https://registry.npmjs.org/@borewit/text-codec/-/text-codec-0.2.2.tgz",
+			"integrity": "sha512-DDaRehssg1aNrH4+2hnj1B7vnUGEjU6OIlyRdkMd0aUdIUvKXrJfXsy8LVtXAy7DRvYVluWbMspsRhz2lcW0mQ==",
+			"license": "MIT",
+			"funding": {
+				"type": "github",
+				"url": "https://github.com/sponsors/Borewit"
+			}
+		},
+		"node_modules/@crawlee/core": {
+			"version": "3.18.1",
+			"resolved": "https://registry.npmjs.org/@crawlee/core/-/core-3.18.1.tgz",
+			"integrity": "sha512-f8bQBBfRxRf5RvUErI6K5xhxN9vWsZajT3XdQmCjjPfqp4Oa20Vsi2DarQE9FAFZpy/djncJH+tn24HlZMaBig==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"@apify/consts": "^2.20.0",
+				"@apify/datastructures": "^2.0.0",
+				"@apify/log": "^2.4.0",
+				"@apify/pseudo_url": "^2.0.30",
+				"@apify/timeout": "^0.4.0",
+				"@apify/utilities": "^2.7.10",
+				"@crawlee/memory-storage": "3.18.1",
+				"@crawlee/types": "3.18.1",
+				"@crawlee/utils": "3.18.1",
+				"@sapphire/async-queue": "^1.5.1",
+				"@standard-schema/spec": "^1.0.0",
+				"@vladfrangu/async_event_emitter": "^2.2.2",
+				"csv-stringify": "^6.2.0",
+				"fs-extra": "^11.0.0",
+				"got-scraping": "^4.2.1",
+				"json5": "^2.2.3",
+				"minimatch": "^9.0.0",
+				"ow": "^0.28.1",
+				"stream-json": "^1.8.0",
+				"tldts": "^7.0.0",
+				"tough-cookie": "^6.0.0",
+				"tslib": "^2.4.0",
+				"type-fest": "^4.0.0"
+			},
+			"engines": {
+				"node": ">=16.0.0"
+			}
+		},
+		"node_modules/@crawlee/core/node_modules/@apify/timeout": {
+			"version": "0.4.14",
+			"resolved": "https://registry.npmjs.org/@apify/timeout/-/timeout-0.4.14.tgz",
+			"integrity": "sha512-Wn3Y49JfbwwlNSzOlQ9PIux3DeMKHhkQSEppaoPGxoZFq1YZQWx+Td9BCWNXyYmM2K+WUa1iHQtNPgqewbNYGw==",
+			"license": "Apache-2.0"
+		},
+		"node_modules/@crawlee/memory-storage": {
+			"version": "3.18.1",
+			"resolved": "https://registry.npmjs.org/@crawlee/memory-storage/-/memory-storage-3.18.1.tgz",
+			"integrity": "sha512-uzyBuSwfwNCFRcJlNOoJ5UMVYGWQE7UlnMsMULzRrs1YnkqLzZ7ldeyXfRwGxJUNo4KJ6o3IxDpGCIj8dkuzrQ==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"@apify/log": "^2.4.0",
+				"@crawlee/types": "3.18.1",
+				"@sapphire/async-queue": "^1.5.0",
+				"@sapphire/shapeshift": "^3.0.0",
+				"content-type": "^1.0.4",
+				"fs-extra": "^11.0.0",
+				"json5": "^2.2.3",
+				"mime-types": "^2.1.35",
+				"p-limit": "^3.1.0",
+				"proper-lockfile": "^4.1.2",
+				"tslib": "^2.4.0"
+			},
+			"engines": {
+				"node": ">= 16"
+			}
+		},
+		"node_modules/@crawlee/types": {
+			"version": "3.18.1",
+			"resolved": "https://registry.npmjs.org/@crawlee/types/-/types-3.18.1.tgz",
+			"integrity": "sha512-jmV7HN4b1vEzriGcKhCRa8A5rv5HaqBPPfneGRxPpZtbmnEcusHTmEOOyG393lUBmv0yaM03da0hy+PZnR35vw==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"tslib": "^2.4.0"
+			},
+			"engines": {
+				"node": ">=16.0.0"
+			}
+		},
+		"node_modules/@crawlee/utils": {
+			"version": "3.18.1",
+			"resolved": "https://registry.npmjs.org/@crawlee/utils/-/utils-3.18.1.tgz",
+			"integrity": "sha512-NS9eCmaH+jcjLHfq2WIKp5yfKxQGEcuLOAwzugFcnH38D/EwCgYXYtnDxidFZB8qbuuONFfDpVfyHohc4mNDhw==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"@apify/log": "^2.4.0",
+				"@apify/ps-tree": "^1.2.0",
+				"@crawlee/types": "3.18.1",
+				"@types/sax": "^1.2.7",
+				"cheerio": "1.0.0-rc.12",
+				"file-type": "^21.3.1",
+				"got-scraping": "^4.2.1",
+				"ow": "^0.28.1",
+				"robots-parser": "^3.0.1",
+				"sax": "^1.4.1",
+				"tldts": "^7.0.0",
+				"tslib": "^2.4.0",
+				"whatwg-mimetype": "^4.0.0"
+			},
+			"engines": {
+				"node": ">=16.0.0"
+			}
+		},
+		"node_modules/@keyv/serialize": {
+			"version": "1.1.1",
+			"resolved": "https://registry.npmjs.org/@keyv/serialize/-/serialize-1.1.1.tgz",
+			"integrity": "sha512-dXn3FZhPv0US+7dtJsIi2R+c7qWYiReoEh5zUntWCf4oSpMNib8FDhSoed6m3QyZdx5hK7iLFkYk3rNxwt8vTA==",
+			"license": "MIT"
+		},
+		"node_modules/@sapphire/async-queue": {
+			"version": "1.5.5",
+			"resolved": "https://registry.npmjs.org/@sapphire/async-queue/-/async-queue-1.5.5.tgz",
+			"integrity": "sha512-cvGzxbba6sav2zZkH8GPf2oGk9yYoD5qrNWdu9fRehifgnFZJMV+nuy2nON2roRO4yQQ+v7MK/Pktl/HgfsUXg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=v14.0.0",
+				"npm": ">=7.0.0"
+			}
+		},
+		"node_modules/@sapphire/shapeshift": {
+			"version": "3.9.7",
+			"resolved": "https://registry.npmjs.org/@sapphire/shapeshift/-/shapeshift-3.9.7.tgz",
+			"integrity": "sha512-4It2mxPSr4OGn4HSQWGmhFMsNFGfFVhWeRPCRwbH972Ek2pzfGRZtb0pJ4Ze6oIzcyh2jw7nUDa6qGlWofgd9g==",
+			"license": "MIT",
+			"dependencies": {
+				"fast-deep-equal": "^3.1.3",
+				"lodash": "^4.17.21"
+			},
+			"engines": {
+				"node": ">=v16"
+			}
+		},
+		"node_modules/@sec-ant/readable-stream": {
+			"version": "0.4.1",
+			"resolved": "https://registry.npmjs.org/@sec-ant/readable-stream/-/readable-stream-0.4.1.tgz",
+			"integrity": "sha512-831qok9r2t8AlxLko40y2ebgSDhenenCatLVeW/uBtnHPyhHOvG0C7TvfgecV+wHzIm5KUICgzmVpWS+IMEAeg==",
+			"license": "MIT"
+		},
+		"node_modules/@sindresorhus/is": {
+			"version": "7.2.0",
+			"resolved": "https://registry.npmjs.org/@sindresorhus/is/-/is-7.2.0.tgz",
+			"integrity": "sha512-P1Cz1dWaFfR4IR+U13mqqiGsLFf1KbayybWwdd2vfctdV6hDpUkgCY0nKOLLTMSoRd/jJNjtbqzf13K8DCCXQw==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=18"
+			},
+			"funding": {
+				"url": "https://github.com/sindresorhus/is?sponsor=1"
+			}
+		},
+		"node_modules/@standard-schema/spec": {
+			"version": "1.1.0",
+			"resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.1.0.tgz",
+			"integrity": "sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==",
+			"license": "MIT"
+		},
+		"node_modules/@tokenizer/inflate": {
+			"version": "0.4.1",
+			"resolved": "https://registry.npmjs.org/@tokenizer/inflate/-/inflate-0.4.1.tgz",
+			"integrity": "sha512-2mAv+8pkG6GIZiF1kNg1jAjh27IDxEPKwdGul3snfztFerfPGI1LjDezZp3i7BElXompqEtPmoPx6c2wgtWsOA==",
+			"license": "MIT",
+			"dependencies": {
+				"debug": "^4.4.3",
+				"token-types": "^6.1.1"
+			},
+			"engines": {
+				"node": ">=18"
+			},
+			"funding": {
+				"type": "github",
+				"url": "https://github.com/sponsors/Borewit"
+			}
+		},
+		"node_modules/@tokenizer/token": {
+			"version": "0.3.0",
+			"resolved": "https://registry.npmjs.org/@tokenizer/token/-/token-0.3.0.tgz",
+			"integrity": "sha512-OvjF+z51L3ov0OyAU0duzsYuvO01PH7x4t6DJx+guahgTnBHkhJdG7soQeTSFLWN3efnHyibZ4Z8l2EuWwJN3A==",
+			"license": "MIT"
+		},
+		"node_modules/@tootallnate/quickjs-emscripten": {
+			"version": "0.23.0",
+			"resolved": "https://registry.npmjs.org/@tootallnate/quickjs-emscripten/-/quickjs-emscripten-0.23.0.tgz",
+			"integrity": "sha512-C5Mc6rdnsaJDjO3UpGW/CQTHtCKaYlScZTly4JIu97Jxo/odCiH0ITnDXSJPTOrEKk/ycSZ0AOgTmkDtkOsvIA==",
+			"license": "MIT"
+		},
+		"node_modules/@types/http-cache-semantics": {
+			"version": "4.2.0",
+			"resolved": "https://registry.npmjs.org/@types/http-cache-semantics/-/http-cache-semantics-4.2.0.tgz",
+			"integrity": "sha512-L3LgimLHXtGkWikKnsPg0/VFx9OGZaC+eN1u4r+OB1XRqH3meBIAVC2zr1WdMH+RHmnRkqliQAOHNJ/E0j/e0Q==",
+			"license": "MIT"
+		},
+		"node_modules/@types/node": {
+			"version": "24.13.6",
+			"resolved": "https://registry.npmjs.org/@types/node/-/node-24.13.6.tgz",
+			"integrity": "sha512-SGrw/h3KPFshy3OE6ZL53LMBG5vGQQ8/gIpiqz/kRZhPJ7HgwCEs8LBuNtWLa8dvGZVpSF7+Bf+c11HUrCb/yg==",
+			"license": "MIT",
+			"dependencies": {
+				"undici-types": "~7.18.0"
+			}
+		},
+		"node_modules/@types/sax": {
+			"version": "1.2.7",
+			"resolved": "https://registry.npmjs.org/@types/sax/-/sax-1.2.7.tgz",
+			"integrity": "sha512-rO73L89PJxeYM3s3pPPjiPgVVcymqU490g0YO5n5By0k2Erzj6tay/4lr1CHAAU4JyOWd1rpQ8bCf6cZfHU96A==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/node": "*"
+			}
+		},
+		"node_modules/@vladfrangu/async_event_emitter": {
+			"version": "2.4.7",
+			"resolved": "https://registry.npmjs.org/@vladfrangu/async_event_emitter/-/async_event_emitter-2.4.7.tgz",
+			"integrity": "sha512-Xfe6rpCTxSxfbswi/W/Pz7zp1WWSNn4A0eW4mLkQUewCrXXtMj31lCg+iQyTkh/CkusZSq9eDflu7tjEDXUY6g==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=v14.0.0",
+				"npm": ">=7.0.0"
+			}
+		},
+		"node_modules/adm-zip": {
+			"version": "0.6.1",
+			"resolved": "https://registry.npmjs.org/adm-zip/-/adm-zip-0.6.1.tgz",
+			"integrity": "sha512-Xwrja8nx9e5o2N1my4DsKCeKpdrnACyr1wtbPxBDgGzKzKyE9kRtBFA8mWldI+RVlD7CBZNWY/wQ2+ydwOR6kQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=14.0"
+			}
+		},
+		"node_modules/agent-base": {
+			"version": "6.0.2",
+			"resolved": "https://registry.npmjs.org/agent-base/-/agent-base-6.0.2.tgz",
+			"integrity": "sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==",
+			"license": "MIT",
+			"dependencies": {
+				"debug": "4"
+			},
+			"engines": {
+				"node": ">= 6.0.0"
+			}
+		},
+		"node_modules/ansi-colors": {
+			"version": "4.1.3",
+			"resolved": "https://registry.npmjs.org/ansi-colors/-/ansi-colors-4.1.3.tgz",
+			"integrity": "sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=6"
+			}
+		},
+		"node_modules/apify": {
+			"version": "3.7.2",
+			"resolved": "https://registry.npmjs.org/apify/-/apify-3.7.2.tgz",
+			"integrity": "sha512-I4R5Qd1X11vk5/1U0CxKSsMhNwER/3MntePEQb9Pbtf942OhQLh5IURrJZufqtpimkqRy44SlQMU6UhPdoFXhA==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"@apify/consts": "^2.51.0",
+				"@apify/input_secrets": "^1.2.0",
+				"@apify/log": "^2.4.3",
+				"@apify/timeout": "^0.3.0",
+				"@apify/utilities": "^2.13.0",
+				"@crawlee/core": "^3.14.1",
+				"@crawlee/types": "^3.14.1",
+				"@crawlee/utils": "^3.14.1",
+				"apify-client": "^2.17.0",
+				"fs-extra": "^11.2.0",
+				"ow": "^0.28.2",
+				"semver": "^7.5.4",
+				"tslib": "^2.6.2",
+				"ws": "^8.18.0"
+			},
+			"engines": {
+				"node": ">=16.0.0"
+			}
+		},
+		"node_modules/apify-client": {
+			"version": "2.25.0",
+			"resolved": "https://registry.npmjs.org/apify-client/-/apify-client-2.25.0.tgz",
+			"integrity": "sha512-g6ttHJ4Au/Gg0iDHIevN3CvTbJfey9DUXUXJxe0ORF6JIYaVVfKdyJjINGb6/49gOpt/62ZFPw+HSEVIzrwR5w==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"@apify/consts": "^2.50.0",
+				"@apify/log": "^2.2.6",
+				"@apify/utilities": "^2.23.2",
+				"@crawlee/types": "^3.3.0",
+				"ansi-colors": "^4.1.1",
+				"async-retry": "^1.3.3",
+				"axios": "^1.16.0",
+				"content-type": "^1.0.5",
+				"ow": "^0.28.2",
+				"proxy-agent": "^6.5.0",
+				"tslib": "^2.5.0",
+				"type-fest": "^4.0.0"
+			}
+		},
+		"node_modules/ast-types": {
+			"version": "0.13.4",
+			"resolved": "https://registry.npmjs.org/ast-types/-/ast-types-0.13.4.tgz",
+			"integrity": "sha512-x1FCFnFifvYDDzTaLII71vG5uvDwgtmDTEVWAxrgeiR8VjMONcCXJx7E+USjDtHlwFmt9MysbqgF9b9Vjr6w+w==",
+			"license": "MIT",
+			"dependencies": {
+				"tslib": "^2.0.1"
+			},
+			"engines": {
+				"node": ">=4"
+			}
+		},
+		"node_modules/async-retry": {
+			"version": "1.3.3",
+			"resolved": "https://registry.npmjs.org/async-retry/-/async-retry-1.3.3.tgz",
+			"integrity": "sha512-wfr/jstw9xNi/0teMHrRW7dsz3Lt5ARhYNZ2ewpadnhaIp5mbALhOAP+EAdsC7t4Z6wqsDVv9+W6gm1Dk9mEyw==",
+			"license": "MIT",
+			"dependencies": {
+				"retry": "0.13.1"
+			}
+		},
+		"node_modules/asynckit": {
+			"version": "0.4.0",
+			"resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
+			"integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==",
+			"license": "MIT"
+		},
+		"node_modules/axios": {
+			"version": "1.20.0",
+			"resolved": "https://registry.npmjs.org/axios/-/axios-1.20.0.tgz",
+			"integrity": "sha512-r8aOh8j9cGKpgQAqpzrUHnSIc6a59Y3Xf/cv8sy1DrHCkZHzQGEuoq1tARk6qSyDdtQGSDgpb9kFlruzPvrgwg==",
+			"license": "MIT",
+			"dependencies": {
+				"follow-redirects": "^1.16.0",
+				"form-data": "^4.0.6",
+				"https-proxy-agent": "^5.0.1",
+				"proxy-from-env": "^2.1.0"
+			}
+		},
+		"node_modules/balanced-match": {
+			"version": "1.0.2",
+			"resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+			"integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+			"license": "MIT"
+		},
+		"node_modules/baseline-browser-mapping": {
+			"version": "2.11.25",
+			"resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.11.25.tgz",
+			"integrity": "sha512-gMmEShwwq7FJqMwvfRwvCl00v4kN+KOfJqXn+f4nrufak5gNHJOksd/60Dvjuz7sI8Y5WiSFBa8FEYr+zoyqCw==",
+			"license": "Apache-2.0",
+			"bin": {
+				"baseline-browser-mapping": "dist/cli.cjs"
+			},
+			"engines": {
+				"node": ">=6.0.0"
+			}
+		},
+		"node_modules/basic-ftp": {
+			"version": "5.3.1",
+			"resolved": "https://registry.npmjs.org/basic-ftp/-/basic-ftp-5.3.1.tgz",
+			"integrity": "sha512-bopVNp6ugyA150DDuZfPFdt1KZ5a94ZDiwX4hMgZDzF+GttD80lEy8kj98kbyhLXnPvhtIo93mdnLIjpCAeeOw==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=10.0.0"
+			}
+		},
+		"node_modules/boolbase": {
+			"version": "1.0.0",
+			"resolved": "https://registry.npmjs.org/boolbase/-/boolbase-1.0.0.tgz",
+			"integrity": "sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww==",
+			"license": "ISC"
+		},
+		"node_modules/brace-expansion": {
+			"version": "2.1.7",
+			"resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.1.7.tgz",
+			"integrity": "sha512-uZbew1NqdmPDTMJ8ah1y+b+9QEJrfkXFk3RcTQw3X0jW/xRUvFKsg1CfQdSYGdTbXZWExtU3J3ccxtnfw1Fi0g==",
+			"license": "MIT",
+			"dependencies": {
+				"balanced-match": "^1.0.0"
+			}
+		},
+		"node_modules/browserslist": {
+			"version": "4.29.0",
+			"resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.29.0.tgz",
+			"integrity": "sha512-3GSvyjvDI4Dur1Meg2BekJquu5uF+9R9a1+5M1Mde192eZoXbeXjzgOsgqPS2V8D5wrrip0gR5Hf/GhWQ9ZzaA==",
+			"funding": [
+				{
+					"type": "opencollective",
+					"url": "https://opencollective.com/browserslist"
+				},
+				{
+					"type": "tidelift",
+					"url": "https://tidelift.com/funding/github/npm/browserslist"
+				},
+				{
+					"type": "github",
+					"url": "https://github.com/sponsors/ai"
+				}
+			],
+			"license": "MIT",
+			"dependencies": {
+				"baseline-browser-mapping": "^2.11.23",
+				"caniuse-lite": "^1.0.30001810",
+				"electron-to-chromium": "^1.5.427",
+				"node-releases": "^2.0.55",
+				"update-browserslist-db": "^1.3.3"
+			},
+			"bin": {
+				"browserslist": "cli.js"
+			},
+			"engines": {
+				"node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
+			}
+		},
+		"node_modules/byte-counter": {
+			"version": "0.1.0",
+			"resolved": "https://registry.npmjs.org/byte-counter/-/byte-counter-0.1.0.tgz",
+			"integrity": "sha512-jheRLVMeUKrDBjVw2O5+k4EvR4t9wtxHL+bo/LxfkxsVeuGMy3a5SEGgXdAFA4FSzTrU8rQXQIrsZ3oBq5a0pQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=20"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/cacheable-lookup": {
+			"version": "7.0.0",
+			"resolved": "https://registry.npmjs.org/cacheable-lookup/-/cacheable-lookup-7.0.0.tgz",
+			"integrity": "sha512-+qJyx4xiKra8mZrcwhjMRMUhD5NR1R8esPkzIYxX96JiecFoxAXFuz/GpR3+ev4PE1WamHip78wV0vcmPQtp8w==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=14.16"
+			}
+		},
+		"node_modules/cacheable-request": {
+			"version": "13.0.19",
+			"resolved": "https://registry.npmjs.org/cacheable-request/-/cacheable-request-13.0.19.tgz",
+			"integrity": "sha512-SVXGH037+Mo1aIMO5B2UcleR43FGjFdN+M8JObSyEoQ2Mn4CODRWx28gN5jiTF0n5ItsgtIZfyargMNs8GX4kg==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/http-cache-semantics": "^4.2.0",
+				"get-stream": "^9.0.1",
+				"http-cache-semantics": "^4.2.0",
+				"keyv": "^5.6.0",
+				"mimic-response": "^4.0.0",
+				"normalize-url": "^8.1.1",
+				"responselike": "^4.0.2"
+			},
+			"engines": {
+				"node": ">=18"
+			}
+		},
+		"node_modules/call-bind-apply-helpers": {
+			"version": "1.0.2",
+			"resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
+			"integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
+			"license": "MIT",
+			"dependencies": {
+				"es-errors": "^1.3.0",
+				"function-bind": "^1.1.2"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			}
+		},
+		"node_modules/callsites": {
+			"version": "3.1.0",
+			"resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
+			"integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=6"
+			}
+		},
+		"node_modules/caniuse-lite": {
+			"version": "1.0.30001812",
+			"resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001812.tgz",
+			"integrity": "sha512-qN+QNNBr93TCmFrmte0bBCjSDMuRvt78VlHT99qIGPszm4QsqCX8lnyWUFkHi8B7ZBAPq8SH+UqyXNy/odMdng==",
+			"funding": [
+				{
+					"type": "opencollective",
+					"url": "https://opencollective.com/browserslist"
+				},
+				{
+					"type": "tidelift",
+					"url": "https://tidelift.com/funding/github/npm/caniuse-lite"
+				},
+				{
+					"type": "github",
+					"url": "https://github.com/sponsors/ai"
+				}
+			],
+			"license": "CC-BY-4.0"
+		},
+		"node_modules/cheerio": {
+			"version": "1.0.0-rc.12",
+			"resolved": "https://registry.npmjs.org/cheerio/-/cheerio-1.0.0-rc.12.tgz",
+			"integrity": "sha512-VqR8m68vM46BNnuZ5NtnGBKIE/DfN0cRIzg9n40EIq9NOv90ayxLBXA8fXC5gquFRGJSTRqBq25Jt2ECLR431Q==",
+			"license": "MIT",
+			"dependencies": {
+				"cheerio-select": "^2.1.0",
+				"dom-serializer": "^2.0.0",
+				"domhandler": "^5.0.3",
+				"domutils": "^3.0.1",
+				"htmlparser2": "^8.0.1",
+				"parse5": "^7.0.0",
+				"parse5-htmlparser2-tree-adapter": "^7.0.0"
+			},
+			"engines": {
+				"node": ">= 6"
+			},
+			"funding": {
+				"url": "https://github.com/cheeriojs/cheerio?sponsor=1"
+			}
+		},
+		"node_modules/cheerio-select": {
+			"version": "2.1.0",
+			"resolved": "https://registry.npmjs.org/cheerio-select/-/cheerio-select-2.1.0.tgz",
+			"integrity": "sha512-9v9kG0LvzrlcungtnJtpGNxY+fzECQKhK4EGJX2vByejiMX84MFNQw4UxPJl3bFbTMw+Dfs37XaIkCwTZfLh4g==",
+			"license": "BSD-2-Clause",
+			"dependencies": {
+				"boolbase": "^1.0.0",
+				"css-select": "^5.1.0",
+				"css-what": "^6.1.0",
+				"domelementtype": "^2.3.0",
+				"domhandler": "^5.0.3",
+				"domutils": "^3.0.1"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/fb55"
+			}
+		},
+		"node_modules/combined-stream": {
+			"version": "1.0.8",
+			"resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
+			"integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
+			"license": "MIT",
+			"dependencies": {
+				"delayed-stream": "~1.0.0"
+			},
+			"engines": {
+				"node": ">= 0.8"
+			}
+		},
+		"node_modules/content-type": {
+			"version": "1.0.5",
+			"resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz",
+			"integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.6"
+			}
+		},
+		"node_modules/css-select": {
+			"version": "5.2.2",
+			"resolved": "https://registry.npmjs.org/css-select/-/css-select-5.2.2.tgz",
+			"integrity": "sha512-TizTzUddG/xYLA3NXodFM0fSbNizXjOKhqiQQwvhlspadZokn1KDy0NZFS0wuEubIYAV5/c1/lAr0TaaFXEXzw==",
+			"license": "BSD-2-Clause",
+			"dependencies": {
+				"boolbase": "^1.0.0",
+				"css-what": "^6.1.0",
+				"domhandler": "^5.0.2",
+				"domutils": "^3.0.1",
+				"nth-check": "^2.0.1"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/fb55"
+			}
+		},
+		"node_modules/css-what": {
+			"version": "6.2.2",
+			"resolved": "https://registry.npmjs.org/css-what/-/css-what-6.2.2.tgz",
+			"integrity": "sha512-u/O3vwbptzhMs3L1fQE82ZSLHQQfto5gyZzwteVIEyeaY5Fc7R4dapF/BvRoSYFeqfBk4m0V1Vafq5Pjv25wvA==",
+			"license": "BSD-2-Clause",
+			"engines": {
+				"node": ">= 6"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/fb55"
+			}
+		},
+		"node_modules/csv-stringify": {
+			"version": "6.8.3",
+			"resolved": "https://registry.npmjs.org/csv-stringify/-/csv-stringify-6.8.3.tgz",
+			"integrity": "sha512-gIeSCvq5F4VtXV3naV3VAewLhBkiZBz+PPhTOA8H3Y8h/ELa+R1ml0GZck/4/Nzo9ep2lvOluilJ6MJlbZsKMA==",
+			"license": "MIT"
+		},
+		"node_modules/data-uri-to-buffer": {
+			"version": "6.0.2",
+			"resolved": "https://registry.npmjs.org/data-uri-to-buffer/-/data-uri-to-buffer-6.0.2.tgz",
+			"integrity": "sha512-7hvf7/GW8e86rW0ptuwS3OcBGDjIi6SZva7hCyWC0yYry2cOPmLIjXAUHI6DK2HsnwJd9ifmt57i8eV2n4YNpw==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 14"
+			}
+		},
+		"node_modules/debug": {
+			"version": "4.4.3",
+			"resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
+			"integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+			"license": "MIT",
+			"dependencies": {
+				"ms": "^2.1.3"
+			},
+			"engines": {
+				"node": ">=6.0"
+			},
+			"peerDependenciesMeta": {
+				"supports-color": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/decompress-response": {
+			"version": "10.0.0",
+			"resolved": "https://registry.npmjs.org/decompress-response/-/decompress-response-10.0.0.tgz",
+			"integrity": "sha512-oj7KWToJuuxlPr7VV0vabvxEIiqNMo+q0NueIiL3XhtwC6FVOX7Hr1c0C4eD0bmf7Zr+S/dSf2xvkH3Ad6sU3Q==",
+			"license": "MIT",
+			"dependencies": {
+				"mimic-response": "^4.0.0"
+			},
+			"engines": {
+				"node": ">=20"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/degenerator": {
+			"version": "5.0.1",
+			"resolved": "https://registry.npmjs.org/degenerator/-/degenerator-5.0.1.tgz",
+			"integrity": "sha512-TllpMR/t0M5sqCXfj85i4XaAzxmS5tVA16dqvdkMwGmzI+dXLXnw3J+3Vdv7VKw+ThlTMboK6i9rnZ6Nntj5CQ==",
+			"license": "MIT",
+			"dependencies": {
+				"ast-types": "^0.13.4",
+				"escodegen": "^2.1.0",
+				"esprima": "^4.0.1"
+			},
+			"engines": {
+				"node": ">= 14"
+			}
+		},
+		"node_modules/delayed-stream": {
+			"version": "1.0.0",
+			"resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
+			"integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=0.4.0"
+			}
+		},
+		"node_modules/dom-serializer": {
+			"version": "2.0.0",
+			"resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-2.0.0.tgz",
+			"integrity": "sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg==",
+			"license": "MIT",
+			"dependencies": {
+				"domelementtype": "^2.3.0",
+				"domhandler": "^5.0.2",
+				"entities": "^4.2.0"
+			},
+			"funding": {
+				"url": "https://github.com/cheeriojs/dom-serializer?sponsor=1"
+			}
+		},
+		"node_modules/domelementtype": {
+			"version": "2.3.0",
+			"resolved": "https://registry.npmjs.org/domelementtype/-/domelementtype-2.3.0.tgz",
+			"integrity": "sha512-OLETBj6w0OsagBwdXnPdN0cnMfF9opN69co+7ZrbfPGrdpPVNBUj02spi6B1N7wChLQiPn4CSH/zJvXw56gmHw==",
+			"funding": [
+				{
+					"type": "github",
+					"url": "https://github.com/sponsors/fb55"
+				}
+			],
+			"license": "BSD-2-Clause"
+		},
+		"node_modules/domhandler": {
+			"version": "5.0.3",
+			"resolved": "https://registry.npmjs.org/domhandler/-/domhandler-5.0.3.tgz",
+			"integrity": "sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w==",
+			"license": "BSD-2-Clause",
+			"dependencies": {
+				"domelementtype": "^2.3.0"
+			},
+			"engines": {
+				"node": ">= 4"
+			},
+			"funding": {
+				"url": "https://github.com/fb55/domhandler?sponsor=1"
+			}
+		},
+		"node_modules/domutils": {
+			"version": "3.2.2",
+			"resolved": "https://registry.npmjs.org/domutils/-/domutils-3.2.2.tgz",
+			"integrity": "sha512-6kZKyUajlDuqlHKVX1w7gyslj9MPIXzIFiz/rGu35uC1wMi+kMhQwGhl4lt9unC9Vb9INnY9Z3/ZA3+FhASLaw==",
+			"license": "BSD-2-Clause",
+			"dependencies": {
+				"dom-serializer": "^2.0.0",
+				"domelementtype": "^2.3.0",
+				"domhandler": "^5.0.3"
+			},
+			"funding": {
+				"url": "https://github.com/fb55/domutils?sponsor=1"
+			}
+		},
+		"node_modules/dot-prop": {
+			"version": "6.0.1",
+			"resolved": "https://registry.npmjs.org/dot-prop/-/dot-prop-6.0.1.tgz",
+			"integrity": "sha512-tE7ztYzXHIeyvc7N+hR3oi7FIbf/NIjVP9hmAt3yMXzrQ072/fpjGLx2GxNxGxUl5V73MEqYzioOMoVhGMJ5cA==",
+			"license": "MIT",
+			"dependencies": {
+				"is-obj": "^2.0.0"
+			},
+			"engines": {
+				"node": ">=10"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/dunder-proto": {
+			"version": "1.0.1",
+			"resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
+			"integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
+			"license": "MIT",
+			"dependencies": {
+				"call-bind-apply-helpers": "^1.0.1",
+				"es-errors": "^1.3.0",
+				"gopd": "^1.2.0"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			}
+		},
+		"node_modules/duplexer": {
+			"version": "0.1.2",
+			"resolved": "https://registry.npmjs.org/duplexer/-/duplexer-0.1.2.tgz",
+			"integrity": "sha512-jtD6YG370ZCIi/9GTaJKQxWTZD045+4R4hTk/x1UyoqadyJ9x9CgSi1RlVDQF8U2sxLLSnFkCaMihqljHIWgMg==",
+			"license": "MIT"
+		},
+		"node_modules/electron-to-chromium": {
+			"version": "1.5.438",
+			"resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.438.tgz",
+			"integrity": "sha512-AN9xMU1hJiT65LkCUPL1DZm5TCbOPb2Qsm5pYwFLEXp6/qj9SdT4yMiqs7Qqstwvkn1zF7l36SRGt+s6XcJ0FA==",
+			"license": "ISC"
+		},
+		"node_modules/entities": {
+			"version": "4.5.0",
+			"resolved": "https://registry.npmjs.org/entities/-/entities-4.5.0.tgz",
+			"integrity": "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==",
+			"license": "BSD-2-Clause",
+			"engines": {
+				"node": ">=0.12"
+			},
+			"funding": {
+				"url": "https://github.com/fb55/entities?sponsor=1"
+			}
+		},
+		"node_modules/es-define-property": {
+			"version": "1.0.1",
+			"resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
+			"integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.4"
+			}
+		},
+		"node_modules/es-errors": {
+			"version": "1.3.0",
+			"resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
+			"integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.4"
+			}
+		},
+		"node_modules/es-object-atoms": {
+			"version": "1.1.2",
+			"resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.2.tgz",
+			"integrity": "sha512-HWcBoN6NileqtSydK2FqHbS/LoDd2pqrnQHLyJzBj4kOp/ky2MWMN694xOfkK8/SnUsW2DH7EfyVlydKCsm1Zw==",
+			"license": "MIT",
+			"dependencies": {
+				"es-errors": "^1.3.0"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			}
+		},
+		"node_modules/es-set-tostringtag": {
+			"version": "2.1.0",
+			"resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz",
+			"integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==",
+			"license": "MIT",
+			"dependencies": {
+				"es-errors": "^1.3.0",
+				"get-intrinsic": "^1.2.6",
+				"has-tostringtag": "^1.0.2",
+				"hasown": "^2.0.2"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			}
+		},
+		"node_modules/escalade": {
+			"version": "3.2.0",
+			"resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+			"integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=6"
+			}
+		},
+		"node_modules/escodegen": {
+			"version": "2.1.0",
+			"resolved": "https://registry.npmjs.org/escodegen/-/escodegen-2.1.0.tgz",
+			"integrity": "sha512-2NlIDTwUWJN0mRPQOdtQBzbUHvdGY2P1VXSyU83Q3xKxM7WHX2Ql8dKq782Q9TgQUNOLEzEYu9bzLNj1q88I5w==",
+			"license": "BSD-2-Clause",
+			"dependencies": {
+				"esprima": "^4.0.1",
+				"estraverse": "^5.2.0",
+				"esutils": "^2.0.2"
+			},
+			"bin": {
+				"escodegen": "bin/escodegen.js",
+				"esgenerate": "bin/esgenerate.js"
+			},
+			"engines": {
+				"node": ">=6.0"
+			},
+			"optionalDependencies": {
+				"source-map": "~0.6.1"
+			}
+		},
+		"node_modules/esprima": {
+			"version": "4.0.1",
+			"resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz",
+			"integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==",
+			"license": "BSD-2-Clause",
+			"bin": {
+				"esparse": "bin/esparse.js",
+				"esvalidate": "bin/esvalidate.js"
+			},
+			"engines": {
+				"node": ">=4"
+			}
+		},
+		"node_modules/estraverse": {
+			"version": "5.3.0",
+			"resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz",
+			"integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==",
+			"license": "BSD-2-Clause",
+			"engines": {
+				"node": ">=4.0"
+			}
+		},
+		"node_modules/esutils": {
+			"version": "2.0.3",
+			"resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
+			"integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==",
+			"license": "BSD-2-Clause",
+			"engines": {
+				"node": ">=0.10.0"
+			}
+		},
+		"node_modules/event-stream": {
+			"version": "3.3.4",
+			"resolved": "https://registry.npmjs.org/event-stream/-/event-stream-3.3.4.tgz",
+			"integrity": "sha512-QHpkERcGsR0T7Qm3HNJSyXKEEj8AHNxkY3PK8TS2KJvQ7NiSHe3DDpwVKKtoYprL/AreyzFBeIkBIWChAqn60g==",
+			"license": "MIT",
+			"dependencies": {
+				"duplexer": "~0.1.1",
+				"from": "~0",
+				"map-stream": "~0.1.0",
+				"pause-stream": "0.0.11",
+				"split": "0.3",
+				"stream-combiner": "~0.0.4",
+				"through": "~2.3.1"
+			}
+		},
+		"node_modules/fast-deep-equal": {
+			"version": "3.1.3",
+			"resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
+			"integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
+			"license": "MIT"
+		},
+		"node_modules/file-type": {
+			"version": "21.3.4",
+			"resolved": "https://registry.npmjs.org/file-type/-/file-type-21.3.4.tgz",
+			"integrity": "sha512-Ievi/yy8DS3ygGvT47PjSfdFoX+2isQueoYP1cntFW1JLYAuS4GD7NUPGg4zv2iZfV52uDyk5w5Z0TdpRS6Q1g==",
+			"license": "MIT",
+			"dependencies": {
+				"@tokenizer/inflate": "^0.4.1",
+				"strtok3": "^10.3.4",
+				"token-types": "^6.1.1",
+				"uint8array-extras": "^1.4.0"
+			},
+			"engines": {
+				"node": ">=20"
+			},
+			"funding": {
+				"url": "https://github.com/sindresorhus/file-type?sponsor=1"
+			}
+		},
+		"node_modules/follow-redirects": {
+			"version": "1.16.0",
+			"resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.16.0.tgz",
+			"integrity": "sha512-y5rN/uOsadFT/JfYwhxRS5R7Qce+g3zG97+JrtFZlC9klX/W5hD7iiLzScI4nZqUS7DNUdhPgw4xI8W2LuXlUw==",
+			"funding": [
+				{
+					"type": "individual",
+					"url": "https://github.com/sponsors/RubenVerborgh"
+				}
+			],
+			"license": "MIT",
+			"engines": {
+				"node": ">=4.0"
+			},
+			"peerDependenciesMeta": {
+				"debug": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/form-data": {
+			"version": "4.0.6",
+			"resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.6.tgz",
+			"integrity": "sha512-vKatAh4SlVfgbv+YtmhiRjhEMJsYpsG1Y2rMQtR+SVSbytsSD1YGzDIcrAJmdFec88u/+VoGmxnl+80gL1tRCQ==",
+			"license": "MIT",
+			"dependencies": {
+				"asynckit": "^0.4.0",
+				"combined-stream": "^1.0.8",
+				"es-set-tostringtag": "^2.1.0",
+				"hasown": "^2.0.4",
+				"mime-types": "^2.1.35"
+			},
+			"engines": {
+				"node": ">= 6"
+			}
+		},
+		"node_modules/form-data-encoder": {
+			"version": "4.1.0",
+			"resolved": "https://registry.npmjs.org/form-data-encoder/-/form-data-encoder-4.1.0.tgz",
+			"integrity": "sha512-G6NsmEW15s0Uw9XnCg+33H3ViYRyiM0hMrMhhqQOR8NFc5GhYrI+6I3u7OTw7b91J2g8rtvMBZJDbcGb2YUniw==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 18"
+			}
+		},
+		"node_modules/from": {
+			"version": "0.1.7",
+			"resolved": "https://registry.npmjs.org/from/-/from-0.1.7.tgz",
+			"integrity": "sha512-twe20eF1OxVxp/ML/kq2p1uc6KvFK/+vs8WjEbeKmV2He22MKm7YF2ANIt+EOqhJ5L3K/SuuPhk0hWQDjOM23g==",
+			"license": "MIT"
+		},
+		"node_modules/fs-extra": {
+			"version": "11.4.1",
+			"resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.4.1.tgz",
+			"integrity": "sha512-KYAb4c9BJQI6QqGKthV68OHe0badztdXJWKo0WtBA9IuCFPTKvE5ZdUBglP833aMjhaSPNO4A5j/EkzZtGlKjA==",
+			"license": "MIT",
+			"dependencies": {
+				"graceful-fs": "^4.2.0",
+				"jsonfile": "^6.0.1",
+				"universalify": "^2.0.0"
+			},
+			"engines": {
+				"node": ">=14.14"
+			}
+		},
+		"node_modules/function-bind": {
+			"version": "1.1.2",
+			"resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
+			"integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
+			"license": "MIT",
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/generative-bayesian-network": {
+			"version": "2.1.88",
+			"resolved": "https://registry.npmjs.org/generative-bayesian-network/-/generative-bayesian-network-2.1.88.tgz",
+			"integrity": "sha512-kxbW6CCsiEAVdBYPont/6ZVOa47Pyfv5ldYFIvj8wmOx9uQOZ4c8wdR0jEf2pE6DeVuIAfmolm+91bYne6/3uA==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"adm-zip": "^0.6.0",
+				"tslib": "^2.4.0"
+			}
+		},
+		"node_modules/get-intrinsic": {
+			"version": "1.3.0",
+			"resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
+			"integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
+			"license": "MIT",
+			"dependencies": {
+				"call-bind-apply-helpers": "^1.0.2",
+				"es-define-property": "^1.0.1",
+				"es-errors": "^1.3.0",
+				"es-object-atoms": "^1.1.1",
+				"function-bind": "^1.1.2",
+				"get-proto": "^1.0.1",
+				"gopd": "^1.2.0",
+				"has-symbols": "^1.1.0",
+				"hasown": "^2.0.2",
+				"math-intrinsics": "^1.1.0"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/get-proto": {
+			"version": "1.0.1",
+			"resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
+			"integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
+			"license": "MIT",
+			"dependencies": {
+				"dunder-proto": "^1.0.1",
+				"es-object-atoms": "^1.0.0"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			}
+		},
+		"node_modules/get-stream": {
+			"version": "9.0.1",
+			"resolved": "https://registry.npmjs.org/get-stream/-/get-stream-9.0.1.tgz",
+			"integrity": "sha512-kVCxPF3vQM/N0B1PmoqVUqgHP+EeVjmZSQn+1oCRPxd2P21P2F19lIgbR3HBosbB1PUhOAoctJnfEn2GbN2eZA==",
+			"license": "MIT",
+			"dependencies": {
+				"@sec-ant/readable-stream": "^0.4.1",
+				"is-stream": "^4.0.1"
+			},
+			"engines": {
+				"node": ">=18"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/get-uri": {
+			"version": "6.0.5",
+			"resolved": "https://registry.npmjs.org/get-uri/-/get-uri-6.0.5.tgz",
+			"integrity": "sha512-b1O07XYq8eRuVzBNgJLstU6FYc1tS6wnMtF1I1D9lE8LxZSOGZ7LhxN54yPP6mGw5f2CkXY2BQUL9Fx41qvcIg==",
+			"license": "MIT",
+			"dependencies": {
+				"basic-ftp": "^5.0.2",
+				"data-uri-to-buffer": "^6.0.2",
+				"debug": "^4.3.4"
+			},
+			"engines": {
+				"node": ">= 14"
+			}
+		},
+		"node_modules/gopd": {
+			"version": "1.2.0",
+			"resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
+			"integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/got": {
+			"version": "14.6.6",
+			"resolved": "https://registry.npmjs.org/got/-/got-14.6.6.tgz",
+			"integrity": "sha512-QLV1qeYSo5l13mQzWgP/y0LbMr5Plr5fJilgAIwgnwseproEbtNym8xpLsDzeZ6MWXgNE6kdWGBjdh3zT/Qerg==",
+			"license": "MIT",
+			"dependencies": {
+				"@sindresorhus/is": "^7.0.1",
+				"byte-counter": "^0.1.0",
+				"cacheable-lookup": "^7.0.0",
+				"cacheable-request": "^13.0.12",
+				"decompress-response": "^10.0.0",
+				"form-data-encoder": "^4.0.2",
+				"http2-wrapper": "^2.2.1",
+				"keyv": "^5.5.3",
+				"lowercase-keys": "^3.0.0",
+				"p-cancelable": "^4.0.1",
+				"responselike": "^4.0.2",
+				"type-fest": "^4.26.1"
+			},
+			"engines": {
+				"node": ">=20"
+			},
+			"funding": {
+				"url": "https://github.com/sindresorhus/got?sponsor=1"
+			}
+		},
+		"node_modules/got-scraping": {
+			"version": "4.2.1",
+			"resolved": "https://registry.npmjs.org/got-scraping/-/got-scraping-4.2.1.tgz",
+			"integrity": "sha512-rhOlO1L4H4Cm31smHJqPtAaXOUrhSKsiTrbZSHKFQW1E/mkTDopnHHpRnXJpqzE0faj+zPsVQnyifIqO+K+cLQ==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"got": "^14.2.1",
+				"header-generator": "^2.1.41",
+				"http2-wrapper": "^2.2.0",
+				"mimic-response": "^4.0.0",
+				"ow": "^1.1.1",
+				"quick-lru": "^7.0.0",
+				"tslib": "^2.6.2"
+			},
+			"engines": {
+				"node": ">=16"
+			}
+		},
+		"node_modules/got-scraping/node_modules/@sindresorhus/is": {
+			"version": "5.6.0",
+			"resolved": "https://registry.npmjs.org/@sindresorhus/is/-/is-5.6.0.tgz",
+			"integrity": "sha512-TV7t8GKYaJWsn00tFDqBw8+Uqmr8A0fRU1tvTQhyZzGv0sJCGRQL3JGMI3ucuKo3XIZdUP+Lx7/gh2t3lewy7g==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=14.16"
+			},
+			"funding": {
+				"url": "https://github.com/sindresorhus/is?sponsor=1"
+			}
+		},
+		"node_modules/got-scraping/node_modules/callsites": {
+			"version": "4.2.0",
+			"resolved": "https://registry.npmjs.org/callsites/-/callsites-4.2.0.tgz",
+			"integrity": "sha512-kfzR4zzQtAE9PC7CzZsjl3aBNbXWuXiSeOCdLcPpBfGW8YuCqQHcRPFDbr/BPVmd3EEPVpuFzLyuT/cUhPr4OQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=12.20"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/got-scraping/node_modules/dot-prop": {
+			"version": "7.2.0",
+			"resolved": "https://registry.npmjs.org/dot-prop/-/dot-prop-7.2.0.tgz",
+			"integrity": "sha512-Ol/IPXUARn9CSbkrdV4VJo7uCy1I3VuSiWCaFSg+8BdUOzF9n3jefIpcgAydvUZbTdEBZs2vEiTiS9m61ssiDA==",
+			"license": "MIT",
+			"dependencies": {
+				"type-fest": "^2.11.2"
+			},
+			"engines": {
+				"node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/got-scraping/node_modules/ow": {
+			"version": "1.1.1",
+			"resolved": "https://registry.npmjs.org/ow/-/ow-1.1.1.tgz",
+			"integrity": "sha512-sJBRCbS5vh1Jp9EOgwp1Ws3c16lJrUkJYlvWTYC03oyiYVwS/ns7lKRWow4w4XjDyTrA2pplQv4B2naWSR6yDA==",
+			"license": "MIT",
+			"dependencies": {
+				"@sindresorhus/is": "^5.3.0",
+				"callsites": "^4.0.0",
+				"dot-prop": "^7.2.0",
+				"lodash.isequal": "^4.5.0",
+				"vali-date": "^1.0.0"
+			},
+			"engines": {
+				"node": ">=14.16"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/got-scraping/node_modules/type-fest": {
+			"version": "2.19.0",
+			"resolved": "https://registry.npmjs.org/type-fest/-/type-fest-2.19.0.tgz",
+			"integrity": "sha512-RAH822pAdBgcNMAfWnCBU3CFZcfZ/i1eZjwFU/dsLKumyuuP3niueg2UAukXYF0E2AAoc82ZSSf9J0WQBinzHA==",
+			"license": "(MIT OR CC0-1.0)",
+			"engines": {
+				"node": ">=12.20"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/graceful-fs": {
+			"version": "4.2.11",
+			"resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz",
+			"integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==",
+			"license": "ISC"
+		},
+		"node_modules/has-symbols": {
+			"version": "1.1.0",
+			"resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
+			"integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/has-tostringtag": {
+			"version": "1.0.2",
+			"resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz",
+			"integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==",
+			"license": "MIT",
+			"dependencies": {
+				"has-symbols": "^1.0.3"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/ljharb"
+			}
+		},
+		"node_modules/hasown": {
+			"version": "2.0.4",
+			"resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.4.tgz",
+			"integrity": "sha512-T2UbfbBEF32wiepXIsMlTW9+dDYC6wMh/t/vYA4tuOMKqWz/n3vr1NFSxQiyP+zk2mXsoMA/i/7qV6LKut1t1A==",
+			"license": "MIT",
+			"dependencies": {
+				"function-bind": "^1.1.2"
+			},
+			"engines": {
+				"node": ">= 0.4"
+			}
+		},
+		"node_modules/header-generator": {
+			"version": "2.1.88",
+			"resolved": "https://registry.npmjs.org/header-generator/-/header-generator-2.1.88.tgz",
+			"integrity": "sha512-12GkTL1CDaPTQ6gkd8TPwxNtn7t3wSExnWU9qgWfEDh8IqpD1NAVcvzfHphIzULez8WP2DK9YQsDegajjDdTKQ==",
+			"license": "Apache-2.0",
+			"dependencies": {
+				"browserslist": "^4.21.1",
+				"generative-bayesian-network": "2.1.88",
+				"ow": "^0.28.1",
+				"tslib": "^2.4.0"
+			},
+			"engines": {
+				"node": ">=16.0.0"
+			}
+		},
+		"node_modules/htmlparser2": {
+			"version": "8.0.2",
+			"resolved": "https://registry.npmjs.org/htmlparser2/-/htmlparser2-8.0.2.tgz",
+			"integrity": "sha512-GYdjWKDkbRLkZ5geuHs5NY1puJ+PXwP7+fHPRz06Eirsb9ugf6d8kkXav6ADhcODhFFPMIXyxkxSuMf3D6NCFA==",
+			"funding": [
+				"https://github.com/fb55/htmlparser2?sponsor=1",
+				{
+					"type": "github",
+					"url": "https://github.com/sponsors/fb55"
+				}
+			],
+			"license": "MIT",
+			"dependencies": {
+				"domelementtype": "^2.3.0",
+				"domhandler": "^5.0.3",
+				"domutils": "^3.0.1",
+				"entities": "^4.4.0"
+			}
+		},
+		"node_modules/http-cache-semantics": {
+			"version": "4.2.0",
+			"resolved": "https://registry.npmjs.org/http-cache-semantics/-/http-cache-semantics-4.2.0.tgz",
+			"integrity": "sha512-dTxcvPXqPvXBQpq5dUr6mEMJX4oIEFv6bwom3FDwKRDsuIjjJGANqhBuoAn9c1RQJIdAKav33ED65E2ys+87QQ==",
+			"license": "BSD-2-Clause"
+		},
+		"node_modules/http-proxy-agent": {
+			"version": "7.0.2",
+			"resolved": "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-7.0.2.tgz",
+			"integrity": "sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==",
+			"license": "MIT",
+			"dependencies": {
+				"agent-base": "^7.1.0",
+				"debug": "^4.3.4"
+			},
+			"engines": {
+				"node": ">= 14"
+			}
+		},
+		"node_modules/http-proxy-agent/node_modules/agent-base": {
+			"version": "7.1.4",
+			"resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz",
+			"integrity": "sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 14"
+			}
+		},
+		"node_modules/http2-wrapper": {
+			"version": "2.2.1",
+			"resolved": "https://registry.npmjs.org/http2-wrapper/-/http2-wrapper-2.2.1.tgz",
+			"integrity": "sha512-V5nVw1PAOgfI3Lmeaj2Exmeg7fenjhRUgz1lPSezy1CuhPYbgQtbQj4jZfEAEMlaL+vupsvhjqCyjzob0yxsmQ==",
+			"license": "MIT",
+			"dependencies": {
+				"quick-lru": "^5.1.1",
+				"resolve-alpn": "^1.2.0"
+			},
+			"engines": {
+				"node": ">=10.19.0"
+			}
+		},
+		"node_modules/http2-wrapper/node_modules/quick-lru": {
+			"version": "5.1.1",
+			"resolved": "https://registry.npmjs.org/quick-lru/-/quick-lru-5.1.1.tgz",
+			"integrity": "sha512-WuyALRjWPDGtt/wzJiadO5AXY+8hZ80hVpe6MyivgraREW751X3SbhRvG3eLKOYN+8VEvqLcf3wdnt44Z4S4SA==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=10"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/https-proxy-agent": {
+			"version": "5.0.1",
+			"resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-5.0.1.tgz",
+			"integrity": "sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==",
+			"license": "MIT",
+			"dependencies": {
+				"agent-base": "6",
+				"debug": "4"
+			},
+			"engines": {
+				"node": ">= 6"
+			}
+		},
+		"node_modules/ieee754": {
+			"version": "1.2.1",
+			"resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz",
+			"integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==",
+			"funding": [
+				{
+					"type": "github",
+					"url": "https://github.com/sponsors/feross"
+				},
+				{
+					"type": "patreon",
+					"url": "https://www.patreon.com/feross"
+				},
+				{
+					"type": "consulting",
+					"url": "https://feross.org/support"
+				}
+			],
+			"license": "BSD-3-Clause"
+		},
+		"node_modules/ip-address": {
+			"version": "10.7.2",
+			"resolved": "https://registry.npmjs.org/ip-address/-/ip-address-10.7.2.tgz",
+			"integrity": "sha512-7H/2gFSIitxc0hG3nOI1glS8QLo/EHBFFLk8vEUjXY/xu0AdL8jZ9U1IzO2PUm0d2D/ofQcAifb0g6OBkt8U7w==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 12"
+			}
+		},
+		"node_modules/is-obj": {
+			"version": "2.0.0",
+			"resolved": "https://registry.npmjs.org/is-obj/-/is-obj-2.0.0.tgz",
+			"integrity": "sha512-drqDG3cbczxxEJRoOXcOjtdp1J/lyp1mNn0xaznRs8+muBhgQcrnbspox5X5fOw0HnMnbfDzvnEMEtqDEJEo8w==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=8"
+			}
+		},
+		"node_modules/is-stream": {
+			"version": "4.0.1",
+			"resolved": "https://registry.npmjs.org/is-stream/-/is-stream-4.0.1.tgz",
+			"integrity": "sha512-Dnz92NInDqYckGEUJv689RbRiTSEHCQ7wOVeALbkOz999YpqT46yMRIGtSNl2iCL1waAZSx40+h59NV/EwzV/A==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=18"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/json5": {
+			"version": "2.2.3",
+			"resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz",
+			"integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==",
+			"license": "MIT",
+			"bin": {
+				"json5": "lib/cli.js"
+			},
+			"engines": {
+				"node": ">=6"
+			}
+		},
+		"node_modules/jsonfile": {
+			"version": "6.2.1",
+			"resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.1.tgz",
+			"integrity": "sha512-zwOTdL3rFQ/lRdBnntKVOX6k5cKJwEc1HdilT71BWEu7J41gXIB2MRp+vxduPSwZJPWBxEzv4yH1wYLJGUHX4Q==",
+			"license": "MIT",
+			"dependencies": {
+				"universalify": "^2.0.0"
+			},
+			"optionalDependencies": {
+				"graceful-fs": "^4.1.6"
+			}
+		},
+		"node_modules/keyv": {
+			"version": "5.6.0",
+			"resolved": "https://registry.npmjs.org/keyv/-/keyv-5.6.0.tgz",
+			"integrity": "sha512-CYDD3SOtsHtyXeEORYRx2qBtpDJFjRTGXUtmNEMGyzYOKj1TE3tycdlho7kA1Ufx9OYWZzg52QFBGALTirzDSw==",
+			"license": "MIT",
+			"dependencies": {
+				"@keyv/serialize": "^1.1.1"
+			}
+		},
+		"node_modules/lodash": {
+			"version": "4.18.1",
+			"resolved": "https://registry.npmjs.org/lodash/-/lodash-4.18.1.tgz",
+			"integrity": "sha512-dMInicTPVE8d1e5otfwmmjlxkZoUpiVLwyeTdUsi/Caj/gfzzblBcCE5sRHV/AsjuCmxWrte2TNGSYuCeCq+0Q==",
+			"license": "MIT"
+		},
+		"node_modules/lodash.isequal": {
+			"version": "4.5.0",
+			"resolved": "https://registry.npmjs.org/lodash.isequal/-/lodash.isequal-4.5.0.tgz",
+			"integrity": "sha512-pDo3lu8Jhfjqls6GkMgpahsF9kCyayhgykjyLMNFTKWrpVdAQtYyB4muAMWozBB4ig/dtWAmsMxLEI8wuz+DYQ==",
+			"deprecated": "This package is deprecated. Use require('node:util').isDeepStrictEqual instead.",
+			"license": "MIT"
+		},
+		"node_modules/lowercase-keys": {
+			"version": "3.0.0",
+			"resolved": "https://registry.npmjs.org/lowercase-keys/-/lowercase-keys-3.0.0.tgz",
+			"integrity": "sha512-ozCC6gdQ+glXOQsveKD0YsDy8DSQFjDTz4zyzEHNV5+JP5D62LmfDZ6o1cycFx9ouG940M5dE8C8CTewdj2YWQ==",
+			"license": "MIT",
+			"engines": {
+				"node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/lru-cache": {
+			"version": "7.18.3",
+			"resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-7.18.3.tgz",
+			"integrity": "sha512-jumlc0BIUrS3qJGgIkWZsyfAM7NCWiBcCDhnd+3NNM5KbBmLTgHVfWBcg6W+rLUsIpzpERPsvwUP7CckAQSOoA==",
+			"license": "ISC",
+			"engines": {
+				"node": ">=12"
+			}
+		},
+		"node_modules/map-stream": {
+			"version": "0.1.0",
+			"resolved": "https://registry.npmjs.org/map-stream/-/map-stream-0.1.0.tgz",
+			"integrity": "sha512-CkYQrPYZfWnu/DAmVCpTSX/xHpKZ80eKh2lAkyA6AJTef6bW+6JpbQZN5rofum7da+SyN1bi5ctTm+lTfcCW3g=="
+		},
+		"node_modules/math-intrinsics": {
+			"version": "1.1.0",
+			"resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
+			"integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.4"
+			}
+		},
+		"node_modules/mime-db": {
+			"version": "1.52.0",
+			"resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
+			"integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.6"
+			}
+		},
+		"node_modules/mime-types": {
+			"version": "2.1.35",
+			"resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",
+			"integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
+			"license": "MIT",
+			"dependencies": {
+				"mime-db": "1.52.0"
+			},
+			"engines": {
+				"node": ">= 0.6"
+			}
+		},
+		"node_modules/mimic-response": {
+			"version": "4.0.0",
+			"resolved": "https://registry.npmjs.org/mimic-response/-/mimic-response-4.0.0.tgz",
+			"integrity": "sha512-e5ISH9xMYU0DzrT+jl8q2ze9D6eWBto+I8CNpe+VI+K2J/F/k3PdkdTdz4wvGVH4NTpo+NRYTVIuMQEMMcsLqg==",
+			"license": "MIT",
+			"engines": {
+				"node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/minimatch": {
+			"version": "9.0.9",
+			"resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.9.tgz",
+			"integrity": "sha512-OBwBN9AL4dqmETlpS2zasx+vTeWclWzkblfZk7KTA5j3jeOONz/tRCnZomUyvNg83wL5Zv9Ss6HMJXAgL8R2Yg==",
+			"license": "ISC",
+			"dependencies": {
+				"brace-expansion": "^2.0.2"
+			},
+			"engines": {
+				"node": ">=16 || 14 >=14.17"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/isaacs"
+			}
+		},
+		"node_modules/ms": {
+			"version": "2.1.3",
+			"resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+			"integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+			"license": "MIT"
+		},
+		"node_modules/netmask": {
+			"version": "2.1.1",
+			"resolved": "https://registry.npmjs.org/netmask/-/netmask-2.1.1.tgz",
+			"integrity": "sha512-eonl3sLUha+S1GzTPxychyhnUzKyeQkZ7jLjKrBagJgPla13F+uQ71HgpFefyHgqrjEbCPkDArxYsjY8/+gLKA==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.4.0"
+			}
+		},
+		"node_modules/node-releases": {
+			"version": "2.0.57",
+			"resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.57.tgz",
+			"integrity": "sha512-kQK9LGGFiHtrWiNhZtA7Qbw17AQz+dmsEKODRIVTXA9+e5MS/2gZEBhYJt13GrAz5/IOZKddH/0Z3TP/Zgo+yw==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=18"
+			}
+		},
+		"node_modules/normalize-url": {
+			"version": "8.1.1",
+			"resolved": "https://registry.npmjs.org/normalize-url/-/normalize-url-8.1.1.tgz",
+			"integrity": "sha512-JYc0DPlpGWB40kH5g07gGTrYuMqV653k3uBKY6uITPWds3M0ov3GaWGp9lbE3Bzngx8+XkfzgvASb9vk9JDFXQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=14.16"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/nth-check": {
+			"version": "2.1.1",
+			"resolved": "https://registry.npmjs.org/nth-check/-/nth-check-2.1.1.tgz",
+			"integrity": "sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w==",
+			"license": "BSD-2-Clause",
+			"dependencies": {
+				"boolbase": "^1.0.0"
+			},
+			"funding": {
+				"url": "https://github.com/fb55/nth-check?sponsor=1"
+			}
+		},
+		"node_modules/ow": {
+			"version": "0.28.2",
+			"resolved": "https://registry.npmjs.org/ow/-/ow-0.28.2.tgz",
+			"integrity": "sha512-dD4UpyBh/9m4X2NVjA+73/ZPBRF+uF4zIMFvvQsabMiEK8x41L3rQ8EENOi35kyyoaJwNxEeJcP6Fj1H4U409Q==",
+			"license": "MIT",
+			"dependencies": {
+				"@sindresorhus/is": "^4.2.0",
+				"callsites": "^3.1.0",
+				"dot-prop": "^6.0.1",
+				"lodash.isequal": "^4.5.0",
+				"vali-date": "^1.0.0"
+			},
+			"engines": {
+				"node": ">=12"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/ow/node_modules/@sindresorhus/is": {
+			"version": "4.6.0",
+			"resolved": "https://registry.npmjs.org/@sindresorhus/is/-/is-4.6.0.tgz",
+			"integrity": "sha512-t09vSN3MdfsyCHoFcTRCH/iUtG7OJ0CsjzB8cjAmKc/va/kIgeDI/TxsigdncE/4be734m0cvIYwNaV4i2XqAw==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=10"
+			},
+			"funding": {
+				"url": "https://github.com/sindresorhus/is?sponsor=1"
+			}
+		},
+		"node_modules/p-cancelable": {
+			"version": "4.0.1",
+			"resolved": "https://registry.npmjs.org/p-cancelable/-/p-cancelable-4.0.1.tgz",
+			"integrity": "sha512-wBowNApzd45EIKdO1LaU+LrMBwAcjfPaYtVzV3lmfM3gf8Z4CHZsiIqlM8TZZ8okYvh5A1cP6gTfCRQtwUpaUg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=14.16"
+			}
+		},
+		"node_modules/p-limit": {
+			"version": "3.1.0",
+			"resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz",
+			"integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==",
+			"license": "MIT",
+			"dependencies": {
+				"yocto-queue": "^0.1.0"
+			},
+			"engines": {
+				"node": ">=10"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/pac-proxy-agent": {
+			"version": "7.2.0",
+			"resolved": "https://registry.npmjs.org/pac-proxy-agent/-/pac-proxy-agent-7.2.0.tgz",
+			"integrity": "sha512-TEB8ESquiLMc0lV8vcd5Ql/JAKAoyzHFXaStwjkzpOpC5Yv+pIzLfHvjTSdf3vpa2bMiUQrg9i6276yn8666aA==",
+			"license": "MIT",
+			"dependencies": {
+				"@tootallnate/quickjs-emscripten": "^0.23.0",
+				"agent-base": "^7.1.2",
+				"debug": "^4.3.4",
+				"get-uri": "^6.0.1",
+				"http-proxy-agent": "^7.0.0",
+				"https-proxy-agent": "^7.0.6",
+				"pac-resolver": "^7.0.1",
+				"socks-proxy-agent": "^8.0.5"
+			},
+			"engines": {
+				"node": ">= 14"
+			}
+		},
+		"node_modules/pac-proxy-agent/node_modules/agent-base": {
+			"version": "7.1.4",
+			"resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz",
+			"integrity": "sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 14"
+			}
+		},
+		"node_modules/pac-proxy-agent/node_modules/https-proxy-agent": {
+			"version": "7.0.6",
+			"resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz",
+			"integrity": "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==",
+			"license": "MIT",
+			"dependencies": {
+				"agent-base": "^7.1.2",
+				"debug": "4"
+			},
+			"engines": {
+				"node": ">= 14"
+			}
+		},
+		"node_modules/pac-resolver": {
+			"version": "7.0.1",
+			"resolved": "https://registry.npmjs.org/pac-resolver/-/pac-resolver-7.0.1.tgz",
+			"integrity": "sha512-5NPgf87AT2STgwa2ntRMr45jTKrYBGkVU36yT0ig/n/GMAa3oPqhZfIQ2kMEimReg0+t9kZViDVZ83qfVUlckg==",
+			"license": "MIT",
+			"dependencies": {
+				"degenerator": "^5.0.0",
+				"netmask": "^2.0.2"
+			},
+			"engines": {
+				"node": ">= 14"
+			}
+		},
+		"node_modules/parse5": {
+			"version": "7.3.0",
+			"resolved": "https://registry.npmjs.org/parse5/-/parse5-7.3.0.tgz",
+			"integrity": "sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw==",
+			"license": "MIT",
+			"dependencies": {
+				"entities": "^6.0.0"
+			},
+			"funding": {
+				"url": "https://github.com/inikulin/parse5?sponsor=1"
+			}
+		},
+		"node_modules/parse5-htmlparser2-tree-adapter": {
+			"version": "7.1.0",
+			"resolved": "https://registry.npmjs.org/parse5-htmlparser2-tree-adapter/-/parse5-htmlparser2-tree-adapter-7.1.0.tgz",
+			"integrity": "sha512-ruw5xyKs6lrpo9x9rCZqZZnIUntICjQAd0Wsmp396Ul9lN/h+ifgVV1x1gZHi8euej6wTfpqX8j+BFQxF0NS/g==",
+			"license": "MIT",
+			"dependencies": {
+				"domhandler": "^5.0.3",
+				"parse5": "^7.0.0"
+			},
+			"funding": {
+				"url": "https://github.com/inikulin/parse5?sponsor=1"
+			}
+		},
+		"node_modules/parse5/node_modules/entities": {
+			"version": "6.0.1",
+			"resolved": "https://registry.npmjs.org/entities/-/entities-6.0.1.tgz",
+			"integrity": "sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g==",
+			"license": "BSD-2-Clause",
+			"engines": {
+				"node": ">=0.12"
+			},
+			"funding": {
+				"url": "https://github.com/fb55/entities?sponsor=1"
+			}
+		},
+		"node_modules/pause-stream": {
+			"version": "0.0.11",
+			"resolved": "https://registry.npmjs.org/pause-stream/-/pause-stream-0.0.11.tgz",
+			"integrity": "sha512-e3FBlXLmN/D1S+zHzanP4E/4Z60oFAa3O051qt1pxa7DEJWKAyil6upYVXCWadEnuoqa4Pkc9oUx9zsxYeRv8A==",
+			"license": [
+				"MIT",
+				"Apache2"
+			],
+			"dependencies": {
+				"through": "~2.3"
+			}
+		},
+		"node_modules/picocolors": {
+			"version": "1.1.1",
+			"resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+			"integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+			"license": "ISC"
+		},
+		"node_modules/proper-lockfile": {
+			"version": "4.1.2",
+			"resolved": "https://registry.npmjs.org/proper-lockfile/-/proper-lockfile-4.1.2.tgz",
+			"integrity": "sha512-TjNPblN4BwAWMXU8s9AEz4JmQxnD1NNL7bNOY/AKUzyamc379FWASUhc/K1pL2noVb+XmZKLL68cjzLsiOAMaA==",
+			"license": "MIT",
+			"dependencies": {
+				"graceful-fs": "^4.2.4",
+				"retry": "^0.12.0",
+				"signal-exit": "^3.0.2"
+			}
+		},
+		"node_modules/proper-lockfile/node_modules/retry": {
+			"version": "0.12.0",
+			"resolved": "https://registry.npmjs.org/retry/-/retry-0.12.0.tgz",
+			"integrity": "sha512-9LkiTwjUh6rT555DtE9rTX+BKByPfrMzEAtnlEtdEwr3Nkffwiihqe2bWADg+OQRjt9gl6ICdmB/ZFDCGAtSow==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 4"
+			}
+		},
+		"node_modules/proxy-agent": {
+			"version": "6.5.0",
+			"resolved": "https://registry.npmjs.org/proxy-agent/-/proxy-agent-6.5.0.tgz",
+			"integrity": "sha512-TmatMXdr2KlRiA2CyDu8GqR8EjahTG3aY3nXjdzFyoZbmB8hrBsTyMezhULIXKnC0jpfjlmiZ3+EaCzoInSu/A==",
+			"license": "MIT",
+			"dependencies": {
+				"agent-base": "^7.1.2",
+				"debug": "^4.3.4",
+				"http-proxy-agent": "^7.0.1",
+				"https-proxy-agent": "^7.0.6",
+				"lru-cache": "^7.14.1",
+				"pac-proxy-agent": "^7.1.0",
+				"proxy-from-env": "^1.1.0",
+				"socks-proxy-agent": "^8.0.5"
+			},
+			"engines": {
+				"node": ">= 14"
+			}
+		},
+		"node_modules/proxy-agent/node_modules/agent-base": {
+			"version": "7.1.4",
+			"resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz",
+			"integrity": "sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 14"
+			}
+		},
+		"node_modules/proxy-agent/node_modules/https-proxy-agent": {
+			"version": "7.0.6",
+			"resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz",
+			"integrity": "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==",
+			"license": "MIT",
+			"dependencies": {
+				"agent-base": "^7.1.2",
+				"debug": "4"
+			},
+			"engines": {
+				"node": ">= 14"
+			}
+		},
+		"node_modules/proxy-agent/node_modules/proxy-from-env": {
+			"version": "1.1.0",
+			"resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz",
+			"integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==",
+			"license": "MIT"
+		},
+		"node_modules/proxy-from-env": {
+			"version": "2.1.0",
+			"resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-2.1.0.tgz",
+			"integrity": "sha512-cJ+oHTW1VAEa8cJslgmUZrc+sjRKgAKl3Zyse6+PV38hZe/V6Z14TbCuXcan9F9ghlz4QrFr2c92TNF82UkYHA==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=10"
+			}
+		},
+		"node_modules/quick-lru": {
+			"version": "7.3.0",
+			"resolved": "https://registry.npmjs.org/quick-lru/-/quick-lru-7.3.0.tgz",
+			"integrity": "sha512-k9lSsjl36EJdK7I06v7APZCbyGT2vMTsYSRX1Q2nbYmnkBqgUhRkAuzH08Ciotteu/PLJmIF2+tti7o3C/ts2g==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=18"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/resolve-alpn": {
+			"version": "1.2.1",
+			"resolved": "https://registry.npmjs.org/resolve-alpn/-/resolve-alpn-1.2.1.tgz",
+			"integrity": "sha512-0a1F4l73/ZFZOakJnQ3FvkJ2+gSTQWz/r2KE5OdDY0TxPm5h4GkqkWWfM47T7HsbnOtcJVEF4epCVy6u7Q3K+g==",
+			"license": "MIT"
+		},
+		"node_modules/responselike": {
+			"version": "4.0.2",
+			"resolved": "https://registry.npmjs.org/responselike/-/responselike-4.0.2.tgz",
+			"integrity": "sha512-cGk8IbWEAnaCpdAt1BHzJ3Ahz5ewDJa0KseTsE3qIRMJ3C698W8psM7byCeWVpd/Ha7FUYzuRVzXoKoM6nRUbA==",
+			"license": "MIT",
+			"dependencies": {
+				"lowercase-keys": "^3.0.0"
+			},
+			"engines": {
+				"node": ">=20"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/retry": {
+			"version": "0.13.1",
+			"resolved": "https://registry.npmjs.org/retry/-/retry-0.13.1.tgz",
+			"integrity": "sha512-XQBQ3I8W1Cge0Seh+6gjj03LbmRFWuoszgK9ooCpwYIrhhoO80pfq4cUkU5DkknwfOfFteRwlZ56PYOGYyFWdg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 4"
+			}
+		},
+		"node_modules/robots-parser": {
+			"version": "3.0.1",
+			"resolved": "https://registry.npmjs.org/robots-parser/-/robots-parser-3.0.1.tgz",
+			"integrity": "sha512-s+pyvQeIKIZ0dx5iJiQk1tPLJAWln39+MI5jtM8wnyws+G5azk+dMnMX0qfbqNetKKNgcWWOdi0sfm+FbQbgdQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=10.0.0"
+			}
+		},
+		"node_modules/sax": {
+			"version": "1.6.1",
+			"resolved": "https://registry.npmjs.org/sax/-/sax-1.6.1.tgz",
+			"integrity": "sha512-42tBVwLWnaQvW5zc4HbZrTuWccECCZfBi92FDuwtqxasH+JbPB3/FOKb1m222K42R4WxuxzzMsTswfzgtSu64Q==",
+			"license": "BlueOak-1.0.0",
+			"engines": {
+				"node": ">=11.0.0"
+			}
+		},
+		"node_modules/semver": {
+			"version": "7.8.5",
+			"resolved": "https://registry.npmjs.org/semver/-/semver-7.8.5.tgz",
+			"integrity": "sha512-Y7/KDsb8LjooZpwaqGyulO6DQlksgCncchHGk+sZIY4SBvUocMBEFH5Ur1fI4dV+Jvl0w6cjvucaIi40puRioA==",
+			"license": "ISC",
+			"bin": {
+				"semver": "bin/semver.js"
+			},
+			"engines": {
+				"node": ">=10"
+			}
+		},
+		"node_modules/signal-exit": {
+			"version": "3.0.7",
+			"resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz",
+			"integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==",
+			"license": "ISC"
+		},
+		"node_modules/smart-buffer": {
+			"version": "4.2.0",
+			"resolved": "https://registry.npmjs.org/smart-buffer/-/smart-buffer-4.2.0.tgz",
+			"integrity": "sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 6.0.0",
+				"npm": ">= 3.0.0"
+			}
+		},
+		"node_modules/socks": {
+			"version": "2.8.10",
+			"resolved": "https://registry.npmjs.org/socks/-/socks-2.8.10.tgz",
+			"integrity": "sha512-e0VyvkVTwVYViNovRkZ9aodhxVlyoMn7eJhVUPxZ+eK9P/7CBkxvvsBOHqFPEH416726W8tLXXXjKwqgTErrCQ==",
+			"license": "MIT",
+			"dependencies": {
+				"ip-address": "^10.1.1",
+				"smart-buffer": "^4.2.0"
+			},
+			"engines": {
+				"node": ">= 10.0.0",
+				"npm": ">= 3.0.0"
+			}
+		},
+		"node_modules/socks-proxy-agent": {
+			"version": "8.0.5",
+			"resolved": "https://registry.npmjs.org/socks-proxy-agent/-/socks-proxy-agent-8.0.5.tgz",
+			"integrity": "sha512-HehCEsotFqbPW9sJ8WVYB6UbmIMv7kUUORIF2Nncq4VQvBfNBLibW9YZR5dlYCSUhwcD628pRllm7n+E+YTzJw==",
+			"license": "MIT",
+			"dependencies": {
+				"agent-base": "^7.1.2",
+				"debug": "^4.3.4",
+				"socks": "^2.8.3"
+			},
+			"engines": {
+				"node": ">= 14"
+			}
+		},
+		"node_modules/socks-proxy-agent/node_modules/agent-base": {
+			"version": "7.1.4",
+			"resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz",
+			"integrity": "sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 14"
+			}
+		},
+		"node_modules/source-map": {
+			"version": "0.6.1",
+			"resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
+			"integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
+			"license": "BSD-3-Clause",
+			"optional": true,
+			"engines": {
+				"node": ">=0.10.0"
+			}
+		},
+		"node_modules/split": {
+			"version": "0.3.3",
+			"resolved": "https://registry.npmjs.org/split/-/split-0.3.3.tgz",
+			"integrity": "sha512-wD2AeVmxXRBoX44wAycgjVpMhvbwdI2aZjCkvfNcH1YqHQvJVa1duWc73OyVGJUc05fhFaTZeQ/PYsrmyH0JVA==",
+			"license": "MIT",
+			"dependencies": {
+				"through": "2"
+			},
+			"engines": {
+				"node": "*"
+			}
+		},
+		"node_modules/stream-chain": {
+			"version": "2.2.5",
+			"resolved": "https://registry.npmjs.org/stream-chain/-/stream-chain-2.2.5.tgz",
+			"integrity": "sha512-1TJmBx6aSWqZ4tx7aTpBDXK0/e2hhcNSTV8+CbFJtDjbb+I1mZ8lHit0Grw9GRT+6JbIrrDd8esncgBi8aBXGA==",
+			"license": "BSD-3-Clause"
+		},
+		"node_modules/stream-combiner": {
+			"version": "0.0.4",
+			"resolved": "https://registry.npmjs.org/stream-combiner/-/stream-combiner-0.0.4.tgz",
+			"integrity": "sha512-rT00SPnTVyRsaSz5zgSPma/aHSOic5U1prhYdRy5HS2kTZviFpmDgzilbtsJsxiroqACmayynDN/9VzIbX5DOw==",
+			"license": "MIT",
+			"dependencies": {
+				"duplexer": "~0.1.1"
+			}
+		},
+		"node_modules/stream-json": {
+			"version": "1.9.1",
+			"resolved": "https://registry.npmjs.org/stream-json/-/stream-json-1.9.1.tgz",
+			"integrity": "sha512-uWkjJ+2Nt/LO9Z/JyKZbMusL8Dkh97uUBTv3AJQ74y07lVahLY4eEFsPsE97pxYBwr8nnjMAIch5eqI0gPShyw==",
+			"license": "BSD-3-Clause",
+			"dependencies": {
+				"stream-chain": "^2.2.5"
+			}
+		},
+		"node_modules/strtok3": {
+			"version": "10.3.5",
+			"resolved": "https://registry.npmjs.org/strtok3/-/strtok3-10.3.5.tgz",
+			"integrity": "sha512-ki4hZQfh5rX0QDLLkOCj+h+CVNkqmp/CMf8v8kZpkNVK6jGQooMytqzLZYUVYIZcFZ6yDB70EfD8POcFXiF5oA==",
+			"license": "MIT",
+			"dependencies": {
+				"@tokenizer/token": "^0.3.0"
+			},
+			"engines": {
+				"node": ">=18"
+			},
+			"funding": {
+				"type": "github",
+				"url": "https://github.com/sponsors/Borewit"
+			}
+		},
+		"node_modules/through": {
+			"version": "2.3.8",
+			"resolved": "https://registry.npmjs.org/through/-/through-2.3.8.tgz",
+			"integrity": "sha512-w89qg7PI8wAdvX60bMDP+bFoD5Dvhm9oLheFp5O4a2QF0cSBGsBX4qZmadPMvVqlLJBBci+WqGGOAPvcDeNSVg==",
+			"license": "MIT"
+		},
+		"node_modules/tldts": {
+			"version": "7.4.15",
+			"resolved": "https://registry.npmjs.org/tldts/-/tldts-7.4.15.tgz",
+			"integrity": "sha512-SJVBeHOxDbNoq14CvpAoA2mLEWdbldGK8nR+yumpjY5nrlZxOflcA7p1Qj1gbTGmbu9DY9qLj/bENSWhBzjxRQ==",
+			"license": "MIT",
+			"dependencies": {
+				"tldts-core": "^7.4.15"
+			},
+			"bin": {
+				"tldts": "bin/cli.js"
+			}
+		},
+		"node_modules/tldts-core": {
+			"version": "7.4.15",
+			"resolved": "https://registry.npmjs.org/tldts-core/-/tldts-core-7.4.15.tgz",
+			"integrity": "sha512-ERuv0p98XgSzmlSLJr8vDNxX+uATGInlN97V3R+JpYWaSqn5IG3ewWgCwczk4bkOpgth/o8Nt5FOi4B4w0n/1A==",
+			"license": "MIT"
+		},
+		"node_modules/token-types": {
+			"version": "6.1.2",
+			"resolved": "https://registry.npmjs.org/token-types/-/token-types-6.1.2.tgz",
+			"integrity": "sha512-dRXchy+C0IgK8WPC6xvCHFRIWYUbqqdEIKPaKo/AcTUNzwLTK6AH7RjdLWsEZcAN/TBdtfUw3PYEgPr5VPr6ww==",
+			"license": "MIT",
+			"dependencies": {
+				"@borewit/text-codec": "^0.2.1",
+				"@tokenizer/token": "^0.3.0",
+				"ieee754": "^1.2.1"
+			},
+			"engines": {
+				"node": ">=14.16"
+			},
+			"funding": {
+				"type": "github",
+				"url": "https://github.com/sponsors/Borewit"
+			}
+		},
+		"node_modules/tough-cookie": {
+			"version": "6.0.2",
+			"resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-6.0.2.tgz",
+			"integrity": "sha512-exgYmnmL/sJpR3upZfXG5PoatXQii55xAiXGXzY+sROLZ/Y+SLcp9PgJNI9Vz37HpQ74WvDcLT8eqm+kV3FzrA==",
+			"license": "BSD-3-Clause",
+			"dependencies": {
+				"tldts": "^7.0.5"
+			},
+			"engines": {
+				"node": ">=16"
+			}
+		},
+		"node_modules/tslib": {
+			"version": "2.8.1",
+			"resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+			"integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+			"license": "0BSD"
+		},
+		"node_modules/type-fest": {
+			"version": "4.41.0",
+			"resolved": "https://registry.npmjs.org/type-fest/-/type-fest-4.41.0.tgz",
+			"integrity": "sha512-TeTSQ6H5YHvpqVwBRcnLDCBnDOHWYu7IvGbHT6N8AOymcr9PJGjc1GTtiWZTYg0NCgYwvnYWEkVChQAr9bjfwA==",
+			"license": "(MIT OR CC0-1.0)",
+			"engines": {
+				"node": ">=16"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/typescript": {
+			"version": "6.0.3",
+			"resolved": "https://registry.npmjs.org/typescript/-/typescript-6.0.3.tgz",
+			"integrity": "sha512-y2TvuxSZPDyQakkFRPZHKFm+KKVqIisdg9/CZwm9ftvKXLP8NRWj38/ODjNbr43SsoXqNuAisEf1GdCxqWcdBw==",
+			"dev": true,
+			"license": "Apache-2.0",
+			"bin": {
+				"tsc": "bin/tsc",
+				"tsserver": "bin/tsserver"
+			},
+			"engines": {
+				"node": ">=14.17"
+			}
+		},
+		"node_modules/uint8array-extras": {
+			"version": "1.5.0",
+			"resolved": "https://registry.npmjs.org/uint8array-extras/-/uint8array-extras-1.5.0.tgz",
+			"integrity": "sha512-rvKSBiC5zqCCiDZ9kAOszZcDvdAHwwIKJG33Ykj43OKcWsnmcBRL09YTU4nOeHZ8Y2a7l1MgTd08SBe9A8Qj6A==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=18"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		},
+		"node_modules/undici-types": {
+			"version": "7.18.2",
+			"resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.18.2.tgz",
+			"integrity": "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w==",
+			"license": "MIT"
+		},
+		"node_modules/universalify": {
+			"version": "2.0.1",
+			"resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+			"integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 10.0.0"
+			}
+		},
+		"node_modules/update-browserslist-db": {
+			"version": "1.3.3",
+			"resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.3.3.tgz",
+			"integrity": "sha512-pJ2sYawQS0R/WI928Gj5GlPhTGzbMelq0+4INtSYNDV9ErKJcX6xjGWkoG/VnB3dpUm00zALaqkrUD77pO5TDQ==",
+			"funding": [
+				{
+					"type": "opencollective",
+					"url": "https://opencollective.com/browserslist"
+				},
+				{
+					"type": "tidelift",
+					"url": "https://tidelift.com/funding/github/npm/browserslist"
+				},
+				{
+					"type": "github",
+					"url": "https://github.com/sponsors/ai"
+				}
+			],
+			"license": "MIT",
+			"dependencies": {
+				"escalade": "^3.2.0",
+				"picocolors": "^1.1.1"
+			},
+			"bin": {
+				"update-browserslist-db": "cli.js"
+			},
+			"peerDependencies": {
+				"browserslist": ">= 4.21.0"
+			}
+		},
+		"node_modules/vali-date": {
+			"version": "1.0.0",
+			"resolved": "https://registry.npmjs.org/vali-date/-/vali-date-1.0.0.tgz",
+			"integrity": "sha512-sgECfZthyaCKW10N0fm27cg8HYTFK5qMWgypqkXMQ4Wbl/zZKx7xZICgcoxIIE+WFAP/MBL2EFwC/YvLxw3Zeg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=0.10.0"
+			}
+		},
+		"node_modules/whatwg-mimetype": {
+			"version": "4.0.0",
+			"resolved": "https://registry.npmjs.org/whatwg-mimetype/-/whatwg-mimetype-4.0.0.tgz",
+			"integrity": "sha512-QaKxh0eNIi2mE9p2vEdzfagOKHCcj1pJ56EEHGQOVxp8r9/iszLUUV7v89x9O1p/T+NlTM5W7jW6+cz4Fq1YVg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=18"
+			}
+		},
+		"node_modules/ws": {
+			"version": "8.21.3",
+			"resolved": "https://registry.npmjs.org/ws/-/ws-8.21.3.tgz",
+			"integrity": "sha512-201TZ/kPWxoPr/OKWjquZR1SWKXcvxdH+e1xrx89b3YbmzLMFCLfnaG1HFIgWzJOEWZ7MvpK++odZufgYR50Rw==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=10.0.0"
+			},
+			"peerDependencies": {
+				"bufferutil": "^4.0.1",
+				"utf-8-validate": ">=5.0.2"
+			},
+			"peerDependenciesMeta": {
+				"bufferutil": {
+					"optional": true
+				},
+				"utf-8-validate": {
+					"optional": true
+				}
+			}
+		},
+		"node_modules/yocto-queue": {
+			"version": "0.1.0",
+			"resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz",
+			"integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=10"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/sindresorhus"
+			}
+		}
+	}
+}
diff --git a/sample_actor_standby_web/package.json b/sample_actor_standby_web/package.json
new file mode 100644
index 00000000..7cef787f
--- /dev/null
+++ b/sample_actor_standby_web/package.json
@@ -0,0 +1,22 @@
+{
+	"name": "my-standby-web-actor",
+	"version": "0.0.1",
+	"type": "module",
+	"description": "A Standby web page and an Actor-to-Actor standby call, for actor-runtime.",
+	"engines": {
+		"node": ">=18.0.0"
+	},
+	"dependencies": {
+		"apify": "^3.7.0"
+	},
+	"devDependencies": {
+		"@apify/tsconfig": "^0.2.0",
+		"@types/node": "^24.0.0",
+		"typescript": "^6.0.0"
+	},
+	"scripts": {
+		"start": "node dist/main.js",
+		"build": "tsc"
+	},
+	"license": "ISC"
+}
diff --git a/sample_actor_standby_web/src/main.ts b/sample_actor_standby_web/src/main.ts
new file mode 100644
index 00000000..66b591f6
--- /dev/null
+++ b/sample_actor_standby_web/src/main.ts
@@ -0,0 +1,103 @@
+/**
+ * Standby web sample for actor-runtime. One Actor, two roles:
+ *
+ * - A standby run serves a web page whose script calls this server with a root-relative URL, as most web
+ *   UIs do; that only works where the Actor owns `/` of its standby URL, as on `*.apify.actor`.
+ *
+ *     GET /                  the page
+ *     GET /api/greeting?name=Ada   JSON: a greeting, the answering run, and the Host the request came to
+ *
+ * - An ordinary run (`apify call`) is a client of a standby Actor, this one unless `standbyActor` names
+ *   another: it reads that Actor's `standbyUrl` through the API, calls `/api/greeting`, and pushes the
+ *   answer to its default dataset.
+ */
+import { createServer, type ServerResponse } from 'node:http';
+import { URL } from 'node:url';
+
+import { Actor, log } from 'apify';
+
+/** Sent by the platform (and the runtime) until the server answers; any response means "ready". */
+const READINESS_PROBE_HEADER = 'x-apify-container-server-readiness-probe';
+
+interface Input {
+	standbyActor?: string;
+	name?: string;
+}
+
+const PAGE = `<!doctype html>
+<html>
+<head><meta charset="utf-8"><title>Standby web sample</title></head>
+<body>
+<h1>Standby web sample</h1>
+<p id="greeting">Loading...</p>
+<script>
+	// Root-relative on purpose; the token the page was opened with is passed on.
+	const token = new URLSearchParams(location.search).get('token');
+	fetch('/api/greeting?name=browser', { headers: token ? { authorization: 'Bearer ' + token } : {} })
+		.then((res) => res.json())
+		.then((body) => (document.getElementById('greeting').textContent = body.greeting + ' (run ' + body.runId + ')'))
+		.catch((error) => (document.getElementById('greeting').textContent = 'Failed: ' + error));
+</script>
+</body>
+</html>
+`;
+
+function sendJson(res: ServerResponse, status: number, body: unknown): void {
+	res.writeHead(status, { 'content-type': 'application/json; charset=utf-8' });
+	res.end(`${JSON.stringify(body, null, 2)}\n`);
+}
+
+async function serve(): Promise<void> {
+	const runId = Actor.config.get('actorRunId');
+	const port = Actor.config.get('standbyPort');
+
+	const server = createServer((req, res) => {
+		if (req.headers[READINESS_PROBE_HEADER]) {
+			res.end('ok\n');
+			return;
+		}
+		const url = new URL(req.url ?? '/', 'http://localhost');
+		const route = `${req.method} ${url.pathname}`;
+		log.info(`${route} (Host: ${req.headers.host})`);
+		if (route === 'GET /') {
+			res.writeHead(200, { 'content-type': 'text/html; charset=utf-8' });
+			res.end(PAGE);
+		} else if (route === 'GET /api/greeting') {
+			const name = url.searchParams.get('name') ?? 'world';
+			sendJson(res, 200, { greeting: `Hello, ${name}!`, runId, host: req.headers.host });
+		} else {
+			sendJson(res, 404, { error: `No endpoint ${route}.` });
+		}
+	});
+
+	// An idle standby run is wound down with an `aborting` event; the SDK exits right after its listeners.
+	Actor.on('aborting', () => {
+		server.close();
+	});
+	server.listen(port, () => log.info(`Standby server listening on port ${port}`));
+}
+
+async function callStandbyActor(): Promise<void> {
+	const input = (await Actor.getInput<Input>()) ?? {};
+	const target = input.standbyActor || Actor.config.get('actorId')!;
+	// Read from inside a container, the Actor object carries a standbyUrl this container can reach.
+	const actor = (await Actor.newClient().actor(target).get()) as { standbyUrl?: string | null } | undefined;
+	if (!actor?.standbyUrl) throw new Error(`Actor ${target} does not exist or has Standby off.`);
+
+	const url = `${actor.standbyUrl}/api/greeting?name=${encodeURIComponent(input.name ?? 'Actor')}`;
+	log.info(`Calling ${url}`);
+	const res = await fetch(url, { headers: { authorization: `Bearer ${Actor.config.get('token')}` } });
+	const body = (await res.json()) as Record<string, unknown>;
+	log.info(`${res.status}: ${JSON.stringify(body)}`);
+	if (!res.ok) throw new Error(`The standby Actor answered ${res.status}.`);
+	await Actor.pushData({ standbyUrl: actor.standbyUrl, status: res.status, ...body });
+}
+
+await Actor.init();
+
+if (Actor.config.get('metaOrigin') === 'STANDBY') {
+	await serve();
+} else {
+	await callStandbyActor();
+	await Actor.exit();
+}
diff --git a/sample_actor_standby_web/tsconfig.json b/sample_actor_standby_web/tsconfig.json
new file mode 100644
index 00000000..971ad9fe
--- /dev/null
+++ b/sample_actor_standby_web/tsconfig.json
@@ -0,0 +1,15 @@
+{
+	"extends": "@apify/tsconfig",
+	"compilerOptions": {
+		"module": "NodeNext",
+		"moduleResolution": "NodeNext",
+		"target": "ES2022",
+		"outDir": "dist",
+		"rootDir": "./src",
+		"incremental": false,
+		"noUnusedLocals": false,
+		"skipLibCheck": true,
+		"lib": ["DOM"]
+	},
+	"include": ["./src/**/*"]
+}
diff --git a/skills/actor-runtime/SKILL.md b/skills/actor-runtime/SKILL.md
index deed036d..d5632bf0 100644
--- a/skills/actor-runtime/SKILL.md
+++ b/skills/actor-runtime/SKILL.md
@@ -186,18 +186,24 @@ An Actor with Standby enabled is served over HTTP, as on the platform. `"usesSta
 
 ```sh
 apify push
+# The standby URL, as on the platform (<username>--<actor-name>.apify.actor); open it in a browser too:
+curl "http://<username>--<actor-name>.localhost:3333/some/path?token=<token>"
+# The same Actor, for clients that do not resolve *.localhost (older curl, many Node/Python clients):
 curl "http://localhost:3333/actor-runtime/standby/<username>--<actor-name>/some/path?token=<token>"
 ```
 
-- The Actor's console page has the same URL with your token already in it (masked on screen), as a link
+- The Actor's console page has the `*.localhost` standby URL with your token already in it (masked on screen), as a link
   to click and a Copy link button - the quickest way to try it in a browser.
 - The first request starts a standby run (origin `STANDBY`, no timeout, the standby build and memory) and
   waits until its server answers on `ACTOR_STANDBY_PORT` (4321); later requests reuse it. More runs start
   once concurrent requests exceed `desiredRequestsPerActorRun` / `maxRequestsPerActorRun`.
 - Everything after the standby URL - path, query, headers, body, websockets - reaches the Actor unchanged.
   The token (`?token=`, `Authorization: Bearer`) is required, and only the Actor's owner is served.
-  `http://<username>--<actor-name>.localhost:3333/` works too, where `*.localhost` resolves (browsers);
-  the Actor id can stand in for `<username>--<actor-name>` in either form.
+  The Actor owns `/` of the `*.localhost` URL, as on the platform, so an Actor's web UI with root-relative
+  links (`fetch('/api/...')`) works; under the path form it would not. The Actor id can stand in for
+  `<username>--<actor-name>` in every form.
+- From another Actor's container use `http://apify-api:3333/actor-runtime/standby/<username>--<actor-name>`;
+  the Actor object read from inside a container already carries that as its `standbyUrl`.
 - A run idle for `idleTimeoutSecs` (300 by default) gets the `aborting` event, is stopped 15 s later and
   ends `SUCCEEDED`. Shorten it while developing:
   `apify api PUT v2/actors/<actorId> --body '{"actorStandby":{"idleTimeoutSecs":10}}'`.
@@ -209,7 +215,8 @@ curl "http://localhost:3333/actor-runtime/standby/<username>--<actor-name>/some/
   within 180 s).
 - `apify call` still starts an ordinary `API` run of the same Actor. `sample_actor_standby_ts` and
   `sample_actor_standby_py` are complete Actor servers (JSON, request body, Server-Sent Events, websocket,
-  graceful shutdown) to start from. Multi-tenant Standby and Standby for tasks are not emulated.
+  graceful shutdown) to start from; `sample_actor_standby_web` serves a web page and, in an ordinary run,
+  calls a standby Actor from its container. Multi-tenant Standby and Standby for tasks are not emulated.
 
 ## Test how an Actor handles a platform migration
 
diff --git a/src/api/dto/actors.ts b/src/api/dto/actors.ts
index b1f9cede..5e28c310 100644
--- a/src/api/dto/actors.ts
+++ b/src/api/dto/actors.ts
@@ -1,7 +1,7 @@
 import type { ActorRecord, BuildRecord, RunRecord } from '../../storage/entities.js';
 import { getRunTelemetry } from '../../services/events-channel.js';
 import { computeRunUsage } from '../../services/run-usage.js';
-import { standbyUrl } from '../../services/standby-config.js';
+import { standbyUrl, type StandbyUrlAudience } from '../../services/standby-config.js';
 
 /** Matches `services/actors.ts`'s `DEFAULT_BUILD_TAG` - backfilled here only for run records that
  * predate `options.build` (directly-seeded test fixtures); every real run always has it set already. */
@@ -10,7 +10,7 @@ const DEFAULT_RUN_BUILD_TAG = 'latest';
  * that predate `options.diskMbytes`; every real run always has it set already. */
 const DISK_MBYTES_PER_MEMORY_MBYTE = 2;
 
-export function actorDto(actor: ActorRecord, username: string) {
+export function actorDto(actor: ActorRecord, username: string, audience: StandbyUrlAudience = 'host') {
 	return {
 		id: actor.id,
 		userId: actor.userId,
@@ -26,7 +26,7 @@ export function actorDto(actor: ActorRecord, username: string) {
 		deploymentKey: actor.id,
 		pricingInfos: actor.pricingInfos ?? [],
 		...(actor.actorStandby ? { actorStandby: actor.actorStandby } : {}),
-		standbyUrl: actor.actorStandby?.isEnabled ? standbyUrl(actor, username) : null,
+		standbyUrl: actor.actorStandby?.isEnabled ? standbyUrl(actor, username, audience) : null,
 		taggedBuilds: Object.fromEntries(
 			Object.entries(actor.taggedBuilds).map(([tag, info]) => [
 				tag,
diff --git a/src/api/routes/actors.ts b/src/api/routes/actors.ts
index e0aa2059..cec395b6 100644
--- a/src/api/routes/actors.ts
+++ b/src/api/routes/actors.ts
@@ -43,7 +43,12 @@ import { CONTAINER_API_BASE_URL } from '../../config.js';
 import { resolveProxyPassword } from '../../services/users.js';
 import { validatePricingInfosUpdate } from '../../services/pricing.js';
 import { resolveBuildInput } from '../../services/input-schema.js';
-import { declaresStandbyMode, mergeStandbyUpdate, standbyUrl } from '../../services/standby-config.js';
+import {
+	declaresStandbyMode,
+	mergeStandbyUpdate,
+	standbyUrl,
+	standbyUrlAudienceOf,
+} from '../../services/standby-config.js';
 
 /** `undefined` when the body does not mention the field; an invalid one throws. */
 function actorStandbyFromBody(body: { actorStandby?: unknown }, actor?: ActorRecord): ActorStandbyRecord | undefined {
@@ -90,7 +95,9 @@ export function mountActors(router: Router, deps: ApiServerDeps): void {
 			const envelope = paginate(sorted, paginationParams(req));
 			sendData(res, {
 				...envelope,
-				items: envelope.items.map((actor) => actorDto(actor, requireUser(req).username)),
+				items: envelope.items.map((actor) =>
+					actorDto(actor, requireUser(req).username, standbyUrlAudienceOf(req.headers.host)),
+				),
 			});
 		}),
 	);
@@ -110,7 +117,7 @@ export function mountActors(router: Router, deps: ApiServerDeps): void {
 			// An explicit `actorStandby` wins over `usesStandbyMode`, even one that disables it.
 			const actorStandby = actorStandbyFromBody(body) ?? standbyEnabledByVersions(undefined, body.versions ?? []);
 			const actor = await createActor(requireUser(req).id, { ...body, actorStandby });
-			sendData(res, actorDto(actor, requireUser(req).username), 201);
+			sendData(res, actorDto(actor, requireUser(req).username, standbyUrlAudienceOf(req.headers.host)), 201);
 		}),
 	);
 
@@ -119,7 +126,7 @@ export function mountActors(router: Router, deps: ApiServerDeps): void {
 		h(async (req, res) => {
 			const actor = await resolveActorParam(req);
 			if (!actor) throw recordNotFound();
-			sendData(res, actorDto(actor, requireUser(req).username));
+			sendData(res, actorDto(actor, requireUser(req).username, standbyUrlAudienceOf(req.headers.host)));
 		}),
 	);
 
@@ -140,7 +147,10 @@ export function mountActors(router: Router, deps: ApiServerDeps): void {
 				...(pricingInfos !== undefined ? { pricingInfos } : {}),
 				...(actorStandby !== undefined ? { actorStandby } : {}),
 			}));
-			sendData(res, actorDto(updated ?? actor, requireUser(req).username));
+			sendData(
+				res,
+				actorDto(updated ?? actor, requireUser(req).username, standbyUrlAudienceOf(req.headers.host)),
+			);
 		}),
 	);
 
diff --git a/src/api/routes/datasets.ts b/src/api/routes/datasets.ts
index 9f78a849..908750e8 100644
--- a/src/api/routes/datasets.ts
+++ b/src/api/routes/datasets.ts
@@ -114,7 +114,9 @@ export function mountDatasets(router: Router, deps: ApiServerDeps): void {
 	router.get(
 		'/datasets',
 		h(async (req, res) => {
-			const records = await listOwnedStorages(requireUser(req).id, 'dataset');
+			const records = await listOwnedStorages(requireUser(req).id, 'dataset', {
+				includeUnnamed: queryBoolean(req, 'unnamed') ?? false,
+			});
 			const sorted = sortByTimestamp(records, (record) => record.createdAt);
 			const envelope = paginate(sorted, paginationParams(req));
 			const items = await Promise.all(
diff --git a/src/api/routes/key-value-stores.ts b/src/api/routes/key-value-stores.ts
index 690fa402..7c547712 100644
--- a/src/api/routes/key-value-stores.ts
+++ b/src/api/routes/key-value-stores.ts
@@ -5,7 +5,15 @@ import { requireUser } from '../auth.js';
 import { paginate, sendData, sortByTimestamp } from '../envelope.js';
 import { recordNotFound } from '../errors.js';
 import { resolveStorageParam } from '../resolve-reference.js';
-import { h, optionalJsonBody, paginationParams, queryNumber, queryString, toNodeBuffer } from '../handler.js';
+import {
+	h,
+	optionalJsonBody,
+	paginationParams,
+	queryBoolean,
+	queryNumber,
+	queryString,
+	toNodeBuffer,
+} from '../handler.js';
 import { openKeyValueStore } from '../../storage/open.js';
 import { createStorage, listOwnedStorages, renameStorage, dropStorage, touchStorage } from '../../services/storages.js';
 import { keyValueStoreDto } from '../dto/storages.js';
@@ -116,7 +124,9 @@ export function mountKeyValueStores(router: Router): void {
 	router.get(
 		'/key-value-stores',
 		h(async (req, res) => {
-			const records = await listOwnedStorages(requireUser(req).id, 'keyValueStore');
+			const records = await listOwnedStorages(requireUser(req).id, 'keyValueStore', {
+				includeUnnamed: queryBoolean(req, 'unnamed') ?? false,
+			});
 			const sorted = sortByTimestamp(records, (record) => record.createdAt);
 			const envelope = paginate(sorted, paginationParams(req));
 			sendData(res, { ...envelope, items: envelope.items.map((record) => keyValueStoreDto(record)) });
diff --git a/src/api/routes/request-queues.ts b/src/api/routes/request-queues.ts
index 7b564ecb..0c1c93b4 100644
--- a/src/api/routes/request-queues.ts
+++ b/src/api/routes/request-queues.ts
@@ -151,7 +151,9 @@ export function mountRequestQueues(router: Router): void {
 	router.get(
 		'/request-queues',
 		h(async (req, res) => {
-			const records = await listOwnedStorages(requireUser(req).id, 'requestQueue');
+			const records = await listOwnedStorages(requireUser(req).id, 'requestQueue', {
+				includeUnnamed: queryBoolean(req, 'unnamed') ?? false,
+			});
 			const sorted = sortByTimestamp(records, (record) => record.createdAt);
 			const envelope = paginate(sorted, paginationParams(req));
 			const items = await Promise.all(
diff --git a/src/api/standby-proxy.ts b/src/api/standby-proxy.ts
index 9a86fbdc..4d7f20cf 100644
--- a/src/api/standby-proxy.ts
+++ b/src/api/standby-proxy.ts
@@ -1,9 +1,10 @@
 /**
  * The standby router (`api.md`'s "Actor Standby"): forwards a request addressed to a standby Actor to
  * one of its standby runs, starting runs as `services/standby.ts` decides. Two addressings, both on the
- * API port: `/actor-runtime/standby/<label>/<path>` (the Actor's `standbyUrl`, resolvable everywhere)
- * and `http://<label>.localhost:3333/<path>` (the platform's host-based shape, for browsers that
- * resolve `*.localhost`). `<label>` is the platform's `<username>--<actor-name>`, or the Actor id.
+ * API port: `http://<label>.localhost:3333/<path>` (the Actor's `standbyUrl`, the platform's host-based
+ * shape, where the Actor owns `/`) and `/actor-runtime/standby/<label>/<path>` (for Actor containers and
+ * clients that do not resolve `*.localhost`). `<label>` is the platform's `<username>--<actor-name>`, or
+ * the Actor id.
  *
  * Mounted ahead of the API's body parser, so a request body is streamed through untouched.
  */
diff --git a/src/driver/docker-driver.ts b/src/driver/docker-driver.ts
index 7ac39985..08faceac 100644
--- a/src/driver/docker-driver.ts
+++ b/src/driver/docker-driver.ts
@@ -466,12 +466,26 @@ async function allocateFreePort(): Promise<number> {
 			const address = server.address();
 			server.close(() => {
 				if (address && typeof address === 'object') resolve(address.port);
-				else reject(new Error('Could not allocate a free port for the browser-view sidecar'));
+				else reject(new Error('Could not allocate a free port'));
 			});
 		});
 	});
 }
 
+/**
+ * A standby container's env inside this process's network namespace: its server on `port`, and the API
+ * on loopback, since `apify-api` is not in the hosts file a joined namespace shares.
+ */
+export function sharedNetnsEnv(env: Record<string, string>, port: number): Record<string, string> {
+	const shared: Record<string, string> = {};
+	for (const [key, value] of Object.entries(env)) {
+		shared[key] = value.replace(`://${CONTAINER_API_ALIAS}:`, '://127.0.0.1:');
+	}
+	shared.ACTOR_STANDBY_PORT = String(port);
+	shared.ACTOR_WEB_SERVER_PORT = String(port);
+	return shared;
+}
+
 /**
  * Maps the `linkTarget` a symlink stat reports back to a host path. Docker resolves a link's target in
  * the scope of the container's root filesystem and reports that absolute container path: a target that
@@ -1079,7 +1093,12 @@ export class DockerDriver implements Driver {
 			throw new Error(this.unavailableReason ?? 'Docker is not available');
 		}
 
-		const env = Object.entries(ctx.env).map(([key, value]) => `${key}=${value}`);
+		const serverRoute = ctx.containerServerPort ? this.containerServerRoute() : undefined;
+		// In this process's network namespace every server needs a port of its own, and the API is on loopback.
+		const netnsServerPort = serverRoute === 'netns' ? await allocateFreePort() : undefined;
+		const env = Object.entries(netnsServerPort ? sharedNetnsEnv(ctx.env, netnsServerPort) : ctx.env).map(
+			([key, value]) => `${key}=${value}`,
+		);
 
 		// Informational only - the requested limits are applied verbatim either way.
 		const overCapacityWarning = this.buildOverCapacityWarning(ctx);
@@ -1126,10 +1145,9 @@ export class DockerDriver implements Driver {
 				: []),
 		];
 
-		const serverRoute = ctx.containerServerPort ? this.containerServerRoute() : undefined;
 		// Only a server this process cannot reach on `apify-local` is published, on an engine-picked port.
 		const serverPublish =
-			ctx.containerServerPort && serverRoute !== 'network'
+			ctx.containerServerPort && (serverRoute === 'loopback' || serverRoute === 'host')
 				? {
 						port: `${ctx.containerServerPort}/tcp`,
 						// A process on the host reaches loopback; one in a container off the network reaches the host.
@@ -1159,9 +1177,11 @@ export class DockerDriver implements Driver {
 						...(preservedEntrypoint.cmd ? { Cmd: preservedEntrypoint.cmd } : {}),
 					}
 				: {}),
-			...(Object.keys(exposedPorts).length > 0 ? { ExposedPorts: exposedPorts } : {}),
+			...(Object.keys(exposedPorts).length > 0 && !netnsServerPort ? { ExposedPorts: exposedPorts } : {}),
 			HostConfig: {
-				...(await this.actorNetworkHostConfig()),
+				...(netnsServerPort
+					? { NetworkMode: `container:${process.env.HOSTNAME}` }
+					: await this.actorNetworkHostConfig()),
 				...(this.resourceLimits.memory ? { Memory: ctx.memoryMbytes * 1024 * 1024 } : {}),
 				// A CFS quota, never `NanoCpus`: the daemon hard-rejects a `NanoCpus` above the host's own
 				// CPU count, which would turn "warn, never clamp" into "cannot run at all". `CpuQuota` is
@@ -1171,7 +1191,7 @@ export class DockerDriver implements Driver {
 					: {}),
 				AutoRemove: false,
 				...(mounts.length > 0 ? { Mounts: mounts } : {}),
-				...(Object.keys(portBindings).length > 0 ? { PortBindings: portBindings } : {}),
+				...(Object.keys(portBindings).length > 0 && !netnsServerPort ? { PortBindings: portBindings } : {}),
 			},
 			Tty: false,
 		});
@@ -1207,7 +1227,9 @@ export class DockerDriver implements Driver {
 			// removes the container.
 			sampler = onSample ? startResourceSampler(container, ctx.memoryMbytes * 1024 * 1024, onSample) : undefined;
 
-			if (ctx.containerServerPort && serverRoute) {
+			if (netnsServerPort) {
+				this.containerServers.set(ctx.runId, { host: '127.0.0.1', port: netnsServerPort });
+			} else if (ctx.containerServerPort && serverRoute && serverRoute !== 'netns') {
 				const address = await this.resolveContainerServer(container, ctx.containerServerPort, serverRoute);
 				if (address) this.containerServers.set(ctx.runId, address);
 				else
@@ -1318,10 +1340,14 @@ export class DockerDriver implements Driver {
 	/**
 	 * How this process reaches a standby container's server: directly on `apify-local` when this process
 	 * sits there too; otherwise through a published port - on loopback for a process running on the host
-	 * itself, on the host's address for one in a container off the network (rootless Podman, Podman 3.x).
+	 * itself, on the host's address for one in a container off the network (rootless Podman). On Podman
+	 * 3.x the host's address from a container is the slirp4netns gateway, which reaches the host's
+	 * published ports only for containers started with `allow_host_loopback` - never this one - so the
+	 * standby container joins this container's network namespace instead, as a browser-view sidecar does.
 	 */
-	private containerServerRoute(): 'network' | 'loopback' | 'host' {
+	private containerServerRoute(): 'network' | 'loopback' | 'host' | 'netns' {
 		if (this.onActorNetwork && !this.actorsOnDefaultNetwork) return 'network';
+		if (this.actorsOnDefaultNetwork && process.env.HOSTNAME) return 'netns';
 		return process.env.HOSTNAME ? 'host' : 'loopback';
 	}
 
diff --git a/src/services/standby-config.ts b/src/services/standby-config.ts
index 1b5870f4..da6bfe9f 100644
--- a/src/services/standby-config.ts
+++ b/src/services/standby-config.ts
@@ -3,7 +3,7 @@
  * defaults and validation rules (apify-core's `ActorStandbySchema`), single-tenant only.
  */
 import type { ActorRecord, ActorStandbyRecord, SourceFile } from '../storage/entities.js';
-import { API_PORT } from '../config.js';
+import { API_PORT, CONTAINER_API_ALIAS, CONTAINER_API_BASE_URL } from '../config.js';
 import { parseActorJson } from './actor-source-files.js';
 import { DEFAULT_BUILD_TAG } from './actors.js';
 
@@ -110,9 +110,23 @@ export function standbyLabel(actor: ActorRecord, username: string): string {
 	return `${dnsFriendly(username)}--${actor.name.toLowerCase()}`;
 }
 
-/** Host-facing: the runtime's own API port, which is what every client of the Actor reaches. */
-export function standbyUrl(actor: ActorRecord, username: string): string {
-	return `http://localhost:${API_PORT}${STANDBY_PATH_PREFIX}/${standbyLabel(actor, username)}`;
+/** Who a standby URL is for: a client on the host, or another Actor's container. */
+export type StandbyUrlAudience = 'host' | 'container';
+
+/**
+ * Host-facing, the platform's shape: the Actor owns `/` of its own origin, so a web UI served by the Actor
+ * can use root-relative links. Containers cannot resolve `*.localhost` to the runtime, so they get the
+ * path form on the API alias instead.
+ */
+export function standbyUrl(actor: ActorRecord, username: string, audience: StandbyUrlAudience = 'host'): string {
+	const label = standbyLabel(actor, username);
+	if (audience === 'container') return `${CONTAINER_API_BASE_URL}${STANDBY_PATH_PREFIX}/${label}`;
+	return `http://${label}.localhost:${API_PORT}`;
+}
+
+/** An API request addressed to the alias only Actor containers use comes from one of them. */
+export function standbyUrlAudienceOf(host: string | undefined): StandbyUrlAudience {
+	return host?.toLowerCase().split(':')[0] === CONTAINER_API_ALIAS ? 'container' : 'host';
 }
 
 /** The label, or `undefined` for a Host header not of the `<label>.localhost` form. */
diff --git a/src/services/storages.ts b/src/services/storages.ts
index b2808090..f3fb73a6 100644
--- a/src/services/storages.ts
+++ b/src/services/storages.ts
@@ -62,9 +62,14 @@ export async function getOwnedStorage(userId: string, id: string, type: StorageT
 	return record;
 }
 
-export async function listOwnedStorages(userId: string, type: StorageType): Promise<StorageRecord[]> {
+/** Named storages only unless `includeUnnamed`, as the platform's list endpoints (`?unnamed=`) do. */
+export async function listOwnedStorages(
+	userId: string,
+	type: StorageType,
+	{ includeUnnamed }: { includeUnnamed: boolean },
+): Promise<StorageRecord[]> {
 	const all = await getRegistries().storages.list();
-	return all.filter((s) => s.userId === userId && s.type === type);
+	return all.filter((s) => s.userId === userId && s.type === type && (includeUnnamed || s.name !== undefined));
 }
 
 /** Cross-user listing, for the console only (see `services/actors.ts: listAllActors`'s doc comment). */
@@ -87,7 +92,7 @@ export async function findOwnedStorageByName(
 	name: string,
 ): Promise<StorageRecord | null> {
 	const wanted = normalizeName(name);
-	const owned = await listOwnedStorages(userId, type);
+	const owned = await listOwnedStorages(userId, type, { includeUnnamed: false });
 	return owned.find((s) => s.name !== undefined && normalizeName(s.name) === wanted) ?? null;
 }
 
diff --git a/test/e2e/all-modes.test.ts b/test/e2e/all-modes.test.ts
index dc5518bc..33317453 100644
--- a/test/e2e/all-modes.test.ts
+++ b/test/e2e/all-modes.test.ts
@@ -21,7 +21,7 @@ import {
 	waitForHttpOk,
 } from './helpers/docker.js';
 import { CRAWL_START_URL } from './helpers/browser-view-suite.js';
-import { CONSOLE_URL, readMirrorGreeting } from './helpers/console-view.js';
+import { CONSOLE_URL, fetchConsole, readMirrorGreeting } from './helpers/console-view.js';
 import { withRunLogOnFailure } from './helpers/run-log.js';
 import { waitFor } from './helpers/wait.js';
 import {
@@ -311,7 +311,7 @@ describe('all advanced modes at once: debug + live dev folder + browser view on
 			expect(finalLog).toContain(EDITED_MARKER);
 			expect(finalLog).not.toContain(ORIGINAL_MARKER);
 
-			const endedPage = await fetch(`${CONSOLE_URL}/runs/${run.id}/browser`);
+			const endedPage = await fetchConsole(`/runs/${run.id}/browser`);
 			expect(await endedPage.text()).toContain('This run has ended');
 			await expect(readMirrorGreeting(run.id, 10_000)).rejects.toThrow(/1008/);
 		},
diff --git a/test/e2e/helpers/browser-view-suite.ts b/test/e2e/helpers/browser-view-suite.ts
index 7011c694..355f0765 100644
--- a/test/e2e/helpers/browser-view-suite.ts
+++ b/test/e2e/helpers/browser-view-suite.ts
@@ -19,7 +19,7 @@ import {
 	stopRuntimeContainer,
 	waitForHttpOk,
 } from './docker.js';
-import { CONSOLE_URL, readMirrorGreeting } from './console-view.js';
+import { CONSOLE_URL, fetchConsole, readMirrorGreeting } from './console-view.js';
 import { withRunLogOnFailure } from './run-log.js';
 import { waitFor } from './wait.js';
 import {
@@ -163,12 +163,12 @@ export function describeBrowserViewSuite(sample: BrowserViewSample): void {
 				expect(greeting.startsWith('RFB 003.')).toBe(true);
 
 				// The console's run page links to the viewer, and the viewer page embeds the noVNC client.
-				const runPage = await fetch(`${CONSOLE_URL}/runs/${run.id}`);
+				const runPage = await fetchConsole(`/runs/${run.id}`);
 				expect(await runPage.text()).toContain(`href="/runs/${run.id}/browser"`);
-				const viewerPage = await fetch(`${CONSOLE_URL}/runs/${run.id}/browser`);
+				const viewerPage = await fetchConsole(`/runs/${run.id}/browser`);
 				expect(viewerPage.status).toBe(200);
 				expect(await viewerPage.text()).toContain('/vendor/novnc/core/rfb.js');
-				const client = await fetch(`${CONSOLE_URL}/vendor/novnc/core/rfb.js`);
+				const client = await fetchConsole(`/vendor/novnc/core/rfb.js`);
 				expect(client.status).toBe(200);
 
 				await withRunLogOnFailure(
@@ -200,7 +200,7 @@ export function describeBrowserViewSuite(sample: BrowserViewSample): void {
 				);
 
 				// Once the run is over its mirror is gone: the viewer page says so, and the websocket is refused.
-				const endedPage = await fetch(`${CONSOLE_URL}/runs/${run.id}/browser`);
+				const endedPage = await fetchConsole(`/runs/${run.id}/browser`);
 				expect(await endedPage.text()).toContain('This run has ended');
 				await expect(readMirrorGreeting(run.id, 10_000)).rejects.toThrow(/1008/);
 			},
diff --git a/test/e2e/helpers/console-view.ts b/test/e2e/helpers/console-view.ts
index e026431b..61e096f3 100644
--- a/test/e2e/helpers/console-view.ts
+++ b/test/e2e/helpers/console-view.ts
@@ -2,6 +2,20 @@ import WebSocket from 'ws';
 
 export const CONSOLE_URL = 'http://localhost:3000';
 
+/**
+ * A GET of a console page. Retried once when the request went out on a keep-alive connection the other
+ * side had already closed - as a browser retries it - since rootless Podman's port forwarder can keep
+ * the client's end of an idle connection open after the console closed its own.
+ */
+export async function fetchConsole(path: string): Promise<Response> {
+	try {
+		return await fetch(`${CONSOLE_URL}${path}`);
+	} catch (error) {
+		if ((error as { cause?: { code?: string } }).cause?.code !== 'UND_ERR_SOCKET') throw error;
+		return fetch(`${CONSOLE_URL}${path}`);
+	}
+}
+
 /** Resolves with x11vnc's `ProtocolVersion` greeting - proof the bridge reached a live VNC server
  * mirroring the run's display. `test.md`'s documented exception to the CLI-only rule. */
 export function readMirrorGreeting(runId: string, timeoutMs: number): Promise<string> {
diff --git a/test/e2e/standby.test.ts b/test/e2e/standby.test.ts
index 9bfcc8ee..b796dd9f 100644
--- a/test/e2e/standby.test.ts
+++ b/test/e2e/standby.test.ts
@@ -2,9 +2,12 @@
  * Actor Standby end to end (`test.md`'s "Actor Standby"), for both standby samples: `apify push` enables
  * Standby from `.actor/actor.json`, requests to the Actor's standby URL are served by one standby run,
  * an idle run is wound down, and the next request starts a fresh one that sees the previous run's
- * totals. The requests themselves are plain HTTP and a websocket - the narrow exception `test.md`
- * allows, since no `apify` command sends one; every other assertion reads `apify` output.
+ * totals. `sample_actor_standby_web` covers the two kinds of callers: an external client at the
+ * platform-shaped `*.localhost` standby URL, and another Actor's run calling from its container. The
+ * requests themselves are plain HTTP and a websocket - the narrow exception `test.md` allows, since no
+ * `apify` command sends one; every other assertion reads `apify` output.
  */
+import http from 'node:http';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
 import { afterAll, beforeAll, describe, expect, it } from 'vitest';
@@ -25,6 +28,7 @@ import {
 	loginApifyCli,
 	removeIsolatedApifyHome,
 	type ApiEnvelope,
+	type CallResult,
 	type DatasetInfoResult,
 	type PushResult,
 } from './helpers/apify-cli.js';
@@ -45,12 +49,45 @@ interface RunSummary {
 	options: { timeoutSecs: number };
 }
 
+/** Retried once on a keep-alive connection the other side already closed (`helpers/console-view.ts`). */
+async function fetchWithRetry(url: string, init?: RequestInit): Promise<Response> {
+	try {
+		return await fetch(url, init);
+	} catch (error) {
+		if ((error as { cause?: { code?: string } }).cause?.code !== 'UND_ERR_SOCKET') throw error;
+		return fetch(url, init);
+	}
+}
+
 async function getJson<T>(url: string, init?: RequestInit): Promise<T> {
-	const res = await fetch(url, { ...init, headers: { authorization: `Bearer ${TOKEN}`, ...init?.headers } });
+	const res = await fetchWithRetry(url, {
+		...init,
+		headers: { authorization: `Bearer ${TOKEN}`, ...init?.headers },
+	});
 	expect(res.status, `${url} answered ${res.status}: ${await res.clone().text()}`).toBe(200);
 	return (await res.json()) as T;
 }
 
+/**
+ * A GET to a `http://<label>.localhost:3333` standby URL, sent the way a browser does: to loopback, with the
+ * URL's host in the `Host` header. This process's resolver, unlike a browser's, does not map `*.localhost`.
+ */
+function getByHost(standbyUrl: string, path: string): Promise<{ status: number; body: string }> {
+	const { hostname, host, port } = new URL(standbyUrl);
+	expect(hostname).toMatch(/\.localhost$/);
+	return new Promise((resolve, reject) => {
+		// `agent: false`: a fresh connection each time, so an idle one closed underneath is never reused.
+		http.get(
+			{ host: '127.0.0.1', port, path, agent: false, headers: { host, authorization: `Bearer ${TOKEN}` } },
+			(res) => {
+				let body = '';
+				res.on('data', (chunk) => (body += chunk));
+				res.on('end', () => resolve({ status: res.statusCode!, body }));
+			},
+		).on('error', reject);
+	});
+}
+
 function websocketRoundTrip(url: string): Promise<string[]> {
 	return new Promise((resolve, reject) => {
 		const frames: string[] = [];
@@ -106,7 +143,10 @@ describe('Actor Standby via apify-cli (requires Docker)', () => {
 					apify(['api', 'GET', `actors/${actorId}`], { cwd: actorDir, env }),
 				) as ApiEnvelope<{ actorStandby: { isEnabled: boolean; idleTimeoutSecs: number }; standbyUrl: string }>;
 				expect(actor.data.actorStandby).toMatchObject({ isEnabled: true, idleTimeoutSecs: 10 });
-				const url = actor.data.standbyUrl;
+				// The platform-shaped `*.localhost` standbyUrl; this process reaches the same Actor by the path form.
+				const standbyHost = new URL(actor.data.standbyUrl);
+				expect(standbyHost.hostname).toMatch(/--[a-z0-9-]+\.localhost$/);
+				const url = `http://localhost:${standbyHost.port}/actor-runtime/standby/${standbyHost.hostname.replace(/\.localhost$/, '')}`;
 
 				const index = await getJson<{ runId: string; endpoints: string[] }>(`${url}/`);
 				expect(index.endpoints).toContain('GET /hello?name=');
@@ -124,7 +164,7 @@ describe('Actor Standby via apify-cli (requires Docker)', () => {
 				});
 				expect(echo).toMatchObject({ query: { x: '1' }, body: { nested: { ok: true } } });
 
-				const stream = await fetch(`${url}/stream?count=3&token=${TOKEN}`);
+				const stream = await fetchWithRetry(`${url}/stream?count=3&token=${TOKEN}`);
 				expect(stream.headers.get('content-type')).toMatch(/^text\/event-stream/);
 				const events = (await stream.text()).match(/^event: \w+$/gm);
 				expect(events).toEqual(['event: tick', 'event: tick', 'event: tick', 'event: done']);
@@ -171,4 +211,92 @@ describe('Actor Standby via apify-cli (requires Docker)', () => {
 			8 * 60 * 1000,
 		);
 	}
+
+	describe('sample_actor_standby_web', () => {
+		const actorDir = join(REPO_ROOT, 'sample_actor_standby_web');
+		let actorId: string;
+		let standbyUrl: string;
+
+		beforeAll(
+			() => {
+				const env = apifyEnv(isolatedApifyHome);
+				const push = JSON.parse(apify(['push', '--json'], { cwd: actorDir, env })) as PushResult;
+				expect(push.build.status).toBe('SUCCEEDED');
+				actorId = push.actor.id;
+				standbyUrl = (
+					JSON.parse(apify(['api', 'GET', `actors/${actorId}`], { cwd: actorDir, env })) as ApiEnvelope<{
+						standbyUrl: string;
+					}>
+				).data.standbyUrl;
+			},
+			5 * 60 * 1000,
+		);
+
+		it('an external client calls a standby endpoint at the *.localhost standbyUrl, where the Actor owns /', async () => {
+			const env = apifyEnv(isolatedApifyHome);
+			// The platform's shape: `<username>--<actor-name>.apify.actor` becomes `<username>--<actor-name>.localhost:3333`.
+			expect(standbyUrl).toMatch(/^http:\/\/[a-z0-9-]+--my-standby-web-actor\.localhost:3333$/);
+			const { host } = new URL(standbyUrl);
+
+			// The page calls its API root-relative, which reaches the Actor only because it owns `/`.
+			const page = await getByHost(standbyUrl, `/?token=${TOKEN}`);
+			expect(page.status).toBe(200);
+			expect(page.body).toContain("fetch('/api/greeting");
+
+			const greeting = await getByHost(standbyUrl, '/api/greeting?name=Ada');
+			expect(greeting.status, greeting.body).toBe(200);
+			const answer = JSON.parse(greeting.body) as { greeting: string; runId: string; host: string };
+			expect(answer).toMatchObject({ greeting: 'Hello, Ada!', host });
+
+			const run = (
+				JSON.parse(
+					apify(['api', 'GET', `actor-runs/${answer.runId}`], { cwd: actorDir, env }),
+				) as ApiEnvelope<RunSummary>
+			).data;
+			expect(run).toMatchObject({ status: 'RUNNING', meta: { origin: 'STANDBY' } });
+
+			// The path form reaches the same run, for clients that do not resolve `*.localhost`.
+			const label = new URL(standbyUrl).hostname.replace(/\.localhost$/, '');
+			const byPath = await getJson<{ greeting: string; runId: string }>(
+				`http://localhost:3333/actor-runtime/standby/${label}/api/greeting?name=Grace`,
+			);
+			expect(byPath).toEqual(expect.objectContaining({ greeting: 'Hello, Grace!', runId: answer.runId }));
+		});
+
+		it(
+			"another Actor's run calls a standby endpoint from inside its container",
+			() => {
+				const env = apifyEnv(isolatedApifyHome);
+				// An ordinary run of the sample is the client: it reads the standby Actor's standbyUrl through the
+				// API from its container and calls `/api/greeting` there.
+				const call = JSON.parse(
+					apify(['call', '--input', JSON.stringify({ standbyActor: actorId, name: 'Actor' }), '--json'], {
+						cwd: actorDir,
+						env,
+					}),
+				) as CallResult;
+				expect(call.run.status).toBe('SUCCEEDED');
+
+				const items = JSON.parse(
+					apify(['api', 'GET', `datasets/${call.storage.defaultDatasetId}/items`], { cwd: actorDir, env }),
+				) as Array<{ standbyUrl: string; status: number; greeting: string; runId: string }>;
+				expect(items).toHaveLength(1);
+				const label = new URL(standbyUrl).hostname.replace(/\.localhost$/, '');
+				expect(items[0]).toMatchObject({
+					standbyUrl: `http://apify-api:3333/actor-runtime/standby/${label}`,
+					status: 200,
+					greeting: 'Hello, Actor!',
+				});
+
+				const standbyRun = (
+					JSON.parse(
+						apify(['api', 'GET', `actor-runs/${items[0]!.runId}`], { cwd: actorDir, env }),
+					) as ApiEnvelope<RunSummary>
+				).data;
+				expect(standbyRun.meta.origin).toBe('STANDBY');
+				expect(items[0]!.runId).not.toBe(call.run.id);
+			},
+			5 * 60 * 1000,
+		);
+	});
 });
diff --git a/test/integration/datasets.test.ts b/test/integration/datasets.test.ts
index 9865aa02..f60c7176 100644
--- a/test/integration/datasets.test.ts
+++ b/test/integration/datasets.test.ts
@@ -26,6 +26,31 @@ describe('datasets API (via real apify-client)', () => {
 		expect(fetched?.id).toBe(created.id);
 	});
 
+	it('lists only named storages unless unnamed=true, as the platform does', async () => {
+		const named = await server.client.datasets().getOrCreate('named');
+		const unnamed = await server.client.datasets().getOrCreate();
+
+		const byDefault = await server.client.datasets().list();
+		expect(byDefault.items.map((dataset) => dataset.id)).toEqual([named.id]);
+		expect(byDefault.total).toBe(1);
+
+		const all = await server.client.datasets().list({ unnamed: true });
+		expect(all.items.map((dataset) => dataset.id).sort()).toEqual([named.id, unnamed.id].sort());
+		expect(all.total).toBe(2);
+
+		for (const path of ['key-value-stores', 'request-queues']) {
+			await fetch(`${server.baseUrl}/v2/${path}?token=${server.token}`, { method: 'POST' });
+			const hidden = (await (await fetch(`${server.baseUrl}/v2/${path}?token=${server.token}`)).json()) as {
+				data: { total: number };
+			};
+			expect(hidden.data.total).toBe(0);
+			const shown = (await (
+				await fetch(`${server.baseUrl}/v2/${path}?unnamed=true&token=${server.token}`)
+			).json()) as { data: { total: number } };
+			expect(shown.data.total).toBe(1);
+		}
+	});
+
 	it('pushes and paginates items', async () => {
 		const { id } = await server.client.datasets().getOrCreate();
 		const dataset = server.client.dataset(id);
diff --git a/test/integration/standby.test.ts b/test/integration/standby.test.ts
index c29107fd..e7aa0944 100644
--- a/test/integration/standby.test.ts
+++ b/test/integration/standby.test.ts
@@ -178,10 +178,33 @@ describe('actorStandby on the Actor object', () => {
 		});
 		const me = await server.client.user('me').get();
 		expect((created as unknown as { standbyUrl: string }).standbyUrl).toBe(
-			`http://localhost:3333/actor-runtime/standby/${me!.username}--my-server`,
+			`http://${me!.username}--my-server.localhost:3333`,
 		);
 	});
 
+	it('gives an Actor container the path form on the API alias as the standbyUrl', async () => {
+		server = await startTestServer();
+		const created = await server.client.actors().create({ name: 'my-server', actorStandby: { isEnabled: true } });
+		const me = await server.client.user('me').get();
+		const fromContainer = await new Promise<string>((resolve, reject) => {
+			const port = new URL(server.baseUrl).port;
+			http.get(
+				{
+					host: '127.0.0.1',
+					port,
+					path: `/v2/actors/${created.id}?token=${server.token}`,
+					headers: { host: `apify-api:${port}` },
+				},
+				(res) => {
+					let body = '';
+					res.on('data', (chunk) => (body += chunk));
+					res.on('end', () => resolve(JSON.parse(body).data.standbyUrl));
+				},
+			).on('error', reject);
+		});
+		expect(fromContainer).toBe(`http://apify-api:3333/actor-runtime/standby/${me!.username}--my-server`);
+	});
+
 	it('merges a partial update over the stored settings, and rejects invalid ones unchanged', async () => {
 		server = await startTestServer();
 		const created = await server.client.actors().create({ name: 'a', actorStandby: { isEnabled: true } });
@@ -244,13 +267,12 @@ describe('standby router', () => {
 			.create({ name: 'standby-actor', actorStandby: { isEnabled: true, ...standby } } as never);
 		const actor = (await getRegistries().actors.get(created.id))!;
 		await seedBuild(actor);
-		return {
-			actor,
-			url: (created as unknown as { standbyUrl: string }).standbyUrl.replace(
-				'http://localhost:3333',
-				server.baseUrl,
-			),
-		};
+		// The path form of the same address: this process cannot resolve the `*.localhost` standbyUrl.
+		const label = new URL((created as unknown as { standbyUrl: string }).standbyUrl).hostname.replace(
+			/\.localhost$/,
+			'',
+		);
+		return { actor, url: `${server.baseUrl}/actor-runtime/standby/${label}` };
 	}
 
 	it('starts a STANDBY run and forwards method, path, query, headers and body to its server', async () => {
@@ -287,7 +309,7 @@ describe('standby router', () => {
 			ACTOR_STANDBY_PORT: '4321',
 			ACTOR_WEB_SERVER_PORT: '4321',
 		});
-		expect(ctx.env.ACTOR_STANDBY_URL).toMatch(/\/actor-runtime\/standby\/.+--standby-actor$/);
+		expect(ctx.env.ACTOR_STANDBY_URL).toMatch(/^http:\/\/.+--standby-actor\.localhost:3333$/);
 		expect(driver.containers[0]!.probes).toBeGreaterThan(0);
 
 		// The next request lands on the same run, without starting another.
@@ -447,14 +469,14 @@ describe('standby router', () => {
 			const { port } = consoleServer.address() as AddressInfo;
 			const html = await (await fetch(`http://127.0.0.1:${port}/actors/${actor.id}`)).text();
 			expect(html).toContain('Actor Standby');
-			expect(html).toContain('/actor-runtime/standby/');
+			expect(html).toContain('--standby-actor.localhost:3333');
 			expect(html).toContain(`/runs/${served.runId}`);
 			// A ready-to-use link carries the owner's token, masked on screen.
 			const label = url.split('/').pop()!;
-			const withToken = `http://localhost:3333/actor-runtime/standby/${label}/?token=${server.token}`;
+			const withToken = `http://${label}.localhost:3333/?token=${server.token}`;
 			expect(html).toContain(`href="${withToken}"`);
 			expect(html).toContain(`data-copy="${withToken}"`);
-			expect(html).toContain(`/actor-runtime/standby/${label}/?token=••••••••</a>`);
+			expect(html).toContain(`http://${label}.localhost:3333/?token=••••••••</a>`);
 			expect(html).not.toMatch(new RegExp(`>[^<]*${server.token}[^<]*<`));
 			const runHtml = await (await fetch(`http://127.0.0.1:${port}/runs/${served.runId}`)).text();
 			expect(runHtml).toContain('STANDBY');
diff --git a/test/integration/storages-concurrency.test.ts b/test/integration/storages-concurrency.test.ts
index 290bfa20..8f2c17dd 100644
--- a/test/integration/storages-concurrency.test.ts
+++ b/test/integration/storages-concurrency.test.ts
@@ -32,7 +32,7 @@ describe('createStorage getOrCreate-by-name concurrency', () => {
 
 		expect(a.id).toBe(b.id);
 
-		const all = await listOwnedStorages(userId, 'dataset');
+		const all = await listOwnedStorages(userId, 'dataset', { includeUnnamed: true });
 		expect(all.filter((s) => s.name === 'same-name-concurrent')).toHaveLength(1);
 	});
 
diff --git a/test/unit/docker-driver-standby.test.ts b/test/unit/docker-driver-standby.test.ts
index 52a5c7e3..0ead7121 100644
--- a/test/unit/docker-driver-standby.test.ts
+++ b/test/unit/docker-driver-standby.test.ts
@@ -107,6 +107,50 @@ describe('DockerDriver.startRun - containerServerPort', () => {
 		await outcome;
 	});
 
+	it("on Podman 3.x, joins this container's network namespace on a port of its own, with the API on loopback", async () => {
+		process.env.HOSTNAME = 'self';
+		const stub = stubWithInspect({});
+		const driver = new DockerDriver(stub.docker);
+		driver.available = true;
+		(driver as unknown as { actorsOnDefaultNetwork: boolean }).actorsOnDefaultNetwork = true;
+
+		const outcome = driver.startRun(
+			{
+				runId: 'r5',
+				imageId: 'img',
+				env: {
+					APIFY_API_BASE_URL: 'http://apify-api:3333',
+					ACTOR_EVENTS_WEBSOCKET_URL: 'ws://apify-api:3333/actor-runtime/events/r5',
+					ACTOR_STANDBY_PORT: '4321',
+					ACTOR_WEB_SERVER_PORT: '4321',
+				},
+				memoryMbytes: 128,
+				timeoutSecs: 0,
+				containerServerPort: 4321,
+			},
+			() => {},
+		);
+		await vi.waitFor(() => expect(stub.createContainer).toHaveBeenCalled());
+		await settle();
+
+		const [options] = stub.createContainer.mock.calls[0]!;
+		expect(options.HostConfig?.NetworkMode).toBe('container:self');
+		expect(options.HostConfig?.ExtraHosts).toBeUndefined();
+		expect(options.HostConfig?.PortBindings).toBeUndefined();
+		expect(options.ExposedPorts).toBeUndefined();
+		const env = Object.fromEntries(options.Env!.map((entry: string) => entry.split(/=(.*)/s).slice(0, 2)));
+		expect(env.APIFY_API_BASE_URL).toBe('http://127.0.0.1:3333');
+		expect(env.ACTOR_EVENTS_WEBSOCKET_URL).toBe('ws://127.0.0.1:3333/actor-runtime/events/r5');
+		const port = Number(env.ACTOR_STANDBY_PORT);
+		expect(port).toBeGreaterThan(0);
+		expect(env.ACTOR_WEB_SERVER_PORT).toBe(String(port));
+		expect(await driver.containerServerAddress('r5')).toEqual({ host: '127.0.0.1', port });
+
+		stub.triggerContainerExit(0);
+		stub.endLogStream();
+		await outcome;
+	});
+
 	it('arms no timeout for a run with timeoutSecs 0', async () => {
 		vi.useFakeTimers({ toFake: ['setTimeout'] });
 		try {
diff --git a/test/unit/standby-config.test.ts b/test/unit/standby-config.test.ts
index c93b2a59..ccb61b48 100644
--- a/test/unit/standby-config.test.ts
+++ b/test/unit/standby-config.test.ts
@@ -7,6 +7,8 @@ import {
 	labelFromHost,
 	mergeStandbyUpdate,
 	standbyLabel,
+	standbyUrl,
+	standbyUrlAudienceOf,
 } from '../../src/services/standby-config.js';
 import { standbyTargetOf } from '../../src/api/standby-proxy.js';
 import type { ActorRecord } from '../../src/storage/entities.js';
@@ -65,6 +67,17 @@ describe('standby addressing', () => {
 		expect(standbyLabel(actor, 'john.doe')).toBe('john-doe--my-actor');
 	});
 
+	it('builds the host-facing standbyUrl in the platform shape, and the container one on the API alias', () => {
+		const actor = { name: 'My-Actor' } as ActorRecord;
+		expect(standbyUrl(actor, 'John.Doe')).toBe('http://john-doe--my-actor.localhost:3333');
+		expect(standbyUrl(actor, 'John.Doe', 'container')).toBe(
+			'http://apify-api:3333/actor-runtime/standby/john-doe--my-actor',
+		);
+		expect(standbyUrlAudienceOf('apify-api:3333')).toBe('container');
+		expect(standbyUrlAudienceOf('localhost:3333')).toBe('host');
+		expect(standbyUrlAudienceOf(undefined)).toBe('host');
+	});
+
 	it('reads a label only from a <label>.localhost host', () => {
 		expect(labelFromHost('john-doe--my-actor.localhost:3333')).toBe('john-doe--my-actor');
 		expect(labelFromHost('localhost:3333')).toBeUndefined();

From 0ea2e1bf435409d61398037ecbaffdd8f347a479 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Thu, 24 Sep 2026 10:57:56 +0000
Subject: [PATCH 5/5] docs: Shorten the Actor Standby requirements to the local
 differences

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01W6t3FkairFVeCRTVXrJfTw
---
 requirements/actor-driver.md | 36 ++++--------------------------------
 requirements/api.md          | 24 ++++--------------------
 requirements/console.md      |  7 ++-----
 requirements/system.md       |  6 ++----
 requirements/test.md         | 12 +++---------
 5 files changed, 15 insertions(+), 70 deletions(-)

diff --git a/requirements/actor-driver.md b/requirements/actor-driver.md
index 13b45bed..4a09dc78 100644
--- a/requirements/actor-driver.md
+++ b/requirements/actor-driver.md
@@ -243,32 +243,9 @@ start`, ...) is refused by name, naming both the `CMD` fix and how to clear debu
 
 # Actor Standby
 
-- An Actor with Actor Standby enabled is served as an HTTP server, as on the platform: requests sent to its
-  standby URL (`api.md`) are handled by runs the runtime starts, reuses and stops on its own. Single-tenant
-  only: every standby run belongs to the Actor's owner.
-- Standby is enabled by the Actor's `actorStandby` settings, or by `usesStandbyMode: true` in the pushed
-  `.actor/actor.json` - `apify push` sends the flag either way.
-- The settings are the platform's, with its defaults and validation: `desiredRequestsPerActorRun` (3),
-  `maxRequestsPerActorRun` (4), `idleTimeoutSecs` (300), `build` (`latest`), `memoryMbytes` (1024),
-  `shouldPassActorInput` (false), `disableStandbyFieldsOverride`.
-- A standby run is an ordinary run with origin `STANDBY`: the standby build and memory, no timeout, and
-  input only when `shouldPassActorInput` is set (the input schema's defaults). Its container is sent
-  requests on its standby port once any HTTP request to `/` carrying the header
-  `x-apify-container-server-readiness-probe` gets an answer.
-- A request goes to the least loaded run below `maxRequestsPerActorRun`; with none, a new run is started
-  and the request waits for it. Once every run is above `desiredRequestsPerActorRun`, one more is started
-  ahead of demand.
-- A run with no request for `idleTimeoutSecs` is wound down gracefully like on the platform: `aborting` and
-  `persistState` events, a stop signal 15 seconds later, a kill 15 seconds after that. It ends
-  `SUCCEEDED` and its log says why. A run that crashes or is aborted just leaves the pool.
-- After a new build of the standby build tag, runs of the older build take no new requests and are wound
-  down once their last one completes. A dev-folder edit reaches the next standby run, not a running one.
-- The runtime reaches the run's server without publishing any port, except when the runtime itself is not
-  on the `apify-local` network (run outside a container, rootless Podman, Podman 3.x): the port is then
-  published on an engine-picked host port - on `127.0.0.1` for a runtime on the host itself.
-- The standby run pool lives in memory; a runtime restart aborts standby runs like every other run.
-- Not emulated: multi-tenant Standby, Standby for tasks, and the Console-auth and tokenless options
-  (`unsupported.md`).
+- Implemented as on the platform (settings, `usesStandbyMode`, scaling, readiness, idle shutdown, env vars).
+- Differences: single-tenant, owner-only; a new build of the standby tag replaces older standby runs; a
+  runtime restart aborts standby runs.
 
 # Users
 
@@ -282,12 +259,7 @@ start`, ...) is refused by name, naming both the `CMD` fix and how to clear debu
   default storage ids, or any other contract var the runtime itself sets.
 - `APIFY_IS_AT_HOME=1` (mirrors the real platform; an SDK/client instantiated
   in the container reports `isAtHome`/`is_at_home = true`).
-- `APIFY_META_ORIGIN` — the run's origin: `STANDBY` for a standby run, `API` for every other run (every
-  local run arrives via the API, apify-cli included)
-- `ACTOR_STANDBY_PORT` / `ACTOR_WEB_SERVER_PORT` — the port an Actor server listens on, both set to the same
-  value (the JavaScript SDK reads the first, the Python SDK the second): a version-level
-  `ACTOR_WEB_SERVER_PORT` or `ACTOR_STANDBY_PORT`, else `4321`, as on the platform.
-- `ACTOR_STANDBY_URL` — the Actor's standby URL (`api.md`).
+- `APIFY_META_ORIGIN` — `STANDBY` for a standby run, `API` for every other run
 - `APIFY_API_BASE_URL` — the runtime's own API, reachable by name from any
   Actor container on the shared Docker network (see "Networking" above).
 - `APIFY_TOKEN` — the run owner's token
diff --git a/requirements/api.md b/requirements/api.md
index 15754be6..8f26838d 100644
--- a/requirements/api.md
+++ b/requirements/api.md
@@ -152,26 +152,10 @@
 
 # Actor Standby
 
-- The Actor object carries the platform's `actorStandby` settings (`actor-driver.md`) and `standbyUrl`,
-  `null` while Standby is off. `POST` and `PUT /v2/actors` accept `actorStandby`; a partial object is merged
-  over the stored settings, over the defaults. An invalid one is `400` `invalid-request`, changing nothing;
-  a `tenancy` other than `SINGLE_TENANT` is invalid.
-- The standby URL is `http://<username>--<actor-name>.localhost:3333`, the local `*.apify.actor`: each
-  Actor has its own origin and owns its whole path, so web UIs served by Actors work as on the platform.
-- Clients that do not resolve `*.localhost` use `http://localhost:3333/actor-runtime/standby/<username>--<actor-name>`;
-  other Actors use `http://apify-api:3333/actor-runtime/standby/<username>--<actor-name>`, which is the
-  `standbyUrl` they read through the API.
-- The Actor id can replace `<username>--<actor-name>`. Path, query, method, headers, body and websockets
-  reach the Actor's server unchanged.
-- Authenticated like the API (`Authorization: Bearer`, `?token=`), plus the platform's
-  `x-apify-authorization` header; only the Actor's owner is served.
-- Errors, as `{ "error": { "type", "message" } }`: no token `401` `user-not-authenticated`; no such Actor of
-  the caller's `404` `record-not-found`; Standby off `400` `standby-not-enabled`; no build under the
-  standby build tag `404` `record-not-found`; a run that ended before its server was ready `503`
-  `standby-run-finished`; a server not ready within 180 seconds `504` `standby-run-not-ready`; a server
-  that drops the request `502` `standby-bad-gateway`. None is relayed by the upstream fallback.
-- A standby run's object has `meta.origin` `STANDBY`, `options.timeoutSecs` `0` and
-  `standby: { deployment: "SINGLE_TENANT" }`.
+- Implemented as on the platform. Differences: only the owner is served, and `standbyUrl` is
+  `http://<username>--<actor-name>.localhost:3333`, or `http://localhost:3333/actor-runtime/standby/<username>--<actor-name>`
+  for clients without `*.localhost` (`http://apify-api:3333/...` from Actors). Standby errors are never
+  relayed by the upstream fallback.
 
 # Actor runtime API
 
diff --git a/requirements/console.md b/requirements/console.md
index b57fb276..26f8cfe9 100644
--- a/requirements/console.md
+++ b/requirements/console.md
@@ -117,8 +117,5 @@
 
 ## Actor Standby (Actor detail view)
 
-- The Actor detail view shows whether Actor Standby is on and, when it is, the standby URL, the settings and
-  the Actor's live standby runs with their open requests.
-- It also offers the standby URL with the owner's token in it, as a link to open and a button that copies
-  it; the token is masked in the text shown on the page. Read-only: the settings are changed through the
-  API (`api.md`). The run detail view shows each run's origin.
+- Shows the standby settings, live standby runs, and the standby URL with the owner's token, as a link and
+  a copy button (the token masked on screen). Read-only. The run detail view shows each run's origin.
diff --git a/requirements/system.md b/requirements/system.md
index 4b4442f4..12fe589b 100644
--- a/requirements/system.md
+++ b/requirements/system.md
@@ -24,16 +24,14 @@
   with a clear status message, while every other endpoint (storages, actor/build/run records,
   console) still works.
 - Both ports are fixed and not configurable.
-- Port 3333 also serves the per-run events websocket and every standby Actor (`api.md`); no additional
-  port is published for either.
+- Port 3333 also serves the per-run events websocket and standby Actors (`api.md`); no additional port is
+  published for either.
 - **Debug mode is the one exception to "no other Actor container port is ever published"**
   (`actor-driver.md`'s "Debug mode" section): when debug mode is on for an Actor, that Actor's runs get a
   port published on the host, bound to `127.0.0.1` (`5678` Python / `9229` Node by default, per-Actor
   overridable) - the runtime's own two ports above are unaffected, and no port is published for an Actor
   that never turned debug mode on.
 - Browser view (`actor-driver.md`) publishes no port on the host; the view is served on the console's port 3000.
-- A standby run publishes its server's port only when the runtime cannot reach it otherwise
-  (`actor-driver.md`'s "Actor Standby").
 - Required `docker run` flags: mount the host's Docker-Engine-API socket read-write
   (`-v /var/run/docker.sock:/var/run/docker.sock`) so the runtime can build and run Actor containers,
   and mount a persistent data directory (`-v <host-dir>:/data`, e.g. `-v "$(pwd)/data:/data"`) so
diff --git a/requirements/test.md b/requirements/test.md
index 29c7110c..81008766 100644
--- a/requirements/test.md
+++ b/requirements/test.md
@@ -17,8 +17,7 @@
 - **A second narrow exception of the same kind**: the browser-view e2e test may open the console's viewer
   page and its websocket directly, to emulate a developer's browser opening the view. Everything else in it
   goes through `apify` commands.
-- **A third narrow exception**: the Actor Standby e2e test sends plain HTTP requests and opens a websocket
-  to the Actor's standby URL, since no `apify` command can. Everything else in it goes through `apify` commands.
+- **A third narrow exception**: the Standby e2e test calls standby URLs directly (HTTP, websocket).
 - For asserting the test results, the tests must inspect the return values of the Apify cli commands.
 - The e2e suite requires a reachable Docker daemon (it builds and runs real Actor containers) and
   detects its absence, failing in such case.
@@ -48,10 +47,5 @@ Test case must verify full Actor development flow:
 
 ## Actor Standby
 
-- For each standby sample (`sample_actor_standby_ts`, `sample_actor_standby_py`), whose `.actor/actor.json`
-  enables Standby: push, and shorten its idle timeout
-- Assert that plain, body-carrying, streamed and websocket requests to its standby URL are all answered by
-  one `STANDBY` run, that the run ends `SUCCEEDED` once idle with one dataset item per greeting, and that
-  the next request starts a new run
-- For `sample_actor_standby_web`: assert that an external client and another Actor's run can both call its
-  standby endpoint
+- Each standby sample, pushed: its requests share one `STANDBY` run, which ends `SUCCEEDED` once idle, and
+  the next request starts a new one; `sample_actor_standby_web` is also reachable from another Actor's run.