withruntime 0.14.0 → 0.16.1

package/BLAXEL.md

@@ -11,8 +11,11 @@ import { SandboxInstance } from "withruntime/blaxel"; // was: from "@blaxel/core
 ```
 
 The mapping was written against `@blaxel/core` 0.3.24 and Blaxel's sandbox API
-source, checked 30 September 2026. Every name `@blaxel/core` exports can be
-imported: code that only mentions an agent, model or MCP helper still loads.
+source, checked 30 September 2026, and checked against `@blaxel/core` 0.3.30
+and `blaxel` 0.4.18 on PyPI on 16 October 2026 (below, "0.3.30 and 0.4.18").
+The exact releases and artifact hashes are kept in `compatibility-lock.json`.
+Every name `@blaxel/core` exports can be imported: code that only mentions an
+agent, model or MCP helper still loads.
 
 ## Keys
 
@@ -84,35 +87,38 @@ name, or through `getByExternalId`, use the same Runtime key.
 
 ## Mapping
 
-| Blaxel                                                                                | On Runtime                                                                                                                                                                                                                                                                                                                                                                                       |
-| ------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `SandboxInstance.create({ name, image, memory, labels, ports, envs, ... })`           | `sandboxes.create`. A name another live sandbox holds is a 409, as in Blaxel; one held by a sandbox still being deleted is waited for.                                                                                                                                                                                                                                                           |
-| `createIfNotExists`                                                                   | `create` with `getOrCreate`: Runtime settles two callers racing for one name, and both get the one sandbox. An existing sandbox is answered as it is.                                                                                                                                                                                                                                            |
-| `get(name)`, `getByExternalId`, `list({ limit, externalId, showTerminated })`         | The live sandbox with that name, or with the `externalId` label; Blaxel's paginated list (`data`, `nextPage`, `for await`, `autoPagingToArray`).                                                                                                                                                                                                                                                 |
-| `delete` (static and on the sandbox)                                                  | `stop`: the sandbox ends at once. Using that object afterwards is a 404.                                                                                                                                                                                                                                                                                                                         |
-| `metadata`, `spec`, `status`, `state`, `lastUsedAt`, `expiresIn`                      | From the Runtime sandbox and its `blaxel/` labels (image, memory, ports, region, TTL, expiry, lifecycle, archived), which any client reads; `state` is `STANDBY` while paused.                                                                                                                                                                                                                   |
-| `updateMetadata`, `updateTtl`, `updateLifecycle`, `updateNetwork`                     | Labels (the display name and `externalId` are labels); the paused retention, as at create; network rules.                                                                                                                                                                                                                                                                                        |
-| `archive`, `unarchive`                                                                | `pause`, `wake`. Runtime keeps memory and processes too, and the next call wakes it.                                                                                                                                                                                                                                                                                                             |
-| `network: { allowedDomains, forbiddenDomains, proxy }`                                | Runtime network rules: `allow` and `deny`.                                                                                                                                                                                                                                                                                                                                                       |
-| `volumes: [{ name, mountPath }]`                                                      | The Runtime volume with that name, mounted read-write.                                                                                                                                                                                                                                                                                                                                           |
-| `fetch(port, path, init)`                                                             | The request goes to a private Runtime preview of the port (made on first use, then reused) with its token.                                                                                                                                                                                                                                                                                       |
-| `process.exec` without `waitForCompletion`                                            | One Runtime process, answered running. Its Blaxel name is kept in its command line, so `get("name")` finds it from any client.                                                                                                                                                                                                                                                                   |
-| `process.exec({ waitForCompletion: true })`                                           | One streamed call, answered with `status`, `exitCode`, `stdout`, `stderr` and `logs`. Past `timeout` the wait ends with a 422 and the process runs on.                                                                                                                                                                                                                                           |
-| `onLog`, `onStdout`, `onStderr`, `streamLogs`                                         | The process's output as it comes; `streamLogs` gives whole lines, as Blaxel's does.                                                                                                                                                                                                                                                                                                              |
-| `process.get`, `wait`, `list`, `logs`, `stop`, `kill`, `writeStdin`, `closeStdin`     | Runtime processes by id or name. `wait` follows output with one deadline covering lookup and output. Cancellation leaves the process running. `stop` is SIGTERM, `kill` SIGKILL.                                                                                                                                                                                                                 |
-| `keepAlive`, `timeout`                                                                | The sandbox does not pause for idleness while the process may run (its `timeout`, 600 s by default, 0 for as long as a lease allows); once no `keepAlive` process runs, it gets its idle pause back.                                                                                                                                                                                             |
-| `restartOnFailure`, `maxRestarts`, `waitForPorts`, `workingDir`, `env`, `stdin`       | A restart loop in the same process, with Blaxel's note in the output (`restartCount` counts the notes); a wait in the sandbox for the ports; as in Blaxel.                                                                                                                                                                                                                                       |
-| `fs.read`, `write`, `readBinary`, `writeBinary`, `writeTree`, `mkdir`, `rm`, `cp`     | Runtime's files API, or one command. A path only root may read or write (outside `/workspace`, or made by a root process) goes through sudo, as Blaxel's root-owned API could.                                                                                                                                                                                                                   |
-| `fs.ls`, `find`, `grep`, `search`                                                     | One command each, with Blaxel's defaults, limits and excluded directories. `ls` reports owners.                                                                                                                                                                                                                                                                                                  |
-| `fs.watch(path, callback, { withContent, ignore })`, `fs.download`                    | A Runtime watch (`path/**` for subdirectories); a download to the local disk.                                                                                                                                                                                                                                                                                                                    |
-| `previews.create`, `createIfNotExists`, `get`, `list`, `delete`                       | Runtime previews of `spec.port`, public or private. The Blaxel name is kept in a label, so any client finds it by name.                                                                                                                                                                                                                                                                          |
-| `preview.tokens.create(expiresAt)`                                                    | A token for that long: at least a minute, at most a week. It is read from Blaxel's `X-Blaxel-Preview-Token` header or `?bl_preview_token=` as from Runtime's `x-runtime-preview-token` and `?runtime_preview_token=`, and never passed on to your server.                                                                                                                                        |
-| `snapshots.create`, `list`, `get`, `delete`; `Snapshot.create`, `get`, `list`, `fork` | Runtime snapshots, kept 365 days: files, memory and running processes.                                                                                                                                                                                                                                                                                                                           |
-| `fork(name)`, `fork(name, { snapshotId, envs })`                                      | A Runtime fork of the running sandbox, or a new sandbox from the snapshot (by id, or by name among this sandbox's); `envs` are added over the source's.                                                                                                                                                                                                                                          |
-| `CodeInterpreter.create`, `runCode`, `createCodeContext`                              | Runtime's interpreter, with the same result classes. The sandbox's envs reach every context.                                                                                                                                                                                                                                                                                                     |
-| `sandbox.sessions.create`, `createIfExpired`, `list`, `get`, `delete`                 | A Runtime sandbox session: a token for commands, files and previews of this one sandbox, for a day unless `expiresAt` says sooner (a day at most). `responseHeaders["Access-Control-Allow-Origin"]` names the pages that may use it; `*`, other response headers and `requestHeaders` are refused. `createIfExpired` reuses the session this process made last; a token is shown only when made. |
-| `SandboxInstance.fromSession(session)`                                                | The sandbox, driven with the session's token alone; anything that manages the sandbox is refused.                                                                                                                                                                                                                                                                                                |
-| `ResponseError`, `SandboxGatewayError`, `isGatewayError`, `isGatewayTimeout`          | Runtime's errors by Blaxel's names: `status` and `code` are the HTTP status; `runtimeCode`, `hint` and `requestId` are Runtime's.                                                                                                                                                                                                                                                                |
+| Blaxel                                                                                                            | On Runtime                                                                                                                                                                                                                                                                                                                                                                                       |
+| ----------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `SandboxInstance.create({ name, image, memory, labels, ports, envs, ... })`                                       | `sandboxes.create`. A name another live sandbox holds is a 409, as in Blaxel; one held by a sandbox still being deleted is waited for.                                                                                                                                                                                                                                                           |
+| `createIfNotExists`                                                                                               | `create` with `getOrCreate`: Runtime settles two callers racing for one name, and both get the one sandbox. An existing sandbox is answered as it is.                                                                                                                                                                                                                                            |
+| `get(name)`, `getByExternalId`, `list({ limit, externalId, showTerminated })`                                     | The live sandbox with that name, or with the `externalId` label; Blaxel's paginated list (`data`, `nextPage`, `for await`, `autoPagingToArray`).                                                                                                                                                                                                                                                 |
+| `delete` (static and on the sandbox)                                                                              | `stop`: the sandbox ends at once. Using that object afterwards is a 404.                                                                                                                                                                                                                                                                                                                         |
+| `metadata`, `spec`, `status`, `state`, `lastUsedAt`, `expiresIn`                                                  | From the Runtime sandbox and its `blaxel/` labels (image, memory, ports, region, TTL, expiry, lifecycle, archived), which any client reads; `state` is `STANDBY` while paused.                                                                                                                                                                                                                   |
+| `updateMetadata`, `updateTtl`, `updateLifecycle`, `updateNetwork`                                                 | Labels (the display name and `externalId` are labels); the paused retention, as at create; network rules.                                                                                                                                                                                                                                                                                        |
+| `archive`, `unarchive`                                                                                            | `pause`, `wake`. Runtime keeps memory and processes too, and the next call wakes it.                                                                                                                                                                                                                                                                                                             |
+| `network: { allowedDomains, forbiddenDomains, proxy }`                                                            | Runtime network rules: `allow` and `deny`.                                                                                                                                                                                                                                                                                                                                                       |
+| `volumes: [{ name, mountPath }]`                                                                                  | The Runtime volume with that name, mounted read-write.                                                                                                                                                                                                                                                                                                                                           |
+| `fetch(port, path, init)`                                                                                         | The request goes to a private Runtime preview of the port (made on first use, then reused) with its token.                                                                                                                                                                                                                                                                                       |
+| `process.exec` without `waitForCompletion`                                                                        | One Runtime process, answered running. Its Blaxel name is kept in its command line, so `get("name")` finds it from any client.                                                                                                                                                                                                                                                                   |
+| `process.exec({ waitForCompletion: true })`                                                                       | One streamed call, answered with `status`, `exitCode`, `stdout`, `stderr` and `logs`. Past `timeout` the wait ends with a 422 and the process runs on.                                                                                                                                                                                                                                           |
+| `onLog`, `onStdout`, `onStderr`, `streamLogs`                                                                     | The process's output as it comes; `streamLogs` gives whole lines, as Blaxel's does.                                                                                                                                                                                                                                                                                                              |
+| `process.get`, `wait`, `list`, `logs`, `stop`, `kill`, `writeStdin`, `closeStdin`                                 | Runtime processes by id or name. `wait` follows output with one deadline covering lookup and output. Cancellation leaves the process running. `stop` is SIGTERM, `kill` SIGKILL.                                                                                                                                                                                                                 |
+| `keepAlive`, `timeout`                                                                                            | The sandbox does not pause for idleness while the process may run (its `timeout`, 600 s by default, 0 for as long as a lease allows); once no `keepAlive` process runs, it gets its idle pause back.                                                                                                                                                                                             |
+| `restartOnFailure`, `maxRestarts`, `waitForPorts`, `workingDir`, `env`, `stdin`                                   | A restart loop in the same process, with Blaxel's note in the output (`restartCount` counts the notes); a wait in the sandbox for the ports; as in Blaxel.                                                                                                                                                                                                                                       |
+| `fs.read`, `write`, `readBinary`, `writeBinary`, `writeTree`, `mkdir`, `rm`, `cp`                                 | Runtime's files API, or one command. A path only root may read or write (outside `/workspace`, or made by a root process) goes through sudo, as Blaxel's root-owned API could.                                                                                                                                                                                                                   |
+| `fs.ls`, `find`, `grep`, `search`                                                                                 | One command each, with Blaxel's defaults, limits and excluded directories. `ls` reports owners.                                                                                                                                                                                                                                                                                                  |
+| `fs.watch(path, callback, { withContent, ignore })`, `fs.download`                                                | A Runtime watch (`path/**` for subdirectories); a download to the local disk.                                                                                                                                                                                                                                                                                                                    |
+| `previews.create`, `createIfNotExists`, `get`, `list`, `delete`                                                   | Runtime previews of `spec.port`, public or private. The Blaxel name is kept in a label, so any client finds it by name. The shorthand `{ port, name?, public? }` is a private `preview-<port>` unless it says otherwise; `createIfNotExists` answers an existing one as it is.                                                                                                                   |
+| `preview.tokens.createIfExpired(expiresAt?, minValidity?)`                                                        | The token this call made last in this process for the sandbox's port, while it lasts `minValidity` more and ends by `expiresAt`; else a new one. Runtime keeps no list of tokens, so a new process makes a new one.                                                                                                                                                                              |
+| `isBlaxelError`, `getBlaxelErrorCode`, `getBlaxelErrorStatus`, `getBlaxelErrorMessage`, `getBlaxelErrorRequestId` | Blaxel's readers over the errors here. A `ResponseError`'s code is its HTTP status, as its `code` is; its request id is Runtime's.                                                                                                                                                                                                                                                               |
+| `settings.integration`, `initialize({ integration })`, `BL_INTEGRATION`                                           | Kept and checked as Blaxel does (`<name>/<semver>`, warned once and `""` otherwise); never sent, as Runtime does not attribute traffic by it.                                                                                                                                                                                                                                                    |
+| `preview.tokens.create(expiresAt)`                                                                                | A token for that long: at least a minute, at most a week. It is read from Blaxel's `X-Blaxel-Preview-Token` header or `?bl_preview_token=` as from Runtime's `x-runtime-preview-token` and `?runtime_preview_token=`, and never passed on to your server.                                                                                                                                        |
+| `snapshots.create`, `list`, `get`, `delete`; `Snapshot.create`, `get`, `list`, `fork`                             | Runtime snapshots, kept 365 days: files, memory and running processes.                                                                                                                                                                                                                                                                                                                           |
+| `fork(name)`, `fork(name, { snapshotId, envs })`                                                                  | A Runtime fork of the running sandbox, or a new sandbox from the snapshot (by id, or by name among this sandbox's); `envs` are added over the source's.                                                                                                                                                                                                                                          |
+| `CodeInterpreter.create`, `runCode`, `createCodeContext`                                                          | Runtime's interpreter, with the same result classes. The sandbox's envs reach every context.                                                                                                                                                                                                                                                                                                     |
+| `sandbox.sessions.create`, `createIfExpired`, `list`, `get`, `delete`                                             | A Runtime sandbox session: a token for commands, files and previews of this one sandbox, for a day unless `expiresAt` says sooner (a day at most). `responseHeaders["Access-Control-Allow-Origin"]` names the pages that may use it; `*`, other response headers and `requestHeaders` are refused. `createIfExpired` reuses the session this process made last; a token is shown only when made. |
+| `SandboxInstance.fromSession(session)`                                                                            | The sandbox, driven with the session's token alone; anything that manages the sandbox is refused.                                                                                                                                                                                                                                                                                                |
+| `ResponseError`, `SandboxGatewayError`, `isGatewayError`, `isGatewayTimeout`                                      | Runtime's errors by Blaxel's names: `status` and `code` are the HTTP status; `runtimeCode`, `hint` and `requestId` are Runtime's.                                                                                                                                                                                                                                                                |
 
 ## Gaps
 
@@ -184,6 +190,65 @@ Some differences are not refusals:
 - A preview token shorter than a minute lasts a minute. Deleting one token
   revokes every token of that preview.
 
+## 0.3.30 and 0.4.18, 16 October 2026
+
+Reviewed the published npm tarball of `@blaxel/core` 0.3.29 → 0.3.30 and the
+PyPI wheel and sdist of `blaxel` 0.4.17 → 0.4.18, each its registry's latest
+when checked. The pinned files matched `compatibility-lock.json`, the new ones
+their registry's SHA-512 integrity or SHA-256 digest, and the wheel's source is
+byte for byte its sdist's. They were compared file by file; nothing was
+installed or run outside the oracle. The npm package's dependencies did not
+change.
+
+| Upstream change                                                                                                                                                                                                                                                                                               | Drop-in disposition                                                                                                                                                                                                                                                                                                                       |
+| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Workspace secrets, which Blaxel's proxy puts into a sandbox's routing as `{{SECRET:name}}`: the generated API calls `listSecrets`, `upsertSecret`, `deleteSecret`, `deleteSecretByQuery`; Python `SecretInstance`, `SyncSecretInstance` (`set`, `list`, `delete`), `SecretAPIError` and `blaxel.core.secret`. | Importable and refused with `NotSupportedError` naming Runtime secrets, `runtime.secrets.set(name, { value, hosts })`: a Runtime secret names the hosts it may reach, which Blaxel's calls do not, and the drop-in already refuses Blaxel's proxy routing. `SecretAPIError` is a `BlaxelError`, never raised. Before, the imports failed. |
+| `deleteDriveFolder` in the generated API.                                                                                                                                                                                                                                                                     | Importable and refused, as every drive call is.                                                                                                                                                                                                                                                                                           |
+| The SDK sends an "Installed SDK" event to PostHog once per version (internal `common/posthog`, not exported).                                                                                                                                                                                                 | Nothing to follow: the drop-in sends nothing to Blaxel or its analytics.                                                                                                                                                                                                                                                                  |
+| Custom domains' `validationMethod`, the `kernelExtensions` extra argument, and doc text (the 60 s floor of `ttl-idle`).                                                                                                                                                                                       | Nothing new to do: custom domains are refused, an extra argument other than `iptables` is refused, and the drop-in has no `ttl-idle` floor (a paused sandbox is kept whole days).                                                                                                                                                         |
+
+`tests/blaxel/blaxel-0-3-30.test.ts` (2) and
+`sdks/python/tests/test_blaxel_0_4_18.py` (2) fail without this change; the
+export list moves to 0.3.30's 275 names. `compat-inventory.json`: blaxel 611
+present, 123 refused, 31 missing of 765 before; 616, 123, 31 of 770 now.
+blaxel-python 375, 11, 652 of 1038 before; 388, 11, 672 of 1071 now (the
+inventory counts the Python stand-ins, as `ImageInstance` before them, as
+missing).
+
+## 0.3.29 and 0.4.17, 15 October 2026
+
+Reviewed the published npm tarball of `@blaxel/core` 0.3.25 → 0.3.29 and the
+PyPI wheel and sdist of `blaxel` 0.4.13 → 0.4.17 (0.3.26 to 0.3.28 and 0.4.14
+to 0.4.16 came out between, all on 13 October). Each was its registry's latest
+when checked. The pinned files matched the hashes already in
+`compatibility-lock.json`, the new ones their registry's SHA-512 integrity or
+SHA-256 digest, and each wheel's Python source is byte for byte its sdist's.
+They were compared file by file; nothing was installed or run outside the
+oracle, which runs 0.3.29 and passes. The npm package's dependencies did not
+change. Python's `withruntime.blaxel` follows the same changes under Python's
+names: `BlaxelError`, `is_blaxel_error(err, code=None)`,
+`SandboxPreviewCreateConfiguration`, `create_if_expired(expires_at=None,
+min_validity=timedelta(hours=1))`, `settings.integration`.
+
+| Upstream change                                                                                                                                                                                                                                                                                                                           | Drop-in disposition                                                                                                                                                                                                                                                                                                                                                                         |
+| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Error helpers `isBlaxelError`, `getBlaxelErrorCode`, `getBlaxelErrorStatus`, `getBlaxelErrorMessage`, `getBlaxelErrorRequestId` and the error code and body types. Python: `BlaxelError` becomes the base of `ResponseError` and every `*APIError`, with `status`, `code`, `request_id`, `retryable` and the rest, and `is_blaxel_error`. | Followed. The helpers read the drop-in's errors with Blaxel's rules; a request id with no Blaxel header is Runtime's. In Python every API error the drop-in raises is a `BlaxelError`: `status` is the HTTP status, `code` Runtime's code, `request_id` Runtime's, `retryable` Runtime's own judgement; Blaxel's gateway fields are None. `VolumeAPIError` and `blaxel.core.errors` import. |
+| `previews.create` and `createIfNotExists` take `{ port, name?, public? }` (Python: a dict or `SandboxPreviewCreateConfiguration`): a private `preview-<port>` by default, checked with `RangeError` (Python `ValueError`); an existing preview is answered as it is.                                                                      | Followed, with Blaxel's checks and messages, before anything is shared. Before, the shorthand failed (`spec.port is required`, or a TypeError in `createIfNotExists`).                                                                                                                                                                                                                      |
+| `preview.tokens.createIfExpired(expiresAt?, minValidity?)` reuses the latest listed token that lasts `minValidity` (an hour) more and ends by `expiresAt` (a day), else makes one; a public preview is refused.                                                                                                                           | Followed. Runtime keeps no list of the tokens it signs, so the token reused is the one this call made last in this process for the sandbox's port; arguments and the public refusal are Blaxel's, checked before any request. Revoking the preview's tokens (`tokens.delete`) forgets it.                                                                                                   |
+| `SandboxPreview.url`, `SandboxPreviewToken.name`.                                                                                                                                                                                                                                                                                         | Followed.                                                                                                                                                                                                                                                                                                                                                                                   |
+| `settings.integration`, `Config.integration` and `BL_INTEGRATION`: a `<name>/<semver>` token appended to Blaxel's User-Agent.                                                                                                                                                                                                             | Kept and checked as Blaxel does, warned once when invalid, never sent: it only attributes traffic to Blaxel. Before, `settings.integration` threw `NotSupportedError`. Python's `settings.user_agent` and other settings still raise `NotSupportedError`.                                                                                                                                   |
+| `fs.search` now sends its query (it was dropped).                                                                                                                                                                                                                                                                                         | Nothing to do: the drop-in's search always used it.                                                                                                                                                                                                                                                                                                                                         |
+| `ImageInstance` takes `buildMemory`, `buildVolume`, `buildRegion`; generated API clients gain `headFilesystemByPath`, service-account `role`, and doc text; Python's resource errors keep the response.                                                                                                                                   | Nothing to follow: `ImageInstance` and the generated API calls stay refused with Runtime's alternative (`runtime.images`, `SandboxInstance`). Python's `ResponseError.from_api_response`, which wraps a generated-client response, now raises `NotSupportedError` saying so.                                                                                                                |
+
+`tests/blaxel/blaxel-0-3-29.test.ts` (9) and
+`sdks/python/tests/test_blaxel_0_4_17.py` (9) fail without this change. The
+export list moves to 0.3.29's 270 names. `compat-inventory.json`, regenerated
+from the verified packages: blaxel 596 present, 123 refused, 31 missing before
+(of 750); 611, 123, 31 now (of 765). blaxel-python 252, 9, 642 before (of
+903, 0.4.13 exported fewer names from `blaxel.core`); 375, 11, 652 now (of
+1038). The pinned-official Python tests (`RUNTIME_COMPAT_OFFICIAL=1`) were not
+run against 0.4.17.
+
 ## The process line
 
 A process's command line, which both this package and the Python one write
@@ -207,7 +272,7 @@ leaves those names alone.
 
 `bun run test` in `packages/cloud-sdk` runs the unit tests against a fake of
 Runtime's SDK: `tests/blaxel`, including a check that every name
-`@blaxel/core` 0.3.24 exports is exported here.
+`@blaxel/core` 0.3.30 exports is exported here.
 
 The end-to-end test runs Blaxel's guides, unmodified but for the import,
 against the real API: `tests/fixtures/blaxel-quickstart.mjs` (create, processes,

package/COMPATIBILITY.md

@@ -14,19 +14,134 @@ interface for it. Python coverage is in the Python SDK's compatibility documents
 The Cloudflare module implements the 0.x `@cloudflare/sandbox` API. Version 1.0.0,
 published 30 September 2026, is a different package: it removes `getSandbox`, the
 `Sandbox` class, `exec`, processes, sessions and preview proxying, and keeps only
-`Files`, `S3Mount` and `DirectoryBackup` for the caller's own Durable Object. The
-pin stays 0.12.10; `compatibility-lock.json` records 1.0.0 as reviewed and
-unsupported, and `bun run compat:upstream` flags any other release.
+`Files`, `S3Mount` and `DirectoryBackup` for the caller's own Durable Object.
+Version 1.0.1 (13 October 2026) is the same API: its `dist/index.mjs` is byte for
+byte 1.0.0's, its declarations export the same names inline instead of in one
+list, its `zod` dependency moves from 4.5.4 to 4.6.5, and README example links
+change. The pin stays 0.12.10; `compatibility-lock.json` records 1.0.0 and 1.0.1
+as reviewed and unsupported, and `bun run compat:upstream` flags any other release.
 
 | Provider    | Published package inspected             | Runtime import            | Implemented sandbox surface                                                                                                                                                                                                                                                                                                                                                                                              |
 | ----------- | --------------------------------------- | ------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
 | Runloop     | `@runloop/api-client` 2.0.0             | `withruntime/runloop`     | `Runloop`, basic `RunloopSDK` command handles, devbox create/get/list/suspend/resume/shutdown, disk snapshots; synchronous and asynchronous commands, resident named shells with variables, functions, aliases, options and working directory, execution completion/output/stdin/signals, text files                                                                                                                     |
 | CodeSandbox | `@codesandbox/sdk` 2.4.2                | `withruntime/codesandbox` | `CodeSandbox`, `VMTier`, create/fork/resume/shutdown/restart/hibernate/delete/list/get; connected command and file clients; output/status subscriptions and same-client command restart; configured tasks and setup steps; public preview ports and readiness checks                                                                                                                                                     |
 | Fly Sprites | `@fly/sprites` 0.2.3                    | `withruntime/sprites`     | `SpritesClient`, create/lookup/list/delete/restart; `exec`, `execFile`, Node streams and event-based `spawn`; attachable native processes; binary/text/JSON files, directory traversal, append, chmod, chown and `asRoot` through sudo, file watches; preview access settings; checkpoints as disk snapshots; domain network policy; session kill; port watcher and port proxy; `APIError` with the vendor's limit codes |
-| Freestyle   | `freestyle` 0.2.17                      | `withruntime/freestyle`   | `Freestyle`, VM create/ref/get/list/start/pause/delete/update; command execution, binary/text files and streams, filesystem metadata; native snapshots; explicit deny-all or outbound-public firewall intent                                                                                                                                                                                                             |
-| Modal       | `modal` 0.11.0                          | `withruntime/modal`       | `ModalClient`, app-name grouping, registry images and Dockerfile layers, CPU sandbox create/get/list/name lookup, text/binary process streams and stdin, command completion, filesystem transfer and metadata, tags, encrypted public previews, outbound allowlists, memory snapshot capture                                                                                                                             |
+| Freestyle   | `freestyle` 0.2.20                      | `withruntime/freestyle`   | `Freestyle`, VM create/ref/get/list/start/pause/delete/update; command execution, binary/text files and streams, filesystem metadata; native snapshots; explicit deny-all or outbound-public firewall intent                                                                                                                                                                                                             |
+| Morph       | `morphcloud` 0.0.20                     | `withruntime/morph`       | `MorphCloudClient`, images list, snapshot create/get/list/delete/metadata and cached `setup` chains, instance start/boot/get/list/stop/pause/resume/branch/snapshot, metadata, wake-on, TTL at start, streamed exec, HTTP services as previews, file `sync`                                                                                                                                                              |
+| Modal       | `modal` 0.11.1                          | `withruntime/modal`       | `ModalClient`, app-name grouping, registry images and Dockerfile layers, CPU sandbox create/get/list/name lookup, text/binary process streams and stdin, command completion, filesystem transfer and metadata, tags, encrypted public previews, outbound allowlists, memory snapshot capture                                                                                                                             |
 | Cloudflare  | `@cloudflare/sandbox` 0.12.10 (0.x API) | `withruntime/cloudflare`  | `getSandbox`, named Runtime sandboxes, explicit execution sessions, text exec and SSE output, background processes, logs/signals/waits, binary/text files, recursive listings, environment updates, signed Runtime previews, conditional Worker Durable Object entry, Worker preview proxy, destruction                                                                                                                  |
 
+### Modal 0.11.1 review (16 October 2026)
+
+The pin advances from 0.11.0 to 0.11.1; support remains partial. Both npm
+tarballs were fetched into an empty directory, matched the lock (0.11.0) and
+the registry (0.11.1), and were compared file by file without installing or
+executing them. Only `package.json`, `README.md` and the four `dist` files
+change; most of the declaration diff is generated protobuf types. The public
+changes, and what `withruntime/modal` does with each:
+
+- `sandboxes.fromName` and `experimentalFromName` take `includeTerminated`:
+  when no sandbox of that name runs, the most recent terminated one is
+  returned. Followed: a running sandbox of the name still wins, otherwise the
+  stopped one with the latest end time. Before, the option was refused as
+  unknown.
+- `client.environments` (`EnvironmentService`, `EnvironmentObjectsService`,
+  `Environment`, `EnvironmentAppsService`) looks up, creates, lists and
+  deletes Modal Environments. Refused before any request, as the
+  `environment` options already are: a Runtime account's sandboxes share one
+  namespace, grouped by app name and tags.
+- `App.info()` returns an App's lifecycle and its Functions and Servers.
+  Refused, naming `client.sandboxes.list({ appId })`: a Runtime app is a label
+  on its sandboxes, with no lifecycle, Functions or Servers.
+- `volumes.fromName` takes a VolumeFS `version` (1 or 2). Refused when given:
+  a Runtime volume has one format.
+- Sidecars take `includeOidcIdentityToken` and `proxy`; sidecars were already
+  refused as a whole. `functions.fromId`, `Function_.stats()`,
+  `Function_.metrics` (`FunctionMetricsManager`) and the deprecation of
+  `FunctionTimeoutError` for `FunctionCall.get` timeouts are Functions, outside
+  the CPU sandbox scope (`FunctionMetricsManager` joins the inventory's
+  outside list). Not followed, with nothing to follow: an internal `keys`
+  argument leaves `Secret`'s constructor, `execWait` and `Sandbox._wait` take
+  an internal abort signal, `smol-toml` moves from ^1.3.3 to ^1.9.0, and the
+  README links a sidecar identity-token example.
+
+`tests/compat/modal-0-11-1.test.ts` fails on the old adapter;
+`compat-inventory.json` records 221 present, 168 refused and 0 missing of 389.
+`tests/compat/reference.bun.lock` records the new `smol-toml` range; it
+already resolved 1.9.0, so the opt-in reference install is unchanged (not
+rerun here).
+
+### Morph 0.0.20 (15 October 2026)
+
+`morphcloud` 0.0.20 (npm, 6 October 2025, the latest) is the TypeScript SDK;
+all 73 inventory items are present or refused, none missing. How it maps:
+
+- An instance is a sandbox; a snapshot is a Runtime snapshot; metadata are
+  labels (`compat.provider` and `morph.*` stay the adapter's). `stop` deletes
+  the sandbox, as Morph's stop deletes the instance; snapshots stay.
+- `snapshots.create` boots the image at its size, keeps its disk and deletes
+  the sandbox. `morphvm-minimal` is Runtime's default image; another id must
+  be a Runtime image. A digest becomes the snapshot's name (`morph-` and its
+  SHA-256), so `setup` caches by Morph's chain hash.
+- `branch(n)` is one fork with the snapshot kept: copies keep memory and
+  running processes.
+- `ttlSeconds` is the time limit (60 to 86400); `ttlAction` stop deletes,
+  pause pauses. Runtime also pauses an idle sandbox after a minute and wakes
+  it on the next request, which Morph does not.
+- `exposeHttpService` is a preview: public with no `auth_mode` (needs a kept
+  top-up), private with `api_key` (send its token as `x-runtime-preview-token`).
+- `exec` of a string or one-item array runs in a shell, a longer array as
+  arguments; 24 hours by default; a timeout throws as Morph's does.
+- Refused, naming the alternative: `ssh`, `sshKey`, `sshKeyRotate` (use
+  `runtime sandboxes ssh`), `reboot`, `setTTL` after start, `sync` with
+  delete/dry run/.gitignore, and the raw `GET`/`POST`/`DELETE` verbs.
+- `bun scripts/compatibility-morph-live.ts --run` runs the quickstart, setup
+  cache, HTTP service, pause and resume, branch and snapshot calls against the
+  real API.
+- Morph's richer Python SDK (`morphcloud` 0.1.115, PyPI) has its own adapter,
+  `withruntime.morph`, inventoried as `morph-python`; see
+  [the Python document](../../sdks/python/COMPATIBILITY.md).
+
+### Freestyle 0.2.18, 0.2.19 and 0.2.20 review (15 October 2026)
+
+The pin advances from 0.2.17 to 0.2.20; support remains partial. The four npm
+tarballs were fetched into an empty directory, matched the lock (0.2.17) and
+the registry (the rest), and were compared file by file without installing or
+executing them.
+
+- 0.2.18, PTY connections. `open` and `attach` take `reconnect` (`true` or
+  `timeoutMs`, `initialDelayMs`, `maxDelayMs`), `connectTimeoutMs`,
+  `onStateChange`, `onReplayStart` and `onReplayEnd`, and check the timers
+  with a `RangeError`; `PtySession` gains `ready`, `state` and `reconnect()`;
+  `write` and `signal` throw `PTY is not connected` while disconnected and
+  `resize` is remembered and applied again after a reattachment; `detach`
+  cancels recovery and reports `Detached` once. Before, the adapter refused
+  each new option with `CompatibilityError`. Now a dropped connection is
+  reattached to the same Runtime process with Freestyle's backoff, after
+  checking the process still exists (a 4xx other than 409 or 429 ends the
+  session), and nothing typed is replayed. A Runtime terminal replays the
+  session's output from its start on each connection without marking where
+  the replay ends, as Freestyle's older guest agents do, so the replay
+  callbacks never fire and a replay begins at the `connected` state. Runtime
+  terminals send no keepalive, so a silent connection is not timed out; the
+  browser's online and visibility events retry a closed session. A first
+  connection waits `connectTimeoutMs` only when given (no wait limit before).
+- 0.2.18, new `connectXterm({ pty, terminal, slug, ... })` and the
+  `XtermTerminal` and `ConnectXtermOptions` types: implemented on the same
+  sessions, with reconnect on by default, the screen reset at each
+  connection, and the replay's terminal queries muted until it is written.
+- 0.2.18, browser PTYs now need an identity access token (a WebSocket
+  subprotocol). Identity tokens are refused here; Runtime terminals
+  authenticate with the Runtime key. `@xterm/xterm` is a new dev dependency
+  only, so the reference install is unchanged.
+- 0.2.18, `PtySessionInfo.slug` is now documented as kept after the shell
+  exits, until the session is closed (`open`'s get-or-create doc already
+  said so). Not followed: Runtime keeps exited processes and cannot remove
+  one, so a slug kept after exit could never be opened afresh. A slug is
+  still released when its shell exits.
+- 0.2.19 changes only its version. 0.2.20 adds `expiresAt` to identity access
+  tokens, in the identities product this adapter does not provide.
+
 ### Freestyle 0.2.17 review (11 October 2026)
 
 The pin advances from 0.2.16; support remains partial. The exact npm tarballs

package/DAYTONA.md

@@ -17,8 +17,8 @@ from withruntime.daytona import AsyncDaytona  # was: from daytona import AsyncDa
 ```
 
 The mapping was written against `@daytona/sdk` 0.220.0 and `daytona` 0.220.0
-on PyPI, and checked against `@daytona/sdk` and `daytona` 0.223.1 on
-9 October 2026 (below, "0.223.1"). The exact releases and artifact hashes
+on PyPI, and checked against `@daytona/sdk` and `daytona` 0.224.1 on
+15 October 2026 (below, "0.224.1"). The exact releases and artifact hashes
 are kept in `compatibility-lock.json`.
 
 ## Keys
@@ -97,7 +97,7 @@ Each of these throws `NotSupportedError` before anything happens. Its
 | --------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | A snapshot name with no Runtime image or snapshot                     | `daytona.snapshot.create({ name, image })` here, or `npx withruntime images build`. This throws `DaytonaNotFoundError`.                                                                 |
 | GPUs, `spot`, `linkedSandbox`, `secrets`, `otelEndpointOverride`      | Runtime runs Linux on CPUs. For `secrets`, a Runtime secret (`npx withruntime secrets set NAME --host <host>`): the sandbox sees a placeholder. For telemetry, `runtime.otel.create()`. |
-| A `target` other than `us`, `jwtToken`                                | Runtime runs in one US region and signs in with keys.                                                                                                                                   |
+| A `target` other than `us` (the client's or a create's), `jwtToken`   | Runtime runs in one US region and signs in with keys.                                                                                                                                   |
 | The entrypoint session, language servers                              | Sessions with `runAsync`.                                                                                                                                                               |
 | Screenshots of a region, with the cursor, scaled, or as WebP          | The whole screen as PNG or JPEG; crop and scale it yourself.                                                                                                                            |
 | `computerUse.accessibility`, the desktop's processes one by one       | Screenshots with the mouse and keyboard; `computerUse.getStatus()`, `stop()` and `start()`.                                                                                             |
@@ -126,6 +126,37 @@ Some differences are not refusals:
 - `autoArchiveInterval` is recorded only: Runtime has no archive tier.
 - Runtime's stock image is Ubuntu 24.04 with Python 3.12, Node.js 24 and Bun.
 
+## 0.224.1, 15 October 2026
+
+Reviewed the published npm tarballs for `@daytona/sdk`, `@daytona/api-client`,
+`@daytona/toolbox-api-client` and `@daytona/analytics-api-client` 0.223.1 →
+0.224.1, and the PyPI wheel and sdist for `daytona` 0.223.1 → 0.224.1 (0.224.0,
+published between them, was also fetched: on npm, 0.224.1 adds only the stream
+decoder change and the dependency floors below; on PyPI it is the same source
+with a new version). Each was its registry's latest when checked. Every pinned
+file matched the hash already in `compatibility-lock.json`, and every new file
+matched its registry's SHA-512 integrity or SHA-256 digest; the wheel's Python
+source is byte for byte its sdist's. Nothing was installed, imported or run.
+The three API clients changed only their version. `@daytona/sdk` changed
+`Daytona` (create params and the client's `target` docs), `Snapshot` (docs),
+and its output stream decoder, ESM and CommonJS alike; `daytona` changed the
+same, sync and async, plus the async PTY handle.
+
+| Upstream change                                                                                                                                                                      | Drop-in disposition                                                                                                                                                                                                                                                                 |
+| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `daytona.create({ target })` (Python `target` on `CreateSandboxFromSnapshotParams` and `CreateSandboxFromImageParams`) picks the region for that create, over the client's `target`. | Followed, in both languages. `"us"` or none creates the sandbox in Runtime's one region; any other is refused with the same `NotSupportedError` as a client `target`, before anything is built or made. Before, TypeScript dropped it without a word and Python raised `TypeError`. |
+| The client's `target` (and `DAYTONA_TARGET`) and a snapshot's `regionId` (Python `region_id`) are documented as the default region, overridden per call.                             | Documentation only; the client's `target` is checked as before. TypeScript already refused a snapshot `regionId`; Python accepted `region_id` and dropped it, and now refuses it the same way (`""` still means the default).                                                       |
+| The output stream decoder finds an stdout or stderr marker that ends exactly at the end of a message, which it held back before, and buffers in linear time.                         | Not applicable: the drop-in takes output from Runtime's exec, which keeps stdout and stderr apart, and never parses Daytona's markers.                                                                                                                                              |
+| Python `AsyncPtyHandle.wait()` shields its reader, so cancelling a caller's wait (for example `asyncio.wait_for`) leaves the PTY connected.                                          | Already so: the drop-in's `wait()` awaits `asyncio.shield` of its reader task.                                                                                                                                                                                                      |
+| `@daytona/sdk` requires `ws` exactly 8.22.0 (was ^8.22.0), `@aws-sdk/client-s3` and `lib-storage` ^3.1146.0 and `shell-quote` ^1.12.0.                                               | The oracle's `bun.lock` moves with them (ws stays 8.22.0).                                                                                                                                                                                                                          |
+
+`tests/daytona/daytona-0-224-1.test.ts` and
+`sdks/python/tests/test_daytona_0_224_1.py` check a create's `target` both
+ways, that it overrides the client's, and (Python) that a snapshot's
+`region_id` is refused; they fail without this change. The oracle was not run
+against the new release, since it executes Daytona's code; the provider
+remains marked `partial`.
+
 ## 0.223.1, 9 October 2026
 
 Reviewed the published npm tarballs for `@daytona/sdk`, `@daytona/api-client`,

package/E2B.md

@@ -20,9 +20,9 @@ from withruntime.e2b import Sandbox  # was: from e2b import Sandbox
 from withruntime.e2b.code_interpreter import Sandbox  # was: from e2b_code_interpreter import Sandbox
 ```
 
-The mapping was written against `e2b` 2.51.0 and checked against `e2b` 2.55.0
-and `@e2b/code-interpreter` 2.8.3 on 9 October 2026. Python was checked
-against `e2b` 2.55.1 and `e2b-code-interpreter` 2.10.5 the same day. The exact
+The mapping was written against `e2b` 2.51.0 and checked against `e2b` 2.56.0
+and `@e2b/code-interpreter` 2.9.0 on 15 October 2026. Python was checked
+against `e2b` 2.56.0 and `e2b-code-interpreter` 2.11.0 the same day. The exact
 package releases and artifact hashes are kept in `compatibility-lock.json`.
 
 ## Keys
@@ -111,7 +111,7 @@ account the key belongs to and where the key came from.
 | Relative paths                                                                           | Resolved against the home directory, `/workspace` on Runtime, and given back under `/home/user`, as E2B gives them: `write("a.txt")` returns `/home/user/a.txt`. A path given in full comes back as given. `pwd` in a command prints `/workspace`.                                                                                                                                                                                                                                                                                                                                                      |
 | `/home/user` (E2B's home)                                                                | The first time a path, `cwd` or command names it, it becomes a link to `/workspace`, unless something is already there.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
 | `sandbox.kill()`, `Sandbox.kill(id)`                                                     | `delete`: gone for good. `false` when the sandbox was not found or was already deleted.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
-| `sandbox.setTimeout(ms)`, `Sandbox.setTimeout(id, ms)`                                   | `extend`: the end moves to now + ms, up to 24 hours. An earlier end is refused: Runtime cannot bring a time limit forward. A sandbox with no time limit (a pilot's) has no end to move, and nothing changes.                                                                                                                                                                                                                                                                                                                                                                                            |
+| `sandbox.setTimeout(ms)`, `Sandbox.setTimeout(id, ms)`                                   | The sandbox's time limit becomes now + ms, sooner or later than before, up to 24 hours (an update's `timeoutSeconds`; under a minute is a minute), and its end still does what it was created to. A sandbox with no time limit gets one; a persistent one (a pilot's) has none to set, and nothing changes.                                                                                                                                                                                                                                                                                             |
 | `Sandbox.connect(id, { timeoutMs })`, `sandbox.connect()`                                | `get`. A paused sandbox is woken. A running one's end moves later, never earlier, up to 24 hours. An ended one throws `SandboxNotFoundError`.                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
 | `sandbox.pause()`, `betaPause`, `Sandbox.pause(id)`                                      | `pause`, keeping memory and files. `false` when it was already paused.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
 | `getInfo`, `isRunning`                                                                   | `get`. `templateId` is the template the sandbox was created from, as you named it (kept in the label `e2b-template`, which `metadata` leaves out), or `base`. `envdVersion` is `runtime`. A sandbox Runtime paused for being idle is `running`. `endAt` is when it ends by itself; one that never will (no time limit, as a pilot's) reads 24 hours ahead, the furthest E2B allows.                                                                                                                                                                                                                     |
@@ -134,7 +134,6 @@ before anything happens. The error's `feature` names the gap and its
 | ------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------- |
 | An E2B template name with no Runtime image of that name       | Build it: `npx withruntime images build --dockerfile e2b.Dockerfile --name <template>`. This throws `TemplateError`. |
 | `Template`, `waitForPort` and the other ready checks          | `runtime.images.build(...)`                                                                                          |
-| `setTimeout` to an earlier time                               | `kill()` when the work is done.                                                                                      |
 | A pause with `mode: "filesystem"` or `keepMemory: false`      | Runtime's pause keeps memory. For the files alone, `createSnapshot({ mode: "filesystem" })`.                         |
 | `onResume: "reboot"`                                          | Stop the sandbox and create a new one.                                                                               |
 | `fork({ timeoutMs })`                                         | Fork without it, then call `setTimeout` on each fork.                                                                |
@@ -260,3 +259,33 @@ source files changed, one was removed, and one interpreter file changed.
 modes, the refusals, their messages and the new exports; they fail without
 this change. The official differential contracts were not run against the new
 releases, since they execute E2B's code; the provider remains marked `partial`.
+
+## e2b 2.56.0, 15 October 2026
+
+Reviewed the published npm tarballs for `e2b` 2.55.0 → 2.56.0 and
+`@e2b/code-interpreter` 2.8.3 → 2.9.0, and the PyPI wheels and sdists for
+`e2b` 2.55.1 → 2.56.0 and `e2b-code-interpreter` 2.10.5 → 2.11.0. Each was
+npm's or PyPI's latest when checked. Every pinned file matched the hash already
+in `compatibility-lock.json`, and every new file matched its registry's SHA-512
+integrity or SHA-256 digest; each wheel's Python source is byte for byte its
+sdist's. Nothing was installed, imported or run for the review. JavaScript
+sources were read from the source maps. The declarations (`index.d.ts`) of
+both npm packages and the `__init__.py` of both Python packages are byte for
+byte unchanged, so the public surface is the same: the recomputed
+`compat-inventory.json` has the same items, only the upstream paths move.
+
+| Upstream change                                                                                                                                                                                                                                                                            | Drop-in disposition                                                                                                                                                                                                                                                                 |
+| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| JavaScript: the process-wide in-flight request caps are removed (`src/api/inflight.ts` and the `E2B_API_INFLIGHT_REQUESTS`, `E2B_ENVD_INFLIGHT_REQUESTS`, `E2B_ENVD_RPC_INFLIGHT_REQUESTS` variables, which threw on a negative value). Requests are bounded by undici's connections only. | No change: the drop-in never read these variables. Its own connection cap (`E2B_MAX_CONNECTIONS` in `src/e2b/client.ts`, 4096) is Runtime's and unchanged.                                                                                                                          |
+| JavaScript: `undici` 8.11.2 becomes the only undici (the `undici8` alias and the undici 7 fallback are gone); below Node 22.19 the global `fetch` is used. `engines.node` is now `>=22.19.0`, `@e2b/dockerfile-utils` `^0.1.1` (0.1.1 changes only its own version and engines).           | Not mirrored: the drop-in uses Runtime's transport and keeps `node >=22.12`. The oracle lock moves to `e2b` 2.56.0 with `undici` 8.11.2 and `@e2b/dockerfile-utils` 0.1.1.                                                                                                          |
+| Python: the per-origin `ConnectionBalancer` over several pyqwest pools is replaced by one pool with `max_connections_per_address` (pyqwest `>=0.12,<0.13`); `E2B_STREAMS_PER_CONNECTION` is no longer read, and `E2B_MAX_CONNECTIONS` caps connections per resolved address.               | No change: `e2b.api` and its clients are E2B's HTTP internals, which the drop-in leaves out; its connection limit is Runtime's own.                                                                                                                                                 |
+| Python: `e2b` and `e2b-code-interpreter` require Python 3.11 (`sandbox/mcp.py` imports `NotRequired` from `typing`).                                                                                                                                                                       | Not followed: `withruntime` keeps Python 3.10, so code moved off E2B on 3.10 keeps working. The official contracts install the new wheels, so that step runs on Python 3.11 (`prepare_compatibility.py` moves to a Python 3.11 or newer on the PATH when run under 3.10, as in CI). |
+| `@e2b/code-interpreter` 2.9.0 and `e2b-code-interpreter` 2.11.0 change only their versions, dependency floors (`e2b ^2.56.0`) and engines.                                                                                                                                                 | Note only.                                                                                                                                                                                                                                                                          |
+
+No behaviour changed that the drop-ins mirror, so there is no new behaviour
+test; `tests/e2b/exports.test.ts` and `sdks/python/tests/test_e2b_exports.py`
+now name the new releases, whose export lists are the same. The oracle
+(`oracle/check.mjs`, 37 passed) ran against `e2b` 2.56.0 and
+`@e2b/code-interpreter` 2.9.0, and the Python official contracts (18 passed)
+against the new wheels in an isolated virtualenv on Python 3.11 and 3.12. The
+provider remains marked `partial`.

package/README.md

@@ -147,6 +147,21 @@ with its token. A Blaxel key is never sent anywhere. Drives, codegen, schedules
 `NotSupportedError` before anything happens, naming what to use instead.
 `BLAXEL.md` in this package lists every mapping and gap.
 
+## Code written for Morph Cloud
+
+`withruntime/morph` translates Morph's TypeScript client (`morphcloud`).
+Change the import:
+
+```ts no-run
+import { MorphCloudClient } from "withruntime/morph"; // was: from "morphcloud"
+```
+
+Instances become sandboxes, snapshots Runtime snapshots, metadata labels and
+HTTP services previews; `setup` caches by Morph's chain hash and `branch`
+copies memory and processes. `stop` deletes the sandbox, as Morph's does.
+SSH, reboot and a time limit set after start throw `CompatibilityError`
+naming the alternative. `COMPATIBILITY.md` lists every mapping.
+
 ## Agent frameworks
 
 `withruntime/openai-agents` is a sandbox client for the OpenAI Agents SDK's
@@ -183,6 +198,24 @@ connected yet, it offers `runtime_connect`, which walks you through the browser
 approval. Remote clients add `https://api.withruntime.com/mcp` and sign in through
 the browser, or send a bearer key.
 
+## How Runtime compares
+
+For typical agent work, Runtime costs 42% to 88% less than fourteen other
+sandbox providers at their published rates. These pages show the arithmetic,
+each with the rates it used and the date they were read:
+
+- [Best sandbox for AI agents](https://withruntime.com/compare/best-sandbox-for-ai-agents)
+- Alternatives to [E2B](https://withruntime.com/compare/e2b-alternatives),
+  [Daytona](https://withruntime.com/compare/daytona-alternatives),
+  [Modal](https://withruntime.com/compare/modal-alternatives) and
+  [Vercel Sandbox](https://withruntime.com/compare/vercel-sandbox-alternatives)
+- [E2B vs Daytona](https://withruntime.com/compare/e2b-vs-daytona), and
+  [every comparison](https://withruntime.com/compare)
+- [The agent sandbox price index](https://withruntime.com/pricing/agent-sandbox-price-index):
+  every provider's rates, also as CSV and JSON
+- [Sandbox cost calculator](https://withruntime.com/calculators/sandbox-cost-calculator)
+  and [Runtime's pricing](https://withruntime.com/pricing)
+
 ## Reliability and support
 
 - **Status:** https://withruntime.com/status checks the API from outside every