diff --git a/.agent/specs/rivetkit-core-wasm-support.md b/.agent/specs/rivetkit-core-wasm-support.md
new file mode 100644
index 0000000000..be416d2967
--- /dev/null
+++ b/.agent/specs/rivetkit-core-wasm-support.md
@@ -0,0 +1,661 @@
+# RivetKit Core WebAssembly Support Proposal
+
+## Goal
+
+Support a WebAssembly build of RivetKit core while keeping the existing native NAPI/runtime behavior intact. This splits into:
+
+- Phase 1: add remote SQLite SQL execution for runtimes that cannot load native SQLite.
+- Phase 2: make `rivetkit-core` and the Rust envoy client compile and run behind WebAssembly-compatible runtime and WebSocket interfaces.
+
+This proposal is intentionally gate-oriented: implementation should not start until the parity, rollout, and failure-mode criteria below are accepted.
+
+## Implemented Invariants
+
+- Remote SQL is an envoy protocol v4-only capability. Older protocol targets reject remote SQL request and response serialization with `ProtocolCompatibilityError { feature: RemoteSqliteExecution, required_version: 4, ... }`, and runtime callers map unsupported remote SQL to `sqlite.remote_unavailable` instead of a BARE decode failure.
+- Wasm uses remote SQLite only. The valid SQLite driver cells are native/local/all encodings, native/remote/all encodings, and wasm/remote/all encodings; wasm/local is invalid and covered by a targeted unavailable assertion.
+- Shared SQLite bind, value, result, and route types live in `rivetkit-sqlite-types`. Native and remote execution both route through the shared SQLite execution layer so statement classification, writer stickiness, migrations, `execute_write`, and manual transactions stay aligned.
+- `pegboard-envoy` creates at most one remote SQL executor per active `(actor_id, sqlite_generation)`. The executor is created lazily on the first accepted SQL request, reused for that generation, and removed when the actor closes or the connection shuts down.
+- Remote SQL work runs outside the pegboard-envoy WebSocket read loop in bounded workers. Accepted SQL is tracked per `(actor_id, sqlite_generation)`; actor stop rejects new SQL after stopping begins and waits for already accepted SQL before closing storage.
+- Sent remote SQL requests fail with `sqlite.remote_indeterminate_result` if the WebSocket disconnects before the response arrives. Only unsent requests may be sent after reconnect.
+- `rivet-envoy-client` owns native versus wasm WebSocket transport selection through mutually exclusive `native-transport` and `wasm-transport` features. `rivetkit-core` selects transport by enabling `native-runtime` or `wasm-runtime`.
+- The wasm binding strategy is direct `wasm-bindgen` in `@rivetkit/rivetkit-wasm`. Native NAPI and wasm bindings both adapt into the shared TypeScript `CoreRuntime` interface; raw binding imports stay inside approved runtime adapter files.
+- `scripts/cargo/check-rivetkit-core-wasm.sh` is the canonical wasm dependency gate for `rivetkit-core`.
+
+## Current State
+
+- `rivetkit-core` owns `ActorContext::sql()` and currently routes `exec`, `query`, `run`, `execute`, and `execute_write` through `SqliteDb`.
+- With `sqlite-local`, `SqliteDb` opens `rivetkit-sqlite::NativeDatabaseHandle`, which uses native `libsqlite3-sys` plus a custom VFS.
+- With `sqlite-remote`, `SqliteDb` sends SQL through envoy remote execution. With no usable backend, the public API returns explicit structured unavailable errors.
+- The envoy SQLite protocol now includes both the page/storage path and v4 SQL execution requests for `exec`, `execute`, and `execute_write`.
+- `pegboard-envoy` validates remote SQL namespace, actor, generation, request size, and response size before executing through the shared SQLite execution layer.
+- The canonical wasm compile and dependency check is `scripts/cargo/check-rivetkit-core-wasm.sh`.
+
+## Phase 1: Remote SQLite SQL Execution
+
+### Summary
+
+Add a second SQLite execution backend in `rivetkit-core`: local native SQLite when compiled with native SQLite support, and remote SQL execution through the envoy protocol when compiled without it or explicitly configured to use remote execution.
+
+The important pushback: this is not just dynamic routing over the current protocol. The current protocol only remotes page reads/writes. SQL execution still happens in the actor process. To run SQLite on `pegboard-envoy`, we need new protocol messages and a server-side SQL executor.
+
+### Proposed Shape
+
+Introduce a core-level SQLite backend enum behind `SqliteDb`:
+
+```rust
+enum SqliteBackend {
+	LocalNative(LocalNativeSqlite),
+	RemoteEnvoy(RemoteSqlite),
+	Unavailable,
+}
+```
+
+Keep the public `SqliteDb` methods unchanged:
+
+- `exec(sql) -> QueryResult`
+- `query(sql, params) -> QueryResult`
+- `run(sql, params) -> ExecResult`
+- `execute(sql, params) -> ExecuteResult`
+- `execute_write(sql, params) -> ExecuteResult`
+- `close()`
+
+Add a compile/runtime selection layer:
+
+- Native default: `local-native` when `rivetkit-core/sqlite` is enabled.
+- Wasm/default-no-native: `remote-envoy` only when the runtime explicitly declares remote SQLite support. Other no-native builds keep returning `sqlite.unavailable`.
+- Explicit override: config/env/feature for forcing remote SQLite in native builds so we can test phase 1 without wasm.
+
+### Protocol Additions
+
+Add a new envoy protocol version rather than mutating an existing `*.bare` version.
+
+New BARE types should mirror core/native result shapes:
+
+- `SqliteBindParam`: `Null | Integer(i64) | Float(f64) | Text(str) | Blob(data)`
+- `SqliteColumnValue`: `Null | Integer(i64) | Float(f64) | Text(str) | Blob(data)`
+- `SqliteExecuteKind`: `Exec | Execute | ExecuteWrite`
+- `SqliteExecuteSqlRequest`: `actorId`, `generation`, `kind`, `sql`, `params`
+- `SqliteExecuteSqlOk`: `columns`, `rows`, `changes`, `lastInsertRowId`, `route`
+- `SqliteExecuteSqlResponse`: `Ok | FenceMismatch | ErrorResponse`
+- `ToRivetSqliteExecuteSqlRequest`
+- `ToEnvoySqliteExecuteSqlResponse`
+
+`query` and `run` can be client-side projections over `Execute`, just like TypeScript now does over the native `execute` path. `exec` remains separate because it supports multi-statement compatibility.
+
+Protocol implementation must include:
+
+- A new `engine/sdks/schemas/envoy-protocol/v4.bare`.
+- Regenerated Rust/TypeScript protocol code and updated stringifiers.
+- `engine/sdks/rust/envoy-protocol/src/versioned.rs` guards that reject remote SQL messages on protocol versions older than v4 with explicit errors.
+- Compatibility tests for old core/new pegboard-envoy, new core/old pegboard-envoy, old core/old pegboard-envoy, and new core/new pegboard-envoy.
+- A user-facing `sqlite.remote_unavailable` or equivalent structured error when the runtime selects remote SQLite but the connected pegboard-envoy protocol cannot serve it.
+
+Rollout order:
+
+| Runtime | Pegboard-envoy | Expected behavior |
+|---|---|---|
+| Old native | New | Existing page-storage SQLite path works unchanged. |
+| New native local | Old | Local native SQLite works unchanged. Remote override fails fast with remote-unavailable. |
+| New native remote | New | Remote SQL path works and passes parity tests. |
+| New wasm remote | Old | Startup or first SQL call fails with remote-unavailable, not `sqlite.unavailable` and not a protocol decode failure. |
+| New wasm remote | New | Remote SQL path works and passes wasm smoke tests. |
+
+Remote SQL is a v4-only capability. `versioned.rs` must fail serialization for `ToRivetSqliteExecRequest`, `ToRivetSqliteExecuteRequest`, `ToRivetSqliteExecuteWriteRequest`, and their `ToEnvoy` responses when the negotiated protocol version is v1, v2, or v3. That failure uses a typed `ProtocolCompatibilityError` with `feature = RemoteSqliteExecution`, `required_version = 4`, and the attempted target version, so runtime code can convert the failure into a user-facing remote-unavailable error instead of leaking a BARE decode failure.
+
+### Server-Side Execution
+
+Do not duplicate SQL classification and connection-routing behavior in `pegboard-envoy`. Prefer extracting reusable native SQLite execution from `rivetkit-sqlite`:
+
+- Move `BindParam`, `ColumnValue`, `ExecResult`, `QueryResult`, `ExecuteResult`, `ExecuteRoute`, statement classification, and connection manager behavior behind a storage backend abstraction.
+- Keep the current actor-side VFS backend backed by `EnvoyHandle`.
+- Add a pegboard-envoy VFS/storage backend that adapts the same execution layer to `Arc<sqlite_storage::SqliteEngine>`. Direct engine access is not enough; the adapter must preserve connection manager setup, PRAGMAs, classification, reader authorizer, and read/write routing.
+- Reuse the same PRAGMA setup, query-only reader authorizer, transaction/write-mode handling, and read-pool policy on both local and remote execution.
+- Create the pegboard-envoy SQL executor lazily on first SQL use for an active `(actor_id, generation)`. Declaring or constructing a database handle in the actor runtime must not eagerly create a server-side database executor.
+- Drop the pegboard-envoy SQL executor when the owning actor generation closes. Client-side `SqliteDb::close()` releases the actor-side handle only; server-side executor cleanup is tied to actor lifecycle.
+
+This keeps native and remote behavior aligned. A concrete example: `BEGIN`, `SAVEPOINT`, schema writes, and unknown classification currently force the writer path. Remote execution must make exactly the same route choice or user code will pass in Node and fail in wasm.
+
+### Concurrency And Lifecycle
+
+- `pegboard-envoy` should hold at most one SQL executor per `(actor_id, generation)`. It is created on the first accepted remote SQL request and closed/removed on `ActorStateStopped` or the equivalent actor-close path.
+- Actors that declare SQLite but never execute SQL should never create a pegboard-envoy SQL executor.
+- The first remote SQL call should perform the same namespace, generation, and local-open validation as existing SQLite storage requests before creating the executor.
+- Server-side SQL must not run inline on the pegboard-envoy WebSocket read loop. Dispatch SQL work to bounded per-connection workers, keep per-actor serialization where required by the connection manager, and continue processing pings, stops, tunnel traffic, and later messages while SQL is running.
+- Track in-flight remote SQL per `(actor_id, generation)`. Accepted SQL runs in bounded per-connection workers. Once an actor enters stopping, new remote SQL is rejected; actor close waits up to the actor stop budget for already-running SQL and must not close SQLite while work is still in flight.
+- Serverful actors can rely on the existing pegboard exclusivity invariant: one active actor generation owns SQLite access.
+- Serverless flows already call `ensure_local_open`; remote execution should use the same generation fencing before each query.
+- Remote `close()` from actor core should release the client-side handle only. Final server-side cleanup should be driven by actor stop so leaked JS/Rust handles cannot keep the database alive forever.
+- Long-running SQL must count as actor activity from core's point of view. Awaited SQL inside action/run work is covered by the user task; detached/background SQL must use a first-class SQL activity counter or mandatory `keep_awake` wrapping so sleep finalize cannot close under it.
+- Remote SQL requests are not blindly retried after a WebSocket disconnect. If a request may have reached pegboard-envoy and the response is lost, the actor-side envoy client fails it with `sqlite.remote_indeterminate_result`. Only requests that were still unsent may be sent after reconnect.
+- Manual transaction sequences spanning calls must remain sticky to the writer connection for the same client-side `SqliteDb` handle, matching native write-mode behavior.
+
+### Payload Limits
+
+Remote SQL must enforce concrete limits before execution and before sending responses:
+
+- SQL text bytes.
+- Bind parameter count and total serialized bind bytes.
+- Row count, column count, cell bytes, and total serialized response bytes.
+- Maximum execution time or cancellation deadline.
+
+The serialized response limit should default to `ProtocolMetadata.maxResponsePayloadSize`; requests that exceed limits return structured SQLite errors without sending oversized WebSocket frames.
+
+### Errors
+
+- SQL errors should cross the protocol as `SqliteErrorResponse` and be converted by core into `RivetError` where possible.
+- Do not expose raw internal engine errors to TypeScript as canonical `RivetError` unless they came from the universal error system.
+- Preserve existing TypeScript error enrichment behavior for KV/VFS failures where useful, but rename it once remote execution is not actually native VFS I/O.
+
+### Tests
+
+Core/unit:
+
+- `SqliteDb` routes to local native when enabled and remote when forced.
+- Remote request serialization supports null/int/float/text/blob bindings, plus TypeScript wrapper normalization for named params, booleans, bigint, `Uint8Array`, and blob-like values.
+- `query`, `run`, `execute`, `execute_write`, and `exec` preserve existing result shapes.
+- `execute_write` forces writer route even for read-looking SQL.
+- `writeMode` and `db({ onMigrate })` run through the remote path with the same writer stickiness and migration ordering as native.
+- Native-to-remote error mapping preserves structured `RivetError` sanitization and does not leak internal engine errors.
+
+Pegboard-envoy:
+
+- SQL request validation rejects invalid actor id, namespace mismatch, stale generation, oversized SQL, oversized params, and oversized result.
+- SQL executor creation is lazy: an actor that never uses SQL creates no server-side SQL executor, the first accepted SQL call creates exactly one executor, and repeated calls reuse it for that actor generation.
+- Actor close removes the server-side SQL executor. A later actor wake creates a fresh executor for the new generation while persisted SQLite data remains in storage.
+- Server-side executor returns fence mismatch when generation does not match.
+- Concurrent remote reads/writes follow the same read-pool/write-mode behavior as native.
+- A long SQL query does not block the WebSocket read loop from handling ping/pong, stop, and tunnel traffic.
+- Actor stop rejects new remote SQL, waits up to the actor stop budget for already-running SQL, and never closes storage under an executing query.
+- Old protocol versions reject remote SQL messages cleanly.
+- Lost response during write SQL returns the selected indeterminate-result or deduped response behavior.
+
+Driver/parity:
+
+- Extend `rivetkit-typescript/packages/rivetkit/tests/driver/shared-matrix.ts` beyond the current encoding-only matrix to cover SQLite backend and runtime dimensions.
+- Run the existing raw SQLite driver suite across `sqliteBackend = local | remote`, `runtime = native | wasm`, and `encoding = bare | cbor | json`.
+- Treat `runtime = wasm` plus `sqliteBackend = local` as an invalid cell. It should be skipped by matrix construction or asserted unavailable, because wasm has no local SQLite backend.
+- Required valid cells are native/local/all encodings, native/remote/all encodings, and wasm/remote/all encodings.
+- SQLite-specific driver tests are the only tests that must multiply by SQLite backend. Non-SQLite driver tests should continue to run across their existing registry/encoding coverage, and may add the runtime dimension only when the wasm runtime is ready.
+- The SQLite driver suite means the existing `rivetkit-typescript/packages/rivetkit/tests/driver/actor-db*.test.ts` coverage plus any database-specific helper suites added for this work.
+- Add deterministic tests for reconnect during write SQL, stale-generation SQL, duplicate command replay around SQL, result-size rejection, shutdown during SQL, and manual transaction sequences spanning calls.
+- Add a wasm/no-native smoke gate once phase 2 exists, then promote wasm/remote/all-encoding SQLite tests into the normal driver matrix.
+
+Required SQLite driver matrix:
+
+| Runtime | SQLite backend | Encodings | Required phase | Expected behavior |
+|---|---|---|---|---|
+| native | local | `bare`, `cbor`, `json` | Phase 1 | Existing native local SQLite behavior passes unchanged. |
+| native | remote | `bare`, `cbor`, `json` | Phase 1 | Native runtime forced to remote SQL passes the same database API tests. |
+| wasm | remote | `bare`, `cbor`, `json` | Phase 2 | Wasm runtime with no local SQLite passes the same database API tests through pegboard-envoy. |
+| wasm | local | none | Phase 2 | Invalid combination. Matrix construction must not run it, and a targeted assertion should prove local SQLite is unavailable in wasm. |
+
+Required test controls:
+
+- Add explicit config fields equivalent to `runtime: "native" | "wasm"` and `sqliteBackend: "local" | "remote"` in the shared driver config.
+- Native remote tests must force remote SQL through a single stable knob such as `RIVETKIT_SQLITE_BACKEND=remote` or an equivalent driver config field.
+- Wasm tests must run with no local SQLite dependency compiled in.
+- The matrix builder should name each dimension in test output so failures show registry, runtime, SQLite backend, and encoding.
+- Before phase 2 lands, wasm/remote/all-encoding tests may be present as skipped or smoke-only coverage. Once phase 2 acceptance is claimed, wasm/remote/all-encoding tests are a required normal driver gate.
+
+### Acceptance Criteria
+
+- Existing native SQLite driver tests pass unchanged with local native SQLite.
+- The same public database API passes the driver SQLite tests with `RIVETKIT_SQLITE_BACKEND=remote` or equivalent.
+- The driver suite has explicit matrix dimensions for SQLite backend, runtime, and encoding. The valid SQLite matrix is native/local/all encodings, native/remote/all encodings, and wasm/remote/all encodings.
+- The driver matrix excludes wasm/local from normal execution and includes a targeted assertion that wasm local SQLite is unavailable.
+- SQLite-specific driver tests multiply by SQLite backend. Non-SQLite driver tests do not multiply by SQLite backend unless they explicitly need database behavior.
+- Test output names the registry, runtime, SQLite backend, and encoding for every SQLite driver cell.
+- Pegboard-envoy creates the server-side SQL executor lazily on first SQL use and removes it when the actor generation closes.
+- Tests prove that an actor that never executes SQL does not create a remote SQL executor, and that reopening the actor after close creates a fresh executor while preserving persisted database contents.
+- `rivetkit-core` can be built with no native SQLite dependency and still execute SQL remotely.
+- `pegboard-envoy` owns server-side SQLite query execution and enforces actor namespace/generation validation.
+- Protocol v4 is added, generated clients are updated, old-version guards are tested, and rollout matrix behavior is implemented.
+- No existing published `*.bare` protocol version is modified.
+- Remote SQLite is opt-in for no-native builds until the runtime has confirmed pegboard-envoy support.
+
+## Phase 2: WebAssembly Compilation
+
+### Summary
+
+Make a wasm target a first-class runtime target for `rivetkit-core`, not a special TypeScript-only side path. The core move is to split native runtime concerns from pure actor runtime concerns.
+
+`wasm_bindgen` can expose JavaScript host APIs, and `web-sys` can drive standard WebSockets, but the current Rust envoy client is native: `tokio-tungstenite`, `mio`, native rustls setup, native process management, and `reqwest`/pooling dependencies all need to be behind target-specific features or abstractions.
+
+### Proposed Crate/Feature Shape
+
+Add explicit features:
+
+- `native-runtime`: current default native transport, process management, native HTTP helpers.
+- `sqlite-local`: current `rivetkit-sqlite` path.
+- `sqlite-remote`: phase 1 remote SQL path.
+- `wasm-runtime`: wasm-safe timers, spawning, WebSocket transport, panic/log setup, and JS bindings.
+
+For the direct wasm-bindgen path on `wasm32-unknown-unknown`, default to:
+
+- no `sqlite-local`
+- yes `sqlite-remote`
+- no native engine process spawning
+- no native `tokio-tungstenite`
+- no native `reqwest` client construction in core
+
+Do not use NAPI-RS wasm for the production edge-host binding. The spike showed its async/callback path is not compatible with workerd's no-threading runtime.
+
+The feature work must include a target-specific dependency graph. The wasm graph must not depend on the workspace `tokio` with `full`, `mio`, `tokio-tungstenite`, `nix`, native `reqwest` pooling, `rivet-pools`, or `rivet-util` paths that pull native networking. This is a dependency-level requirement, not just a source-level `cfg`.
+
+Current blockers to remove or gate:
+
+- `rivetkit-core` has unconditional `nix`, `reqwest`, `rivet-pools`, and `rivet-util` dependencies.
+- `rivet-envoy-client` has an unconditional `tokio-tungstenite` dependency.
+- Workspace `tokio` currently enables native-heavy features through dependent crates.
+- `rivetkit-core/src/lib.rs` exports native-only modules like `engine_process` and `serverless` unconditionally.
+
+### WebSocket Ownership And Branching
+
+The envoy WebSocket implementation is defined by `rivet-envoy-client`, not by `pegboard-envoy`.
+
+Current ownership:
+
+- `rivetkit-core/src/registry/mod.rs` calls `rivet_envoy_client::envoy::start_envoy(...)` with `EnvoyConfig`.
+- `engine/sdks/rust/envoy-client/src/connection.rs` builds the envoy connection URL, chooses `tokio-tungstenite`, sends the `rivet` and `rivet_token.*` subprotocols, reconnects, serializes `ToRivet`, deserializes `ToEnvoy`, and forwards messages into the envoy loop.
+- `engine/packages/pegboard-envoy` accepts the WebSocket and speaks the envoy protocol. It should not care whether the actor host used `tokio-tungstenite`, `web-sys::WebSocket`, or a future host transport.
+- `rivetkit-core/src/registry/websocket.rs` and `rivetkit-core/src/websocket.rs` are a different WebSocket surface: actor/user WebSockets tunneled through envoy. They do not choose the actor-host-to-pegboard-envoy transport.
+
+Desired ownership:
+
+- `rivet-envoy-client` owns transport selection and the transport implementation.
+- `rivetkit-core` owns runtime feature selection and passes a normal `EnvoyConfig` into `start_envoy`.
+- `pegboard-envoy` owns protocol validation, close semantics, and actor lifecycle. It does not branch on wasm/native client transport.
+
+Branching should be compile-time, not a runtime `if wasm` check:
+
+| Build | `rivetkit-core` feature | `rivet-envoy-client` feature | Envoy transport |
+|---|---|---|---|
+| Native NAPI/Rust | `native-runtime` | `native-transport` | `tokio-tungstenite` |
+| Wasm JS host | `wasm-runtime` | `wasm-transport` | Host WebSocket API, normally `web-sys::WebSocket` |
+
+The branch should work like this:
+
+- `rivetkit-rust/packages/rivetkit-core/Cargo.toml` maps `native-runtime` to `rivet-envoy-client/native-transport`.
+- `rivetkit-rust/packages/rivetkit-core/Cargo.toml` maps `wasm-runtime` to `rivet-envoy-client/wasm-transport`.
+- `engine/sdks/rust/envoy-client/Cargo.toml` makes `tokio-tungstenite`, native rustls setup, and any native-only HTTP/WebSocket dependencies optional behind `native-transport`.
+- `engine/sdks/rust/envoy-client/Cargo.toml` adds optional `wasm-bindgen`, `wasm-bindgen-futures`, `js-sys`, and `web-sys` dependencies behind `wasm-transport`.
+- `engine/sdks/rust/envoy-client/src/connection/mod.rs` exposes the stable API used by the envoy loop, for example `start_connection(shared)`.
+- `engine/sdks/rust/envoy-client/src/connection/native.rs` contains the current `tokio-tungstenite` implementation moved out of `connection.rs`.
+- `engine/sdks/rust/envoy-client/src/connection/wasm.rs` contains the `web-sys::WebSocket` implementation.
+- `connection/mod.rs` uses `#[cfg(feature = "native-transport")]` and `#[cfg(feature = "wasm-transport")]` to re-export exactly one implementation.
+- Invalid feature combinations should fail at compile time: wasm target plus `native-transport`, native target plus `wasm-transport` unless explicitly supported, both transports enabled, or no transport enabled.
+
+The wasm transport must preserve the behavior of the current native `connection.rs`:
+
+- Same `ws_url(...)` query parameters: `protocol_version`, `namespace`, `envoy_key`, `version`, and `pool_name`.
+- Same subprotocol auth shape: `rivet` plus `rivet_token.{token}` when a token exists.
+- Same initial `ToRivetMetadata` send after connection open.
+- Same `ToRivet` vbare serialization and `ToEnvoy` vbare deserialization.
+- Same ping/pong handling, close-reason parsing, reconnect backoff, and shutdown close behavior.
+
+The important browser constraint is that `web-sys::WebSocket` cannot set arbitrary WebSocket upgrade headers such as `Host`, `Connection`, `Upgrade`, or `Sec-WebSocket-Key`. This is acceptable only if `pegboard-envoy` authentication continues to work through URL parameters and `Sec-WebSocket-Protocol`.
+
+### Runtime Abstractions
+
+Introduce small core traits rather than threading `#[cfg(target_arch = "wasm32")]` through lifecycle code:
+
+- `RuntimeSpawner`: spawn local futures, spawn Send futures on native, and surface abort handles.
+- `RuntimeClock`: sleep, intervals, deadlines.
+- `EnvoyTransport`: connect, send binary messages, receive binary messages, close, observe close reason.
+- `HttpClient`: only for the few places core fetches runner config or probes local engine health.
+- `ProcessManager`: native-only engine binary spawning, unavailable in wasm with explicit errors.
+
+The existing actor lifecycle, queues, schedule, sleep, state persistence, registry dispatch, and SQLite routing should stay in core. Only environmental I/O moves behind interfaces.
+
+The callback surface also needs a wasm-local design. Current callback traits require `Send + Sync + 'static` and `BoxFuture + Send`, which does not fit browser/worker JS promises and closures. Phase 2 must either:
+
+- Add wasm-local callback traits that use local futures and JS-owned closures.
+- Or keep Rust callback traits native-only and expose a JS host wrapper that converts JS promises into core events without requiring `Send`.
+
+This decision is a blocker for WebAssembly feature parity; a spawn helper alone is not enough.
+
+### WebSocket Transport
+
+Create a wasm transport using `web-sys::WebSocket` and `wasm_bindgen` closures:
+
+- Build the URL and subprotocol list to match native authentication semantics.
+- Set binary type to `ArrayBuffer`.
+- Convert JS `MessageEvent` data into `Vec<u8>`.
+- Feed decoded `ToEnvoy` messages into the existing envoy loop.
+- Map close frames into the same close reason parser used by native.
+- Reconnect with the same backoff policy.
+
+This should live in the envoy client layer, but selected by `wasm-runtime`, so `rivetkit-core` does not import `web_sys` directly unless we intentionally create a wasm facade crate.
+
+JavaScript-host WebSockets cannot set arbitrary upgrade headers such as `Host`, `Connection`, `Upgrade`, or `Sec-WebSocket-Key`. The real compatibility gate is subprotocol-token auth working from the chosen host's WebSocket API.
+
+### Tokio And Futures
+
+The current direct `tokio::spawn` usage assumes `Send` futures and native runtime features. Wasm should use `wasm_bindgen_futures::spawn_local` or a wasm-compatible local executor through `RuntimeSpawner`.
+
+Likely migration pattern:
+
+- Replace `tokio::spawn(...)` in core-owned lifecycle code with a core spawn helper.
+- Keep `tokio::sync` where it compiles, but gate `tokio` features so `net`, process, and full native runtime are not pulled into wasm.
+- Avoid `spawn_blocking` in wasm. Phase 1 remote SQLite removes the current SQLite preload-hint `spawn_blocking` path for wasm.
+
+### Native-Only Code To Gate
+
+- `rivetkit-core/src/engine_process.rs`: native-only. Wasm should return explicit configuration errors.
+- `rivetkit-core/src/serverless.rs`: split pure request handling from HTTP/client validation and native streaming assumptions.
+- `rivetkit-core/src/registry/runner_config.rs`: move HTTP fetch behind a wasm-safe client abstraction.
+- `rivet-envoy-client/src/connection.rs`: split `tokio-tungstenite` native transport from wasm `web-sys` transport.
+- `rivetkit-sqlite`: never compiled for wasm.
+- `rivet-pools`, `rivet-util`, and `rivet-metrics`: stop pulling broad engine/native dependencies into `rivetkit-core` for wasm.
+
+### File-Level Change Plan
+
+Phase 1 remote SQLite changes:
+
+| File or package | Change |
+|---|---|
+| `engine/sdks/schemas/envoy-protocol/v4.bare` | Add remote SQL request/response messages and SQL value/result types. |
+| `engine/sdks/rust/envoy-protocol/src/versioned.rs` | Wire v4 and reject remote SQL against older protocol versions with explicit structured errors. |
+| `engine/sdks/rust/envoy-client/src/envoy.rs` | Add a `ToEnvoyMessage` variant for remote SQL execution requests and cleanup behavior on shutdown. |
+| `engine/sdks/rust/envoy-client/src/sqlite.rs` | Add request ID tracking and response matching for remote SQL execution, separate from existing page/VFS requests. |
+| `engine/sdks/rust/envoy-client/src/handle.rs` | Add a handle method used by core to send remote SQL requests and await responses. |
+| `engine/sdks/rust/envoy-client/src/stringify.rs` | Add stringifiers for the new v4 SQL execution messages. |
+| `rivetkit-rust/packages/rivetkit-core/src/actor/sqlite.rs` | Add `SqliteBackend::{LocalNative, RemoteEnvoy, Unavailable}` routing and preserve existing public `SqliteDb` methods. |
+| `rivetkit-rust/packages/rivetkit-core/src/actor/context.rs` | Select the SQLite backend when `ActorContext::sql()` constructs the database handle. Remote selection requires an envoy handle and remote capability. |
+| `rivetkit-rust/packages/rivetkit-core/Cargo.toml` | Split `sqlite-local` from `sqlite-remote`; keep native local SQLite optional and unavailable for wasm. |
+| `rivetkit-rust/packages/rivetkit-sqlite/` | Extract reusable execution/result/classification pieces so pegboard-envoy and actor-local native SQLite share behavior. |
+| `engine/packages/pegboard-envoy/src/sqlite_runtime.rs` | Add the lazy per-`(actor_id, generation)` SQL executor registry, first-use creation, in-flight accounting, and actor-close cleanup. |
+| `engine/packages/pegboard-envoy/src/conn.rs` and related message dispatch files | Dispatch new remote SQL messages to `sqlite_runtime` without blocking the WebSocket read loop. |
+| `engine/packages/pegboard-envoy/src/errors.rs` | Add structured errors for remote SQLite unavailable, stale generation, size limits, and indeterminate lost-response behavior. |
+| `rivetkit-typescript/packages/rivetkit/tests/driver/shared-types.ts` | Add matrix fields for `runtime` and `sqliteBackend` alongside `encoding`. |
+| `rivetkit-typescript/packages/rivetkit/tests/driver/shared-matrix.ts` | Generate native/local/all encodings, native/remote/all encodings, and wasm/remote/all encodings. Exclude wasm/local. |
+| `rivetkit-typescript/packages/rivetkit/tests/driver/actor-db*.test.ts` | Run existing SQLite coverage across the new valid matrix and add lazy-create/cleanup assertions. |
+
+Phase 2 wasm transport and build changes:
+
+| File or package | Change |
+|---|---|
+| `engine/sdks/rust/envoy-client/Cargo.toml` | Add `native-transport` and `wasm-transport` features. Make `tokio-tungstenite` optional. Add optional wasm dependencies. |
+| `engine/sdks/rust/envoy-client/src/connection.rs` | Replace with a module wrapper or move to `connection/mod.rs`. Keep the public `start_connection(shared)` API stable. |
+| `engine/sdks/rust/envoy-client/src/connection/native.rs` | Move the current `tokio-tungstenite` implementation here with minimal behavior changes. |
+| `engine/sdks/rust/envoy-client/src/connection/wasm.rs` | Implement `web-sys::WebSocket` transport, ArrayBuffer decoding, subprotocol auth, close parsing, reconnect, and metadata send. |
+| `engine/sdks/rust/envoy-client/src/context.rs` | Keep shared protocol state transport-agnostic. Replace native-only channel assumptions if wasm needs local channels. |
+| `engine/sdks/rust/envoy-client/src/utils.rs` | Keep backoff and close-reason parsing shared by native and wasm transports. Gate native-only helpers. |
+| `rivetkit-rust/packages/rivetkit-core/Cargo.toml` | Add `native-runtime`, `wasm-runtime`, `sqlite-local`, and `sqlite-remote` feature mappings. Gate native dependencies. |
+| `rivetkit-rust/packages/rivetkit-core/src/lib.rs` | Gate exports for `engine_process`, native serverless helpers, and any module that cannot compile on wasm. |
+| `rivetkit-rust/packages/rivetkit-core/src/engine_process.rs` | Native-only behind `native-runtime`; wasm path returns explicit unsupported configuration errors. |
+| `rivetkit-rust/packages/rivetkit-core/src/registry/mod.rs` | Keep lifecycle logic in core, but construct envoy with runtime-selected features and no direct dependency on `web_sys`. |
+| `rivetkit-rust/packages/rivetkit-core/src/registry/runner_config.rs` | Move HTTP fetches behind `HttpClient` so wasm can use a JS/fetch-backed implementation or fail explicitly. |
+| `rivetkit-rust/packages/rivetkit-core/src/serverless.rs` | Split pure request/response parsing from native HTTP/client assumptions. |
+| `rivetkit-rust/packages/rivetkit-core/src/actor/task.rs` and lifecycle spawn sites | Replace direct native spawn assumptions with `RuntimeSpawner` or an equivalent core helper. |
+| `rivetkit-typescript/packages/rivetkit-napi/` | Current native Node binding package. Keep native-only for production edge support. The NAPI-RS wasm spike only supports sync calls in workerd and fails on async/callback-style surfaces. |
+| `rivetkit-typescript/packages/rivetkit-wasm/` | New wasm binding package that wraps `rivetkit-core` through direct `wasm-bindgen` on `wasm32-unknown-unknown`. |
+| `rivetkit-typescript/packages/rivetkit/src/registry/core-runtime-interface.ts` | New bridge-neutral TypeScript interface implemented by both NAPI and wasm bindings. Exact file name can change, but the boundary must exist. |
+| `rivetkit-typescript/packages/rivetkit/src/registry/native.ts` | Refactor NAPI-specific loading and NAPI object adaptation behind the shared core-runtime interface instead of serving as the only runtime glue. |
+| `rivetkit-typescript/packages/rivetkit/src/registry/wasm.ts` | New wasm-specific loader/adaptor that imports the selected wasm binding package and implements the same core-runtime interface. |
+
+### Build Targets
+
+Support Supabase Edge Functions and Cloudflare Workers as first-class wasm hosts.
+
+Host requirements from docs:
+
+| Host | Documented wasm model | Implication |
+|---|---|---|
+| Supabase Edge Functions | Deno-based functions can load wasm generated with `wasm-pack --target deno`. | The wasm package must work in Deno and avoid Node-only NAPI assumptions. |
+| Cloudflare Workers | Workers can import/instantiate `.wasm` modules, but threading is not possible in Workers and WASI support is experimental. | The wasm package must not require wasm threads, SharedArrayBuffer/Atomics, or a full WASI runtime. |
+
+Target direct wasm-bindgen on `wasm32-unknown-unknown`, packaged/tested for both Deno/Supabase and Cloudflare Workers. Browser main thread, Node wasm, and WASI are follow-up targets unless they pass the same Supabase and Cloudflare host contract explicitly.
+
+Expected packages:
+
+- `rivetkit-core` wasm library.
+- `@rivetkit/rivetkit-wasm`, a direct wasm-bindgen binding package over `rivetkit-core`.
+- Separate native NAPI package remains unchanged.
+
+### TypeScript Runtime Boundary
+
+The TypeScript glue must be a separate layer from `rivetkit-core`. `rivetkit-core` should expose Rust runtime primitives; it should not contain TypeScript package loading, JS promise conversion, NAPI-specific public API design, or wasm-bindgen-specific public API design. The wasm binding belongs in a separate `rivetkit-wasm` package, equivalent in role to `rivetkit-napi`.
+
+Recommended package shape:
+
+| Layer | Responsibility |
+|---|---|
+| `rivetkit-core` | Shared Rust actor runtime, lifecycle, state, sleep, queue, schedule, KV/SQLite handles, and envoy integration. No NAPI, NAPI-RS wasm, or wasm-bindgen exports. |
+| `rivetkit-napi` | Node N-API binding over `rivetkit-core`. Native-only. Owns N-API object wrappers, ThreadsafeFunction bridging, Node buffers, and native Tokio interop. |
+| `rivetkit-wasm` | Wasm binding over `rivetkit-core`. Owns wasm-bindgen classes/functions, JS Promise conversion, `Uint8Array`/ArrayBuffer conversion, wasm-local callback handling, and host setup for Supabase Edge Functions and Cloudflare Workers. |
+| `rivetkit` TypeScript package | Public TypeScript actor API. Chooses a runtime binding and adapts it through a shared TypeScript interface. |
+
+The current TypeScript NAPI glue in `rivetkit-typescript/packages/rivetkit/src/registry/native.ts` should not be duplicated wholesale for wasm. It should be split into:
+
+- Runtime-independent TypeScript actor adaptation: actor definition lookup, schema validation, action/request/connection callback adaptation, state serialization, vars, workflow/agent-os integration, client construction, and error decoding.
+- Runtime-specific binding adaptation: loading `@rivetkit/rivetkit-napi` or `@rivetkit/rivetkit-wasm`, converting JS values to that binding's ABI, cancellation token wiring, buffer conversion, and host-specific callback scheduling.
+
+Define a shared TypeScript interface first, then make both bindings implement it. The local `JsNativeDatabaseLike` and `NativeDatabaseProvider` shapes are already a small example of this pattern, but the broader runtime interface should be flatter than the current generated NAPI class graph.
+
+Use explicit methods with opaque handles. Do not expose a command bus, and do not expose rich binding classes across the shared TypeScript boundary. The NAPI and wasm adapters may internally wrap generated classes, but the rest of `rivetkit` should see only the flat interface.
+
+Keep the handle set small:
+
+- `RegistryHandle`
+- `ActorFactoryHandle`
+- `ActorContextHandle`
+- `ConnHandle`
+- `WebSocketHandle`
+- `CancellationTokenHandle`
+
+Do not expose separate shared-interface handles for KV, SQLite, queue, or schedule unless a later implementation proves it is necessary. Route those operations through `ActorContextHandle`.
+
+Initial interface sketch:
+
+```ts
+type RegistryHandle = unknown;
+type ActorFactoryHandle = unknown;
+type ActorContextHandle = unknown;
+type ConnHandle = unknown;
+type WebSocketHandle = unknown;
+type CancellationTokenHandle = unknown;
+
+interface CoreRuntimeBindings {
+	createCancellationToken(): CancellationTokenHandle;
+	cancelTokenCancel(token: CancellationTokenHandle): void;
+
+	createRegistry(): Promise<RegistryHandle>;
+	registryRegisterActor(
+		registry: RegistryHandle,
+		name: string,
+		factory: ActorFactoryHandle,
+	): Promise<void>;
+	registryServe(
+		registry: RegistryHandle,
+		config: CoreServeConfig,
+	): Promise<void>;
+	registryShutdown(registry: RegistryHandle): Promise<void>;
+
+	createActorFactory(
+		callbacks: CoreActorCallbacks,
+		config: CoreActorConfig,
+	): Promise<ActorFactoryHandle>;
+
+	registryHandleServerlessRequest?(
+		registry: RegistryHandle,
+		request: CoreServerlessRequest,
+		onStreamEvent: CoreServerlessStreamCallback,
+		cancelToken: CancellationTokenHandle,
+		config: CoreServeConfig,
+	): Promise<CoreServerlessResponseHead>;
+
+	actorId(ctx: ActorContextHandle): string;
+	actorState(ctx: ActorContextHandle): Uint8Array;
+	actorRequestSave(
+		ctx: ActorContextHandle,
+		opts?: CoreRequestSaveOpts,
+	): Promise<void>;
+
+	kvBatchGet(
+		ctx: ActorContextHandle,
+		keys: Uint8Array[],
+	): Promise<(Uint8Array | null)[]>;
+	kvBatchPut(
+		ctx: ActorContextHandle,
+		entries: [Uint8Array, Uint8Array][],
+	): Promise<void>;
+	kvBatchDelete(ctx: ActorContextHandle, keys: Uint8Array[]): Promise<void>;
+	kvDeleteRange(
+		ctx: ActorContextHandle,
+		start: Uint8Array,
+		end: Uint8Array,
+	): Promise<void>;
+
+	sqliteExec(ctx: ActorContextHandle, sql: string): Promise<CoreSqliteExecResult>;
+	sqliteExecute(
+		ctx: ActorContextHandle,
+		sql: string,
+		params: CoreSqliteBindParam[] | null,
+		mode: "readWrite" | "forceWrite",
+	): Promise<CoreSqliteExecuteResult>;
+	sqliteClose(ctx: ActorContextHandle): Promise<void>;
+
+	queueSend(
+		ctx: ActorContextHandle,
+		queue: string,
+		message: Uint8Array,
+	): Promise<void>;
+
+	scheduleSetAlarm(
+		ctx: ActorContextHandle,
+		timestamp: number,
+	): Promise<void>;
+
+	webSocketSend(
+		ws: WebSocketHandle,
+		data: Uint8Array,
+		binary: boolean,
+	): Promise<void>;
+	webSocketClose(
+		ws: WebSocketHandle,
+		code?: number,
+		reason?: string,
+	): Promise<void>;
+}
+```
+
+This interface is the cleanup point. Native NAPI and wasm may expose different raw generated bindings, but `rivetkit` should only depend on the normalized `CoreRuntimeBindings` contract. That keeps the public TypeScript actor API unified while allowing each binding to use the ABI that fits its host.
+
+Boundary rules:
+
+- `rivetkit-core` must not depend on `napi`, `wasm-bindgen`, `web-sys`, `js-sys`, Node buffers, or TypeScript package-loading behavior. Host bindings wrap core; core does not wrap hosts.
+- `rivetkit-napi` and `rivetkit-wasm` are the only packages that may expose generated host ABI classes/functions.
+- `rivetkit-typescript/packages/rivetkit` must not import raw generated binding classes outside the runtime adapters. Direct imports of `@rivetkit/rivetkit-napi` belong in the NAPI adapter; direct imports of `@rivetkit/rivetkit-wasm` belong in the wasm adapter.
+- The shared TypeScript runtime boundary uses explicit methods plus opaque handles, not generated classes and not a generic command bus.
+- Runtime-independent actor glue should live behind the shared interface: actor definition lookup, schema validation, callback adaptation, state serialization, vars, workflow/agent-os integration, client construction, and error decoding.
+- Runtime-specific adapter code owns ABI conversion: Node `Buffer` vs `Uint8Array`, NAPI errors vs wasm thrown values, cancellation token wrappers, callback scheduling, and host-specific startup.
+- Add type tests proving both adapters satisfy `CoreRuntimeBindings`.
+- Add a static guard or lint check that fails if raw generated binding imports appear outside the approved adapter files.
+
+### Wasm Binding Strategy Decision
+
+Use direct wasm-bindgen on `wasm32-unknown-unknown` for the production edge-host path.
+
+The NAPI-RS wasm spike in `/home/nathan/misc/napi-rs-wasm-test/` proved that sync-only NAPI-RS wasm can run through a custom workerd loader, but async/callback-style surfaces fail in workerd:
+
+```text
+failed to spawn thread: Error { kind: Unsupported, message: "operation not supported on this platform" }
+RuntimeError: unreachable
+```
+
+That failure is decisive for RivetKit because the real boundary needs async methods, callback dispatch, cancellation, and JS promise interop. NAPI-RS wasm remains useful as a Node fallback/playground path, but not as the mainline Supabase/Cloudflare binding strategy.
+
+Why disabling the worker pool is not enough:
+
+- The generated NAPI-RS browser loader uses shared wasm memory, `asyncWorkPoolSize: 4`, and `new Worker(...)` by default.
+- The custom workerd loader can set `asyncWorkPoolSize: 0`, which makes emnapi use a single-thread mock for `napi_create_async_work` / `napi_queue_async_work`.
+- That does not affect NAPI-RS `#[napi] async fn` plumbing. The generated wrapper calls `execute_tokio_future_with_finalize_callback`, and the non-`tokio_unstable` wasm path uses `std::thread::spawn(|| block_on(inner))`.
+- In workerd, that `std::thread::spawn` panics because Workers do not support threads.
+- Making NAPI-RS viable would require upstream-level support for a single-thread wasm target/loader, host-event-loop-driven Rust futures, and non-threaded callback/deferred resolution. This is not a RivetKit config toggle.
+
+Decision record:
+
+| Option | Shape | Main benefit | Main risk |
+|---|---|---|---|
+| NAPI-RS wasm | Reuse a NAPI-shaped binding surface compiled to wasm, likely as a separate wasm package. | Sync-only exports can run in local workerd with a custom loader. | Async/callback exports try to spawn threads and fail in workerd. Generated loader also is not directly Cloudflare-compatible. Not viable for RivetKit's edge runtime boundary. |
+| Direct wasm-bindgen | Create a separate wasm binding package over `rivetkit-core`. | Supabase/Cloudflare-compatible ABI with direct `Promise`, `Uint8Array`, and standard host WebSocket patterns. | More binding code to write and maintain beside `rivetkit-napi`. |
+
+Prior art checked:
+
+- `napi-rs` supports building N-API projects for WebAssembly. The current docs say the default support is `wasm32-wasip1-threads`, aimed at Node fallback/playgrounds/browser repros, and browser usage relies on `SharedArrayBuffer`/Atomics headers.
+- `emnapi` can emulate Node-API on WebAssembly and supports browser execution, but it preserves the Node-API programming model and can introduce thread/SAB constraints that do not match a clean browser-compatible Web Worker target.
+- `wasm-bindgen` is the standard Rust-to-JS wasm binding path and can generate TypeScript-facing JS classes/functions, but it is not N-API-compatible.
+
+Conclusion: keep `rivetkit-core` binding-agnostic, keep `rivetkit-napi` native-only for production, and build `rivetkit-wasm` as a direct wasm-bindgen binding. `rivetkit` TypeScript must consume a normalized `CoreRuntimeBindings` interface so the public actor API stays unified.
+
+### TypeScript API Parity Matrix
+
+Feature parity means the wasm package preserves these public TypeScript surfaces or explicitly fails the phase:
+
+| Surface | Parity requirement |
+|---|---|
+| Actor lifecycle and actions | Same start, run, action, stop, sleep, destroy, and error sanitization behavior as NAPI. |
+| State | Same persisted state serialization and `onStateChange` semantics. |
+| Vars | Same TypeScript-owned vars behavior in the wasm wrapper. Do not move vars into core. |
+| KV | Same batch operations, ordering, errors, and reconnect behavior as native. |
+| SQLite | Remote SQL passes the phase 1 parity suite, including migrations and `writeMode`. |
+| Schedule/alarms | Same persisted alarm dedup, wake, and local alarm behavior. |
+| Queue | Same enqueue, receive, completion, cancellation, and sleep gating behavior. |
+| Connections/WebSockets | Same hibernatable connection persistence, raw WebSocket callbacks, close handler gating, and ack behavior where supported by the host. |
+| Client | Actor-to-actor client construction works or fails with explicit unsupported errors for surfaces impossible in the selected host. |
+| `abortSignal`, `keepAwake`, `waitUntil` | Same shutdown and sleep gating semantics. |
+| Inspector | Protocol support remains compatible. Serving inspector HTTP inside wasm is not required for the first host unless the package claims full embedded serving. |
+| Workflow/agent-os | Must be either implemented by the wasm TypeScript wrapper or explicitly declared out of scope before phase 2 starts. |
+
+### Acceptance Criteria
+
+- `cargo check -p rivetkit-core --target wasm32-unknown-unknown --no-default-features --features wasm-runtime,sqlite-remote` passes.
+- The above check uses a wasm dependency graph that excludes native networking/process crates, verified with `cargo tree --target wasm32-unknown-unknown`.
+- `rivet-envoy-client` has a wasm transport that can connect to pegboard-envoy using browser/Web Worker WebSocket APIs.
+- The wasm build does not include `rivetkit-sqlite`, `libsqlite3-sys`, `tokio-tungstenite`, `mio`, `nix`, native `reqwest` pooling, or engine process spawning.
+- A wasm runtime can start an actor, receive a command from pegboard-envoy, run an action, persist state, use KV, and execute SQLite remotely.
+- Deterministic wasm parity tests cover reconnect during action, reconnect during remote write SQL, actor stop with in-flight SQL, stale-generation SQL, duplicate command replay, KV failure sanitization, and sleep finalization blocked by remote SQL.
+- Native persisted actor state can round-trip native to wasm to native for state, schedule, queue, hibernatable connection metadata, and inspector-visible fields.
+- Existing native NAPI tests continue to pass.
+- Wasm smoke tests run in both Supabase Edge Functions/Deno and Cloudflare Workers and verify subprotocol-token WebSocket auth.
+
+### Build Gate
+
+Run `scripts/cargo/check-rivetkit-core-wasm.sh` before claiming wasm dependency hygiene. It performs the checked `rivetkit-core` wasm compile, scans the normal wasm dependency tree for native-only crates, verifies the wasm feature graph excludes `native-runtime` and `native-transport`, and asserts native envoy/core runtime feature selections fail for `wasm32-unknown-unknown`.
+
+## Questions And Decisions
+
+- Decision: remote SQLite is the only SQLite backend for wasm in phase 1/2. A wasm SQLite VFS can be reconsidered later.
+- Decision: remote SQL execution uses the existing envoy WebSocket because it already has actor lifecycle, namespace validation, reconnect, and generation fencing.
+- Decision: no streaming result rows in phase 1. Match the existing `execute` API and reject oversized results.
+- Decision: Supabase Edge Functions/Deno and Cloudflare Workers are first-class wasm hosts.
+- Decision: direct wasm-bindgen on `wasm32-unknown-unknown` is the wasm binding path for Supabase and Cloudflare.
+- Decision: NAPI-RS wasm is not viable for the mainline edge-host binding because the spike showed async/callback surfaces fail in workerd when Rust tries to spawn a thread.
+- Open: exact numeric defaults for SQL text, bind bytes, row count, cell bytes, response bytes, and execution timeout.
+- Decision: sent remote SQL requests fail with `sqlite.remote_indeterminate_result` on lost responses; durable request ID deduplication is a future enhancement.
+- Decision: remote SQL calls already accepted before actor stopping may finish, but new calls after stopping begins are rejected.
+- Open: whether workflow/agent-os are in scope for the first wasm package or deferred as explicit non-goals.
+- Decision: Node wasm and WASI are follow-up targets. They do not replace Supabase and Cloudflare acceptance.
+- Do we need inspector HTTP handled inside wasm? I recommend no for the first wasm milestone; preserve inspector protocol support but leave HTTP serving to the host.
+
+## Concerns
+
+- Remote SQL performance will add one network round trip per query unless batching is added later. This is acceptable for wasm enablement, but benchmarks should set expectations.
+- Server-side SQL execution must not bypass actor exclusivity. The safest model is one SQL executor per active `(actor_id, generation)` owned by the same pegboard-envoy connection that owns the actor.
+- If we duplicate SQL execution code between `rivetkit-sqlite` and `pegboard-envoy`, route drift is likely. Extracting the VFS/backend abstraction is more work up front but less risky.
+- Wasm support will expose broad dependency hygiene problems. `rivetkit-core` currently depends on engine utility crates that pull in native networking and metrics trees. Phase 2 should aggressively narrow those dependencies.
+- `tokio::spawn` and `Send` assumptions may be more invasive than the WebSocket binding itself. Treat spawn/timer abstraction as a first-class part of the wasm work.
+- `rand::thread_rng` and `getrandom` paths may need target-specific features for wasm randomness.
+
+## External References Checked
+
+- wasm-bindgen WebSocket example: https://rustwasm.github.io/docs/wasm-bindgen/examples/websockets.html
+- wasm-bindgen futures `spawn_local`: https://docs.rs/wasm-bindgen-futures/latest/wasm_bindgen_futures/fn.spawn_local.html
+- wasm-bindgen TypeScript custom sections: https://rustwasm.github.io/docs/wasm-bindgen/reference/attributes/on-rust-exports/typescript_custom_section.html
+- emnapi overview: https://emnapi-docs.vercel.app/
+- emnapi FAQ on browser/WebAssembly differences from native Node-API: https://toyobayashi.github.io/emnapi-docs/guide/faq.html
+- Supabase Edge Functions WebAssembly guide: https://supabase.com/docs/guides/functions/wasm
+- Cloudflare Workers WebAssembly API docs: https://developers.cloudflare.com/workers/runtime-apis/webassembly/
+- reqwest crate docs for WebAssembly support: https://docs.rs/reqwest/latest/reqwest/
+- Local compile gate: `scripts/cargo/check-rivetkit-core-wasm.sh`.
diff --git a/.agent/specs/rivetkit-runtime-boundary-cleanup.md b/.agent/specs/rivetkit-runtime-boundary-cleanup.md
new file mode 100644
index 0000000000..91e64da977
--- /dev/null
+++ b/.agent/specs/rivetkit-runtime-boundary-cleanup.md
@@ -0,0 +1,392 @@
+# RivetKit Runtime Boundary Cleanup Spec
+
+## Goal
+
+Make the TypeScript actor runtime boundary truly portable between NAPI and WebAssembly while keeping the existing actor glue and `CoreRuntime -> NapiCoreRuntime | WasmCoreRuntime` architecture.
+
+The current wasm implementation works end to end, but it reached parity by adapting wasm to a NAPI-shaped boundary. The cleanup goal is to make the shared boundary neutral enough that NAPI, wasm, and any future runtime adapter can implement it without Node-specific shims, hidden globals, or duplicated behavior.
+
+## Problem Summary
+
+The current stack is:
+
+```text
+User TypeScript
+  setup({ runtime })
+    -> rivetkit TypeScript actor glue
+    -> CoreRuntime
+       -> NapiCoreRuntime -> @rivetkit/rivetkit-napi -> rivetkit-core
+       -> WasmCoreRuntime -> @rivetkit/rivetkit-wasm -> rivetkit-core
+```
+
+That shape is correct. The problem is the contract under `CoreRuntime` still reflects the original NAPI implementation:
+
+- It uses `Buffer` for runtime bytes.
+- SQL types are derived from `JsNativeDatabaseLike`.
+- Runtime kind checks use concrete adapter classes instead of `runtime.kind`.
+- Wasm package initialization relies on an implicit global binding escape hatch in edge examples.
+- NAPI and wasm serverless registry state machines have drifted.
+- Some wasm methods are stubs or local adaptations rather than parity implementations.
+
+These differences happened because NAPI existed first and wasm was added as a compatibility adapter. This spec keeps the shared actor glue intact but cleans up the adapter contract.
+
+## Non-Goals
+
+- Do not rewrite the TypeScript actor glue.
+- Do not merge `@rivetkit/rivetkit-napi` and `@rivetkit/rivetkit-wasm` into one package.
+- Do not reintroduce class-heavy public APIs for user code.
+- Do not add local SQLite support to wasm.
+- Do not change existing published BARE protocol versions.
+
+## Target Boundary
+
+`CoreRuntime` should be a runtime-neutral TypeScript contract:
+
+```text
+CoreRuntime
+  bytes: Uint8Array
+  handles: opaque runtime handles
+  SQL params/results: plain shared structs
+  errors: structured RivetError payloads or unknown errors for core sanitization
+  lifecycle: identical registry/serverless state semantics
+```
+
+Adapters own host-specific conversion:
+
+```text
+NapiCoreRuntime
+  Node Buffer <-> Uint8Array
+  napi-rs classes <-> opaque handles
+  native promises/errors <-> CoreRuntime results
+
+WasmCoreRuntime
+  wasm-bindgen Uint8Array <-> Uint8Array
+  wasm-bindgen classes <-> opaque handles
+  JS promises/errors <-> CoreRuntime results
+```
+
+The TypeScript actor glue should not need to know which adapter is active.
+
+Tests should use the same public API shape that application developers use. Avoid test-only runtime wiring unless a unit test is specifically isolating a private helper. Edge and packaged-consumer coverage should call `setup({ runtime: "wasm", wasm: { bindings, initInput }, use })` instead of mutating globals, importing private generated paths from app code, or calling lower-level registry builders directly.
+
+## Required Changes
+
+### 1. Replace Boundary Buffers With Portable Bytes
+
+Update `rivetkit-typescript/packages/rivetkit/src/registry/runtime.ts` so runtime byte fields use `Uint8Array` instead of `Buffer`.
+
+This includes:
+
+- HTTP request and response bodies.
+- State deltas.
+- KV keys and values.
+- Queue message bodies and completion payloads.
+- SQL blob params and SQL result blobs.
+- WebSocket binary messages.
+- Conn params and conn state.
+- Inspector request and response bytes.
+
+NAPI may still accept and return `Buffer` internally, but the conversion belongs in `NapiCoreRuntime`. Wasm should not need to construct `Buffer` for normal runtime operation.
+
+Acceptance criteria:
+
+- `CoreRuntime` no longer references `Buffer`.
+- `NapiCoreRuntime` performs Node-only `Buffer` conversion at its adapter edge.
+- `WasmCoreRuntime` does not call `Buffer.from`, `Buffer.alloc`, or `Buffer.isBuffer` for runtime boundary normalization.
+- Typecheck passes.
+- Tests pass.
+
+### 2. Define Shared SQL Boundary Types
+
+Move the TypeScript SQL runtime types away from `JsNativeDatabaseLike` and define explicit portable types in `runtime.ts` or a small sibling module.
+
+Required shape:
+
+```ts
+type RuntimeSqlBindParam =
+  | { kind: "null" }
+  | { kind: "int"; intValue: number }
+  | { kind: "float"; floatValue: number }
+  | { kind: "text"; textValue: string }
+  | { kind: "blob"; blobValue: Uint8Array };
+
+interface RuntimeSqlQueryResult {
+  columns: string[];
+  rows: unknown[][];
+}
+
+interface RuntimeSqlExecuteResult {
+  columns: string[];
+  rows: unknown[][];
+  changes: number;
+  lastInsertRowId?: number | null;
+  route: "read" | "write" | "writeFallback";
+}
+
+interface RuntimeSqlRunResult {
+  changes: number;
+}
+```
+
+For this cleanup, preserve the current user-facing integer behavior. SQL integer values should continue to surface as numbers where they do today. Do not introduce new public bigint result semantics as part of the boundary cleanup.
+
+Acceptance criteria:
+
+- `runtime.ts` no longer imports `JsNativeDatabaseLike`.
+- NAPI and wasm SQL adapters both implement the same explicit SQL result types.
+- Existing `wrapJsNativeDatabase` behavior remains unchanged for user-facing database APIs.
+- Bigint, boolean, string, number, null, undefined, and `Uint8Array` SQL parameter normalization still works.
+- User-facing SQL integer result behavior remains unchanged from the current TypeScript API.
+- Typecheck passes.
+- Tests pass.
+
+### 3. Make Wasm Initialization First-Class
+
+Remove the need for edge examples to set `globalThis.__rivetkitWasmBindings`.
+
+Use one public wasm package import plus explicit host-provided initialization inputs. This follows the same broad pattern used by Prisma driver adapters and DuckDB-Wasm/sql.js-style initialization: keep the high-level user API stable, but let the host application provide the runtime-specific adapter or asset handle when packaging differs by environment.
+
+Supported configuration should remain:
+
+```ts
+setup({
+  runtime: "wasm",
+  wasm: {
+    initInput,
+  },
+  use: { counter },
+});
+```
+
+Add an explicit binding override as the first-class escape hatch:
+
+```ts
+wasm?: {
+  initInput?: WebAssembly.Module | BufferSource | URL | Response;
+  bindings?: typeof import("@rivetkit/rivetkit-wasm");
+}
+```
+
+`bindings` is a documented loader escape hatch, not a hidden global. The default path may still import `@rivetkit/rivetkit-wasm` internally when `bindings` is omitted.
+
+Cloudflare and Supabase should differ only in how they produce `initInput`, not in RivetKit actor/runtime semantics.
+
+Cloudflare example:
+
+```ts
+import * as rivetkitWasm from "@rivetkit/rivetkit-wasm";
+import wasmModule from "./rivetkit_wasm_bg.wasm";
+
+const registry = setup({
+  runtime: "wasm",
+  wasm: {
+    bindings: rivetkitWasm,
+    initInput: wasmModule,
+  },
+  use: { counter },
+});
+```
+
+Supabase/Deno example:
+
+```ts
+import * as rivetkitWasm from "@rivetkit/rivetkit-wasm";
+
+const wasmBytes = await Deno.readFile(
+  new URL("./rivetkit_wasm_bg.wasm", import.meta.url),
+);
+
+const registry = setup({
+  runtime: "wasm",
+  wasm: {
+    bindings: rivetkitWasm,
+    initInput: wasmBytes,
+  },
+  use: { counter },
+});
+```
+
+Do not add `@rivetkit/rivetkit-wasm/cloudflare` or `@rivetkit/rivetkit-wasm/deno` exports in this cleanup unless the single-export plus explicit `bindings`/`initInput` design fails in packaged-consumer tests. If a specialized export becomes necessary, document the packaging failure that requires it.
+
+Acceptance criteria:
+
+- `loadWasmRuntime` does not read `globalThis.__rivetkitWasmBindings`.
+- Cloudflare and Supabase examples use either package exports or `wasm.bindings`, not a global.
+- `@rivetkit/rivetkit-wasm` exposes one default public import path that can be passed as `wasm.bindings`.
+- Cloudflare passes a bundled `WebAssembly.Module` or equivalent as `wasm.initInput`.
+- Supabase/Deno passes wasm bytes, URL, `Response`, or equivalent as `wasm.initInput`.
+- Packaged-consumer smoke coverage imports only public package exports.
+- Typecheck passes.
+- Tests pass.
+
+### 4. Align NAPI And Wasm Serverless Registry State
+
+Port the NAPI serverless build state semantics to wasm.
+
+The required state machine is:
+
+```text
+Registering
+  -> BuildingServerless
+  -> Serverless
+  -> ShuttingDown
+  -> ShutDown
+```
+
+Concurrent first serverless requests must share one build or wait for the build to finish. Shutdown during build must cancel or tear down the newly built runtime without orphaning it.
+
+Acceptance criteria:
+
+- Wasm registry has a `BuildingServerless` equivalent.
+- Concurrent first requests do not fail with "already serving" while the runtime is building.
+- Shutdown during wasm serverless build leaves the registry in a terminal state.
+- NAPI and wasm return equivalent wrong-mode/shutdown errors for serve/serverless mode conflicts.
+- Add focused tests for concurrent first serverless requests and shutdown during build. These may use a delayed fake runtime builder to make the ordering deterministic.
+- Existing workerd and Supabase e2e checks continue to prove the real wasm runtime boots.
+- Typecheck passes.
+- Tests pass.
+
+### 5. Use `runtime.kind` For Runtime Resolution
+
+Replace concrete adapter checks with the interface discriminator.
+
+Acceptance criteria:
+
+- `loadedRuntimeKind` switches on `runtime.kind`.
+- No production runtime selection logic depends on `instanceof NapiCoreRuntime` or `instanceof WasmCoreRuntime`.
+- Fake runtimes in tests can use `kind: "napi"` or `kind: "wasm"` without constructing concrete adapter classes.
+- Typecheck passes.
+- Tests pass.
+
+### 6. Remove Wasm Parity Stubs
+
+Audit `@rivetkit/rivetkit-wasm` for methods that return placeholders or silently diverge from NAPI.
+
+Known issue:
+
+- `WasmQueue.maxSize()` currently returns `0`.
+
+Acceptance criteria:
+
+- `WasmQueue.maxSize()` returns the real core queue max size.
+- Add parity coverage for queue max size through both NAPI and wasm adapters.
+- Any unsupported wasm runtime method fails with an explicit structured unsupported-runtime error.
+- Typecheck passes.
+- Tests pass.
+
+### 7. Make Invalid Matrix Cells Visible
+
+The driver matrix should not silently drop an explicitly requested invalid cell.
+
+Acceptance criteria:
+
+- Default matrix excludes `runtime=wasm/sqlite=local`.
+- If a user explicitly requests `RIVETKIT_DRIVER_TEST_RUNTIME=wasm` and `RIVETKIT_DRIVER_TEST_SQLITE=local`, the suite fails fast with a clear configuration error.
+- Existing valid cells remain native/local/all encodings, native/remote/all encodings, and wasm/remote/all encodings.
+- Typecheck passes.
+- Tests pass.
+
+### 8. Add Platform Wasm Smoke Coverage
+
+Current workerd and Supabase smoke scripts live under `.agent/` and exercise the kitchen-sink app. Replace that with first-class platform smoke tests under the RivetKit test tree.
+
+Add a new platform test folder:
+
+```text
+rivetkit-typescript/packages/rivetkit/tests/platforms/
+  shared-registry.ts
+  shared-platform-harness.ts
+  cloudflare-workers.test.ts
+  supabase-functions.test.ts
+  deno.test.ts
+```
+
+The platform tests should share one minimal registry and actor. Keep it intentionally boring: a SQLite-backed counter actor with `increment` and `getCount` implemented with raw SQL. These tests should validate platform packaging and wasm runtime boot, not duplicate the full driver suite.
+
+Do not run these tests in the default unit or driver test path. Expose them through an explicit script, for example `test:platforms`, or a manual/nightly CI job.
+
+Use pinned `pnpm dlx` commands for platform CLIs. Do not depend on globally installed Wrangler or Supabase CLI versions.
+
+Engine startup should reuse the existing driver-suite shared engine mechanism. If the current helper in `tests/driver/shared-harness.ts` is too driver-specific, extract the engine start/release logic into a shared test utility and have both driver tests and platform tests use it.
+
+Acceptance criteria:
+
+- `tests/platforms/shared-registry.ts` defines the shared SQLite counter actor and registry factory.
+- The shared SQLite counter actor uses raw SQL rather than Drizzle.
+- Platform tests run from generated temporary app directories or committed minimal fixtures backed by shared source files. Avoid large committed scaffold output.
+- Platform tests are not included in the default test command.
+- Platform CLIs are launched with pinned `pnpm dlx` versions.
+- Cloudflare Workers test runs against real local workerd, for example through pinned `pnpm dlx wrangler@... dev --local`.
+- Supabase Functions test runs against real local pinned `pnpm dlx supabase@... functions serve`.
+- Deno test runs against plain local Deno without the Supabase CLI wrapper.
+- Platform tests reuse the driver-suite shared engine mechanism, or share an extracted engine utility with the driver suite.
+- Each platform test imports `rivetkit` and `@rivetkit/rivetkit-wasm` only through public package exports.
+- Each platform test uses the same public API shape users should copy: `setup({ runtime: "wasm", wasm: { bindings, initInput }, use })`.
+- Do not call lower-level registry builders, mutate `globalThis` loader hooks, or otherwise use test-only wasm runtime wiring in packaged-consumer app code.
+- Each platform test exercises the shared SQLite counter with at least one write and one readback.
+- Platform coverage includes multiple requests to the same actor, actor sleep and wake, and multiple actors running in parallel on the same platform instance.
+- The parallel actor check should use separate actor IDs. It should not rely on concurrent requests to one actor as the only concurrency signal.
+- Remote SQLite is used. Local SQLite is not allowed for these wasm platform tests.
+- Keep platform smoke intentionally small. Do not test raw HTTP, raw WebSocket, workflows, queues, or the full driver suite here.
+- Do not depend on repo-relative imports to `pkg`, `pkg-deno`, or `dist/tsup`.
+- Typecheck passes.
+- Tests pass.
+
+### 9. Update Public Edge Runtime Docs
+
+Document wasm runtime usage for Cloudflare Workers and Supabase Edge Functions in the public docs.
+
+Required docs:
+
+- Update the quickstart docs to point users at edge/serverless wasm setup.
+- Add or update `website/src/content/docs/connect/cloudflare.mdx` for Cloudflare Workers.
+- Update `website/src/content/docs/connect/supabase.mdx` with the Supabase Edge Functions setup instead of the placeholder.
+- If a new Connect page is added, update the sidebar source used by `website/src/sitemap/mod.ts`.
+
+Docs must use the same public API that tests and users use:
+
+```ts
+setup({
+  runtime: "wasm",
+  wasm: {
+    bindings,
+    initInput,
+  },
+  use: { counter },
+});
+```
+
+Acceptance criteria:
+
+- Cloudflare docs show how to pass the bundled wasm module or equivalent `initInput`.
+- Supabase docs show how to load and pass wasm bytes, URL, `Response`, or equivalent `initInput`.
+- Docs explain that wasm cannot use local SQLite and defaults to remote SQLite when SQLite config is unset.
+- Docs mention `runtime: "wasm"` and the `RIVETKIT_RUNTIME=wasm` env override.
+- Docs do not mention hidden globals, private generated paths, or lower-level registry builders.
+- Quickstart and Connect pages link to each other where appropriate.
+
+## Risks
+
+- Replacing `Buffer` at the runtime boundary is broad because actor glue currently assumes Node-compatible bytes in many places.
+- Edge package export behavior differs between Cloudflare, Deno/Supabase, Node, and bundlers. Keep public exports explicit and tested.
+- Serverless state-machine parity is correctness work, not cosmetic cleanup. Treat first-request concurrency as a real bug.
+- Some generated wasm-bindgen types may still expose `Uint8Array` or `bigint`; adapters should normalize those at the edge only.
+
+## Validation Plan
+
+Required local checks after the full cleanup:
+
+```bash
+pnpm --filter rivetkit check-types
+pnpm --filter rivetkit test tests/runtime-selection.test.ts
+pnpm --filter rivetkit test tests/driver/shared-matrix.test.ts
+scripts/cargo/check-rivetkit-core-wasm.sh
+cargo check -p rivetkit-core
+```
+
+Required e2e checks:
+
+- Driver suite valid cells for wasm/remote across bare, cbor, and json where wasm support is claimed.
+- Cloudflare Workers platform smoke using real local workerd through pinned `pnpm dlx wrangler@...` and the shared SQLite counter registry.
+- Supabase Functions platform smoke using real local `supabase functions serve` through pinned `pnpm dlx supabase@...` and the shared SQLite counter registry.
+- Deno platform smoke using real local Deno and the shared SQLite counter registry.
diff --git a/.agent/supabase-functions-kitchen-sink-serverless-e2e.ts b/.agent/supabase-functions-kitchen-sink-serverless-e2e.ts
new file mode 100644
index 0000000000..537052f8ef
--- /dev/null
+++ b/.agent/supabase-functions-kitchen-sink-serverless-e2e.ts
@@ -0,0 +1,456 @@
+import { spawn, type ChildProcess } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve, toNamespacedPath } from "node:path";
+import { pathToFileURL } from "node:url";
+import { createServer } from "node:net";
+import { createClient } from "../rivetkit-typescript/packages/rivetkit/dist/tsup/client/mod.js";
+
+const TOKEN = "dev";
+const HOST = "127.0.0.1";
+let lastEngineOutput = "";
+let lastFunctionOutput = "";
+
+function freePort(): Promise<number> {
+	return new Promise((resolvePort, reject) => {
+		const server = createServer();
+		server.once("error", reject);
+		server.listen(0, HOST, () => {
+			const address = server.address();
+			if (!address || typeof address === "string") {
+				server.close(() => reject(new Error("failed to allocate port")));
+				return;
+			}
+			const port = address.port;
+			server.close(() => resolvePort(port));
+		});
+	});
+}
+
+async function waitForOk(url: string, timeoutMs: number): Promise<void> {
+	const deadline = Date.now() + timeoutMs;
+	let lastError: unknown;
+	while (Date.now() < deadline) {
+		try {
+			const res = await fetchWithTimeout(url, undefined, 2_000);
+			if (res.ok) return;
+			lastError = new Error(`${res.status} ${await res.text()}`);
+		} catch (error) {
+			lastError = error;
+		}
+		await new Promise((resolve) => setTimeout(resolve, 250));
+	}
+	throw new Error(`timed out waiting for ${url}: ${String(lastError)}`);
+}
+
+async function readJson<T>(res: Response): Promise<T> {
+	const text = await res.text();
+	if (!res.ok) {
+		throw new Error(`${res.status} ${text}`);
+	}
+	return JSON.parse(text) as T;
+}
+
+async function fetchWithTimeout(
+	input: string,
+	init?: RequestInit,
+	timeoutMs = 15_000,
+): Promise<Response> {
+	const controller = new AbortController();
+	const timeout = setTimeout(() => controller.abort(), timeoutMs);
+	try {
+		return await fetch(input, { ...init, signal: init?.signal ?? controller.signal });
+	} finally {
+		clearTimeout(timeout);
+	}
+}
+
+function logStep(step: string, details?: Record<string, unknown>) {
+	console.error(JSON.stringify({ kind: "step", step, ...details }));
+}
+
+async function waitForWebSocketOpen(ws: WebSocket): Promise<void> {
+	if (ws.readyState === WebSocket.OPEN) return;
+	await new Promise<void>((resolveOpen, reject) => {
+		ws.addEventListener("open", () => resolveOpen(), { once: true });
+		ws.addEventListener("error", () => reject(new Error("websocket error")), {
+			once: true,
+		});
+		ws.addEventListener(
+			"close",
+			(event) =>
+				reject(
+					new Error(
+						`websocket closed before open code=${event.code} reason=${event.reason}`,
+					),
+				),
+			{ once: true },
+		);
+	});
+}
+
+async function nextJsonMessage<T>(ws: WebSocket, timeoutMs = 5_000): Promise<T> {
+	return await new Promise<T>((resolveMessage, reject) => {
+		const timeout = setTimeout(
+			() => reject(new Error("timed out waiting for websocket message")),
+			timeoutMs,
+		);
+		ws.addEventListener(
+			"message",
+			(event) => {
+				clearTimeout(timeout);
+				resolveMessage(JSON.parse(String(event.data)) as T);
+			},
+			{ once: true },
+		);
+		ws.addEventListener(
+			"close",
+			(event) => {
+				clearTimeout(timeout);
+				reject(
+					new Error(`websocket closed code=${event.code} reason=${event.reason}`),
+				);
+			},
+			{ once: true },
+		);
+	});
+}
+
+function spawnLogged(
+	command: string,
+	args: string[],
+	options: { cwd?: string; env?: NodeJS.ProcessEnv } = {},
+) {
+	return spawn(command, args, {
+		cwd: options.cwd,
+		env: { ...process.env, ...options.env },
+		stdio: ["ignore", "pipe", "pipe"],
+	});
+}
+
+async function stopChild(child: ChildProcess | undefined) {
+	if (!child || child.exitCode !== null) return;
+	child.kill("SIGTERM");
+	await new Promise((resolve) => setTimeout(resolve, 1000));
+	if (child.exitCode === null) {
+		child.kill("SIGKILL");
+	}
+}
+
+function fileUrl(path: string) {
+	return pathToFileURL(toNamespacedPath(path)).href;
+}
+
+async function main() {
+	const guardPort = await freePort();
+	const apiPeerPort = await freePort();
+	const metricsPort = await freePort();
+	const externalServiceUrl = process.env.SUPABASE_FUNCTION_URL;
+	const externalHealthUrl = process.env.SUPABASE_FUNCTION_HEALTH_URL;
+	const functionPort = externalServiceUrl ? undefined : await freePort();
+	const endpoint = `http://${HOST}:${guardPort}`;
+	const engineBindHost = externalServiceUrl ? "0.0.0.0" : HOST;
+	const enginePublicEndpoint =
+		process.env.SUPABASE_ENGINE_PUBLIC_ENDPOINT ??
+		(externalServiceUrl ? `http://host.docker.internal:${guardPort}` : endpoint);
+	const serviceUrl = externalServiceUrl ?? `http://${HOST}:${functionPort}/api/rivet`;
+	const functionHealthUrl =
+		externalHealthUrl ?? `http://${HOST}:${functionPort}/health`;
+	const namespace = `supabase-e2e-${randomUUID()}`;
+	const runnerName = `supabase-kitchen-sink-${randomUUID()}`;
+	const dbRoot = mkdtempSync(join(tmpdir(), "rivetkit-supabase-e2e-"));
+	const configPath = join(dbRoot, "engine.json");
+	const importMapPath = join(dbRoot, "deno.import_map.json");
+	let engine: ChildProcess | undefined;
+	let edgeFunction: ChildProcess | undefined;
+
+	try {
+		writeFileSync(
+			configPath,
+			JSON.stringify({
+				topology: {
+					datacenter_label: 1,
+					datacenters: {
+						default: {
+							datacenter_label: 1,
+							is_leader: true,
+							public_url: enginePublicEndpoint,
+							peer_url: `http://${HOST}:${apiPeerPort}`,
+						},
+					},
+				},
+			}),
+		);
+
+		writeFileSync(
+			importMapPath,
+			JSON.stringify({
+				imports: {
+					rivetkit: fileUrl(resolve("rivetkit-typescript/packages/rivetkit/dist/tsup/mod.js")),
+					"rivetkit/db": fileUrl(
+						resolve("rivetkit-typescript/packages/rivetkit/dist/tsup/db/mod.js"),
+					),
+					"@rivetkit/engine-envoy-protocol": fileUrl(
+						resolve("engine/sdks/typescript/envoy-protocol/dist/index.js"),
+					),
+					"@rivetkit/rivetkit-wasm": fileUrl(
+						resolve("rivetkit-typescript/packages/rivetkit-wasm/pkg-deno/rivetkit_wasm.js"),
+					),
+					"@rivetkit/virtual-websocket": fileUrl(
+						resolve("shared/typescript/virtual-websocket/dist/mod.js"),
+					),
+					"@rivetkit/workflow-engine": fileUrl(
+						resolve("rivetkit-typescript/packages/workflow-engine/dist/tsup/index.js"),
+					),
+					"@rivetkit/bare-ts": "npm:@rivetkit/bare-ts@^0.6.2",
+					"@rivetkit/bare-ts/": "npm:@rivetkit/bare-ts@^0.6.2/",
+					"@rivet-dev/agent-os-core": "npm:@rivet-dev/agent-os-core@^0.1.1",
+					"cbor-x": "npm:cbor-x@^1.6.0",
+					"crypto": "node:crypto",
+					"drizzle-orm/sqlite-core": "npm:drizzle-orm@^0.44.2/sqlite-core",
+					"drizzle-orm/sqlite-proxy": "npm:drizzle-orm@^0.44.2/sqlite-proxy",
+					"drizzle-orm/": "npm:drizzle-orm@^0.44.2/",
+					hono: "npm:hono@^4.11.3",
+					"hono/ws": "npm:hono@^4.11.3/ws",
+					"hono/": "npm:hono@^4.11.3/",
+					invariant: "npm:invariant@^2.2.4",
+					module: "node:module",
+					"p-retry": "npm:p-retry@^6.2.1",
+					"path/posix": "node:path/posix",
+					pino: "npm:pino@^9.5.0",
+					vbare: "npm:vbare@^0.0.4",
+					zod: "npm:zod@^4.1.0",
+					"zod/v4": "npm:zod@^4.1.0/v4",
+					"zod/": "npm:zod@^4.1.0/",
+				},
+			}),
+		);
+
+		engine = spawnLogged(resolve("target/debug/rivet-engine"), [
+			"--config",
+			configPath,
+			"start",
+		], {
+			env: {
+				RIVET__GUARD__HOST: engineBindHost,
+				RIVET__GUARD__PORT: guardPort.toString(),
+				RIVET__API_PEER__HOST: HOST,
+				RIVET__API_PEER__PORT: apiPeerPort.toString(),
+				RIVET__METRICS__HOST: HOST,
+				RIVET__METRICS__PORT: metricsPort.toString(),
+				RIVET__FILE_SYSTEM__PATH: join(dbRoot, "db"),
+			},
+		});
+		engine.stdout?.on("data", (chunk) => {
+			lastEngineOutput += chunk.toString();
+		});
+		engine.stderr?.on("data", (chunk) => {
+			lastEngineOutput += chunk.toString();
+		});
+
+		logStep("wait-engine", { endpoint });
+		await waitForOk(`${endpoint}/health`, 90_000);
+
+		if (!externalServiceUrl) {
+			edgeFunction = spawnLogged("deno", [
+				"run",
+				"--allow-all",
+				"--no-config",
+				"--no-lock",
+				"--node-modules-dir=none",
+				"--import-map",
+				importMapPath,
+				resolve("examples/kitchen-sink/supabase/functions/rivetkit/index.ts"),
+			], {
+				cwd: dbRoot,
+				env: {
+					CI: "1",
+					PORT: functionPort?.toString(),
+					HOST,
+					RIVET_LOG_LEVEL: "debug",
+				},
+			});
+			edgeFunction.stdout?.on("data", (chunk) => {
+				lastFunctionOutput += chunk.toString();
+			});
+			edgeFunction.stderr?.on("data", (chunk) => {
+				lastFunctionOutput += chunk.toString();
+			});
+		}
+
+		logStep("wait-supabase-function", { serviceUrl });
+		await waitForOk(functionHealthUrl, 120_000);
+
+		logStep("metadata");
+		const serviceMetadata = await readJson<{ runtime: string }>(
+			await fetchWithTimeout(`${serviceUrl}/metadata`),
+		);
+		if (serviceMetadata.runtime !== "rivetkit") {
+			throw new Error(`unexpected metadata runtime ${serviceMetadata.runtime}`);
+		}
+
+		logStep("create-namespace", { namespace });
+		await readJson(
+			await fetchWithTimeout(`${endpoint}/namespaces`, {
+				method: "POST",
+				headers: {
+					Authorization: `Bearer ${TOKEN}`,
+					"Content-Type": "application/json",
+				},
+				body: JSON.stringify({ name: namespace, display_name: namespace }),
+			}),
+		);
+
+		logStep("get-datacenters", { namespace });
+		const datacenters = await readJson<{ datacenters: Array<{ name: string }> }>(
+			await fetchWithTimeout(`${endpoint}/datacenters?namespace=${namespace}`, {
+				headers: { Authorization: `Bearer ${TOKEN}` },
+			}),
+		);
+		const dc = datacenters.datacenters[0]?.name;
+		if (!dc) throw new Error("engine returned no datacenters");
+
+		logStep("serverless-health-check", { serviceUrl });
+		const healthCheck = await readJson<{ success?: { version: string }; failure?: unknown }>(
+			await fetchWithTimeout(
+				`${endpoint}/runner-configs/serverless-health-check?namespace=${namespace}`,
+				{
+					method: "POST",
+					headers: {
+						Authorization: `Bearer ${TOKEN}`,
+						"Content-Type": "application/json",
+					},
+					body: JSON.stringify({ url: serviceUrl, headers: {} }),
+				},
+				30_000,
+			),
+		);
+		if (!("success" in healthCheck)) {
+			throw new Error(`serverless health check failed: ${JSON.stringify(healthCheck)}`);
+		}
+
+		logStep("put-runner-config", { runnerName, dc });
+		await readJson(
+			await fetchWithTimeout(
+				`${endpoint}/runner-configs/${encodeURIComponent(runnerName)}?namespace=${namespace}`,
+				{
+					method: "PUT",
+					headers: {
+						Authorization: `Bearer ${TOKEN}`,
+						"Content-Type": "application/json",
+					},
+					body: JSON.stringify({
+						datacenters: {
+							[dc]: {
+								serverless: {
+									url: serviceUrl,
+									headers: { "x-rivet-token": TOKEN },
+									request_lifespan: 30,
+									max_concurrent_actors: 8,
+									drain_grace_period: 10,
+									slots_per_runner: 8,
+									min_runners: 0,
+									max_runners: 8,
+									runners_margin: 0,
+									metadata_poll_interval: 1000,
+								},
+								drain_on_version_upgrade: true,
+							},
+						},
+					}),
+				},
+			),
+		);
+
+		const client = createClient<any>({
+			endpoint,
+			namespace,
+			token: TOKEN,
+			poolName: runnerName,
+			disableMetadataLookup: true,
+		});
+		try {
+			logStep("counter-action");
+			const count = await client.counter
+				.getOrCreate(["supabase-counter"])
+				.increment(7);
+			if (count !== 7) {
+				throw new Error(`expected counter result 7, received ${count}`);
+			}
+
+			logStep("sqlite-action");
+			const sqliteActor = client.testCounterSqlite.getOrCreate(["supabase-sqlite"]);
+			const sqliteCount = await sqliteActor.increment(11);
+			if (sqliteCount !== 11) {
+				throw new Error(`expected sqlite count 11, received ${sqliteCount}`);
+			}
+			const sqliteReadback = await sqliteActor.getCount();
+			if (sqliteReadback !== 11) {
+				throw new Error(`expected sqlite readback 11, received ${sqliteReadback}`);
+			}
+
+			logStep("raw-http");
+			const httpResponse = await client.rawHttpActor
+				.getOrCreate(["supabase-http"])
+				.fetch("api/hello");
+			const httpBody = await readJson<{ message: string }>(httpResponse);
+			if (httpBody.message !== "Hello from actor!") {
+				throw new Error(`unexpected raw HTTP body ${JSON.stringify(httpBody)}`);
+			}
+
+			logStep("raw-websocket");
+			const ws = await client.rawWebSocketActor
+				.getOrCreate(["supabase-websocket"])
+				.webSocket();
+			try {
+				await waitForWebSocketOpen(ws);
+				const welcome = await nextJsonMessage<{ type: string }>(ws);
+				if (welcome.type !== "welcome") {
+					throw new Error(`unexpected websocket welcome ${JSON.stringify(welcome)}`);
+				}
+				ws.send(JSON.stringify({ type: "ping" }));
+				const pong = await nextJsonMessage<{ type: string }>(ws);
+				if (pong.type !== "pong") {
+					throw new Error(`unexpected websocket pong ${JSON.stringify(pong)}`);
+				}
+			} finally {
+				ws.close();
+			}
+		} finally {
+			await client.dispose();
+		}
+
+		console.log(
+			JSON.stringify({
+				ok: true,
+				endpoint,
+				namespace,
+				runnerName,
+				serviceUrl,
+			}),
+		);
+
+		if (engine.exitCode !== null) {
+			throw new Error(`engine exited early:\n${lastEngineOutput}`);
+		}
+		if (edgeFunction && edgeFunction.exitCode !== null) {
+			throw new Error(`Supabase function exited early:\n${lastFunctionOutput}`);
+		}
+	} finally {
+		await stopChild(edgeFunction);
+		await stopChild(engine);
+		rmSync(dbRoot, { recursive: true, force: true });
+	}
+}
+
+main()
+	.then(() => process.exit(0))
+	.catch((error) => {
+		console.error(error);
+		console.error("=== supabase function output ===");
+		console.error(lastFunctionOutput);
+		console.error("=== engine output ===");
+		console.error(lastEngineOutput);
+		process.exit(1);
+	});
diff --git a/.agent/workerd-kitchen-sink-serverless-e2e.ts b/.agent/workerd-kitchen-sink-serverless-e2e.ts
new file mode 100644
index 0000000000..bd478f7c63
--- /dev/null
+++ b/.agent/workerd-kitchen-sink-serverless-e2e.ts
@@ -0,0 +1,420 @@
+import { spawn, type ChildProcess } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { createServer } from "node:net";
+import { createClient } from "../rivetkit-typescript/packages/rivetkit/dist/tsup/client/mod.js";
+import type { registry } from "../examples/kitchen-sink/src/index.ts";
+
+const TOKEN = "dev";
+const HOST = "127.0.0.1";
+const WRANGLER_VERSION = "4.86.0";
+let lastEngineOutput = "";
+let lastWorkerdOutput = "";
+
+function freePort(): Promise<number> {
+	return new Promise((resolvePort, reject) => {
+		const server = createServer();
+		server.once("error", reject);
+		server.listen(0, HOST, () => {
+			const address = server.address();
+			if (!address || typeof address === "string") {
+				server.close(() => reject(new Error("failed to allocate port")));
+				return;
+			}
+			const port = address.port;
+			server.close(() => resolvePort(port));
+		});
+	});
+}
+
+async function waitForOk(url: string, timeoutMs: number): Promise<void> {
+	const deadline = Date.now() + timeoutMs;
+	let lastError: unknown;
+	while (Date.now() < deadline) {
+		try {
+			const res = await fetchWithTimeout(url, undefined, 2_000);
+			if (res.ok) return;
+			lastError = new Error(`${res.status} ${await res.text()}`);
+		} catch (error) {
+			lastError = error;
+		}
+		await new Promise((resolve) => setTimeout(resolve, 250));
+	}
+	throw new Error(`timed out waiting for ${url}: ${String(lastError)}`);
+}
+
+async function readJson<T>(res: Response): Promise<T> {
+	const text = await res.text();
+	if (!res.ok) {
+		throw new Error(`${res.status} ${text}`);
+	}
+	return JSON.parse(text) as T;
+}
+
+async function fetchWithTimeout(
+	input: string,
+	init?: RequestInit,
+	timeoutMs = 15_000,
+): Promise<Response> {
+	const controller = new AbortController();
+	const timeout = setTimeout(() => controller.abort(), timeoutMs);
+	try {
+		return await fetch(input, { ...init, signal: init?.signal ?? controller.signal });
+	} finally {
+		clearTimeout(timeout);
+	}
+}
+
+function logStep(step: string, details?: Record<string, unknown>) {
+	console.error(JSON.stringify({ kind: "step", step, ...details }));
+}
+
+async function waitForWebSocketOpen(ws: WebSocket): Promise<void> {
+	if (ws.readyState === WebSocket.OPEN) return;
+	await new Promise<void>((resolve, reject) => {
+		ws.addEventListener("open", () => resolve(), { once: true });
+		ws.addEventListener("error", () => reject(new Error("websocket error")), {
+			once: true,
+		});
+		ws.addEventListener(
+			"close",
+			(event) =>
+				reject(
+					new Error(
+						`websocket closed before open code=${event.code} reason=${event.reason}`,
+					),
+				),
+			{ once: true },
+		);
+	});
+}
+
+async function nextJsonMessage<T>(ws: WebSocket, timeoutMs = 5_000): Promise<T> {
+	return await new Promise<T>((resolve, reject) => {
+		const timeout = setTimeout(
+			() => reject(new Error("timed out waiting for websocket message")),
+			timeoutMs,
+		);
+		ws.addEventListener(
+			"message",
+			(event) => {
+				clearTimeout(timeout);
+				resolve(JSON.parse(String(event.data)) as T);
+			},
+			{ once: true },
+		);
+		ws.addEventListener(
+			"close",
+			(event) => {
+				clearTimeout(timeout);
+				reject(
+					new Error(`websocket closed code=${event.code} reason=${event.reason}`),
+				);
+			},
+			{ once: true },
+		);
+	});
+}
+
+function spawnLogged(
+	command: string,
+	args: string[],
+	options: { env?: NodeJS.ProcessEnv } = {},
+) {
+	const child = spawn(command, args, {
+		env: { ...process.env, ...options.env },
+		stdio: ["ignore", "pipe", "pipe"],
+	});
+	return child;
+}
+
+async function stopChild(child: ChildProcess | undefined) {
+	if (!child || child.exitCode !== null) return;
+	child.kill("SIGTERM");
+	await new Promise((resolve) => setTimeout(resolve, 1000));
+	if (child.exitCode === null) {
+		child.kill("SIGKILL");
+	}
+}
+
+async function main() {
+	const guardPort = await freePort();
+	const apiPeerPort = await freePort();
+	const metricsPort = await freePort();
+	const workerdPort = await freePort();
+	const endpoint = `http://${HOST}:${guardPort}`;
+	const serviceUrl = `http://${HOST}:${workerdPort}/api/rivet`;
+	const namespace = `workerd-e2e-${randomUUID()}`;
+	const runnerName = `workerd-kitchen-sink-${randomUUID()}`;
+	const dbRoot = mkdtempSync(join(tmpdir(), "rivetkit-workerd-e2e-"));
+	const configPath = join(dbRoot, "engine.json");
+	const wranglerConfigPath = join(dbRoot, "wrangler.toml");
+	let engine: ChildProcess | undefined;
+	let workerd: ChildProcess | undefined;
+
+	try {
+		writeFileSync(
+			configPath,
+			JSON.stringify({
+				topology: {
+					datacenter_label: 1,
+					datacenters: {
+						default: {
+							datacenter_label: 1,
+							is_leader: true,
+							public_url: endpoint,
+							peer_url: `http://${HOST}:${apiPeerPort}`,
+						},
+					},
+				},
+			}),
+		);
+
+		writeFileSync(
+			wranglerConfigPath,
+			[
+				'name = "rivetkit-kitchen-sink-workerd-e2e"',
+				'main = "./repo/examples/kitchen-sink/src/cloudflare.ts"',
+				'compatibility_date = "2026-05-01"',
+				'compatibility_flags = ["nodejs_compat"]',
+				"",
+				"[[rules]]",
+				'type = "CompiledWasm"',
+				'globs = ["**/*.wasm"]',
+				"fallthrough = true",
+				"",
+			].join("\n"),
+		);
+
+		const repoLink = join(dbRoot, "repo");
+		await import("node:fs/promises").then((fs) =>
+			fs.symlink(resolve("."), repoLink, "dir"),
+		);
+
+		engine = spawnLogged(resolve("target/debug/rivet-engine"), [
+			"--config",
+			configPath,
+			"start",
+		], {
+			env: {
+				RIVET__GUARD__HOST: HOST,
+				RIVET__GUARD__PORT: guardPort.toString(),
+				RIVET__API_PEER__HOST: HOST,
+				RIVET__API_PEER__PORT: apiPeerPort.toString(),
+				RIVET__METRICS__HOST: HOST,
+				RIVET__METRICS__PORT: metricsPort.toString(),
+				RIVET__FILE_SYSTEM__PATH: join(dbRoot, "db"),
+			},
+		});
+		engine.stdout?.on("data", (chunk) => {
+			lastEngineOutput += chunk.toString();
+		});
+		engine.stderr?.on("data", (chunk) => {
+			lastEngineOutput += chunk.toString();
+		});
+
+		logStep("wait-engine", { endpoint });
+		await waitForOk(`${endpoint}/health`, 90_000);
+
+		workerd = spawnLogged("npx", [
+			"-y",
+			`wrangler@${WRANGLER_VERSION}`,
+			"dev",
+			"--config",
+			wranglerConfigPath,
+			"--ip",
+			HOST,
+			"--port",
+			workerdPort.toString(),
+			"--local",
+		], {
+			env: {
+				CI: "1",
+				WRANGLER_SEND_METRICS: "false",
+				RIVET_LOG_LEVEL: "debug",
+			},
+		});
+		workerd.stdout?.on("data", (chunk) => {
+			lastWorkerdOutput += chunk.toString();
+		});
+		workerd.stderr?.on("data", (chunk) => {
+			lastWorkerdOutput += chunk.toString();
+		});
+
+		logStep("wait-workerd", { serviceUrl });
+		await waitForOk(`http://${HOST}:${workerdPort}/health`, 120_000);
+
+		logStep("metadata");
+		const serviceMetadata = await readJson<{ runtime: string }>(
+			await fetchWithTimeout(`${serviceUrl}/metadata`),
+		);
+		if (serviceMetadata.runtime !== "rivetkit") {
+			throw new Error(`unexpected metadata runtime ${serviceMetadata.runtime}`);
+		}
+
+		logStep("create-namespace", { namespace });
+		await readJson(
+			await fetchWithTimeout(`${endpoint}/namespaces`, {
+				method: "POST",
+				headers: {
+					Authorization: `Bearer ${TOKEN}`,
+					"Content-Type": "application/json",
+				},
+				body: JSON.stringify({ name: namespace, display_name: namespace }),
+			}),
+		);
+
+		logStep("get-datacenters", { namespace });
+		const datacenters = await readJson<{ datacenters: Array<{ name: string }> }>(
+			await fetchWithTimeout(`${endpoint}/datacenters?namespace=${namespace}`, {
+				headers: { Authorization: `Bearer ${TOKEN}` },
+			}),
+		);
+		const dc = datacenters.datacenters[0]?.name;
+		if (!dc) throw new Error("engine returned no datacenters");
+
+		logStep("serverless-health-check", { serviceUrl });
+		const healthCheck = await readJson<{ success?: { version: string }; failure?: unknown }>(
+			await fetchWithTimeout(
+				`${endpoint}/runner-configs/serverless-health-check?namespace=${namespace}`,
+				{
+					method: "POST",
+					headers: {
+						Authorization: `Bearer ${TOKEN}`,
+						"Content-Type": "application/json",
+					},
+					body: JSON.stringify({ url: serviceUrl, headers: {} }),
+				},
+				30_000,
+			),
+		);
+		if (!("success" in healthCheck)) {
+			throw new Error(`serverless health check failed: ${JSON.stringify(healthCheck)}`);
+		}
+
+		logStep("put-runner-config", { runnerName, dc });
+		await readJson(
+			await fetchWithTimeout(
+				`${endpoint}/runner-configs/${encodeURIComponent(runnerName)}?namespace=${namespace}`,
+				{
+					method: "PUT",
+					headers: {
+						Authorization: `Bearer ${TOKEN}`,
+						"Content-Type": "application/json",
+					},
+					body: JSON.stringify({
+						datacenters: {
+							[dc]: {
+								serverless: {
+									url: serviceUrl,
+									headers: { "x-rivet-token": TOKEN },
+									request_lifespan: 30,
+									max_concurrent_actors: 8,
+									drain_grace_period: 10,
+									slots_per_runner: 8,
+									min_runners: 0,
+									max_runners: 8,
+									runners_margin: 0,
+									metadata_poll_interval: 1000,
+								},
+								drain_on_version_upgrade: true,
+							},
+						},
+					}),
+				},
+			),
+		);
+
+		const client = createClient<typeof registry>({
+			endpoint,
+			namespace,
+			token: TOKEN,
+			poolName: runnerName,
+			disableMetadataLookup: true,
+		});
+		try {
+			logStep("counter-action");
+			const count = await client.counter
+				.getOrCreate(["workerd-counter"])
+				.increment(7);
+			if (count !== 7) {
+				throw new Error(`expected counter result 7, received ${count}`);
+			}
+
+			logStep("sqlite-action");
+			const sqliteActor = client.testCounterSqlite.getOrCreate(["workerd-sqlite"]);
+			const sqliteCount = await sqliteActor.increment(11);
+			if (sqliteCount !== 11) {
+				throw new Error(`expected sqlite count 11, received ${sqliteCount}`);
+			}
+			const sqliteReadback = await sqliteActor.getCount();
+			if (sqliteReadback !== 11) {
+				throw new Error(`expected sqlite readback 11, received ${sqliteReadback}`);
+			}
+
+			logStep("raw-http");
+			const httpResponse = await client.rawHttpActor
+				.getOrCreate(["workerd-http"])
+				.fetch("api/hello");
+			const httpBody = await readJson<{ message: string }>(httpResponse);
+			if (httpBody.message !== "Hello from actor!") {
+				throw new Error(`unexpected raw HTTP body ${JSON.stringify(httpBody)}`);
+			}
+
+			logStep("raw-websocket");
+			const ws = await client.rawWebSocketActor
+				.getOrCreate(["workerd-websocket"])
+				.webSocket();
+			try {
+				await waitForWebSocketOpen(ws);
+				const welcome = await nextJsonMessage<{ type: string }>(ws);
+				if (welcome.type !== "welcome") {
+					throw new Error(`unexpected websocket welcome ${JSON.stringify(welcome)}`);
+				}
+				ws.send(JSON.stringify({ type: "ping" }));
+				const pong = await nextJsonMessage<{ type: string }>(ws);
+				if (pong.type !== "pong") {
+					throw new Error(`unexpected websocket pong ${JSON.stringify(pong)}`);
+				}
+			} finally {
+				ws.close();
+			}
+		} finally {
+			await client.dispose();
+		}
+
+		console.log(
+			JSON.stringify({
+				ok: true,
+				endpoint,
+				namespace,
+				runnerName,
+				serviceUrl,
+			}),
+		);
+
+		if (engine.exitCode !== null) {
+			throw new Error(`engine exited early:\n${lastEngineOutput}`);
+		}
+		if (workerd.exitCode !== null) {
+			throw new Error(`workerd exited early:\n${lastWorkerdOutput}`);
+		}
+	} finally {
+		await stopChild(workerd);
+		await stopChild(engine);
+		rmSync(dbRoot, { recursive: true, force: true });
+	}
+}
+
+main()
+	.then(() => process.exit(0))
+	.catch((error) => {
+		console.error(error);
+		console.error("=== workerd output ===");
+		console.error(lastWorkerdOutput);
+		console.error("=== engine output ===");
+		console.error(lastEngineOutput);
+		process.exit(1);
+	});
diff --git a/.github/workflows/publish.yaml b/.github/workflows/publish.yaml
index c2ecb41863..edd6cdf163 100644
--- a/.github/workflows/publish.yaml
+++ b/.github/workflows/publish.yaml
@@ -79,7 +79,7 @@ jobs:
           fi
 
   # ---------------------------------------------------------------------------
-  # build — matrix of 10 native/engine artifacts (11 on release for Windows)
+  # build — matrix of native/engine artifacts
   # ---------------------------------------------------------------------------
   build:
     needs: [context]
@@ -232,6 +232,45 @@ jobs:
           path: artifacts/${{ matrix.artifact }}
           if-no-files-found: error
 
+  # ---------------------------------------------------------------------------
+  # build-wasm — wasm package artifact built in parallel with native artifacts
+  # ---------------------------------------------------------------------------
+  build-wasm:
+    needs: [context]
+    name: "Build rivetkit-wasm"
+    if: needs.context.outputs.is_fork != 'true'
+    runs-on: depot-ubuntu-24.04-8
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          lfs: ${{ needs.context.outputs.trigger == 'release' }}
+      - run: corepack enable
+      - uses: actions/setup-node@v4
+        with:
+          node-version: "22"
+          cache: pnpm
+      - uses: actions-rust-lang/setup-rust-toolchain@v1
+        with:
+          toolchain: stable
+          target: wasm32-unknown-unknown
+          rustflags: ""
+      - uses: Swatinem/rust-cache@v2
+        with:
+          shared-key: "rivetkit-wasm-publish"
+          cache-on-failure: true
+      - name: Install wasm package dependencies
+        run: pnpm install --frozen-lockfile --filter=@rivetkit/rivetkit-wasm
+      - name: Build wasm package
+        run: pnpm --filter=@rivetkit/rivetkit-wasm build
+      - name: Upload wasm package artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: wasm-package
+          path: rivetkit-typescript/packages/rivetkit-wasm/pkg
+          if-no-files-found: error
+
   # ---------------------------------------------------------------------------
   # docker-images — per-arch runtime images pushed to Docker Hub
   # ---------------------------------------------------------------------------
@@ -298,12 +337,13 @@ jobs:
   # publish — npm publish + R2 upload + Docker manifest + release tail
   # ---------------------------------------------------------------------------
   publish:
-    needs: [context, build, docker-images]
+    needs: [context, build, build-wasm, docker-images]
     name: "Publish"
     if: |
       !cancelled() &&
       needs.context.outputs.is_fork != 'true' &&
       needs.build.result == 'success' &&
+      needs.build-wasm.result == 'success' &&
       needs.docker-images.result == 'success'
     runs-on: depot-ubuntu-24.04-8
     permissions:
@@ -343,6 +383,16 @@ jobs:
           path: engine-artifacts
           pattern: engine-*
           merge-multiple: true
+      - name: Download wasm package artifact
+        uses: actions/download-artifact@v4
+        with:
+          name: wasm-package
+          path: rivetkit-typescript/packages/rivetkit-wasm/pkg
+      - name: Validate wasm package artifact
+        run: |
+          test -f rivetkit-typescript/packages/rivetkit-wasm/pkg/rivetkit_wasm.js
+          test -f rivetkit-typescript/packages/rivetkit-wasm/pkg/rivetkit_wasm.d.ts
+          test -f rivetkit-typescript/packages/rivetkit-wasm/pkg/rivetkit_wasm_bg.wasm
 
       - name: Place native binaries in platform packages
         run: |
@@ -397,7 +447,9 @@ jobs:
 
       # ---- build TypeScript packages (turbo dep graph picks up native) ----
       - name: Build TypeScript packages
-        run: pnpm build -F rivetkit -F '@rivetkit/*' -F '!@rivetkit/shared-data' -F '!@rivetkit/engine-frontend' -F '!@rivetkit/mcp-hub' -F '!@rivetkit/rivetkit-napi'
+        env:
+          SKIP_WASM_BUILD: "1"
+        run: pnpm build -F rivetkit -F '@rivetkit/*' -F '!@rivetkit/shared-data' -F '!@rivetkit/engine-frontend' -F '!@rivetkit/mcp-hub' -F '!@rivetkit/rivetkit-napi' -F '!@rivetkit/rivetkit-wasm'
 
       # ---- shared publish (runs for all triggers) ----
       - name: Finalize package versions for publish
diff --git a/CLAUDE.md b/CLAUDE.md
index 318949b4f9..7db3338543 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -22,6 +22,8 @@ Design constraints, invariants, and reference commands for the Rivet monorepo. F
 
 **Always use versioned BARE (`vbare`) instead of raw `serde_bare` for any persisted or wire-format encoding unless explicitly told otherwise.** Raw `serde_bare::to_vec` / `from_slice` has no version header, so any future schema change forces hand-rolled `LegacyXxx` fallback structs. `vbare::OwnedVersionedData` plus a versioned `*.bare` schema is the standard pattern. Acceptable raw-bare exceptions: ephemeral in-memory encodings that never cross a process boundary or hit disk, and wire formats whose protocol version is coordinated out-of-band (e.g. an HTTP path like `/v{PROTOCOL_VERSION}/...` or another channel that pins both peers to one schema per call).
 
+- Avoid raw `f64` fields in vbare protocol schemas that use hashable maps; generated Rust derives `Eq`/`Hash`, so encode floats as fixed bytes or an ordered wrapper.
+
 When talking about "Rivet Actors" make sure to capitalize "Rivet Actor" as a proper noun and lowercase "actor" as a generic noun.
 
 ## Commands
@@ -90,6 +92,13 @@ docker-compose up -d
 ## Dependency Management
 
 - Prefer the Tokio-shaped APIs from `antiox` (`antiox/sync/mpsc`, `antiox/task`, etc.) over ad hoc Promise queues, custom channel wrappers, or event-emitter coordination.
+- `rivet-envoy-client` transport features are mutually exclusive; native builds use the default `native-transport`, while wasm builds must set `default-features = false` and enable `wasm-transport`.
+- `rivet-envoy-client` wasm WebSocket code lives behind `target_arch = "wasm32"` with a native-host `wasm-transport` stub so feature checks do not compile browser APIs on developer machines.
+- `rivetkit-core` wasm builds use `--no-default-features --features wasm-runtime,sqlite-remote`; keep native process and runner-config HTTP code behind `native-runtime`.
+- Core-owned lifecycle tasks in `rivetkit-core` should spawn through `RuntimeSpawner` so native builds use Send-capable tasks and wasm builds use local tasks.
+- `rivet-envoy-client::async_counter::AsyncCounter` is the shared HTTP request counter type consumed by core sleep logic; do not pull `rivet-util` into core for that counter.
+- For `wasm32-unknown-unknown` Rust checks, use target-specific minimal Tokio plus `getrandom/js` and `uuid/js`; scan production dependencies with `cargo tree -e normal` so dev-dependencies do not create false native-dependency hits.
+- Use `scripts/cargo/check-rivetkit-core-wasm.sh` as the canonical wasm gate for `rivetkit-core`; it checks the wasm build, scans native dependency leaks, and verifies native transport/runtime features fail on wasm.
 - The high-level `rivetkit` crate stays a thin typed wrapper over `rivetkit-core` and re-exports shared transport/config types instead of redefining them.
 - When `rivetkit` needs ergonomic helpers on a `rivetkit-core` type it re-exports, prefer an extension trait plus `prelude` re-export instead of wrapping and replacing the core type.
 - `engine/sdks/*/api-*` are auto-generated SDK outputs; update the source API schema and regenerate them instead of editing them by hand.
@@ -98,6 +107,7 @@ docker-compose up -d
 
 - Core tests that touch the `_RIVET_TEST_INSPECTOR_TOKEN` env override must share a process-wide lock with startup tests that assert inspector-token initialization side effects; otherwise parallel `cargo test` runs can flip `init_inspector_token(...)` between the env-override no-op path and the KV-backed path.
 - For the fast static/http/bare driver verifier, pass only the files listed under `## Fast Tests` in `.agent/notes/driver-test-progress.md`; `tests/driver/*.test.ts` also pulls in slow-suite files and gives bogus gate failures.
+- Wasm host smoke tests can drive `buildNativeFactory` through `WasmCoreRuntime` fake bindings to cover actor callbacks, KV, state serialization, remote SQLite routing, and NAPI import boundaries without checked-in wasm-pack output.
 - When moving Rust inline tests out of `src/`, keep a tiny source-owned `#[cfg(test)] #[path = "..."] mod tests;` shim so the moved file still has private module access without widening runtime visibility. Prefer a dedicated moved-test file per source module; reusing stale shared `tests/modules/*.rs` files can silently rot against private APIs and explode once you wire them back in.
 - Tracing assertions on spawned Rust futures should bind an explicit `tracing::Dispatch` with `.with_subscriber(...)` on the spawned future; thread-local `set_default(...)` can miss the real logs in full async suite runs.
 
@@ -108,6 +118,9 @@ docker-compose up -d
 - Native SQLite VFS recent-page preload hints are actor-side Rust state surfaced by `NativeDatabase::snapshot_preload_hints()`; persist and consume them through runtime/envoy wiring, not JS APIs.
 - SQLite VFS file handles must enforce their reader or writer role; reader-owned handles fail closed on mutating callbacks.
 - Native SQLite single-statement work should route through the native execute path; keep `exec` as the multi-statement compatibility path.
+- Pegboard-envoy remote SQL execution should use `rivetkit-sqlite::database::open_database_from_engine` instead of direct `rusqlite` calls so native routing policy stays shared.
+- Pegboard-envoy remote SQL executor caches should use `Arc<OnceCell<NativeDatabaseHandle>>` values so first-use initialization stays lazy and single-flight per `(actor_id, sqlite_generation)`.
+- Sent remote SQL requests must fail with `sqlite.remote_indeterminate_result` on WebSocket disconnect; only unsent remote SQL may be sent after reconnect.
 - Native SQLite manual transactions keep an idle writer open until autocommit returns; route subsequent work through the writer instead of reader classification.
 - Native SQLite read mode may hold multiple read-only connections, while write mode must hold exactly one writable connection and no readers; TypeScript must not be the routing policy boundary.
 - For NAPI bridge wiring (TSF callback layout, cancellation tokens, `#[napi(object)]` rules), see `docs-internal/engine/napi-bridge.md`.
@@ -139,6 +152,7 @@ When the user asks to track something in a note, store it in `.agent/notes/` by
 - rivetkit-napi must be pure bindings. If code would be duplicated by a future V8 runtime, it belongs in rivetkit-core instead.
 - rivetkit-napi serves through `CoreRegistry` + `NapiActorFactory`; do not reintroduce the deleted `BridgeCallbacks` JSON-envelope envoy path or `startEnvoy*Js` exports.
 - NAPI `ActorContext.sql()` returns `JsNativeDatabase` directly; do not reintroduce a standalone `SqliteDb` wrapper export.
+- TypeScript runtime adapters expose `CoreRuntime` from `rivetkit/src/registry/runtime.ts`; keep raw `@rivetkit/rivetkit-napi` and future `@rivetkit/rivetkit-wasm` imports inside `src/registry/*-runtime.ts`.
 - rivetkit (Rust) is a thin typed wrapper. If it does more than deserialize, delegate to core, and serialize, the logic should move to rivetkit-core.
 - rivetkit (TypeScript) owns only: workflow engine, agent-os, client library, Zod schema validation for user-defined types, and actor definition types.
 - Errors use universal `RivetError` (group/code/message/metadata) at all boundaries. No custom error classes in TS.
@@ -277,6 +291,7 @@ When the user asks to track something in a note, store it in `.agent/notes/` by
 - Only add design constraints, invariants, and non-obvious rules that shape how new code should be written. Do not add general trivia, current implementation wiring, KV-key layouts, module organization, API signatures, ephemeral migration state, or anything a reader can learn by reading the code. That content belongs in module doc-comments, `docs-internal/`, or `.claude/reference/`.
 - When the user asks to update any `CLAUDE.md`, add one-line bullet points only, or add a new section containing one-line bullet points.
 - Architectural internals and runtime wiring belong in `docs-internal/engine/`. Agent-procedural guides (test-harness gotchas, build troubleshooting, docs-sync tables) belong in `.claude/reference/`. Link them from the [Reference Docs](#reference-docs) index below instead of inlining.
+- Every directory that has a `CLAUDE.md` must also have an `AGENTS.md` symlink pointing to it (`ln -s CLAUDE.md AGENTS.md` from the same directory). When creating a new `CLAUDE.md`, create the symlink in the same change.
 
 ## Reference Docs
 
diff --git a/Cargo.lock b/Cargo.lock
index 4209f14d46..59358f9a1d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1439,6 +1439,16 @@ dependencies = [
  "tracing-subscriber",
 ]
 
+[[package]]
+name = "console_error_panic_hook"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a06aeb73f470f66dcdbf7223caeebb85984942f22f1adb2a088cf9668146bbbc"
+dependencies = [
+ "cfg-if",
+ "wasm-bindgen",
+]
+
 [[package]]
 name = "const-oid"
 version = "0.9.6"
@@ -4202,6 +4212,7 @@ dependencies = [
  "rivet-pools",
  "rivet-runtime",
  "rivet-types",
+ "rivetkit-sqlite",
  "rusqlite",
  "scc",
  "serde",
@@ -5433,11 +5444,12 @@ version = "2.3.0-rc.4"
 dependencies = [
  "anyhow",
  "futures-util",
+ "getrandom 0.2.16",
  "hex",
+ "js-sys",
  "parking_lot",
  "rand 0.8.5",
  "rivet-envoy-protocol",
- "rivet-util",
  "rivet-util-serde",
  "rustls 0.23.29",
  "scc",
@@ -5450,6 +5462,10 @@ dependencies = [
  "urlencoding",
  "uuid",
  "vbare",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+ "web-time",
 ]
 
 [[package]]
@@ -5954,7 +5970,9 @@ dependencies = [
  "base64 0.22.1",
  "ciborium",
  "futures",
+ "getrandom 0.2.16",
  "http 1.3.1",
+ "js-sys",
  "nix 0.30.1",
  "parking_lot",
  "portpicker",
@@ -5964,12 +5982,12 @@ dependencies = [
  "rivet-envoy-client",
  "rivet-error",
  "rivet-pools",
- "rivet-util",
  "rivetkit-actor-persist",
  "rivetkit-client-protocol",
  "rivetkit-inspector-protocol",
  "rivetkit-shared-types",
  "rivetkit-sqlite",
+ "rivetkit-sqlite-types",
  "scc",
  "serde",
  "serde_bare",
@@ -5981,8 +5999,12 @@ dependencies = [
  "tokio-util",
  "tracing",
  "tracing-subscriber",
+ "url",
  "uuid",
  "vbare",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-time",
 ]
 
 [[package]]
@@ -6048,6 +6070,7 @@ dependencies = [
  "rivet-envoy-protocol",
  "rivet-pools",
  "rivet-test-deps",
+ "rivetkit-sqlite-types",
  "scc",
  "sha2",
  "tempfile",
@@ -6057,6 +6080,28 @@ dependencies = [
  "universalpubsub",
 ]
 
+[[package]]
+name = "rivetkit-sqlite-types"
+version = "2.3.0-rc.4"
+
+[[package]]
+name = "rivetkit-wasm"
+version = "2.3.0-rc.4"
+dependencies = [
+ "anyhow",
+ "console_error_panic_hook",
+ "js-sys",
+ "rivet-error",
+ "rivetkit-core",
+ "serde",
+ "serde-wasm-bindgen",
+ "serde_json",
+ "tokio",
+ "tokio-util",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+]
+
 [[package]]
 name = "rocksdb"
 version = "0.24.0"
@@ -6600,6 +6645,17 @@ dependencies = [
  "serde_derive",
 ]
 
+[[package]]
+name = "serde-wasm-bindgen"
+version = "0.6.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8302e169f0eddcc139c70f139d19d6467353af16f9fce27e8c30158036a1e16b"
+dependencies = [
+ "js-sys",
+ "serde",
+ "wasm-bindgen",
+]
+
 [[package]]
 name = "serde_bare"
 version = "0.5.0"
diff --git a/Cargo.toml b/Cargo.toml
index eb54879656..e568ea85fc 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -63,7 +63,10 @@ members = [
   "rivetkit-rust/packages/actor-persist",
   "rivetkit-rust/packages/rivetkit-core",
   "rivetkit-rust/packages/shared-types",
-  "rivetkit-typescript/packages/rivetkit-napi"
+  "rivetkit-rust/packages/rivetkit-sqlite",
+  "rivetkit-rust/packages/rivetkit-sqlite-types",
+  "rivetkit-typescript/packages/rivetkit-napi",
+  "rivetkit-typescript/packages/rivetkit-wasm"
 ]
 
   [workspace.package]
@@ -122,7 +125,6 @@ members = [
   regex = "1.4"
   replace_with = "0.1.8"
   rstest = "0.26.1"
-  rusqlite = { version = "0.32.1", features = [ "bundled" ] }
   rustls-pemfile = "2.2.0"
   rustyline = "15.0.0"
   scc = "3.6.12"
@@ -539,6 +541,7 @@ members = [
 
     [workspace.dependencies.rivet-envoy-client]
     path = "engine/sdks/rust/envoy-client"
+    default-features = false
 
     [workspace.dependencies.rivet-envoy-protocol]
     path = "engine/sdks/rust/envoy-protocol"
@@ -558,6 +561,9 @@ members = [
     [workspace.dependencies.rivetkit-sqlite]
     path = "rivetkit-rust/packages/rivetkit-sqlite"
 
+    [workspace.dependencies.rivetkit-sqlite-types]
+    path = "rivetkit-rust/packages/rivetkit-sqlite-types"
+
     [workspace.dependencies.rivetkit-core]
     path = "rivetkit-rust/packages/rivetkit-core"
 
diff --git a/docker/build/darwin-arm64.Dockerfile b/docker/build/darwin-arm64.Dockerfile
index 8f91c7b346..a5737bd9f9 100644
--- a/docker/build/darwin-arm64.Dockerfile
+++ b/docker/build/darwin-arm64.Dockerfile
@@ -35,6 +35,7 @@ COPY . .
 RUN if [ "$BUILD_TARGET" = "engine" ] && [ "$BUILD_FRONTEND" = "true" ]; then \
         export NODE_OPTIONS="--max-old-space-size=8192" && \
         export SKIP_NAPI_BUILD=1 && \
+        export SKIP_WASM_BUILD=1 && \
         pnpm install --ignore-scripts && \
         VITE_APP_API_URL="${VITE_APP_API_URL}" VITE_FEATURE_FLAGS="${VITE_FEATURE_FLAGS}" npx turbo build -F @rivetkit/engine-frontend; \
     fi
@@ -62,7 +63,7 @@ RUN --mount=type=cache,id=cargo-registry-darwin-arm64,target=/usr/local/cargo/re
     fi && \
     mkdir -p /artifacts && \
     if [ "$BUILD_TARGET" = "engine" ]; then \
-        cargo build --bin rivet-engine $CARGO_FLAG --target aarch64-apple-darwin && \
+        cargo build -p rivet-engine --bin rivet-engine $CARGO_FLAG --target aarch64-apple-darwin && \
         cp target/aarch64-apple-darwin/$PROFILE_DIR/rivet-engine /artifacts/rivet-engine-aarch64-apple-darwin; \
     elif [ "$BUILD_TARGET" = "rivetkit-napi" ]; then \
         cd rivetkit-typescript/packages/rivetkit-napi && \
diff --git a/docker/build/darwin-x64.Dockerfile b/docker/build/darwin-x64.Dockerfile
index d862fa55a4..dbd2819ec4 100644
--- a/docker/build/darwin-x64.Dockerfile
+++ b/docker/build/darwin-x64.Dockerfile
@@ -35,6 +35,7 @@ COPY . .
 RUN if [ "$BUILD_TARGET" = "engine" ] && [ "$BUILD_FRONTEND" = "true" ]; then \
         export NODE_OPTIONS="--max-old-space-size=8192" && \
         export SKIP_NAPI_BUILD=1 && \
+        export SKIP_WASM_BUILD=1 && \
         pnpm install --ignore-scripts && \
         VITE_APP_API_URL="${VITE_APP_API_URL}" VITE_FEATURE_FLAGS="${VITE_FEATURE_FLAGS}" npx turbo build -F @rivetkit/engine-frontend; \
     fi
@@ -62,7 +63,7 @@ RUN --mount=type=cache,id=cargo-registry-darwin-x64,target=/usr/local/cargo/regi
     fi && \
     mkdir -p /artifacts && \
     if [ "$BUILD_TARGET" = "engine" ]; then \
-        cargo build --bin rivet-engine $CARGO_FLAG --target x86_64-apple-darwin && \
+        cargo build -p rivet-engine --bin rivet-engine $CARGO_FLAG --target x86_64-apple-darwin && \
         cp target/x86_64-apple-darwin/$PROFILE_DIR/rivet-engine /artifacts/rivet-engine-x86_64-apple-darwin; \
     elif [ "$BUILD_TARGET" = "rivetkit-napi" ]; then \
         cd rivetkit-typescript/packages/rivetkit-napi && \
diff --git a/docker/build/linux-arm64-gnu.Dockerfile b/docker/build/linux-arm64-gnu.Dockerfile
index 27f6ede6ad..6c2c3dae61 100644
--- a/docker/build/linux-arm64-gnu.Dockerfile
+++ b/docker/build/linux-arm64-gnu.Dockerfile
@@ -22,6 +22,7 @@ COPY . .
 RUN if [ "$BUILD_TARGET" = "engine" ] && [ "$BUILD_FRONTEND" = "true" ]; then \
         export NODE_OPTIONS="--max-old-space-size=8192" && \
         export SKIP_NAPI_BUILD=1 && \
+        export SKIP_WASM_BUILD=1 && \
         pnpm install --ignore-scripts && \
         VITE_APP_API_URL="${VITE_APP_API_URL}" VITE_FEATURE_FLAGS="${VITE_FEATURE_FLAGS}" npx turbo build -F @rivetkit/engine-frontend; \
     fi
@@ -49,7 +50,7 @@ RUN --mount=type=cache,id=cargo-registry-linux-arm64-gnu,target=/usr/local/cargo
     fi && \
     mkdir -p /artifacts && \
     if [ "$BUILD_TARGET" = "engine" ]; then \
-        cargo build --bin rivet-engine $CARGO_FLAG --target aarch64-unknown-linux-gnu && \
+        cargo build -p rivet-engine --bin rivet-engine $CARGO_FLAG --target aarch64-unknown-linux-gnu && \
         cp target/aarch64-unknown-linux-gnu/$PROFILE_DIR/rivet-engine /artifacts/rivet-engine-aarch64-unknown-linux-gnu; \
     elif [ "$BUILD_TARGET" = "rivetkit-napi" ]; then \
         cd rivetkit-typescript/packages/rivetkit-napi && \
diff --git a/docker/build/linux-arm64-musl.Dockerfile b/docker/build/linux-arm64-musl.Dockerfile
index ce59e540ad..a54a908db3 100644
--- a/docker/build/linux-arm64-musl.Dockerfile
+++ b/docker/build/linux-arm64-musl.Dockerfile
@@ -28,6 +28,7 @@ COPY . .
 RUN if [ "$BUILD_TARGET" = "engine" ] && [ "$BUILD_FRONTEND" = "true" ]; then \
         export NODE_OPTIONS="--max-old-space-size=8192" && \
         export SKIP_NAPI_BUILD=1 && \
+        export SKIP_WASM_BUILD=1 && \
         pnpm install --ignore-scripts && \
         VITE_APP_API_URL="${VITE_APP_API_URL}" VITE_FEATURE_FLAGS="${VITE_FEATURE_FLAGS}" npx turbo build -F @rivetkit/engine-frontend; \
     fi
@@ -56,7 +57,7 @@ RUN --mount=type=cache,id=cargo-registry-linux-arm64-musl,target=/usr/local/carg
     mkdir -p /artifacts && \
     if [ "$BUILD_TARGET" = "engine" ]; then \
         RUSTFLAGS="--cfg tokio_unstable -C target-feature=+crt-static -C link-arg=-static-libgcc" \
-            cargo build --bin rivet-engine $CARGO_FLAG --target aarch64-unknown-linux-musl && \
+            cargo build -p rivet-engine --bin rivet-engine $CARGO_FLAG --target aarch64-unknown-linux-musl && \
         cp target/aarch64-unknown-linux-musl/$PROFILE_DIR/rivet-engine /artifacts/rivet-engine-aarch64-unknown-linux-musl; \
     elif [ "$BUILD_TARGET" = "rivetkit-napi" ]; then \
         cd rivetkit-typescript/packages/rivetkit-napi && \
diff --git a/docker/build/linux-x64-gnu.Dockerfile b/docker/build/linux-x64-gnu.Dockerfile
index 475cce5f7d..6137632a51 100644
--- a/docker/build/linux-x64-gnu.Dockerfile
+++ b/docker/build/linux-x64-gnu.Dockerfile
@@ -31,6 +31,7 @@ COPY . .
 RUN if [ "$BUILD_TARGET" = "engine" ] && [ "$BUILD_FRONTEND" = "true" ]; then \
         export NODE_OPTIONS="--max-old-space-size=8192" && \
         export SKIP_NAPI_BUILD=1 && \
+        export SKIP_WASM_BUILD=1 && \
         pnpm install --ignore-scripts && \
         VITE_APP_API_URL="${VITE_APP_API_URL}" VITE_FEATURE_FLAGS="${VITE_FEATURE_FLAGS}" npx turbo build -F @rivetkit/engine-frontend; \
     fi
@@ -59,7 +60,7 @@ RUN --mount=type=cache,id=cargo-registry-linux-x64-gnu,target=/usr/local/cargo/r
     fi && \
     mkdir -p /artifacts && \
     if [ "$BUILD_TARGET" = "engine" ]; then \
-        cargo build --bin rivet-engine $CARGO_FLAG --target x86_64-unknown-linux-gnu && \
+        cargo build -p rivet-engine --bin rivet-engine $CARGO_FLAG --target x86_64-unknown-linux-gnu && \
         cp target/x86_64-unknown-linux-gnu/$PROFILE_DIR/rivet-engine /artifacts/rivet-engine-x86_64-unknown-linux-gnu; \
     elif [ "$BUILD_TARGET" = "rivetkit-napi" ]; then \
         cd rivetkit-typescript/packages/rivetkit-napi && \
diff --git a/docker/build/linux-x64-musl.Dockerfile b/docker/build/linux-x64-musl.Dockerfile
index 779efda303..48ed2fab3c 100644
--- a/docker/build/linux-x64-musl.Dockerfile
+++ b/docker/build/linux-x64-musl.Dockerfile
@@ -27,6 +27,7 @@ COPY . .
 RUN if [ "$BUILD_TARGET" = "engine" ] && [ "$BUILD_FRONTEND" = "true" ]; then \
         export NODE_OPTIONS="--max-old-space-size=8192" && \
         export SKIP_NAPI_BUILD=1 && \
+        export SKIP_WASM_BUILD=1 && \
         pnpm install --ignore-scripts && \
         VITE_APP_API_URL="${VITE_APP_API_URL}" VITE_FEATURE_FLAGS="${VITE_FEATURE_FLAGS}" npx turbo build -F @rivetkit/engine-frontend; \
     fi
@@ -55,7 +56,7 @@ RUN --mount=type=cache,id=cargo-registry-linux-x64-musl,target=/usr/local/cargo/
     mkdir -p /artifacts && \
     if [ "$BUILD_TARGET" = "engine" ]; then \
         RUSTFLAGS="--cfg tokio_unstable -C target-feature=+crt-static -C link-arg=-static-libgcc" \
-            cargo build --bin rivet-engine $CARGO_FLAG --target x86_64-unknown-linux-musl && \
+            cargo build -p rivet-engine --bin rivet-engine $CARGO_FLAG --target x86_64-unknown-linux-musl && \
         cp target/x86_64-unknown-linux-musl/$PROFILE_DIR/rivet-engine /artifacts/rivet-engine-x86_64-unknown-linux-musl; \
     elif [ "$BUILD_TARGET" = "rivetkit-napi" ]; then \
         cd rivetkit-typescript/packages/rivetkit-napi && \
diff --git a/docker/build/windows-x64.Dockerfile b/docker/build/windows-x64.Dockerfile
index c0017e240e..5e2061cfbe 100644
--- a/docker/build/windows-x64.Dockerfile
+++ b/docker/build/windows-x64.Dockerfile
@@ -35,6 +35,7 @@ COPY . .
 RUN if [ "$BUILD_TARGET" = "engine" ] && [ "$BUILD_FRONTEND" = "true" ]; then \
         export NODE_OPTIONS="--max-old-space-size=8192" && \
         export SKIP_NAPI_BUILD=1 && \
+        export SKIP_WASM_BUILD=1 && \
         pnpm install --ignore-scripts && \
         VITE_APP_API_URL="${VITE_APP_API_URL}" VITE_FEATURE_FLAGS="${VITE_FEATURE_FLAGS}" npx turbo build -F @rivetkit/engine-frontend; \
     fi
@@ -62,7 +63,7 @@ RUN --mount=type=cache,id=cargo-registry-windows-x64,target=/usr/local/cargo/reg
     fi && \
     mkdir -p /artifacts && \
     if [ "$BUILD_TARGET" = "engine" ]; then \
-        cargo build --bin rivet-engine $CARGO_FLAG --target x86_64-pc-windows-gnu && \
+        cargo build -p rivet-engine --bin rivet-engine $CARGO_FLAG --target x86_64-pc-windows-gnu && \
         cp target/x86_64-pc-windows-gnu/$PROFILE_DIR/rivet-engine.exe /artifacts/rivet-engine-x86_64-pc-windows-gnu.exe; \
     elif [ "$BUILD_TARGET" = "rivetkit-napi" ]; then \
         cd rivetkit-typescript/packages/rivetkit-napi && \
diff --git a/docker/engine/Dockerfile b/docker/engine/Dockerfile
index 6cbe4a83b7..a3d04fda72 100644
--- a/docker/engine/Dockerfile
+++ b/docker/engine/Dockerfile
@@ -21,12 +21,13 @@ COPY . .
 # Build frontend. Use --ignore-scripts because the root postinstall runs
 # `lefthook install`, which needs a .git directory (excluded by
 # .dockerignore). lefthook is a dev-only git hook manager and has no
-# place inside the Docker build. SKIP_NAPI_BUILD=1 tells
-# @rivetkit/rivetkit-napi to skip its napi build. The frontend only
-# consumes the TypeScript surface, not the runtime .node binary.
+# place inside the Docker build. SKIP_NAPI_BUILD=1 and SKIP_WASM_BUILD=1 tell
+# the runtime binding packages to skip native artifact builds. The frontend only
+# consumes their TypeScript surfaces, not the runtime binaries.
 RUN if [ "$BUILD_FRONTEND" = "true" ]; then \
         export NODE_OPTIONS="--max-old-space-size=8192" && \
         export SKIP_NAPI_BUILD=1 && \
+        export SKIP_WASM_BUILD=1 && \
         pnpm install --ignore-scripts && \
         VITE_APP_API_URL="${VITE_APP_API_URL}" VITE_FEATURE_FLAGS="${VITE_FEATURE_FLAGS}" VITE_APP_TURNSTILE_SITE_KEY="${VITE_APP_TURNSTILE_SITE_KEY}" npx turbo build -F @rivetkit/engine-frontend; \
     fi
@@ -40,9 +41,9 @@ RUN \
     --mount=type=cache,target=/app/target,id=univseral-target \
     --mount=type=cache,target=/root/.cache,id=universal-user-cache \
     if [ "$CARGO_BUILD_MODE" = "release" ]; then \
-        RUSTFLAGS="--cfg tokio_unstable" cargo build --bin rivet-engine --release; \
+        RUSTFLAGS="--cfg tokio_unstable" cargo build -p rivet-engine --bin rivet-engine --release; \
     else \
-        RUSTFLAGS="--cfg tokio_unstable" cargo build --bin rivet-engine; \
+        RUSTFLAGS="--cfg tokio_unstable" cargo build -p rivet-engine --bin rivet-engine; \
     fi && \
     # cargo install --locked tokio-console && \
     mkdir /app/dist/ && \
diff --git a/engine/AGENTS.md b/engine/AGENTS.md
new file mode 120000
index 0000000000..681311eb9c
--- /dev/null
+++ b/engine/AGENTS.md
@@ -0,0 +1 @@
+CLAUDE.md
\ No newline at end of file
diff --git a/engine/artifacts/errors/wasm.invalid_config.json b/engine/artifacts/errors/wasm.invalid_config.json
new file mode 100644
index 0000000000..b127e23f81
--- /dev/null
+++ b/engine/artifacts/errors/wasm.invalid_config.json
@@ -0,0 +1,5 @@
+{
+  "code": "invalid_config",
+  "group": "wasm",
+  "message": "Invalid wasm configuration."
+}
\ No newline at end of file
diff --git a/engine/artifacts/errors/wasm.invalid_state.json b/engine/artifacts/errors/wasm.invalid_state.json
new file mode 100644
index 0000000000..af34e4655f
--- /dev/null
+++ b/engine/artifacts/errors/wasm.invalid_state.json
@@ -0,0 +1,5 @@
+{
+  "code": "invalid_state",
+  "group": "wasm",
+  "message": "Invalid wasm state"
+}
\ No newline at end of file
diff --git a/engine/packages/guard/src/routing/pegboard_gateway/mod.rs b/engine/packages/guard/src/routing/pegboard_gateway/mod.rs
index f80d9ebe87..222c7b80e6 100644
--- a/engine/packages/guard/src/routing/pegboard_gateway/mod.rs
+++ b/engine/packages/guard/src/routing/pegboard_gateway/mod.rs
@@ -138,6 +138,10 @@ pub async fn route_request(
 		return Ok(Some(RoutingOutput::CustomServe(Arc::new(CorsPreflight))));
 	}
 
+	if !req_ctx.is_websocket() && !is_actor_http_request_path(req_ctx.path()) {
+		return Ok(None);
+	}
+
 	// Attach CORS headers to the actual (non-OPTIONS) response so both the
 	// actor response and any early error are readable by the browser.
 	set_non_preflight_cors(req_ctx);
@@ -227,6 +231,14 @@ pub async fn route_request(
 	.map(Some)
 }
 
+fn is_actor_http_request_path(path: &str) -> bool {
+	let Some(stripped) = path.strip_prefix("/request") else {
+		return false;
+	};
+
+	stripped.is_empty() || matches!(stripped.as_bytes().first(), Some(b'/') | Some(b'?'))
+}
+
 async fn route_request_inner(
 	ctx: &StandaloneCtx,
 	shared_state: &SharedState,
diff --git a/engine/packages/pegboard-envoy/Cargo.toml b/engine/packages/pegboard-envoy/Cargo.toml
index 5452541759..86d8f64ce2 100644
--- a/engine/packages/pegboard-envoy/Cargo.toml
+++ b/engine/packages/pegboard-envoy/Cargo.toml
@@ -26,6 +26,7 @@ rivet-guard-core.workspace = true
 rivet-metrics.workspace = true
 rivet-pools.workspace = true
 rivet-envoy-protocol.workspace = true
+rivetkit-sqlite.workspace = true
 rivet-runtime.workspace = true
 rivet-types.workspace = true
 scc.workspace = true
diff --git a/engine/packages/pegboard-envoy/src/conn.rs b/engine/packages/pegboard-envoy/src/conn.rs
index 617596a5d0..1dab9efb07 100644
--- a/engine/packages/pegboard-envoy/src/conn.rs
+++ b/engine/packages/pegboard-envoy/src/conn.rs
@@ -24,6 +24,7 @@ use crate::{actor_lifecycle, errors, metrics, utils::UrlData};
 
 pub struct Conn {
 	pub namespace_id: Id,
+	pub namespace_name: String,
 	pub pool_name: String,
 	pub envoy_key: String,
 	pub protocol_version: u16,
@@ -307,12 +308,13 @@ pub async fn init_conn(
 
 	let conn = Arc::new(Conn {
 		namespace_id: namespace.namespace_id,
+		namespace_name,
 		pool_name,
 		envoy_key,
-			protocol_version,
-			ws_handle,
-			authorized_tunnel_routes: HashMap::new(),
-			udb: conn_udb,
+		protocol_version,
+		ws_handle,
+		authorized_tunnel_routes: HashMap::new(),
+		udb: conn_udb,
 		node_id,
 		sqlite_cold_tier,
 		actor_dbs: HashMap::new(),
diff --git a/engine/packages/pegboard-envoy/src/ws_to_tunnel_task.rs b/engine/packages/pegboard-envoy/src/ws_to_tunnel_task.rs
index 33426a8236..f0b099c1fe 100644
--- a/engine/packages/pegboard-envoy/src/ws_to_tunnel_task.rs
+++ b/engine/packages/pegboard-envoy/src/ws_to_tunnel_task.rs
@@ -64,7 +64,7 @@ pub async fn task_inner(
 	loop {
 		match recv_msg(&mut ws_rx, &mut ws_to_tunnel_abort_rx, &mut term_signal).await? {
 			Ok(Some(msg)) => {
-				handle_message(&ctx, &conn, event_demuxer, msg).await?;
+				handle_message(&ctx, conn.clone(), event_demuxer, msg).await?;
 			}
 			Ok(None) => {}
 			Err(lifecycle_res) => return Ok(lifecycle_res),
@@ -118,7 +118,7 @@ async fn recv_msg(
 #[tracing::instrument(skip_all)]
 async fn handle_message(
 	ctx: &StandaloneCtx,
-	conn: &Conn,
+	conn: Arc<Conn>,
 	event_demuxer: &mut ActorEventDemuxer,
 	msg: Bytes,
 ) -> Result<()> {
@@ -383,23 +383,57 @@ async fn handle_message(
 			}
 		}
 		protocol::ToRivet::ToRivetSqliteGetPagesRequest(req) => {
-			let response = handle_sqlite_get_pages_response(ctx, conn, req.data).await;
-			send_sqlite_get_pages_response(conn, req.request_id, response).await?;
+			let response = handle_sqlite_get_pages_response(ctx, &conn, req.data).await;
+			send_sqlite_get_pages_response(&conn, req.request_id, response).await?;
 		}
 		protocol::ToRivet::ToRivetSqliteCommitRequest(req) => {
 			let actor_id = req.data.actor_id.clone();
 			let request_id = req.request_id;
-			let timed_response = async { handle_sqlite_commit_response(ctx, conn, req.data).await }
+			let timed_response = async { handle_sqlite_commit_response(ctx, &conn, req.data).await }
 				.instrument(tracing::debug_span!(
 					"handle_sqlite_commit",
 					actor_id = %actor_id,
 					request_id = ?request_id
 				))
 				.await;
-			send_sqlite_commit_response(conn, request_id, timed_response.response).await?;
+			send_sqlite_commit_response(&conn, request_id, timed_response.response).await?;
 			crate::metrics::SQLITE_COMMIT_ENVOY_RESPONSE_DURATION
 				.observe(timed_response.commit_completed_at.elapsed().as_secs_f64());
 		}
+		protocol::ToRivet::ToRivetSqliteExecRequest(req) => {
+			send_sqlite_exec_response(
+				&conn,
+				req.request_id,
+				protocol::SqliteExecResponse::SqliteErrorResponse(protocol::SqliteErrorResponse {
+					message: "remote sqlite exec handling is not wired".to_string(),
+				}),
+			)
+			.await?;
+		}
+		protocol::ToRivet::ToRivetSqliteExecuteRequest(req) => {
+			send_sqlite_execute_response(
+				&conn,
+				req.request_id,
+				protocol::SqliteExecuteResponse::SqliteErrorResponse(
+					protocol::SqliteErrorResponse {
+						message: "remote sqlite execute handling is not wired".to_string(),
+					},
+				),
+			)
+			.await?;
+		}
+		protocol::ToRivet::ToRivetSqliteExecuteWriteRequest(req) => {
+			send_sqlite_execute_write_response(
+				&conn,
+				req.request_id,
+				protocol::SqliteExecuteWriteResponse::SqliteErrorResponse(
+					protocol::SqliteErrorResponse {
+						message: "remote sqlite execute_write handling is not wired".to_string(),
+					},
+				),
+			)
+			.await?;
+		}
 		protocol::ToRivet::ToRivetTunnelMessage(tunnel_msg) => {
 			handle_tunnel_message(ctx, &conn.authorized_tunnel_routes, tunnel_msg)
 				.await
@@ -850,6 +884,53 @@ async fn send_sqlite_commit_response(
 	.await
 }
 
+async fn send_sqlite_exec_response(
+	conn: &Conn,
+	request_id: u32,
+	data: protocol::SqliteExecResponse,
+) -> Result<()> {
+	send_to_envoy(
+		conn,
+		protocol::ToEnvoy::ToEnvoySqliteExecResponse(protocol::ToEnvoySqliteExecResponse {
+			request_id,
+			data,
+		}),
+		"sqlite exec response",
+	)
+	.await
+}
+
+async fn send_sqlite_execute_response(
+	conn: &Conn,
+	request_id: u32,
+	data: protocol::SqliteExecuteResponse,
+) -> Result<()> {
+	send_to_envoy(
+		conn,
+		protocol::ToEnvoy::ToEnvoySqliteExecuteResponse(protocol::ToEnvoySqliteExecuteResponse {
+			request_id,
+			data,
+		}),
+		"sqlite execute response",
+	)
+	.await
+}
+
+async fn send_sqlite_execute_write_response(
+	conn: &Conn,
+	request_id: u32,
+	data: protocol::SqliteExecuteWriteResponse,
+) -> Result<()> {
+	send_to_envoy(
+		conn,
+		protocol::ToEnvoy::ToEnvoySqliteExecuteWriteResponse(
+			protocol::ToEnvoySqliteExecuteWriteResponse { request_id, data },
+		),
+		"sqlite execute_write response",
+	)
+	.await
+}
+
 async fn send_to_envoy(conn: &Conn, msg: protocol::ToEnvoy, description: &str) -> Result<()> {
 	let serialized = versioned::ToEnvoy::wrap_latest(msg)
 		.serialize(conn.protocol_version)
diff --git a/engine/packages/pegboard-envoy/tests/support/ws_to_tunnel_task.rs b/engine/packages/pegboard-envoy/tests/support/ws_to_tunnel_task.rs
index be474033f7..0f6d66a909 100644
--- a/engine/packages/pegboard-envoy/tests/support/ws_to_tunnel_task.rs
+++ b/engine/packages/pegboard-envoy/tests/support/ws_to_tunnel_task.rs
@@ -81,12 +81,37 @@
 // 	assert!(matches!(msg, NextOutput::Message(_)));
 // }
 
-use sqlite_storage::error::SqliteStorageError;
+use std::{
+	sync::{
+		Arc,
+		atomic::{AtomicBool, Ordering},
+	},
+	time::{SystemTime, UNIX_EPOCH},
+};
+
+use anyhow::Result;
+use rivetkit_sqlite::types::{BindParam, ColumnValue};
+use sqlite_storage::{engine::SqliteEngine, error::SqliteStorageError, open::OpenConfig};
+use tokio::{
+	sync::{Notify, Semaphore},
+	time::{Duration, Instant, timeout},
+};
+use universaldb::{Subspace, driver::RocksDbDatabaseDriver};
 
 use super::{
-	actor_lifecycle::{ActiveActor, ActiveActorState},
-	cached_active_sqlite_actor, cached_serverless_sqlite_generation,
-	validate_sqlite_get_page_range_request,
+	actor_lifecycle::{
+		ActiveActor, ActiveActorState, clear_remote_sqlite_executors,
+		remove_remote_sqlite_executor_generation, remove_remote_sqlite_executors_for_actor,
+	},
+	cached_active_sqlite_actor,
+	cached_serverless_sqlite_generation,
+	remote_sqlite_executor_cell, remote_sqlite_executor_from_parts,
+	spawn_tracked_remote_sqlite_task,
+	validate_remote_sqlite_params, validate_sqlite_get_page_range_request,
+};
+use crate::conn::{
+	RemoteSqliteExecutors, RemoteSqliteInflight, remote_sqlite_inflight_count,
+	remove_remote_sqlite_inflight_generation_if_idle, wait_remote_sqlite_inflight_generation,
 };
 
 #[tokio::test]
@@ -169,6 +194,242 @@ async fn cached_serverless_sqlite_generation_reports_fence_mismatch() {
 	);
 }
 
+#[tokio::test]
+async fn remote_sqlite_executor_cache_is_lazy_and_actor_generation_scoped() {
+	let executors = RemoteSqliteExecutors::new();
+
+	assert_eq!(executors.len(), 0);
+
+	let first = remote_sqlite_executor_cell(&executors, "actor-a", 7).await;
+	assert!(first.get().is_none());
+	assert_eq!(executors.len(), 1);
+
+	let second = remote_sqlite_executor_cell(&executors, "actor-a", 7).await;
+	assert!(Arc::ptr_eq(&first, &second));
+	assert_eq!(executors.len(), 1);
+
+	let next_generation = remote_sqlite_executor_cell(&executors, "actor-a", 8).await;
+	assert!(!Arc::ptr_eq(&first, &next_generation));
+	assert_eq!(executors.len(), 2);
+}
+
+#[tokio::test]
+async fn remote_sqlite_executor_cleanup_removes_actor_scoped_entries() {
+	let executors = RemoteSqliteExecutors::new();
+	let _ = remote_sqlite_executor_cell(&executors, "actor-a", 7).await;
+	let _ = remote_sqlite_executor_cell(&executors, "actor-a", 8).await;
+	let _ = remote_sqlite_executor_cell(&executors, "actor-b", 7).await;
+
+	remove_remote_sqlite_executor_generation(&executors, "actor-a", 7).await;
+	assert!(!has_remote_sqlite_executor(&executors, "actor-a", 7).await);
+	assert!(has_remote_sqlite_executor(&executors, "actor-a", 8).await);
+	assert!(has_remote_sqlite_executor(&executors, "actor-b", 7).await);
+
+	remove_remote_sqlite_executors_for_actor(&executors, "actor-a");
+	assert!(!has_remote_sqlite_executor(&executors, "actor-a", 8).await);
+	assert!(has_remote_sqlite_executor(&executors, "actor-b", 7).await);
+
+	clear_remote_sqlite_executors(&executors);
+	assert_eq!(executors.len(), 0);
+}
+
+#[tokio::test]
+async fn tracked_remote_sqlite_tasks_are_bounded_and_visible_to_stop_waiters() {
+	let worker_permits = Arc::new(Semaphore::new(1));
+	let in_flight = RemoteSqliteInflight::new();
+	let first_started = Arc::new(Notify::new());
+	let first_release = Arc::new(Notify::new());
+	let second_started = Arc::new(Notify::new());
+	let second_release = Arc::new(Notify::new());
+	let second_ran = Arc::new(AtomicBool::new(false));
+
+	spawn_tracked_remote_sqlite_task(
+		worker_permits.clone(),
+		&in_flight,
+		"actor-a".to_string(),
+		7,
+		"test sqlite execute",
+		{
+			let first_started = first_started.clone();
+			let first_release = first_release.clone();
+			async move {
+				first_started.notify_waiters();
+				first_release.notified().await;
+			}
+		},
+	)
+	.await;
+	first_started.notified().await;
+
+	spawn_tracked_remote_sqlite_task(
+		worker_permits,
+		&in_flight,
+		"actor-a".to_string(),
+		7,
+		"test sqlite execute",
+		{
+			let second_started = second_started.clone();
+			let second_release = second_release.clone();
+			let second_ran = second_ran.clone();
+			async move {
+				second_ran.store(true, Ordering::SeqCst);
+				second_started.notify_waiters();
+				second_release.notified().await;
+			}
+		},
+	)
+	.await;
+
+	assert_eq!(
+		remote_sqlite_inflight_count(&in_flight, "actor-a", 7).await,
+		2
+	);
+	assert!(!second_ran.load(Ordering::SeqCst));
+	assert!(
+		!wait_remote_sqlite_inflight_generation(
+			&in_flight,
+			"actor-a",
+			7,
+			Instant::now() + Duration::from_millis(1),
+		)
+		.await
+	);
+
+	first_release.notify_waiters();
+	timeout(Duration::from_secs(1), second_started.notified())
+		.await
+		.expect("second task should start after the first releases its worker permit");
+	second_release.notify_waiters();
+	assert!(
+		wait_remote_sqlite_inflight_generation(
+			&in_flight,
+			"actor-a",
+			7,
+			Instant::now() + Duration::from_secs(1),
+		)
+		.await
+	);
+
+	remove_remote_sqlite_inflight_generation_if_idle(&in_flight, "actor-a", 7).await;
+	assert_eq!(
+		remote_sqlite_inflight_count(&in_flight, "actor-a", 7).await,
+		0
+	);
+}
+
+#[tokio::test]
+async fn remote_sqlite_stop_wait_does_not_finish_before_running_task() {
+	let worker_permits = Arc::new(Semaphore::new(1));
+	let in_flight = RemoteSqliteInflight::new();
+	let task_started = Arc::new(Notify::new());
+	let task_release = Arc::new(Notify::new());
+
+	spawn_tracked_remote_sqlite_task(
+		worker_permits,
+		&in_flight,
+		"actor-a".to_string(),
+		7,
+		"test sqlite execute",
+		{
+			let task_started = task_started.clone();
+			let task_release = task_release.clone();
+			async move {
+				task_started.notify_waiters();
+				task_release.notified().await;
+			}
+		},
+	)
+	.await;
+	task_started.notified().await;
+
+	assert!(
+		timeout(
+			Duration::from_millis(20),
+			wait_remote_sqlite_inflight_generation(
+				&in_flight,
+				"actor-a",
+				7,
+				Instant::now() + Duration::from_secs(1),
+			),
+		)
+		.await
+		.is_err()
+	);
+	task_release.notify_waiters();
+	assert!(
+		wait_remote_sqlite_inflight_generation(
+			&in_flight,
+			"actor-a",
+			7,
+			Instant::now() + Duration::from_secs(1),
+		)
+		.await
+	);
+}
+
+#[tokio::test]
+async fn remote_sqlite_executor_reopens_fresh_cell_with_persisted_contents() -> Result<()> {
+	let actor_id = unique_actor_id("remote-sqlite-lazy");
+	let db_dir = tempfile::tempdir()?;
+	let driver = RocksDbDatabaseDriver::new(db_dir.path().to_path_buf()).await?;
+	let db = universaldb::Database::new(Arc::new(driver));
+	let (engine, _compaction_rx) =
+		SqliteEngine::new(db, Subspace::new(&("remote-sqlite-lazy", &actor_id)));
+	let engine = Arc::new(engine);
+	let executors = RemoteSqliteExecutors::new();
+	let opened = engine.open(&actor_id, OpenConfig::new(1)).await?;
+
+	assert_eq!(executors.len(), 0);
+
+	let handle = remote_sqlite_executor_from_parts(
+		&executors,
+		Arc::clone(&engine),
+		&actor_id,
+		opened.generation,
+	)
+	.await?;
+	assert_eq!(executors.len(), 1);
+	handle
+		.execute_write(
+			"CREATE TABLE items(id INTEGER PRIMARY KEY, label TEXT);".to_string(),
+			None,
+		)
+		.await?;
+	handle
+		.execute_write(
+			"INSERT INTO items(label) VALUES (?);".to_string(),
+			Some(vec![BindParam::Text("alpha".to_string())]),
+		)
+		.await?;
+	handle.close().await?;
+	remove_remote_sqlite_executor_generation(&executors, &actor_id, opened.generation).await;
+	engine.close(&actor_id, opened.generation).await?;
+
+	let reopened = engine.open(&actor_id, OpenConfig::new(2)).await?;
+	let fresh_handle = remote_sqlite_executor_from_parts(
+		&executors,
+		Arc::clone(&engine),
+		&actor_id,
+		reopened.generation,
+	)
+	.await?;
+	let result = fresh_handle
+		.execute(
+			"SELECT label FROM items WHERE id = ?;".to_string(),
+			Some(vec![BindParam::Integer(1)]),
+		)
+		.await?;
+	assert_eq!(
+		result.rows,
+		vec![vec![ColumnValue::Text("alpha".to_string())]]
+	);
+
+	fresh_handle.close().await?;
+	remove_remote_sqlite_executor_generation(&executors, &actor_id, reopened.generation).await;
+	engine.close(&actor_id, reopened.generation).await?;
+	Ok(())
+}
+
 #[test]
 fn validate_sqlite_get_page_range_request_rejects_empty_bounds() {
 	let valid = rivet_envoy_protocol::SqliteGetPageRangeRequest {
@@ -193,3 +454,46 @@ fn validate_sqlite_get_page_range_request_rejects_empty_bounds() {
 	invalid.max_bytes = 0;
 	assert!(validate_sqlite_get_page_range_request(&invalid).is_err());
 }
+
+#[test]
+fn validate_remote_sqlite_params_bounds_total_bind_bytes() {
+	let valid = vec![
+		rivet_envoy_protocol::SqliteBindParam::SqliteValueText(
+			rivet_envoy_protocol::SqliteValueText {
+				value: "alpha".to_string(),
+			},
+		),
+		rivet_envoy_protocol::SqliteBindParam::SqliteValueBlob(
+			rivet_envoy_protocol::SqliteValueBlob {
+				value: vec![0, 1, 2],
+			},
+		),
+	];
+	validate_remote_sqlite_params(Some(&valid)).expect("small bind params should pass");
+
+	let too_large = vec![rivet_envoy_protocol::SqliteBindParam::SqliteValueBlob(
+		rivet_envoy_protocol::SqliteValueBlob {
+			value: vec![0; super::MAX_REMOTE_SQL_BIND_BYTES + 1],
+		},
+	)];
+	let err = validate_remote_sqlite_params(Some(&too_large))
+		.expect_err("oversized bind params should fail");
+	assert!(err.to_string().contains("bind params had"));
+}
+
+async fn has_remote_sqlite_executor(
+	executors: &RemoteSqliteExecutors,
+	actor_id: &str,
+	generation: u64,
+) -> bool {
+	let key = (actor_id.to_string(), generation);
+	executors.read_async(&key, |_, _| ()).await.is_some()
+}
+
+fn unique_actor_id(prefix: &str) -> String {
+	let nanos = SystemTime::now()
+		.duration_since(UNIX_EPOCH)
+		.expect("system time should be after epoch")
+		.as_nanos();
+	format!("{prefix}-{nanos}")
+}
diff --git a/engine/packages/pegboard/src/workflows/actor2/runtime.rs b/engine/packages/pegboard/src/workflows/actor2/runtime.rs
index 145c6f733c..39c685484f 100644
--- a/engine/packages/pegboard/src/workflows/actor2/runtime.rs
+++ b/engine/packages/pegboard/src/workflows/actor2/runtime.rs
@@ -582,19 +582,29 @@ pub async fn handle_stopped(
 			if let Some(allocation) = allocate_res.allocation {
 				state.generation += 1;
 
+				match &allocation {
+					Allocation::Serverless => {
+						state.transition = Transition::Allocating {
+							destroy_after_start: false,
+							lost_timeout_ts: allocate_res.now
+								+ ctx.config().pegboard().actor_allocation_threshold(),
+						};
+					}
+					Allocation::Serverful { envoy_key: _ } => {
+						state.transition = Transition::Starting {
+							destroy_after_start: false,
+							lost_timeout_ts: allocate_res.now
+								+ ctx.config().pegboard().actor_start_threshold(),
+						};
+					}
+				}
+
 				ctx.activity(SendOutboundInput {
 					generation: state.generation,
 					input: input.input.clone(),
 					allocation,
 				})
 				.await?;
-
-				// Transition to allocating
-				state.transition = Transition::Allocating {
-					destroy_after_start: false,
-					lost_timeout_ts: allocate_res.now
-						+ ctx.config().pegboard().actor_allocation_threshold(),
-				};
 			} else {
 				// Transition to retry backoff
 				state.transition = Transition::Reallocating {
diff --git a/engine/sdks/rust/envoy-client/Cargo.toml b/engine/sdks/rust/envoy-client/Cargo.toml
index ecf9617527..6cc6958283 100644
--- a/engine/sdks/rust/envoy-client/Cargo.toml
+++ b/engine/sdks/rust/envoy-client/Cargo.toml
@@ -5,23 +5,46 @@ authors.workspace = true
 license.workspace = true
 edition.workspace = true
 
+[features]
+default = ["native-transport"]
+native-transport = ["dep:rustls", "dep:tokio-tungstenite"]
+wasm-transport = ["dep:js-sys", "dep:wasm-bindgen", "dep:wasm-bindgen-futures", "dep:web-sys"]
+
 [dependencies]
 anyhow.workspace = true
 futures-util.workspace = true
 parking_lot.workspace = true
 hex.workspace = true
+js-sys = { version = "0.3", optional = true }
 rand.workspace = true
 rivet-envoy-protocol.workspace = true
-rivet-util.workspace = true
 rivet-util-serde.workspace = true
-rustls.workspace = true
+rustls = { workspace = true, optional = true }
 scc.workspace = true
 serde.workspace = true
 serde_bare.workspace = true
 serde_json.workspace = true
-tokio.workspace = true
-tokio-tungstenite.workspace = true
+tokio-tungstenite = { workspace = true, optional = true }
 tracing.workspace = true
 urlencoding.workspace = true
-uuid.workspace = true
 vbare.workspace = true
+wasm-bindgen = { version = "0.2", optional = true }
+wasm-bindgen-futures = { version = "0.4", optional = true }
+web-sys = { version = "0.3", optional = true, features = [
+	"BinaryType",
+	"CloseEvent",
+	"ErrorEvent",
+	"Event",
+	"MessageEvent",
+	"WebSocket",
+] }
+
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+tokio.workspace = true
+uuid.workspace = true
+
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+getrandom = { version = "0.2", features = ["js"] }
+tokio = { version = "1.44.0", default-features = false, features = ["macros", "rt", "sync", "time"] }
+uuid = { version = "1.11.0", features = ["v4", "serde", "js"] }
+web-time = "1.1"
diff --git a/engine/sdks/rust/envoy-client/src/actor.rs b/engine/sdks/rust/envoy-client/src/actor.rs
index 48f7c004be..efe6885983 100644
--- a/engine/sdks/rust/envoy-client/src/actor.rs
+++ b/engine/sdks/rust/envoy-client/src/actor.rs
@@ -3,7 +3,7 @@ use std::collections::HashMap;
 use std::sync::Arc;
 
 use rivet_envoy_protocol as protocol;
-use rivet_util::async_counter::AsyncCounter;
+use crate::async_counter::AsyncCounter;
 use rivet_util_serde::HashableMap;
 use tokio::sync::mpsc;
 use tokio::sync::oneshot;
@@ -16,7 +16,9 @@ use crate::connection::ws_send;
 use crate::context::SharedContext;
 use crate::handle::EnvoyHandle;
 use crate::stringify::stringify_to_rivet_tunnel_message_kind;
-use crate::utils::{BufferMap, id_to_str, wrapping_add_u16, wrapping_lte_u16, wrapping_sub_u16};
+use crate::utils::{
+	BufferMap, id_to_str, spawn_detached, wrapping_add_u16, wrapping_lte_u16, wrapping_sub_u16,
+};
 
 pub enum ToActor {
 	Intent {
@@ -128,7 +130,7 @@ pub fn create_actor(
 ) -> (mpsc::UnboundedSender<ToActor>, Arc<AsyncCounter>) {
 	let (tx, rx) = mpsc::unbounded_channel();
 	let active_http_request_count = Arc::new(AsyncCounter::new());
-	tokio::spawn(actor_inner(
+	spawn_detached(actor_inner(
 		shared,
 		actor_id,
 		generation,
@@ -540,27 +542,30 @@ fn handle_req_start(
 	let request_id = message_id.request_id;
 	let request_guard = ActiveHttpRequestGuard::new(ctx.active_http_request_count.clone());
 
-	http_request_tasks.spawn(
-		async move {
-			let _request_guard = request_guard;
-			let response = shared
-				.config
-				.callbacks
-				.fetch(handle_clone, actor_id, gateway_id, request_id, request)
-				.await;
+	let task = async move {
+		let _request_guard = request_guard;
+		let response = shared
+			.config
+			.callbacks
+			.fetch(handle_clone, actor_id, gateway_id, request_id, request)
+			.await;
 
-			match response {
-				Ok(response) => {
-					send_response(&shared, gateway_id, request_id, response).await;
-				}
-				Err(error) => {
-					tracing::error!(?error, "fetch failed");
-					send_fetch_error_response(&shared, gateway_id, request_id).await;
-				}
+		match response {
+			Ok(response) => {
+				send_response(&shared, gateway_id, request_id, response).await;
+			}
+			Err(error) => {
+				tracing::error!(?error, "fetch failed");
+				send_fetch_error_response(&shared, gateway_id, request_id).await;
 			}
 		}
-		.in_current_span(),
-	);
+	}
+	.in_current_span();
+
+	#[cfg(target_arch = "wasm32")]
+	http_request_tasks.spawn_local(task);
+	#[cfg(not(target_arch = "wasm32"))]
+	http_request_tasks.spawn(task);
 
 	if !req.stream {
 		ctx.pending_requests
@@ -684,7 +689,7 @@ fn spawn_ws_outgoing_task(
 			}
 		}
 	};
-	tokio::spawn(ws_task.in_current_span());
+	spawn_detached(ws_task.in_current_span());
 }
 
 async fn handle_ws_open(
diff --git a/engine/sdks/rust/envoy-client/src/async_counter.rs b/engine/sdks/rust/envoy-client/src/async_counter.rs
new file mode 100644
index 0000000000..e31b697af7
--- /dev/null
+++ b/engine/sdks/rust/envoy-client/src/async_counter.rs
@@ -0,0 +1,111 @@
+use std::sync::Arc;
+use std::sync::Weak;
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::time::Duration;
+
+use parking_lot::Mutex;
+use tokio::sync::Notify;
+
+use crate::time::Instant;
+use crate::utils::sleep;
+
+pub struct AsyncCounter {
+	value: AtomicUsize,
+	zero_notify: Notify,
+	zero_observers: Mutex<Vec<Weak<Notify>>>,
+	change_observers: Mutex<Vec<Weak<Notify>>>,
+	change_callbacks: Mutex<Vec<Arc<dyn Fn() + Send + Sync>>>,
+}
+
+impl AsyncCounter {
+	pub fn new() -> Self {
+		Self {
+			value: AtomicUsize::new(0),
+			zero_notify: Notify::new(),
+			zero_observers: Mutex::new(Vec::new()),
+			change_observers: Mutex::new(Vec::new()),
+			change_callbacks: Mutex::new(Vec::new()),
+		}
+	}
+
+	pub fn register_zero_notify(&self, notify: &Arc<Notify>) {
+		self.zero_observers.lock().push(Arc::downgrade(notify));
+	}
+
+	pub fn register_change_notify(&self, notify: &Arc<Notify>) {
+		self.change_observers.lock().push(Arc::downgrade(notify));
+	}
+
+	pub fn register_change_callback(&self, callback: Arc<dyn Fn() + Send + Sync>) {
+		self.change_callbacks.lock().push(callback);
+	}
+
+	pub fn increment(&self) {
+		self.value.fetch_add(1, Ordering::Relaxed);
+		self.notify_change();
+	}
+
+	pub fn decrement(&self) {
+		let prev = self.value.fetch_sub(1, Ordering::AcqRel);
+		debug_assert!(prev > 0, "AsyncCounter decrement below zero");
+		if prev == 1 {
+			self.zero_notify.notify_waiters();
+			let mut observers = self.zero_observers.lock();
+			observers.retain(|observer| {
+				let Some(notify) = observer.upgrade() else {
+					return false;
+				};
+				notify.notify_waiters();
+				true
+			});
+		}
+		self.notify_change();
+	}
+
+	fn notify_change(&self) {
+		let mut observers = self.change_observers.lock();
+		observers.retain(|observer| {
+			let Some(notify) = observer.upgrade() else {
+				return false;
+			};
+			notify.notify_waiters();
+			true
+		});
+		drop(observers);
+
+		let callbacks = self.change_callbacks.lock().clone();
+		for callback in callbacks {
+			callback();
+		}
+	}
+
+	pub fn load(&self) -> usize {
+		self.value.load(Ordering::Acquire)
+	}
+
+	pub async fn wait_zero(&self, deadline: Instant) -> bool {
+		loop {
+			let notified = self.zero_notify.notified();
+			tokio::pin!(notified);
+			notified.as_mut().enable();
+
+			if self.value.load(Ordering::Acquire) == 0 {
+				return true;
+			}
+
+			let timeout = deadline
+				.checked_duration_since(Instant::now())
+				.unwrap_or(Duration::ZERO);
+			tokio::select! {
+				_ = notified => {}
+				_ = sleep(timeout) => return false,
+			}
+		}
+	}
+}
+
+impl Default for AsyncCounter {
+	fn default() -> Self {
+		Self::new()
+	}
+}
diff --git a/engine/sdks/rust/envoy-client/src/config.rs b/engine/sdks/rust/envoy-client/src/config.rs
index ebef992c85..6ac5d129ce 100644
--- a/engine/sdks/rust/envoy-client/src/config.rs
+++ b/engine/sdks/rust/envoy-client/src/config.rs
@@ -9,8 +9,12 @@ use tokio::sync::{mpsc, oneshot};
 
 use crate::handle::EnvoyHandle;
 
+#[cfg(not(target_arch = "wasm32"))]
 pub type BoxFuture<T> = Pin<Box<dyn Future<Output = T> + Send>>;
 
+#[cfg(target_arch = "wasm32")]
+pub type BoxFuture<T> = Pin<Box<dyn Future<Output = T>>>;
+
 /// HTTP request/response types used by the envoy client.
 pub struct HttpRequest {
 	pub method: String,
diff --git a/engine/sdks/rust/envoy-client/src/connection/mod.rs b/engine/sdks/rust/envoy-client/src/connection/mod.rs
new file mode 100644
index 0000000000..b685a440d8
--- /dev/null
+++ b/engine/sdks/rust/envoy-client/src/connection/mod.rs
@@ -0,0 +1,139 @@
+use rivet_envoy_protocol as protocol;
+#[cfg(any(
+	feature = "native-transport",
+	all(feature = "wasm-transport", target_arch = "wasm32")
+))]
+use rivet_util_serde::HashableMap;
+use vbare::OwnedVersionedData;
+
+use crate::context::SharedContext;
+use crate::context::WsTxMessage;
+#[cfg(any(
+	feature = "native-transport",
+	all(feature = "wasm-transport", target_arch = "wasm32")
+))]
+use crate::envoy::ToEnvoyMessage;
+#[cfg(any(
+	feature = "native-transport",
+	all(feature = "wasm-transport", target_arch = "wasm32")
+))]
+use crate::stringify::stringify_to_envoy;
+use crate::stringify::stringify_to_rivet;
+
+#[cfg(all(feature = "native-transport", feature = "wasm-transport"))]
+compile_error!(
+	"`native-transport` and `wasm-transport` are mutually exclusive. Enable exactly one envoy-client transport."
+);
+
+#[cfg(not(any(feature = "native-transport", feature = "wasm-transport")))]
+compile_error!(
+	"rivet-envoy-client requires a WebSocket transport. Enable `native-transport` or `wasm-transport`."
+);
+
+#[cfg(feature = "native-transport")]
+mod native;
+#[cfg(feature = "wasm-transport")]
+mod wasm;
+
+#[cfg(feature = "native-transport")]
+pub use native::start_connection;
+#[cfg(feature = "wasm-transport")]
+pub use wasm::start_connection;
+
+#[cfg(any(
+	feature = "native-transport",
+	all(feature = "wasm-transport", target_arch = "wasm32")
+))]
+async fn send_initial_metadata(shared: &SharedContext) {
+	let mut prepopulate_map = HashableMap::new();
+	for (name, actor) in &shared.config.prepopulate_actor_names {
+		prepopulate_map.insert(
+			name.clone(),
+			protocol::ActorName {
+				metadata: serde_json::to_string(&actor.metadata).unwrap_or_else(|_| "{}".to_string()),
+			},
+		);
+	}
+
+	let metadata_json = shared
+		.config
+		.metadata
+		.as_ref()
+		.map(|m| serde_json::to_string(m).unwrap_or_else(|_| "{}".to_string()));
+
+	ws_send(
+		shared,
+		protocol::ToRivet::ToRivetMetadata(protocol::ToRivetMetadata {
+			prepopulate_actor_names: Some(prepopulate_map),
+			metadata: metadata_json,
+		}),
+	)
+	.await;
+}
+
+#[cfg(any(
+	feature = "native-transport",
+	all(feature = "wasm-transport", target_arch = "wasm32")
+))]
+async fn forward_to_envoy(shared: &SharedContext, message: protocol::ToEnvoy) {
+	if tracing::enabled!(tracing::Level::DEBUG) {
+		tracing::debug!(data = stringify_to_envoy(&message), "received message");
+	}
+
+	match message {
+		protocol::ToEnvoy::ToEnvoyPing(ping) => {
+			ws_send(
+				shared,
+				protocol::ToRivet::ToRivetPong(protocol::ToRivetPong { ts: ping.ts }),
+			)
+			.await;
+		}
+		other => {
+			let _ = shared
+				.envoy_tx
+				.send(ToEnvoyMessage::ConnMessage { message: other });
+		}
+	}
+}
+
+/// Send a message over the WebSocket. Returns true if the message could not be sent.
+pub async fn ws_send(shared: &SharedContext, message: protocol::ToRivet) -> bool {
+	if tracing::enabled!(tracing::Level::DEBUG) {
+		tracing::debug!(data = stringify_to_rivet(&message), "sending message");
+	}
+
+	let guard = shared.ws_tx.lock().await;
+	let Some(tx) = guard.as_ref() else {
+		tracing::error!("websocket not available for sending");
+		return true;
+	};
+
+	let encoded = crate::protocol::versioned::ToRivet::wrap_latest(message)
+		.serialize(protocol::PROTOCOL_VERSION)
+		.expect("failed to encode message");
+	let _ = tx.send(WsTxMessage::Send(encoded));
+	false
+}
+
+#[cfg(any(
+	feature = "native-transport",
+	all(feature = "wasm-transport", target_arch = "wasm32")
+))]
+fn ws_url(shared: &SharedContext) -> String {
+	let ws_endpoint = shared
+		.config
+		.endpoint
+		.replace("http://", "ws://")
+		.replace("https://", "wss://");
+	let base_url = ws_endpoint.trim_end_matches('/');
+
+	format!(
+		"{}/envoys/connect?protocol_version={}&namespace={}&envoy_key={}&version={}&pool_name={}",
+		base_url,
+		protocol::PROTOCOL_VERSION,
+		urlencoding::encode(&shared.config.namespace),
+		urlencoding::encode(&shared.envoy_key),
+		urlencoding::encode(&shared.config.version.to_string()),
+		urlencoding::encode(&shared.config.pool_name),
+	)
+}
diff --git a/engine/sdks/rust/envoy-client/src/connection.rs b/engine/sdks/rust/envoy-client/src/connection/native.rs
similarity index 65%
rename from engine/sdks/rust/envoy-client/src/connection.rs
rename to engine/sdks/rust/envoy-client/src/connection/native.rs
index 36ae280515..50631c0a33 100644
--- a/engine/sdks/rust/envoy-client/src/connection.rs
+++ b/engine/sdks/rust/envoy-client/src/connection/native.rs
@@ -3,14 +3,12 @@ use std::sync::atomic::Ordering;
 
 use futures_util::{SinkExt, StreamExt};
 use rivet_envoy_protocol as protocol;
-use rivet_util_serde::HashableMap;
 use tokio::sync::mpsc;
 use tokio_tungstenite::tungstenite;
 use vbare::OwnedVersionedData;
 
 use crate::context::{SharedContext, WsTxMessage};
 use crate::envoy::ToEnvoyMessage;
-use crate::stringify::{stringify_to_envoy, stringify_to_rivet};
 use crate::utils::{BackoffOptions, calculate_backoff, parse_ws_close_reason};
 
 const STABLE_CONNECTION_MS: u64 = 60_000;
@@ -72,7 +70,7 @@ async fn connection_loop(shared: Arc<SharedContext>) {
 async fn single_connection(
 	shared: &Arc<SharedContext>,
 ) -> anyhow::Result<Option<crate::utils::ParsedCloseReason>> {
-	let url = ws_url(shared);
+	let url = super::ws_url(shared);
 	let protocols = {
 		let mut p = vec!["rivet".to_string()];
 		if let Some(token) = &shared.config.token {
@@ -121,34 +119,7 @@ async fn single_connection(
 	// Spawn write task
 	let shared2 = shared.clone();
 	let write_handle = tokio::spawn(async move {
-		// Build prepopulate actor names map
-		let mut prepopulate_map = HashableMap::new();
-		for (name, actor) in &shared2.config.prepopulate_actor_names {
-			prepopulate_map.insert(
-				name.clone(),
-				protocol::ActorName {
-					metadata: serde_json::to_string(&actor.metadata)
-						.unwrap_or_else(|_| "{}".to_string()),
-				},
-			);
-		}
-
-		// Serialize metadata HashMap to JSON string for the protocol
-		let metadata_json = shared2
-			.config
-			.metadata
-			.as_ref()
-			.map(|m| serde_json::to_string(m).unwrap_or_else(|_| "{}".to_string()));
-
-		// Send metadata
-		ws_send(
-			&shared2,
-			protocol::ToRivet::ToRivetMetadata(protocol::ToRivetMetadata {
-				prepopulate_actor_names: Some(prepopulate_map),
-				metadata: metadata_json,
-			}),
-		)
-		.await;
+		super::send_initial_metadata(&shared2).await;
 
 		while let Some(msg) = ws_rx.recv().await {
 			match msg {
@@ -187,11 +158,7 @@ async fn single_connection(
 					protocol::PROTOCOL_VERSION,
 				)?;
 
-				if tracing::enabled!(tracing::Level::DEBUG) {
-					tracing::debug!(data = stringify_to_envoy(&decoded), "received message");
-				}
-
-				forward_to_envoy(shared, decoded).await;
+				super::forward_to_envoy(shared, decoded).await;
 			}
 			Ok(tungstenite::Message::Close(frame)) => {
 				if let Some(frame) = frame {
@@ -224,61 +191,6 @@ async fn single_connection(
 	Ok(result)
 }
 
-async fn forward_to_envoy(shared: &SharedContext, message: protocol::ToEnvoy) {
-	match message {
-		protocol::ToEnvoy::ToEnvoyPing(ping) => {
-			ws_send(
-				shared,
-				protocol::ToRivet::ToRivetPong(protocol::ToRivetPong { ts: ping.ts }),
-			)
-			.await;
-		}
-		other => {
-			let _ = shared
-				.envoy_tx
-				.send(ToEnvoyMessage::ConnMessage { message: other });
-		}
-	}
-}
-
-/// Send a message over the WebSocket. Returns true if the message could not be sent.
-pub async fn ws_send(shared: &SharedContext, message: protocol::ToRivet) -> bool {
-	if tracing::enabled!(tracing::Level::DEBUG) {
-		tracing::debug!(data = stringify_to_rivet(&message), "sending message");
-	}
-
-	let guard = shared.ws_tx.lock().await;
-	let Some(tx) = guard.as_ref() else {
-		tracing::error!("websocket not available for sending");
-		return true;
-	};
-
-	let encoded = crate::protocol::versioned::ToRivet::wrap_latest(message)
-		.serialize(protocol::PROTOCOL_VERSION)
-		.expect("failed to encode message");
-	let _ = tx.send(WsTxMessage::Send(encoded));
-	false
-}
-
-fn ws_url(shared: &SharedContext) -> String {
-	let ws_endpoint = shared
-		.config
-		.endpoint
-		.replace("http://", "ws://")
-		.replace("https://", "wss://");
-	let base_url = ws_endpoint.trim_end_matches('/');
-
-	format!(
-		"{}/envoys/connect?protocol_version={}&namespace={}&envoy_key={}&version={}&pool_name={}",
-		base_url,
-		protocol::PROTOCOL_VERSION,
-		urlencoding::encode(&shared.config.namespace),
-		urlencoding::encode(&shared.envoy_key),
-		urlencoding::encode(&shared.config.version.to_string()),
-		urlencoding::encode(&shared.config.pool_name),
-	)
-}
-
 fn extract_host(url: &str) -> String {
 	url.replace("ws://", "")
 		.replace("wss://", "")
diff --git a/engine/sdks/rust/envoy-client/src/connection/wasm.rs b/engine/sdks/rust/envoy-client/src/connection/wasm.rs
new file mode 100644
index 0000000000..2eb230b962
--- /dev/null
+++ b/engine/sdks/rust/envoy-client/src/connection/wasm.rs
@@ -0,0 +1,316 @@
+#[cfg(target_arch = "wasm32")]
+mod imp {
+	use std::sync::Arc;
+	use std::sync::atomic::Ordering;
+	use std::time::Duration;
+
+	use js_sys::{Array, Function, Promise, Reflect, Uint8Array};
+	use rivet_envoy_protocol as protocol;
+	use tokio::sync::mpsc;
+	use vbare::OwnedVersionedData;
+	use wasm_bindgen::{JsCast, JsValue, closure::Closure};
+	use wasm_bindgen_futures::JsFuture;
+	use web_sys::{BinaryType, CloseEvent, ErrorEvent, Event, MessageEvent, WebSocket};
+
+	use crate::context::{SharedContext, WsTxMessage};
+	use crate::envoy::ToEnvoyMessage;
+	use crate::utils::{BackoffOptions, calculate_backoff, parse_ws_close_reason};
+
+	const STABLE_CONNECTION_MS: u64 = 60_000;
+	const NORMAL_CLOSE_CODE: u16 = 1000;
+
+	enum ConnectionEvent {
+		Open,
+		Message(Vec<u8>),
+		Close { code: u16, reason: String },
+		Error(String),
+		WriteFailed,
+	}
+
+	pub fn start_connection(shared: Arc<SharedContext>) {
+		wasm_bindgen_futures::spawn_local(connection_loop(shared));
+	}
+
+	async fn connection_loop(shared: Arc<SharedContext>) {
+		let mut attempt = 0u32;
+
+		loop {
+			if shared.shutting_down.load(Ordering::Acquire) {
+				tracing::debug!("stopping reconnect loop because envoy is shutting down");
+				return;
+			}
+
+			let connected_at_ms = js_sys::Date::now();
+
+			match single_connection(&shared).await {
+				Ok(close_reason) => {
+					if let Some(reason) = &close_reason {
+						if reason.group == "ws" && reason.error == "eviction" {
+							tracing::debug!("connection evicted");
+							let _ = shared
+								.envoy_tx
+								.send(ToEnvoyMessage::ConnClose { evict: true });
+							return;
+						}
+					}
+					let _ = shared
+						.envoy_tx
+						.send(ToEnvoyMessage::ConnClose { evict: false });
+				}
+				Err(error) => {
+					tracing::error!(?error, "connection failed");
+					let _ = shared
+						.envoy_tx
+						.send(ToEnvoyMessage::ConnClose { evict: false });
+				}
+			}
+
+			if js_sys::Date::now() - connected_at_ms >= STABLE_CONNECTION_MS as f64 {
+				attempt = 0;
+			}
+
+			if shared.shutting_down.load(Ordering::Acquire) {
+				tracing::debug!("skipping reconnect because envoy is shutting down");
+				return;
+			}
+
+			let delay = calculate_backoff(attempt, &BackoffOptions::default());
+			tracing::info!(attempt, delay_ms = delay.as_millis() as u64, "reconnecting");
+			sleep(delay).await;
+			attempt += 1;
+		}
+	}
+
+	async fn single_connection(
+		shared: &Arc<SharedContext>,
+	) -> anyhow::Result<Option<crate::utils::ParsedCloseReason>> {
+		let url = super::super::ws_url(shared);
+		let protocols = protocols(&shared.config.token);
+		let ws = WebSocket::new_with_str_sequence(&url, protocols.as_ref())
+			.map_err(|error| anyhow::anyhow!("failed to create websocket: {}", js_error(error)))?;
+		ws.set_binary_type(BinaryType::Arraybuffer);
+
+		let (event_tx, mut event_rx) = mpsc::unbounded_channel::<ConnectionEvent>();
+
+		let onopen = {
+			let event_tx = event_tx.clone();
+			Closure::<dyn FnMut(Event)>::wrap(Box::new(move |_| {
+				let _ = event_tx.send(ConnectionEvent::Open);
+			}))
+		};
+		ws.set_onopen(Some(onopen.as_ref().unchecked_ref()));
+
+		let onmessage = {
+			let event_tx = event_tx.clone();
+			Closure::<dyn FnMut(MessageEvent)>::wrap(Box::new(move |event| {
+				let data = event.data();
+				let Some(bytes) = decode_message_data(data) else {
+					tracing::warn!("received non-binary websocket message");
+					return;
+				};
+				let _ = event_tx.send(ConnectionEvent::Message(bytes));
+			}))
+		};
+		ws.set_onmessage(Some(onmessage.as_ref().unchecked_ref()));
+
+		let onclose = {
+			let event_tx = event_tx.clone();
+			Closure::<dyn FnMut(CloseEvent)>::wrap(Box::new(move |event| {
+				let _ = event_tx.send(ConnectionEvent::Close {
+					code: event.code(),
+					reason: event.reason(),
+				});
+			}))
+		};
+		ws.set_onclose(Some(onclose.as_ref().unchecked_ref()));
+
+		let onerror = {
+			let event_tx = event_tx.clone();
+			Closure::<dyn FnMut(ErrorEvent)>::wrap(Box::new(move |event| {
+				let _ = event_tx.send(ConnectionEvent::Error(event.message()));
+			}))
+		};
+		ws.set_onerror(Some(onerror.as_ref().unchecked_ref()));
+
+		match event_rx
+			.recv()
+			.await
+			.ok_or_else(|| anyhow::anyhow!("websocket closed before opening"))?
+		{
+			ConnectionEvent::Open => {}
+			ConnectionEvent::Close { code, reason } => {
+				tracing::info!(code, reason = %reason, "websocket closed");
+				return Ok(parse_ws_close_reason(&reason));
+			}
+			ConnectionEvent::Error(message) => {
+				anyhow::bail!("websocket failed to open: {message}");
+			}
+			ConnectionEvent::Message(_) | ConnectionEvent::WriteFailed => {
+				anyhow::bail!("websocket produced an unexpected event before opening");
+			}
+		}
+
+		let (ws_tx, mut ws_rx) = mpsc::unbounded_channel::<WsTxMessage>();
+		{
+			let mut guard = shared.ws_tx.lock().await;
+			*guard = Some(ws_tx);
+		}
+
+		tracing::info!(
+			endpoint = %shared.config.endpoint,
+			namespace = %shared.config.namespace,
+			envoy_key = %shared.envoy_key,
+			has_token = shared.config.token.is_some(),
+			"websocket connected"
+		);
+
+		wasm_bindgen_futures::spawn_local({
+			let shared = shared.clone();
+			let ws = ws.clone();
+			let event_tx = event_tx.clone();
+			async move {
+				super::super::send_initial_metadata(&shared).await;
+
+				while let Some(msg) = ws_rx.recv().await {
+						match msg {
+							WsTxMessage::Send(data) => {
+								let data = Uint8Array::from(data.as_slice());
+								if let Err(error) = ws.send_with_array_buffer(&data.buffer()) {
+									tracing::error!(error = %js_error(error), "failed to send ws message");
+									let _ = event_tx.send(ConnectionEvent::WriteFailed);
+									break;
+								}
+						}
+						WsTxMessage::Close => {
+							let _ = ws.close_with_code_and_reason(NORMAL_CLOSE_CODE, "envoy.shutdown");
+							break;
+						}
+					}
+				}
+			}
+		});
+
+		let mut result = None;
+		let debug_latency_ms = shared.config.debug_latency_ms;
+
+		while let Some(event) = event_rx.recv().await {
+			match event {
+				ConnectionEvent::Open => {}
+				ConnectionEvent::Message(data) => {
+					if let Some(ms) = debug_latency_ms {
+						if ms > 0 {
+							sleep(Duration::from_millis(ms)).await;
+						}
+					}
+
+					let decoded = crate::protocol::versioned::ToEnvoy::deserialize(
+						&data,
+						protocol::PROTOCOL_VERSION,
+					)?;
+
+					super::super::forward_to_envoy(shared, decoded).await;
+				}
+				ConnectionEvent::Close { code, reason } => {
+					tracing::info!(code, reason = %reason, "websocket closed");
+					result = parse_ws_close_reason(&reason);
+					break;
+				}
+				ConnectionEvent::Error(message) => {
+					tracing::error!(message = %message, "websocket error");
+					break;
+				}
+				ConnectionEvent::WriteFailed => {
+					break;
+				}
+			}
+		}
+
+		{
+			let mut guard = shared.ws_tx.lock().await;
+			*guard = None;
+		}
+
+		close_if_open(&ws);
+		ws.set_onopen(None);
+		ws.set_onmessage(None);
+		ws.set_onclose(None);
+		ws.set_onerror(None);
+		drop((onopen, onmessage, onclose, onerror));
+
+		Ok(result)
+	}
+
+	fn protocols(token: &Option<String>) -> JsValue {
+		let protocols = Array::new();
+		protocols.push(&JsValue::from_str("rivet"));
+		if let Some(token) = token {
+			protocols.push(&JsValue::from_str(&format!("rivet_token.{token}")));
+		}
+		protocols.into()
+	}
+
+	fn decode_message_data(data: JsValue) -> Option<Vec<u8>> {
+		if let Some(buffer) = data.dyn_ref::<js_sys::ArrayBuffer>() {
+			return Some(uint8_array_to_vec(&Uint8Array::new(buffer)));
+		}
+
+		if let Some(array) = data.dyn_ref::<Uint8Array>() {
+			return Some(uint8_array_to_vec(array));
+		}
+
+		None
+	}
+
+	fn uint8_array_to_vec(array: &Uint8Array) -> Vec<u8> {
+		let mut bytes = vec![0; array.length() as usize];
+		array.copy_to(&mut bytes);
+		bytes
+	}
+
+	fn close_if_open(ws: &WebSocket) {
+		let state = ws.ready_state();
+		if state == WebSocket::CONNECTING || state == WebSocket::OPEN {
+			let _ = ws.close();
+		}
+	}
+
+	async fn sleep(delay: Duration) {
+		let delay_ms = delay.as_millis().min(u32::MAX as u128) as f64;
+		let promise = Promise::new(&mut |resolve, _reject| {
+			let global = js_sys::global();
+			let set_timeout = Reflect::get(&global, &JsValue::from_str("setTimeout"))
+				.ok()
+				.and_then(|value| value.dyn_into::<Function>().ok());
+
+			if let Some(set_timeout) = set_timeout {
+				let _ = set_timeout.call2(&global, &resolve, &JsValue::from_f64(delay_ms));
+			} else {
+				let _ = resolve.call0(&JsValue::UNDEFINED);
+			}
+		});
+
+		let _ = JsFuture::from(promise).await;
+	}
+
+	fn js_error(error: JsValue) -> String {
+		error
+			.as_string()
+			.or_else(|| js_sys::JSON::stringify(&error).ok().and_then(|s| s.as_string()))
+			.unwrap_or_else(|| "unknown JavaScript error".to_string())
+	}
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+mod imp {
+	use std::sync::Arc;
+
+	use crate::context::SharedContext;
+	use crate::envoy::ToEnvoyMessage;
+
+	pub fn start_connection(shared: Arc<SharedContext>) {
+		let _ = shared.envoy_tx.send(ToEnvoyMessage::ConnClose { evict: false });
+		tracing::error!("wasm envoy transport requires the wasm32 target");
+	}
+}
+
+pub use imp::start_connection;
diff --git a/engine/sdks/rust/envoy-client/src/context.rs b/engine/sdks/rust/envoy-client/src/context.rs
index f1d69f0654..56347564d7 100644
--- a/engine/sdks/rust/envoy-client/src/context.rs
+++ b/engine/sdks/rust/envoy-client/src/context.rs
@@ -4,7 +4,7 @@ use std::sync::Mutex as StdMutex;
 use std::sync::atomic::AtomicBool;
 
 use rivet_envoy_protocol as protocol;
-use rivet_util::async_counter::AsyncCounter;
+use crate::async_counter::AsyncCounter;
 use tokio::sync::Mutex;
 use tokio::sync::mpsc;
 use tokio::sync::watch;
diff --git a/engine/sdks/rust/envoy-client/src/envoy.rs b/engine/sdks/rust/envoy-client/src/envoy.rs
index c932d9c0f0..b79e28e4af 100644
--- a/engine/sdks/rust/envoy-client/src/envoy.rs
+++ b/engine/sdks/rust/envoy-client/src/envoy.rs
@@ -1,12 +1,14 @@
 use std::collections::HashMap;
 use std::sync::Arc;
+#[cfg(not(target_arch = "wasm32"))]
 use std::sync::OnceLock;
 use std::sync::atomic::Ordering;
 
+#[cfg(not(target_arch = "wasm32"))]
 use parking_lot::Mutex;
 
 use rivet_envoy_protocol as protocol;
-use rivet_util::async_counter::AsyncCounter;
+use crate::async_counter::AsyncCounter;
 use tokio::sync::mpsc;
 use tokio::sync::oneshot;
 
@@ -22,18 +24,24 @@ use crate::kv::{
 	handle_kv_response, process_unsent_kv_requests,
 };
 use crate::sqlite::{
-	SqliteRequest, SqliteRequestEntry, SqliteResponse, cleanup_old_sqlite_requests,
+	RemoteSqliteRequest, RemoteSqliteRequestEntry, RemoteSqliteResponse, SqliteRequest,
+	SqliteRequestEntry, SqliteResponse, cleanup_old_remote_sqlite_requests,
+	cleanup_old_sqlite_requests, fail_remote_sqlite_requests_with_shutdown,
+	fail_sent_remote_sqlite_requests_with_indeterminate_result, fail_sqlite_requests_with_shutdown,
+	handle_remote_sqlite_exec_response, handle_remote_sqlite_execute_response,
+	handle_remote_sqlite_execute_write_response, handle_remote_sqlite_request,
 	handle_sqlite_commit_response, handle_sqlite_get_pages_response, handle_sqlite_request,
-	process_unsent_sqlite_requests,
+	process_unsent_remote_sqlite_requests, process_unsent_sqlite_requests,
 };
 use crate::tunnel::{
 	handle_tunnel_message, resend_buffered_tunnel_messages, send_hibernatable_ws_message_ack,
 };
-use crate::utils::{BufferMap, EnvoyShutdownError};
+use crate::utils::{BufferMap, EnvoyShutdownError, SleepFuture, boxed_sleep, spawn_detached};
 
 /// Process-wide envoy slot. Holds the handle inside a mutex so a stopped
 /// handle (e.g. from a shutdown-during-build race in serverless mode) can be
 /// replaced on the next `start_envoy_sync` call.
+#[cfg(not(target_arch = "wasm32"))]
 static GLOBAL_ENVOY: OnceLock<Mutex<Option<EnvoyHandle>>> = OnceLock::new();
 
 pub struct EnvoyContext {
@@ -45,6 +53,8 @@ pub struct EnvoyContext {
 	pub next_kv_request_id: u32,
 	pub sqlite_requests: HashMap<u32, SqliteRequestEntry>,
 	pub next_sqlite_request_id: u32,
+	pub remote_sqlite_requests: HashMap<u32, RemoteSqliteRequestEntry>,
+	pub next_remote_sqlite_request_id: u32,
 	pub request_to_actor: BufferMap<String>,
 	pub buffered_messages: Vec<protocol::ToRivetTunnelMessage>,
 	/// Highest command index processed per `(actor_id, generation)`, used to
@@ -93,6 +103,10 @@ pub enum ToEnvoyMessage {
 		request: SqliteRequest,
 		response_tx: oneshot::Sender<anyhow::Result<SqliteResponse>>,
 	},
+	RemoteSqliteRequest {
+		request: RemoteSqliteRequest,
+		response_tx: oneshot::Sender<anyhow::Result<RemoteSqliteResponse>>,
+	},
 	BufferTunnelMsg {
 		msg: protocol::ToRivetTunnelMessage,
 	},
@@ -249,20 +263,28 @@ pub async fn start_envoy(config: EnvoyConfig) -> EnvoyHandle {
 }
 
 pub fn start_envoy_sync(config: EnvoyConfig) -> EnvoyHandle {
-	if config.not_global {
-		return start_envoy_sync_inner(config);
+	#[cfg(target_arch = "wasm32")]
+	{
+		start_envoy_sync_inner(config)
 	}
 
-	let slot = GLOBAL_ENVOY.get_or_init(|| Mutex::new(None));
-	let mut guard = slot.lock();
-	if let Some(handle) = guard.as_ref() {
-		if !handle.is_stopped() {
-			return handle.clone();
+	#[cfg(not(target_arch = "wasm32"))]
+	{
+		if config.not_global {
+			return start_envoy_sync_inner(config);
+		}
+
+		let slot = GLOBAL_ENVOY.get_or_init(|| Mutex::new(None));
+		let mut guard = slot.lock();
+		if let Some(handle) = guard.as_ref() {
+			if !handle.is_stopped() {
+				return handle.clone();
+			}
 		}
+		let handle = start_envoy_sync_inner(config);
+		*guard = Some(handle.clone());
+		handle
 	}
-	let handle = start_envoy_sync_inner(config);
-	*guard = Some(handle.clone());
-	handle
 }
 
 fn start_envoy_sync_inner(config: EnvoyConfig) -> EnvoyHandle {
@@ -300,6 +322,8 @@ fn start_envoy_sync_inner(config: EnvoyConfig) -> EnvoyHandle {
 		next_kv_request_id: 0,
 		sqlite_requests: HashMap::new(),
 		next_sqlite_request_id: 0,
+		remote_sqlite_requests: HashMap::new(),
+		next_remote_sqlite_request_id: 0,
 		request_to_actor: BufferMap::new(),
 		buffered_messages: Vec::new(),
 		processed_command_idx: HashMap::new(),
@@ -307,7 +331,7 @@ fn start_envoy_sync_inner(config: EnvoyConfig) -> EnvoyHandle {
 
 	tracing::info!("starting envoy");
 
-	tokio::spawn(envoy_loop(ctx, envoy_rx, start_tx));
+	spawn_detached(envoy_loop(ctx, envoy_rx, start_tx));
 
 	handle
 }
@@ -317,12 +341,11 @@ async fn envoy_loop(
 	mut rx: mpsc::UnboundedReceiver<ToEnvoyMessage>,
 	start_tx: tokio::sync::watch::Sender<()>,
 ) {
-	let mut ack_interval =
-		tokio::time::interval(std::time::Duration::from_millis(ACK_COMMANDS_INTERVAL_MS));
-	let mut kv_cleanup_interval =
-		tokio::time::interval(std::time::Duration::from_millis(KV_CLEANUP_INTERVAL_MS));
+	let mut ack_tick = boxed_sleep(std::time::Duration::from_millis(ACK_COMMANDS_INTERVAL_MS));
+	let mut kv_cleanup_tick =
+		boxed_sleep(std::time::Duration::from_millis(KV_CLEANUP_INTERVAL_MS));
 
-	let mut lost_timeout: Option<std::pin::Pin<Box<tokio::time::Sleep>>> = None;
+	let mut lost_timeout: Option<SleepFuture> = None;
 
 	loop {
 		tokio::select! {
@@ -334,6 +357,7 @@ async fn envoy_loop(
 						lost_timeout = handle_conn_message(&mut ctx, &start_tx, lost_timeout, message).await;
 					}
 					ToEnvoyMessage::ConnClose { evict } => {
+						fail_sent_remote_sqlite_requests_with_indeterminate_result(&mut ctx);
 						lost_timeout = handle_conn_close(&ctx, lost_timeout);
 						if evict { break; }
 					}
@@ -346,6 +370,9 @@ async fn envoy_loop(
 					ToEnvoyMessage::SqliteRequest { request, response_tx } => {
 						handle_sqlite_request(&mut ctx, request, response_tx).await;
 					}
+					ToEnvoyMessage::RemoteSqliteRequest { request, response_tx } => {
+						handle_remote_sqlite_request(&mut ctx, request, response_tx).await;
+					}
 					ToEnvoyMessage::BufferTunnelMsg { msg } => {
 						ctx.buffered_messages.push(msg);
 					}
@@ -399,12 +426,15 @@ async fn envoy_loop(
 					}
 				}
 			}
-			_ = ack_interval.tick() => {
+			_ = ack_tick.as_mut() => {
 				send_command_ack(&mut ctx).await;
+				ack_tick = boxed_sleep(std::time::Duration::from_millis(ACK_COMMANDS_INTERVAL_MS));
 			}
-			_ = kv_cleanup_interval.tick() => {
+			_ = kv_cleanup_tick.as_mut() => {
 				cleanup_old_kv_requests(&mut ctx);
 				cleanup_old_sqlite_requests(&mut ctx);
+				cleanup_old_remote_sqlite_requests(&mut ctx);
+				kv_cleanup_tick = boxed_sleep(std::time::Duration::from_millis(KV_CLEANUP_INTERVAL_MS));
 			}
 			_ = async {
 				match lost_timeout.as_mut() {
@@ -416,9 +446,8 @@ async fn envoy_loop(
 				for (_id, request) in ctx.kv_requests.drain() {
 					let _ = request.response_tx.send(Err(anyhow::anyhow!(EnvoyShutdownError)));
 				}
-				for (_id, request) in ctx.sqlite_requests.drain() {
-					let _ = request.response_tx.send(Err(anyhow::anyhow!(EnvoyShutdownError)));
-				}
+				fail_sqlite_requests_with_shutdown(&mut ctx);
+				fail_remote_sqlite_requests_with_shutdown(&mut ctx);
 
 				if !ctx.actors.is_empty() {
 					tracing::warn!("stopping all actors due to envoy lost threshold");
@@ -455,11 +484,8 @@ async fn envoy_loop(
 			.response_tx
 			.send(Err(anyhow::anyhow!("envoy shutting down")));
 	}
-	for (_id, request) in ctx.sqlite_requests.drain() {
-		let _ = request
-			.response_tx
-			.send(Err(anyhow::anyhow!("envoy shutting down")));
-	}
+	fail_sqlite_requests_with_shutdown(&mut ctx);
+	fail_remote_sqlite_requests_with_shutdown(&mut ctx);
 
 	ctx.actors.clear();
 	ctx.shared
@@ -481,9 +507,9 @@ async fn envoy_loop(
 async fn handle_conn_message(
 	ctx: &mut EnvoyContext,
 	start_tx: &tokio::sync::watch::Sender<()>,
-	mut lost_timeout: Option<std::pin::Pin<Box<tokio::time::Sleep>>>,
+	mut lost_timeout: Option<SleepFuture>,
 	message: protocol::ToEnvoy,
-) -> Option<std::pin::Pin<Box<tokio::time::Sleep>>> {
+) -> Option<SleepFuture> {
 	match message {
 		protocol::ToEnvoy::ToEnvoyInit(init) => {
 			{
@@ -496,6 +522,7 @@ async fn handle_conn_message(
 			resend_unacknowledged_events(ctx).await;
 			process_unsent_kv_requests(ctx).await;
 			process_unsent_sqlite_requests(ctx).await;
+			process_unsent_remote_sqlite_requests(ctx).await;
 			resend_buffered_tunnel_messages(ctx).await;
 
 			let _ = start_tx.send(());
@@ -512,12 +539,21 @@ async fn handle_conn_message(
 		protocol::ToEnvoy::ToEnvoySqliteGetPagesResponse(response) => {
 			handle_sqlite_get_pages_response(ctx, response).await;
 		}
-			protocol::ToEnvoy::ToEnvoySqliteCommitResponse(response) => {
-				handle_sqlite_commit_response(ctx, response).await;
-			}
-			protocol::ToEnvoy::ToEnvoyTunnelMessage(tunnel_msg) => {
-				handle_tunnel_message(ctx, tunnel_msg).await;
-			}
+		protocol::ToEnvoy::ToEnvoySqliteCommitResponse(response) => {
+			handle_sqlite_commit_response(ctx, response).await;
+		}
+		protocol::ToEnvoy::ToEnvoySqliteExecResponse(response) => {
+			handle_remote_sqlite_exec_response(ctx, response).await;
+		}
+		protocol::ToEnvoy::ToEnvoySqliteExecuteResponse(response) => {
+			handle_remote_sqlite_execute_response(ctx, response).await;
+		}
+		protocol::ToEnvoy::ToEnvoySqliteExecuteWriteResponse(response) => {
+			handle_remote_sqlite_execute_write_response(ctx, response).await;
+		}
+		protocol::ToEnvoy::ToEnvoyTunnelMessage(tunnel_msg) => {
+			handle_tunnel_message(ctx, tunnel_msg).await;
+		}
 		protocol::ToEnvoy::ToEnvoyPing(_) => {
 			// Should be handled by connection task
 		}
@@ -528,8 +564,8 @@ async fn handle_conn_message(
 
 fn handle_conn_close(
 	ctx: &EnvoyContext,
-	lost_timeout: Option<std::pin::Pin<Box<tokio::time::Sleep>>>,
-) -> Option<std::pin::Pin<Box<tokio::time::Sleep>>> {
+	lost_timeout: Option<SleepFuture>,
+) -> Option<SleepFuture> {
 	if lost_timeout.is_some() {
 		return lost_timeout;
 	}
@@ -544,9 +580,7 @@ fn handle_conn_close(
 
 	tracing::debug!(ms = lost_threshold, "starting envoy lost timeout");
 
-	Some(Box::pin(tokio::time::sleep(
-		std::time::Duration::from_millis(lost_threshold),
-	)))
+	Some(boxed_sleep(std::time::Duration::from_millis(lost_threshold)))
 }
 
 async fn handle_shutdown(ctx: &mut EnvoyContext) {
@@ -571,7 +605,7 @@ async fn handle_shutdown(ctx: &mut EnvoyContext) {
 		.collect();
 
 	let envoy_tx = ctx.shared.envoy_tx.clone();
-	tokio::spawn(async move {
+	spawn_detached(async move {
 		futures_util::future::join_all(actor_handles.iter().map(|h| h.closed())).await;
 		tracing::debug!("all actors stopped during graceful shutdown");
 		let _ = envoy_tx.send(ToEnvoyMessage::Stop);
diff --git a/engine/sdks/rust/envoy-client/src/events.rs b/engine/sdks/rust/envoy-client/src/events.rs
index 3dc4bce884..806a7f812b 100644
--- a/engine/sdks/rust/envoy-client/src/events.rs
+++ b/engine/sdks/rust/envoy-client/src/events.rs
@@ -79,7 +79,7 @@ mod tests {
 	use std::sync::Arc;
 
 	use rivet_envoy_protocol as protocol;
-	use rivet_util::async_counter::AsyncCounter;
+	use crate::async_counter::AsyncCounter;
 	use tokio::sync::mpsc;
 
 	use super::handle_send_events;
@@ -187,6 +187,8 @@ mod tests {
 				next_kv_request_id: 0,
 				sqlite_requests: HashMap::new(),
 				next_sqlite_request_id: 0,
+				remote_sqlite_requests: HashMap::new(),
+				next_remote_sqlite_request_id: 0,
 				request_to_actor: crate::utils::BufferMap::new(),
 				buffered_messages: Vec::new(),
 				processed_command_idx: HashMap::new(),
diff --git a/engine/sdks/rust/envoy-client/src/handle.rs b/engine/sdks/rust/envoy-client/src/handle.rs
index 63ed1f5cbf..5e3af875ec 100644
--- a/engine/sdks/rust/envoy-client/src/handle.rs
+++ b/engine/sdks/rust/envoy-client/src/handle.rs
@@ -2,12 +2,12 @@ use std::sync::Arc;
 use std::sync::atomic::Ordering;
 
 use rivet_envoy_protocol as protocol;
-use rivet_util::async_counter::AsyncCounter;
+use crate::async_counter::AsyncCounter;
 use tokio::sync::oneshot;
 
 use crate::context::SharedContext;
 use crate::envoy::{ActorInfo, ToEnvoyMessage};
-use crate::sqlite::{SqliteRequest, SqliteResponse};
+use crate::sqlite::{RemoteSqliteRequest, RemoteSqliteResponse, SqliteRequest, SqliteResponse};
 use crate::tunnel::HibernatingWebSocketMetadata;
 
 /// Handle for interacting with the envoy from callbacks.
@@ -46,7 +46,7 @@ impl EnvoyHandle {
 	///
 	/// Returning does NOT imply successful delivery of pending KV/SQLite/tunnel
 	/// requests. The cleanup block errors out every outstanding request with
-	/// `"envoy shutting down"`. Callers needing durability must wait on individual
+	/// `EnvoyShutdownError`. Callers needing durability must wait on individual
 	/// request acks before invoking shutdown.
 	///
 	/// Latched: safe to call before, during, or after the envoy loop exits.
@@ -406,29 +406,55 @@ impl EnvoyHandle {
 		}
 	}
 
-	pub async fn sqlite_get_page_range(
+	pub async fn sqlite_commit(
 		&self,
-		request: protocol::SqliteGetPageRangeRequest,
-	) -> anyhow::Result<protocol::SqliteGetPageRangeResponse> {
+		request: protocol::SqliteCommitRequest,
+	) -> anyhow::Result<protocol::SqliteCommitResponse> {
 		match self
-			.send_sqlite_request(SqliteRequest::GetPageRange(request))
+			.send_sqlite_request(SqliteRequest::Commit(request))
 			.await?
 		{
-			SqliteResponse::GetPageRange(response) => Ok(response),
-			_ => anyhow::bail!("unexpected sqlite get_page_range response type"),
+			SqliteResponse::Commit(response) => Ok(response),
+			_ => anyhow::bail!("unexpected sqlite commit response type"),
 		}
 	}
 
-	pub async fn sqlite_commit(
+	pub async fn remote_sqlite_exec(
 		&self,
-		request: protocol::SqliteCommitRequest,
-	) -> anyhow::Result<protocol::SqliteCommitResponse> {
+		request: protocol::SqliteExecRequest,
+	) -> anyhow::Result<protocol::SqliteExecResponse> {
 		match self
-			.send_sqlite_request(SqliteRequest::Commit(request))
+			.send_remote_sqlite_request(RemoteSqliteRequest::Exec(request))
 			.await?
 		{
-			SqliteResponse::Commit(response) => Ok(response),
-			_ => anyhow::bail!("unexpected sqlite commit response type"),
+			RemoteSqliteResponse::Exec(response) => Ok(response),
+			_ => anyhow::bail!("unexpected remote sqlite exec response type"),
+		}
+	}
+
+	pub async fn remote_sqlite_execute(
+		&self,
+		request: protocol::SqliteExecuteRequest,
+	) -> anyhow::Result<protocol::SqliteExecuteResponse> {
+		match self
+			.send_remote_sqlite_request(RemoteSqliteRequest::Execute(request))
+			.await?
+		{
+			RemoteSqliteResponse::Execute(response) => Ok(response),
+			_ => anyhow::bail!("unexpected remote sqlite execute response type"),
+		}
+	}
+
+	pub async fn remote_sqlite_execute_write(
+		&self,
+		request: protocol::SqliteExecuteWriteRequest,
+	) -> anyhow::Result<protocol::SqliteExecuteWriteResponse> {
+		match self
+			.send_remote_sqlite_request(RemoteSqliteRequest::ExecuteWrite(request))
+			.await?
+		{
+			RemoteSqliteResponse::ExecuteWrite(response) => Ok(response),
+			_ => anyhow::bail!("unexpected remote sqlite execute_write response type"),
 		}
 	}
 
@@ -556,6 +582,22 @@ impl EnvoyHandle {
 		rx.await
 			.map_err(|_| anyhow::anyhow!("sqlite response channel closed"))?
 	}
+
+	async fn send_remote_sqlite_request(
+		&self,
+		request: RemoteSqliteRequest,
+	) -> anyhow::Result<RemoteSqliteResponse> {
+		let (tx, rx) = tokio::sync::oneshot::channel();
+		self.shared
+			.envoy_tx
+			.send(ToEnvoyMessage::RemoteSqliteRequest {
+				request,
+				response_tx: tx,
+			})
+			.map_err(|_| anyhow::anyhow!("envoy channel closed"))?;
+		rx.await
+			.map_err(|_| anyhow::anyhow!("remote sqlite response channel closed"))?
+	}
 }
 
 fn make_ws_key(gateway_id: &protocol::GatewayId, request_id: &protocol::RequestId) -> [u8; 8] {
diff --git a/engine/sdks/rust/envoy-client/src/kv.rs b/engine/sdks/rust/envoy-client/src/kv.rs
index df073c036b..1088aa902a 100644
--- a/engine/sdks/rust/envoy-client/src/kv.rs
+++ b/engine/sdks/rust/envoy-client/src/kv.rs
@@ -9,7 +9,7 @@ pub struct KvRequestEntry {
 	pub data: protocol::KvRequestData,
 	pub response_tx: oneshot::Sender<anyhow::Result<protocol::KvResponseData>>,
 	pub sent: bool,
-	pub timestamp: std::time::Instant,
+	pub timestamp: crate::time::Instant,
 }
 
 pub const KV_EXPIRE_MS: u64 = 30_000;
@@ -29,7 +29,7 @@ pub async fn handle_kv_request(
 		data,
 		response_tx,
 		sent: false,
-		timestamp: std::time::Instant::now(),
+		timestamp: crate::time::Instant::now(),
 	};
 
 	ctx.kv_requests.insert(request_id, entry);
@@ -86,7 +86,7 @@ pub async fn send_single_kv_request(ctx: &mut EnvoyContext, request_id: u32) {
 	// Re-get after async call
 	if let Some(request) = ctx.kv_requests.get_mut(&request_id) {
 		request.sent = true;
-		request.timestamp = std::time::Instant::now();
+		request.timestamp = crate::time::Instant::now();
 	}
 }
 
@@ -113,7 +113,7 @@ pub async fn process_unsent_kv_requests(ctx: &mut EnvoyContext) {
 }
 
 pub fn cleanup_old_kv_requests(ctx: &mut EnvoyContext) {
-	let now = std::time::Instant::now();
+	let now = crate::time::Instant::now();
 	let mut to_delete = Vec::new();
 
 	for (request_id, request) in &ctx.kv_requests {
diff --git a/engine/sdks/rust/envoy-client/src/latency_channel.rs b/engine/sdks/rust/envoy-client/src/latency_channel.rs
index 0605838941..97ab9ddca9 100644
--- a/engine/sdks/rust/envoy-client/src/latency_channel.rs
+++ b/engine/sdks/rust/envoy-client/src/latency_channel.rs
@@ -2,6 +2,8 @@ use std::time::Duration;
 
 use tokio::sync::mpsc;
 
+use crate::utils::sleep;
+
 /// Debug-only wrapper around an `mpsc::UnboundedReceiver` that injects configurable
 /// latency on each receive. Used for testing reconnection behavior under latency.
 pub struct LatencyReceiver<T> {
@@ -20,7 +22,7 @@ impl<T> LatencyReceiver<T> {
 	pub async fn recv(&mut self) -> Option<T> {
 		let item = self.rx.recv().await?;
 		if let Some(latency) = self.latency {
-			tokio::time::sleep(latency).await;
+			sleep(latency).await;
 		}
 		Some(item)
 	}
diff --git a/engine/sdks/rust/envoy-client/src/lib.rs b/engine/sdks/rust/envoy-client/src/lib.rs
index 89b8907bfa..3126f06573 100644
--- a/engine/sdks/rust/envoy-client/src/lib.rs
+++ b/engine/sdks/rust/envoy-client/src/lib.rs
@@ -1,4 +1,5 @@
 pub mod actor;
+pub mod async_counter;
 pub mod commands;
 pub mod config;
 pub mod connection;
@@ -10,6 +11,12 @@ pub mod kv;
 pub mod latency_channel;
 pub mod sqlite;
 pub mod stringify;
+pub(crate) mod time {
+	#[cfg(not(target_arch = "wasm32"))]
+	pub use std::time::Instant;
+	#[cfg(target_arch = "wasm32")]
+	pub use web_time::Instant;
+}
 pub mod tunnel;
 pub mod utils;
 
diff --git a/engine/sdks/rust/envoy-client/src/sqlite.rs b/engine/sdks/rust/envoy-client/src/sqlite.rs
index c7c1ff9865..a18e7c3c53 100644
--- a/engine/sdks/rust/envoy-client/src/sqlite.rs
+++ b/engine/sdks/rust/envoy-client/src/sqlite.rs
@@ -4,25 +4,55 @@ use tokio::sync::oneshot;
 use crate::connection::ws_send;
 use crate::envoy::EnvoyContext;
 use crate::kv::KV_EXPIRE_MS;
+use crate::utils::{EnvoyShutdownError, RemoteSqliteIndeterminateResultError};
 
 #[derive(Clone)]
 pub enum SqliteRequest {
 	GetPages(protocol::SqliteGetPagesRequest),
-	GetPageRange(protocol::SqliteGetPageRangeRequest),
 	Commit(protocol::SqliteCommitRequest),
 }
 
 pub enum SqliteResponse {
 	GetPages(protocol::SqliteGetPagesResponse),
-	GetPageRange(protocol::SqliteGetPageRangeResponse),
 	Commit(protocol::SqliteCommitResponse),
 }
 
+#[derive(Clone, Debug)]
+pub enum RemoteSqliteRequest {
+	Exec(protocol::SqliteExecRequest),
+	Execute(protocol::SqliteExecuteRequest),
+	ExecuteWrite(protocol::SqliteExecuteWriteRequest),
+}
+
+#[derive(Debug)]
+pub enum RemoteSqliteResponse {
+	Exec(protocol::SqliteExecResponse),
+	Execute(protocol::SqliteExecuteResponse),
+	ExecuteWrite(protocol::SqliteExecuteWriteResponse),
+}
+
+impl RemoteSqliteRequest {
+	fn operation(&self) -> &'static str {
+		match self {
+			RemoteSqliteRequest::Exec(_) => "exec",
+			RemoteSqliteRequest::Execute(_) => "execute",
+			RemoteSqliteRequest::ExecuteWrite(_) => "execute_write",
+		}
+	}
+}
+
 pub struct SqliteRequestEntry {
 	pub request: SqliteRequest,
 	pub response_tx: oneshot::Sender<anyhow::Result<SqliteResponse>>,
 	pub sent: bool,
-	pub timestamp: std::time::Instant,
+	pub timestamp: crate::time::Instant,
+}
+
+pub struct RemoteSqliteRequestEntry {
+	pub request: RemoteSqliteRequest,
+	pub response_tx: oneshot::Sender<anyhow::Result<RemoteSqliteResponse>>,
+	pub sent: bool,
+	pub timestamp: crate::time::Instant,
 }
 
 pub async fn handle_sqlite_request(
@@ -37,7 +67,7 @@ pub async fn handle_sqlite_request(
 		request,
 		response_tx,
 		sent: false,
-		timestamp: std::time::Instant::now(),
+		timestamp: crate::time::Instant::now(),
 	};
 
 	ctx.sqlite_requests.insert(request_id, entry);
@@ -52,6 +82,33 @@ pub async fn handle_sqlite_request(
 	}
 }
 
+pub async fn handle_remote_sqlite_request(
+	ctx: &mut EnvoyContext,
+	request: RemoteSqliteRequest,
+	response_tx: oneshot::Sender<anyhow::Result<RemoteSqliteResponse>>,
+) {
+	let request_id = ctx.next_remote_sqlite_request_id;
+	ctx.next_remote_sqlite_request_id += 1;
+
+	let entry = RemoteSqliteRequestEntry {
+		request,
+		response_tx,
+		sent: false,
+		timestamp: crate::time::Instant::now(),
+	};
+
+	ctx.remote_sqlite_requests.insert(request_id, entry);
+
+	let ws_available = {
+		let guard = ctx.shared.ws_tx.lock().await;
+		guard.is_some()
+	};
+
+	if ws_available {
+		send_single_remote_sqlite_request(ctx, request_id).await;
+	}
+}
+
 pub async fn handle_sqlite_get_pages_response(
 	ctx: &mut EnvoyContext,
 	response: protocol::ToEnvoySqliteGetPagesResponse,
@@ -64,27 +121,51 @@ pub async fn handle_sqlite_get_pages_response(
 	);
 }
 
-pub async fn handle_sqlite_get_page_range_response(
+pub async fn handle_sqlite_commit_response(
 	ctx: &mut EnvoyContext,
-	response: protocol::ToEnvoySqliteGetPageRangeResponse,
+	response: protocol::ToEnvoySqliteCommitResponse,
 ) {
 	handle_sqlite_response(
 		ctx,
 		response.request_id,
-		SqliteResponse::GetPageRange(response.data),
-		"sqlite_get_page_range",
+		SqliteResponse::Commit(response.data),
+		"sqlite_commit",
 	);
 }
 
-pub async fn handle_sqlite_commit_response(
+pub async fn handle_remote_sqlite_exec_response(
 	ctx: &mut EnvoyContext,
-	response: protocol::ToEnvoySqliteCommitResponse,
+	response: protocol::ToEnvoySqliteExecResponse,
 ) {
-	handle_sqlite_response(
+	handle_remote_sqlite_response(
 		ctx,
 		response.request_id,
-		SqliteResponse::Commit(response.data),
-		"sqlite_commit",
+		RemoteSqliteResponse::Exec(response.data),
+		"remote_sqlite_exec",
+	);
+}
+
+pub async fn handle_remote_sqlite_execute_response(
+	ctx: &mut EnvoyContext,
+	response: protocol::ToEnvoySqliteExecuteResponse,
+) {
+	handle_remote_sqlite_response(
+		ctx,
+		response.request_id,
+		RemoteSqliteResponse::Execute(response.data),
+		"remote_sqlite_execute",
+	);
+}
+
+pub async fn handle_remote_sqlite_execute_write_response(
+	ctx: &mut EnvoyContext,
+	response: protocol::ToEnvoySqliteExecuteWriteResponse,
+) {
+	handle_remote_sqlite_response(
+		ctx,
+		response.request_id,
+		RemoteSqliteResponse::ExecuteWrite(response.data),
+		"remote_sqlite_execute_write",
 	);
 }
 
@@ -107,6 +188,25 @@ fn handle_sqlite_response(
 	}
 }
 
+fn handle_remote_sqlite_response(
+	ctx: &mut EnvoyContext,
+	request_id: u32,
+	response: RemoteSqliteResponse,
+	op: &str,
+) {
+	let request = ctx.remote_sqlite_requests.remove(&request_id);
+
+	if let Some(request) = request {
+		let _ = request.response_tx.send(Ok(response));
+	} else {
+		tracing::error!(
+			request_id,
+			op,
+			"received remote sqlite response for unknown request id"
+		);
+	}
+}
+
 pub async fn send_single_sqlite_request(ctx: &mut EnvoyContext, request_id: u32) {
 	let request = ctx.sqlite_requests.get_mut(&request_id);
 	let Some(request) = request else { return };
@@ -119,11 +219,6 @@ pub async fn send_single_sqlite_request(ctx: &mut EnvoyContext, request_id: u32)
 			SqliteRequest::GetPages(data) => protocol::ToRivet::ToRivetSqliteGetPagesRequest(
 				protocol::ToRivetSqliteGetPagesRequest { request_id, data },
 			),
-			SqliteRequest::GetPageRange(data) => {
-				protocol::ToRivet::ToRivetSqliteGetPageRangeRequest(
-					protocol::ToRivetSqliteGetPageRangeRequest { request_id, data },
-				)
-			}
 			SqliteRequest::Commit(data) => protocol::ToRivet::ToRivetSqliteCommitRequest(
 				protocol::ToRivetSqliteCommitRequest { request_id, data },
 			),
@@ -133,7 +228,49 @@ pub async fn send_single_sqlite_request(ctx: &mut EnvoyContext, request_id: u32)
 
 	if let Some(request) = ctx.sqlite_requests.get_mut(&request_id) {
 		request.sent = true;
-		request.timestamp = std::time::Instant::now();
+		request.timestamp = crate::time::Instant::now();
+	}
+}
+
+pub async fn send_single_remote_sqlite_request(ctx: &mut EnvoyContext, request_id: u32) {
+	let request = ctx.remote_sqlite_requests.get_mut(&request_id);
+	let Some(request) = request else { return };
+	if request.sent {
+		return;
+	}
+
+	let message = remote_sqlite_request_to_message(request_id, request.request.clone());
+
+	ws_send(&ctx.shared, message).await;
+
+	if let Some(request) = ctx.remote_sqlite_requests.get_mut(&request_id) {
+		request.sent = true;
+		request.timestamp = crate::time::Instant::now();
+	}
+}
+
+pub fn remote_sqlite_request_to_message(
+	request_id: u32,
+	request: RemoteSqliteRequest,
+) -> protocol::ToRivet {
+	match request {
+		RemoteSqliteRequest::Exec(data) => {
+			protocol::ToRivet::ToRivetSqliteExecRequest(protocol::ToRivetSqliteExecRequest {
+				request_id,
+				data,
+			})
+		}
+		RemoteSqliteRequest::Execute(data) => {
+			protocol::ToRivet::ToRivetSqliteExecuteRequest(protocol::ToRivetSqliteExecuteRequest {
+				request_id,
+				data,
+			})
+		}
+		RemoteSqliteRequest::ExecuteWrite(data) => {
+			protocol::ToRivet::ToRivetSqliteExecuteWriteRequest(
+				protocol::ToRivetSqliteExecuteWriteRequest { request_id, data },
+			)
+		}
 	}
 }
 
@@ -159,8 +296,30 @@ pub async fn process_unsent_sqlite_requests(ctx: &mut EnvoyContext) {
 	}
 }
 
+pub async fn process_unsent_remote_sqlite_requests(ctx: &mut EnvoyContext) {
+	let ws_available = {
+		let guard = ctx.shared.ws_tx.lock().await;
+		guard.is_some()
+	};
+
+	if !ws_available {
+		return;
+	}
+
+	let unsent: Vec<u32> = ctx
+		.remote_sqlite_requests
+		.iter()
+		.filter(|(_, req)| !req.sent)
+		.map(|(id, _)| *id)
+		.collect();
+
+	for request_id in unsent {
+		send_single_remote_sqlite_request(ctx, request_id).await;
+	}
+}
+
 pub fn cleanup_old_sqlite_requests(ctx: &mut EnvoyContext) {
-	let now = std::time::Instant::now();
+	let now = crate::time::Instant::now();
 	let mut to_delete = Vec::new();
 
 	for (request_id, request) in &ctx.sqlite_requests {
@@ -177,3 +336,359 @@ pub fn cleanup_old_sqlite_requests(ctx: &mut EnvoyContext) {
 		}
 	}
 }
+
+pub fn cleanup_old_remote_sqlite_requests(ctx: &mut EnvoyContext) {
+	let now = crate::time::Instant::now();
+	let mut to_delete = Vec::new();
+
+	for (request_id, request) in &ctx.remote_sqlite_requests {
+		if now.duration_since(request.timestamp).as_millis() > KV_EXPIRE_MS as u128 {
+			to_delete.push(*request_id);
+		}
+	}
+
+	for request_id in to_delete {
+		if let Some(request) = ctx.remote_sqlite_requests.remove(&request_id) {
+			let _ = request
+				.response_tx
+				.send(Err(anyhow::anyhow!("remote sqlite request timed out")));
+		}
+	}
+}
+
+pub fn fail_sqlite_requests_with_shutdown(ctx: &mut EnvoyContext) {
+	for (_id, request) in ctx.sqlite_requests.drain() {
+		let _ = request.response_tx.send(Err(anyhow::anyhow!(EnvoyShutdownError)));
+	}
+}
+
+pub fn fail_remote_sqlite_requests_with_shutdown(ctx: &mut EnvoyContext) {
+	for (_id, request) in ctx.remote_sqlite_requests.drain() {
+		let _ = request.response_tx.send(Err(anyhow::anyhow!(EnvoyShutdownError)));
+	}
+}
+
+pub fn fail_sent_remote_sqlite_requests_with_indeterminate_result(ctx: &mut EnvoyContext) {
+	let request_ids: Vec<u32> = ctx
+		.remote_sqlite_requests
+		.iter()
+		.filter(|(_, request)| request.sent)
+		.map(|(request_id, _)| *request_id)
+		.collect();
+
+	for request_id in request_ids {
+		if let Some(request) = ctx.remote_sqlite_requests.remove(&request_id) {
+			let operation = request.request.operation();
+			tracing::warn!(
+				request_id,
+				operation,
+				"remote sqlite response lost after websocket disconnect"
+			);
+			let _ = request
+				.response_tx
+				.send(Err(anyhow::anyhow!(RemoteSqliteIndeterminateResultError {
+					operation,
+				})));
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use std::collections::HashMap;
+	use std::sync::Arc;
+
+	use vbare::OwnedVersionedData;
+
+	use super::*;
+	use crate::config::{
+		BoxFuture, EnvoyCallbacks, EnvoyConfig, HttpRequest, HttpResponse, WebSocketHandler,
+		WebSocketSender,
+	};
+	use crate::context::{SharedContext, WsTxMessage};
+	use crate::handle::EnvoyHandle;
+	use crate::utils::{BufferMap, RemoteSqliteIndeterminateResultError};
+
+	struct IdleCallbacks;
+
+	impl EnvoyCallbacks for IdleCallbacks {
+		fn on_actor_start(
+			&self,
+			_handle: EnvoyHandle,
+			_actor_id: String,
+			_generation: u32,
+			_config: protocol::ActorConfig,
+			_preloaded_kv: Option<protocol::PreloadedKv>,
+			_sqlite_startup_data: Option<protocol::SqliteStartupData>,
+		) -> BoxFuture<anyhow::Result<()>> {
+			Box::pin(async { Ok(()) })
+		}
+
+		fn on_shutdown(&self) {}
+
+		fn fetch(
+			&self,
+			_handle: EnvoyHandle,
+			_actor_id: String,
+			_gateway_id: protocol::GatewayId,
+			_request_id: protocol::RequestId,
+			_request: HttpRequest,
+		) -> BoxFuture<anyhow::Result<HttpResponse>> {
+			Box::pin(async { anyhow::bail!("fetch should not be called in sqlite tests") })
+		}
+
+		fn websocket(
+			&self,
+			_handle: EnvoyHandle,
+			_actor_id: String,
+			_gateway_id: protocol::GatewayId,
+			_request_id: protocol::RequestId,
+			_request: HttpRequest,
+			_path: String,
+			_headers: HashMap<String, String>,
+			_is_hibernatable: bool,
+			_is_restoring_hibernatable: bool,
+			_sender: WebSocketSender,
+		) -> BoxFuture<anyhow::Result<WebSocketHandler>> {
+			Box::pin(async { anyhow::bail!("websocket should not be called in sqlite tests") })
+		}
+
+		fn can_hibernate(
+			&self,
+			_actor_id: &str,
+			_gateway_id: &protocol::GatewayId,
+			_request_id: &protocol::RequestId,
+			_request: &HttpRequest,
+		) -> BoxFuture<anyhow::Result<bool>> {
+			Box::pin(async { Ok(false) })
+		}
+	}
+
+	fn new_envoy_context() -> EnvoyContext {
+		let (envoy_tx, _envoy_rx) = tokio::sync::mpsc::unbounded_channel();
+		let shared = Arc::new(SharedContext {
+			config: EnvoyConfig {
+				version: 1,
+				endpoint: "http://127.0.0.1:1".to_string(),
+				token: None,
+				namespace: "test".to_string(),
+				pool_name: "test".to_string(),
+				prepopulate_actor_names: HashMap::new(),
+				metadata: None,
+				not_global: true,
+				debug_latency_ms: None,
+				callbacks: Arc::new(IdleCallbacks),
+			},
+			envoy_key: "test-envoy".to_string(),
+			envoy_tx,
+			actors: Arc::new(std::sync::Mutex::new(HashMap::new())),
+			live_tunnel_requests: Arc::new(std::sync::Mutex::new(HashMap::new())),
+			pending_hibernation_restores: Arc::new(std::sync::Mutex::new(HashMap::new())),
+			ws_tx: Arc::new(tokio::sync::Mutex::new(
+				None::<tokio::sync::mpsc::UnboundedSender<WsTxMessage>>,
+			)),
+			protocol_metadata: Arc::new(tokio::sync::Mutex::new(None)),
+			shutting_down: std::sync::atomic::AtomicBool::new(false),
+			stopped_tx: tokio::sync::watch::channel(true).0,
+		});
+
+		EnvoyContext {
+			shared,
+			shutting_down: false,
+			actors: HashMap::new(),
+			buffered_actor_messages: HashMap::new(),
+			kv_requests: HashMap::new(),
+			next_kv_request_id: 0,
+			sqlite_requests: HashMap::new(),
+			next_sqlite_request_id: 0,
+			remote_sqlite_requests: HashMap::new(),
+			next_remote_sqlite_request_id: 0,
+			request_to_actor: BufferMap::new(),
+			buffered_messages: Vec::new(),
+			processed_command_idx: HashMap::new(),
+		}
+	}
+
+	fn exec_request() -> protocol::SqliteExecRequest {
+		protocol::SqliteExecRequest {
+			namespace_id: "ns".to_string(),
+			actor_id: "actor".to_string(),
+			generation: 1,
+			sql: "select 1".to_string(),
+		}
+	}
+
+	fn execute_request() -> protocol::SqliteExecuteRequest {
+		protocol::SqliteExecuteRequest {
+			namespace_id: "ns".to_string(),
+			actor_id: "actor".to_string(),
+			generation: 1,
+			sql: "select ?".to_string(),
+			params: Some(vec![protocol::SqliteBindParam::SqliteValueInteger(
+				protocol::SqliteValueInteger { value: 1 },
+			)]),
+		}
+	}
+
+	fn execute_write_request() -> protocol::SqliteExecuteWriteRequest {
+		protocol::SqliteExecuteWriteRequest {
+			namespace_id: "ns".to_string(),
+			actor_id: "actor".to_string(),
+			generation: 1,
+			sql: "insert into test values (?)".to_string(),
+			params: Some(vec![protocol::SqliteBindParam::SqliteValueText(
+				protocol::SqliteValueText {
+					value: "value".to_string(),
+				},
+			)]),
+		}
+	}
+
+	#[tokio::test]
+	async fn remote_sqlite_exec_response_matches_pending_request() {
+		let mut ctx = new_envoy_context();
+		let (tx, rx) = oneshot::channel();
+
+		handle_remote_sqlite_request(&mut ctx, RemoteSqliteRequest::Exec(exec_request()), tx).await;
+		assert!(ctx.remote_sqlite_requests.contains_key(&0));
+
+		handle_remote_sqlite_exec_response(
+			&mut ctx,
+			protocol::ToEnvoySqliteExecResponse {
+				request_id: 0,
+				data: protocol::SqliteExecResponse::SqliteExecOk(protocol::SqliteExecOk {
+					result: protocol::SqliteQueryResult {
+						columns: vec!["one".to_string()],
+						rows: vec![vec![protocol::SqliteColumnValue::SqliteValueInteger(
+							protocol::SqliteValueInteger { value: 1 },
+						)]],
+					},
+				}),
+			},
+		)
+		.await;
+
+		let response = rx
+			.await
+			.expect("response sender should complete")
+			.expect("response should succeed");
+		match response {
+			RemoteSqliteResponse::Exec(protocol::SqliteExecResponse::SqliteExecOk(ok)) => {
+				assert_eq!(ok.result.columns, vec!["one"]);
+				assert_eq!(ok.result.rows.len(), 1);
+			}
+			_ => panic!("unexpected response"),
+		}
+		assert!(ctx.remote_sqlite_requests.is_empty());
+	}
+
+	#[test]
+	fn remote_sqlite_requests_reject_protocol_v3_serialization() {
+		let requests = vec![
+			RemoteSqliteRequest::Exec(exec_request()),
+			RemoteSqliteRequest::Execute(execute_request()),
+			RemoteSqliteRequest::ExecuteWrite(execute_write_request()),
+		];
+
+		for request in requests {
+			let message = remote_sqlite_request_to_message(7, request);
+			let err = protocol::versioned::ToRivet::wrap_latest(message)
+				.serialize(3)
+				.expect_err("remote sqlite requests should require protocol v4");
+			let compatibility = err
+				.downcast_ref::<protocol::versioned::ProtocolCompatibilityError>()
+				.expect("error should be a protocol compatibility error");
+			assert_eq!(
+				compatibility.feature,
+				protocol::versioned::ProtocolCompatibilityFeature::RemoteSqliteExecution
+			);
+			assert_eq!(compatibility.required_version, 4);
+			assert_eq!(compatibility.target_version, 3);
+		}
+	}
+
+	#[tokio::test]
+	async fn remote_sqlite_shutdown_cleanup_fails_pending_requests() {
+		let mut ctx = new_envoy_context();
+		let (tx, rx) = oneshot::channel();
+
+		handle_remote_sqlite_request(&mut ctx, RemoteSqliteRequest::Execute(execute_request()), tx)
+			.await;
+		fail_remote_sqlite_requests_with_shutdown(&mut ctx);
+
+		let err = rx
+			.await
+			.expect("response sender should complete")
+			.expect_err("pending request should fail during shutdown");
+		assert!(err.downcast_ref::<EnvoyShutdownError>().is_some());
+		assert!(ctx.remote_sqlite_requests.is_empty());
+	}
+
+	#[tokio::test]
+	async fn sent_remote_sqlite_request_fails_indeterminate_on_disconnect() {
+		let mut ctx = new_envoy_context();
+		let (ws_tx, mut ws_rx) = tokio::sync::mpsc::unbounded_channel();
+		*ctx.shared.ws_tx.lock().await = Some(ws_tx);
+		let (tx, rx) = oneshot::channel();
+
+		handle_remote_sqlite_request(
+			&mut ctx,
+			RemoteSqliteRequest::ExecuteWrite(execute_write_request()),
+			tx,
+		)
+		.await;
+		assert!(matches!(ws_rx.recv().await, Some(WsTxMessage::Send(_))));
+		assert!(
+			ctx.remote_sqlite_requests
+				.get(&0)
+				.expect("request should be pending")
+				.sent
+		);
+
+		fail_sent_remote_sqlite_requests_with_indeterminate_result(&mut ctx);
+
+		let err = rx
+			.await
+			.expect("response sender should complete")
+			.expect_err("sent write should fail indeterminate on disconnect");
+		let indeterminate = err
+			.downcast_ref::<RemoteSqliteIndeterminateResultError>()
+			.expect("error should describe indeterminate remote sqlite result");
+		assert_eq!(indeterminate.operation, "execute_write");
+		assert!(ctx.remote_sqlite_requests.is_empty());
+	}
+
+	#[tokio::test]
+	async fn unsent_remote_sqlite_request_survives_disconnect_and_sends_on_reconnect() {
+		let mut ctx = new_envoy_context();
+		let (tx, mut rx) = oneshot::channel();
+
+		handle_remote_sqlite_request(&mut ctx, RemoteSqliteRequest::Execute(execute_request()), tx)
+			.await;
+		assert!(
+			!ctx.remote_sqlite_requests
+				.get(&0)
+				.expect("request should be pending")
+				.sent
+		);
+
+		fail_sent_remote_sqlite_requests_with_indeterminate_result(&mut ctx);
+		assert!(matches!(
+			rx.try_recv(),
+			Err(tokio::sync::oneshot::error::TryRecvError::Empty)
+		));
+		assert!(ctx.remote_sqlite_requests.contains_key(&0));
+
+		let (ws_tx, mut ws_rx) = tokio::sync::mpsc::unbounded_channel();
+		*ctx.shared.ws_tx.lock().await = Some(ws_tx);
+		process_unsent_remote_sqlite_requests(&mut ctx).await;
+
+		assert!(matches!(ws_rx.recv().await, Some(WsTxMessage::Send(_))));
+		assert!(
+			ctx.remote_sqlite_requests
+				.get(&0)
+				.expect("request should still be pending")
+				.sent
+		);
+	}
+}
diff --git a/engine/sdks/rust/envoy-client/src/stringify.rs b/engine/sdks/rust/envoy-client/src/stringify.rs
index 9077084702..9c21fd3a8a 100644
--- a/engine/sdks/rust/envoy-client/src/stringify.rs
+++ b/engine/sdks/rust/envoy-client/src/stringify.rs
@@ -269,16 +269,28 @@ pub fn stringify_to_rivet(message: &protocol::ToRivet) -> String {
 				val.request_id
 			)
 		}
-		protocol::ToRivet::ToRivetSqliteGetPageRangeRequest(val) => {
+		protocol::ToRivet::ToRivetSqliteCommitRequest(val) => {
 			format!(
-				"ToRivetSqliteGetPageRangeRequest{{requestId: {}}}",
+				"ToRivetSqliteCommitRequest{{requestId: {}}}",
 				val.request_id
 			)
 		}
-		protocol::ToRivet::ToRivetSqliteCommitRequest(val) => {
+		protocol::ToRivet::ToRivetSqliteExecRequest(val) => {
 			format!(
-				"ToRivetSqliteCommitRequest{{requestId: {}}}",
-				val.request_id
+				"ToRivetSqliteExecRequest{{requestId: {}, actorId: \"{}\", generation: {}}}",
+				val.request_id, val.data.actor_id, val.data.generation
+			)
+		}
+		protocol::ToRivet::ToRivetSqliteExecuteRequest(val) => {
+			format!(
+				"ToRivetSqliteExecuteRequest{{requestId: {}, actorId: \"{}\", generation: {}}}",
+				val.request_id, val.data.actor_id, val.data.generation
+			)
+		}
+		protocol::ToRivet::ToRivetSqliteExecuteWriteRequest(val) => {
+			format!(
+				"ToRivetSqliteExecuteWriteRequest{{requestId: {}, actorId: \"{}\", generation: {}}}",
+				val.request_id, val.data.actor_id, val.data.generation
 			)
 		}
 		protocol::ToRivet::ToRivetTunnelMessage(val) => {
@@ -327,15 +339,24 @@ pub fn stringify_to_envoy(message: &protocol::ToEnvoy) -> String {
 				val.request_id
 			)
 		}
-		protocol::ToEnvoy::ToEnvoySqliteGetPageRangeResponse(val) => {
+		protocol::ToEnvoy::ToEnvoySqliteCommitResponse(val) => {
 			format!(
-				"ToEnvoySqliteGetPageRangeResponse{{requestId: {}}}",
+				"ToEnvoySqliteCommitResponse{{requestId: {}}}",
 				val.request_id
 			)
 		}
-		protocol::ToEnvoy::ToEnvoySqliteCommitResponse(val) => {
+		protocol::ToEnvoy::ToEnvoySqliteExecResponse(val) => {
+			format!("ToEnvoySqliteExecResponse{{requestId: {}}}", val.request_id)
+		}
+		protocol::ToEnvoy::ToEnvoySqliteExecuteResponse(val) => {
 			format!(
-				"ToEnvoySqliteCommitResponse{{requestId: {}}}",
+				"ToEnvoySqliteExecuteResponse{{requestId: {}}}",
+				val.request_id
+			)
+		}
+		protocol::ToEnvoy::ToEnvoySqliteExecuteWriteResponse(val) => {
+			format!(
+				"ToEnvoySqliteExecuteWriteResponse{{requestId: {}}}",
 				val.request_id
 			)
 		}
diff --git a/engine/sdks/rust/envoy-client/src/utils.rs b/engine/sdks/rust/envoy-client/src/utils.rs
index 7d3988e434..bd0c0671e7 100644
--- a/engine/sdks/rust/envoy-client/src/utils.rs
+++ b/engine/sdks/rust/envoy-client/src/utils.rs
@@ -1,7 +1,13 @@
 use std::collections::HashMap;
+use std::future::Future;
+use std::pin::Pin;
 use std::time::Duration;
 
 use rand::Rng;
+#[cfg(target_arch = "wasm32")]
+use wasm_bindgen::{JsCast, JsValue};
+#[cfg(target_arch = "wasm32")]
+use wasm_bindgen_futures::JsFuture;
 
 /// Convert an ID (byte slice) to a hex string.
 pub fn id_to_str(id: &[u8]) -> String {
@@ -25,15 +31,83 @@ impl std::fmt::Display for EnvoyShutdownError {
 
 impl std::error::Error for EnvoyShutdownError {}
 
+/// Error returned when a sent remote SQLite request may have completed but the
+/// WebSocket closed before the response arrived.
+#[derive(Debug)]
+pub struct RemoteSqliteIndeterminateResultError {
+	pub operation: &'static str,
+}
+
+impl std::fmt::Display for RemoteSqliteIndeterminateResultError {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		write!(
+			f,
+			"remote sqlite {} result is indeterminate after envoy disconnect",
+			self.operation
+		)
+	}
+}
+
+impl std::error::Error for RemoteSqliteIndeterminateResultError {}
+
 /// Inject artificial latency for testing.
 pub async fn inject_latency(ms: Option<u64>) {
 	if let Some(ms) = ms {
 		if ms > 0 {
-			tokio::time::sleep(Duration::from_millis(ms)).await;
+			sleep(Duration::from_millis(ms)).await;
 		}
 	}
 }
 
+#[cfg(not(target_arch = "wasm32"))]
+pub type SleepFuture = Pin<Box<dyn Future<Output = ()> + Send>>;
+#[cfg(target_arch = "wasm32")]
+pub type SleepFuture = Pin<Box<dyn Future<Output = ()>>>;
+
+pub fn boxed_sleep(duration: Duration) -> SleepFuture {
+	Box::pin(sleep(duration))
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+pub async fn sleep(duration: Duration) {
+	tokio::time::sleep(duration).await;
+}
+
+#[cfg(target_arch = "wasm32")]
+pub async fn sleep(duration: Duration) {
+	let delay_ms = duration.as_millis().min(u32::MAX as u128) as f64;
+	let promise = js_sys::Promise::new(&mut |resolve, _reject| {
+		let global = js_sys::global();
+		let set_timeout = js_sys::Reflect::get(&global, &JsValue::from_str("setTimeout"))
+			.ok()
+			.and_then(|value| value.dyn_into::<js_sys::Function>().ok());
+
+		if let Some(set_timeout) = set_timeout {
+			let _ = set_timeout.call2(&global, &resolve, &JsValue::from_f64(delay_ms));
+		} else {
+			let _ = resolve.call0(&JsValue::UNDEFINED);
+		}
+	});
+
+	let _ = JsFuture::from(promise).await;
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+pub fn spawn_detached<F>(future: F)
+where
+	F: Future<Output = ()> + Send + 'static,
+{
+	tokio::spawn(future);
+}
+
+#[cfg(target_arch = "wasm32")]
+pub fn spawn_detached<F>(future: F)
+where
+	F: Future<Output = ()> + 'static,
+{
+	tokio::task::spawn_local(future);
+}
+
 pub struct BackoffOptions {
 	pub initial_delay: u64,
 	pub max_delay: u64,
diff --git a/engine/sdks/rust/envoy-client/tests/command_dedup.rs b/engine/sdks/rust/envoy-client/tests/command_dedup.rs
index f7c6cea0c4..ee5cea90e7 100644
--- a/engine/sdks/rust/envoy-client/tests/command_dedup.rs
+++ b/engine/sdks/rust/envoy-client/tests/command_dedup.rs
@@ -10,9 +10,13 @@ use rivet_envoy_client::config::{
 use rivet_envoy_client::context::{SharedContext, WsTxMessage};
 use rivet_envoy_client::envoy::EnvoyContext;
 use rivet_envoy_client::handle::EnvoyHandle;
-use rivet_envoy_client::utils::BufferMap;
+use rivet_envoy_client::sqlite::{
+	RemoteSqliteRequest, fail_sent_remote_sqlite_requests_with_indeterminate_result,
+	handle_remote_sqlite_request,
+};
+use rivet_envoy_client::utils::{BufferMap, RemoteSqliteIndeterminateResultError};
 use rivet_envoy_protocol as protocol;
-use rivet_util::async_counter::AsyncCounter;
+use rivet_envoy_client::async_counter::AsyncCounter;
 use tokio::sync::mpsc;
 
 struct IdleCallbacks;
@@ -105,6 +109,8 @@ fn new_envoy_context() -> EnvoyContext {
 		next_kv_request_id: 0,
 		sqlite_requests: HashMap::new(),
 		next_sqlite_request_id: 0,
+		remote_sqlite_requests: HashMap::new(),
+		next_remote_sqlite_request_id: 0,
 		request_to_actor: BufferMap::new(),
 		buffered_messages: Vec::new(),
 		processed_command_idx: HashMap::new(),
@@ -124,6 +130,20 @@ fn stop_command(actor_id: &str, generation: u32, index: i64) -> protocol::Comman
 	}
 }
 
+fn execute_write_request() -> protocol::SqliteExecuteWriteRequest {
+	protocol::SqliteExecuteWriteRequest {
+		namespace_id: "test".to_string(),
+		actor_id: "actor-replay".to_string(),
+		generation: 1,
+		sql: "insert into test values (?)".to_string(),
+		params: Some(vec![protocol::SqliteBindParam::SqliteValueText(
+			protocol::SqliteValueText {
+				value: "value".to_string(),
+			},
+		)]),
+	}
+}
+
 #[tokio::test]
 async fn replayed_stop_command_is_dropped() {
 	let mut ctx = new_envoy_context();
@@ -201,3 +221,47 @@ async fn dedup_is_per_actor_and_generation() {
 	handle_commands(&mut ctx, vec![stop_command("actor-b", 1, 5)]).await;
 	assert!(rx_b1.try_recv().is_ok());
 }
+
+#[tokio::test]
+async fn replayed_command_is_dropped_after_remote_sql_lost_response() {
+	let mut ctx = new_envoy_context();
+	let (actor_tx, mut actor_rx) = mpsc::unbounded_channel::<ToActor>();
+	ctx.insert_actor(
+		"actor-replay".to_string(),
+		1,
+		actor_tx,
+		Arc::new(AsyncCounter::new()),
+		"actor-replay".to_string(),
+		-1,
+	);
+
+	let (ws_tx, mut ws_rx) = mpsc::unbounded_channel();
+	*ctx.shared.ws_tx.lock().await = Some(ws_tx);
+	let (sql_tx, sql_rx) = tokio::sync::oneshot::channel();
+	handle_remote_sqlite_request(
+		&mut ctx,
+		RemoteSqliteRequest::ExecuteWrite(execute_write_request()),
+		sql_tx,
+	)
+	.await;
+	assert!(matches!(ws_rx.recv().await, Some(WsTxMessage::Send(_))));
+
+	handle_commands(&mut ctx, vec![stop_command("actor-replay", 1, 5)]).await;
+	assert!(matches!(
+		actor_rx.try_recv(),
+		Ok(ToActor::Stop { command_idx: 5, .. })
+	));
+
+	fail_sent_remote_sqlite_requests_with_indeterminate_result(&mut ctx);
+	let err = sql_rx
+		.await
+		.expect("response sender should complete")
+		.expect_err("sent remote SQL should become indeterminate");
+	assert!(
+		err.downcast_ref::<RemoteSqliteIndeterminateResultError>()
+			.is_some()
+	);
+
+	handle_commands(&mut ctx, vec![stop_command("actor-replay", 1, 5)]).await;
+	assert!(actor_rx.try_recv().is_err());
+}
diff --git a/engine/sdks/rust/envoy-protocol/src/lib.rs b/engine/sdks/rust/envoy-protocol/src/lib.rs
index 00ef23ef72..167dcbe173 100644
--- a/engine/sdks/rust/envoy-protocol/src/lib.rs
+++ b/engine/sdks/rust/envoy-protocol/src/lib.rs
@@ -3,6 +3,6 @@ pub mod util;
 pub mod versioned;
 
 // Re-export latest
-pub use generated::v3::*;
+pub use generated::v4::*;
 
 pub use generated::PROTOCOL_VERSION;
diff --git a/engine/sdks/rust/envoy-protocol/src/versioned.rs b/engine/sdks/rust/envoy-protocol/src/versioned.rs
index a15b4a19e9..b8060acf55 100644
--- a/engine/sdks/rust/envoy-protocol/src/versioned.rs
+++ b/engine/sdks/rust/envoy-protocol/src/versioned.rs
@@ -1,287 +1,512 @@
 use anyhow::{Result, bail};
+use std::{error::Error, fmt};
 use vbare::OwnedVersionedData;
 
-use crate::generated::{v1, v2, v3};
+use crate::generated::{v1, v2, v3, v4};
+
+fn convert_same_bytes<T, U>(message: T) -> Result<U>
+where
+	T: serde::Serialize,
+	U: serde::de::DeserializeOwned,
+{
+	serde_bare::from_slice(&serde_bare::to_vec(&message)?).map_err(Into::into)
+}
+
+fn convert_same_bytes_ref<T, U>(message: &T) -> Result<U>
+where
+	T: serde::Serialize + ?Sized,
+	U: serde::de::DeserializeOwned,
+{
+	serde_bare::from_slice(&serde_bare::to_vec(message)?).map_err(Into::into)
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ProtocolCompatibilityFeature {
+	SqliteStartupData,
+	SqlitePageIo,
+	SqlitePageRange,
+	RemoteSqliteExecution,
+}
+
+impl ProtocolCompatibilityFeature {
+	fn description(self, direction: ProtocolCompatibilityDirection) -> &'static str {
+		match self {
+			ProtocolCompatibilityFeature::SqliteStartupData => "sqlite startup data",
+			ProtocolCompatibilityFeature::SqlitePageIo => match direction {
+				ProtocolCompatibilityDirection::ToEnvoy => "sqlite responses",
+				ProtocolCompatibilityDirection::ToRivet => "sqlite requests",
+			},
+			ProtocolCompatibilityFeature::SqlitePageRange => match direction {
+				ProtocolCompatibilityDirection::ToEnvoy => "sqlite range responses",
+				ProtocolCompatibilityDirection::ToRivet => "sqlite range requests",
+			},
+			ProtocolCompatibilityFeature::RemoteSqliteExecution => match direction {
+				ProtocolCompatibilityDirection::ToEnvoy => "remote sqlite responses",
+				ProtocolCompatibilityDirection::ToRivet => "remote sqlite requests",
+			},
+		}
+	}
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ProtocolCompatibilityDirection {
+	ToEnvoy,
+	ToRivet,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct ProtocolCompatibilityError {
+	pub feature: ProtocolCompatibilityFeature,
+	pub direction: ProtocolCompatibilityDirection,
+	pub required_version: u16,
+	pub target_version: u16,
+}
+
+impl fmt::Display for ProtocolCompatibilityError {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		let verb = match self.feature {
+			ProtocolCompatibilityFeature::SqliteStartupData => "requires",
+			ProtocolCompatibilityFeature::SqlitePageIo
+			| ProtocolCompatibilityFeature::SqlitePageRange
+			| ProtocolCompatibilityFeature::RemoteSqliteExecution => "require",
+		};
+
+		write!(
+			f,
+			"{} {} envoy-protocol v{} but target version is v{}",
+			self.feature.description(self.direction),
+			verb,
+			self.required_version,
+			self.target_version
+		)
+	}
+}
+
+impl Error for ProtocolCompatibilityError {}
+
+fn incompatible(
+	feature: ProtocolCompatibilityFeature,
+	direction: ProtocolCompatibilityDirection,
+	required_version: u16,
+	target_version: u16,
+) -> anyhow::Error {
+	ProtocolCompatibilityError {
+		feature,
+		direction,
+		required_version,
+		target_version,
+	}
+	.into()
+}
+
 
 pub enum ToEnvoy {
-	V3(v3::ToEnvoy),
+	V4(v4::ToEnvoy),
 }
 
 impl OwnedVersionedData for ToEnvoy {
-	type Latest = v3::ToEnvoy;
+	type Latest = v4::ToEnvoy;
 
 	fn wrap_latest(latest: Self::Latest) -> Self {
-		Self::V3(latest)
+		Self::V4(latest)
 	}
 
 	fn unwrap_latest(self) -> Result<Self::Latest> {
 		match self {
-			Self::V3(data) => Ok(data),
+			Self::V4(data) => Ok(data),
 		}
 	}
 
 	fn deserialize_version(payload: &[u8], version: u16) -> Result<Self> {
-		Ok(Self::V3(match version {
-			1 => convert_to_envoy_v2_to_v3(convert_to_envoy_v1_to_v2(
+		Ok(Self::V4(match version {
+			1 => convert_to_envoy_v3_to_v4(convert_to_envoy_v2_to_v3(convert_to_envoy_v1_to_v2(
 				serde_bare::from_slice(payload)?,
-			)?)?,
-			2 => convert_to_envoy_v2_to_v3(serde_bare::from_slice(payload)?)?,
-			3 => serde_bare::from_slice(payload)?,
+			)?)?)?,
+			2 => convert_to_envoy_v3_to_v4(convert_to_envoy_v2_to_v3(serde_bare::from_slice(
+				payload,
+			)?)?)?,
+			3 => convert_to_envoy_v3_to_v4(serde_bare::from_slice(payload)?)?,
+			4 => serde_bare::from_slice(payload)?,
 			_ => bail!("invalid version: {version}"),
 		}))
 	}
 
 	fn serialize_version(self, version: u16) -> Result<Vec<u8>> {
-		let Self::V3(data) = self;
+		let Self::V4(data) = self;
 		match version {
-			1 => serde_bare::to_vec(&convert_to_envoy_v2_to_v1(convert_to_envoy_v3_to_v2(data)?)?)
+			1 => serde_bare::to_vec(&convert_to_envoy_v2_to_v1(convert_to_envoy_v3_to_v2(
+				convert_to_envoy_v4_to_v3(data, 1)?,
+			)?)?)
+			.map_err(Into::into),
+			2 => serde_bare::to_vec(&convert_to_envoy_v3_to_v2(convert_to_envoy_v4_to_v3(data, 2)?)?)
 				.map_err(Into::into),
-			2 => serde_bare::to_vec(&convert_to_envoy_v3_to_v2(data)?).map_err(Into::into),
-			3 => serde_bare::to_vec(&data).map_err(Into::into),
+			3 => serde_bare::to_vec(&convert_to_envoy_v4_to_v3(data, 3)?).map_err(Into::into),
+			4 => serde_bare::to_vec(&data).map_err(Into::into),
 			_ => bail!("invalid version: {version}"),
 		}
 	}
 
 	fn deserialize_converters() -> Vec<impl Fn(Self) -> Result<Self>> {
-		vec![Ok, Ok]
+		vec![Ok, Ok, Ok]
 	}
 
 	fn serialize_converters() -> Vec<impl Fn(Self) -> Result<Self>> {
-		vec![Ok, Ok]
+		vec![Ok, Ok, Ok]
 	}
 }
 
 pub enum ToRivet {
-	V3(v3::ToRivet),
+	V4(v4::ToRivet),
 }
 
 impl OwnedVersionedData for ToRivet {
-	type Latest = v3::ToRivet;
+	type Latest = v4::ToRivet;
 
 	fn wrap_latest(latest: Self::Latest) -> Self {
-		Self::V3(latest)
+		Self::V4(latest)
 	}
 
 	fn unwrap_latest(self) -> Result<Self::Latest> {
 		match self {
-			Self::V3(data) => Ok(data),
+			Self::V4(data) => Ok(data),
 		}
 	}
 
 	fn deserialize_version(payload: &[u8], version: u16) -> Result<Self> {
-		Ok(Self::V3(match version {
-			1 | 2 => convert_to_rivet_v2_to_v3(serde_bare::from_slice(payload)?)?,
-			3 => serde_bare::from_slice(payload)?,
+		Ok(Self::V4(match version {
+			1 | 2 => convert_to_rivet_v3_to_v4(convert_to_rivet_v2_to_v3(
+				serde_bare::from_slice(payload)?,
+			)?)?,
+			3 => convert_to_rivet_v3_to_v4(serde_bare::from_slice(payload)?)?,
+			4 => serde_bare::from_slice(payload)?,
 			_ => bail!("invalid version: {version}"),
 		}))
 	}
 
 	fn serialize_version(self, version: u16) -> Result<Vec<u8>> {
-		let Self::V3(data) = self;
+		let Self::V4(data) = self;
 		match version {
-			1 | 2 => serde_bare::to_vec(&convert_to_rivet_v3_to_v2(data)?).map_err(Into::into),
-			3 => serde_bare::to_vec(&data).map_err(Into::into),
+			1 | 2 => serde_bare::to_vec(&convert_to_rivet_v3_to_v2(convert_to_rivet_v4_to_v3(
+				data,
+				version,
+			)?)?)
+			.map_err(Into::into),
+			3 => serde_bare::to_vec(&convert_to_rivet_v4_to_v3(data, 3)?).map_err(Into::into),
+			4 => serde_bare::to_vec(&data).map_err(Into::into),
 			_ => bail!("invalid version: {version}"),
 		}
 	}
 
 	fn deserialize_converters() -> Vec<impl Fn(Self) -> Result<Self>> {
-		vec![Ok, Ok]
+		vec![Ok, Ok, Ok]
 	}
 
 	fn serialize_converters() -> Vec<impl Fn(Self) -> Result<Self>> {
-		vec![Ok, Ok]
+		vec![Ok, Ok, Ok]
 	}
 }
 
 pub enum ToEnvoyConn {
-	V3(v3::ToEnvoyConn),
+	V4(v4::ToEnvoyConn),
 }
 
 impl OwnedVersionedData for ToEnvoyConn {
-	type Latest = v3::ToEnvoyConn;
+	type Latest = v4::ToEnvoyConn;
 
 	fn wrap_latest(latest: Self::Latest) -> Self {
-		Self::V3(latest)
+		Self::V4(latest)
 	}
 
 	fn unwrap_latest(self) -> Result<Self::Latest> {
 		match self {
-			Self::V3(data) => Ok(data),
+			Self::V4(data) => Ok(data),
 		}
 	}
 
 	fn deserialize_version(payload: &[u8], version: u16) -> Result<Self> {
-		Ok(Self::V3(match version {
-			1 => convert_to_envoy_conn_v1_to_v3(serde_bare::from_slice(payload)?)?,
-			2 => convert_to_envoy_conn_v2_to_v3(serde_bare::from_slice(payload)?)?,
-			3 => serde_bare::from_slice(payload)?,
+		Ok(Self::V4(match version {
+			1 => convert_same_bytes(convert_to_envoy_conn_v1_to_v3(serde_bare::from_slice(
+				payload,
+			)?)?)?,
+			2 => convert_same_bytes(convert_to_envoy_conn_v2_to_v3(serde_bare::from_slice(
+				payload,
+			)?)?)?,
+			3 => convert_same_bytes(serde_bare::from_slice::<v3::ToEnvoyConn>(payload)?)?,
+			4 => serde_bare::from_slice(payload)?,
 			_ => bail!("invalid version: {version}"),
 		}))
 	}
 
 	fn serialize_version(self, version: u16) -> Result<Vec<u8>> {
-		let Self::V3(data) = self;
+		let Self::V4(data) = self;
+		let data_v3 = || convert_same_bytes_ref::<_, v3::ToEnvoyConn>(&data);
 		match version {
 			1 => {
-				serde_bare::to_vec(&convert_to_envoy_conn_v3_to_v1(data)?).map_err(Into::into)
+				serde_bare::to_vec(&convert_to_envoy_conn_v3_to_v1(data_v3()?)?)
+					.map_err(Into::into)
 			}
 			2 => {
-				serde_bare::to_vec(&convert_to_envoy_conn_v3_to_v2(data)?).map_err(Into::into)
+				serde_bare::to_vec(&convert_to_envoy_conn_v3_to_v2(data_v3()?)?)
+					.map_err(Into::into)
 			}
-			3 => serde_bare::to_vec(&data).map_err(Into::into),
+			3 => serde_bare::to_vec(&data_v3()?).map_err(Into::into),
+			4 => serde_bare::to_vec(&data).map_err(Into::into),
 			_ => bail!("invalid version: {version}"),
 		}
 	}
 
 	fn deserialize_converters() -> Vec<impl Fn(Self) -> Result<Self>> {
-		vec![Ok, Ok]
+		vec![Ok, Ok, Ok]
 	}
 
 	fn serialize_converters() -> Vec<impl Fn(Self) -> Result<Self>> {
-		vec![Ok, Ok]
+		vec![Ok, Ok, Ok]
 	}
 }
 
 pub enum ToGateway {
-	V3(v3::ToGateway),
+	V4(v4::ToGateway),
 }
 
 impl OwnedVersionedData for ToGateway {
-	type Latest = v3::ToGateway;
+	type Latest = v4::ToGateway;
 
 	fn wrap_latest(latest: Self::Latest) -> Self {
-		Self::V3(latest)
+		Self::V4(latest)
 	}
 
 	fn unwrap_latest(self) -> Result<Self::Latest> {
 		match self {
-			Self::V3(data) => Ok(data),
+			Self::V4(data) => Ok(data),
 		}
 	}
 
 	fn deserialize_version(payload: &[u8], version: u16) -> Result<Self> {
-		Ok(Self::V3(match version {
-			1 => convert_to_gateway_v1_to_v3(serde_bare::from_slice(payload)?),
-			2 => convert_to_gateway_v2_to_v3(serde_bare::from_slice(payload)?),
-			3 => serde_bare::from_slice(payload)?,
+		Ok(Self::V4(match version {
+			1 => convert_same_bytes(convert_to_gateway_v1_to_v3(serde_bare::from_slice(payload)?))?,
+			2 => convert_same_bytes(convert_to_gateway_v2_to_v3(serde_bare::from_slice(payload)?))?,
+			3 => convert_same_bytes(serde_bare::from_slice::<v3::ToGateway>(payload)?)?,
+			4 => serde_bare::from_slice(payload)?,
 			_ => bail!("invalid version: {version}"),
 		}))
 	}
 
 	fn serialize_version(self, version: u16) -> Result<Vec<u8>> {
-		let Self::V3(data) = self;
+		let Self::V4(data) = self;
+		let data_v3 = || convert_same_bytes_ref::<_, v3::ToGateway>(&data);
 		match version {
-			1 => serde_bare::to_vec(&convert_to_gateway_v3_to_v1(data)).map_err(Into::into),
-			2 => serde_bare::to_vec(&convert_to_gateway_v3_to_v2(data)).map_err(Into::into),
-			3 => serde_bare::to_vec(&data).map_err(Into::into),
+			1 => serde_bare::to_vec(&convert_to_gateway_v3_to_v1(data_v3()?)).map_err(Into::into),
+			2 => serde_bare::to_vec(&convert_to_gateway_v3_to_v2(data_v3()?)).map_err(Into::into),
+			3 => serde_bare::to_vec(&data_v3()?).map_err(Into::into),
+			4 => serde_bare::to_vec(&data).map_err(Into::into),
 			_ => bail!("invalid version: {version}"),
 		}
 	}
 
 	fn deserialize_converters() -> Vec<impl Fn(Self) -> Result<Self>> {
-		vec![Ok, Ok]
+		vec![Ok, Ok, Ok]
 	}
 
 	fn serialize_converters() -> Vec<impl Fn(Self) -> Result<Self>> {
-		vec![Ok, Ok]
+		vec![Ok, Ok, Ok]
 	}
 }
 
 pub enum ToOutbound {
-	V3(v3::ToOutbound),
+	V4(v4::ToOutbound),
 }
 
 impl OwnedVersionedData for ToOutbound {
-	type Latest = v3::ToOutbound;
+	type Latest = v4::ToOutbound;
 
 	fn wrap_latest(latest: Self::Latest) -> Self {
-		Self::V3(latest)
+		Self::V4(latest)
 	}
 
 	fn unwrap_latest(self) -> Result<Self::Latest> {
 		match self {
-			Self::V3(data) => Ok(data),
+			Self::V4(data) => Ok(data),
 		}
 	}
 
 	fn deserialize_version(payload: &[u8], version: u16) -> Result<Self> {
-		Ok(Self::V3(match version {
-			1 => convert_to_outbound_v1_to_v3(serde_bare::from_slice(payload)?),
-			2 => convert_to_outbound_v2_to_v3(serde_bare::from_slice(payload)?),
-			3 => serde_bare::from_slice(payload)?,
+		Ok(Self::V4(match version {
+			1 => convert_same_bytes(convert_to_outbound_v1_to_v3(serde_bare::from_slice(
+				payload,
+			)?))?,
+			2 => convert_same_bytes(convert_to_outbound_v2_to_v3(serde_bare::from_slice(
+				payload,
+			)?))?,
+			3 => convert_same_bytes(serde_bare::from_slice::<v3::ToOutbound>(payload)?)?,
+			4 => serde_bare::from_slice(payload)?,
 			_ => bail!("invalid version: {version}"),
 		}))
 	}
 
 	fn serialize_version(self, version: u16) -> Result<Vec<u8>> {
-		let Self::V3(data) = self;
+		let Self::V4(data) = self;
+		let data_v3 = || convert_same_bytes_ref::<_, v3::ToOutbound>(&data);
 		match version {
-			1 => serde_bare::to_vec(&convert_to_outbound_v3_to_v1(data)).map_err(Into::into),
-			2 => serde_bare::to_vec(&convert_to_outbound_v3_to_v2(data)).map_err(Into::into),
-			3 => serde_bare::to_vec(&data).map_err(Into::into),
+			1 => serde_bare::to_vec(&convert_to_outbound_v3_to_v1(data_v3()?)).map_err(Into::into),
+			2 => serde_bare::to_vec(&convert_to_outbound_v3_to_v2(data_v3()?)).map_err(Into::into),
+			3 => serde_bare::to_vec(&data_v3()?).map_err(Into::into),
+			4 => serde_bare::to_vec(&data).map_err(Into::into),
 			_ => bail!("invalid version: {version}"),
 		}
 	}
 
 	fn deserialize_converters() -> Vec<impl Fn(Self) -> Result<Self>> {
-		vec![Ok, Ok]
+		vec![Ok, Ok, Ok]
 	}
 
 	fn serialize_converters() -> Vec<impl Fn(Self) -> Result<Self>> {
-		vec![Ok, Ok]
+		vec![Ok, Ok, Ok]
 	}
 }
 
 pub enum ActorCommandKeyData {
-	V3(v3::ActorCommandKeyData),
+	V4(v4::ActorCommandKeyData),
 }
 
 impl OwnedVersionedData for ActorCommandKeyData {
-	type Latest = v3::ActorCommandKeyData;
+	type Latest = v4::ActorCommandKeyData;
 
 	fn wrap_latest(latest: Self::Latest) -> Self {
-		Self::V3(latest)
+		Self::V4(latest)
 	}
 
 	fn unwrap_latest(self) -> Result<Self::Latest> {
 		match self {
-			Self::V3(data) => Ok(data),
+			Self::V4(data) => Ok(data),
 		}
 	}
 
 	fn deserialize_version(payload: &[u8], version: u16) -> Result<Self> {
-		Ok(Self::V3(match version {
-			1 => convert_actor_command_key_data_v1_to_v3(serde_bare::from_slice(payload)?),
-			2 => convert_actor_command_key_data_v2_to_v3(serde_bare::from_slice(payload)?),
-			3 => serde_bare::from_slice(payload)?,
+		Ok(Self::V4(match version {
+			1 => convert_same_bytes(convert_actor_command_key_data_v1_to_v3(
+				serde_bare::from_slice(payload)?,
+			))?,
+			2 => convert_same_bytes(convert_actor_command_key_data_v2_to_v3(
+				serde_bare::from_slice(payload)?,
+			))?,
+			3 => convert_same_bytes(serde_bare::from_slice::<v3::ActorCommandKeyData>(payload)?)?,
+			4 => serde_bare::from_slice(payload)?,
 			_ => bail!("invalid version: {version}"),
 		}))
 	}
 
 	fn serialize_version(self, version: u16) -> Result<Vec<u8>> {
-		let Self::V3(data) = self;
+		let Self::V4(data) = self;
+		let data_v3 = || convert_same_bytes_ref::<_, v3::ActorCommandKeyData>(&data);
 		match version {
 			1 => {
-				serde_bare::to_vec(&convert_actor_command_key_data_v3_to_v1(data))
+				serde_bare::to_vec(&convert_actor_command_key_data_v3_to_v1(data_v3()?))
 					.map_err(Into::into)
 			}
 			2 => {
-				serde_bare::to_vec(&convert_actor_command_key_data_v3_to_v2(data))
+				serde_bare::to_vec(&convert_actor_command_key_data_v3_to_v2(data_v3()?))
 					.map_err(Into::into)
 			}
-			3 => serde_bare::to_vec(&data).map_err(Into::into),
+			3 => serde_bare::to_vec(&data_v3()?).map_err(Into::into),
+			4 => serde_bare::to_vec(&data).map_err(Into::into),
 			_ => bail!("invalid version: {version}"),
 		}
 	}
 
 	fn deserialize_converters() -> Vec<impl Fn(Self) -> Result<Self>> {
-		vec![Ok, Ok]
+		vec![Ok, Ok, Ok]
 	}
 
 	fn serialize_converters() -> Vec<impl Fn(Self) -> Result<Self>> {
-		vec![Ok, Ok]
-	}
+		vec![Ok, Ok, Ok]
+	}
+}
+
+fn convert_to_envoy_v3_to_v4(message: v3::ToEnvoy) -> Result<v4::ToEnvoy> {
+	convert_same_bytes(message)
+}
+
+fn convert_to_envoy_v4_to_v3(message: v4::ToEnvoy, target_version: u16) -> Result<v3::ToEnvoy> {
+	match &message {
+		v4::ToEnvoy::ToEnvoySqliteExecResponse(_) => {
+			return Err(incompatible(
+				ProtocolCompatibilityFeature::RemoteSqliteExecution,
+				ProtocolCompatibilityDirection::ToEnvoy,
+				4,
+				target_version,
+			));
+		}
+		v4::ToEnvoy::ToEnvoySqliteExecuteResponse(_) => {
+			return Err(incompatible(
+				ProtocolCompatibilityFeature::RemoteSqliteExecution,
+				ProtocolCompatibilityDirection::ToEnvoy,
+				4,
+				target_version,
+			));
+		}
+		v4::ToEnvoy::ToEnvoySqliteExecuteWriteResponse(_) => {
+			return Err(incompatible(
+				ProtocolCompatibilityFeature::RemoteSqliteExecution,
+				ProtocolCompatibilityDirection::ToEnvoy,
+				4,
+				target_version,
+			));
+		}
+		v4::ToEnvoy::ToEnvoyInit(_)
+		| v4::ToEnvoy::ToEnvoyCommands(_)
+		| v4::ToEnvoy::ToEnvoyAckEvents(_)
+		| v4::ToEnvoy::ToEnvoyKvResponse(_)
+		| v4::ToEnvoy::ToEnvoyTunnelMessage(_)
+		| v4::ToEnvoy::ToEnvoyPing(_)
+		| v4::ToEnvoy::ToEnvoySqliteGetPagesResponse(_)
+		| v4::ToEnvoy::ToEnvoySqliteCommitResponse(_) => {}
+	}
+
+	convert_same_bytes(message)
+}
+
+fn convert_to_rivet_v3_to_v4(message: v3::ToRivet) -> Result<v4::ToRivet> {
+	convert_same_bytes(message)
+}
+
+fn convert_to_rivet_v4_to_v3(message: v4::ToRivet, target_version: u16) -> Result<v3::ToRivet> {
+	match &message {
+		v4::ToRivet::ToRivetSqliteExecRequest(_) => {
+			return Err(incompatible(
+				ProtocolCompatibilityFeature::RemoteSqliteExecution,
+				ProtocolCompatibilityDirection::ToRivet,
+				4,
+				target_version,
+			));
+		}
+		v4::ToRivet::ToRivetSqliteExecuteRequest(_) => {
+			return Err(incompatible(
+				ProtocolCompatibilityFeature::RemoteSqliteExecution,
+				ProtocolCompatibilityDirection::ToRivet,
+				4,
+				target_version,
+			));
+		}
+		v4::ToRivet::ToRivetSqliteExecuteWriteRequest(_) => {
+			return Err(incompatible(
+				ProtocolCompatibilityFeature::RemoteSqliteExecution,
+				ProtocolCompatibilityDirection::ToRivet,
+				4,
+				target_version,
+			));
+		}
+		v4::ToRivet::ToRivetMetadata(_)
+		| v4::ToRivet::ToRivetEvents(_)
+		| v4::ToRivet::ToRivetAckCommands(_)
+		| v4::ToRivet::ToRivetStopping
+		| v4::ToRivet::ToRivetPong(_)
+		| v4::ToRivet::ToRivetKvRequest(_)
+		| v4::ToRivet::ToRivetTunnelMessage(_)
+		| v4::ToRivet::ToRivetSqliteGetPagesRequest(_)
+		| v4::ToRivet::ToRivetSqliteCommitRequest(_) => {}
+	}
+
+	convert_same_bytes(message)
 }
 
 fn convert_to_envoy_v2_to_v3(message: v2::ToEnvoy) -> Result<v3::ToEnvoy> {
@@ -798,7 +1023,12 @@ fn convert_command_start_actor_v2_to_v1(
 	start: v2::CommandStartActor,
 ) -> Result<v1::CommandStartActor> {
 	if start.sqlite_startup_data.is_some() {
-		bail!("sqlite startup data requires envoy-protocol v2");
+		return Err(incompatible(
+			ProtocolCompatibilityFeature::SqliteStartupData,
+			ProtocolCompatibilityDirection::ToEnvoy,
+			2,
+			1,
+		));
 	}
 
 	Ok(v1::CommandStartActor {
@@ -1093,12 +1323,12 @@ mod tests {
 	use super::{ActorCommandKeyData, ToEnvoy};
 	use crate::{
 		PROTOCOL_VERSION,
-		generated::{v1, v2, v3},
+		generated::{v1, v2, v4},
 	};
 
 	#[test]
 	fn protocol_version_constant_matches_schema_version() {
-		assert_eq!(PROTOCOL_VERSION, 3);
+		assert_eq!(PROTOCOL_VERSION, 4);
 	}
 
 	#[test]
@@ -1123,10 +1353,10 @@ mod tests {
 			}]))?;
 
 		let decoded = ToEnvoy::deserialize_version(&payload, 1)?.unwrap_latest()?;
-		let v3::ToEnvoy::ToEnvoyCommands(commands) = decoded else {
+		let v4::ToEnvoy::ToEnvoyCommands(commands) = decoded else {
 			panic!("expected commands");
 		};
-		let v3::Command::CommandStartActor(start) = &commands[0].inner else {
+		let v4::Command::CommandStartActor(start) = &commands[0].inner else {
 			panic!("expected start actor");
 		};
 
@@ -1154,8 +1384,8 @@ mod tests {
 	#[test]
 	fn actor_command_key_data_round_trips_to_v1() -> Result<()> {
 		let encoded = ActorCommandKeyData::wrap_latest(
-			v3::ActorCommandKeyData::CommandStartActor(v3::CommandStartActor {
-				config: v3::ActorConfig {
+			v4::ActorCommandKeyData::CommandStartActor(v4::CommandStartActor {
+				config: v4::ActorConfig {
 					name: "demo".into(),
 					key: None,
 					create_ts: 7,
@@ -1168,7 +1398,7 @@ mod tests {
 		.serialize_version(1)?;
 
 		let decoded = ActorCommandKeyData::deserialize_version(&encoded, 1)?.unwrap_latest()?;
-		let v3::ActorCommandKeyData::CommandStartActor(start) = decoded else {
+		let v4::ActorCommandKeyData::CommandStartActor(start) = decoded else {
 			panic!("expected start actor");
 		};
 		assert_eq!(start.config.name, "demo");
diff --git a/engine/sdks/rust/envoy-protocol/tests/remote_sql_compat.rs b/engine/sdks/rust/envoy-protocol/tests/remote_sql_compat.rs
new file mode 100644
index 0000000000..ac867d68f2
--- /dev/null
+++ b/engine/sdks/rust/envoy-protocol/tests/remote_sql_compat.rs
@@ -0,0 +1,188 @@
+use anyhow::Result;
+use rivet_envoy_protocol::{
+	generated::v4,
+	versioned::{
+		ProtocolCompatibilityDirection, ProtocolCompatibilityError,
+		ProtocolCompatibilityFeature, ToEnvoy, ToRivet,
+	},
+};
+use vbare::OwnedVersionedData;
+
+fn remote_sql_request_exec() -> v4::ToRivet {
+	v4::ToRivet::ToRivetSqliteExecRequest(v4::ToRivetSqliteExecRequest {
+		request_id: 1,
+		data: v4::SqliteExecRequest {
+			namespace_id: "namespace".into(),
+			actor_id: "actor".into(),
+			generation: 7,
+			sql: "select 1".into(),
+		},
+	})
+}
+
+fn remote_sql_request_execute() -> v4::ToRivet {
+	v4::ToRivet::ToRivetSqliteExecuteRequest(v4::ToRivetSqliteExecuteRequest {
+		request_id: 2,
+		data: v4::SqliteExecuteRequest {
+			namespace_id: "namespace".into(),
+			actor_id: "actor".into(),
+			generation: 7,
+			sql: "select ?".into(),
+			params: Some(vec![v4::SqliteBindParam::SqliteValueInteger(
+				v4::SqliteValueInteger { value: 1 },
+			)]),
+		},
+	})
+}
+
+fn remote_sql_request_execute_write() -> v4::ToRivet {
+	v4::ToRivet::ToRivetSqliteExecuteWriteRequest(v4::ToRivetSqliteExecuteWriteRequest {
+		request_id: 3,
+		data: v4::SqliteExecuteWriteRequest {
+			namespace_id: "namespace".into(),
+			actor_id: "actor".into(),
+			generation: 7,
+			sql: "insert into t values (?)".into(),
+			params: Some(vec![v4::SqliteBindParam::SqliteValueText(
+				v4::SqliteValueText {
+					value: "value".into(),
+				},
+			)]),
+		},
+	})
+}
+
+fn remote_sql_response_exec() -> v4::ToEnvoy {
+	v4::ToEnvoy::ToEnvoySqliteExecResponse(v4::ToEnvoySqliteExecResponse {
+		request_id: 1,
+		data: v4::SqliteExecResponse::SqliteErrorResponse(v4::SqliteErrorResponse {
+			message: "remote sql execution is unavailable".into(),
+		}),
+	})
+}
+
+fn remote_sql_response_execute() -> v4::ToEnvoy {
+	v4::ToEnvoy::ToEnvoySqliteExecuteResponse(v4::ToEnvoySqliteExecuteResponse {
+		request_id: 2,
+		data: v4::SqliteExecuteResponse::SqliteErrorResponse(v4::SqliteErrorResponse {
+			message: "remote sql execution is unavailable".into(),
+		}),
+	})
+}
+
+fn remote_sql_response_execute_write() -> v4::ToEnvoy {
+	v4::ToEnvoy::ToEnvoySqliteExecuteWriteResponse(v4::ToEnvoySqliteExecuteWriteResponse {
+		request_id: 3,
+		data: v4::SqliteExecuteWriteResponse::SqliteErrorResponse(v4::SqliteErrorResponse {
+			message: "remote sql execution is unavailable".into(),
+		}),
+	})
+}
+
+fn assert_compatibility_error(
+	err: anyhow::Error,
+	direction: ProtocolCompatibilityDirection,
+	target_version: u16,
+) {
+	let err = err
+		.downcast_ref::<ProtocolCompatibilityError>()
+		.expect("expected structured protocol compatibility error");
+
+	assert_eq!(err.feature, ProtocolCompatibilityFeature::RemoteSqliteExecution);
+	assert_eq!(err.direction, direction);
+	assert_eq!(err.required_version, 4);
+	assert_eq!(err.target_version, target_version);
+}
+
+#[test]
+fn old_core_new_pegboard_envoy_rejects_remote_sql_request() {
+	let err = ToRivet::wrap_latest(remote_sql_request_exec())
+		.serialize(3)
+		.expect_err("remote SQL requests must not serialize below v4");
+
+	assert_compatibility_error(err, ProtocolCompatibilityDirection::ToRivet, 3);
+}
+
+#[test]
+fn new_core_old_pegboard_envoy_rejects_remote_sql_response() {
+	let err = ToEnvoy::wrap_latest(remote_sql_response_exec())
+		.serialize(3)
+		.expect_err("remote SQL responses must not serialize below v4");
+
+	assert_compatibility_error(err, ProtocolCompatibilityDirection::ToEnvoy, 3);
+}
+
+#[test]
+fn old_core_old_pegboard_envoy_rejects_remote_sql_both_directions() {
+	let request_err = ToRivet::wrap_latest(remote_sql_request_exec())
+		.serialize(3)
+		.expect_err("remote SQL requests must not serialize below v4");
+	let response_err = ToEnvoy::wrap_latest(remote_sql_response_exec())
+		.serialize(3)
+		.expect_err("remote SQL responses must not serialize below v4");
+
+	assert_compatibility_error(request_err, ProtocolCompatibilityDirection::ToRivet, 3);
+	assert_compatibility_error(response_err, ProtocolCompatibilityDirection::ToEnvoy, 3);
+}
+
+#[test]
+fn new_core_new_pegboard_envoy_allows_remote_sql_both_directions() -> Result<()> {
+	let request = ToRivet::wrap_latest(remote_sql_request_exec()).serialize(4)?;
+	let response = ToEnvoy::wrap_latest(remote_sql_response_exec()).serialize(4)?;
+
+	assert!(matches!(
+		ToRivet::deserialize(&request, 4)?,
+		v4::ToRivet::ToRivetSqliteExecRequest(_)
+	));
+	assert!(matches!(
+		ToEnvoy::deserialize(&response, 4)?,
+		v4::ToEnvoy::ToEnvoySqliteExecResponse(_)
+	));
+
+	Ok(())
+}
+
+#[test]
+fn v4_remote_sql_payloads_do_not_decode_as_v3() -> Result<()> {
+	let request = serde_bare::to_vec(&remote_sql_request_exec())?;
+	let response = serde_bare::to_vec(&remote_sql_response_exec())?;
+
+	assert!(ToRivet::deserialize(&request, 3).is_err());
+	assert!(ToEnvoy::deserialize(&response, 3).is_err());
+
+	Ok(())
+}
+
+#[test]
+fn all_remote_sql_request_variants_require_v4() {
+	for version in 1..4 {
+		for request in [
+			remote_sql_request_exec(),
+			remote_sql_request_execute(),
+			remote_sql_request_execute_write(),
+		] {
+			let err = ToRivet::wrap_latest(request)
+				.serialize(version)
+				.expect_err("remote SQL request variant must not serialize below v4");
+
+			assert_compatibility_error(err, ProtocolCompatibilityDirection::ToRivet, 3);
+		}
+	}
+}
+
+#[test]
+fn all_remote_sql_response_variants_require_v4() {
+	for version in 1..4 {
+		for response in [
+			remote_sql_response_exec(),
+			remote_sql_response_execute(),
+			remote_sql_response_execute_write(),
+		] {
+			let err = ToEnvoy::wrap_latest(response)
+				.serialize(version)
+				.expect_err("remote SQL response variant must not serialize below v4");
+
+			assert_compatibility_error(err, ProtocolCompatibilityDirection::ToEnvoy, 3);
+		}
+	}
+}
diff --git a/engine/sdks/rust/envoy-protocol/tests/stateless_sqlite_v3.rs b/engine/sdks/rust/envoy-protocol/tests/stateless_sqlite_v3.rs
index 9e5de977bb..65e109c4be 100644
--- a/engine/sdks/rust/envoy-protocol/tests/stateless_sqlite_v3.rs
+++ b/engine/sdks/rust/envoy-protocol/tests/stateless_sqlite_v3.rs
@@ -162,7 +162,7 @@ fn expected_generation_optional_present_and_absent() -> anyhow::Result<()> {
 
 #[test]
 fn protocol_version_constant_matches_schema_version() {
-	assert_eq!(PROTOCOL_VERSION, 3);
+	assert_eq!(PROTOCOL_VERSION, 4);
 }
 
 #[test]
diff --git a/engine/sdks/rust/test-envoy/Cargo.toml b/engine/sdks/rust/test-envoy/Cargo.toml
index cbcdafbf1c..d1699e5f95 100644
--- a/engine/sdks/rust/test-envoy/Cargo.toml
+++ b/engine/sdks/rust/test-envoy/Cargo.toml
@@ -15,7 +15,7 @@ anyhow.workspace = true
 async-stream.workspace = true
 axum.workspace = true
 reqwest.workspace = true
-rivet-envoy-client.workspace = true
+rivet-envoy-client = { workspace = true, features = ["native-transport"] }
 rivet-envoy-protocol.workspace = true
 serde_json.workspace = true
 tokio.workspace = true
diff --git a/engine/sdks/schemas/envoy-protocol/v4.bare b/engine/sdks/schemas/envoy-protocol/v4.bare
new file mode 100644
index 0000000000..9396e3e5aa
--- /dev/null
+++ b/engine/sdks/schemas/envoy-protocol/v4.bare
@@ -0,0 +1,673 @@
+# MARK: Core Primitives
+
+type Id str
+type Json str
+
+type GatewayId data[4]
+type RequestId data[4]
+type MessageIndex u16
+
+# MARK: KV
+
+# Basic types
+type KvKey data
+type KvValue data
+type KvMetadata struct {
+	version: data
+	updateTs: i64
+}
+
+# Query types
+type KvListAllQuery void
+type KvListRangeQuery struct {
+	start: KvKey
+	end: KvKey
+	exclusive: bool
+}
+
+type KvListPrefixQuery struct {
+	key: KvKey
+}
+
+type KvListQuery union {
+	KvListAllQuery |
+	KvListRangeQuery |
+	KvListPrefixQuery
+}
+
+# Request types
+type KvGetRequest struct {
+	keys: list<KvKey>
+}
+
+type KvListRequest struct {
+	query: KvListQuery
+	reverse: optional<bool>
+	limit: optional<u64>
+}
+
+type KvPutRequest struct {
+	keys: list<KvKey>
+	values: list<KvValue>
+}
+
+type KvDeleteRequest struct {
+	keys: list<KvKey>
+}
+
+type KvDeleteRangeRequest struct {
+	start: KvKey
+	end: KvKey
+}
+
+type KvDropRequest void
+
+# Response types
+type KvErrorResponse struct {
+	message: str
+}
+
+type KvGetResponse struct {
+	keys: list<KvKey>
+	values: list<KvValue>
+	metadata: list<KvMetadata>
+}
+
+type KvListResponse struct {
+	keys: list<KvKey>
+	values: list<KvValue>
+	metadata: list<KvMetadata>
+}
+
+type KvPutResponse void
+type KvDeleteResponse void
+type KvDropResponse void
+
+# Request/Response unions
+type KvRequestData union {
+	KvGetRequest |
+	KvListRequest |
+	KvPutRequest |
+	KvDeleteRequest |
+	KvDeleteRangeRequest |
+	KvDropRequest
+}
+
+type KvResponseData union {
+	KvErrorResponse |
+	KvGetResponse |
+	KvListResponse |
+	KvPutResponse |
+	KvDeleteResponse |
+	KvDropResponse
+}
+
+# MARK: SQLite
+
+type SqlitePgno u32
+type SqliteGeneration u64
+type SqlitePageBytes data
+
+type SqliteDirtyPage struct {
+	pgno: SqlitePgno
+	bytes: SqlitePageBytes
+}
+
+type SqliteFetchedPage struct {
+	pgno: SqlitePgno
+	bytes: optional<SqlitePageBytes>
+}
+
+type SqliteGetPagesRequest struct {
+	actorId: Id
+	pgnos: list<SqlitePgno>
+	expectedGeneration: optional<u64>
+	expectedHeadTxid: optional<u64>
+}
+
+type SqliteGetPagesOk struct {
+	pages: list<SqliteFetchedPage>
+}
+
+type SqliteErrorResponse struct {
+	message: str
+}
+
+type SqliteGetPagesResponse union {
+	SqliteGetPagesOk |
+	SqliteErrorResponse
+}
+
+type SqliteCommitRequest struct {
+	actorId: Id
+	dirtyPages: list<SqliteDirtyPage>
+	dbSizePages: u32
+	nowMs: i64
+	expectedGeneration: optional<u64>
+	expectedHeadTxid: optional<u64>
+}
+
+type SqliteCommitOk void
+
+type SqliteCommitResponse union {
+	SqliteCommitOk |
+	SqliteErrorResponse
+}
+
+# MARK: SQLite Remote Execution
+
+type SqliteValueNull void
+
+type SqliteValueInteger struct {
+	value: i64
+}
+
+type SqliteValueFloat struct {
+	value: data[8]
+}
+
+type SqliteValueText struct {
+	value: str
+}
+
+type SqliteValueBlob struct {
+	value: data
+}
+
+type SqliteBindParam union {
+	SqliteValueNull |
+	SqliteValueInteger |
+	SqliteValueFloat |
+	SqliteValueText |
+	SqliteValueBlob
+}
+
+type SqliteColumnValue union {
+	SqliteValueNull |
+	SqliteValueInteger |
+	SqliteValueFloat |
+	SqliteValueText |
+	SqliteValueBlob
+}
+
+type SqliteQueryResult struct {
+	columns: list<str>
+	rows: list<list<SqliteColumnValue>>
+}
+
+type SqliteExecuteRoute enum {
+	READ
+	WRITE
+	WRITE_FALLBACK
+}
+
+type SqliteExecuteResult struct {
+	columns: list<str>
+	rows: list<list<SqliteColumnValue>>
+	changes: i64
+	lastInsertRowId: optional<i64>
+	route: SqliteExecuteRoute
+}
+
+type SqliteExecRequest struct {
+	namespaceId: Id
+	actorId: Id
+	generation: SqliteGeneration
+	sql: str
+}
+
+type SqliteExecuteRequest struct {
+	namespaceId: Id
+	actorId: Id
+	generation: SqliteGeneration
+	sql: str
+	params: optional<list<SqliteBindParam>>
+}
+
+type SqliteExecuteWriteRequest struct {
+	namespaceId: Id
+	actorId: Id
+	generation: SqliteGeneration
+	sql: str
+	params: optional<list<SqliteBindParam>>
+}
+
+type SqliteExecOk struct {
+	result: SqliteQueryResult
+}
+
+type SqliteExecuteOk struct {
+	result: SqliteExecuteResult
+}
+
+type SqliteExecuteWriteOk struct {
+	result: SqliteExecuteResult
+}
+
+type SqliteExecResponse union {
+	SqliteExecOk |
+	SqliteErrorResponse
+}
+
+type SqliteExecuteResponse union {
+	SqliteExecuteOk |
+	SqliteErrorResponse
+}
+
+type SqliteExecuteWriteResponse union {
+	SqliteExecuteWriteOk |
+	SqliteErrorResponse
+}
+
+# MARK: Actor
+
+# Core
+type StopCode enum {
+	OK
+	ERROR
+}
+
+type ActorName struct {
+	metadata: Json
+}
+
+type ActorConfig struct {
+	name: str
+	key: optional<str>
+	createTs: i64
+	input: optional<data>
+}
+
+type ActorCheckpoint struct {
+	actorId: Id
+	generation: u32
+	index: i64
+}
+
+# Intent
+type ActorIntentSleep void
+
+type ActorIntentStop void
+
+type ActorIntent union {
+	ActorIntentSleep |
+	ActorIntentStop
+}
+
+# State
+type ActorStateRunning void
+
+type ActorStateStopped struct {
+	code: StopCode
+	message: optional<str>
+}
+
+type ActorState union {
+	ActorStateRunning |
+	ActorStateStopped
+}
+
+# MARK: Events
+type EventActorIntent struct {
+	intent: ActorIntent
+}
+
+type EventActorStateUpdate struct {
+	state: ActorState
+}
+
+type EventActorSetAlarm struct {
+	alarmTs: optional<i64>
+}
+
+type Event union {
+	EventActorIntent |
+	EventActorStateUpdate |
+	EventActorSetAlarm
+}
+
+type EventWrapper struct {
+	checkpoint: ActorCheckpoint
+	inner: Event
+}
+
+# MARK: Preloaded KV
+
+type PreloadedKvEntry struct {
+	key: KvKey
+	value: KvValue
+	metadata: KvMetadata
+}
+
+type PreloadedKv struct {
+	entries: list<PreloadedKvEntry>
+	requestedGetKeys: list<KvKey>
+	requestedPrefixes: list<KvKey>
+}
+
+# MARK: Commands
+
+type HibernatingRequest struct {
+	gatewayId: GatewayId
+	requestId: RequestId
+}
+
+type CommandStartActor struct {
+	config: ActorConfig
+	hibernatingRequests: list<HibernatingRequest>
+	preloadedKv: optional<PreloadedKv>
+}
+
+type StopActorReason enum {
+	SLEEP_INTENT
+	STOP_INTENT
+	DESTROY
+	GOING_AWAY
+	LOST
+}
+
+type CommandStopActor struct {
+	reason: StopActorReason
+}
+
+type Command union {
+	CommandStartActor |
+	CommandStopActor
+}
+
+type CommandWrapper struct {
+	checkpoint: ActorCheckpoint
+	inner: Command
+}
+
+# We redeclare this so its top level
+type ActorCommandKeyData union {
+	CommandStartActor |
+	CommandStopActor
+}
+
+# MARK: Tunnel
+
+# Message ID
+
+type MessageId struct {
+	# Globally unique ID
+	gatewayId: GatewayId
+	# Unique ID to the gateway
+	requestId: RequestId
+	# Unique ID to the request
+	messageIndex: MessageIndex
+}
+
+# HTTP
+type ToEnvoyRequestStart struct {
+	actorId: Id
+	method: str
+	path: str
+	headers: map<str><str>
+	body: optional<data>
+	stream: bool
+}
+
+type ToEnvoyRequestChunk struct {
+	body: data
+	finish: bool
+}
+
+type ToEnvoyRequestAbort void
+
+type ToRivetResponseStart struct {
+	status: u16
+	headers: map<str><str>
+	body: optional<data>
+	stream: bool
+}
+
+type ToRivetResponseChunk struct {
+	body: data
+	finish: bool
+}
+
+type ToRivetResponseAbort void
+
+# WebSocket
+type ToEnvoyWebSocketOpen struct {
+	actorId: Id
+	path: str
+	headers: map<str><str>
+}
+
+type ToEnvoyWebSocketMessage struct {
+	data: data
+	binary: bool
+}
+
+type ToEnvoyWebSocketClose struct {
+	code: optional<u16>
+	reason: optional<str>
+}
+
+type ToRivetWebSocketOpen struct {
+	canHibernate: bool
+}
+
+type ToRivetWebSocketMessage struct {
+	data: data
+	binary: bool
+}
+
+type ToRivetWebSocketMessageAck struct {
+	index: MessageIndex
+}
+
+type ToRivetWebSocketClose struct {
+	code: optional<u16>
+	reason: optional<str>
+	hibernate: bool
+}
+
+# To Rivet
+type ToRivetTunnelMessageKind union {
+	# HTTP
+	ToRivetResponseStart |
+	ToRivetResponseChunk |
+	ToRivetResponseAbort |
+
+	# WebSocket
+	ToRivetWebSocketOpen |
+	ToRivetWebSocketMessage |
+	ToRivetWebSocketMessageAck |
+	ToRivetWebSocketClose
+}
+
+type ToRivetTunnelMessage struct {
+	messageId: MessageId
+	messageKind: ToRivetTunnelMessageKind
+}
+
+# To Envoy
+type ToEnvoyTunnelMessageKind union {
+	# HTTP
+	ToEnvoyRequestStart |
+	ToEnvoyRequestChunk |
+	ToEnvoyRequestAbort |
+
+	# WebSocket
+	ToEnvoyWebSocketOpen |
+	ToEnvoyWebSocketMessage |
+	ToEnvoyWebSocketClose
+}
+
+type ToEnvoyTunnelMessage struct {
+	messageId: MessageId
+	messageKind: ToEnvoyTunnelMessageKind
+}
+
+type ToEnvoyPing struct {
+	ts: i64
+}
+
+# MARK: To Rivet
+type ToRivetMetadata struct {
+	prepopulateActorNames: optional<map<str><ActorName>>
+	metadata: optional<Json>
+}
+
+type ToRivetEvents list<EventWrapper>
+
+type ToRivetAckCommands struct {
+	lastCommandCheckpoints: list<ActorCheckpoint>
+}
+
+type ToRivetStopping void
+
+type ToRivetPong struct {
+	ts: i64
+}
+
+type ToRivetKvRequest struct {
+	actorId: Id
+	requestId: u32
+	data: KvRequestData
+}
+
+type ToRivetSqliteGetPagesRequest struct {
+	requestId: u32
+	data: SqliteGetPagesRequest
+}
+
+type ToRivetSqliteCommitRequest struct {
+	requestId: u32
+	data: SqliteCommitRequest
+}
+
+type ToRivetSqliteExecRequest struct {
+	requestId: u32
+	data: SqliteExecRequest
+}
+
+type ToRivetSqliteExecuteRequest struct {
+	requestId: u32
+	data: SqliteExecuteRequest
+}
+
+type ToRivetSqliteExecuteWriteRequest struct {
+	requestId: u32
+	data: SqliteExecuteWriteRequest
+}
+
+type ToRivet union {
+	ToRivetMetadata |
+	ToRivetEvents |
+	ToRivetAckCommands |
+	ToRivetStopping |
+	ToRivetPong |
+	ToRivetKvRequest |
+	ToRivetTunnelMessage |
+	ToRivetSqliteGetPagesRequest |
+	ToRivetSqliteCommitRequest |
+	ToRivetSqliteExecRequest |
+	ToRivetSqliteExecuteRequest |
+	ToRivetSqliteExecuteWriteRequest
+}
+
+# MARK: To Envoy
+type ProtocolMetadata struct {
+	envoyLostThreshold: i64
+	actorStopThreshold: i64
+	maxResponsePayloadSize: u64
+}
+
+type ToEnvoyInit struct {
+	metadata: ProtocolMetadata
+}
+
+type ToEnvoyCommands list<CommandWrapper>
+
+type ToEnvoyAckEvents struct {
+	lastEventCheckpoints: list<ActorCheckpoint>
+}
+
+type ToEnvoyKvResponse struct {
+	requestId: u32
+	data: KvResponseData
+}
+
+type ToEnvoySqliteGetPagesResponse struct {
+	requestId: u32
+	data: SqliteGetPagesResponse
+}
+
+type ToEnvoySqliteCommitResponse struct {
+	requestId: u32
+	data: SqliteCommitResponse
+}
+
+type ToEnvoySqliteExecResponse struct {
+	requestId: u32
+	data: SqliteExecResponse
+}
+
+type ToEnvoySqliteExecuteResponse struct {
+	requestId: u32
+	data: SqliteExecuteResponse
+}
+
+type ToEnvoySqliteExecuteWriteResponse struct {
+	requestId: u32
+	data: SqliteExecuteWriteResponse
+}
+
+type ToEnvoy union {
+	ToEnvoyInit |
+	ToEnvoyCommands |
+	ToEnvoyAckEvents |
+	ToEnvoyKvResponse |
+	ToEnvoyTunnelMessage |
+	ToEnvoyPing |
+	ToEnvoySqliteGetPagesResponse |
+	ToEnvoySqliteCommitResponse |
+	ToEnvoySqliteExecResponse |
+	ToEnvoySqliteExecuteResponse |
+	ToEnvoySqliteExecuteWriteResponse
+}
+
+# MARK: To Envoy Conn
+type ToEnvoyConnPing struct {
+	gatewayId: GatewayId
+	requestId: RequestId
+	ts: i64
+}
+
+type ToEnvoyConnClose void
+
+type ToEnvoyConn union {
+	ToEnvoyConnPing |
+	ToEnvoyConnClose |
+	ToEnvoyCommands |
+	ToEnvoyAckEvents |
+	ToEnvoyTunnelMessage
+}
+
+# MARK: To Gateway
+type ToGatewayPong struct {
+	requestId: RequestId
+	ts: i64
+}
+
+type ToGateway union {
+	ToGatewayPong |
+	ToRivetTunnelMessage
+}
+
+# MARK: To Outbound
+type ToOutboundActorStart struct {
+	namespaceId: Id
+	poolName: str
+	checkpoint: ActorCheckpoint
+	actorConfig: ActorConfig
+}
+
+type ToOutbound union {
+	ToOutboundActorStart
+}
diff --git a/engine/sdks/typescript/envoy-protocol/src/index.ts b/engine/sdks/typescript/envoy-protocol/src/index.ts
index 824b7f16b1..7171249f82 100644
--- a/engine/sdks/typescript/envoy-protocol/src/index.ts
+++ b/engine/sdks/typescript/envoy-protocol/src/index.ts
@@ -551,6 +551,16 @@ export function writeSqlitePgno(bc: bare.ByteCursor, x: SqlitePgno): void {
     bare.writeU32(bc, x)
 }
 
+export type SqliteGeneration = u64
+
+export function readSqliteGeneration(bc: bare.ByteCursor): SqliteGeneration {
+    return bare.readU64(bc)
+}
+
+export function writeSqliteGeneration(bc: bare.ByteCursor, x: SqliteGeneration): void {
+    bare.writeU64(bc, x)
+}
+
 export type SqlitePageBytes = ArrayBuffer
 
 export function readSqlitePageBytes(bc: bare.ByteCursor): SqlitePageBytes {
@@ -812,6 +822,581 @@ export function writeSqliteCommitResponse(bc: bare.ByteCursor, x: SqliteCommitRe
     }
 }
 
+export type SqliteValueNull = null
+
+export type SqliteValueInteger = {
+    readonly value: i64
+}
+
+export function readSqliteValueInteger(bc: bare.ByteCursor): SqliteValueInteger {
+    return {
+        value: bare.readI64(bc),
+    }
+}
+
+export function writeSqliteValueInteger(bc: bare.ByteCursor, x: SqliteValueInteger): void {
+    bare.writeI64(bc, x.value)
+}
+
+export type SqliteValueFloat = {
+    readonly value: ArrayBuffer
+}
+
+export function readSqliteValueFloat(bc: bare.ByteCursor): SqliteValueFloat {
+    return {
+        value: bare.readFixedData(bc, 8),
+    }
+}
+
+export function writeSqliteValueFloat(bc: bare.ByteCursor, x: SqliteValueFloat): void {
+    {
+        assert(x.value.byteLength === 8)
+        bare.writeFixedData(bc, x.value)
+    }
+}
+
+export type SqliteValueText = {
+    readonly value: string
+}
+
+export function readSqliteValueText(bc: bare.ByteCursor): SqliteValueText {
+    return {
+        value: bare.readString(bc),
+    }
+}
+
+export function writeSqliteValueText(bc: bare.ByteCursor, x: SqliteValueText): void {
+    bare.writeString(bc, x.value)
+}
+
+export type SqliteValueBlob = {
+    readonly value: ArrayBuffer
+}
+
+export function readSqliteValueBlob(bc: bare.ByteCursor): SqliteValueBlob {
+    return {
+        value: bare.readData(bc),
+    }
+}
+
+export function writeSqliteValueBlob(bc: bare.ByteCursor, x: SqliteValueBlob): void {
+    bare.writeData(bc, x.value)
+}
+
+export type SqliteBindParam =
+    | { readonly tag: "SqliteValueNull"; readonly val: SqliteValueNull }
+    | { readonly tag: "SqliteValueInteger"; readonly val: SqliteValueInteger }
+    | { readonly tag: "SqliteValueFloat"; readonly val: SqliteValueFloat }
+    | { readonly tag: "SqliteValueText"; readonly val: SqliteValueText }
+    | { readonly tag: "SqliteValueBlob"; readonly val: SqliteValueBlob }
+
+export function readSqliteBindParam(bc: bare.ByteCursor): SqliteBindParam {
+    const offset = bc.offset
+    const tag = bare.readU8(bc)
+    switch (tag) {
+        case 0:
+            return { tag: "SqliteValueNull", val: null }
+        case 1:
+            return { tag: "SqliteValueInteger", val: readSqliteValueInteger(bc) }
+        case 2:
+            return { tag: "SqliteValueFloat", val: readSqliteValueFloat(bc) }
+        case 3:
+            return { tag: "SqliteValueText", val: readSqliteValueText(bc) }
+        case 4:
+            return { tag: "SqliteValueBlob", val: readSqliteValueBlob(bc) }
+        default: {
+            bc.offset = offset
+            throw new bare.BareError(offset, "invalid tag")
+        }
+    }
+}
+
+export function writeSqliteBindParam(bc: bare.ByteCursor, x: SqliteBindParam): void {
+    switch (x.tag) {
+        case "SqliteValueNull": {
+            bare.writeU8(bc, 0)
+            break
+        }
+        case "SqliteValueInteger": {
+            bare.writeU8(bc, 1)
+            writeSqliteValueInteger(bc, x.val)
+            break
+        }
+        case "SqliteValueFloat": {
+            bare.writeU8(bc, 2)
+            writeSqliteValueFloat(bc, x.val)
+            break
+        }
+        case "SqliteValueText": {
+            bare.writeU8(bc, 3)
+            writeSqliteValueText(bc, x.val)
+            break
+        }
+        case "SqliteValueBlob": {
+            bare.writeU8(bc, 4)
+            writeSqliteValueBlob(bc, x.val)
+            break
+        }
+    }
+}
+
+export type SqliteColumnValue =
+    | { readonly tag: "SqliteValueNull"; readonly val: SqliteValueNull }
+    | { readonly tag: "SqliteValueInteger"; readonly val: SqliteValueInteger }
+    | { readonly tag: "SqliteValueFloat"; readonly val: SqliteValueFloat }
+    | { readonly tag: "SqliteValueText"; readonly val: SqliteValueText }
+    | { readonly tag: "SqliteValueBlob"; readonly val: SqliteValueBlob }
+
+export function readSqliteColumnValue(bc: bare.ByteCursor): SqliteColumnValue {
+    const offset = bc.offset
+    const tag = bare.readU8(bc)
+    switch (tag) {
+        case 0:
+            return { tag: "SqliteValueNull", val: null }
+        case 1:
+            return { tag: "SqliteValueInteger", val: readSqliteValueInteger(bc) }
+        case 2:
+            return { tag: "SqliteValueFloat", val: readSqliteValueFloat(bc) }
+        case 3:
+            return { tag: "SqliteValueText", val: readSqliteValueText(bc) }
+        case 4:
+            return { tag: "SqliteValueBlob", val: readSqliteValueBlob(bc) }
+        default: {
+            bc.offset = offset
+            throw new bare.BareError(offset, "invalid tag")
+        }
+    }
+}
+
+export function writeSqliteColumnValue(bc: bare.ByteCursor, x: SqliteColumnValue): void {
+    switch (x.tag) {
+        case "SqliteValueNull": {
+            bare.writeU8(bc, 0)
+            break
+        }
+        case "SqliteValueInteger": {
+            bare.writeU8(bc, 1)
+            writeSqliteValueInteger(bc, x.val)
+            break
+        }
+        case "SqliteValueFloat": {
+            bare.writeU8(bc, 2)
+            writeSqliteValueFloat(bc, x.val)
+            break
+        }
+        case "SqliteValueText": {
+            bare.writeU8(bc, 3)
+            writeSqliteValueText(bc, x.val)
+            break
+        }
+        case "SqliteValueBlob": {
+            bare.writeU8(bc, 4)
+            writeSqliteValueBlob(bc, x.val)
+            break
+        }
+    }
+}
+
+function read9(bc: bare.ByteCursor): readonly string[] {
+    const len = bare.readUintSafe(bc)
+    if (len === 0) {
+        return []
+    }
+    const result = [bare.readString(bc)]
+    for (let i = 1; i < len; i++) {
+        result[i] = bare.readString(bc)
+    }
+    return result
+}
+
+function write9(bc: bare.ByteCursor, x: readonly string[]): void {
+    bare.writeUintSafe(bc, x.length)
+    for (let i = 0; i < x.length; i++) {
+        bare.writeString(bc, x[i])
+    }
+}
+
+function read10(bc: bare.ByteCursor): readonly SqliteColumnValue[] {
+    const len = bare.readUintSafe(bc)
+    if (len === 0) {
+        return []
+    }
+    const result = [readSqliteColumnValue(bc)]
+    for (let i = 1; i < len; i++) {
+        result[i] = readSqliteColumnValue(bc)
+    }
+    return result
+}
+
+function write10(bc: bare.ByteCursor, x: readonly SqliteColumnValue[]): void {
+    bare.writeUintSafe(bc, x.length)
+    for (let i = 0; i < x.length; i++) {
+        writeSqliteColumnValue(bc, x[i])
+    }
+}
+
+function read11(bc: bare.ByteCursor): readonly (readonly SqliteColumnValue[])[] {
+    const len = bare.readUintSafe(bc)
+    if (len === 0) {
+        return []
+    }
+    const result = [read10(bc)]
+    for (let i = 1; i < len; i++) {
+        result[i] = read10(bc)
+    }
+    return result
+}
+
+function write11(bc: bare.ByteCursor, x: readonly (readonly SqliteColumnValue[])[]): void {
+    bare.writeUintSafe(bc, x.length)
+    for (let i = 0; i < x.length; i++) {
+        write10(bc, x[i])
+    }
+}
+
+export type SqliteQueryResult = {
+    readonly columns: readonly string[]
+    readonly rows: readonly (readonly SqliteColumnValue[])[]
+}
+
+export function readSqliteQueryResult(bc: bare.ByteCursor): SqliteQueryResult {
+    return {
+        columns: read9(bc),
+        rows: read11(bc),
+    }
+}
+
+export function writeSqliteQueryResult(bc: bare.ByteCursor, x: SqliteQueryResult): void {
+    write9(bc, x.columns)
+    write11(bc, x.rows)
+}
+
+export enum SqliteExecuteRoute {
+    Read = "Read",
+    Write = "Write",
+    WriteFallback = "WriteFallback",
+}
+
+export function readSqliteExecuteRoute(bc: bare.ByteCursor): SqliteExecuteRoute {
+    const offset = bc.offset
+    const tag = bare.readU8(bc)
+    switch (tag) {
+        case 0:
+            return SqliteExecuteRoute.Read
+        case 1:
+            return SqliteExecuteRoute.Write
+        case 2:
+            return SqliteExecuteRoute.WriteFallback
+        default: {
+            bc.offset = offset
+            throw new bare.BareError(offset, "invalid tag")
+        }
+    }
+}
+
+export function writeSqliteExecuteRoute(bc: bare.ByteCursor, x: SqliteExecuteRoute): void {
+    switch (x) {
+        case SqliteExecuteRoute.Read: {
+            bare.writeU8(bc, 0)
+            break
+        }
+        case SqliteExecuteRoute.Write: {
+            bare.writeU8(bc, 1)
+            break
+        }
+        case SqliteExecuteRoute.WriteFallback: {
+            bare.writeU8(bc, 2)
+            break
+        }
+    }
+}
+
+function read12(bc: bare.ByteCursor): i64 | null {
+    return bare.readBool(bc) ? bare.readI64(bc) : null
+}
+
+function write12(bc: bare.ByteCursor, x: i64 | null): void {
+    bare.writeBool(bc, x != null)
+    if (x != null) {
+        bare.writeI64(bc, x)
+    }
+}
+
+export type SqliteExecuteResult = {
+    readonly columns: readonly string[]
+    readonly rows: readonly (readonly SqliteColumnValue[])[]
+    readonly changes: i64
+    readonly lastInsertRowId: i64 | null
+    readonly route: SqliteExecuteRoute
+}
+
+export function readSqliteExecuteResult(bc: bare.ByteCursor): SqliteExecuteResult {
+    return {
+        columns: read9(bc),
+        rows: read11(bc),
+        changes: bare.readI64(bc),
+        lastInsertRowId: read12(bc),
+        route: readSqliteExecuteRoute(bc),
+    }
+}
+
+export function writeSqliteExecuteResult(bc: bare.ByteCursor, x: SqliteExecuteResult): void {
+    write9(bc, x.columns)
+    write11(bc, x.rows)
+    bare.writeI64(bc, x.changes)
+    write12(bc, x.lastInsertRowId)
+    writeSqliteExecuteRoute(bc, x.route)
+}
+
+export type SqliteExecRequest = {
+    readonly namespaceId: Id
+    readonly actorId: Id
+    readonly generation: SqliteGeneration
+    readonly sql: string
+}
+
+export function readSqliteExecRequest(bc: bare.ByteCursor): SqliteExecRequest {
+    return {
+        namespaceId: readId(bc),
+        actorId: readId(bc),
+        generation: readSqliteGeneration(bc),
+        sql: bare.readString(bc),
+    }
+}
+
+export function writeSqliteExecRequest(bc: bare.ByteCursor, x: SqliteExecRequest): void {
+    writeId(bc, x.namespaceId)
+    writeId(bc, x.actorId)
+    writeSqliteGeneration(bc, x.generation)
+    bare.writeString(bc, x.sql)
+}
+
+function read13(bc: bare.ByteCursor): readonly SqliteBindParam[] {
+    const len = bare.readUintSafe(bc)
+    if (len === 0) {
+        return []
+    }
+    const result = [readSqliteBindParam(bc)]
+    for (let i = 1; i < len; i++) {
+        result[i] = readSqliteBindParam(bc)
+    }
+    return result
+}
+
+function write13(bc: bare.ByteCursor, x: readonly SqliteBindParam[]): void {
+    bare.writeUintSafe(bc, x.length)
+    for (let i = 0; i < x.length; i++) {
+        writeSqliteBindParam(bc, x[i])
+    }
+}
+
+function read14(bc: bare.ByteCursor): readonly SqliteBindParam[] | null {
+    return bare.readBool(bc) ? read13(bc) : null
+}
+
+function write14(bc: bare.ByteCursor, x: readonly SqliteBindParam[] | null): void {
+    bare.writeBool(bc, x != null)
+    if (x != null) {
+        write13(bc, x)
+    }
+}
+
+export type SqliteExecuteRequest = {
+    readonly namespaceId: Id
+    readonly actorId: Id
+    readonly generation: SqliteGeneration
+    readonly sql: string
+    readonly params: readonly SqliteBindParam[] | null
+}
+
+export function readSqliteExecuteRequest(bc: bare.ByteCursor): SqliteExecuteRequest {
+    return {
+        namespaceId: readId(bc),
+        actorId: readId(bc),
+        generation: readSqliteGeneration(bc),
+        sql: bare.readString(bc),
+        params: read14(bc),
+    }
+}
+
+export function writeSqliteExecuteRequest(bc: bare.ByteCursor, x: SqliteExecuteRequest): void {
+    writeId(bc, x.namespaceId)
+    writeId(bc, x.actorId)
+    writeSqliteGeneration(bc, x.generation)
+    bare.writeString(bc, x.sql)
+    write14(bc, x.params)
+}
+
+export type SqliteExecuteWriteRequest = {
+    readonly namespaceId: Id
+    readonly actorId: Id
+    readonly generation: SqliteGeneration
+    readonly sql: string
+    readonly params: readonly SqliteBindParam[] | null
+}
+
+export function readSqliteExecuteWriteRequest(bc: bare.ByteCursor): SqliteExecuteWriteRequest {
+    return {
+        namespaceId: readId(bc),
+        actorId: readId(bc),
+        generation: readSqliteGeneration(bc),
+        sql: bare.readString(bc),
+        params: read14(bc),
+    }
+}
+
+export function writeSqliteExecuteWriteRequest(bc: bare.ByteCursor, x: SqliteExecuteWriteRequest): void {
+    writeId(bc, x.namespaceId)
+    writeId(bc, x.actorId)
+    writeSqliteGeneration(bc, x.generation)
+    bare.writeString(bc, x.sql)
+    write14(bc, x.params)
+}
+
+export type SqliteExecOk = {
+    readonly result: SqliteQueryResult
+}
+
+export function readSqliteExecOk(bc: bare.ByteCursor): SqliteExecOk {
+    return {
+        result: readSqliteQueryResult(bc),
+    }
+}
+
+export function writeSqliteExecOk(bc: bare.ByteCursor, x: SqliteExecOk): void {
+    writeSqliteQueryResult(bc, x.result)
+}
+
+export type SqliteExecuteOk = {
+    readonly result: SqliteExecuteResult
+}
+
+export function readSqliteExecuteOk(bc: bare.ByteCursor): SqliteExecuteOk {
+    return {
+        result: readSqliteExecuteResult(bc),
+    }
+}
+
+export function writeSqliteExecuteOk(bc: bare.ByteCursor, x: SqliteExecuteOk): void {
+    writeSqliteExecuteResult(bc, x.result)
+}
+
+export type SqliteExecuteWriteOk = {
+    readonly result: SqliteExecuteResult
+}
+
+export function readSqliteExecuteWriteOk(bc: bare.ByteCursor): SqliteExecuteWriteOk {
+    return {
+        result: readSqliteExecuteResult(bc),
+    }
+}
+
+export function writeSqliteExecuteWriteOk(bc: bare.ByteCursor, x: SqliteExecuteWriteOk): void {
+    writeSqliteExecuteResult(bc, x.result)
+}
+
+export type SqliteExecResponse =
+    | { readonly tag: "SqliteExecOk"; readonly val: SqliteExecOk }
+    | { readonly tag: "SqliteErrorResponse"; readonly val: SqliteErrorResponse }
+
+export function readSqliteExecResponse(bc: bare.ByteCursor): SqliteExecResponse {
+    const offset = bc.offset
+    const tag = bare.readU8(bc)
+    switch (tag) {
+        case 0:
+            return { tag: "SqliteExecOk", val: readSqliteExecOk(bc) }
+        case 1:
+            return { tag: "SqliteErrorResponse", val: readSqliteErrorResponse(bc) }
+        default: {
+            bc.offset = offset
+            throw new bare.BareError(offset, "invalid tag")
+        }
+    }
+}
+
+export function writeSqliteExecResponse(bc: bare.ByteCursor, x: SqliteExecResponse): void {
+    switch (x.tag) {
+        case "SqliteExecOk": {
+            bare.writeU8(bc, 0)
+            writeSqliteExecOk(bc, x.val)
+            break
+        }
+        case "SqliteErrorResponse": {
+            bare.writeU8(bc, 1)
+            writeSqliteErrorResponse(bc, x.val)
+            break
+        }
+    }
+}
+
+export type SqliteExecuteResponse =
+    | { readonly tag: "SqliteExecuteOk"; readonly val: SqliteExecuteOk }
+    | { readonly tag: "SqliteErrorResponse"; readonly val: SqliteErrorResponse }
+
+export function readSqliteExecuteResponse(bc: bare.ByteCursor): SqliteExecuteResponse {
+    const offset = bc.offset
+    const tag = bare.readU8(bc)
+    switch (tag) {
+        case 0:
+            return { tag: "SqliteExecuteOk", val: readSqliteExecuteOk(bc) }
+        case 1:
+            return { tag: "SqliteErrorResponse", val: readSqliteErrorResponse(bc) }
+        default: {
+            bc.offset = offset
+            throw new bare.BareError(offset, "invalid tag")
+        }
+    }
+}
+
+export function writeSqliteExecuteResponse(bc: bare.ByteCursor, x: SqliteExecuteResponse): void {
+    switch (x.tag) {
+        case "SqliteExecuteOk": {
+            bare.writeU8(bc, 0)
+            writeSqliteExecuteOk(bc, x.val)
+            break
+        }
+        case "SqliteErrorResponse": {
+            bare.writeU8(bc, 1)
+            writeSqliteErrorResponse(bc, x.val)
+            break
+        }
+    }
+}
+
+export type SqliteExecuteWriteResponse =
+    | { readonly tag: "SqliteExecuteWriteOk"; readonly val: SqliteExecuteWriteOk }
+    | { readonly tag: "SqliteErrorResponse"; readonly val: SqliteErrorResponse }
+
+export function readSqliteExecuteWriteResponse(bc: bare.ByteCursor): SqliteExecuteWriteResponse {
+    const offset = bc.offset
+    const tag = bare.readU8(bc)
+    switch (tag) {
+        case 0:
+            return { tag: "SqliteExecuteWriteOk", val: readSqliteExecuteWriteOk(bc) }
+        case 1:
+            return { tag: "SqliteErrorResponse", val: readSqliteErrorResponse(bc) }
+        default: {
+            bc.offset = offset
+            throw new bare.BareError(offset, "invalid tag")
+        }
+    }
+}
+
+export function writeSqliteExecuteWriteResponse(bc: bare.ByteCursor, x: SqliteExecuteWriteResponse): void {
+    switch (x.tag) {
+        case "SqliteExecuteWriteOk": {
+            bare.writeU8(bc, 0)
+            writeSqliteExecuteWriteOk(bc, x.val)
+            break
+        }
+        case "SqliteErrorResponse": {
+            bare.writeU8(bc, 1)
+            writeSqliteErrorResponse(bc, x.val)
+            break
+        }
+    }
+}
+
 /**
  * Core
  */
@@ -862,22 +1447,22 @@ export function writeActorName(bc: bare.ByteCursor, x: ActorName): void {
     writeJson(bc, x.metadata)
 }
 
-function read9(bc: bare.ByteCursor): string | null {
+function read15(bc: bare.ByteCursor): string | null {
     return bare.readBool(bc) ? bare.readString(bc) : null
 }
 
-function write9(bc: bare.ByteCursor, x: string | null): void {
+function write15(bc: bare.ByteCursor, x: string | null): void {
     bare.writeBool(bc, x != null)
     if (x != null) {
         bare.writeString(bc, x)
     }
 }
 
-function read10(bc: bare.ByteCursor): ArrayBuffer | null {
+function read16(bc: bare.ByteCursor): ArrayBuffer | null {
     return bare.readBool(bc) ? bare.readData(bc) : null
 }
 
-function write10(bc: bare.ByteCursor, x: ArrayBuffer | null): void {
+function write16(bc: bare.ByteCursor, x: ArrayBuffer | null): void {
     bare.writeBool(bc, x != null)
     if (x != null) {
         bare.writeData(bc, x)
@@ -894,17 +1479,17 @@ export type ActorConfig = {
 export function readActorConfig(bc: bare.ByteCursor): ActorConfig {
     return {
         name: bare.readString(bc),
-        key: read9(bc),
+        key: read15(bc),
         createTs: bare.readI64(bc),
-        input: read10(bc),
+        input: read16(bc),
     }
 }
 
 export function writeActorConfig(bc: bare.ByteCursor, x: ActorConfig): void {
     bare.writeString(bc, x.name)
-    write9(bc, x.key)
+    write15(bc, x.key)
     bare.writeI64(bc, x.createTs)
-    write10(bc, x.input)
+    write16(bc, x.input)
 }
 
 export type ActorCheckpoint = {
@@ -979,13 +1564,13 @@ export type ActorStateStopped = {
 export function readActorStateStopped(bc: bare.ByteCursor): ActorStateStopped {
     return {
         code: readStopCode(bc),
-        message: read9(bc),
+        message: read15(bc),
     }
 }
 
 export function writeActorStateStopped(bc: bare.ByteCursor, x: ActorStateStopped): void {
     writeStopCode(bc, x.code)
-    write9(bc, x.message)
+    write15(bc, x.message)
 }
 
 export type ActorState =
@@ -1052,29 +1637,18 @@ export function writeEventActorStateUpdate(bc: bare.ByteCursor, x: EventActorSta
     writeActorState(bc, x.state)
 }
 
-function read11(bc: bare.ByteCursor): i64 | null {
-    return bare.readBool(bc) ? bare.readI64(bc) : null
-}
-
-function write11(bc: bare.ByteCursor, x: i64 | null): void {
-    bare.writeBool(bc, x != null)
-    if (x != null) {
-        bare.writeI64(bc, x)
-    }
-}
-
 export type EventActorSetAlarm = {
     readonly alarmTs: i64 | null
 }
 
 export function readEventActorSetAlarm(bc: bare.ByteCursor): EventActorSetAlarm {
     return {
-        alarmTs: read11(bc),
+        alarmTs: read12(bc),
     }
 }
 
 export function writeEventActorSetAlarm(bc: bare.ByteCursor, x: EventActorSetAlarm): void {
-    write11(bc, x.alarmTs)
+    write12(bc, x.alarmTs)
 }
 
 export type Event =
@@ -1156,7 +1730,7 @@ export function writePreloadedKvEntry(bc: bare.ByteCursor, x: PreloadedKvEntry):
     writeKvMetadata(bc, x.metadata)
 }
 
-function read12(bc: bare.ByteCursor): readonly PreloadedKvEntry[] {
+function read17(bc: bare.ByteCursor): readonly PreloadedKvEntry[] {
     const len = bare.readUintSafe(bc)
     if (len === 0) {
         return []
@@ -1168,7 +1742,7 @@ function read12(bc: bare.ByteCursor): readonly PreloadedKvEntry[] {
     return result
 }
 
-function write12(bc: bare.ByteCursor, x: readonly PreloadedKvEntry[]): void {
+function write17(bc: bare.ByteCursor, x: readonly PreloadedKvEntry[]): void {
     bare.writeUintSafe(bc, x.length)
     for (let i = 0; i < x.length; i++) {
         writePreloadedKvEntry(bc, x[i])
@@ -1183,14 +1757,14 @@ export type PreloadedKv = {
 
 export function readPreloadedKv(bc: bare.ByteCursor): PreloadedKv {
     return {
-        entries: read12(bc),
+        entries: read17(bc),
         requestedGetKeys: read0(bc),
         requestedPrefixes: read0(bc),
     }
 }
 
 export function writePreloadedKv(bc: bare.ByteCursor, x: PreloadedKv): void {
-    write12(bc, x.entries)
+    write17(bc, x.entries)
     write0(bc, x.requestedGetKeys)
     write0(bc, x.requestedPrefixes)
 }
@@ -1212,7 +1786,7 @@ export function writeHibernatingRequest(bc: bare.ByteCursor, x: HibernatingReque
     writeRequestId(bc, x.requestId)
 }
 
-function read13(bc: bare.ByteCursor): readonly HibernatingRequest[] {
+function read18(bc: bare.ByteCursor): readonly HibernatingRequest[] {
     const len = bare.readUintSafe(bc)
     if (len === 0) {
         return []
@@ -1224,18 +1798,18 @@ function read13(bc: bare.ByteCursor): readonly HibernatingRequest[] {
     return result
 }
 
-function write13(bc: bare.ByteCursor, x: readonly HibernatingRequest[]): void {
+function write18(bc: bare.ByteCursor, x: readonly HibernatingRequest[]): void {
     bare.writeUintSafe(bc, x.length)
     for (let i = 0; i < x.length; i++) {
         writeHibernatingRequest(bc, x[i])
     }
 }
 
-function read14(bc: bare.ByteCursor): PreloadedKv | null {
+function read19(bc: bare.ByteCursor): PreloadedKv | null {
     return bare.readBool(bc) ? readPreloadedKv(bc) : null
 }
 
-function write14(bc: bare.ByteCursor, x: PreloadedKv | null): void {
+function write19(bc: bare.ByteCursor, x: PreloadedKv | null): void {
     bare.writeBool(bc, x != null)
     if (x != null) {
         writePreloadedKv(bc, x)
@@ -1251,15 +1825,15 @@ export type CommandStartActor = {
 export function readCommandStartActor(bc: bare.ByteCursor): CommandStartActor {
     return {
         config: readActorConfig(bc),
-        hibernatingRequests: read13(bc),
-        preloadedKv: read14(bc),
+        hibernatingRequests: read18(bc),
+        preloadedKv: read19(bc),
     }
 }
 
 export function writeCommandStartActor(bc: bare.ByteCursor, x: CommandStartActor): void {
     writeActorConfig(bc, x.config)
-    write13(bc, x.hibernatingRequests)
-    write14(bc, x.preloadedKv)
+    write18(bc, x.hibernatingRequests)
+    write19(bc, x.preloadedKv)
 }
 
 export enum StopActorReason {
@@ -1466,7 +2040,7 @@ export function writeMessageId(bc: bare.ByteCursor, x: MessageId): void {
     writeMessageIndex(bc, x.messageIndex)
 }
 
-function read15(bc: bare.ByteCursor): ReadonlyMap<string, string> {
+function read20(bc: bare.ByteCursor): ReadonlyMap<string, string> {
     const len = bare.readUintSafe(bc)
     const result = new Map<string, string>()
     for (let i = 0; i < len; i++) {
@@ -1481,7 +2055,7 @@ function read15(bc: bare.ByteCursor): ReadonlyMap<string, string> {
     return result
 }
 
-function write15(bc: bare.ByteCursor, x: ReadonlyMap<string, string>): void {
+function write20(bc: bare.ByteCursor, x: ReadonlyMap<string, string>): void {
     bare.writeUintSafe(bc, x.size)
     for (const kv of x) {
         bare.writeString(bc, kv[0])
@@ -1506,8 +2080,8 @@ export function readToEnvoyRequestStart(bc: bare.ByteCursor): ToEnvoyRequestStar
         actorId: readId(bc),
         method: bare.readString(bc),
         path: bare.readString(bc),
-        headers: read15(bc),
-        body: read10(bc),
+        headers: read20(bc),
+        body: read16(bc),
         stream: bare.readBool(bc),
     }
 }
@@ -1516,8 +2090,8 @@ export function writeToEnvoyRequestStart(bc: bare.ByteCursor, x: ToEnvoyRequestS
     writeId(bc, x.actorId)
     bare.writeString(bc, x.method)
     bare.writeString(bc, x.path)
-    write15(bc, x.headers)
-    write10(bc, x.body)
+    write20(bc, x.headers)
+    write16(bc, x.body)
     bare.writeBool(bc, x.stream)
 }
 
@@ -1550,16 +2124,16 @@ export type ToRivetResponseStart = {
 export function readToRivetResponseStart(bc: bare.ByteCursor): ToRivetResponseStart {
     return {
         status: bare.readU16(bc),
-        headers: read15(bc),
-        body: read10(bc),
+        headers: read20(bc),
+        body: read16(bc),
         stream: bare.readBool(bc),
     }
 }
 
 export function writeToRivetResponseStart(bc: bare.ByteCursor, x: ToRivetResponseStart): void {
     bare.writeU16(bc, x.status)
-    write15(bc, x.headers)
-    write10(bc, x.body)
+    write20(bc, x.headers)
+    write16(bc, x.body)
     bare.writeBool(bc, x.stream)
 }
 
@@ -1595,14 +2169,14 @@ export function readToEnvoyWebSocketOpen(bc: bare.ByteCursor): ToEnvoyWebSocketO
     return {
         actorId: readId(bc),
         path: bare.readString(bc),
-        headers: read15(bc),
+        headers: read20(bc),
     }
 }
 
 export function writeToEnvoyWebSocketOpen(bc: bare.ByteCursor, x: ToEnvoyWebSocketOpen): void {
     writeId(bc, x.actorId)
     bare.writeString(bc, x.path)
-    write15(bc, x.headers)
+    write20(bc, x.headers)
 }
 
 export type ToEnvoyWebSocketMessage = {
@@ -1622,11 +2196,11 @@ export function writeToEnvoyWebSocketMessage(bc: bare.ByteCursor, x: ToEnvoyWebS
     bare.writeBool(bc, x.binary)
 }
 
-function read16(bc: bare.ByteCursor): u16 | null {
+function read21(bc: bare.ByteCursor): u16 | null {
     return bare.readBool(bc) ? bare.readU16(bc) : null
 }
 
-function write16(bc: bare.ByteCursor, x: u16 | null): void {
+function write21(bc: bare.ByteCursor, x: u16 | null): void {
     bare.writeBool(bc, x != null)
     if (x != null) {
         bare.writeU16(bc, x)
@@ -1640,14 +2214,14 @@ export type ToEnvoyWebSocketClose = {
 
 export function readToEnvoyWebSocketClose(bc: bare.ByteCursor): ToEnvoyWebSocketClose {
     return {
-        code: read16(bc),
-        reason: read9(bc),
+        code: read21(bc),
+        reason: read15(bc),
     }
 }
 
 export function writeToEnvoyWebSocketClose(bc: bare.ByteCursor, x: ToEnvoyWebSocketClose): void {
-    write16(bc, x.code)
-    write9(bc, x.reason)
+    write21(bc, x.code)
+    write15(bc, x.reason)
 }
 
 export type ToRivetWebSocketOpen = {
@@ -1703,15 +2277,15 @@ export type ToRivetWebSocketClose = {
 
 export function readToRivetWebSocketClose(bc: bare.ByteCursor): ToRivetWebSocketClose {
     return {
-        code: read16(bc),
-        reason: read9(bc),
+        code: read21(bc),
+        reason: read15(bc),
         hibernate: bare.readBool(bc),
     }
 }
 
 export function writeToRivetWebSocketClose(bc: bare.ByteCursor, x: ToRivetWebSocketClose): void {
-    write16(bc, x.code)
-    write9(bc, x.reason)
+    write21(bc, x.code)
+    write15(bc, x.reason)
     bare.writeBool(bc, x.hibernate)
 }
 
@@ -1919,7 +2493,7 @@ export function writeToEnvoyPing(bc: bare.ByteCursor, x: ToEnvoyPing): void {
     bare.writeI64(bc, x.ts)
 }
 
-function read17(bc: bare.ByteCursor): ReadonlyMap<string, ActorName> {
+function read22(bc: bare.ByteCursor): ReadonlyMap<string, ActorName> {
     const len = bare.readUintSafe(bc)
     const result = new Map<string, ActorName>()
     for (let i = 0; i < len; i++) {
@@ -1934,7 +2508,7 @@ function read17(bc: bare.ByteCursor): ReadonlyMap<string, ActorName> {
     return result
 }
 
-function write17(bc: bare.ByteCursor, x: ReadonlyMap<string, ActorName>): void {
+function write22(bc: bare.ByteCursor, x: ReadonlyMap<string, ActorName>): void {
     bare.writeUintSafe(bc, x.size)
     for (const kv of x) {
         bare.writeString(bc, kv[0])
@@ -1942,22 +2516,22 @@ function write17(bc: bare.ByteCursor, x: ReadonlyMap<string, ActorName>): void {
     }
 }
 
-function read18(bc: bare.ByteCursor): ReadonlyMap<string, ActorName> | null {
-    return bare.readBool(bc) ? read17(bc) : null
+function read23(bc: bare.ByteCursor): ReadonlyMap<string, ActorName> | null {
+    return bare.readBool(bc) ? read22(bc) : null
 }
 
-function write18(bc: bare.ByteCursor, x: ReadonlyMap<string, ActorName> | null): void {
+function write23(bc: bare.ByteCursor, x: ReadonlyMap<string, ActorName> | null): void {
     bare.writeBool(bc, x != null)
     if (x != null) {
-        write17(bc, x)
+        write22(bc, x)
     }
 }
 
-function read19(bc: bare.ByteCursor): Json | null {
+function read24(bc: bare.ByteCursor): Json | null {
     return bare.readBool(bc) ? readJson(bc) : null
 }
 
-function write19(bc: bare.ByteCursor, x: Json | null): void {
+function write24(bc: bare.ByteCursor, x: Json | null): void {
     bare.writeBool(bc, x != null)
     if (x != null) {
         writeJson(bc, x)
@@ -1974,14 +2548,14 @@ export type ToRivetMetadata = {
 
 export function readToRivetMetadata(bc: bare.ByteCursor): ToRivetMetadata {
     return {
-        prepopulateActorNames: read18(bc),
-        metadata: read19(bc),
+        prepopulateActorNames: read23(bc),
+        metadata: read24(bc),
     }
 }
 
 export function writeToRivetMetadata(bc: bare.ByteCursor, x: ToRivetMetadata): void {
-    write18(bc, x.prepopulateActorNames)
-    write19(bc, x.metadata)
+    write23(bc, x.prepopulateActorNames)
+    write24(bc, x.metadata)
 }
 
 export type ToRivetEvents = readonly EventWrapper[]
@@ -2005,7 +2579,7 @@ export function writeToRivetEvents(bc: bare.ByteCursor, x: ToRivetEvents): void
     }
 }
 
-function read20(bc: bare.ByteCursor): readonly ActorCheckpoint[] {
+function read25(bc: bare.ByteCursor): readonly ActorCheckpoint[] {
     const len = bare.readUintSafe(bc)
     if (len === 0) {
         return []
@@ -2017,7 +2591,7 @@ function read20(bc: bare.ByteCursor): readonly ActorCheckpoint[] {
     return result
 }
 
-function write20(bc: bare.ByteCursor, x: readonly ActorCheckpoint[]): void {
+function write25(bc: bare.ByteCursor, x: readonly ActorCheckpoint[]): void {
     bare.writeUintSafe(bc, x.length)
     for (let i = 0; i < x.length; i++) {
         writeActorCheckpoint(bc, x[i])
@@ -2030,12 +2604,12 @@ export type ToRivetAckCommands = {
 
 export function readToRivetAckCommands(bc: bare.ByteCursor): ToRivetAckCommands {
     return {
-        lastCommandCheckpoints: read20(bc),
+        lastCommandCheckpoints: read25(bc),
     }
 }
 
 export function writeToRivetAckCommands(bc: bare.ByteCursor, x: ToRivetAckCommands): void {
-    write20(bc, x.lastCommandCheckpoints)
+    write25(bc, x.lastCommandCheckpoints)
 }
 
 export type ToRivetStopping = null
@@ -2108,6 +2682,57 @@ export function writeToRivetSqliteCommitRequest(bc: bare.ByteCursor, x: ToRivetS
     writeSqliteCommitRequest(bc, x.data)
 }
 
+export type ToRivetSqliteExecRequest = {
+    readonly requestId: u32
+    readonly data: SqliteExecRequest
+}
+
+export function readToRivetSqliteExecRequest(bc: bare.ByteCursor): ToRivetSqliteExecRequest {
+    return {
+        requestId: bare.readU32(bc),
+        data: readSqliteExecRequest(bc),
+    }
+}
+
+export function writeToRivetSqliteExecRequest(bc: bare.ByteCursor, x: ToRivetSqliteExecRequest): void {
+    bare.writeU32(bc, x.requestId)
+    writeSqliteExecRequest(bc, x.data)
+}
+
+export type ToRivetSqliteExecuteRequest = {
+    readonly requestId: u32
+    readonly data: SqliteExecuteRequest
+}
+
+export function readToRivetSqliteExecuteRequest(bc: bare.ByteCursor): ToRivetSqliteExecuteRequest {
+    return {
+        requestId: bare.readU32(bc),
+        data: readSqliteExecuteRequest(bc),
+    }
+}
+
+export function writeToRivetSqliteExecuteRequest(bc: bare.ByteCursor, x: ToRivetSqliteExecuteRequest): void {
+    bare.writeU32(bc, x.requestId)
+    writeSqliteExecuteRequest(bc, x.data)
+}
+
+export type ToRivetSqliteExecuteWriteRequest = {
+    readonly requestId: u32
+    readonly data: SqliteExecuteWriteRequest
+}
+
+export function readToRivetSqliteExecuteWriteRequest(bc: bare.ByteCursor): ToRivetSqliteExecuteWriteRequest {
+    return {
+        requestId: bare.readU32(bc),
+        data: readSqliteExecuteWriteRequest(bc),
+    }
+}
+
+export function writeToRivetSqliteExecuteWriteRequest(bc: bare.ByteCursor, x: ToRivetSqliteExecuteWriteRequest): void {
+    bare.writeU32(bc, x.requestId)
+    writeSqliteExecuteWriteRequest(bc, x.data)
+}
+
 export type ToRivet =
     | { readonly tag: "ToRivetMetadata"; readonly val: ToRivetMetadata }
     | { readonly tag: "ToRivetEvents"; readonly val: ToRivetEvents }
@@ -2118,6 +2743,9 @@ export type ToRivet =
     | { readonly tag: "ToRivetTunnelMessage"; readonly val: ToRivetTunnelMessage }
     | { readonly tag: "ToRivetSqliteGetPagesRequest"; readonly val: ToRivetSqliteGetPagesRequest }
     | { readonly tag: "ToRivetSqliteCommitRequest"; readonly val: ToRivetSqliteCommitRequest }
+    | { readonly tag: "ToRivetSqliteExecRequest"; readonly val: ToRivetSqliteExecRequest }
+    | { readonly tag: "ToRivetSqliteExecuteRequest"; readonly val: ToRivetSqliteExecuteRequest }
+    | { readonly tag: "ToRivetSqliteExecuteWriteRequest"; readonly val: ToRivetSqliteExecuteWriteRequest }
 
 export function readToRivet(bc: bare.ByteCursor): ToRivet {
     const offset = bc.offset
@@ -2141,6 +2769,12 @@ export function readToRivet(bc: bare.ByteCursor): ToRivet {
             return { tag: "ToRivetSqliteGetPagesRequest", val: readToRivetSqliteGetPagesRequest(bc) }
         case 8:
             return { tag: "ToRivetSqliteCommitRequest", val: readToRivetSqliteCommitRequest(bc) }
+        case 9:
+            return { tag: "ToRivetSqliteExecRequest", val: readToRivetSqliteExecRequest(bc) }
+        case 10:
+            return { tag: "ToRivetSqliteExecuteRequest", val: readToRivetSqliteExecuteRequest(bc) }
+        case 11:
+            return { tag: "ToRivetSqliteExecuteWriteRequest", val: readToRivetSqliteExecuteWriteRequest(bc) }
         default: {
             bc.offset = offset
             throw new bare.BareError(offset, "invalid tag")
@@ -2194,6 +2828,21 @@ export function writeToRivet(bc: bare.ByteCursor, x: ToRivet): void {
             writeToRivetSqliteCommitRequest(bc, x.val)
             break
         }
+        case "ToRivetSqliteExecRequest": {
+            bare.writeU8(bc, 9)
+            writeToRivetSqliteExecRequest(bc, x.val)
+            break
+        }
+        case "ToRivetSqliteExecuteRequest": {
+            bare.writeU8(bc, 10)
+            writeToRivetSqliteExecuteRequest(bc, x.val)
+            break
+        }
+        case "ToRivetSqliteExecuteWriteRequest": {
+            bare.writeU8(bc, 11)
+            writeToRivetSqliteExecuteWriteRequest(bc, x.val)
+            break
+        }
     }
 }
 
@@ -2280,12 +2929,12 @@ export type ToEnvoyAckEvents = {
 
 export function readToEnvoyAckEvents(bc: bare.ByteCursor): ToEnvoyAckEvents {
     return {
-        lastEventCheckpoints: read20(bc),
+        lastEventCheckpoints: read25(bc),
     }
 }
 
 export function writeToEnvoyAckEvents(bc: bare.ByteCursor, x: ToEnvoyAckEvents): void {
-    write20(bc, x.lastEventCheckpoints)
+    write25(bc, x.lastEventCheckpoints)
 }
 
 export type ToEnvoyKvResponse = {
@@ -2339,6 +2988,57 @@ export function writeToEnvoySqliteCommitResponse(bc: bare.ByteCursor, x: ToEnvoy
     writeSqliteCommitResponse(bc, x.data)
 }
 
+export type ToEnvoySqliteExecResponse = {
+    readonly requestId: u32
+    readonly data: SqliteExecResponse
+}
+
+export function readToEnvoySqliteExecResponse(bc: bare.ByteCursor): ToEnvoySqliteExecResponse {
+    return {
+        requestId: bare.readU32(bc),
+        data: readSqliteExecResponse(bc),
+    }
+}
+
+export function writeToEnvoySqliteExecResponse(bc: bare.ByteCursor, x: ToEnvoySqliteExecResponse): void {
+    bare.writeU32(bc, x.requestId)
+    writeSqliteExecResponse(bc, x.data)
+}
+
+export type ToEnvoySqliteExecuteResponse = {
+    readonly requestId: u32
+    readonly data: SqliteExecuteResponse
+}
+
+export function readToEnvoySqliteExecuteResponse(bc: bare.ByteCursor): ToEnvoySqliteExecuteResponse {
+    return {
+        requestId: bare.readU32(bc),
+        data: readSqliteExecuteResponse(bc),
+    }
+}
+
+export function writeToEnvoySqliteExecuteResponse(bc: bare.ByteCursor, x: ToEnvoySqliteExecuteResponse): void {
+    bare.writeU32(bc, x.requestId)
+    writeSqliteExecuteResponse(bc, x.data)
+}
+
+export type ToEnvoySqliteExecuteWriteResponse = {
+    readonly requestId: u32
+    readonly data: SqliteExecuteWriteResponse
+}
+
+export function readToEnvoySqliteExecuteWriteResponse(bc: bare.ByteCursor): ToEnvoySqliteExecuteWriteResponse {
+    return {
+        requestId: bare.readU32(bc),
+        data: readSqliteExecuteWriteResponse(bc),
+    }
+}
+
+export function writeToEnvoySqliteExecuteWriteResponse(bc: bare.ByteCursor, x: ToEnvoySqliteExecuteWriteResponse): void {
+    bare.writeU32(bc, x.requestId)
+    writeSqliteExecuteWriteResponse(bc, x.data)
+}
+
 export type ToEnvoy =
     | { readonly tag: "ToEnvoyInit"; readonly val: ToEnvoyInit }
     | { readonly tag: "ToEnvoyCommands"; readonly val: ToEnvoyCommands }
@@ -2348,6 +3048,9 @@ export type ToEnvoy =
     | { readonly tag: "ToEnvoyPing"; readonly val: ToEnvoyPing }
     | { readonly tag: "ToEnvoySqliteGetPagesResponse"; readonly val: ToEnvoySqliteGetPagesResponse }
     | { readonly tag: "ToEnvoySqliteCommitResponse"; readonly val: ToEnvoySqliteCommitResponse }
+    | { readonly tag: "ToEnvoySqliteExecResponse"; readonly val: ToEnvoySqliteExecResponse }
+    | { readonly tag: "ToEnvoySqliteExecuteResponse"; readonly val: ToEnvoySqliteExecuteResponse }
+    | { readonly tag: "ToEnvoySqliteExecuteWriteResponse"; readonly val: ToEnvoySqliteExecuteWriteResponse }
 
 export function readToEnvoy(bc: bare.ByteCursor): ToEnvoy {
     const offset = bc.offset
@@ -2369,6 +3072,12 @@ export function readToEnvoy(bc: bare.ByteCursor): ToEnvoy {
             return { tag: "ToEnvoySqliteGetPagesResponse", val: readToEnvoySqliteGetPagesResponse(bc) }
         case 7:
             return { tag: "ToEnvoySqliteCommitResponse", val: readToEnvoySqliteCommitResponse(bc) }
+        case 8:
+            return { tag: "ToEnvoySqliteExecResponse", val: readToEnvoySqliteExecResponse(bc) }
+        case 9:
+            return { tag: "ToEnvoySqliteExecuteResponse", val: readToEnvoySqliteExecuteResponse(bc) }
+        case 10:
+            return { tag: "ToEnvoySqliteExecuteWriteResponse", val: readToEnvoySqliteExecuteWriteResponse(bc) }
         default: {
             bc.offset = offset
             throw new bare.BareError(offset, "invalid tag")
@@ -2418,6 +3127,21 @@ export function writeToEnvoy(bc: bare.ByteCursor, x: ToEnvoy): void {
             writeToEnvoySqliteCommitResponse(bc, x.val)
             break
         }
+        case "ToEnvoySqliteExecResponse": {
+            bare.writeU8(bc, 8)
+            writeToEnvoySqliteExecResponse(bc, x.val)
+            break
+        }
+        case "ToEnvoySqliteExecuteResponse": {
+            bare.writeU8(bc, 9)
+            writeToEnvoySqliteExecuteResponse(bc, x.val)
+            break
+        }
+        case "ToEnvoySqliteExecuteWriteResponse": {
+            bare.writeU8(bc, 10)
+            writeToEnvoySqliteExecuteWriteResponse(bc, x.val)
+            break
+        }
     }
 }
 
@@ -2690,4 +3414,4 @@ function assert(condition: boolean, message?: string): asserts condition {
     if (!condition) throw new Error(message ?? "Assertion failed")
 }
 
-export const VERSION = 3;
\ No newline at end of file
+export const VERSION = 4;
\ No newline at end of file
diff --git a/examples/kitchen-sink-vercel/AGENTS.md b/examples/kitchen-sink-vercel/AGENTS.md
new file mode 120000
index 0000000000..681311eb9c
--- /dev/null
+++ b/examples/kitchen-sink-vercel/AGENTS.md
@@ -0,0 +1 @@
+CLAUDE.md
\ No newline at end of file
diff --git a/examples/kitchen-sink/AGENTS.md b/examples/kitchen-sink/AGENTS.md
new file mode 120000
index 0000000000..681311eb9c
--- /dev/null
+++ b/examples/kitchen-sink/AGENTS.md
@@ -0,0 +1 @@
+CLAUDE.md
\ No newline at end of file
diff --git a/examples/kitchen-sink/src/cloudflare.ts b/examples/kitchen-sink/src/cloudflare.ts
new file mode 100644
index 0000000000..d8c8afbf38
--- /dev/null
+++ b/examples/kitchen-sink/src/cloudflare.ts
@@ -0,0 +1,49 @@
+import wasmModule from "../../../rivetkit-typescript/packages/rivetkit-wasm/pkg/rivetkit_wasm_bg.wasm";
+import * as rivetkitWasm from "../../../rivetkit-typescript/packages/rivetkit-wasm/pkg/rivetkit_wasm.js";
+import { setup } from "rivetkit";
+import { counter } from "./actors/counter/counter.ts";
+import { rawHttpActor } from "./actors/http/raw-http.ts";
+import { rawWebSocketActor } from "./actors/http/raw-websocket.ts";
+import { testCounterSqlite } from "./actors/testing/test-counter-sqlite.ts";
+
+(
+	globalThis as typeof globalThis & {
+		__rivetkitWasmBindings?: typeof rivetkitWasm;
+	}
+).__rivetkitWasmBindings = rivetkitWasm;
+
+const registry = setup({
+	runtime: "wasm",
+	wasm: {
+		initInput: wasmModule as WebAssembly.Module,
+	},
+	test: {
+		enabled: true,
+		sqliteBackend: "remote",
+	},
+	noWelcome: true,
+	startEngine: false,
+	use: {
+		counter,
+		rawHttpActor,
+		rawWebSocketActor,
+		testCounterSqlite,
+	},
+});
+
+function matchesRivetPath(pathname: string) {
+	return pathname === "/api/rivet" || pathname.startsWith("/api/rivet/");
+}
+
+export default {
+	async fetch(request: Request) {
+		const url = new URL(request.url);
+		if (url.pathname === "/health") {
+			return Response.json({ ok: true });
+		}
+		if (matchesRivetPath(url.pathname)) {
+			return registry.handler(request);
+		}
+		return new Response("not found", { status: 404 });
+	},
+};
diff --git a/examples/kitchen-sink/supabase/.gitignore b/examples/kitchen-sink/supabase/.gitignore
new file mode 100644
index 0000000000..4eca3f39a8
--- /dev/null
+++ b/examples/kitchen-sink/supabase/.gitignore
@@ -0,0 +1,9 @@
+# Supabase
+.branches
+.temp
+
+# dotenvx
+.env.keys
+.env.local
+.env.*.local
+functions/rivetkit/rivetkit_wasm_bg.wasm
diff --git a/examples/kitchen-sink/supabase/config.toml b/examples/kitchen-sink/supabase/config.toml
new file mode 100644
index 0000000000..6b54d4a790
--- /dev/null
+++ b/examples/kitchen-sink/supabase/config.toml
@@ -0,0 +1,414 @@
+# For detailed configuration reference documentation, visit:
+# https://supabase.com/docs/guides/local-development/cli/config
+# A string used to distinguish different Supabase projects on the same host. Defaults to the
+# working directory name when running `supabase init`.
+project_id = "kitchen-sink"
+
+[api]
+enabled = true
+# Port to use for the API URL.
+port = 54321
+# Schemas to expose in your API. Tables, views and stored procedures in this schema will get API
+# endpoints. `public` and `graphql_public` schemas are included by default.
+schemas = ["public", "graphql_public"]
+# Extra schemas to add to the search_path of every request.
+extra_search_path = ["public", "extensions"]
+# The maximum number of rows returns from a view, table, or stored procedure. Limits payload size
+# for accidental or malicious requests.
+max_rows = 1000
+
+[api.tls]
+# Enable HTTPS endpoints locally using a self-signed certificate.
+enabled = false
+# Paths to self-signed certificate pair.
+# cert_path = "../certs/my-cert.pem"
+# key_path = "../certs/my-key.pem"
+
+[db]
+# Port to use for the local database URL.
+port = 54322
+# Port used by db diff command to initialize the shadow database.
+shadow_port = 54320
+# Maximum amount of time to wait for health check when starting the local database.
+health_timeout = "2m"
+# The database major version to use. This has to be the same as your remote database's. Run `SHOW
+# server_version;` on the remote database to check.
+major_version = 17
+
+[db.pooler]
+enabled = false
+# Port to use for the local connection pooler.
+port = 54329
+# Specifies when a server connection can be reused by other clients.
+# Configure one of the supported pooler modes: `transaction`, `session`.
+pool_mode = "transaction"
+# How many server connections to allow per user/database pair.
+default_pool_size = 20
+# Maximum number of client connections allowed.
+max_client_conn = 100
+
+# [db.vault]
+# secret_key = "env(SECRET_VALUE)"
+
+[db.migrations]
+# If disabled, migrations will be skipped during a db push or reset.
+enabled = true
+# Specifies an ordered list of schema files that describe your database.
+# Supports glob patterns relative to supabase directory: "./schemas/*.sql"
+schema_paths = []
+
+[db.seed]
+# If enabled, seeds the database after migrations during a db reset.
+enabled = true
+# Specifies an ordered list of seed files to load during db reset.
+# Supports glob patterns relative to supabase directory: "./seeds/*.sql"
+sql_paths = ["./seed.sql"]
+
+[db.network_restrictions]
+# Enable management of network restrictions.
+enabled = false
+# List of IPv4 CIDR blocks allowed to connect to the database.
+# Defaults to allow all IPv4 connections. Set empty array to block all IPs.
+allowed_cidrs = ["0.0.0.0/0"]
+# List of IPv6 CIDR blocks allowed to connect to the database.
+# Defaults to allow all IPv6 connections. Set empty array to block all IPs.
+allowed_cidrs_v6 = ["::/0"]
+
+# Uncomment to reject non-secure connections to the database.
+# [db.ssl_enforcement]
+# enabled = true
+
+[realtime]
+enabled = true
+# Bind realtime via either IPv4 or IPv6. (default: IPv4)
+# ip_version = "IPv6"
+# The maximum length in bytes of HTTP request headers. (default: 4096)
+# max_header_length = 4096
+
+[studio]
+enabled = true
+# Port to use for Supabase Studio.
+port = 54323
+# External URL of the API server that frontend connects to.
+api_url = "http://127.0.0.1"
+# OpenAI API Key to use for Supabase AI in the Supabase Studio.
+openai_api_key = "env(OPENAI_API_KEY)"
+
+# Email testing server. Emails sent with the local dev setup are not actually sent - rather, they
+# are monitored, and you can view the emails that would have been sent from the web interface.
+[inbucket]
+enabled = true
+# Port to use for the email testing server web interface.
+port = 54324
+# Uncomment to expose additional ports for testing user applications that send emails.
+# smtp_port = 54325
+# pop3_port = 54326
+# admin_email = "admin@email.com"
+# sender_name = "Admin"
+
+[storage]
+enabled = true
+# The maximum file size allowed (e.g. "5MB", "500KB").
+file_size_limit = "50MiB"
+
+# Uncomment to configure local storage buckets
+# [storage.buckets.images]
+# public = false
+# file_size_limit = "50MiB"
+# allowed_mime_types = ["image/png", "image/jpeg"]
+# objects_path = "./images"
+
+# Allow connections via S3 compatible clients
+[storage.s3_protocol]
+enabled = true
+
+# Image transformation API is available to Supabase Pro plan.
+# [storage.image_transformation]
+# enabled = true
+
+# Store analytical data in S3 for running ETL jobs over Iceberg Catalog
+# This feature is only available on the hosted platform.
+[storage.analytics]
+enabled = false
+max_namespaces = 5
+max_tables = 10
+max_catalogs = 2
+
+# Analytics Buckets is available to Supabase Pro plan.
+# [storage.analytics.buckets.my-warehouse]
+
+# Store vector embeddings in S3 for large and durable datasets
+# This feature is only available on the hosted platform.
+[storage.vector]
+enabled = false
+max_buckets = 10
+max_indexes = 5
+
+# Vector Buckets is available to Supabase Pro plan.
+# [storage.vector.buckets.documents-openai]
+
+[auth]
+enabled = true
+# The base URL of your website. Used as an allow-list for redirects and for constructing URLs used
+# in emails.
+site_url = "http://127.0.0.1:3000"
+# The public URL that Auth serves on. Defaults to the API external URL with `/auth/v1` appended.
+# external_url = ""
+# A list of *exact* URLs that auth providers are permitted to redirect to post authentication.
+additional_redirect_urls = ["https://127.0.0.1:3000"]
+# How long tokens are valid for, in seconds. Defaults to 3600 (1 hour), maximum 604,800 (1 week).
+jwt_expiry = 3600
+# JWT issuer URL. If not set, defaults to auth.external_url.
+# jwt_issuer = ""
+# Path to JWT signing key. DO NOT commit your signing keys file to git.
+# signing_keys_path = "./signing_keys.json"
+# If disabled, the refresh token will never expire.
+enable_refresh_token_rotation = true
+# Allows refresh tokens to be reused after expiry, up to the specified interval in seconds.
+# Requires enable_refresh_token_rotation = true.
+refresh_token_reuse_interval = 10
+# Allow/disallow new user signups to your project.
+enable_signup = true
+# Allow/disallow anonymous sign-ins to your project.
+enable_anonymous_sign_ins = false
+# Allow/disallow testing manual linking of accounts
+enable_manual_linking = false
+# Passwords shorter than this value will be rejected as weak. Minimum 6, recommended 8 or more.
+minimum_password_length = 6
+# Passwords that do not meet the following requirements will be rejected as weak. Supported values
+# are: `letters_digits`, `lower_upper_letters_digits`, `lower_upper_letters_digits_symbols`
+password_requirements = ""
+
+# Configure passkey sign-ins.
+# [auth.passkey]
+# enabled = false
+
+# Configure WebAuthn relying party settings (required when passkey is enabled).
+# [auth.webauthn]
+# rp_display_name = "Supabase"
+# rp_id = "localhost"
+# rp_origins = ["http://127.0.0.1:3000"]
+
+[auth.rate_limit]
+# Number of emails that can be sent per hour. Requires auth.email.smtp to be enabled.
+email_sent = 2
+# Number of SMS messages that can be sent per hour. Requires auth.sms to be enabled.
+sms_sent = 30
+# Number of anonymous sign-ins that can be made per hour per IP address. Requires enable_anonymous_sign_ins = true.
+anonymous_users = 30
+# Number of sessions that can be refreshed in a 5 minute interval per IP address.
+token_refresh = 150
+# Number of sign up and sign-in requests that can be made in a 5 minute interval per IP address (excludes anonymous users).
+sign_in_sign_ups = 30
+# Number of OTP / Magic link verifications that can be made in a 5 minute interval per IP address.
+token_verifications = 30
+# Number of Web3 logins that can be made in a 5 minute interval per IP address.
+web3 = 30
+
+# Configure one of the supported captcha providers: `hcaptcha`, `turnstile`.
+# [auth.captcha]
+# enabled = true
+# provider = "hcaptcha"
+# secret = ""
+
+[auth.email]
+# Allow/disallow new user signups via email to your project.
+enable_signup = true
+# If enabled, a user will be required to confirm any email change on both the old, and new email
+# addresses. If disabled, only the new email is required to confirm.
+double_confirm_changes = true
+# If enabled, users need to confirm their email address before signing in.
+enable_confirmations = false
+# If enabled, users will need to reauthenticate or have logged in recently to change their password.
+secure_password_change = false
+# Controls the minimum amount of time that must pass before sending another signup confirmation or password reset email.
+max_frequency = "1s"
+# Number of characters used in the email OTP.
+otp_length = 6
+# Number of seconds before the email OTP expires (defaults to 1 hour).
+otp_expiry = 3600
+
+# Use a production-ready SMTP server
+# [auth.email.smtp]
+# enabled = true
+# host = "smtp.sendgrid.net"
+# port = 587
+# user = "apikey"
+# pass = "env(SENDGRID_API_KEY)"
+# admin_email = "admin@email.com"
+# sender_name = "Admin"
+
+# Uncomment to customize email template
+# [auth.email.template.invite]
+# subject = "You have been invited"
+# content_path = "./supabase/templates/invite.html"
+
+# Uncomment to customize notification email template
+# [auth.email.notification.password_changed]
+# enabled = true
+# subject = "Your password has been changed"
+# content_path = "./templates/password_changed_notification.html"
+
+[auth.sms]
+# Allow/disallow new user signups via SMS to your project.
+enable_signup = false
+# If enabled, users need to confirm their phone number before signing in.
+enable_confirmations = false
+# Template for sending OTP to users
+template = "Your code is {{ .Code }}"
+# Controls the minimum amount of time that must pass before sending another sms otp.
+max_frequency = "5s"
+
+# Use pre-defined map of phone number to OTP for testing.
+# [auth.sms.test_otp]
+# 4152127777 = "123456"
+
+# Configure logged in session timeouts.
+# [auth.sessions]
+# Force log out after the specified duration.
+# timebox = "24h"
+# Force log out if the user has been inactive longer than the specified duration.
+# inactivity_timeout = "8h"
+
+# This hook runs before a new user is created and allows developers to reject the request based on the incoming user object.
+# [auth.hook.before_user_created]
+# enabled = true
+# uri = "pg-functions://postgres/auth/before-user-created-hook"
+
+# This hook runs before a token is issued and allows you to add additional claims based on the authentication method used.
+# [auth.hook.custom_access_token]
+# enabled = true
+# uri = "pg-functions://<database>/<schema>/<hook_name>"
+
+# Configure one of the supported SMS providers: `twilio`, `twilio_verify`, `messagebird`, `textlocal`, `vonage`.
+[auth.sms.twilio]
+enabled = false
+account_sid = ""
+message_service_sid = ""
+# DO NOT commit your Twilio auth token to git. Use environment variable substitution instead:
+auth_token = "env(SUPABASE_AUTH_SMS_TWILIO_AUTH_TOKEN)"
+
+# Multi-factor-authentication is available to Supabase Pro plan.
+[auth.mfa]
+# Control how many MFA factors can be enrolled at once per user.
+max_enrolled_factors = 10
+
+# Control MFA via App Authenticator (TOTP)
+[auth.mfa.totp]
+enroll_enabled = false
+verify_enabled = false
+
+# Configure MFA via Phone Messaging
+[auth.mfa.phone]
+enroll_enabled = false
+verify_enabled = false
+otp_length = 6
+template = "Your code is {{ .Code }}"
+max_frequency = "5s"
+
+# Configure MFA via WebAuthn
+# [auth.mfa.web_authn]
+# enroll_enabled = true
+# verify_enabled = true
+
+# Use an external OAuth provider. The full list of providers are: `apple`, `azure`, `bitbucket`,
+# `discord`, `facebook`, `github`, `gitlab`, `google`, `keycloak`, `linkedin_oidc`, `notion`, `twitch`,
+# `twitter`, `x`, `slack`, `spotify`, `workos`, `zoom`.
+[auth.external.apple]
+enabled = false
+client_id = ""
+# DO NOT commit your OAuth provider secret to git. Use environment variable substitution instead:
+secret = "env(SUPABASE_AUTH_EXTERNAL_APPLE_SECRET)"
+# Overrides the default auth callback URL derived from auth.external_url.
+redirect_uri = ""
+# Overrides the default auth provider URL. Used to support self-hosted gitlab, single-tenant Azure,
+# or any other third-party OIDC providers.
+url = ""
+# If enabled, the nonce check will be skipped. Required for local sign in with Google auth.
+skip_nonce_check = false
+# If enabled, it will allow the user to successfully authenticate when the provider does not return an email address.
+email_optional = false
+
+# Allow Solana wallet holders to sign in to your project via the Sign in with Solana (SIWS, EIP-4361) standard.
+# You can configure "web3" rate limit in the [auth.rate_limit] section and set up [auth.captcha] if self-hosting.
+[auth.web3.solana]
+enabled = false
+
+# Use Firebase Auth as a third-party provider alongside Supabase Auth.
+[auth.third_party.firebase]
+enabled = false
+# project_id = "my-firebase-project"
+
+# Use Auth0 as a third-party provider alongside Supabase Auth.
+[auth.third_party.auth0]
+enabled = false
+# tenant = "my-auth0-tenant"
+# tenant_region = "us"
+
+# Use AWS Cognito (Amplify) as a third-party provider alongside Supabase Auth.
+[auth.third_party.aws_cognito]
+enabled = false
+# user_pool_id = "my-user-pool-id"
+# user_pool_region = "us-east-1"
+
+# Use Clerk as a third-party provider alongside Supabase Auth.
+[auth.third_party.clerk]
+enabled = false
+# Obtain from https://clerk.com/setup/supabase
+# domain = "example.clerk.accounts.dev"
+
+# OAuth server configuration
+[auth.oauth_server]
+# Enable OAuth server functionality
+enabled = false
+# Path for OAuth consent flow UI
+authorization_url_path = "/oauth/consent"
+# Allow dynamic client registration
+allow_dynamic_registration = false
+
+[functions.rivetkit]
+verify_jwt = false
+static_files = [
+	"./functions/rivetkit/rivetkit_wasm_bg.wasm",
+]
+
+[edge_runtime]
+enabled = true
+# Supported request policies: `oneshot`, `per_worker`.
+# `per_worker` (default) — enables hot reload during local development.
+# `oneshot` — fallback mode if hot reload causes issues (e.g. in large repos or with symlinks).
+policy = "per_worker"
+# Port to attach the Chrome inspector for debugging edge functions.
+inspector_port = 8083
+# The Deno major version to use.
+deno_version = 2
+
+# [edge_runtime.secrets]
+# secret_key = "env(SECRET_VALUE)"
+
+[analytics]
+enabled = true
+port = 54327
+# Configure one of the supported backends: `postgres`, `bigquery`.
+backend = "postgres"
+
+# Experimental features may be deprecated any time
+[experimental]
+# Configures Postgres storage engine to use OrioleDB (S3)
+orioledb_version = ""
+# Configures S3 bucket URL, eg. <bucket_name>.s3-<region>.amazonaws.com
+s3_host = "env(S3_HOST)"
+# Configures S3 bucket region, eg. us-east-1
+s3_region = "env(S3_REGION)"
+# Configures AWS_ACCESS_KEY_ID for S3 bucket
+s3_access_key = "env(S3_ACCESS_KEY)"
+# Configures AWS_SECRET_ACCESS_KEY for S3 bucket
+s3_secret_key = "env(S3_SECRET_KEY)"
+
+# [experimental.pgdelta]
+# When enabled, pg-delta becomes the active engine for supported schema flows.
+# enabled = false
+# Directory under `supabase/` where declarative files are written.
+# declarative_schema_path = "./database"
+# JSON string passed through to pg-delta SQL formatting.
+# format_options = "{\"keywordCase\":\"upper\",\"indent\":2,\"maxWidth\":80,\"commaStyle\":\"trailing\"}"
diff --git a/examples/kitchen-sink/supabase/functions/rivetkit/deno.json b/examples/kitchen-sink/supabase/functions/rivetkit/deno.json
new file mode 100644
index 0000000000..8f37a2dc6b
--- /dev/null
+++ b/examples/kitchen-sink/supabase/functions/rivetkit/deno.json
@@ -0,0 +1,30 @@
+{
+  "imports": {
+    "@rivet-dev/agent-os-core": "npm:@rivet-dev/agent-os-core@^0.1.1",
+    "@rivetkit/bare-ts": "npm:@rivetkit/bare-ts@^0.6.2",
+    "@rivetkit/bare-ts/": "npm:@rivetkit/bare-ts@^0.6.2/",
+    "@rivetkit/engine-envoy-protocol": "../../../../../engine/sdks/typescript/envoy-protocol/dist/index.js",
+    "@rivetkit/rivetkit-wasm": "../../../../../rivetkit-typescript/packages/rivetkit-wasm/pkg-deno/rivetkit_wasm.js",
+    "@rivetkit/virtual-websocket": "../../../../../shared/typescript/virtual-websocket/dist/mod.js",
+    "@rivetkit/workflow-engine": "../../../../../rivetkit-typescript/packages/workflow-engine/dist/tsup/index.js",
+    "cbor-x": "npm:cbor-x@^1.6.0",
+    "crypto": "node:crypto",
+    "drizzle-orm/": "npm:drizzle-orm@^0.44.2/",
+    "drizzle-orm/sqlite-core": "npm:drizzle-orm@^0.44.2/sqlite-core",
+    "drizzle-orm/sqlite-proxy": "npm:drizzle-orm@^0.44.2/sqlite-proxy",
+    "hono": "npm:hono@^4.11.3",
+    "hono/": "npm:hono@^4.11.3/",
+    "hono/ws": "npm:hono@^4.11.3/ws",
+    "invariant": "npm:invariant@^2.2.4",
+    "module": "node:module",
+    "p-retry": "npm:p-retry@^6.2.1",
+    "path/posix": "node:path/posix",
+    "pino": "npm:pino@^9.5.0",
+    "rivetkit": "../../../../../rivetkit-typescript/packages/rivetkit/dist/tsup/mod.js",
+    "rivetkit/db": "../../../../../rivetkit-typescript/packages/rivetkit/dist/tsup/db/mod.js",
+    "vbare": "npm:vbare@^0.0.4",
+    "zod": "npm:zod@^4.1.0",
+    "zod/": "npm:zod@^4.1.0/",
+    "zod/v4": "npm:zod@^4.1.0/v4"
+  }
+}
diff --git a/examples/kitchen-sink/supabase/functions/rivetkit/index.ts b/examples/kitchen-sink/supabase/functions/rivetkit/index.ts
new file mode 100644
index 0000000000..a3ffefd499
--- /dev/null
+++ b/examples/kitchen-sink/supabase/functions/rivetkit/index.ts
@@ -0,0 +1,75 @@
+import { Buffer } from "node:buffer";
+import * as rivetkitWasm from "../../../../../rivetkit-typescript/packages/rivetkit-wasm/pkg-deno/rivetkit_wasm.js";
+import "../../../../../rivetkit-typescript/packages/rivetkit/dist/tsup/db/mod.js";
+import { setup } from "rivetkit";
+import { counter } from "../../../src/actors/counter/counter.ts";
+import { rawHttpActor } from "../../../src/actors/http/raw-http.ts";
+import { rawWebSocketActor } from "../../../src/actors/http/raw-websocket.ts";
+import { testCounterSqlite } from "../../../src/actors/testing/test-counter-sqlite.ts";
+
+const wasmBytes = await Deno.readFile(
+	new URL("./rivetkit_wasm_bg.wasm", import.meta.url),
+);
+
+(
+	globalThis as typeof globalThis & {
+		Buffer?: typeof Buffer;
+		__rivetkitWasmBindings?: typeof rivetkitWasm;
+	}
+).Buffer ??= Buffer;
+
+(
+	globalThis as typeof globalThis & {
+		__rivetkitWasmBindings?: typeof rivetkitWasm;
+	}
+).__rivetkitWasmBindings = rivetkitWasm;
+
+const registry = setup({
+	runtime: "wasm",
+	wasm: {
+		initInput: wasmBytes,
+	},
+	test: {
+		enabled: true,
+		sqliteBackend: "remote",
+	},
+	noWelcome: true,
+	startEngine: false,
+	use: {
+		counter,
+		rawHttpActor,
+		rawWebSocketActor,
+		testCounterSqlite,
+	},
+});
+
+function matchesRivetPath(pathname: string) {
+	return pathname === "/api/rivet" || pathname.includes("/api/rivet/");
+}
+
+function normalizeRivetRequest(request: Request) {
+	const url = new URL(request.url);
+	const marker = "/api/rivet";
+	const markerIndex = url.pathname.indexOf(marker);
+	if (markerIndex > 0) {
+		url.pathname = url.pathname.slice(markerIndex);
+		return new Request(url, request);
+	}
+	return request;
+}
+
+async function handler(request: Request) {
+	const url = new URL(request.url);
+	if (url.pathname === "/health" || url.pathname.endsWith("/health")) {
+		return Response.json({ ok: true });
+	}
+	if (matchesRivetPath(url.pathname)) {
+		return registry.handler(normalizeRivetRequest(request));
+	}
+	return new Response("not found", { status: 404 });
+}
+
+const port = Number(Deno.env.get("PORT") ?? "8000");
+const hostname = Deno.env.get("HOST") ?? "127.0.0.1";
+
+Deno.serve({ hostname, port }, handler);
diff --git a/frontend/packages/icons/AGENTS.md b/frontend/packages/icons/AGENTS.md
new file mode 120000
index 0000000000..681311eb9c
--- /dev/null
+++ b/frontend/packages/icons/AGENTS.md
@@ -0,0 +1 @@
+CLAUDE.md
\ No newline at end of file
diff --git a/frontend/packages/shared-data/src/deploy.ts b/frontend/packages/shared-data/src/deploy.ts
index 775452dfa7..7389e2d843 100644
--- a/frontend/packages/shared-data/src/deploy.ts
+++ b/frontend/packages/shared-data/src/deploy.ts
@@ -1,6 +1,7 @@
 import {
 	faAws,
 	faCloudflare,
+	faFunction,
 	faGoogleCloud,
 	faHetznerH,
 	faKubernetes,
@@ -37,24 +38,41 @@ export const deployOptions = [
 		displayName: "Vercel",
 		name: "vercel" as const,
 		href: "/docs/connect/vercel",
-		description:
-			"Deploy Next.js + RivetKit apps to Vercel's edge network",
+		description: "Deploy Next.js + RivetKit apps to Vercel's edge network",
 		icon: faVercel as any,
 	},
+	{
+		displayName: "Cloudflare Workers",
+		shortTitle: "Cloudflare",
+		name: "cloudflare-workers" as const,
+		href: "/docs/connect/cloudflare",
+		description:
+			"Run RivetKit on Cloudflare Workers with the WebAssembly runtime",
+		icon: faCloudflare as any,
+		specializedPlatform: true,
+	},
+	{
+		displayName: "Supabase Functions",
+		shortTitle: "Supabase",
+		name: "supabase-functions" as const,
+		href: "/docs/connect/supabase",
+		description:
+			"Run RivetKit on Supabase Edge Functions with the WebAssembly runtime",
+		icon: faFunction as any,
+		specializedPlatform: true,
+	},
 	{
 		displayName: "Railway",
 		name: "railway" as const,
 		href: "/docs/connect/railway",
-		description:
-			"Deploy containers to Railway's managed infrastructure",
+		description: "Deploy containers to Railway's managed infrastructure",
 		icon: faRailway as any,
 	},
 	{
 		displayName: "Kubernetes",
 		name: "kubernetes" as const,
 		href: "/docs/connect/kubernetes",
-		description:
-			"Deploy to any Kubernetes cluster with container images",
+		description: "Deploy to any Kubernetes cluster with container images",
 		icon: faKubernetes as any,
 	},
 	{
@@ -71,16 +89,14 @@ export const deployOptions = [
 		shortTitle: "GCP",
 		name: "gcp-cloud-run" as const,
 		href: "/docs/connect/gcp-cloud-run",
-		description:
-			"Deploy containers to Google Cloud Run for auto-scaling",
+		description: "Deploy containers to Google Cloud Run for auto-scaling",
 		icon: faGoogleCloud,
 	},
 	{
 		displayName: "Hetzner",
 		name: "hetzner" as const,
 		href: "/docs/connect/hetzner",
-		description:
-			"Deploy to Hetzner's cost-effective cloud infrastructure",
+		description: "Deploy to Hetzner's cost-effective cloud infrastructure",
 		icon: faHetznerH as any,
 	},
 	{
@@ -102,4 +118,4 @@ export const deployOptions = [
 	},
 ] satisfies DeployOption[];
 
-export type Provider = typeof deployOptions[number]["name"];
+export type Provider = (typeof deployOptions)[number]["name"];
diff --git a/package.json b/package.json
index 67a01e495f..1f02924655 100644
--- a/package.json
+++ b/package.json
@@ -38,6 +38,7 @@
 		"@rivetkit/db": "workspace:*",
 		"@rivetkit/engine-api-full": "workspace:*",
 		"@rivetkit/rivetkit-napi": "workspace:*",
+		"@rivetkit/rivetkit-wasm": "workspace:*",
 		"@rivetkit/engine-cli": "workspace:*",
 		"@types/react": "^19",
 		"@types/react-dom": "^19"
@@ -56,4 +57,4 @@
 			"@codemirror/lint": "6.8.5"
 		}
 	}
-}
\ No newline at end of file
+}
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 24f6def67b..42b5d106ad 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -11,6 +11,7 @@ overrides:
   '@rivetkit/db': workspace:*
   '@rivetkit/engine-api-full': workspace:*
   '@rivetkit/rivetkit-napi': workspace:*
+  '@rivetkit/rivetkit-wasm': workspace:*
   '@rivetkit/engine-cli': workspace:*
   '@types/react': ^19
   '@types/react-dom': ^19
@@ -4271,6 +4272,9 @@ importers:
       '@rivetkit/rivetkit-napi':
         specifier: workspace:*
         version: link:../rivetkit-napi
+      '@rivetkit/rivetkit-wasm':
+        specifier: workspace:*
+        version: link:../rivetkit-wasm
       '@rivetkit/traces':
         specifier: workspace:*
         version: link:../traces
@@ -4366,6 +4370,12 @@ importers:
         specifier: workspace:*
         version: link:../../../engine/sdks/typescript/envoy-protocol
 
+  rivetkit-typescript/packages/rivetkit-wasm:
+    devDependencies:
+      typescript:
+        specifier: ^5.9.2
+        version: 5.9.3
+
   rivetkit-typescript/packages/sql-loader:
     devDependencies:
       '@types/node':
@@ -6984,6 +6994,7 @@ packages:
   '@hono/node-ws@1.3.0':
     resolution: {integrity: sha512-ju25YbbvLuXdqBCmLZLqnNYu1nbHIQjoyUqA8ApZOeL1k4skuiTcw5SW77/5SUYo2Xi2NVBJoVlfQurnKEp03Q==}
     engines: {node: '>=18.14.1'}
+    deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.
     peerDependencies:
       '@hono/node-server': ^1.19.2
       hono: ^4.6.0
@@ -17586,6 +17597,7 @@ packages:
 
   uuid@7.0.3:
     resolution: {integrity: sha512-DPSke0pXhTZgoF/d+WSt2QaKMCFSfx7QegxEWT+JOuHF5aWrKEn0G+ztjuJg/gG8/ItK+rbPCD/yNv8yyih6Cg==}
+    deprecated: uuid@10 and below is no longer supported.  For ESM codebases, update to uuid@latest.  For CommonJS codebases, use uuid@11 (but be aware this version will likely be deprecated in 2028).
     hasBin: true
 
   v8-compile-cache-lib@3.0.1:
@@ -25079,7 +25091,7 @@ snapshots:
 
   '@types/pg@8.16.0':
     dependencies:
-      '@types/node': 20.19.13
+      '@types/node': 22.19.15
       pg-protocol: 1.11.0
       pg-types: 2.2.0
 
diff --git a/rivetkit-rust/AGENTS.md b/rivetkit-rust/AGENTS.md
new file mode 120000
index 0000000000..681311eb9c
--- /dev/null
+++ b/rivetkit-rust/AGENTS.md
@@ -0,0 +1 @@
+CLAUDE.md
\ No newline at end of file
diff --git a/rivetkit-rust/CLAUDE.md b/rivetkit-rust/CLAUDE.md
new file mode 100644
index 0000000000..d1827e0402
--- /dev/null
+++ b/rivetkit-rust/CLAUDE.md
@@ -0,0 +1,9 @@
+# CLAUDE.md
+
+## RivetKit Runtime Boundary
+
+- Keep runtime-neutral byte boundaries as `Uint8Array`/`Vec<u8>` shaped data; Node `Buffer` conversion belongs only in TypeScript NAPI adapter code.
+- Keep SQL boundary types explicit and shared across native and wasm adapters; do not derive runtime API contracts from NAPI-only database wrappers.
+- Wasm SQLite is remote-only; do not add or imply local SQLite support for wasm builds.
+- Keep NAPI and wasm serverless registry lifecycle semantics aligned, including concurrent first-request build and shutdown-during-build behavior.
+- Runtime selection should use explicit runtime discriminators such as `runtime.kind`, not concrete adapter class identity.
diff --git a/rivetkit-rust/engine/artifacts/errors/sqlite.remote_execution_failed.json b/rivetkit-rust/engine/artifacts/errors/sqlite.remote_execution_failed.json
new file mode 100644
index 0000000000..2473dc6219
--- /dev/null
+++ b/rivetkit-rust/engine/artifacts/errors/sqlite.remote_execution_failed.json
@@ -0,0 +1,5 @@
+{
+  "code": "remote_execution_failed",
+  "group": "sqlite",
+  "message": "Remote SQLite execution failed."
+}
\ No newline at end of file
diff --git a/rivetkit-rust/engine/artifacts/errors/sqlite.remote_fence_mismatch.json b/rivetkit-rust/engine/artifacts/errors/sqlite.remote_fence_mismatch.json
new file mode 100644
index 0000000000..fea4f70edc
--- /dev/null
+++ b/rivetkit-rust/engine/artifacts/errors/sqlite.remote_fence_mismatch.json
@@ -0,0 +1,5 @@
+{
+  "code": "remote_fence_mismatch",
+  "group": "sqlite",
+  "message": "Remote SQLite generation is stale."
+}
\ No newline at end of file
diff --git a/rivetkit-rust/engine/artifacts/errors/sqlite.remote_indeterminate_result.json b/rivetkit-rust/engine/artifacts/errors/sqlite.remote_indeterminate_result.json
new file mode 100644
index 0000000000..62f53f8d55
--- /dev/null
+++ b/rivetkit-rust/engine/artifacts/errors/sqlite.remote_indeterminate_result.json
@@ -0,0 +1,5 @@
+{
+  "code": "remote_indeterminate_result",
+  "group": "sqlite",
+  "message": "Remote SQLite result is indeterminate."
+}
\ No newline at end of file
diff --git a/rivetkit-rust/engine/artifacts/errors/sqlite.remote_unavailable.json b/rivetkit-rust/engine/artifacts/errors/sqlite.remote_unavailable.json
new file mode 100644
index 0000000000..710a61505a
--- /dev/null
+++ b/rivetkit-rust/engine/artifacts/errors/sqlite.remote_unavailable.json
@@ -0,0 +1,5 @@
+{
+  "code": "remote_unavailable",
+  "group": "sqlite",
+  "message": "Remote SQLite is unavailable."
+}
\ No newline at end of file
diff --git a/rivetkit-rust/packages/rivetkit-core/AGENTS.md b/rivetkit-rust/packages/rivetkit-core/AGENTS.md
new file mode 120000
index 0000000000..681311eb9c
--- /dev/null
+++ b/rivetkit-rust/packages/rivetkit-core/AGENTS.md
@@ -0,0 +1 @@
+CLAUDE.md
\ No newline at end of file
diff --git a/rivetkit-rust/packages/rivetkit-core/Cargo.toml b/rivetkit-rust/packages/rivetkit-core/Cargo.toml
index e6b748c3b4..1f8904144c 100644
--- a/rivetkit-rust/packages/rivetkit-core/Cargo.toml
+++ b/rivetkit-rust/packages/rivetkit-core/Cargo.toml
@@ -8,8 +8,17 @@ workspace = "../../../"
 autotests = false
 
 [features]
-default = []
-sqlite = ["dep:rivetkit-sqlite"]
+default = ["native-runtime"]
+native-runtime = [
+	"dep:nix",
+	"dep:reqwest",
+	"dep:rivet-pools",
+	"rivet-envoy-client/native-transport",
+]
+wasm-runtime = ["rivet-envoy-client/wasm-transport"]
+sqlite = ["sqlite-local"]
+sqlite-local = ["native-runtime", "dep:rivetkit-sqlite"]
+sqlite-remote = []
 
 [dependencies]
 anyhow.workspace = true
@@ -17,19 +26,19 @@ base64.workspace = true
 ciborium.workspace = true
 futures.workspace = true
 http.workspace = true
-nix.workspace = true
+nix = { workspace = true, optional = true }
 parking_lot.workspace = true
 prometheus.workspace = true
 rand.workspace = true
-reqwest.workspace = true
-rivet-pools.workspace = true
-rivet-util.workspace = true
+reqwest = { workspace = true, optional = true }
+rivet-pools = { workspace = true, optional = true }
 rivet-error.workspace = true
-rivet-envoy-client.workspace = true
+rivet-envoy-client = { workspace = true, default-features = false }
 rivetkit-shared-types.workspace = true
 rivetkit-actor-persist.workspace = true
 rivetkit-client-protocol.workspace = true
 rivetkit-inspector-protocol.workspace = true
+rivetkit-sqlite-types.workspace = true
 rivetkit-sqlite = { workspace = true, optional = true }
 scc.workspace = true
 serde.workspace = true
@@ -37,15 +46,28 @@ serde_json.workspace = true
 serde_bare.workspace = true
 serde_bytes.workspace = true
 subtle.workspace = true
-tokio.workspace = true
 tokio-util.workspace = true
 tracing.workspace = true
-uuid.workspace = true
+url.workspace = true
 vbare.workspace = true
 
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+tokio.workspace = true
+uuid.workspace = true
+
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+getrandom = { version = "0.2", features = ["js"] }
+js-sys = "0.3"
+tokio = { version = "1.44.0", default-features = false, features = ["macros", "rt", "sync", "time"] }
+uuid = { version = "1.11.0", features = ["v4", "serde", "js"] }
+wasm-bindgen = "0.2"
+wasm-bindgen-futures = "0.4"
+web-time = "1.1"
+
 [dev-dependencies]
 portpicker.workspace = true
 tempfile.workspace = true
+tokio = { workspace = true, features = ["test-util"] }
 tracing-subscriber.workspace = true
 
 [[test]]
diff --git a/rivetkit-rust/packages/rivetkit-core/src/actor/config.rs b/rivetkit-rust/packages/rivetkit-core/src/actor/config.rs
index 71164de9a0..fac01c866f 100644
--- a/rivetkit-rust/packages/rivetkit-core/src/actor/config.rs
+++ b/rivetkit-rust/packages/rivetkit-core/src/actor/config.rs
@@ -61,6 +61,7 @@ pub struct ActorConfig {
 	/// Whether the user declared a SQLite database for this actor (`db({...})`
 	/// on the TS side). Gates the inspector database tab.
 	pub has_database: bool,
+	pub remote_sqlite: bool,
 	/// Whether the user declared actor state (`state: ...` or `createState`).
 	/// Gates the inspector state tab and state-subscription messages.
 	pub has_state: bool,
@@ -97,6 +98,7 @@ pub struct ActorConfigInput {
 	pub name: Option<String>,
 	pub icon: Option<String>,
 	pub has_database: Option<bool>,
+	pub remote_sqlite: Option<bool>,
 	pub has_state: Option<bool>,
 	pub can_hibernate_websocket: Option<bool>,
 	pub state_save_interval_ms: Option<u32>,
@@ -126,6 +128,7 @@ impl ActorConfig {
 			name: config.name,
 			icon: config.icon,
 			has_database: config.has_database.unwrap_or(false),
+			remote_sqlite: config.remote_sqlite.unwrap_or(false),
 			has_state: config.has_state.unwrap_or(false),
 			..Self::default()
 		};
@@ -210,6 +213,7 @@ impl Default for ActorConfig {
 			name: None,
 			icon: None,
 			has_database: false,
+			remote_sqlite: false,
 			has_state: false,
 			can_hibernate_websocket: CanHibernateWebSocket::default(),
 			state_save_interval: DEFAULT_STATE_SAVE_INTERVAL,
diff --git a/rivetkit-rust/packages/rivetkit-core/src/actor/connection.rs b/rivetkit-rust/packages/rivetkit-core/src/actor/connection.rs
index a8dee18161..617f25ed86 100644
--- a/rivetkit-rust/packages/rivetkit-core/src/actor/connection.rs
+++ b/rivetkit-rust/packages/rivetkit-core/src/actor/connection.rs
@@ -11,7 +11,6 @@ use parking_lot::{RwLock, RwLockReadGuard};
 use rivet_error::RivetError;
 use rivetkit_actor_persist::{generated::v4 as persist_v4, versioned as persist_versioned};
 use serde::Serialize;
-use tokio::time::timeout;
 use uuid::Uuid;
 
 use tokio::sync::oneshot;
@@ -27,6 +26,7 @@ use crate::actor::persist::{
 use crate::actor::preload::PreloadedKv;
 use crate::actor::state::RequestSaveOpts;
 use crate::error::ActorRuntime;
+use crate::time::timeout;
 use crate::types::ConnId;
 use crate::types::ListOpts;
 
diff --git a/rivetkit-rust/packages/rivetkit-core/src/actor/context.rs b/rivetkit-rust/packages/rivetkit-core/src/actor/context.rs
index aa042e1c19..f6bcdeab68 100644
--- a/rivetkit-rust/packages/rivetkit-core/src/actor/context.rs
+++ b/rivetkit-rust/packages/rivetkit-core/src/actor/context.rs
@@ -3,7 +3,9 @@ use std::future::Future;
 use std::sync::Weak;
 use std::sync::atomic::{AtomicBool, AtomicU32, AtomicU64, AtomicUsize, Ordering};
 use std::sync::{Arc, OnceLock};
-use std::time::{Duration, SystemTime, UNIX_EPOCH};
+use std::time::Duration;
+
+use crate::time::{Instant, SystemTime, UNIX_EPOCH};
 
 use anyhow::{Context as AnyhowContext, Result};
 use futures::future::BoxFuture;
@@ -14,7 +16,6 @@ use scc::HashMap as SccHashMap;
 use tokio::runtime::Handle;
 use tokio::sync::{Mutex as AsyncMutex, Notify, OnceCell, broadcast, mpsc, oneshot};
 use tokio::task::JoinHandle;
-use tokio::time::Instant;
 use tokio_util::sync::CancellationToken;
 
 use crate::ActorConfig;
@@ -31,10 +32,12 @@ use crate::actor::queue::{QueueInspectorUpdateCallback, QueueMetadata, QueueWait
 use crate::actor::schedule::{InternalKeepAwakeCallback, LocalAlarmCallback};
 use crate::actor::sleep::{CanSleep, SleepState};
 use crate::actor::state::{PendingSave, PersistedActor, RequestSaveOpts};
-use crate::actor::task::{
-	LIFECYCLE_EVENT_INBOX_CHANNEL, LifecycleEvent, actor_channel_overloaded_error,
-};
+#[cfg(not(target_arch = "wasm32"))]
+use crate::actor::task::{LIFECYCLE_EVENT_INBOX_CHANNEL, actor_channel_overloaded_error};
+use crate::actor::task::LifecycleEvent;
 use crate::actor::task_types::UserTaskKind;
+#[cfg(feature = "wasm-runtime")]
+use crate::actor::work_registry::CountGuard;
 use crate::actor::work_registry::RegionGuard;
 use crate::error::{ActorLifecycle as ActorLifecycleError, ActorRuntime};
 use crate::inspector::{Inspector, InspectorSnapshot};
@@ -69,8 +72,8 @@ pub(crate) struct ActorContextInner {
 	pub(super) save_requested: AtomicBool,
 	pub(super) save_requested_immediate: AtomicBool,
 	// Forced-sync: debounce bookkeeping is updated from sync save-request paths.
-	pub(super) save_requested_within_deadline: Mutex<Option<std::time::Instant>>,
-	pub(super) last_save_at: Mutex<Option<std::time::Instant>>,
+	pub(super) save_requested_within_deadline: Mutex<Option<crate::time::Instant>>,
+	pub(super) last_save_at: Mutex<Option<crate::time::Instant>>,
 	pub(super) pending_save: Mutex<Option<PendingSave>>,
 	pub(super) tracked_persist: Mutex<Option<JoinHandle<()>>>,
 	pub(super) save_guard: AsyncMutex<()>,
@@ -215,19 +218,21 @@ impl ActorContext {
 		)
 	}
 
-		pub(crate) fn build(
-			actor_id: String,
-			name: String,
-			key: ActorKey,
-			region: String,
-			config: ActorConfig,
-			kv: Kv,
-			mut sql: SqliteDb,
-		) -> Self {
-			let metrics = ActorMetrics::new(actor_id.clone(), name.clone());
-			#[cfg(feature = "sqlite")]
-			sql.set_vfs_metrics(Arc::new(metrics.clone()));
-			let diagnostics = ActorDiagnostics::new(actor_id.clone());
+	pub(crate) fn build(
+		actor_id: String,
+		name: String,
+		key: ActorKey,
+		region: String,
+		config: ActorConfig,
+		kv: Kv,
+		sql: SqliteDb,
+	) -> Self {
+		let metrics = ActorMetrics::new(actor_id.clone(), name.clone());
+		#[cfg(feature = "sqlite-local")]
+		let mut sql = sql;
+		#[cfg(feature = "sqlite-local")]
+		sql.set_vfs_metrics(Arc::new(metrics.clone()));
+		let diagnostics = ActorDiagnostics::new(actor_id.clone());
 		let lifecycle_event_inbox_capacity = config.lifecycle_event_inbox_capacity;
 		let state_save_interval = config.state_save_interval;
 		let abort_signal = CancellationToken::new();
@@ -445,11 +450,14 @@ impl ActorContext {
 			return Err(ActorLifecycleError::Stopping.build())
 				.context("destroy already requested for this generation");
 		}
-		// Reuse the shared teardown sequence used by the registry shutdown
-		// path so future changes to `mark_destroy_requested` cannot drift.
-		// `destroy_requested` is already true from the swap above; the redundant
+		// Reuse the shared teardown sequence used by the registry shutdown path
+		// so future changes to `mark_destroy_requested` cannot drift.
+		// `destroy_requested` is already true from the swap above. The redundant
 		// `store(true)` inside is harmless.
+		#[cfg(not(feature = "wasm-runtime"))]
 		self.mark_destroy_requested();
+		#[cfg(feature = "wasm-runtime")]
+		self.mark_destroy_requested_without_spawn();
 
 		let ctx = self.clone();
 		if Handle::try_current().is_ok() {
@@ -476,6 +484,14 @@ impl ActorContext {
 		self.0.abort_signal.cancel();
 	}
 
+	#[cfg(feature = "wasm-runtime")]
+	fn mark_destroy_requested_without_spawn(&self) {
+		self.cancel_sleep_timer();
+		self.0.destroy_requested.store(true, Ordering::SeqCst);
+		self.0.destroy_completed.store(false, Ordering::SeqCst);
+		self.0.abort_signal.cancel();
+	}
+
 	#[doc(hidden)]
 	pub fn cancel_abort_signal_for_sleep(&self) {
 		self.0.abort_signal.cancel();
@@ -516,6 +532,7 @@ impl ActorContext {
 		false
 	}
 
+	#[cfg(not(feature = "wasm-runtime"))]
 	pub fn wait_until(&self, future: impl Future<Output = ()> + Send + 'static) {
 		if Handle::try_current().is_err() {
 			tracing::warn!("skipping wait_until without a tokio runtime");
@@ -531,6 +548,23 @@ impl ActorContext {
 			let started_at = Instant::now();
 			future.await;
 			ctx.record_user_task_finished(UserTaskKind::WaitUntil, started_at.elapsed());
+			ctx.reset_sleep_timer();
+		});
+	}
+
+	#[cfg(feature = "wasm-runtime")]
+	pub fn wait_until(&self, future: impl Future<Output = ()> + 'static) {
+		let counter = self.0.sleep.work.shutdown_counter.clone();
+		counter.increment();
+		let guard = CountGuard::from_incremented(counter);
+		let ctx = self.clone();
+		wasm_bindgen_futures::spawn_local(async move {
+			let _guard = guard;
+			ctx.record_user_task_started(UserTaskKind::WaitUntil);
+			let started_at = Instant::now();
+			future.await;
+			ctx.record_user_task_finished(UserTaskKind::WaitUntil, started_at.elapsed());
+			ctx.reset_sleep_timer();
 		});
 	}
 
@@ -653,8 +687,12 @@ impl ActorContext {
 	/// so overdue scheduled work enters the normal actor event loop.
 	pub async fn drain_overdue_scheduled_events(&self) -> Result<()> {
 		for event in self.due_scheduled_events(now_timestamp_ms()) {
-			self.dispatch_scheduled_action(&event.event_id, event.action, event.args)
-				.await;
+			self.dispatch_scheduled_action(
+				&event.event_id,
+				event.action,
+				event.args.unwrap_or_default(),
+			)
+			.await;
 		}
 
 		self.sync_alarm_logged();
@@ -822,6 +860,34 @@ impl ActorContext {
 		Ok(conn)
 	}
 
+	pub(crate) async fn connect_conn_with_prepare<F, P>(
+		&self,
+		params: Vec<u8>,
+		is_hibernatable: bool,
+		hibernation: Option<HibernatableConnectionMetadata>,
+		request: Option<Request>,
+		create_state: F,
+		prepare_connection: P,
+	) -> Result<ConnHandle>
+	where
+		F: Future<Output = Result<Vec<u8>>> + Send,
+		P: FnOnce(&ConnHandle) -> Result<()>,
+	{
+		let conn = self
+			.connect_with_state_and_prepare(
+				params,
+				is_hibernatable,
+				hibernation,
+				request,
+				create_state,
+				prepare_connection,
+			)
+			.await?;
+		self.record_connections_updated();
+		self.reset_sleep_timer();
+		Ok(conn)
+	}
+
 	pub async fn connect_conn_with_request<F>(
 		&self,
 		params: Vec<u8>,
@@ -1184,6 +1250,10 @@ impl ActorContext {
 			return;
 		}
 
+		#[cfg(feature = "wasm-runtime")]
+		return;
+
+		#[cfg(not(feature = "wasm-runtime"))]
 		self.reset_sleep_timer_state();
 	}
 
@@ -1370,17 +1440,23 @@ impl ActorContext {
 	}
 
 	fn try_send_lifecycle_event(&self, event: LifecycleEvent, operation: &'static str) {
+		#[cfg(target_arch = "wasm32")]
+		let _ = operation;
+
 		let Some(sender) = self.0.lifecycle_events.read().clone() else {
 			return;
 		};
 
 		match sender.try_reserve() {
-			Ok(permit) => {
-				permit.send(event);
-			}
-			Err(_) => {
-				let _ = actor_channel_overloaded_error(
-					LIFECYCLE_EVENT_INBOX_CHANNEL,
+				Ok(permit) => {
+					permit.send(event);
+				}
+				#[cfg(target_arch = "wasm32")]
+				Err(_) => {}
+				#[cfg(not(target_arch = "wasm32"))]
+				Err(_) => {
+					let _ = actor_channel_overloaded_error(
+						LIFECYCLE_EVENT_INBOX_CHANNEL,
 					self.0.lifecycle_event_inbox_capacity,
 					operation,
 					Some(&self.0.metrics),
diff --git a/rivetkit-rust/packages/rivetkit-core/src/actor/diagnostics.rs b/rivetkit-rust/packages/rivetkit-core/src/actor/diagnostics.rs
index 37eed3402d..6fa37232cf 100644
--- a/rivetkit-rust/packages/rivetkit-core/src/actor/diagnostics.rs
+++ b/rivetkit-rust/packages/rivetkit-core/src/actor/diagnostics.rs
@@ -1,5 +1,7 @@
 use std::sync::{Arc, OnceLock};
-use std::time::{Duration, Instant};
+use std::time::Duration;
+
+use crate::time::Instant;
 
 use parking_lot::Mutex;
 use scc::HashMap as SccHashMap;
diff --git a/rivetkit-rust/packages/rivetkit-core/src/actor/factory.rs b/rivetkit-rust/packages/rivetkit-core/src/actor/factory.rs
index 299dbdb1aa..6c98cdf617 100644
--- a/rivetkit-rust/packages/rivetkit-core/src/actor/factory.rs
+++ b/rivetkit-rust/packages/rivetkit-core/src/actor/factory.rs
@@ -1,12 +1,16 @@
 use std::fmt;
 
 use anyhow::Result;
-use futures::future::BoxFuture;
 
+use crate::runtime::RuntimeBoxFuture;
 use crate::ActorConfig;
 use crate::actor::lifecycle_hooks::ActorStart;
 
-pub type ActorEntryFn = dyn Fn(ActorStart) -> BoxFuture<'static, Result<()>> + Send + Sync;
+#[cfg(feature = "wasm-runtime")]
+pub type ActorEntryFn = dyn Fn(ActorStart) -> RuntimeBoxFuture<Result<()>>;
+
+#[cfg(not(feature = "wasm-runtime"))]
+pub type ActorEntryFn = dyn Fn(ActorStart) -> RuntimeBoxFuture<Result<()>> + Send + Sync;
 
 /// Runtime extension point for building actor receive loops.
 pub struct ActorFactory {
@@ -15,10 +19,16 @@ pub struct ActorFactory {
 	manual_startup_ready: bool,
 }
 
+#[cfg(feature = "wasm-runtime")]
+unsafe impl Send for ActorFactory {}
+
+#[cfg(feature = "wasm-runtime")]
+unsafe impl Sync for ActorFactory {}
+
 impl ActorFactory {
 	pub fn new<F>(config: ActorConfig, entry: F) -> Self
 	where
-		F: Fn(ActorStart) -> BoxFuture<'static, Result<()>> + Send + Sync + 'static,
+		F: ActorEntry,
 	{
 		Self {
 			config,
@@ -31,7 +41,7 @@ impl ActorFactory {
 	/// after its own startup preamble finishes.
 	pub fn new_with_manual_startup_ready<F>(config: ActorConfig, entry: F) -> Self
 	where
-		F: Fn(ActorStart) -> BoxFuture<'static, Result<()>> + Send + Sync + 'static,
+		F: ActorEntry,
 	{
 		Self {
 			config,
@@ -53,6 +63,24 @@ impl ActorFactory {
 	}
 }
 
+#[cfg(feature = "wasm-runtime")]
+pub trait ActorEntry: Fn(ActorStart) -> RuntimeBoxFuture<Result<()>> + 'static {}
+
+#[cfg(feature = "wasm-runtime")]
+impl<F> ActorEntry for F where F: Fn(ActorStart) -> RuntimeBoxFuture<Result<()>> + 'static {}
+
+#[cfg(not(feature = "wasm-runtime"))]
+pub trait ActorEntry:
+	Fn(ActorStart) -> RuntimeBoxFuture<Result<()>> + Send + Sync + 'static
+{
+}
+
+#[cfg(not(feature = "wasm-runtime"))]
+impl<F> ActorEntry for F where
+	F: Fn(ActorStart) -> RuntimeBoxFuture<Result<()>> + Send + Sync + 'static
+{
+}
+
 impl fmt::Debug for ActorFactory {
 	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 		f.debug_struct("ActorFactory")
diff --git a/rivetkit-rust/packages/rivetkit-core/src/actor/kv.rs b/rivetkit-rust/packages/rivetkit-core/src/actor/kv.rs
index 5c7d39f479..c89de11fc3 100644
--- a/rivetkit-rust/packages/rivetkit-core/src/actor/kv.rs
+++ b/rivetkit-rust/packages/rivetkit-core/src/actor/kv.rs
@@ -1,6 +1,8 @@
 use std::collections::BTreeMap;
 use std::sync::Arc;
-use std::time::{Duration, Instant};
+use std::time::Duration;
+
+use crate::time::Instant;
 
 #[cfg(test)]
 use std::sync::atomic::{AtomicUsize, Ordering};
diff --git a/rivetkit-rust/packages/rivetkit-core/src/actor/metrics.rs b/rivetkit-rust/packages/rivetkit-core/src/actor/metrics.rs
index 180664f438..93d2d0440b 100644
--- a/rivetkit-rust/packages/rivetkit-core/src/actor/metrics.rs
+++ b/rivetkit-rust/packages/rivetkit-core/src/actor/metrics.rs
@@ -38,53 +38,53 @@ struct ActorMetricsInner {
 	shutdown_timeout_total: CounterVec,
 	state_mutation_total: CounterVec,
 	direct_subsystem_shutdown_warning_total: CounterVec,
-	#[cfg(feature = "sqlite")]
+	#[cfg(feature = "sqlite-local")]
 	sqlite_vfs_resolve_pages_total: IntCounter,
-	#[cfg(feature = "sqlite")]
+	#[cfg(feature = "sqlite-local")]
 	sqlite_vfs_resolve_pages_requested_total: IntCounter,
-	#[cfg(feature = "sqlite")]
+	#[cfg(feature = "sqlite-local")]
 	sqlite_vfs_resolve_pages_cache_hits_total: IntCounter,
-	#[cfg(feature = "sqlite")]
+	#[cfg(feature = "sqlite-local")]
 	sqlite_vfs_resolve_pages_cache_misses_total: IntCounter,
-	#[cfg(feature = "sqlite")]
+	#[cfg(feature = "sqlite-local")]
 	sqlite_vfs_get_pages_total: IntCounter,
-	#[cfg(feature = "sqlite")]
+	#[cfg(feature = "sqlite-local")]
 	sqlite_vfs_pages_fetched_total: IntCounter,
-	#[cfg(feature = "sqlite")]
+	#[cfg(feature = "sqlite-local")]
 	sqlite_vfs_prefetch_pages_total: IntCounter,
-	#[cfg(feature = "sqlite")]
+	#[cfg(feature = "sqlite-local")]
 	sqlite_vfs_bytes_fetched_total: IntCounter,
-	#[cfg(feature = "sqlite")]
+	#[cfg(feature = "sqlite-local")]
 	sqlite_vfs_prefetch_bytes_total: IntCounter,
-	#[cfg(feature = "sqlite")]
+	#[cfg(feature = "sqlite-local")]
 	sqlite_vfs_get_pages_duration_seconds: Histogram,
-	#[cfg(feature = "sqlite")]
+	#[cfg(feature = "sqlite-local")]
 	sqlite_vfs_commit_total: IntCounter,
-	#[cfg(feature = "sqlite")]
+	#[cfg(feature = "sqlite-local")]
 	sqlite_vfs_commit_phase_duration_seconds_total: CounterVec,
-	#[cfg(feature = "sqlite")]
+	#[cfg(feature = "sqlite-local")]
 	sqlite_vfs_commit_duration_seconds_total: CounterVec,
-	#[cfg(feature = "sqlite")]
+	#[cfg(feature = "sqlite-local")]
 	sqlite_read_pool_active_readers: IntGauge,
-	#[cfg(feature = "sqlite")]
+	#[cfg(feature = "sqlite-local")]
 	sqlite_read_pool_idle_readers: IntGauge,
-	#[cfg(feature = "sqlite")]
+	#[cfg(feature = "sqlite-local")]
 	sqlite_read_pool_read_wait_duration_seconds: Histogram,
-	#[cfg(feature = "sqlite")]
+	#[cfg(feature = "sqlite-local")]
 	sqlite_read_pool_write_wait_duration_seconds: Histogram,
-	#[cfg(feature = "sqlite")]
+	#[cfg(feature = "sqlite-local")]
 	sqlite_read_pool_routed_read_queries_total: IntCounter,
-	#[cfg(feature = "sqlite")]
+	#[cfg(feature = "sqlite-local")]
 	sqlite_read_pool_write_fallback_queries_total: IntCounter,
-	#[cfg(feature = "sqlite")]
+	#[cfg(feature = "sqlite-local")]
 	sqlite_read_pool_manual_transaction_duration_seconds: Histogram,
-	#[cfg(feature = "sqlite")]
+	#[cfg(feature = "sqlite-local")]
 	sqlite_read_pool_reader_opens_total: IntCounter,
-	#[cfg(feature = "sqlite")]
+	#[cfg(feature = "sqlite-local")]
 	sqlite_read_pool_reader_closes_total: IntCounter,
-	#[cfg(feature = "sqlite")]
+	#[cfg(feature = "sqlite-local")]
 	sqlite_read_pool_rejected_reader_mutations_total: IntCounter,
-	#[cfg(feature = "sqlite")]
+	#[cfg(feature = "sqlite-local")]
 	sqlite_read_pool_mode_transitions_total: CounterVec,
 }
 
@@ -234,61 +234,61 @@ impl ActorMetrics {
 			&["subsystem", "operation"],
 		)
 		.context("create direct_subsystem_shutdown_warning_total counter")?;
-		#[cfg(feature = "sqlite")]
+		#[cfg(feature = "sqlite-local")]
 		let sqlite_vfs_resolve_pages_total = IntCounter::with_opts(Opts::new(
 			"sqlite_vfs_resolve_pages_total",
 			"total VFS page resolution attempts",
 		))
 		.context("create sqlite_vfs_resolve_pages_total counter")?;
-		#[cfg(feature = "sqlite")]
+		#[cfg(feature = "sqlite-local")]
 		let sqlite_vfs_resolve_pages_requested_total = IntCounter::with_opts(Opts::new(
 			"sqlite_vfs_resolve_pages_requested_total",
 			"total pages requested by VFS page resolution attempts",
 		))
 		.context("create sqlite_vfs_resolve_pages_requested_total counter")?;
-		#[cfg(feature = "sqlite")]
+		#[cfg(feature = "sqlite-local")]
 		let sqlite_vfs_resolve_pages_cache_hits_total = IntCounter::with_opts(Opts::new(
 			"sqlite_vfs_resolve_pages_cache_hits_total",
 			"total pages resolved from the VFS page cache or write buffer",
 		))
 		.context("create sqlite_vfs_resolve_pages_cache_hits_total counter")?;
-		#[cfg(feature = "sqlite")]
+		#[cfg(feature = "sqlite-local")]
 		let sqlite_vfs_resolve_pages_cache_misses_total = IntCounter::with_opts(Opts::new(
 			"sqlite_vfs_resolve_pages_cache_misses_total",
 			"total pages missing from the VFS page cache and write buffer",
 		))
 		.context("create sqlite_vfs_resolve_pages_cache_misses_total counter")?;
-		#[cfg(feature = "sqlite")]
+		#[cfg(feature = "sqlite-local")]
 		let sqlite_vfs_get_pages_total = IntCounter::with_opts(Opts::new(
 			"sqlite_vfs_get_pages_total",
 			"total VFS to engine get_pages requests",
 		))
 		.context("create sqlite_vfs_get_pages_total counter")?;
-		#[cfg(feature = "sqlite")]
+		#[cfg(feature = "sqlite-local")]
 		let sqlite_vfs_pages_fetched_total = IntCounter::with_opts(Opts::new(
 			"sqlite_vfs_pages_fetched_total",
 			"total pages requested from the engine by VFS get_pages calls",
 		))
 		.context("create sqlite_vfs_pages_fetched_total counter")?;
-		#[cfg(feature = "sqlite")]
+		#[cfg(feature = "sqlite-local")]
 		let sqlite_vfs_prefetch_pages_total = IntCounter::with_opts(Opts::new(
 			"sqlite_vfs_prefetch_pages_total",
 			"total pages requested speculatively by VFS prefetch",
 		))
 		.context("create sqlite_vfs_prefetch_pages_total counter")?;
-		#[cfg(feature = "sqlite")]
+		#[cfg(feature = "sqlite-local")]
 		let sqlite_vfs_bytes_fetched_total = IntCounter::with_opts(Opts::new(
 			"sqlite_vfs_bytes_fetched_total",
 			"total bytes requested from the engine by VFS get_pages calls",
 		))
 		.context("create sqlite_vfs_bytes_fetched_total counter")?;
-		#[cfg(feature = "sqlite")]
+		#[cfg(feature = "sqlite-local")]
 		let sqlite_vfs_prefetch_bytes_total = IntCounter::with_opts(Opts::new(
 			"sqlite_vfs_prefetch_bytes_total",
 			"total bytes requested speculatively by VFS prefetch",
 		))
 		.context("create sqlite_vfs_prefetch_bytes_total counter")?;
-		#[cfg(feature = "sqlite")]
+		#[cfg(feature = "sqlite-local")]
 		let sqlite_vfs_get_pages_duration_seconds = Histogram::with_opts(
 			HistogramOpts::new(
 				"sqlite_vfs_get_pages_duration_seconds",
@@ -299,13 +299,13 @@ impl ActorMetrics {
 			]),
 		)
 		.context("create sqlite_vfs_get_pages_duration_seconds histogram")?;
-		#[cfg(feature = "sqlite")]
+		#[cfg(feature = "sqlite-local")]
 		let sqlite_vfs_commit_total = IntCounter::with_opts(Opts::new(
 			"sqlite_vfs_commit_total",
 			"total successful VFS commits",
 		))
 		.context("create sqlite_vfs_commit_total counter")?;
-		#[cfg(feature = "sqlite")]
+		#[cfg(feature = "sqlite-local")]
 		let sqlite_vfs_commit_phase_duration_seconds_total = CounterVec::new(
 			Opts::new(
 				"sqlite_vfs_commit_phase_duration_seconds_total",
@@ -314,7 +314,7 @@ impl ActorMetrics {
 			&["phase"],
 		)
 		.context("create sqlite_vfs_commit_phase_duration_seconds_total counter")?;
-		#[cfg(feature = "sqlite")]
+		#[cfg(feature = "sqlite-local")]
 		let sqlite_vfs_commit_duration_seconds_total = CounterVec::new(
 			Opts::new(
 				"sqlite_vfs_commit_duration_seconds_total",
@@ -323,19 +323,19 @@ impl ActorMetrics {
 			&["phase"],
 		)
 		.context("create sqlite_vfs_commit_duration_seconds_total counter")?;
-		#[cfg(feature = "sqlite")]
+		#[cfg(feature = "sqlite-local")]
 		let sqlite_read_pool_active_readers = IntGauge::with_opts(Opts::new(
 			"sqlite_read_pool_active_readers",
 			"current active SQLite read-pool readers",
 		))
 		.context("create sqlite_read_pool_active_readers gauge")?;
-		#[cfg(feature = "sqlite")]
+		#[cfg(feature = "sqlite-local")]
 		let sqlite_read_pool_idle_readers = IntGauge::with_opts(Opts::new(
 			"sqlite_read_pool_idle_readers",
 			"current idle SQLite read-pool readers",
 		))
 		.context("create sqlite_read_pool_idle_readers gauge")?;
-		#[cfg(feature = "sqlite")]
+		#[cfg(feature = "sqlite-local")]
 		let sqlite_read_pool_read_wait_duration_seconds = Histogram::with_opts(
 			HistogramOpts::new(
 				"sqlite_read_pool_read_wait_duration_seconds",
@@ -344,7 +344,7 @@ impl ActorMetrics {
 			.buckets(sqlite_pool_wait_buckets()),
 		)
 		.context("create sqlite_read_pool_read_wait_duration_seconds histogram")?;
-		#[cfg(feature = "sqlite")]
+		#[cfg(feature = "sqlite-local")]
 		let sqlite_read_pool_write_wait_duration_seconds = Histogram::with_opts(
 			HistogramOpts::new(
 				"sqlite_read_pool_write_wait_duration_seconds",
@@ -353,19 +353,19 @@ impl ActorMetrics {
 			.buckets(sqlite_pool_wait_buckets()),
 		)
 		.context("create sqlite_read_pool_write_wait_duration_seconds histogram")?;
-		#[cfg(feature = "sqlite")]
+		#[cfg(feature = "sqlite-local")]
 		let sqlite_read_pool_routed_read_queries_total = IntCounter::with_opts(Opts::new(
 			"sqlite_read_pool_routed_read_queries_total",
 			"total SQLite statements routed to read-pool readers",
 		))
 		.context("create sqlite_read_pool_routed_read_queries_total counter")?;
-		#[cfg(feature = "sqlite")]
+		#[cfg(feature = "sqlite-local")]
 		let sqlite_read_pool_write_fallback_queries_total = IntCounter::with_opts(Opts::new(
 			"sqlite_read_pool_write_fallback_queries_total",
 			"total SQLite statements routed to write mode as read-pool fallbacks",
 		))
 		.context("create sqlite_read_pool_write_fallback_queries_total counter")?;
-		#[cfg(feature = "sqlite")]
+		#[cfg(feature = "sqlite-local")]
 		let sqlite_read_pool_manual_transaction_duration_seconds = Histogram::with_opts(
 			HistogramOpts::new(
 				"sqlite_read_pool_manual_transaction_duration_seconds",
@@ -374,25 +374,25 @@ impl ActorMetrics {
 			.buckets(sqlite_pool_wait_buckets()),
 		)
 		.context("create sqlite_read_pool_manual_transaction_duration_seconds histogram")?;
-		#[cfg(feature = "sqlite")]
+		#[cfg(feature = "sqlite-local")]
 		let sqlite_read_pool_reader_opens_total = IntCounter::with_opts(Opts::new(
 			"sqlite_read_pool_reader_opens_total",
 			"total SQLite read-pool reader connection opens",
 		))
 		.context("create sqlite_read_pool_reader_opens_total counter")?;
-		#[cfg(feature = "sqlite")]
+		#[cfg(feature = "sqlite-local")]
 		let sqlite_read_pool_reader_closes_total = IntCounter::with_opts(Opts::new(
 			"sqlite_read_pool_reader_closes_total",
 			"total SQLite read-pool reader connection closes",
 		))
 		.context("create sqlite_read_pool_reader_closes_total counter")?;
-		#[cfg(feature = "sqlite")]
+		#[cfg(feature = "sqlite-local")]
 		let sqlite_read_pool_rejected_reader_mutations_total = IntCounter::with_opts(Opts::new(
 			"sqlite_read_pool_rejected_reader_mutations_total",
 			"total SQLite reader mutation attempts rejected by read-pool safeguards",
 		))
 		.context("create sqlite_read_pool_rejected_reader_mutations_total counter")?;
-		#[cfg(feature = "sqlite")]
+		#[cfg(feature = "sqlite-local")]
 		let sqlite_read_pool_mode_transitions_total = CounterVec::new(
 			Opts::new(
 				"sqlite_read_pool_mode_transitions_total",
@@ -421,7 +421,7 @@ impl ActorMetrics {
 		register_metric(&registry, shutdown_timeout_total.clone());
 		register_metric(&registry, state_mutation_total.clone());
 		register_metric(&registry, direct_subsystem_shutdown_warning_total.clone());
-		#[cfg(feature = "sqlite")]
+		#[cfg(feature = "sqlite-local")]
 		{
 			register_metric(&registry, sqlite_vfs_resolve_pages_total.clone());
 			register_metric(&registry, sqlite_vfs_resolve_pages_requested_total.clone());
@@ -477,7 +477,7 @@ impl ActorMetrics {
 			shutdown_wait_seconds.with_label_values(&[reason.as_metric_label()]);
 			shutdown_timeout_total.with_label_values(&[reason.as_metric_label()]);
 		}
-		#[cfg(feature = "sqlite")]
+		#[cfg(feature = "sqlite-local")]
 		{
 			for phase in ["request_build", "serialize", "transport", "state_update"] {
 				sqlite_vfs_commit_phase_duration_seconds_total.with_label_values(&[phase]);
@@ -517,53 +517,53 @@ impl ActorMetrics {
 			shutdown_timeout_total,
 			state_mutation_total,
 			direct_subsystem_shutdown_warning_total,
-			#[cfg(feature = "sqlite")]
+			#[cfg(feature = "sqlite-local")]
 			sqlite_vfs_resolve_pages_total,
-			#[cfg(feature = "sqlite")]
+			#[cfg(feature = "sqlite-local")]
 			sqlite_vfs_resolve_pages_requested_total,
-			#[cfg(feature = "sqlite")]
+			#[cfg(feature = "sqlite-local")]
 			sqlite_vfs_resolve_pages_cache_hits_total,
-			#[cfg(feature = "sqlite")]
+			#[cfg(feature = "sqlite-local")]
 			sqlite_vfs_resolve_pages_cache_misses_total,
-			#[cfg(feature = "sqlite")]
+			#[cfg(feature = "sqlite-local")]
 			sqlite_vfs_get_pages_total,
-			#[cfg(feature = "sqlite")]
+			#[cfg(feature = "sqlite-local")]
 			sqlite_vfs_pages_fetched_total,
-			#[cfg(feature = "sqlite")]
+			#[cfg(feature = "sqlite-local")]
 			sqlite_vfs_prefetch_pages_total,
-			#[cfg(feature = "sqlite")]
+			#[cfg(feature = "sqlite-local")]
 			sqlite_vfs_bytes_fetched_total,
-			#[cfg(feature = "sqlite")]
+			#[cfg(feature = "sqlite-local")]
 			sqlite_vfs_prefetch_bytes_total,
-			#[cfg(feature = "sqlite")]
+			#[cfg(feature = "sqlite-local")]
 			sqlite_vfs_get_pages_duration_seconds,
-			#[cfg(feature = "sqlite")]
+			#[cfg(feature = "sqlite-local")]
 			sqlite_vfs_commit_total,
-			#[cfg(feature = "sqlite")]
+			#[cfg(feature = "sqlite-local")]
 			sqlite_vfs_commit_phase_duration_seconds_total,
-			#[cfg(feature = "sqlite")]
+			#[cfg(feature = "sqlite-local")]
 			sqlite_vfs_commit_duration_seconds_total,
-			#[cfg(feature = "sqlite")]
+			#[cfg(feature = "sqlite-local")]
 			sqlite_read_pool_active_readers,
-			#[cfg(feature = "sqlite")]
+			#[cfg(feature = "sqlite-local")]
 			sqlite_read_pool_idle_readers,
-			#[cfg(feature = "sqlite")]
+			#[cfg(feature = "sqlite-local")]
 			sqlite_read_pool_read_wait_duration_seconds,
-			#[cfg(feature = "sqlite")]
+			#[cfg(feature = "sqlite-local")]
 			sqlite_read_pool_write_wait_duration_seconds,
-			#[cfg(feature = "sqlite")]
+			#[cfg(feature = "sqlite-local")]
 			sqlite_read_pool_routed_read_queries_total,
-			#[cfg(feature = "sqlite")]
+			#[cfg(feature = "sqlite-local")]
 			sqlite_read_pool_write_fallback_queries_total,
-			#[cfg(feature = "sqlite")]
+			#[cfg(feature = "sqlite-local")]
 			sqlite_read_pool_manual_transaction_duration_seconds,
-			#[cfg(feature = "sqlite")]
+			#[cfg(feature = "sqlite-local")]
 			sqlite_read_pool_reader_opens_total,
-			#[cfg(feature = "sqlite")]
+			#[cfg(feature = "sqlite-local")]
 			sqlite_read_pool_reader_closes_total,
-			#[cfg(feature = "sqlite")]
+			#[cfg(feature = "sqlite-local")]
 			sqlite_read_pool_rejected_reader_mutations_total,
-			#[cfg(feature = "sqlite")]
+			#[cfg(feature = "sqlite-local")]
 			sqlite_read_pool_mode_transitions_total,
 		})
 	}
@@ -761,7 +761,7 @@ impl ActorMetrics {
 	}
 }
 
-#[cfg(feature = "sqlite")]
+#[cfg(feature = "sqlite-local")]
 impl rivetkit_sqlite::vfs::SqliteVfsMetrics for ActorMetrics {
 	fn record_resolve_pages(&self, requested_pages: u64) {
 		let Some(inner) = self.inner.as_ref().as_ref() else {
@@ -957,12 +957,12 @@ fn duration_ms(duration: Duration) -> f64 {
 	duration.as_secs_f64() * 1000.0
 }
 
-#[cfg(feature = "sqlite")]
+#[cfg(feature = "sqlite-local")]
 fn ns_to_seconds(duration_ns: u64) -> f64 {
 	Duration::from_nanos(duration_ns).as_secs_f64()
 }
 
-#[cfg(feature = "sqlite")]
+#[cfg(feature = "sqlite-local")]
 fn sqlite_pool_wait_buckets() -> Vec<f64> {
 	vec![
 		0.000_1, 0.000_5, 0.001, 0.0025, 0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5,
diff --git a/rivetkit-rust/packages/rivetkit-core/src/actor/mod.rs b/rivetkit-rust/packages/rivetkit-core/src/actor/mod.rs
index bdb909f007..feceed14c5 100644
--- a/rivetkit-rust/packages/rivetkit-core/src/actor/mod.rs
+++ b/rivetkit-rust/packages/rivetkit-core/src/actor/mod.rs
@@ -4,6 +4,7 @@ pub mod connection;
 pub mod context;
 pub(crate) mod diagnostics;
 pub mod factory;
+pub(crate) mod keys;
 pub mod kv;
 pub mod lifecycle_hooks;
 pub mod messages;
@@ -33,6 +34,7 @@ pub use queue::{
 };
 pub use sqlite::{
 	BindParam, ColumnValue, ExecResult, ExecuteResult, ExecuteRoute, QueryResult, SqliteDb,
+	SqliteBackend,
 };
 pub use state::RequestSaveOpts;
 pub use task::{
diff --git a/rivetkit-rust/packages/rivetkit-core/src/actor/queue.rs b/rivetkit-rust/packages/rivetkit-core/src/actor/queue.rs
index 5cb04618ae..47b7d83559 100644
--- a/rivetkit-rust/packages/rivetkit-core/src/actor/queue.rs
+++ b/rivetkit-rust/packages/rivetkit-core/src/actor/queue.rs
@@ -3,12 +3,15 @@ use std::fmt;
 use std::future::pending;
 use std::sync::Arc;
 use std::sync::atomic::Ordering;
-use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
+use std::time::Duration;
+
+use crate::time::{Instant, SystemTime, UNIX_EPOCH, sleep};
 
 use anyhow::{Context, Result};
 use rivet_error::RivetError;
 use rivetkit_actor_persist::{generated::v4 as persist_v4, versioned as persist_versioned};
 use serde::{Deserialize, Serialize};
+#[cfg(not(target_arch = "wasm32"))]
 use tokio::runtime::{Builder, Handle};
 use tokio::sync::oneshot;
 use tokio_util::sync::CancellationToken;
@@ -23,6 +26,8 @@ use crate::actor::persist::{
 };
 use crate::actor::preload::PreloadedKv;
 use crate::actor::task_types::UserTaskKind;
+#[cfg(target_arch = "wasm32")]
+use crate::error::ActorRuntime;
 use crate::types::ListOpts;
 
 #[derive(Clone, Debug, Default)]
@@ -847,7 +852,7 @@ impl ActorContext {
 					_ = notified => WaitOutcome::Notified,
 					_ = actor_aborted => WaitOutcome::Aborted,
 					_ = external_aborted => WaitOutcome::Aborted,
-					_ = tokio::time::sleep(timeout) => WaitOutcome::TimedOut,
+					_ = sleep(timeout) => WaitOutcome::TimedOut,
 				}
 			}
 			None => {
@@ -887,7 +892,7 @@ impl ActorContext {
 				tokio::select! {
 					response = &mut receiver => CompletionWaitOutcome::Response(response),
 					_ = external_aborted => CompletionWaitOutcome::Aborted,
-					_ = tokio::time::sleep(timeout) => CompletionWaitOutcome::TimedOut,
+					_ = sleep(timeout) => CompletionWaitOutcome::TimedOut,
 				}
 			}
 			None => {
@@ -911,14 +916,27 @@ impl ActorContext {
 	}
 
 	fn block_on<T>(&self, future: impl std::future::Future<Output = Result<T>>) -> Result<T> {
-		if let Ok(handle) = Handle::try_current() {
-			tokio::task::block_in_place(|| handle.block_on(future))
-		} else {
-			Builder::new_current_thread()
-				.enable_all()
-				.build()
-				.context("build temporary runtime for queue operation")?
-				.block_on(future)
+		#[cfg(not(target_arch = "wasm32"))]
+		{
+			if let Ok(handle) = Handle::try_current() {
+				tokio::task::block_in_place(|| handle.block_on(future))
+			} else {
+				Builder::new_current_thread()
+					.enable_all()
+					.build()
+					.context("build temporary runtime for queue operation")?
+					.block_on(future)
+			}
+		}
+
+		#[cfg(target_arch = "wasm32")]
+		{
+			drop(future);
+			Err(ActorRuntime::InvalidOperation {
+				operation: "queue.try_next_batch".to_owned(),
+				reason: "synchronous queue receive requires native runtime support".to_owned(),
+			}
+			.build())
 		}
 	}
 
diff --git a/rivetkit-rust/packages/rivetkit-core/src/actor/schedule.rs b/rivetkit-rust/packages/rivetkit-core/src/actor/schedule.rs
index b68e059a2f..f3d1d4f840 100644
--- a/rivetkit-rust/packages/rivetkit-core/src/actor/schedule.rs
+++ b/rivetkit-rust/packages/rivetkit-core/src/actor/schedule.rs
@@ -1,6 +1,8 @@
 use std::sync::Arc;
 use std::sync::atomic::Ordering;
-use std::time::{Duration, SystemTime, UNIX_EPOCH};
+use std::time::Duration;
+
+use crate::time::{SystemTime, UNIX_EPOCH, sleep};
 
 use anyhow::Result;
 use futures::future::BoxFuture;
@@ -13,6 +15,8 @@ use uuid::Uuid;
 use crate::actor::context::ActorContext;
 use crate::actor::state::PersistedScheduleEvent;
 use crate::error::ActorRuntime;
+#[cfg(feature = "wasm-runtime")]
+use crate::runtime::RuntimeSpawner;
 
 pub(super) type InternalKeepAwakeCallback =
 	Arc<dyn Fn(BoxFuture<'static, Result<()>>) -> BoxFuture<'static, Result<()>> + Send + Sync>;
@@ -345,8 +349,10 @@ impl ActorContext {
 			return;
 		}
 
-		let Ok(tokio_handle) = Handle::try_current() else {
-			return;
+		#[cfg(not(feature = "wasm-runtime"))]
+		let tokio_handle = match Handle::try_current() {
+			Ok(handle) => handle,
+			Err(_) => return,
 		};
 
 		let delay_ms = next_alarm.saturating_sub(now_timestamp_ms()).max(0) as u64;
@@ -361,9 +367,8 @@ impl ActorContext {
 		);
 		// Intentionally detached but abortable: the handle is stored in
 		// `local_alarm_task` and cancelled when alarms are resynced or stopped.
-		let handle = tokio_handle.spawn(
-			async move {
-				tokio::time::sleep(Duration::from_millis(delay_ms)).await;
+		let task = async move {
+				sleep(Duration::from_millis(delay_ms)).await;
 				if schedule.0.schedule_local_alarm_epoch.load(Ordering::SeqCst) != local_alarm_epoch
 				{
 					return;
@@ -378,8 +383,13 @@ impl ActorContext {
 				};
 				callback().await;
 			}
-			.in_current_span(),
-		);
+			.in_current_span();
+
+		#[cfg(not(feature = "wasm-runtime"))]
+		let handle = tokio_handle.spawn(task);
+
+		#[cfg(feature = "wasm-runtime")]
+		let handle = RuntimeSpawner::spawn(task);
 
 		*self.0.schedule_local_alarm_task.lock() = Some(handle);
 	}
diff --git a/rivetkit-rust/packages/rivetkit-core/src/actor/sleep.rs b/rivetkit-rust/packages/rivetkit-core/src/actor/sleep.rs
index 0988b7d43a..5bb9b2f90b 100644
--- a/rivetkit-rust/packages/rivetkit-core/src/actor/sleep.rs
+++ b/rivetkit-rust/packages/rivetkit-core/src/actor/sleep.rs
@@ -1,22 +1,25 @@
 use parking_lot::Mutex;
+use rivet_envoy_client::async_counter::AsyncCounter;
 use rivet_envoy_client::handle::EnvoyHandle;
-use rivet_util::async_counter::AsyncCounter;
 use std::future::Future;
 use std::sync::Arc;
 #[cfg(test)]
 use std::sync::atomic::AtomicUsize as TestAtomicUsize;
 use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
+#[cfg(not(feature = "wasm-runtime"))]
 use tokio::runtime::Handle;
 use tokio::sync::Notify;
 use tokio::task::JoinHandle;
-#[cfg(test)]
-use tokio::time::sleep_until;
-use tokio::time::{Instant, sleep};
 use tracing::Instrument;
 
 use crate::actor::config::ActorConfig;
 use crate::actor::context::ActorContext;
 use crate::actor::work_registry::{CountGuard, RegionGuard, WorkRegistry};
+#[cfg(feature = "wasm-runtime")]
+use crate::runtime::RuntimeSpawner;
+use crate::time::{Instant, sleep};
+#[cfg(test)]
+use crate::time::sleep_until;
 #[cfg(test)]
 use crate::types::ActorKey;
 
@@ -267,6 +270,7 @@ impl ActorContext {
 	pub(crate) fn reset_sleep_timer_state(&self) {
 		self.cancel_sleep_timer();
 
+		#[cfg(not(feature = "wasm-runtime"))]
 		let Ok(runtime) = Handle::try_current() else {
 			tracing::debug!(
 				actor_id = %self.actor_id(),
@@ -282,7 +286,7 @@ impl ActorContext {
 		);
 
 		let ctx = self.clone();
-		let task = runtime.spawn(async move {
+		let task_body = async move {
 			let can_sleep = ctx.can_sleep().await;
 			if can_sleep != CanSleep::Yes {
 				tracing::debug!(
@@ -317,7 +321,13 @@ impl ActorContext {
 					"sleep idle timer elapsed but actor stayed awake"
 				);
 			}
-		});
+		};
+
+		#[cfg(not(feature = "wasm-runtime"))]
+		let task = runtime.spawn(task_body);
+
+		#[cfg(feature = "wasm-runtime")]
+		let task = RuntimeSpawner::spawn(task_body);
 
 		*self.0.sleep.sleep_timer.lock() = Some(task);
 	}
@@ -441,6 +451,7 @@ impl ActorContext {
 		self.0.sleep.work.websocket_callback.load()
 	}
 
+	#[cfg(not(feature = "wasm-runtime"))]
 	pub(crate) fn track_shutdown_task<F>(&self, fut: F) -> bool
 	where
 		F: Future<Output = ()> + Send + 'static,
@@ -458,10 +469,36 @@ impl ActorContext {
 		let counter = self.0.sleep.work.shutdown_counter.clone();
 		counter.increment();
 		let guard = CountGuard::from_incremented(counter);
+		let ctx = self.clone();
 		shutdown_tasks.spawn(
 			async move {
 				let _guard = guard;
 				fut.await;
+				ctx.reset_sleep_timer();
+			}
+			.in_current_span(),
+		);
+		true
+	}
+
+	#[cfg(feature = "wasm-runtime")]
+	pub(crate) fn track_shutdown_task<F>(&self, fut: F) -> bool
+	where
+		F: Future<Output = ()> + 'static,
+	{
+		if self.0.sleep.work.teardown_started.load(Ordering::Acquire) {
+			tracing::warn!("shutdown task spawned after teardown; aborting immediately");
+			return false;
+		}
+		let counter = self.0.sleep.work.shutdown_counter.clone();
+		counter.increment();
+		let guard = CountGuard::from_incremented(counter);
+		let ctx = self.clone();
+		wasm_bindgen_futures::spawn_local(
+			async move {
+				let _guard = guard;
+				fut.await;
+				ctx.reset_sleep_timer();
 			}
 			.in_current_span(),
 		);
diff --git a/rivetkit-rust/packages/rivetkit-core/src/actor/sqlite.rs b/rivetkit-rust/packages/rivetkit-core/src/actor/sqlite.rs
index ea4a47ae78..840a99c6c0 100644
--- a/rivetkit-rust/packages/rivetkit-core/src/actor/sqlite.rs
+++ b/rivetkit-rust/packages/rivetkit-core/src/actor/sqlite.rs
@@ -1,122 +1,97 @@
 use std::collections::HashSet;
 use std::io::Cursor;
-#[cfg(feature = "sqlite")]
+#[cfg(feature = "sqlite-local")]
 use std::sync::Arc;
-#[cfg(feature = "sqlite")]
+#[cfg(feature = "sqlite-local")]
 use std::time::Duration;
 
 use anyhow::{Context, Result};
-#[cfg(feature = "sqlite")]
+#[cfg(feature = "sqlite-local")]
 use parking_lot::Mutex;
-use rivet_envoy_client::handle::EnvoyHandle;
 use rivet_envoy_client::protocol;
+use rivet_envoy_client::{
+	handle::EnvoyHandle, utils::RemoteSqliteIndeterminateResultError,
+};
+pub use rivetkit_sqlite_types::{
+	BindParam, ColumnValue, ExecResult, ExecuteResult, ExecuteRoute, QueryResult,
+};
 use serde::Serialize;
 use serde_json::{Map as JsonMap, Value as JsonValue};
-#[cfg(feature = "sqlite")]
-use tokio::task::JoinHandle;
-#[cfg(feature = "sqlite")]
+#[cfg(feature = "sqlite-local")]
 use tokio::sync::Mutex as AsyncMutex;
-#[cfg(feature = "sqlite")]
+#[cfg(feature = "sqlite-local")]
+use tokio::task::JoinHandle;
+#[cfg(feature = "sqlite-local")]
 use tokio::time::{interval, timeout};
-#[cfg(feature = "sqlite")]
+#[cfg(feature = "sqlite-local")]
 use tracing::Instrument;
 
 use crate::error::SqliteRuntimeError;
 
-#[cfg(feature = "sqlite")]
-pub use rivetkit_sqlite::query::{
-	BindParam, ColumnValue, ExecResult, ExecuteResult, ExecuteRoute, QueryResult,
-};
-#[cfg(feature = "sqlite")]
+#[cfg(feature = "sqlite-local")]
 use rivetkit_sqlite::{
 	database::{NativeDatabaseHandle, open_database_from_envoy},
 	optimization_flags::sqlite_optimization_flags,
-	vfs::{SqliteVfsMetrics, VfsPreloadHintSnapshot},
+	vfs::{SqliteVfsMetrics, SqliteVfsMetricsSnapshot, VfsPreloadHintSnapshot},
 };
 
-#[cfg(feature = "sqlite")]
-const PRELOAD_HINT_FLUSH_INTERVAL: Duration = Duration::from_secs(30);
-#[cfg(feature = "sqlite")]
-const PRELOAD_HINT_FLUSH_TIMEOUT: Duration = Duration::from_secs(5);
-
-#[cfg(not(feature = "sqlite"))]
-#[derive(Clone, Debug, PartialEq)]
-pub enum BindParam {
-	Null,
-	Integer(i64),
-	Float(f64),
-	Text(String),
-	Blob(Vec<u8>),
-}
-
-#[cfg(not(feature = "sqlite"))]
-#[derive(Clone, Debug, PartialEq)]
-pub struct ExecResult {
-	pub changes: i64,
-}
-
-#[cfg(not(feature = "sqlite"))]
-#[derive(Clone, Debug, PartialEq)]
-pub struct QueryResult {
-	pub columns: Vec<String>,
-	pub rows: Vec<Vec<ColumnValue>>,
-}
-
-#[cfg(not(feature = "sqlite"))]
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum ExecuteRoute {
-	Read,
-	Write,
-	WriteFallback,
+#[cfg(not(feature = "sqlite-local"))]
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub struct SqliteVfsMetricsSnapshot {
+	pub request_build_ns: u64,
+	pub serialize_ns: u64,
+	pub transport_ns: u64,
+	pub state_update_ns: u64,
+	pub total_ns: u64,
+	pub commit_count: u64,
 }
 
-#[cfg(not(feature = "sqlite"))]
-#[derive(Clone, Debug, PartialEq)]
-pub struct ExecuteResult {
-	pub columns: Vec<String>,
-	pub rows: Vec<Vec<ColumnValue>>,
-	pub changes: i64,
-	pub last_insert_row_id: Option<i64>,
-	pub route: ExecuteRoute,
-}
-
-#[cfg(not(feature = "sqlite"))]
-#[derive(Clone, Debug, PartialEq)]
-pub enum ColumnValue {
-	Null,
-	Integer(i64),
-	Float(f64),
-	Text(String),
-	Blob(Vec<u8>),
-}
+#[cfg(feature = "sqlite-local")]
+const PRELOAD_HINT_FLUSH_INTERVAL: Duration = Duration::from_secs(30);
+#[cfg(feature = "sqlite-local")]
+const PRELOAD_HINT_FLUSH_TIMEOUT: Duration = Duration::from_secs(5);
 
 #[derive(Clone)]
 pub struct SqliteRuntimeConfig {
 	pub handle: EnvoyHandle,
 	pub actor_id: String,
-	pub startup_data: Option<protocol::SqliteStartupData>,
+	pub generation: Option<u64>,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum SqliteBackend {
+	LocalNative,
+	RemoteEnvoy,
+	Unavailable,
+}
+
+impl Default for SqliteBackend {
+	fn default() -> Self {
+		Self::Unavailable
+	}
 }
 
 #[derive(Clone, Default)]
 pub struct SqliteDb {
 	handle: Option<EnvoyHandle>,
 	actor_id: Option<String>,
-	startup_data: Option<protocol::SqliteStartupData>,
+	generation: Option<u64>,
+	backend: SqliteBackend,
 	/// Mirrors the user's actor-config `db({...})` declaration. The envoy
 	/// always sets up sqlite storage under the hood, so handle/actor_id are
 	/// not a reliable signal for whether the user opted in; this flag is.
 	enabled: bool,
-	#[cfg(feature = "sqlite")]
-	// Forced-sync: native SQLite handles are read from synchronous diagnostic
-	// accessors and closed from cleanup paths.
+	#[cfg(feature = "sqlite-local")]
+	// Forced-sync: native SQLite handles are used inside spawn_blocking and
+	// synchronous diagnostic accessors.
 	db: Arc<Mutex<Option<NativeDatabaseHandle>>>,
-	#[cfg(feature = "sqlite")]
+	#[cfg(feature = "sqlite-local")]
 	open_lock: Arc<AsyncMutex<()>>,
-	#[cfg(feature = "sqlite")]
+	#[cfg(feature = "sqlite-local")]
 	// Forced-sync: the background task is spawned and aborted from sync cleanup
 	// paths around the native database handle.
 	preload_hint_flush_task: Arc<Mutex<Option<JoinHandle<()>>>>,
-	#[cfg(feature = "sqlite")]
+	#[cfg(feature = "sqlite-local")]
 	vfs_metrics: Option<Arc<dyn SqliteVfsMetrics>>,
 }
 
@@ -124,26 +99,36 @@ impl SqliteDb {
 	pub fn new(
 		handle: EnvoyHandle,
 		actor_id: impl Into<String>,
-		startup_data: Option<protocol::SqliteStartupData>,
 		enabled: bool,
+	) -> Self {
+		Self::new_with_remote_sqlite(handle, actor_id, None, enabled, false)
+	}
+
+	pub fn new_with_remote_sqlite(
+		handle: EnvoyHandle,
+		actor_id: impl Into<String>,
+		generation: Option<u64>,
+		enabled: bool,
+		remote_sqlite: bool,
 	) -> Self {
 		Self {
 			handle: Some(handle),
 			actor_id: Some(actor_id.into()),
-			startup_data,
+			generation,
+			backend: select_sqlite_backend(enabled, remote_sqlite),
 			enabled,
-			#[cfg(feature = "sqlite")]
+			#[cfg(feature = "sqlite-local")]
 			db: Default::default(),
-			#[cfg(feature = "sqlite")]
+			#[cfg(feature = "sqlite-local")]
 			open_lock: Default::default(),
-			#[cfg(feature = "sqlite")]
+			#[cfg(feature = "sqlite-local")]
 			preload_hint_flush_task: Default::default(),
-			#[cfg(feature = "sqlite")]
+			#[cfg(feature = "sqlite-local")]
 			vfs_metrics: None,
 		}
 	}
 
-	#[cfg(feature = "sqlite")]
+	#[cfg(feature = "sqlite-local")]
 	pub(crate) fn set_vfs_metrics(&mut self, metrics: Arc<dyn SqliteVfsMetrics>) {
 		self.vfs_metrics = Some(metrics);
 	}
@@ -152,6 +137,10 @@ impl SqliteDb {
 		self.enabled
 	}
 
+	pub fn backend(&self) -> SqliteBackend {
+		self.backend
+	}
+
 	pub async fn get_pages(
 		&self,
 		request: protocol::SqliteGetPagesRequest,
@@ -166,78 +155,130 @@ impl SqliteDb {
 		self.handle()?.sqlite_commit(request).await
 	}
 
-	pub async fn commit_stage_begin(
-		&self,
-		request: protocol::SqliteCommitStageBeginRequest,
-	) -> Result<protocol::SqliteCommitStageBeginResponse> {
-		self.handle()?.sqlite_commit_stage_begin(request).await
+	pub async fn open(&self) -> Result<()> {
+		match self.backend {
+			SqliteBackend::LocalNative => {
+				#[cfg(feature = "sqlite-local")]
+				{
+					let _open_guard = self.open_lock.lock().await;
+					if self.db.lock().is_some() {
+						return Ok(());
+					}
+
+					let config = self.runtime_config()?;
+					let vfs_metrics = self.vfs_metrics.clone();
+					let rt_handle = tokio::runtime::Handle::try_current()
+						.context("open sqlite database requires a tokio runtime")?;
+
+					let native_db = open_database_from_envoy(
+						config.handle,
+						config.actor_id,
+						config
+							.generation
+							.ok_or_else(|| sqlite_not_configured("generation"))?,
+						rt_handle,
+						vfs_metrics,
+					)
+					.await?;
+					*self.db.lock() = Some(native_db);
+					self.ensure_preload_hint_flush_task()?;
+					Ok(())
+				}
+
+				#[cfg(not(feature = "sqlite-local"))]
+				{
+					Err(SqliteRuntimeError::Unavailable.build())
+				}
+			}
+			SqliteBackend::RemoteEnvoy => {
+				self.remote_config()?;
+				Ok(())
+			}
+			SqliteBackend::Unavailable => Err(SqliteRuntimeError::Unavailable.build()),
+		}
+	}
+
+	#[cfg(feature = "sqlite-local")]
+	async fn local_exec(&self, sql: String) -> Result<QueryResult> {
+		self.open().await?;
+		self.native_db_handle()?.exec(sql).await
+	}
+
+	#[cfg(not(feature = "sqlite-local"))]
+	async fn local_exec(&self, _sql: String) -> Result<QueryResult> {
+		Err(SqliteRuntimeError::Unavailable.build())
 	}
 
-	pub async fn commit_stage(
+	#[cfg(feature = "sqlite-local")]
+	async fn local_query(&self, sql: String, params: Option<Vec<BindParam>>) -> Result<QueryResult> {
+		self.open().await?;
+		self.native_db_handle()?.query(sql, params).await
+	}
+
+	#[cfg(not(feature = "sqlite-local"))]
+	async fn local_query(
 		&self,
-		request: protocol::SqliteCommitStageRequest,
-	) -> Result<protocol::SqliteCommitStageResponse> {
-		self.handle()?.sqlite_commit_stage(request).await
+		_sql: String,
+		_params: Option<Vec<BindParam>>,
+	) -> Result<QueryResult> {
+		Err(SqliteRuntimeError::Unavailable.build())
 	}
 
-	pub fn commit_stage_fire_and_forget(
+	#[cfg(feature = "sqlite-local")]
+	async fn local_run(&self, sql: String, params: Option<Vec<BindParam>>) -> Result<ExecResult> {
+		self.open().await?;
+		self.native_db_handle()?.run(sql, params).await
+	}
+
+	#[cfg(not(feature = "sqlite-local"))]
+	async fn local_run(&self, _sql: String, _params: Option<Vec<BindParam>>) -> Result<ExecResult> {
+		Err(SqliteRuntimeError::Unavailable.build())
+	}
+
+	#[cfg(feature = "sqlite-local")]
+	async fn local_execute(
 		&self,
-		request: protocol::SqliteCommitStageRequest,
-	) -> Result<()> {
-		self.handle()?.sqlite_commit_stage_fire_and_forget(request)
+		sql: String,
+		params: Option<Vec<BindParam>>,
+	) -> Result<ExecuteResult> {
+		self.open().await?;
+		self.native_db_handle()?.execute(sql, params).await
 	}
 
-	pub async fn commit_finalize(
+	#[cfg(not(feature = "sqlite-local"))]
+	async fn local_execute(
 		&self,
-		request: protocol::SqliteCommitFinalizeRequest,
-	) -> Result<protocol::SqliteCommitFinalizeResponse> {
-		self.handle()?.sqlite_commit_finalize(request).await
+		_sql: String,
+		_params: Option<Vec<BindParam>>,
+	) -> Result<ExecuteResult> {
+		Err(SqliteRuntimeError::Unavailable.build())
 	}
 
-	pub async fn open(&self) -> Result<()> {
-		#[cfg(feature = "sqlite")]
-		{
-			let _open_guard = self.open_lock.lock().await;
-			if self.db.lock().is_some() {
-				return Ok(());
-			}
+	#[cfg(feature = "sqlite-local")]
+	async fn local_execute_write(
+		&self,
+		sql: String,
+		params: Option<Vec<BindParam>>,
+	) -> Result<ExecuteResult> {
+		self.open().await?;
+		self.native_db_handle()?.execute_write(sql, params).await
+	}
 
-			let config = self.runtime_config()?;
-			let vfs_metrics = self.vfs_metrics.clone();
-			let rt_handle = tokio::runtime::Handle::try_current()
-				.context("open sqlite database requires a tokio runtime")?;
-
-			let native_db = open_database_from_envoy(
-				config.handle,
-				config.actor_id,
-				config.startup_data,
-				rt_handle,
-				vfs_metrics,
-			)
-			.await?;
-			*self.db.lock() = Some(native_db);
-			self.ensure_preload_hint_flush_task()?;
-			Ok(())
-		}
-
-		#[cfg(not(feature = "sqlite"))]
-		{
-			Err(SqliteRuntimeError::Unavailable.build())
-		}
+	#[cfg(not(feature = "sqlite-local"))]
+	async fn local_execute_write(
+		&self,
+		_sql: String,
+		_params: Option<Vec<BindParam>>,
+	) -> Result<ExecuteResult> {
+		Err(SqliteRuntimeError::Unavailable.build())
 	}
 
 	pub async fn exec(&self, sql: impl Into<String>) -> Result<QueryResult> {
-		#[cfg(feature = "sqlite")]
-		{
-			self.open().await?;
-			let sql = sql.into();
-			self.native_db_handle()?.exec(sql).await
-		}
-
-		#[cfg(not(feature = "sqlite"))]
-		{
-			let _ = sql;
-			Err(SqliteRuntimeError::Unavailable.build())
+		let sql = sql.into();
+		match self.backend {
+			SqliteBackend::LocalNative => self.local_exec(sql).await,
+			SqliteBackend::RemoteEnvoy => self.remote_exec(sql).await,
+			SqliteBackend::Unavailable => Err(SqliteRuntimeError::Unavailable.build()),
 		}
 	}
 
@@ -246,17 +287,13 @@ impl SqliteDb {
 		sql: impl Into<String>,
 		params: Option<Vec<BindParam>>,
 	) -> Result<QueryResult> {
-		#[cfg(feature = "sqlite")]
-		{
-			self.open().await?;
-			let sql = sql.into();
-			self.native_db_handle()?.query(sql, params).await
-		}
-
-		#[cfg(not(feature = "sqlite"))]
-		{
-			let _ = (sql, params);
-			Err(SqliteRuntimeError::Unavailable.build())
+		let sql = sql.into();
+		match self.backend {
+			SqliteBackend::LocalNative => self.local_query(sql, params).await,
+			SqliteBackend::RemoteEnvoy => {
+				Ok(self.remote_execute(sql, params).await?.into_query_result())
+			}
+			SqliteBackend::Unavailable => Err(SqliteRuntimeError::Unavailable.build()),
 		}
 	}
 
@@ -265,17 +302,13 @@ impl SqliteDb {
 		sql: impl Into<String>,
 		params: Option<Vec<BindParam>>,
 	) -> Result<ExecResult> {
-		#[cfg(feature = "sqlite")]
-		{
-			self.open().await?;
-			let sql = sql.into();
-			self.native_db_handle()?.run(sql, params).await
-		}
-
-		#[cfg(not(feature = "sqlite"))]
-		{
-			let _ = (sql, params);
-			Err(SqliteRuntimeError::Unavailable.build())
+		let sql = sql.into();
+		match self.backend {
+			SqliteBackend::LocalNative => self.local_run(sql, params).await,
+			SqliteBackend::RemoteEnvoy => {
+				Ok(self.remote_execute(sql, params).await?.into_exec_result())
+			}
+			SqliteBackend::Unavailable => Err(SqliteRuntimeError::Unavailable.build()),
 		}
 	}
 
@@ -284,17 +317,11 @@ impl SqliteDb {
 		sql: impl Into<String>,
 		params: Option<Vec<BindParam>>,
 	) -> Result<ExecuteResult> {
-		#[cfg(feature = "sqlite")]
-		{
-			self.open().await?;
-			let sql = sql.into();
-			self.native_db_handle()?.execute(sql, params).await
-		}
-
-		#[cfg(not(feature = "sqlite"))]
-		{
-			let _ = (sql, params);
-			Err(SqliteRuntimeError::Unavailable.build())
+		let sql = sql.into();
+		match self.backend {
+			SqliteBackend::LocalNative => self.local_execute(sql, params).await,
+			SqliteBackend::RemoteEnvoy => self.remote_execute(sql, params).await,
+			SqliteBackend::Unavailable => Err(SqliteRuntimeError::Unavailable.build()),
 		}
 	}
 
@@ -303,39 +330,33 @@ impl SqliteDb {
 		sql: impl Into<String>,
 		params: Option<Vec<BindParam>>,
 	) -> Result<ExecuteResult> {
-		#[cfg(feature = "sqlite")]
-		{
-			self.open().await?;
-			let sql = sql.into();
-			self.native_db_handle()?.execute_write(sql, params).await
-		}
-
-		#[cfg(not(feature = "sqlite"))]
-		{
-			let _ = (sql, params);
-			Err(SqliteRuntimeError::Unavailable.build())
+		let sql = sql.into();
+		match self.backend {
+			SqliteBackend::LocalNative => self.local_execute_write(sql, params).await,
+			SqliteBackend::RemoteEnvoy => self.remote_execute_write(sql, params).await,
+			SqliteBackend::Unavailable => Err(SqliteRuntimeError::Unavailable.build()),
 		}
 	}
 
 	pub async fn close(&self) -> Result<()> {
-		#[cfg(feature = "sqlite")]
-		{
-			self.stop_preload_hint_flush_task();
-			let native_db = self.db.lock().take();
-			if let Some(native_db) = native_db {
-				native_db.close().await?;
+		match self.backend {
+			SqliteBackend::LocalNative => {
+				#[cfg(feature = "sqlite-local")]
+				{
+					self.stop_preload_hint_flush_task();
+					let native_db = self.db.lock().take();
+					if let Some(native_db) = native_db {
+						native_db.close().await?;
+					}
+				}
+				Ok(())
 			}
-			Ok(())
-		}
-
-		#[cfg(not(feature = "sqlite"))]
-		{
-			Ok(())
+			SqliteBackend::RemoteEnvoy | SqliteBackend::Unavailable => Ok(()),
 		}
 	}
 
 	pub(crate) async fn cleanup(&self) -> Result<()> {
-		#[cfg(feature = "sqlite")]
+		#[cfg(feature = "sqlite-local")]
 		{
 			self.stop_preload_hint_flush_task();
 			self.flush_preload_hints_before_close().await;
@@ -343,14 +364,14 @@ impl SqliteDb {
 		self.close().await
 	}
 
-	#[cfg(feature = "sqlite")]
+	#[cfg(feature = "sqlite-local")]
 	fn ensure_preload_hint_flush_task(&self) -> Result<()> {
 		if !sqlite_optimization_flags().preload_hint_flush {
 			return Ok(());
 		}
 
 		let config = self.runtime_config()?;
-		let Some(generation) = config.startup_data.as_ref().map(|data| data.generation) else {
+		let Some(generation) = config.generation else {
 			return Ok(());
 		};
 		if self.db.lock().is_none() {
@@ -386,14 +407,14 @@ impl SqliteDb {
 		Ok(())
 	}
 
-	#[cfg(feature = "sqlite")]
+	#[cfg(feature = "sqlite-local")]
 	fn stop_preload_hint_flush_task(&self) {
 		if let Some(task) = self.preload_hint_flush_task.lock().take() {
 			task.abort();
 		}
 	}
 
-	#[cfg(feature = "sqlite")]
+	#[cfg(feature = "sqlite-local")]
 	async fn flush_preload_hints_before_close(&self) {
 		if !sqlite_optimization_flags().preload_hint_flush {
 			return;
@@ -402,7 +423,7 @@ impl SqliteDb {
 		let Ok(config) = self.runtime_config() else {
 			return;
 		};
-		let Some(generation) = config.startup_data.as_ref().map(|data| data.generation) else {
+		let Some(generation) = config.generation else {
 			return;
 		};
 
@@ -416,21 +437,24 @@ impl SqliteDb {
 	}
 
 	pub fn take_last_kv_error(&self) -> Option<String> {
-		#[cfg(feature = "sqlite")]
+		if self.backend != SqliteBackend::LocalNative {
+			return None;
+		}
+
+		#[cfg(feature = "sqlite-local")]
 		{
-			self.db
+			return self
+				.db
 				.lock()
 				.as_ref()
-				.and_then(NativeDatabaseHandle::take_last_kv_error)
+				.and_then(NativeDatabaseHandle::take_last_kv_error);
 		}
 
-		#[cfg(not(feature = "sqlite"))]
-		{
-			None
-		}
+		#[cfg(not(feature = "sqlite-local"))]
+		None
 	}
 
-	#[cfg(feature = "sqlite")]
+	#[cfg(feature = "sqlite-local")]
 	fn native_db_handle(&self) -> Result<NativeDatabaseHandle> {
 		self.db
 			.lock()
@@ -439,6 +463,21 @@ impl SqliteDb {
 			.ok_or_else(|| SqliteRuntimeError::Closed.build())
 	}
 
+	pub fn metrics(&self) -> Option<SqliteVfsMetricsSnapshot> {
+		#[cfg(feature = "sqlite-local")]
+		{
+			self.db
+				.lock()
+				.as_ref()
+				.map(NativeDatabaseHandle::sqlite_vfs_metrics)
+		}
+
+		#[cfg(not(feature = "sqlite-local"))]
+		{
+			None
+		}
+	}
+
 	pub fn runtime_config(&self) -> Result<SqliteRuntimeConfig> {
 		Ok(SqliteRuntimeConfig {
 			handle: self.handle()?,
@@ -446,10 +485,102 @@ impl SqliteDb {
 				.actor_id
 				.clone()
 				.ok_or_else(|| sqlite_not_configured("actor id"))?,
-			startup_data: self.startup_data.clone(),
+			generation: self.generation,
 		})
 	}
 
+	fn remote_config(&self) -> Result<RemoteSqliteConfig> {
+		let config = self.runtime_config()?;
+		let generation = config
+			.generation
+			.ok_or_else(|| sqlite_not_configured("generation"))?;
+		Ok(RemoteSqliteConfig {
+			namespace_id: config.handle.namespace().to_owned(),
+			handle: config.handle,
+			actor_id: config.actor_id,
+			generation,
+		})
+	}
+
+	async fn remote_exec(&self, sql: String) -> Result<QueryResult> {
+		let config = self.remote_config()?;
+		let response = config
+			.handle
+			.remote_sqlite_exec(protocol::SqliteExecRequest {
+				namespace_id: config.namespace_id,
+				actor_id: config.actor_id,
+				generation: config.generation,
+				sql,
+			})
+			.await
+			.map_err(remote_request_error)?;
+
+			match response {
+				protocol::SqliteExecResponse::SqliteExecOk(ok) => {
+					Ok(query_result_from_protocol(ok.result))
+				}
+				protocol::SqliteExecResponse::SqliteErrorResponse(error) => {
+					Err(remote_sqlite_error_response(error.message))
+				}
+		}
+	}
+
+	async fn remote_execute(
+		&self,
+		sql: String,
+		params: Option<Vec<BindParam>>,
+	) -> Result<ExecuteResult> {
+		let config = self.remote_config()?;
+		let response = config
+			.handle
+			.remote_sqlite_execute(protocol::SqliteExecuteRequest {
+				namespace_id: config.namespace_id,
+				actor_id: config.actor_id,
+				generation: config.generation,
+				sql,
+				params: params.map(protocol_bind_params),
+			})
+			.await
+			.map_err(remote_request_error)?;
+
+			match response {
+				protocol::SqliteExecuteResponse::SqliteExecuteOk(ok) => {
+					Ok(execute_result_from_protocol(ok.result))
+				}
+				protocol::SqliteExecuteResponse::SqliteErrorResponse(error) => {
+					Err(remote_sqlite_error_response(error.message))
+				}
+		}
+	}
+
+	async fn remote_execute_write(
+		&self,
+		sql: String,
+		params: Option<Vec<BindParam>>,
+	) -> Result<ExecuteResult> {
+		let config = self.remote_config()?;
+		let response = config
+			.handle
+			.remote_sqlite_execute_write(protocol::SqliteExecuteWriteRequest {
+				namespace_id: config.namespace_id,
+				actor_id: config.actor_id,
+				generation: config.generation,
+				sql,
+				params: params.map(protocol_bind_params),
+			})
+			.await
+			.map_err(remote_request_error)?;
+
+			match response {
+				protocol::SqliteExecuteWriteResponse::SqliteExecuteWriteOk(ok) => {
+					Ok(execute_result_from_protocol(ok.result))
+				}
+				protocol::SqliteExecuteWriteResponse::SqliteErrorResponse(error) => {
+					Err(remote_sqlite_error_response(error.message))
+				}
+		}
+	}
+
 	pub(crate) async fn query_rows_cbor(
 		&self,
 		sql: &str,
@@ -490,7 +621,7 @@ impl SqliteDb {
 	}
 }
 
-#[cfg(feature = "sqlite")]
+#[cfg(feature = "sqlite-local")]
 async fn enqueue_preload_hint_flush_best_effort(
 	db: Arc<Mutex<Option<NativeDatabaseHandle>>>,
 	handle: EnvoyHandle,
@@ -543,7 +674,7 @@ async fn enqueue_preload_hint_flush_best_effort(
 	}
 }
 
-#[cfg(feature = "sqlite")]
+#[cfg(feature = "sqlite-local")]
 async fn flush_preload_hints_best_effort(
 	db: Arc<Mutex<Option<NativeDatabaseHandle>>>,
 	handle: EnvoyHandle,
@@ -632,7 +763,7 @@ async fn flush_preload_hints_best_effort(
 	}
 }
 
-#[cfg(feature = "sqlite")]
+#[cfg(feature = "sqlite-local")]
 async fn snapshot_preload_hints(
 	db: Arc<Mutex<Option<NativeDatabaseHandle>>>,
 ) -> Result<Option<VfsPreloadHintSnapshot>> {
@@ -644,7 +775,7 @@ async fn snapshot_preload_hints(
 	.context("join sqlite preload hint snapshot task")?
 }
 
-#[cfg(feature = "sqlite")]
+#[cfg(feature = "sqlite-local")]
 fn protocol_preload_hints(snapshot: VfsPreloadHintSnapshot) -> protocol::SqlitePreloadHints {
 	protocol::SqlitePreloadHints {
 		pgnos: snapshot.pgnos,
@@ -659,6 +790,131 @@ fn protocol_preload_hints(snapshot: VfsPreloadHintSnapshot) -> protocol::SqliteP
 	}
 }
 
+struct RemoteSqliteConfig {
+	handle: EnvoyHandle,
+	namespace_id: String,
+	actor_id: String,
+	generation: u64,
+}
+
+fn select_sqlite_backend(enabled: bool, remote_sqlite: bool) -> SqliteBackend {
+	if enabled && remote_sqlite {
+		return SqliteBackend::RemoteEnvoy;
+	}
+
+	#[cfg(feature = "sqlite-local")]
+	{
+		SqliteBackend::LocalNative
+	}
+
+	#[cfg(not(feature = "sqlite-local"))]
+	{
+		SqliteBackend::Unavailable
+	}
+}
+
+fn protocol_bind_params(params: Vec<BindParam>) -> Vec<protocol::SqliteBindParam> {
+	params.into_iter().map(protocol_bind_param).collect()
+}
+
+fn protocol_bind_param(param: BindParam) -> protocol::SqliteBindParam {
+	match param {
+		BindParam::Null => protocol::SqliteBindParam::SqliteValueNull,
+		BindParam::Integer(value) => {
+			protocol::SqliteBindParam::SqliteValueInteger(protocol::SqliteValueInteger { value })
+		}
+		BindParam::Float(value) => protocol::SqliteBindParam::SqliteValueFloat(
+			protocol::SqliteValueFloat {
+				value: value.to_bits().to_be_bytes(),
+			},
+		),
+		BindParam::Text(value) => {
+			protocol::SqliteBindParam::SqliteValueText(protocol::SqliteValueText { value })
+		}
+		BindParam::Blob(value) => {
+			protocol::SqliteBindParam::SqliteValueBlob(protocol::SqliteValueBlob { value })
+		}
+	}
+}
+
+fn query_result_from_protocol(result: protocol::SqliteQueryResult) -> QueryResult {
+	QueryResult {
+		columns: result.columns,
+		rows: result
+			.rows
+			.into_iter()
+			.map(|row| row.into_iter().map(column_value_from_protocol).collect())
+			.collect(),
+	}
+}
+
+fn execute_result_from_protocol(result: protocol::SqliteExecuteResult) -> ExecuteResult {
+	ExecuteResult {
+		columns: result.columns,
+		rows: result
+			.rows
+			.into_iter()
+			.map(|row| row.into_iter().map(column_value_from_protocol).collect())
+			.collect(),
+		changes: result.changes,
+		last_insert_row_id: result.last_insert_row_id,
+		route: execute_route_from_protocol(result.route),
+	}
+}
+
+fn column_value_from_protocol(value: protocol::SqliteColumnValue) -> ColumnValue {
+	match value {
+		protocol::SqliteColumnValue::SqliteValueNull => ColumnValue::Null,
+		protocol::SqliteColumnValue::SqliteValueInteger(value) => {
+			ColumnValue::Integer(value.value)
+		}
+		protocol::SqliteColumnValue::SqliteValueFloat(value) => {
+			ColumnValue::Float(f64::from_bits(u64::from_be_bytes(value.value)))
+		}
+		protocol::SqliteColumnValue::SqliteValueText(value) => ColumnValue::Text(value.value),
+		protocol::SqliteColumnValue::SqliteValueBlob(value) => ColumnValue::Blob(value.value),
+	}
+}
+
+fn execute_route_from_protocol(route: protocol::SqliteExecuteRoute) -> ExecuteRoute {
+	match route {
+		protocol::SqliteExecuteRoute::Read => ExecuteRoute::Read,
+		protocol::SqliteExecuteRoute::Write => ExecuteRoute::Write,
+		protocol::SqliteExecuteRoute::WriteFallback => ExecuteRoute::WriteFallback,
+	}
+}
+
+fn remote_request_error(error: anyhow::Error) -> anyhow::Error {
+	if let Some(indeterminate) = error.downcast_ref::<RemoteSqliteIndeterminateResultError>() {
+		return SqliteRuntimeError::RemoteIndeterminateResult {
+			operation: indeterminate.operation.to_owned(),
+		}
+		.build();
+	}
+
+	if let Some(compatibility) =
+		error.downcast_ref::<protocol::versioned::ProtocolCompatibilityError>()
+	{
+		if compatibility.feature
+			== protocol::versioned::ProtocolCompatibilityFeature::RemoteSqliteExecution
+		{
+			return SqliteRuntimeError::RemoteUnavailable {
+				reason: compatibility.to_string(),
+			}
+			.build();
+		}
+	}
+
+	error
+}
+
+fn remote_sqlite_error_response(message: String) -> anyhow::Error {
+	if message.contains("unavailable") || message.contains("unsupported") {
+		return SqliteRuntimeError::RemoteUnavailable { reason: message }.build();
+	}
+
+	SqliteRuntimeError::RemoteExecutionFailed { message }.build()
+}
 impl std::fmt::Debug for SqliteDb {
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 		f.debug_struct("SqliteDb")
@@ -867,3 +1123,7 @@ fn json_type_name(value: &JsonValue) -> &'static str {
 		JsonValue::Object(_) => "object",
 	}
 }
+
+#[cfg(test)]
+#[path = "../../tests/sqlite.rs"]
+mod tests;
diff --git a/rivetkit-rust/packages/rivetkit-core/src/actor/state.rs b/rivetkit-rust/packages/rivetkit-core/src/actor/state.rs
index 7ceb83acbc..5a0111784c 100644
--- a/rivetkit-rust/packages/rivetkit-core/src/actor/state.rs
+++ b/rivetkit-rust/packages/rivetkit-core/src/actor/state.rs
@@ -1,9 +1,13 @@
 use std::sync::Arc;
 use std::sync::atomic::Ordering;
-use std::time::{Duration, Instant as StdInstant};
+use std::time::Duration;
+
+use crate::time::Instant as StdInstant;
+use crate::time::sleep;
 
 use anyhow::{Context, Result};
 use rivetkit_actor_persist::{generated::v4 as persist_v4, versioned as persist_versioned};
+#[cfg(not(feature = "wasm-runtime"))]
 use tokio::runtime::Handle;
 use tokio::sync::mpsc;
 use tokio::task::JoinHandle;
@@ -17,11 +21,13 @@ use crate::actor::messages::StateDelta;
 use crate::actor::persist::{
 	decode_latest_with_embedded_version, encode_latest_with_embedded_version,
 };
-use crate::actor::task::{
-	LIFECYCLE_EVENT_INBOX_CHANNEL, LifecycleEvent, actor_channel_overloaded_error,
-};
+#[cfg(not(target_arch = "wasm32"))]
+use crate::actor::task::{LIFECYCLE_EVENT_INBOX_CHANNEL, actor_channel_overloaded_error};
+use crate::actor::task::LifecycleEvent;
 use crate::actor::task_types::StateMutationReason;
 use crate::error::ActorRuntime;
+#[cfg(feature = "wasm-runtime")]
+use crate::runtime::RuntimeSpawner;
 use crate::types::SaveStateOpts;
 
 const LAST_PUSHED_ALARM_VERSION: u16 = 1;
@@ -106,7 +112,7 @@ impl ActorContext {
 		} else {
 			let delay = self.compute_save_delay(None);
 			if !delay.is_zero() {
-				tokio::time::sleep(delay).await;
+				sleep(delay).await;
 			}
 			self.persist_if_dirty().await
 		};
@@ -129,11 +135,54 @@ impl ActorContext {
 	/// [`Self::request_save_and_wait`] when the caller must observe
 	/// save-request delivery failures.
 	pub fn request_save(&self, opts: RequestSaveOpts) {
+		#[cfg(target_arch = "wasm32")]
+		{
+			self.request_save_best_effort(opts);
+		}
+
+		#[cfg(not(target_arch = "wasm32"))]
 		if let Err(error) = self.request_save_with_revision(opts) {
 			tracing::warn!(?error, "failed to request actor state save");
 		}
 	}
 
+	#[cfg(target_arch = "wasm32")]
+	fn request_save_best_effort(&self, opts: RequestSaveOpts) {
+		let immediate = opts.immediate;
+		let _save_request_revision = self.0.save_request_revision.fetch_add(1, Ordering::SeqCst) + 1;
+		self.notify_request_save_hooks(opts);
+		let already_requested = self.0.save_requested.swap(true, Ordering::SeqCst);
+		let immediate_already_requested = if immediate {
+			self.0.save_requested_immediate.swap(true, Ordering::SeqCst)
+		} else {
+			self.0.save_requested_immediate.load(Ordering::SeqCst)
+		};
+
+		if let Some(max_wait_ms) = opts.max_wait_ms {
+			let deadline = StdInstant::now() + Duration::from_millis(u64::from(max_wait_ms));
+			let mut requested_deadline = self.0.save_requested_within_deadline.lock();
+			*requested_deadline = Some(match *requested_deadline {
+				Some(existing) => existing.min(deadline),
+				None => deadline,
+			});
+		}
+
+		let Some(sender) = self.lifecycle_event_sender() else {
+			return;
+		};
+
+		if opts.max_wait_ms.is_none()
+			&& already_requested
+			&& (!immediate || immediate_already_requested)
+		{
+			return;
+		}
+
+		if let Ok(permit) = sender.try_reserve() {
+			permit.send(LifecycleEvent::SaveRequested { immediate });
+		}
+	}
+
 	pub async fn request_save_and_wait(&self, opts: RequestSaveOpts) -> Result<()> {
 		let save_request_revision = self.request_save_with_revision(opts)?;
 		self.wait_for_save_request(save_request_revision).await;
@@ -185,6 +234,9 @@ impl ActorContext {
 				permit.send(LifecycleEvent::SaveRequested { immediate });
 				Ok(save_request_revision)
 			}
+			#[cfg(target_arch = "wasm32")]
+			Err(_) => Ok(save_request_revision),
+			#[cfg(not(target_arch = "wasm32"))]
 			Err(_) => Err(actor_channel_overloaded_error(
 				LIFECYCLE_EVENT_INBOX_CHANNEL,
 				self.0.lifecycle_event_inbox_capacity,
@@ -212,8 +264,8 @@ impl ActorContext {
 		self.0.save_requested_immediate.load(Ordering::SeqCst)
 	}
 
-	pub(crate) fn save_deadline(&self, immediate: bool) -> tokio::time::Instant {
-		self.compute_save_deadline(immediate).into()
+	pub(crate) fn save_deadline(&self, immediate: bool) -> StdInstant {
+		self.compute_save_deadline(immediate)
 	}
 
 	pub(crate) fn compute_save_deadline(&self, immediate: bool) -> StdInstant {
@@ -546,10 +598,6 @@ impl ActorContext {
 			return;
 		}
 
-		let Ok(tokio_handle) = Handle::try_current() else {
-			return;
-		};
-
 		let delay = self.compute_save_delay(max_wait);
 		let scheduled_at = StdInstant::now() + delay;
 
@@ -567,20 +615,29 @@ impl ActorContext {
 		// Intentionally detached but abortable: pending delayed saves are
 		// retained in `pending_save`, replaced by newer saves, and awaited at
 		// shutdown through the state save guard.
-		let handle = tokio_handle.spawn(
-			async move {
-				if !delay.is_zero() {
-					tokio::time::sleep(delay).await;
-				}
+		let task = async move {
+			if !delay.is_zero() {
+				sleep(delay).await;
+			}
 
-				state.take_pending_save();
+			state.take_pending_save();
 
-				if let Err(error) = state.persist_if_dirty().await {
-					tracing::error!(?error, "failed to persist actor state");
-				}
+			if let Err(error) = state.persist_if_dirty().await {
+				tracing::error!(?error, "failed to persist actor state");
 			}
-			.in_current_span(),
-		);
+		}
+		.in_current_span();
+
+		#[cfg(not(feature = "wasm-runtime"))]
+		let handle = {
+			let Ok(tokio_handle) = Handle::try_current() else {
+				return;
+			};
+			tokio_handle.spawn(task)
+		};
+
+		#[cfg(feature = "wasm-runtime")]
+		let handle = RuntimeSpawner::spawn(task);
 
 		*pending_save = Some(PendingSave {
 			scheduled_at,
@@ -597,29 +654,35 @@ impl ActorContext {
 	pub(crate) fn persist_now_tracked(&self, description: &'static str) {
 		self.clear_pending_save();
 
-		let Ok(tokio_handle) = Handle::try_current() else {
-			tracing::warn!(
-				description,
-				"skipping tracked actor state persistence without runtime"
-			);
-			return;
-		};
-
 		let state = self.clone();
 		let mut tracked_persist = self.0.tracked_persist.lock();
 		let previous = tracked_persist.take();
-		let handle = tokio_handle.spawn(
-			async move {
-				if let Some(previous) = previous {
-					let _ = previous.await;
-				}
+		let task = async move {
+			if let Some(previous) = previous {
+				let _ = previous.await;
+			}
 
-				if let Err(error) = state.persist_state(SaveStateOpts { immediate: true }).await {
-					tracing::error!(?error, description, "failed to persist actor state");
-				}
+			if let Err(error) = state.persist_state(SaveStateOpts { immediate: true }).await {
+				tracing::error!(?error, description, "failed to persist actor state");
 			}
-			.in_current_span(),
-		);
+		}
+		.in_current_span();
+
+		#[cfg(not(feature = "wasm-runtime"))]
+		let handle = {
+			let Ok(tokio_handle) = Handle::try_current() else {
+				tracing::warn!(
+					description,
+					"skipping tracked actor state persistence without runtime"
+				);
+				return;
+			};
+			tokio_handle.spawn(task)
+		};
+
+		#[cfg(feature = "wasm-runtime")]
+		let handle = RuntimeSpawner::spawn(task);
+
 		*tracked_persist = Some(handle);
 	}
 
diff --git a/rivetkit-rust/packages/rivetkit-core/src/actor/task.rs b/rivetkit-rust/packages/rivetkit-core/src/actor/task.rs
index e4df478cc9..960efaeeab 100644
--- a/rivetkit-rust/packages/rivetkit-core/src/actor/task.rs
+++ b/rivetkit-rust/packages/rivetkit-core/src/actor/task.rs
@@ -37,6 +37,7 @@ use std::sync::Arc;
 #[cfg(test)]
 use std::sync::OnceLock;
 use std::sync::atomic::{AtomicU32, Ordering};
+use std::time::Duration;
 
 use anyhow::{Context, Result, anyhow};
 use futures::FutureExt;
@@ -44,13 +45,12 @@ use futures::FutureExt;
 use parking_lot::Mutex;
 use tokio::sync::{broadcast, mpsc, oneshot};
 use tokio::task::{JoinError, JoinHandle};
-use tokio::time::{Duration, Instant, sleep_until, timeout};
-use tracing::Instrument;
-use tracing::instrument::WithSubscriber;
+use tracing::{Instrument, instrument::WithSubscriber};
 
 use crate::actor::action::ActionDispatchError;
 use crate::actor::connection::ConnHandle;
 use crate::actor::context::ActorContext;
+#[cfg(not(target_arch = "wasm32"))]
 use crate::actor::diagnostics::record_actor_warning;
 use crate::actor::factory::ActorFactory;
 use crate::actor::keys::{LAST_PUSHED_ALARM_KEY, PERSIST_DATA_KEY};
@@ -63,6 +63,10 @@ use crate::actor::preload::{PreloadedKv, PreloadedPersistedActor};
 use crate::actor::state::{PersistedActor, decode_last_pushed_alarm, decode_persisted_actor};
 use crate::actor::task_types::ShutdownKind;
 use crate::error::{ActorLifecycle as ActorLifecycleError, ActorRuntime};
+use crate::runtime::RuntimeSpawner;
+#[cfg(test)]
+use crate::time::sleep;
+use crate::time::{Instant, sleep_until, timeout};
 use crate::types::{SaveStateOpts, format_actor_key};
 use crate::websocket::WebSocket;
 
@@ -208,39 +212,53 @@ pub(crate) fn actor_channel_overloaded_error(
 			_ => {}
 		}
 	}
-	if let Some(metrics) = metrics {
-		if let Some(suppression) =
-			record_actor_warning(metrics.actor_id(), "actor_channel_overloaded")
-		{
+	#[cfg(not(target_arch = "wasm32"))]
+	{
+		if let Some(metrics) = metrics {
+			if let Some(suppression) =
+				record_actor_warning(metrics.actor_id(), "actor_channel_overloaded")
+			{
+				tracing::warn!(
+					actor_id = %suppression.actor_id,
+					channel,
+					capacity,
+					operation,
+					event = if channel == LIFECYCLE_EVENT_INBOX_CHANNEL {
+						operation
+					} else {
+						""
+					},
+					per_actor_suppressed = suppression.per_actor_suppressed,
+					global_suppressed = suppression.global_suppressed,
+					"actor bounded channel overloaded"
+				);
+			}
+		} else {
 			tracing::warn!(
-				actor_id = %suppression.actor_id,
 				channel,
 				capacity,
 				operation,
-				event = if channel == LIFECYCLE_EVENT_INBOX_CHANNEL {
-					operation
-				} else {
-					""
-				},
-				per_actor_suppressed = suppression.per_actor_suppressed,
-				global_suppressed = suppression.global_suppressed,
 				"actor bounded channel overloaded"
 			);
 		}
-	} else {
-		tracing::warn!(
-			channel,
-			capacity,
-			operation,
-			"actor bounded channel overloaded"
-		);
 	}
-	ActorLifecycleError::Overloaded {
-		channel: channel.to_owned(),
-		capacity,
-		operation: operation.to_owned(),
+	#[cfg(target_arch = "wasm32")]
+	{
+		let _ = metrics;
+		anyhow!(
+			"actor bounded channel overloaded: channel={channel}, capacity={capacity}, operation={operation}"
+		)
+	}
+
+	#[cfg(not(target_arch = "wasm32"))]
+	{
+		ActorLifecycleError::Overloaded {
+			channel: channel.to_owned(),
+			capacity,
+			operation: operation.to_owned(),
+		}
+		.build()
 	}
-	.build()
 }
 
 pub(crate) fn try_send_lifecycle_command(
@@ -868,22 +886,20 @@ impl ActorTask {
 	fn core_dispatched_hook_reply(&self, operation: &'static str) -> Reply<()> {
 		let (tx, rx) = oneshot::channel();
 		let ctx = self.ctx.clone();
-		tokio::spawn(
-			async move {
-				match rx.await {
-					Ok(Ok(())) => {}
-					Ok(Err(error)) => {
-						tracing::error!(?error, operation, "core dispatched hook failed");
-					}
-					Err(error) => {
-						tracing::error!(?error, operation, "core dispatched hook reply dropped");
-					}
+		let task = async move {
+			match rx.await {
+				Ok(Ok(())) => {}
+				Ok(Err(error)) => {
+					tracing::error!(?error, operation, "core dispatched hook failed");
+				}
+				Err(error) => {
+					tracing::error!(?error, operation, "core dispatched hook reply dropped");
 				}
-				ctx.mark_core_dispatched_hook_completed();
 			}
-			.in_current_span()
-			.with_current_subscriber(),
-		);
+			ctx.mark_core_dispatched_hook_completed();
+		}
+		.in_current_span();
+		RuntimeSpawner::spawn(task);
 		tx.into()
 	}
 
@@ -1138,6 +1154,15 @@ impl ActorTask {
 	}
 
 	fn dispatch_lifecycle_error(&self) -> Option<anyhow::Error> {
+		if self.ctx.destroy_requested() {
+			self.ctx.warn_work_sent_to_stopping_instance("dispatch");
+			return Some(ActorLifecycleError::Destroying.build());
+		}
+		if self.ctx.sleep_requested() {
+			self.ctx.warn_work_sent_to_stopping_instance("dispatch");
+			return Some(ActorLifecycleError::Stopping.build());
+		}
+
 		match self.lifecycle {
 			LifecycleState::Started => None,
 			LifecycleState::SleepGrace
@@ -1317,7 +1342,8 @@ impl ActorTask {
 			startup_ready: startup_ready_tx,
 		};
 		let factory = self.factory.clone();
-		self.run_handle = Some(tokio::spawn(
+		let run_dispatch = tracing::dispatcher::get_default(Clone::clone);
+		self.run_handle = Some(RuntimeSpawner::spawn(
 			async move {
 				match AssertUnwindSafe(factory.start(start)).catch_unwind().await {
 					Ok(result) => result,
@@ -1328,7 +1354,7 @@ impl ActorTask {
 				}
 			}
 			.in_current_span()
-			.with_current_subscriber(),
+			.with_subscriber(run_dispatch),
 		));
 		if let Some(startup_ready_rx) = startup_ready_rx {
 			startup_ready_rx
@@ -1567,7 +1593,7 @@ impl ActorTask {
 		let started_at = Instant::now();
 		tokio::select! {
 			result = ctx.wait_for_shutdown_tasks(deadline) => result,
-			_ = tokio::time::sleep(LONG_SHUTDOWN_DRAIN_WARNING_THRESHOLD) => {
+			_ = sleep(LONG_SHUTDOWN_DRAIN_WARNING_THRESHOLD) => {
 				if ctx.wait_for_shutdown_tasks(Instant::now()).await {
 					true
 				} else {
diff --git a/rivetkit-rust/packages/rivetkit-core/src/actor/work_registry.rs b/rivetkit-rust/packages/rivetkit-core/src/actor/work_registry.rs
index 232c8e9910..dbc5b8feb9 100644
--- a/rivetkit-rust/packages/rivetkit-core/src/actor/work_registry.rs
+++ b/rivetkit-rust/packages/rivetkit-core/src/actor/work_registry.rs
@@ -2,7 +2,7 @@ use std::sync::Arc;
 use std::sync::atomic::AtomicBool;
 
 use parking_lot::Mutex;
-use rivet_util::async_counter::AsyncCounter;
+use rivet_envoy_client::async_counter::AsyncCounter;
 use tokio::sync::Notify;
 use tokio::task::JoinSet;
 
diff --git a/rivetkit-rust/packages/rivetkit-core/src/error.rs b/rivetkit-rust/packages/rivetkit-core/src/error.rs
index c94c3a5f2b..acdcd5f78f 100644
--- a/rivetkit-rust/packages/rivetkit-core/src/error.rs
+++ b/rivetkit-rust/packages/rivetkit-core/src/error.rs
@@ -141,6 +141,34 @@ pub(crate) enum SqliteRuntimeError {
 		"Invalid SQLite bind parameter {name}: {reason}"
 	)]
 	InvalidBindParameter { name: String, reason: String },
+
+	#[error(
+		"remote_unavailable",
+		"Remote SQLite is unavailable.",
+		"Remote SQLite is unavailable: {reason}"
+	)]
+	RemoteUnavailable { reason: String },
+
+	#[error(
+		"remote_execution_failed",
+		"Remote SQLite execution failed.",
+		"Remote SQLite execution failed: {message}"
+	)]
+	RemoteExecutionFailed { message: String },
+
+	#[error(
+		"remote_indeterminate_result",
+		"Remote SQLite result is indeterminate.",
+		"Remote SQLite {operation} may have completed, but the envoy disconnected before returning a result."
+	)]
+	RemoteIndeterminateResult { operation: String },
+
+	#[error(
+		"remote_fence_mismatch",
+		"Remote SQLite generation is stale.",
+		"Remote SQLite generation is stale: {reason}"
+	)]
+	RemoteFenceMismatch { reason: String },
 }
 
 #[derive(RivetError, Debug, Clone, Deserialize, Serialize)]
diff --git a/rivetkit-rust/packages/rivetkit-core/src/inspector/auth.rs b/rivetkit-rust/packages/rivetkit-core/src/inspector/auth.rs
index b38dcb5069..c8313fabb7 100644
--- a/rivetkit-rust/packages/rivetkit-core/src/inspector/auth.rs
+++ b/rivetkit-rust/packages/rivetkit-core/src/inspector/auth.rs
@@ -1,10 +1,12 @@
 use anyhow::{Context, Result};
 use base64::{Engine, engine::general_purpose::URL_SAFE_NO_PAD};
+use parking_lot::RwLock;
 use rand::RngCore;
 use rivet_error::RivetError as RivetErrorDerive;
 use serde::{Deserialize, Serialize};
 #[cfg(test)]
-use std::sync::{Mutex, OnceLock};
+use std::sync::Mutex;
+use std::sync::OnceLock;
 use subtle::ConstantTimeEq;
 
 use crate::ActorContext;
@@ -15,12 +17,20 @@ use crate::actor::keys::INSPECTOR_TOKEN_KEY;
 const INSPECTOR_TOKEN_ENV: &str = "_RIVET_TEST_INSPECTOR_TOKEN";
 const INSPECTOR_TOKEN_BYTES: usize = 32;
 
+static INSPECTOR_TEST_TOKEN_OVERRIDE: OnceLock<RwLock<Option<String>>> = OnceLock::new();
+
 #[cfg(test)]
 pub(crate) fn test_inspector_env_lock() -> &'static Mutex<()> {
 	static LOCK: OnceLock<Mutex<()>> = OnceLock::new();
 	LOCK.get_or_init(|| Mutex::new(()))
 }
 
+pub fn set_test_inspector_token_override(token: Option<String>) {
+	*INSPECTOR_TEST_TOKEN_OVERRIDE
+		.get_or_init(|| RwLock::new(None))
+		.write() = token.filter(|token| !token.is_empty());
+}
+
 #[derive(Clone, Copy, Debug, Default)]
 pub struct InspectorAuth;
 
@@ -42,10 +52,7 @@ impl InspectorAuth {
 			return Err(InspectorUnauthorized.build());
 		};
 
-		if let Some(configured_token) = std::env::var(INSPECTOR_TOKEN_ENV)
-			.ok()
-			.filter(|token| !token.is_empty())
-		{
+		if let Some(configured_token) = configured_test_token() {
 			return verify_token_bytes(bearer_token.as_bytes(), configured_token.as_bytes());
 		}
 
@@ -68,10 +75,7 @@ impl InspectorAuth {
 /// precedence over any KV-stored token and we do not want to pin a per-actor
 /// token that will never be consulted.
 pub async fn init_inspector_token(ctx: &ActorContext) -> Result<()> {
-	if std::env::var(INSPECTOR_TOKEN_ENV)
-		.ok()
-		.is_some_and(|token| !token.is_empty())
-	{
+	if configured_test_token().is_some() {
 		return Ok(());
 	}
 
@@ -99,6 +103,17 @@ fn generate_inspector_token() -> String {
 	URL_SAFE_NO_PAD.encode(bytes)
 }
 
+fn configured_test_token() -> Option<String> {
+	std::env::var(INSPECTOR_TOKEN_ENV)
+		.ok()
+		.filter(|token| !token.is_empty())
+		.or_else(|| {
+			INSPECTOR_TEST_TOKEN_OVERRIDE
+				.get()
+				.and_then(|token| token.read().clone())
+		})
+}
+
 fn verify_token_bytes(candidate: &[u8], expected: &[u8]) -> Result<()> {
 	if candidate.ct_eq(expected).into() {
 		Ok(())
diff --git a/rivetkit-rust/packages/rivetkit-core/src/inspector/mod.rs b/rivetkit-rust/packages/rivetkit-core/src/inspector/mod.rs
index 96dc6f4181..3fa2230975 100644
--- a/rivetkit-rust/packages/rivetkit-core/src/inspector/mod.rs
+++ b/rivetkit-rust/packages/rivetkit-core/src/inspector/mod.rs
@@ -7,7 +7,7 @@ use parking_lot::RwLock;
 pub mod auth;
 pub(crate) mod protocol;
 
-pub use auth::{InspectorAuth, init_inspector_token};
+pub use auth::{InspectorAuth, init_inspector_token, set_test_inspector_token_override};
 
 type InspectorListener = Arc<dyn Fn(InspectorSignal) + Send + Sync>;
 
diff --git a/rivetkit-rust/packages/rivetkit-core/src/lib.rs b/rivetkit-rust/packages/rivetkit-core/src/lib.rs
index b85256cb2f..4f39c313b8 100644
--- a/rivetkit-rust/packages/rivetkit-core/src/lib.rs
+++ b/rivetkit-rust/packages/rivetkit-core/src/lib.rs
@@ -1,9 +1,114 @@
+#[cfg(all(feature = "native-runtime", feature = "wasm-runtime"))]
+compile_error!(
+	"`native-runtime` and `wasm-runtime` are mutually exclusive. Enable exactly one rivetkit-core runtime."
+);
+
+#[cfg(all(feature = "wasm-runtime", feature = "sqlite-local"))]
+compile_error!("`sqlite-local` is native-only. Use `sqlite-remote` for wasm runtime builds.");
+
 pub mod actor;
+#[cfg(feature = "native-runtime")]
 pub mod engine_process;
 pub mod error;
 pub mod inspector;
 pub mod registry;
+pub mod runtime;
 pub mod serverless;
+pub(crate) mod time {
+	use std::fmt;
+	use std::future::Future;
+	use std::time::Duration;
+
+	#[cfg(target_arch = "wasm32")]
+	use futures::FutureExt;
+	#[cfg(target_arch = "wasm32")]
+	use wasm_bindgen::{JsCast, JsValue};
+	#[cfg(target_arch = "wasm32")]
+	use wasm_bindgen_futures::JsFuture;
+
+	#[cfg(not(target_arch = "wasm32"))]
+	pub use std::time::{Instant, SystemTime, UNIX_EPOCH};
+	#[cfg(target_arch = "wasm32")]
+	pub use web_time::{Instant, SystemTime, UNIX_EPOCH};
+
+	#[derive(Debug, Clone, Copy)]
+	pub struct TimeoutError;
+
+	impl fmt::Display for TimeoutError {
+		fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+			f.write_str("operation timed out")
+		}
+	}
+
+	impl std::error::Error for TimeoutError {}
+
+	#[cfg(not(target_arch = "wasm32"))]
+	pub fn tokio_deadline(deadline: Instant) -> tokio::time::Instant {
+		deadline.into()
+	}
+
+	#[cfg(target_arch = "wasm32")]
+	pub async fn sleep(duration: Duration) {
+		let delay_ms = duration.as_millis().min(u32::MAX as u128) as f64;
+		let promise = js_sys::Promise::new(&mut |resolve, _reject| {
+			let global = js_sys::global();
+			let set_timeout = js_sys::Reflect::get(&global, &JsValue::from_str("setTimeout"))
+				.ok()
+				.and_then(|value| value.dyn_into::<js_sys::Function>().ok());
+
+			if let Some(set_timeout) = set_timeout {
+				let _ = set_timeout.call2(&global, &resolve, &JsValue::from_f64(delay_ms));
+			} else {
+				let _ = resolve.call0(&JsValue::UNDEFINED);
+			}
+		});
+
+		let _ = JsFuture::from(promise).await;
+	}
+
+	#[cfg(not(target_arch = "wasm32"))]
+	pub async fn sleep(duration: Duration) {
+		tokio::time::sleep(duration).await;
+	}
+
+	#[cfg(not(target_arch = "wasm32"))]
+	pub async fn sleep_until(deadline: Instant) {
+		tokio::time::sleep_until(tokio_deadline(deadline)).await;
+	}
+
+	#[cfg(target_arch = "wasm32")]
+	pub async fn sleep_until(deadline: Instant) {
+		let remaining = deadline
+			.checked_duration_since(Instant::now())
+			.unwrap_or(Duration::ZERO);
+		sleep(remaining).await;
+	}
+
+	#[cfg(not(target_arch = "wasm32"))]
+	pub async fn timeout<F>(duration: Duration, future: F) -> Result<F::Output, TimeoutError>
+	where
+		F: Future,
+	{
+		tokio::time::timeout(duration, future)
+			.await
+			.map_err(|_| TimeoutError)
+	}
+
+	#[cfg(target_arch = "wasm32")]
+	pub async fn timeout<F>(duration: Duration, future: F) -> Result<F::Output, TimeoutError>
+	where
+		F: Future,
+	{
+		futures::pin_mut!(future);
+		let timer = sleep(duration);
+		futures::pin_mut!(timer);
+
+		futures::select! {
+			result = future.fuse() => Ok(result),
+			_ = timer.fuse() => Err(TimeoutError),
+		}
+	}
+}
 pub mod types;
 pub mod websocket;
 pub use actor::{kv, sqlite};
@@ -25,7 +130,10 @@ pub use actor::queue::{
 	CompletableQueueMessage, EnqueueAndWaitOpts, QueueMessage, QueueNextBatchOpts, QueueNextOpts,
 	QueueTryNextBatchOpts, QueueTryNextOpts, QueueWaitOpts,
 };
-pub use actor::sqlite::{BindParam, ColumnValue, ExecResult, QueryResult, SqliteDb};
+pub use actor::sqlite::{
+	BindParam, ColumnValue, ExecResult, ExecuteResult, ExecuteRoute, QueryResult, SqliteBackend,
+	SqliteDb,
+};
 pub use actor::state::RequestSaveOpts;
 pub use actor::task::{
 	ActionDispatchResult, ActorTask, DispatchCommand, HttpDispatchResult, LifecycleCommand,
@@ -35,6 +143,7 @@ pub use actor::task_types::ShutdownKind;
 pub use error::ActorLifecycle;
 pub use inspector::{Inspector, InspectorSnapshot};
 pub use registry::{CoreRegistry, ServeConfig};
+pub use runtime::{RuntimeBoxFuture, RuntimeSpawner, boxed_runtime_future};
 pub use serverless::{CoreServerlessRuntime, ServerlessRequest, ServerlessResponse};
 pub use types::{
 	ActorKey, ActorKeySegment, ConnId, ListOpts, SaveStateOpts, WsMessage, format_actor_key,
diff --git a/rivetkit-rust/packages/rivetkit-core/src/registry/dispatch.rs b/rivetkit-rust/packages/rivetkit-core/src/registry/dispatch.rs
index 2cbc97cad8..e7c2dd981d 100644
--- a/rivetkit-rust/packages/rivetkit-core/src/registry/dispatch.rs
+++ b/rivetkit-rust/packages/rivetkit-core/src/registry/dispatch.rs
@@ -1,5 +1,6 @@
 use super::*;
 use crate::error::ActorLifecycle as ActorLifecycleError;
+use crate::time;
 
 pub(super) async fn dispatch_action_through_task(
 	dispatch: &mpsc::Sender<DispatchCommand>,
@@ -61,7 +62,7 @@ pub(super) async fn with_action_dispatch_timeout<T, F>(
 where
 	F: std::future::Future<Output = std::result::Result<T, ActionDispatchError>>,
 {
-	tokio::time::timeout(duration, future)
+	time::timeout(duration, future)
 		.await
 		.map_err(|_| ActionDispatchError::from_anyhow(ActionTimedOut.build()))?
 }
@@ -73,7 +74,7 @@ pub(super) async fn with_framework_action_timeout<T, F>(
 where
 	F: std::future::Future<Output = Result<T>>,
 {
-	tokio::time::timeout(duration, future)
+	time::timeout(duration, future)
 		.await
 		.map_err(|_| ActionTimedOut.build())?
 }
diff --git a/rivetkit-rust/packages/rivetkit-core/src/registry/envoy_callbacks.rs b/rivetkit-rust/packages/rivetkit-core/src/registry/envoy_callbacks.rs
index 93b523f608..76fd10cf54 100644
--- a/rivetkit-rust/packages/rivetkit-core/src/registry/envoy_callbacks.rs
+++ b/rivetkit-rust/packages/rivetkit-core/src/registry/envoy_callbacks.rs
@@ -2,6 +2,7 @@ use tracing::Instrument;
 
 use super::*;
 use crate::error::ActorRuntime;
+use crate::runtime::RuntimeSpawner;
 
 impl EnvoyCallbacks for RegistryCallbacks {
 	fn on_actor_start(
@@ -62,7 +63,7 @@ impl EnvoyCallbacks for RegistryCallbacks {
 	) -> EnvoyBoxFuture<anyhow::Result<()>> {
 		let dispatcher = self.dispatcher.clone();
 		Box::pin(async move {
-			tokio::spawn(
+			RuntimeSpawner::spawn(
 				async move {
 					if let Err(error) = dispatcher.stop_actor(&actor_id, reason, stop_handle).await
 					{
@@ -163,13 +164,13 @@ impl ServeSettings {
 			serverless_base_path: None,
 			serverless_package_version: env!("CARGO_PKG_VERSION").to_owned(),
 			serverless_client_endpoint: None,
-			serverless_client_namespace: None,
-			serverless_client_token: None,
-			serverless_validate_endpoint: true,
-			serverless_max_start_payload_bytes: 1_048_576,
+				serverless_client_namespace: None,
+				serverless_client_token: None,
+				serverless_validate_endpoint: true,
+				serverless_max_start_payload_bytes: 1_048_576,
+			}
 		}
 	}
-}
 
 impl Default for ServeConfig {
 	fn default() -> Self {
@@ -191,13 +192,14 @@ impl ServeConfig {
 			serverless_base_path: settings.serverless_base_path,
 			serverless_package_version: settings.serverless_package_version,
 			serverless_client_endpoint: settings.serverless_client_endpoint,
-			serverless_client_namespace: settings.serverless_client_namespace,
-			serverless_client_token: settings.serverless_client_token,
-			serverless_validate_endpoint: settings.serverless_validate_endpoint,
-			serverless_max_start_payload_bytes: settings.serverless_max_start_payload_bytes,
+				serverless_client_namespace: settings.serverless_client_namespace,
+				serverless_client_token: settings.serverless_client_token,
+				serverless_validate_endpoint: settings.serverless_validate_endpoint,
+				serverless_max_start_payload_bytes: settings.serverless_max_start_payload_bytes,
+				serverless_cache_envoy: true,
+			}
 		}
 	}
-}
 
 fn actor_key_from_protocol(key: Option<String>) -> ActorKey {
 	key.as_deref()
diff --git a/rivetkit-rust/packages/rivetkit-core/src/registry/http.rs b/rivetkit-rust/packages/rivetkit-core/src/registry/http.rs
index 614f623622..08085cca8b 100644
--- a/rivetkit-rust/packages/rivetkit-core/src/registry/http.rs
+++ b/rivetkit-rust/packages/rivetkit-core/src/registry/http.rs
@@ -17,7 +17,11 @@ impl RegistryDispatcher {
 
 		let original_path = request.path.clone();
 		let request = build_http_request(request).await?;
-		let route = RegistryHttpRoute::from_paths(&original_path, request.uri().path())?;
+		let route = RegistryHttpRoute::from_paths(
+			&original_path,
+			request.uri().path(),
+			self.handle_inspector_http_in_runtime,
+		)?;
 		let instance = match self.active_actor(actor_id).await {
 			Ok(instance) => instance,
 			Err(error) => {
@@ -104,6 +108,7 @@ impl RegistryDispatcher {
 			FrameworkHttpRoute::Metadata => handle_metadata_fetch(&request),
 			FrameworkHttpRoute::Health => handle_health_fetch(&request),
 			FrameworkHttpRoute::Root => handle_root_fetch(&request),
+			FrameworkHttpRoute::NotFound => handle_not_found_fetch(&request),
 		}
 	}
 
@@ -388,13 +393,20 @@ enum RegistryHttpRoute {
 }
 
 impl RegistryHttpRoute {
-	fn from_paths(original_path: &str, normalized_path: &str) -> Result<Self> {
+	fn from_paths(
+		original_path: &str,
+		normalized_path: &str,
+		handle_inspector_http_in_runtime: bool,
+	) -> Result<Self> {
 		if let Some(stripped) = original_path.strip_prefix("/request") {
 			if stripped.is_empty() || matches!(stripped.as_bytes().first(), Some(b'/') | Some(b'?'))
 			{
 				return Ok(Self::UserRawRequest);
 			}
 		}
+		if handle_inspector_http_in_runtime && normalized_path.starts_with("/inspector/") {
+			return Ok(Self::UserRawRequest);
+		}
 
 		if let Some(segment) = single_path_segment(normalized_path, "/action/") {
 			return Ok(Self::Framework(FrameworkHttpRoute::Action(
@@ -411,7 +423,7 @@ impl RegistryHttpRoute {
 			"/metadata" => Ok(Self::Framework(FrameworkHttpRoute::Metadata)),
 			"/health" => Ok(Self::Framework(FrameworkHttpRoute::Health)),
 			"/" => Ok(Self::Framework(FrameworkHttpRoute::Root)),
-			_ => Ok(Self::UserRawRequest),
+			_ => Ok(Self::Framework(FrameworkHttpRoute::NotFound)),
 		}
 	}
 }
@@ -422,6 +434,7 @@ pub(super) enum FrameworkHttpRoute {
 	Metadata,
 	Health,
 	Root,
+	NotFound,
 }
 
 pub(super) struct DecodedHttpQueueRequest {
@@ -466,6 +479,19 @@ fn handle_root_fetch(request: &Request) -> Result<HttpResponse> {
 	)
 }
 
+fn handle_not_found_fetch(request: &Request) -> Result<HttpResponse> {
+	let encoding = request_encoding(request.headers());
+	message_boundary_error_response(
+		encoding,
+		framework_error_status("actor", "not_found"),
+		ActorRuntime::NotFound {
+			resource: "route".to_owned(),
+			id: request.uri().path().to_owned(),
+		}
+		.build(),
+	)
+}
+
 fn text_response(status: StatusCode, body: &str) -> Result<HttpResponse> {
 	let mut headers = HashMap::new();
 	headers.insert(
@@ -892,6 +918,7 @@ pub(super) fn framework_error_status(group: &str, code: &str) -> StatusCode {
 	match (group, code) {
 		("auth", "forbidden") => StatusCode::FORBIDDEN,
 		("actor", "action_not_found") => StatusCode::NOT_FOUND,
+		("actor", "not_found") => StatusCode::NOT_FOUND,
 		("actor", "action_timed_out") => StatusCode::REQUEST_TIMEOUT,
 		("actor", "invalid_request") => StatusCode::BAD_REQUEST,
 		("actor", "method_not_allowed") => StatusCode::METHOD_NOT_ALLOWED,
diff --git a/rivetkit-rust/packages/rivetkit-core/src/registry/inspector_ws.rs b/rivetkit-rust/packages/rivetkit-core/src/registry/inspector_ws.rs
index 9db604d652..8a1ff8cf52 100644
--- a/rivetkit-rust/packages/rivetkit-core/src/registry/inspector_ws.rs
+++ b/rivetkit-rust/packages/rivetkit-core/src/registry/inspector_ws.rs
@@ -141,7 +141,7 @@ impl RegistryDispatcher {
 					}
 					let overlay_sender = open_sender.clone();
 					let overlay_actor_id = on_open_instance.ctx.actor_id().to_owned();
-					let overlay_task = tokio::spawn(
+					let overlay_task = RuntimeSpawner::spawn(
 						async move {
 							loop {
 								match overlay_rx.recv().await {
@@ -201,7 +201,7 @@ impl RegistryDispatcher {
 								let instance = listener_instance.clone();
 								let sender = listener_sender.clone();
 								let actor_id = instance.ctx.actor_id().to_owned();
-								tokio::spawn(
+									RuntimeSpawner::spawn(
 									async move {
 										match dispatcher
 											.inspector_push_message_for_signal(&instance, signal)
@@ -318,14 +318,17 @@ impl RegistryDispatcher {
 		message: inspector_protocol::ClientMessage,
 	) -> Result<Option<InspectorServerMessage>> {
 		match message {
-			inspector_protocol::ClientMessage::PatchStateRequest(request) => {
-				instance
-					.ctx
-					.save_state(vec![StateDelta::ActorState(request.state)])
-					.await
-					.context("save inspector websocket state patch")?;
-				Ok(None)
-			}
+				inspector_protocol::ClientMessage::PatchStateRequest(request) => {
+					let state = request.state;
+					instance
+						.ctx
+						.save_state(vec![StateDelta::ActorState(state.clone())])
+						.await
+						.context("save inspector websocket state patch")?;
+					Ok(Some(InspectorServerMessage::StateUpdated(
+						inspector_protocol::StateUpdated { state },
+					)))
+				}
 			inspector_protocol::ClientMessage::StateRequest(request) => {
 				Ok(Some(InspectorServerMessage::StateResponse(
 					self.inspector_state_response(instance, request.id),
diff --git a/rivetkit-rust/packages/rivetkit-core/src/registry/mod.rs b/rivetkit-rust/packages/rivetkit-core/src/registry/mod.rs
index c4fdf48e15..10281c24f0 100644
--- a/rivetkit-rust/packages/rivetkit-core/src/registry/mod.rs
+++ b/rivetkit-rust/packages/rivetkit-core/src/registry/mod.rs
@@ -4,12 +4,13 @@ use std::io::Cursor;
 use std::path::PathBuf;
 use std::sync::Arc;
 use std::sync::atomic::{AtomicBool, Ordering};
-use std::time::{Duration, Instant};
+use std::time::Duration;
+
+use crate::time::{Instant, timeout};
 
 use ::http::StatusCode;
 use anyhow::{Context, Result};
 use parking_lot::Mutex;
-use reqwest::Url;
 use rivet_envoy_client::config::{
 	ActorStopHandle, BoxFuture as EnvoyBoxFuture, EnvoyCallbacks, HttpRequest, HttpResponse,
 	WebSocketHandler, WebSocketMessage, WebSocketSender,
@@ -26,6 +27,7 @@ use serde_json::{Value as JsonValue, json};
 use tokio::sync::{Mutex as TokioMutex, Notify, broadcast, mpsc, oneshot};
 use tokio::task::JoinHandle;
 use tokio_util::sync::CancellationToken;
+use url::Url;
 use vbare::OwnedVersionedData;
 
 use crate::actor::action::ActionDispatchError;
@@ -48,6 +50,7 @@ use crate::actor::task::{
 	try_send_lifecycle_command,
 };
 use crate::actor::task_types::ShutdownKind;
+#[cfg(feature = "native-runtime")]
 use crate::engine_process::EngineProcessManager;
 use crate::error::{ActorLifecycle as ActorLifecycleError, ActorRuntime};
 use crate::inspector::protocol::{
@@ -55,6 +58,7 @@ use crate::inspector::protocol::{
 };
 use crate::inspector::{Inspector, InspectorAuth, InspectorSignal, InspectorSubscription};
 use crate::kv::Kv;
+use crate::runtime::RuntimeSpawner;
 use crate::sqlite::SqliteDb;
 use crate::types::{ActorKey, ActorKeySegment, WsMessage};
 use crate::websocket::WebSocket;
@@ -65,6 +69,7 @@ mod envoy_callbacks;
 mod http;
 mod inspector;
 mod inspector_ws;
+#[cfg(feature = "native-runtime")]
 mod runner_config;
 mod websocket;
 
@@ -183,6 +188,7 @@ pub struct ServeConfig {
 	pub serverless_client_token: Option<String>,
 	pub serverless_validate_endpoint: bool,
 	pub serverless_max_start_payload_bytes: usize,
+	pub serverless_cache_envoy: bool,
 }
 
 #[derive(Debug, Default, Deserialize)]
@@ -428,12 +434,19 @@ impl CoreRegistry {
 		shutdown: CancellationToken,
 	) -> Result<()> {
 		let dispatcher = self.into_dispatcher(&config);
+		#[cfg(feature = "native-runtime")]
 		let _engine_process = match config.engine_binary_path.as_ref() {
 			Some(binary_path) => {
 				Some(EngineProcessManager::start(binary_path, &config.endpoint).await?)
 			}
 			None => None,
 		};
+		#[cfg(not(feature = "native-runtime"))]
+		if config.engine_binary_path.is_some() {
+			anyhow::bail!("engine process spawning requires the `native-runtime` feature");
+		}
+
+		#[cfg(feature = "native-runtime")]
 		runner_config::ensure_local_normal_runner_config(&config).await?;
 		let callbacks = Arc::new(RegistryCallbacks {
 			dispatcher: dispatcher.clone(),
@@ -475,7 +488,7 @@ impl CoreRegistry {
 		// Bounded drain. If envoy cannot reach the engine (reconnect loop stuck),
 		// we fall back to immediate `Stop` rather than hanging indefinitely.
 		// The outer host (TS signal handler / Rust binary) is the backstop.
-		match tokio::time::timeout(SHUTDOWN_DRAIN_TIMEOUT, handle.shutdown_and_wait(false)).await {
+		match timeout(SHUTDOWN_DRAIN_TIMEOUT, handle.shutdown_and_wait(false)).await {
 			Ok(()) => {}
 			Err(_) => {
 				tracing::warn!("envoy shutdown drain exceeded timeout; forcing immediate stop");
@@ -627,7 +640,7 @@ impl RegistryDispatcher {
 		)
 		.with_preloaded_persisted_actor(request.preload_persisted_actor)
 		.with_preloaded_kv(request.preloaded_kv);
-		let join = tokio::spawn(task.run());
+		let join = RuntimeSpawner::spawn(task.run());
 
 		let (start_tx, start_rx) = oneshot::channel();
 		let result: Result<Arc<ActorTaskHandle>> = async {
@@ -686,7 +699,7 @@ impl RegistryDispatcher {
 						.await;
 
 					let dispatcher = self.clone();
-					tokio::spawn(async move {
+					RuntimeSpawner::spawn(async move {
 						if let Err(error) = dispatcher
 							.shutdown_started_instance(
 								&actor_id,
@@ -788,6 +801,16 @@ impl RegistryDispatcher {
 				ActorInstanceState::Active(instance) => {
 					let instance = instance.clone();
 					if instance.ctx.started() {
+						if instance.ctx.destroy_requested() || instance.ctx.sleep_requested() {
+							instance
+								.ctx
+								.warn_work_sent_to_stopping_instance("active_actor");
+							return Err(if instance.ctx.destroy_requested() {
+								ActorLifecycleError::Destroying.build()
+							} else {
+								ActorLifecycleError::Stopping.build()
+							});
+						}
 						return Ok(instance);
 					}
 
@@ -917,7 +940,7 @@ impl RegistryDispatcher {
 				Instant::now() + instance.factory.config().effective_sleep_grace_period();
 			if !instance
 				.ctx
-				.wait_for_internal_keep_awake_idle(shutdown_deadline.into())
+				.wait_for_internal_keep_awake_idle(shutdown_deadline)
 				.await
 			{
 				instance.ctx.record_direct_subsystem_shutdown_warning(
@@ -931,7 +954,7 @@ impl RegistryDispatcher {
 			}
 			if !instance
 				.ctx
-				.wait_for_http_requests_drained(shutdown_deadline.into())
+				.wait_for_http_requests_drained(shutdown_deadline)
 				.await
 			{
 				instance
@@ -1002,10 +1025,12 @@ impl RegistryDispatcher {
 			self.region.clone(),
 			factory.config().clone(),
 			Kv::new(handle.clone(), actor_id.to_owned()),
-			SqliteDb::new(
+			SqliteDb::new_with_remote_sqlite(
 				handle.clone(),
 				actor_id.to_owned(),
+				Some(generation as u64),
 				factory.config().has_database,
+				factory.config().remote_sqlite,
 			),
 		);
 		ctx.configure_envoy(handle, Some(generation));
diff --git a/rivetkit-rust/packages/rivetkit-core/src/registry/websocket.rs b/rivetkit-rust/packages/rivetkit-core/src/registry/websocket.rs
index 365e8e710f..ecf23df63a 100644
--- a/rivetkit-rust/packages/rivetkit-core/src/registry/websocket.rs
+++ b/rivetkit-rust/packages/rivetkit-core/src/registry/websocket.rs
@@ -3,7 +3,7 @@ use super::dispatch::*;
 use super::inspector::encode_json_as_cbor;
 use super::*;
 use crate::error::ProtocolError;
-use tokio::time::timeout;
+use crate::time::timeout;
 use tracing::Instrument;
 
 impl RegistryDispatcher {
@@ -247,9 +247,8 @@ impl RegistryDispatcher {
 		let on_message_dispatch_capacity =
 			instance.factory.config().dispatch_command_inbox_capacity;
 
-		let on_open: Option<
-			Box<dyn FnOnce(WebSocketSender) -> futures::future::BoxFuture<'static, ()> + Send>,
-		> = if is_restoring_hibernatable {
+		let on_open: Option<Box<dyn FnOnce(WebSocketSender) -> EnvoyBoxFuture<()> + Send>> =
+			if is_restoring_hibernatable {
 			None
 		} else {
 			Some(Box::new(move |sender| {
@@ -356,8 +355,8 @@ impl RegistryDispatcher {
 							let conn = conn.clone();
 							let message_index = message.message_index;
 							let actor_id = ctx.actor_id().to_owned();
-							tokio::spawn(
-								async move {
+								RuntimeSpawner::spawn(
+									async move {
 									let response = match dispatch_action_through_task(
 										&dispatch,
 										on_message_dispatch_capacity,
diff --git a/rivetkit-rust/packages/rivetkit-core/src/runtime.rs b/rivetkit-rust/packages/rivetkit-core/src/runtime.rs
new file mode 100644
index 0000000000..b73a5f0d05
--- /dev/null
+++ b/rivetkit-rust/packages/rivetkit-core/src/runtime.rs
@@ -0,0 +1,135 @@
+use std::future::Future;
+use std::pin::Pin;
+
+use tokio::task::JoinHandle;
+
+#[cfg(feature = "native-runtime")]
+pub type RuntimeBoxFuture<T> = Pin<Box<dyn Future<Output = T> + Send>>;
+
+#[cfg(not(any(feature = "native-runtime", feature = "wasm-runtime")))]
+pub type RuntimeBoxFuture<T> = Pin<Box<dyn Future<Output = T> + Send>>;
+
+#[cfg(feature = "wasm-runtime")]
+pub type RuntimeBoxFuture<T> = Pin<Box<dyn Future<Output = T>>>;
+
+#[cfg(feature = "native-runtime")]
+pub trait RuntimeFuture: Future + Send + 'static {}
+
+#[cfg(feature = "native-runtime")]
+impl<F> RuntimeFuture for F where F: Future + Send + 'static {}
+
+#[cfg(not(any(feature = "native-runtime", feature = "wasm-runtime")))]
+pub trait RuntimeFuture: Future + Send + 'static {}
+
+#[cfg(not(any(feature = "native-runtime", feature = "wasm-runtime")))]
+impl<F> RuntimeFuture for F where F: Future + Send + 'static {}
+
+#[cfg(feature = "wasm-runtime")]
+pub trait RuntimeFuture: Future + 'static {}
+
+#[cfg(feature = "wasm-runtime")]
+impl<F> RuntimeFuture for F where F: Future + 'static {}
+
+#[cfg(feature = "native-runtime")]
+pub trait RuntimeFutureOutput: Send + 'static {}
+
+#[cfg(feature = "native-runtime")]
+impl<T> RuntimeFutureOutput for T where T: Send + 'static {}
+
+#[cfg(not(any(feature = "native-runtime", feature = "wasm-runtime")))]
+pub trait RuntimeFutureOutput: Send + 'static {}
+
+#[cfg(not(any(feature = "native-runtime", feature = "wasm-runtime")))]
+impl<T> RuntimeFutureOutput for T where T: Send + 'static {}
+
+#[cfg(feature = "wasm-runtime")]
+pub trait RuntimeFutureOutput: 'static {}
+
+#[cfg(feature = "wasm-runtime")]
+impl<T> RuntimeFutureOutput for T where T: 'static {}
+
+#[derive(Clone, Copy, Debug, Default)]
+pub struct RuntimeSpawner;
+
+impl RuntimeSpawner {
+	#[cfg(feature = "native-runtime")]
+	pub fn spawn<F>(future: F) -> JoinHandle<F::Output>
+	where
+		F: RuntimeFuture,
+		F::Output: RuntimeFutureOutput,
+	{
+		tokio::spawn(future)
+	}
+
+	#[cfg(not(any(feature = "native-runtime", feature = "wasm-runtime")))]
+	pub fn spawn<F>(future: F) -> JoinHandle<F::Output>
+	where
+		F: RuntimeFuture,
+		F::Output: RuntimeFutureOutput,
+	{
+		tokio::spawn(future)
+	}
+
+	#[cfg(feature = "wasm-runtime")]
+	pub fn spawn<F>(future: F) -> JoinHandle<F::Output>
+	where
+		F: RuntimeFuture,
+		F::Output: RuntimeFutureOutput,
+	{
+		tokio::task::spawn_local(future)
+	}
+}
+
+#[cfg(feature = "native-runtime")]
+pub fn boxed_runtime_future<F, T>(future: F) -> RuntimeBoxFuture<T>
+where
+	F: Future<Output = T> + Send + 'static,
+{
+	Box::pin(future)
+}
+
+#[cfg(not(any(feature = "native-runtime", feature = "wasm-runtime")))]
+pub fn boxed_runtime_future<F, T>(future: F) -> RuntimeBoxFuture<T>
+where
+	F: Future<Output = T> + Send + 'static,
+{
+	Box::pin(future)
+}
+
+#[cfg(feature = "wasm-runtime")]
+pub fn boxed_runtime_future<F, T>(future: F) -> RuntimeBoxFuture<T>
+where
+	F: Future<Output = T> + 'static,
+{
+	Box::pin(future)
+}
+
+#[cfg(all(test, feature = "wasm-runtime"))]
+mod tests {
+	use std::cell::RefCell;
+	use std::rc::Rc;
+
+	use super::{RuntimeBoxFuture, boxed_runtime_future};
+
+	fn accepts_wasm_local_callback(
+		callback: impl Fn() -> RuntimeBoxFuture<()> + 'static,
+	) -> impl Fn() -> RuntimeBoxFuture<()> {
+		callback
+	}
+
+	#[test]
+	fn wasm_runtime_box_future_accepts_local_callbacks() {
+		let state = Rc::new(RefCell::new(0));
+		let callback = accepts_wasm_local_callback({
+			let state = state.clone();
+			move || {
+				let state = state.clone();
+				boxed_runtime_future(async move {
+					*state.borrow_mut() += 1;
+				})
+			}
+		});
+
+		let _future = callback();
+	}
+}
diff --git a/rivetkit-rust/packages/rivetkit-core/src/serverless.rs b/rivetkit-rust/packages/rivetkit-core/src/serverless.rs
index 9d58cfd3bb..c77d0ce523 100644
--- a/rivetkit-rust/packages/rivetkit-core/src/serverless.rs
+++ b/rivetkit-rust/packages/rivetkit-core/src/serverless.rs
@@ -5,9 +5,8 @@ use std::time::Duration;
 
 use anyhow::{Context, Result};
 use http::StatusCode;
-use reqwest::Url;
 use rivet_envoy_client::config::{ActorName as EnvoyActorName, EnvoyConfig};
-use rivet_envoy_client::envoy::start_envoy;
+use rivet_envoy_client::envoy::start_envoy as start_envoy_client;
 use rivet_envoy_client::handle::EnvoyHandle;
 use rivet_envoy_client::protocol;
 use rivetkit_shared_types::serverless_metadata::{
@@ -17,10 +16,14 @@ use serde::Serialize;
 use serde_json::json;
 use tokio::sync::{Mutex as TokioMutex, mpsc};
 use tokio_util::sync::CancellationToken;
+use url::Url;
 
 use crate::actor::factory::ActorFactory;
+#[cfg(feature = "native-runtime")]
 use crate::engine_process::EngineProcessManager;
 use crate::registry::{RegistryCallbacks, RegistryDispatcher, ServeConfig};
+use crate::runtime::RuntimeSpawner;
+use crate::time::{sleep, timeout};
 
 const DEFAULT_BASE_PATH: &str = "/api/rivet";
 const SSE_PING_INTERVAL: Duration = Duration::from_secs(1);
@@ -34,6 +37,7 @@ pub struct CoreServerlessRuntime {
 	settings: Arc<ServerlessSettings>,
 	dispatcher: Arc<RegistryDispatcher>,
 	envoy: Arc<TokioMutex<Option<EnvoyHandle>>>,
+	#[cfg(feature = "native-runtime")]
 	_engine_process: Arc<TokioMutex<Option<EngineProcessManager>>>,
 	shutting_down: Arc<AtomicBool>,
 }
@@ -51,6 +55,7 @@ struct ServerlessSettings {
 	client_token: Option<String>,
 	validate_endpoint: bool,
 	max_start_payload_bytes: usize,
+	cache_envoy: bool,
 }
 
 #[derive(Debug)]
@@ -148,12 +153,17 @@ impl CoreServerlessRuntime {
 		factories: HashMap<String, Arc<ActorFactory>>,
 		config: ServeConfig,
 	) -> Result<Self> {
+		#[cfg(feature = "native-runtime")]
 		let engine_process = match config.engine_binary_path.as_ref() {
 			Some(binary_path) => {
 				Some(EngineProcessManager::start(binary_path, &config.endpoint).await?)
 			}
 			None => None,
 		};
+		#[cfg(not(feature = "native-runtime"))]
+		if config.engine_binary_path.is_some() {
+			anyhow::bail!("engine process spawning requires the `native-runtime` feature");
+		}
 
 		let dispatcher = Arc::new(RegistryDispatcher::new(
 			factories,
@@ -171,12 +181,14 @@ impl CoreServerlessRuntime {
 				package_version: config.serverless_package_version,
 				client_endpoint: config.serverless_client_endpoint,
 				client_namespace: config.serverless_client_namespace,
-				client_token: config.serverless_client_token,
-				validate_endpoint: config.serverless_validate_endpoint,
-				max_start_payload_bytes: config.serverless_max_start_payload_bytes,
-			}),
+					client_token: config.serverless_client_token,
+					validate_endpoint: config.serverless_validate_endpoint,
+					max_start_payload_bytes: config.serverless_max_start_payload_bytes,
+					cache_envoy: config.serverless_cache_envoy,
+				}),
 			dispatcher,
 			envoy: Arc::new(TokioMutex::new(None)),
+			#[cfg(feature = "native-runtime")]
 			_engine_process: Arc::new(TokioMutex::new(engine_process)),
 			shutting_down: Arc::new(AtomicBool::new(false)),
 		})
@@ -192,7 +204,7 @@ impl CoreServerlessRuntime {
 		self.shutting_down.store(true, Ordering::Release);
 		let handle = { self.envoy.lock().await.take() };
 		let Some(handle) = handle else { return };
-		match tokio::time::timeout(SHUTDOWN_DRAIN_TIMEOUT, handle.shutdown_and_wait(false)).await {
+		match timeout(SHUTDOWN_DRAIN_TIMEOUT, handle.shutdown_and_wait(false)).await {
 			Ok(()) => {}
 			Err(_) => {
 				tracing::warn!(
@@ -236,7 +248,7 @@ impl CoreServerlessRuntime {
 				}),
 			)),
 			("GET", "/metadata") => Ok(self.metadata_response()),
-			("POST", "/start") => self.start_response(req).await,
+			("GET", "/start") | ("POST", "/start") => self.start_response(req).await,
 			("OPTIONS", _) => Ok(bytes_response(
 				StatusCode::NO_CONTENT,
 				HashMap::new(),
@@ -260,14 +272,21 @@ impl CoreServerlessRuntime {
 			}
 			.build());
 		}
+
 		let handle = self.ensure_envoy(&headers).await?;
 		let payload = req.body;
 		let cancel_token = req.cancel_token;
+		let cache_envoy = self.settings.cache_envoy;
 		let (tx, rx) = mpsc::channel(16);
+		let _ = tx.try_send(Ok(b"event: ping\ndata:\n\n".to_vec()));
 
-		tokio::spawn(async move {
+		RuntimeSpawner::spawn(async move {
+			let shutdown_handle = handle.clone();
 			let result = tokio::select! {
 				_ = cancel_token.cancelled() => {
+					if !cache_envoy {
+						shutdown_handle.shutdown_and_wait(false).await;
+					}
 					return;
 				}
 				result = handle.start_serverless_actor(&payload) => result,
@@ -275,6 +294,9 @@ impl CoreServerlessRuntime {
 			if let Err(error) = result {
 				let error = stream_error(error);
 				let _ = tx.send(Err(error)).await;
+				if !cache_envoy {
+					handle.shutdown_and_wait(false).await;
+				}
 				return;
 			}
 
@@ -283,13 +305,17 @@ impl CoreServerlessRuntime {
 					_ = cancel_token.cancelled() => {
 						break;
 					}
-					_ = tokio::time::sleep(SSE_PING_INTERVAL) => {
+					_ = sleep(SSE_PING_INTERVAL) => {
 						if tx.send(Ok(b"event: ping\ndata:\n\n".to_vec())).await.is_err() {
 							break;
 						}
 					}
 				}
 			}
+
+			if !cache_envoy {
+				handle.shutdown_and_wait(false).await;
+			}
 		});
 
 		Ok(ServerlessResponse {
@@ -374,6 +400,9 @@ impl CoreServerlessRuntime {
 		if self.shutting_down.load(Ordering::Acquire) {
 			return Err(RuntimeShutDown.build());
 		}
+		if !self.settings.cache_envoy {
+			return self.start_envoy(headers).await;
+		}
 		let mut guard = self.envoy.lock().await;
 		if let Some(handle) = guard.as_ref() {
 			// The start request token authenticates the serverless callback. It is not part
@@ -387,6 +416,28 @@ impl CoreServerlessRuntime {
 			return Ok(handle.clone());
 		}
 
+		let handle = self.start_envoy(headers).await?;
+		// Re-check under the lock: shutdown may have run while we were awaiting
+		// `start_envoy`. If so, tear down the freshly-built envoy rather than
+		// installing it into the cache.
+		if self.shutting_down.load(Ordering::Acquire) {
+			drop(guard);
+			match timeout(SHUTDOWN_DRAIN_TIMEOUT, handle.shutdown_and_wait(false))
+				.await
+			{
+				Ok(()) => {}
+				Err(_) => {
+					handle.shutdown(true);
+					handle.wait_stopped().await;
+				}
+			}
+			return Err(RuntimeShutDown.build());
+		}
+		*guard = Some(handle.clone());
+		Ok(handle)
+	}
+
+	async fn start_envoy(&self, headers: &StartHeaders) -> Result<EnvoyHandle> {
 		let callbacks = Arc::new(RegistryCallbacks {
 			dispatcher: self.dispatcher.clone(),
 		});
@@ -396,7 +447,11 @@ impl CoreServerlessRuntime {
 			.into_iter()
 			.map(|(name, metadata)| (name, EnvoyActorName { metadata }))
 			.collect();
-		let handle = start_envoy(EnvoyConfig {
+		// not_global: true to avoid caching the handle in the process-wide
+		// `GLOBAL_ENVOY` OnceLock. Without this, a shutdown-during-build race
+		// (spec §3 step 7) leaves a dead handle cached for the life of the
+		// process and any subsequent consumer gets it back.
+		Ok(start_envoy_client(EnvoyConfig {
 			version: self.settings.version,
 			endpoint: headers.endpoint.clone(),
 			token: headers.token.clone(),
@@ -406,29 +461,11 @@ impl CoreServerlessRuntime {
 			metadata: Some(json!({
 				"rivetkit": { "version": self.settings.package_version },
 			})),
-			not_global: false,
+			not_global: true,
 			debug_latency_ms: None,
 			callbacks,
 		})
-		.await;
-		// Re-check under the lock: shutdown may have run while we were awaiting
-		// `start_envoy`. If so, tear down the freshly-built envoy rather than
-		// installing it into the cache.
-		if self.shutting_down.load(Ordering::Acquire) {
-			drop(guard);
-			match tokio::time::timeout(SHUTDOWN_DRAIN_TIMEOUT, handle.shutdown_and_wait(false))
-				.await
-			{
-				Ok(()) => {}
-				Err(_) => {
-					handle.shutdown(true);
-					handle.wait_stopped().await;
-				}
-			}
-			return Err(RuntimeShutDown.build());
-		}
-		*guard = Some(handle.clone());
-		Ok(handle)
+		.await)
 	}
 }
 
@@ -446,10 +483,13 @@ fn route_path(base_path: &str, url: &str) -> Result<String> {
 }
 
 fn parse_start_headers(headers: &HashMap<String, String>) -> Result<StartHeaders> {
+	let pool_name = required_header(headers, "x-rivet-pool-name")
+		.or_else(|_| required_header(headers, "x-rivet-runner-name"))?;
+
 	Ok(StartHeaders {
 		endpoint: required_header(headers, "x-rivet-endpoint")?,
 		token: optional_header(headers, "x-rivet-token"),
-		pool_name: required_header(headers, "x-rivet-pool-name")?,
+		pool_name,
 		namespace: required_header(headers, "x-rivet-namespace-name")?,
 	})
 }
@@ -550,9 +590,7 @@ fn bytes_response(
 	body: Vec<u8>,
 ) -> ServerlessResponse {
 	let (tx, rx) = mpsc::channel(1);
-	tokio::spawn(async move {
-		let _ = tx.send(Ok(body)).await;
-	});
+	let _ = tx.try_send(Ok(body));
 	ServerlessResponse {
 		status: status.as_u16(),
 		headers,
@@ -612,11 +650,27 @@ pub fn normalize_endpoint_url(url: &str) -> Option<String> {
 	Some(format!("{}://{}{}", parsed.scheme(), host, pathname))
 }
 
+fn normalized_endpoint_candidates(value: &str) -> Vec<String> {
+	value
+		.split(',')
+		.map(str::trim)
+		.filter(|candidate| !candidate.is_empty())
+		.map(|candidate| {
+			normalize_endpoint_url(candidate).unwrap_or_else(|| candidate.to_owned())
+		})
+		.collect()
+}
+
 pub fn endpoints_match(a: &str, b: &str) -> bool {
-	match (normalize_endpoint_url(a), normalize_endpoint_url(b)) {
-		(Some(a), Some(b)) => a == b,
-		_ => a == b,
-	}
+	let a_candidates = normalized_endpoint_candidates(a);
+	let b_candidates = normalized_endpoint_candidates(b);
+	a_candidates
+		.iter()
+		.any(|a_candidate| {
+			b_candidates
+				.iter()
+				.any(|b_candidate| a_candidate == b_candidate)
+		})
 }
 
 fn normalize_regional_hostname(hostname: &str) -> String {
diff --git a/rivetkit-rust/packages/rivetkit-core/tests/context.rs b/rivetkit-rust/packages/rivetkit-core/tests/context.rs
index 749be3bc2e..54e091db7d 100644
--- a/rivetkit-rust/packages/rivetkit-core/tests/context.rs
+++ b/rivetkit-rust/packages/rivetkit-core/tests/context.rs
@@ -199,7 +199,7 @@ mod moved_tests {
 	use std::collections::{BTreeSet, HashMap, HashSet};
 	use std::sync::atomic::{AtomicUsize, Ordering};
 	use std::sync::{Arc, Mutex};
-	use std::time::{Duration, SystemTime, UNIX_EPOCH};
+	use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
 
 	use anyhow::anyhow;
 	use rivet_envoy_client::config::{
@@ -211,7 +211,7 @@ mod moved_tests {
 	use rivet_envoy_client::protocol;
 	use rivet_envoy_client::tunnel::HibernatingWebSocketMetadata;
 	use tokio::sync::mpsc;
-	use tokio::time::{Instant, sleep};
+	use tokio::time::sleep;
 
 	use super::ActorContext;
 	use crate::actor::connection::ConnHandle;
@@ -335,7 +335,7 @@ mod moved_tests {
 				SharedActorEntry {
 					handle: mpsc::unbounded_channel().0,
 					active_http_request_count: Arc::new(
-						rivet_util::async_counter::AsyncCounter::new(),
+						rivet_envoy_client::async_counter::AsyncCounter::new(),
 					),
 				},
 			);
diff --git a/rivetkit-rust/packages/rivetkit-core/tests/metrics.rs b/rivetkit-rust/packages/rivetkit-core/tests/metrics.rs
index 0e6e291a0f..b59d9504b7 100644
--- a/rivetkit-rust/packages/rivetkit-core/tests/metrics.rs
+++ b/rivetkit-rust/packages/rivetkit-core/tests/metrics.rs
@@ -35,7 +35,7 @@ mod moved_tests {
 		);
 	}
 
-	#[cfg(feature = "sqlite")]
+	#[cfg(feature = "sqlite-local")]
 	#[test]
 	fn sqlite_read_pool_metrics_render() {
 		use rivetkit_sqlite::vfs::SqliteVfsMetrics;
diff --git a/rivetkit-rust/packages/rivetkit-core/tests/serverless.rs b/rivetkit-rust/packages/rivetkit-core/tests/serverless.rs
index f7fd5aea16..b49cc7ec34 100644
--- a/rivetkit-rust/packages/rivetkit-core/tests/serverless.rs
+++ b/rivetkit-rust/packages/rivetkit-core/tests/serverless.rs
@@ -2,6 +2,8 @@ use super::*;
 
 mod moved_tests {
 	use std::collections::HashMap;
+	#[cfg(not(feature = "native-runtime"))]
+	use std::path::PathBuf;
 
 	use tokio_util::sync::CancellationToken;
 
@@ -45,6 +47,18 @@ mod moved_tests {
 		assert!(!endpoints_match("not a url", "also not a url"));
 	}
 
+	#[test]
+	fn matches_combined_duplicate_endpoint_headers() {
+		assert!(endpoints_match(
+			"http://127.0.0.1:6420, http://127.0.0.1:8080",
+			"http://localhost:8080/"
+		));
+		assert!(!endpoints_match(
+			"http://127.0.0.1:6420, http://127.0.0.1:8080",
+			"http://localhost:9000/"
+		));
+	}
+
 	#[tokio::test]
 	async fn handles_basic_routes() {
 		let runtime = test_runtime().await;
@@ -133,30 +147,50 @@ mod moved_tests {
 		assert_eq!(parsed.token.as_deref(), Some("dev"));
 	}
 
+	#[cfg(not(feature = "native-runtime"))]
+	#[tokio::test]
+	async fn engine_process_spawn_requires_native_runtime() {
+		let mut config = test_config();
+		config.engine_binary_path = Some(PathBuf::from("rivet-engine"));
+
+		let error = match CoreServerlessRuntime::new(HashMap::new(), config).await {
+			Ok(_) => panic!("engine process spawning should fail without native runtime"),
+			Err(error) => error,
+		};
+
+		assert!(
+			error
+				.to_string()
+				.contains("engine process spawning requires the `native-runtime` feature")
+		);
+	}
+
 	async fn test_runtime() -> CoreServerlessRuntime {
-		CoreServerlessRuntime::new(
-			HashMap::new(),
-			ServeConfig {
-				version: 1,
-				endpoint: "http://127.0.0.1:6420".to_owned(),
-				token: Some("dev".to_owned()),
-				namespace: "default".to_owned(),
-				pool_name: "default".to_owned(),
-				engine_binary_path: None,
-				handle_inspector_http_in_runtime: true,
-				serverless_base_path: Some("/api/rivet".to_owned()),
-				serverless_package_version: "test-version".to_owned(),
-				serverless_client_endpoint: Some("http://client.example".to_owned()),
-				serverless_client_namespace: Some("default".to_owned()),
-				serverless_client_token: Some("client-token".to_owned()),
-				serverless_validate_endpoint: true,
-				serverless_max_start_payload_bytes: 1_048_576,
-			},
-		)
+		CoreServerlessRuntime::new(HashMap::new(), test_config())
 		.await
 		.expect("runtime should build")
 	}
 
+	fn test_config() -> ServeConfig {
+		ServeConfig {
+			version: 1,
+			endpoint: "http://127.0.0.1:6420".to_owned(),
+			token: Some("dev".to_owned()),
+			namespace: "default".to_owned(),
+			pool_name: "default".to_owned(),
+			engine_binary_path: None,
+			handle_inspector_http_in_runtime: true,
+			serverless_base_path: Some("/api/rivet".to_owned()),
+			serverless_package_version: "test-version".to_owned(),
+			serverless_client_endpoint: Some("http://client.example".to_owned()),
+			serverless_client_namespace: Some("default".to_owned()),
+			serverless_client_token: Some("client-token".to_owned()),
+			serverless_validate_endpoint: true,
+			serverless_max_start_payload_bytes: 1_048_576,
+			serverless_cache_envoy: true,
+		}
+	}
+
 	fn test_request(method: &str, path: &str) -> ServerlessRequest {
 		ServerlessRequest {
 			method: method.to_owned(),
diff --git a/rivetkit-rust/packages/rivetkit-core/tests/sleep.rs b/rivetkit-rust/packages/rivetkit-core/tests/sleep.rs
index f042819133..0111ab4e65 100644
--- a/rivetkit-rust/packages/rivetkit-core/tests/sleep.rs
+++ b/rivetkit-rust/packages/rivetkit-core/tests/sleep.rs
@@ -4,10 +4,12 @@ mod moved_tests {
 
 	use crate::actor::context::ActorContext;
 	use parking_lot::Mutex as DropMutex;
-	use rivet_util::async_counter::AsyncCounter;
+	use rivet_envoy_client::async_counter::AsyncCounter;
 	use tokio::sync::oneshot;
 	use tokio::task::yield_now;
-	use tokio::time::{Duration, Instant, advance};
+	use std::time::{Duration, Instant};
+
+	use tokio::time::advance;
 	use tracing::field::{Field, Visit};
 	use tracing::{Event, Subscriber};
 	use tracing_subscriber::layer::{Context as LayerContext, Layer};
diff --git a/rivetkit-rust/packages/rivetkit-core/tests/sqlite.rs b/rivetkit-rust/packages/rivetkit-core/tests/sqlite.rs
new file mode 100644
index 0000000000..0ef2d193a1
--- /dev/null
+++ b/rivetkit-rust/packages/rivetkit-core/tests/sqlite.rs
@@ -0,0 +1,106 @@
+use super::*;
+
+#[test]
+fn remote_backend_requires_declared_database_and_capability() {
+	assert_eq!(select_sqlite_backend(true, true), SqliteBackend::RemoteEnvoy);
+
+	#[cfg(feature = "sqlite-local")]
+	{
+		assert_eq!(select_sqlite_backend(true, false), SqliteBackend::LocalNative);
+		assert_eq!(select_sqlite_backend(false, true), SqliteBackend::LocalNative);
+	}
+
+	#[cfg(not(feature = "sqlite-local"))]
+	{
+		assert_eq!(select_sqlite_backend(true, false), SqliteBackend::Unavailable);
+		assert_eq!(select_sqlite_backend(false, true), SqliteBackend::Unavailable);
+	}
+}
+
+#[test]
+fn protocol_conversion_preserves_bind_and_result_values() {
+	let params = protocol_bind_params(vec![
+		BindParam::Null,
+		BindParam::Integer(7),
+		BindParam::Float(1.5),
+		BindParam::Text("hello".to_owned()),
+		BindParam::Blob(vec![1, 2, 3]),
+	]);
+
+	assert!(matches!(
+		params[0],
+		protocol::SqliteBindParam::SqliteValueNull
+	));
+	assert!(matches!(
+		params[1],
+		protocol::SqliteBindParam::SqliteValueInteger(protocol::SqliteValueInteger { value: 7 })
+	));
+	assert!(matches!(
+		params[2],
+		protocol::SqliteBindParam::SqliteValueFloat(protocol::SqliteValueFloat { value })
+			if f64::from_bits(u64::from_be_bytes(value)) == 1.5
+	));
+	assert!(matches!(
+		&params[3],
+		protocol::SqliteBindParam::SqliteValueText(protocol::SqliteValueText { value })
+			if value == "hello"
+	));
+	assert!(matches!(
+		&params[4],
+		protocol::SqliteBindParam::SqliteValueBlob(protocol::SqliteValueBlob { value })
+			if value == &vec![1, 2, 3]
+	));
+
+	let result = execute_result_from_protocol(protocol::SqliteExecuteResult {
+		columns: vec!["id".to_owned(), "score".to_owned()],
+		rows: vec![vec![
+			protocol::SqliteColumnValue::SqliteValueInteger(protocol::SqliteValueInteger {
+				value: 9,
+			}),
+			protocol::SqliteColumnValue::SqliteValueFloat(protocol::SqliteValueFloat {
+				value: 2.25_f64.to_bits().to_be_bytes(),
+			}),
+		]],
+		changes: 3,
+		last_insert_row_id: Some(11),
+		route: protocol::SqliteExecuteRoute::WriteFallback,
+	});
+
+	assert_eq!(result.columns, vec!["id", "score"]);
+	assert_eq!(
+		result.rows,
+		vec![vec![ColumnValue::Integer(9), ColumnValue::Float(2.25)]]
+	);
+	assert_eq!(result.changes, 3);
+	assert_eq!(result.last_insert_row_id, Some(11));
+	assert_eq!(result.route, ExecuteRoute::WriteFallback);
+}
+
+#[test]
+fn remote_protocol_compatibility_errors_become_remote_unavailable() {
+	let err = anyhow::anyhow!(protocol::versioned::ProtocolCompatibilityError {
+		feature: protocol::versioned::ProtocolCompatibilityFeature::RemoteSqliteExecution,
+		direction: protocol::versioned::ProtocolCompatibilityDirection::ToRivet,
+		required_version: 4,
+		target_version: 3,
+	});
+
+	let mapped = remote_request_error(err);
+	let structured = rivet_error::RivetError::extract(&mapped);
+	assert_eq!(structured.group(), "sqlite");
+	assert_eq!(structured.code(), "remote_unavailable");
+}
+
+#[test]
+fn remote_lost_response_errors_become_indeterminate_result() {
+	let err = anyhow::anyhow!(
+		rivet_envoy_client::utils::RemoteSqliteIndeterminateResultError {
+			operation: "execute_write",
+		}
+	);
+
+	let mapped = remote_request_error(err);
+	let structured = rivet_error::RivetError::extract(&mapped);
+	assert_eq!(structured.group(), "sqlite");
+	assert_eq!(structured.code(), "remote_indeterminate_result");
+}
diff --git a/rivetkit-rust/packages/rivetkit-core/tests/task.rs b/rivetkit-rust/packages/rivetkit-core/tests/task.rs
index 044425917a..4fc1b0c773 100644
--- a/rivetkit-rust/packages/rivetkit-core/tests/task.rs
+++ b/rivetkit-rust/packages/rivetkit-core/tests/task.rs
@@ -6,7 +6,7 @@ mod moved_tests {
 	use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
 	use std::sync::{Mutex, OnceLock};
 	use std::task::Poll;
-	use std::time::Duration;
+	use std::time::{Duration, Instant};
 
 	use futures::{FutureExt, poll};
 	use rivet_envoy_client::config::{
@@ -19,7 +19,7 @@ mod moved_tests {
 	use rivet_envoy_client::protocol;
 	use tokio::sync::{Mutex as AsyncMutex, mpsc, oneshot};
 	use tokio::task::yield_now;
-	use tokio::time::{Instant, advance, sleep, timeout};
+	use tokio::time::{advance, sleep, timeout};
 	use tracing::field::{Field, Visit};
 	use tracing::instrument::WithSubscriber;
 	use tracing::{Event, Subscriber};
@@ -761,7 +761,7 @@ mod moved_tests {
 		let debounce_deadline = task
 			.state_save_deadline
 			.expect("debounced save deadline should exist");
-		assert!(debounce_deadline > tokio::time::Instant::now());
+		assert!(debounce_deadline > Instant::now());
 		sleep(Duration::from_millis(20)).await;
 		assert_eq!(save_ticks.load(Ordering::SeqCst), 0);
 
@@ -779,7 +779,7 @@ mod moved_tests {
 		let immediate_deadline = task
 			.state_save_deadline
 			.expect("immediate save deadline should exist");
-		assert!(immediate_deadline <= tokio::time::Instant::now() + Duration::from_millis(5));
+		assert!(immediate_deadline <= Instant::now() + Duration::from_millis(5));
 		task.on_state_save_tick().await;
 		wait_for_count(&save_ticks, 2).await;
 		wait_for_state(&ctx, &[2]).await;
diff --git a/rivetkit-rust/packages/rivetkit-sqlite-types/Cargo.toml b/rivetkit-rust/packages/rivetkit-sqlite-types/Cargo.toml
new file mode 100644
index 0000000000..2b3e19d504
--- /dev/null
+++ b/rivetkit-rust/packages/rivetkit-sqlite-types/Cargo.toml
@@ -0,0 +1,11 @@
+[package]
+name = "rivetkit-sqlite-types"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+edition.workspace = true
+workspace = "../../../"
+description = "Shared SQLite execution types for RivetKit"
+
+[lib]
+crate-type = ["lib"]
diff --git a/rivetkit-rust/packages/rivetkit-sqlite-types/src/lib.rs b/rivetkit-rust/packages/rivetkit-sqlite-types/src/lib.rs
new file mode 100644
index 0000000000..7e6839dcf5
--- /dev/null
+++ b/rivetkit-rust/packages/rivetkit-sqlite-types/src/lib.rs
@@ -0,0 +1,110 @@
+//! Shared SQLite execution types for local and remote RivetKit backends.
+
+#[derive(Clone, Debug, PartialEq)]
+pub enum BindParam {
+	Null,
+	Integer(i64),
+	Float(f64),
+	Text(String),
+	Blob(Vec<u8>),
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct ExecResult {
+	pub changes: i64,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct QueryResult {
+	pub columns: Vec<String>,
+	pub rows: Vec<Vec<ColumnValue>>,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum ExecuteRoute {
+	Read,
+	Write,
+	WriteFallback,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct ExecuteResult {
+	pub columns: Vec<String>,
+	pub rows: Vec<Vec<ColumnValue>>,
+	pub changes: i64,
+	pub last_insert_row_id: Option<i64>,
+	pub route: ExecuteRoute,
+}
+
+impl ExecuteResult {
+	pub fn into_query_result(self) -> QueryResult {
+		QueryResult {
+			columns: self.columns,
+			rows: self.rows,
+		}
+	}
+
+	pub fn into_exec_result(self) -> ExecResult {
+		ExecResult {
+			changes: self.changes,
+		}
+	}
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub enum ColumnValue {
+	Null,
+	Integer(i64),
+	Float(f64),
+	Text(String),
+	Blob(Vec<u8>),
+}
+
+#[cfg(test)]
+mod tests {
+	use super::{ColumnValue, ExecuteResult, ExecuteRoute};
+
+	#[test]
+	fn execute_result_preserves_result_and_route_metadata() {
+		let result = ExecuteResult {
+			columns: vec!["id".to_owned(), "name".to_owned()],
+			rows: vec![vec![
+				ColumnValue::Integer(7),
+				ColumnValue::Text("alpha".to_owned()),
+			]],
+			changes: 3,
+			last_insert_row_id: Some(42),
+			route: ExecuteRoute::WriteFallback,
+		};
+
+		assert_eq!(result.columns, vec!["id", "name"]);
+		assert_eq!(
+			result.rows,
+			vec![vec![
+				ColumnValue::Integer(7),
+				ColumnValue::Text("alpha".to_owned())
+			]]
+		);
+		assert_eq!(result.changes, 3);
+		assert_eq!(result.last_insert_row_id, Some(42));
+		assert_eq!(result.route, ExecuteRoute::WriteFallback);
+	}
+
+	#[test]
+	fn execute_result_projects_query_and_exec_results() {
+		let result = ExecuteResult {
+			columns: vec!["count".to_owned()],
+			rows: vec![vec![ColumnValue::Integer(9)]],
+			changes: 2,
+			last_insert_row_id: Some(10),
+			route: ExecuteRoute::Write,
+		};
+
+		let query_result = result.clone().into_query_result();
+		assert_eq!(query_result.columns, vec!["count"]);
+		assert_eq!(query_result.rows, vec![vec![ColumnValue::Integer(9)]]);
+
+		let exec_result = result.into_exec_result();
+		assert_eq!(exec_result.changes, 2);
+	}
+}
diff --git a/rivetkit-rust/packages/rivetkit-sqlite/Cargo.toml b/rivetkit-rust/packages/rivetkit-sqlite/Cargo.toml
index e9cff9ba84..58d5606de0 100644
--- a/rivetkit-rust/packages/rivetkit-sqlite/Cargo.toml
+++ b/rivetkit-rust/packages/rivetkit-sqlite/Cargo.toml
@@ -13,11 +13,12 @@ crate-type = ["lib"]
 [dependencies]
 anyhow.workspace = true
 libsqlite3-sys = { version = "0.30", features = ["bundled"] }
-rivet-envoy-client.workspace = true
+rivet-envoy-client = { workspace = true, features = ["native-transport"] }
 tokio.workspace = true
 tracing.workspace = true
 getrandom = "0.2"
 rivet-envoy-protocol.workspace = true
+rivetkit-sqlite-types.workspace = true
 moka = { version = "0.12", default-features = false, features = ["sync"] }
 parking_lot.workspace = true
 
diff --git a/rivetkit-rust/packages/rivetkit-sqlite/src/database.rs b/rivetkit-rust/packages/rivetkit-sqlite/src/database.rs
index 66ecaae91f..3ca29d2d5e 100644
--- a/rivetkit-rust/packages/rivetkit-sqlite/src/database.rs
+++ b/rivetkit-rust/packages/rivetkit-sqlite/src/database.rs
@@ -2,7 +2,6 @@ use std::sync::Arc;
 
 use anyhow::{Result, anyhow};
 use rivet_envoy_client::handle::EnvoyHandle;
-use rivet_envoy_protocol as protocol;
 use tokio::runtime::Handle;
 
 use crate::{
@@ -38,23 +37,20 @@ pub fn vfs_name_for_actor_database(actor_id: &str, generation: u64) -> String {
 pub async fn open_database_from_envoy(
 	handle: EnvoyHandle,
 	actor_id: String,
-	startup_data: Option<protocol::SqliteStartupData>,
+	generation: u64,
 	rt_handle: Handle,
 	metrics: Option<Arc<dyn SqliteVfsMetrics>>,
 ) -> Result<NativeDatabaseHandle> {
-	let startup =
-		startup_data.ok_or_else(|| anyhow!("missing sqlite startup data for actor {actor_id}"))?;
-	let vfs_name = vfs_name_for_actor_database(&actor_id, startup.generation);
-	let vfs = SqliteVfs::register(
+	let vfs_name = vfs_name_for_actor_database(&actor_id, generation);
+	let vfs = Arc::new(SqliteVfs::register(
 		&vfs_name,
 		handle,
 		actor_id.clone(),
 		rt_handle,
-		startup,
 		VfsConfig::default(),
 		metrics.clone(),
 	)
-	.map_err(|e| anyhow!("failed to register sqlite VFS: {e}"))?;
+	.map_err(|e| anyhow!("failed to register sqlite VFS: {e}"))?);
 
 	let native_db = NativeDatabaseHandle::new_with_metrics(
 		vfs,
diff --git a/rivetkit-rust/packages/rivetkit-sqlite/src/lib.rs b/rivetkit-rust/packages/rivetkit-sqlite/src/lib.rs
index 73bfda64ad..5b49adb529 100644
--- a/rivetkit-rust/packages/rivetkit-sqlite/src/lib.rs
+++ b/rivetkit-rust/packages/rivetkit-sqlite/src/lib.rs
@@ -27,4 +27,6 @@ pub mod optimization_flags;
 pub mod query;
 
 /// Custom SQLite VFS for actor-side sqlite-storage transport.
+
+pub use rivetkit_sqlite_types as types;
 pub mod vfs;
diff --git a/rivetkit-rust/packages/rivetkit-sqlite/src/optimization_flags.rs b/rivetkit-rust/packages/rivetkit-sqlite/src/optimization_flags.rs
index eb2caa7946..1f1b7050ca 100644
--- a/rivetkit-rust/packages/rivetkit-sqlite/src/optimization_flags.rs
+++ b/rivetkit-rust/packages/rivetkit-sqlite/src/optimization_flags.rs
@@ -14,6 +14,7 @@ pub const PRELOAD_HINTS_ON_OPEN_ENV: &str = "RIVETKIT_SQLITE_OPT_PRELOAD_HINTS_O
 pub const PRELOAD_HINT_HOT_PAGES_ENV: &str = "RIVETKIT_SQLITE_OPT_PRELOAD_HINT_HOT_PAGES";
 pub const PRELOAD_HINT_EARLY_PAGES_ENV: &str = "RIVETKIT_SQLITE_OPT_PRELOAD_HINT_EARLY_PAGES";
 pub const PRELOAD_HINT_SCAN_RANGES_ENV: &str = "RIVETKIT_SQLITE_OPT_PRELOAD_HINT_SCAN_RANGES";
+pub const DEDUP_GET_PAGES_META_ENV: &str = "RIVETKIT_SQLITE_OPT_DEDUP_GET_PAGES_META";
 pub const CACHE_GET_PAGES_VALIDATION_ENV: &str = "RIVETKIT_SQLITE_OPT_CACHE_GET_PAGES_VALIDATION";
 pub const RANGE_READS_ENV: &str = "RIVETKIT_SQLITE_OPT_RANGE_READS";
 pub const BATCH_CHUNK_READS_ENV: &str = "RIVETKIT_SQLITE_OPT_BATCH_CHUNK_READS";
@@ -98,6 +99,7 @@ pub struct SqliteOptimizationFlags {
 	pub preload_hint_hot_pages: bool,
 	pub preload_hint_early_pages: bool,
 	pub preload_hint_scan_ranges: bool,
+	pub dedup_get_pages_meta: bool,
 	pub cache_get_pages_validation: bool,
 	pub range_reads: bool,
 	pub batch_chunk_reads: bool,
@@ -126,6 +128,7 @@ impl Default for SqliteOptimizationFlags {
 			preload_hint_hot_pages: true,
 			preload_hint_early_pages: true,
 			preload_hint_scan_ranges: true,
+			dedup_get_pages_meta: true,
 			cache_get_pages_validation: true,
 			range_reads: true,
 			batch_chunk_reads: true,
@@ -181,6 +184,7 @@ impl SqliteOptimizationFlags {
 			preload_hint_scan_ranges: enabled_by_default(
 				read_env(PRELOAD_HINT_SCAN_RANGES_ENV).as_deref(),
 			),
+			dedup_get_pages_meta: enabled_by_default(read_env(DEDUP_GET_PAGES_META_ENV).as_deref()),
 			cache_get_pages_validation: enabled_by_default(
 				read_env(CACHE_GET_PAGES_VALIDATION_ENV).as_deref(),
 			),
@@ -236,7 +240,6 @@ fn enabled_by_default(value: Option<&str>) -> bool {
 		_ => true,
 	}
 }
-
 fn usize_bounded_by_default(value: Option<&str>, default: usize, max: usize) -> usize {
 	value
 		.and_then(|value| value.trim().parse::<usize>().ok())
diff --git a/rivetkit-rust/packages/rivetkit-sqlite/src/query.rs b/rivetkit-rust/packages/rivetkit-sqlite/src/query.rs
index 177a4d9d68..77f1294a82 100644
--- a/rivetkit-rust/packages/rivetkit-sqlite/src/query.rs
+++ b/rivetkit-rust/packages/rivetkit-sqlite/src/query.rs
@@ -20,51 +20,9 @@ use libsqlite3_sys::{
 	sqlite3_column_type, sqlite3_errmsg, sqlite3_finalize, sqlite3_last_insert_rowid,
 	sqlite3_prepare_v2, sqlite3_set_authorizer, sqlite3_step, sqlite3_stmt_readonly,
 };
-
-#[derive(Clone, Debug, PartialEq)]
-pub enum BindParam {
-	Null,
-	Integer(i64),
-	Float(f64),
-	Text(String),
-	Blob(Vec<u8>),
-}
-
-#[derive(Clone, Debug, PartialEq)]
-pub struct ExecResult {
-	pub changes: i64,
-}
-
-#[derive(Clone, Debug, PartialEq)]
-pub struct QueryResult {
-	pub columns: Vec<String>,
-	pub rows: Vec<Vec<ColumnValue>>,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum ExecuteRoute {
-	Read,
-	Write,
-	WriteFallback,
-}
-
-#[derive(Clone, Debug, PartialEq)]
-pub struct ExecuteResult {
-	pub columns: Vec<String>,
-	pub rows: Vec<Vec<ColumnValue>>,
-	pub changes: i64,
-	pub last_insert_row_id: Option<i64>,
-	pub route: ExecuteRoute,
-}
-
-#[derive(Clone, Debug, PartialEq)]
-pub enum ColumnValue {
-	Null,
-	Integer(i64),
-	Float(f64),
-	Text(String),
-	Blob(Vec<u8>),
-}
+pub use rivetkit_sqlite_types::{
+	BindParam, ColumnValue, ExecResult, ExecuteResult, ExecuteRoute, QueryResult,
+};
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct StatementClassification {
@@ -107,6 +65,16 @@ impl StatementAuthorizerSummary {
 	}
 }
 
+pub fn reader_authorizer_allows_classification(
+	classification: &StatementClassification,
+) -> bool {
+	classification
+		.authorizer
+		.actions
+		.iter()
+		.all(reader_authorizer_allows_action)
+}
+
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct StatementAuthorizerAction {
 	pub kind: StatementAuthorizerActionKind,
@@ -681,36 +649,42 @@ unsafe extern "C" fn reader_authorizer_action(
 	let first_arg = unsafe { optional_c_string(first_arg) };
 	let second_arg = unsafe { optional_c_string(second_arg) };
 
-	if kind.is_data_write()
-		|| kind.is_schema_write()
-		|| kind.is_temp_schema_write()
-		|| (kind.is_data_write() && database_name.as_deref() == Some("temp"))
+	if reader_authorizer_allows_action(&StatementAuthorizerAction {
+		kind,
+		first_arg,
+		second_arg,
+		database_name,
+		trigger_or_view_name: None,
+	}) {
+		SQLITE_OK
+	} else {
+		SQLITE_DENY
+	}
+}
+
+fn reader_authorizer_allows_action(action: &StatementAuthorizerAction) -> bool {
+	if action.kind.is_data_write()
+		|| action.kind.is_schema_write()
+		|| action.kind.is_temp_schema_write()
+		|| (action.kind.is_data_write() && action.database_name.as_deref() == Some("temp"))
 	{
-		return SQLITE_DENY;
+		return false;
 	}
 
-	match kind {
+	match action.kind {
 		StatementAuthorizerActionKind::Transaction
 		| StatementAuthorizerActionKind::Savepoint
 		| StatementAuthorizerActionKind::Attach
-		| StatementAuthorizerActionKind::Detach => SQLITE_DENY,
+		| StatementAuthorizerActionKind::Detach => false,
 		StatementAuthorizerActionKind::Pragma => {
-			if reader_pragma_allowed(first_arg.as_deref(), second_arg.as_deref()) {
-				SQLITE_OK
-			} else {
-				SQLITE_DENY
-			}
+			reader_pragma_allowed(action.first_arg.as_deref(), action.second_arg.as_deref())
 		}
 		StatementAuthorizerActionKind::Function => {
-			if reader_function_allowed(first_arg.as_deref(), second_arg.as_deref()) {
-				SQLITE_OK
-			} else {
-				SQLITE_DENY
-			}
+			reader_function_allowed(action.first_arg.as_deref(), action.second_arg.as_deref())
 		}
 		StatementAuthorizerActionKind::Read
 		| StatementAuthorizerActionKind::Select
-		| StatementAuthorizerActionKind::Other(_) => SQLITE_OK,
+		| StatementAuthorizerActionKind::Other(_) => true,
 		StatementAuthorizerActionKind::Insert
 		| StatementAuthorizerActionKind::Update
 		| StatementAuthorizerActionKind::Delete
@@ -734,7 +708,7 @@ unsafe extern "C" fn reader_authorizer_action(
 		| StatementAuthorizerActionKind::DropTempView
 		| StatementAuthorizerActionKind::AlterTable
 		| StatementAuthorizerActionKind::Reindex
-		| StatementAuthorizerActionKind::Analyze => SQLITE_DENY,
+		| StatementAuthorizerActionKind::Analyze => false,
 	}
 }
 
@@ -742,12 +716,25 @@ fn reader_pragma_allowed(first_arg: Option<&str>, second_arg: Option<&str>) -> b
 	let Some(name) = first_arg else {
 		return false;
 	};
+
+	let name = name.to_ascii_lowercase();
 	if second_arg.is_some() {
-		return false;
+		return matches!(
+			name.as_str(),
+			"foreign_key_check"
+				| "foreign_key_list"
+				| "index_info"
+				| "index_list"
+				| "index_xinfo"
+				| "integrity_check"
+				| "quick_check"
+				| "table_info"
+				| "table_xinfo"
+		);
 	}
 
 	matches!(
-		name.to_ascii_lowercase().as_str(),
+		name.as_str(),
 		"application_id"
 			| "busy_timeout"
 			| "cache_size"
diff --git a/rivetkit-rust/packages/rivetkit-sqlite/src/vfs.rs b/rivetkit-rust/packages/rivetkit-sqlite/src/vfs.rs
index 61ac58504e..4d46347ac9 100644
--- a/rivetkit-rust/packages/rivetkit-sqlite/src/vfs.rs
+++ b/rivetkit-rust/packages/rivetkit-sqlite/src/vfs.rs
@@ -353,6 +353,28 @@ pub trait SqliteVfsMetrics: Send + Sync {
 		_total_ns: u64,
 	) {
 	}
+
+	fn set_read_pool_active_readers(&self, _readers: u64) {}
+
+	fn set_read_pool_idle_readers(&self, _readers: u64) {}
+
+	fn observe_read_pool_read_wait(&self, _duration: Duration) {}
+
+	fn observe_read_pool_write_wait(&self, _duration: Duration) {}
+
+	fn record_read_pool_routed_read_query(&self) {}
+
+	fn record_read_pool_write_fallback_query(&self) {}
+
+	fn observe_read_pool_manual_transaction(&self, _duration: Duration) {}
+
+	fn record_read_pool_reader_open(&self) {}
+
+	fn record_read_pool_reader_close(&self, _count: u64) {}
+
+	fn record_read_pool_rejected_reader_mutation(&self) {}
+
+	fn record_read_pool_mode_transition(&self, _from: &str, _to: &str) {}
 }
 
 #[derive(Debug, Clone, Copy, Default)]
@@ -503,11 +525,14 @@ struct SqliteVfsRegistration {
 
 pub struct NativeDatabase {
 	db: *mut sqlite3,
-	_vfs: SqliteVfs,
+	_vfs: NativeVfsHandle,
 }
 
 unsafe impl Send for NativeDatabase {}
 
+pub type NativeVfsHandle = Arc<SqliteVfs>;
+pub type NativeConnection = NativeDatabase;
+
 impl PrefetchPredictor {
 	fn record(&mut self, pgno: u32) {
 		if let Some(last_pgno) = self.last_pgno {
@@ -939,7 +964,7 @@ impl VfsContext {
 		self.last_error.lock().clone()
 	}
 
-	fn take_last_error(&self) -> Option<String> {
+	pub(crate) fn take_last_error(&self) -> Option<String> {
 		self.last_error.lock().take()
 	}
 
@@ -1055,7 +1080,7 @@ impl VfsContext {
 		self.state.write().dead = true;
 	}
 
-	fn snapshot_preload_hints(&self) -> VfsPreloadHintSnapshot {
+	pub(crate) fn snapshot_preload_hints(&self) -> VfsPreloadHintSnapshot {
 		if !self.config.recent_page_hints {
 			return VfsPreloadHintSnapshot::default();
 		}
@@ -2453,7 +2478,7 @@ impl SqliteVfs {
 		)
 	}
 
-	fn take_last_error(&self) -> Option<String> {
+	pub(crate) fn take_last_error(&self) -> Option<String> {
 		self.ctx.take_last_error()
 	}
 
@@ -2461,8 +2486,8 @@ impl SqliteVfs {
 		self.ctx.clone_last_error()
 	}
 
-	fn snapshot_preload_hints(&self) -> VfsPreloadHintSnapshot {
-		unsafe { (*self.ctx_ptr).snapshot_preload_hints() }
+	pub(crate) fn snapshot_preload_hints(&self) -> VfsPreloadHintSnapshot {
+		self.ctx.snapshot_preload_hints()
 	}
 
 	fn register_with_transport(
@@ -2631,6 +2656,19 @@ pub fn open_database(
 	vfs: SqliteVfs,
 	file_name: &str,
 ) -> std::result::Result<NativeDatabase, String> {
+	open_connection(Arc::new(vfs), file_name, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE)
+		.and_then(|connection| {
+			configure_connection_for_database(connection.as_ptr(), &connection._vfs, file_name)?;
+			verify_batch_atomic_writes(connection.as_ptr(), &connection._vfs, file_name)?;
+			Ok(connection)
+		})
+}
+
+pub fn open_connection(
+	vfs: NativeVfsHandle,
+	file_name: &str,
+	flags: c_int,
+) -> std::result::Result<NativeConnection, String> {
 	let c_name = CString::new(file_name).map_err(|err| err.to_string())?;
 	let mut db: *mut sqlite3 = ptr::null_mut();
 
@@ -2638,7 +2676,7 @@ pub fn open_database(
 		sqlite3_open_v2(
 			c_name.as_ptr(),
 			&mut db,
-			SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE,
+			flags,
 			vfs.name_ptr(),
 		)
 	};
@@ -2659,6 +2697,17 @@ pub fn open_database(
 		return Err(format!("sqlite3_open_v2 failed with code {rc}: {message}"));
 	}
 
+	Ok(NativeDatabase {
+		db,
+		_vfs: vfs,
+	})
+}
+
+pub fn configure_connection_for_database(
+	db: *mut sqlite3,
+	vfs: &SqliteVfs,
+	file_name: &str,
+) -> std::result::Result<(), String> {
 	for pragma in &[
 		"PRAGMA page_size = 4096;",
 		"PRAGMA journal_mode = DELETE;",
@@ -2675,13 +2724,18 @@ pub fn open_database(
 				last_error = ?vfs.clone_last_error(),
 				"failed to configure sqlite database"
 			);
-			unsafe {
-				sqlite3_close(db);
-			}
 			return Err(err);
 		}
 	}
 
+	Ok(())
+}
+
+pub fn verify_batch_atomic_writes(
+	db: *mut sqlite3,
+	vfs: &SqliteVfs,
+	file_name: &str,
+) -> std::result::Result<(), String> {
 	#[cfg(test)]
 	let assert_batch_atomic = vfs.ctx.config.assert_batch_atomic;
 	#[cfg(not(test))]
@@ -2694,14 +2748,11 @@ pub fn open_database(
 				last_error = ?vfs.clone_last_error(),
 				"failed to verify sqlite batch atomic writes"
 			);
-			unsafe {
-				sqlite3_close(db);
-			}
 			return Err(err);
 		}
 	}
 
-	Ok(NativeDatabase { db, _vfs: vfs })
+	Ok(())
 }
 
 #[cfg(test)]
diff --git a/rivetkit-rust/packages/rivetkit-sqlite/tests/remote_execution_parity.rs b/rivetkit-rust/packages/rivetkit-sqlite/tests/remote_execution_parity.rs
new file mode 100644
index 0000000000..c5e9339662
--- /dev/null
+++ b/rivetkit-rust/packages/rivetkit-sqlite/tests/remote_execution_parity.rs
@@ -0,0 +1,261 @@
+use std::sync::Arc;
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use anyhow::Result;
+use rivetkit_sqlite::database::{NativeDatabaseHandle, open_database_from_engine};
+use rivetkit_sqlite::types::{BindParam, ColumnValue, ExecuteRoute};
+use sqlite_storage::engine::SqliteEngine;
+use sqlite_storage::open::OpenConfig;
+use tempfile::TempDir;
+use universaldb::Subspace;
+use universaldb::driver::RocksDbDatabaseDriver;
+
+struct RemoteDbHarness {
+	_db_dir: TempDir,
+	engine: Arc<SqliteEngine>,
+	actor_id: String,
+	generation: u64,
+	db: NativeDatabaseHandle,
+}
+
+impl RemoteDbHarness {
+	async fn open(prefix: &str, now_ms: i64) -> Result<Self> {
+		let actor_id = unique_actor_id(prefix);
+		let db_dir = tempfile::tempdir()?;
+		let driver = RocksDbDatabaseDriver::new(db_dir.path().to_path_buf()).await?;
+		let db = universaldb::Database::new(Arc::new(driver));
+		let (engine, _compaction_rx) =
+			SqliteEngine::new(db, Subspace::new(&(prefix, &actor_id)));
+		let engine = Arc::new(engine);
+		let opened = engine.open(&actor_id, OpenConfig::new(now_ms)).await?;
+		let db = open_database_from_engine(
+			Arc::clone(&engine),
+			actor_id.clone(),
+			opened.generation,
+			tokio::runtime::Handle::current(),
+			None,
+		)
+		.await?;
+
+		Ok(Self {
+			_db_dir: db_dir,
+			engine,
+			actor_id,
+			generation: opened.generation,
+			db,
+		})
+	}
+
+	async fn reopen(&mut self, now_ms: i64) -> Result<()> {
+		self.db.close().await?;
+		self.engine.close(&self.actor_id, self.generation).await?;
+		let opened = self.engine.open(&self.actor_id, OpenConfig::new(now_ms)).await?;
+		self.generation = opened.generation;
+		self.db = open_database_from_engine(
+			Arc::clone(&self.engine),
+			self.actor_id.clone(),
+			opened.generation,
+			tokio::runtime::Handle::current(),
+			None,
+		)
+		.await?;
+		Ok(())
+	}
+
+	async fn close(self) -> Result<()> {
+		self.db.close().await?;
+		self.engine.close(&self.actor_id, self.generation).await?;
+		Ok(())
+	}
+}
+
+#[tokio::test]
+async fn remote_migration_order_persists_across_reopen() -> Result<()> {
+	let mut harness = RemoteDbHarness::open("remote-migration-order", 1).await?;
+
+	harness
+		.db
+		.execute_write(
+			"CREATE TABLE __rivet_migrations(id INTEGER PRIMARY KEY, name TEXT NOT NULL);"
+				.to_string(),
+			None,
+		)
+		.await?;
+	harness
+		.db
+		.execute_write(
+			"CREATE TABLE items(id INTEGER PRIMARY KEY, value TEXT NOT NULL);".to_string(),
+			None,
+		)
+		.await?;
+	harness
+		.db
+		.execute_write(
+			"INSERT INTO __rivet_migrations(id, name) VALUES (?, ?);".to_string(),
+			Some(vec![
+				BindParam::Integer(1),
+				BindParam::Text("create-items".to_string()),
+			]),
+		)
+		.await?;
+
+	let before_reopen = harness
+		.db
+		.execute(
+			"SELECT name FROM __rivet_migrations ORDER BY id;".to_string(),
+			None,
+		)
+		.await?;
+	assert_eq!(
+		before_reopen.rows,
+		vec![vec![ColumnValue::Text("create-items".to_string())]]
+	);
+
+	harness.reopen(2).await?;
+	let after_reopen = harness
+		.db
+		.execute(
+			"SELECT name FROM __rivet_migrations ORDER BY id;".to_string(),
+			None,
+		)
+		.await?;
+	assert_eq!(
+		after_reopen.rows,
+		vec![vec![ColumnValue::Text("create-items".to_string())]]
+	);
+
+	let table_check = harness
+		.db
+		.execute(
+			"SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'items';"
+				.to_string(),
+			None,
+		)
+		.await?;
+	assert_eq!(
+		table_check.rows,
+		vec![vec![ColumnValue::Text("items".to_string())]]
+	);
+
+	harness.close().await
+}
+
+#[tokio::test]
+async fn remote_execute_write_forces_writer_for_readonly_sql() -> Result<()> {
+	let harness = RemoteDbHarness::open("remote-execute-write", 1).await?;
+	harness
+		.db
+		.execute_write(
+			"CREATE TABLE force_writer(id INTEGER PRIMARY KEY);".to_string(),
+			None,
+		)
+		.await?;
+
+	let result = harness
+		.db
+		.execute_write("SELECT COUNT(*) FROM force_writer;".to_string(), None)
+		.await?;
+
+	assert_eq!(result.route, ExecuteRoute::Write);
+	assert_eq!(result.rows, vec![vec![ColumnValue::Integer(0)]]);
+
+	harness.close().await
+}
+
+#[tokio::test]
+async fn remote_manual_transactions_stay_on_writer_until_commit_or_rollback() -> Result<()> {
+	let harness = RemoteDbHarness::open("remote-manual-transactions", 1).await?;
+	harness
+		.db
+		.execute_write(
+			"CREATE TABLE tx_items(id INTEGER PRIMARY KEY, value TEXT NOT NULL);".to_string(),
+			None,
+		)
+		.await?;
+
+	harness.db.execute("BEGIN".to_string(), None).await?;
+	harness
+		.db
+		.execute(
+			"INSERT INTO tx_items(id, value) VALUES (1, 'committed');".to_string(),
+			None,
+		)
+		.await?;
+	let in_tx_read = harness
+		.db
+		.execute(
+			"SELECT COUNT(*) FROM tx_items WHERE value = 'committed';".to_string(),
+			None,
+		)
+		.await?;
+	assert_eq!(in_tx_read.route, ExecuteRoute::WriteFallback);
+	assert_eq!(in_tx_read.rows, vec![vec![ColumnValue::Integer(1)]]);
+	harness.db.execute("COMMIT".to_string(), None).await?;
+
+	harness.db.execute("BEGIN".to_string(), None).await?;
+	harness
+		.db
+		.execute(
+			"INSERT INTO tx_items(id, value) VALUES (2, 'rolled-back');".to_string(),
+			None,
+		)
+		.await?;
+	harness.db.execute("ROLLBACK".to_string(), None).await?;
+
+	harness.db.execute("BEGIN".to_string(), None).await?;
+	harness
+		.db
+		.execute(
+			"INSERT INTO tx_items(id, value) VALUES (3, 'savepoint-base');".to_string(),
+			None,
+		)
+		.await?;
+	harness
+		.db
+		.execute("SAVEPOINT patch".to_string(), None)
+		.await?;
+	harness
+		.db
+		.execute(
+			"UPDATE tx_items SET value = 'patched' WHERE id = 3;".to_string(),
+			None,
+		)
+		.await?;
+	harness
+		.db
+		.execute("ROLLBACK TO patch".to_string(), None)
+		.await?;
+	harness
+		.db
+		.execute("RELEASE patch".to_string(), None)
+		.await?;
+	harness.db.execute("COMMIT".to_string(), None).await?;
+
+	let rows = harness
+		.db
+		.execute("SELECT id, value FROM tx_items ORDER BY id;".to_string(), None)
+		.await?;
+	assert_eq!(
+		rows.rows,
+		vec![
+			vec![
+				ColumnValue::Integer(1),
+				ColumnValue::Text("committed".to_string())
+			],
+			vec![
+				ColumnValue::Integer(3),
+				ColumnValue::Text("savepoint-base".to_string())
+			],
+		]
+	);
+
+	harness.close().await
+}
+
+fn unique_actor_id(prefix: &str) -> String {
+	let nanos = SystemTime::now()
+		.duration_since(UNIX_EPOCH)
+		.expect("system time should be after epoch")
+		.as_nanos();
+	format!("{prefix}-{nanos}")
+}
diff --git a/rivetkit-rust/packages/rivetkit-sqlite/tests/statement_classification.rs b/rivetkit-rust/packages/rivetkit-sqlite/tests/statement_classification.rs
index 244f27f479..14a22765ca 100644
--- a/rivetkit-rust/packages/rivetkit-sqlite/tests/statement_classification.rs
+++ b/rivetkit-rust/packages/rivetkit-sqlite/tests/statement_classification.rs
@@ -3,7 +3,8 @@ use std::ptr;
 
 use libsqlite3_sys::{SQLITE_OK, sqlite3, sqlite3_close, sqlite3_open};
 use rivetkit_sqlite::query::{
-	StatementAuthorizerActionKind, classify_statement, exec_statements,
+	ExecuteRoute, StatementAuthorizerActionKind, classify_statement, exec_statements,
+	execute_single_statement, install_reader_authorizer,
 };
 
 struct MemoryDb(*mut sqlite3);
@@ -58,6 +59,28 @@ fn readonly_pragma_is_reader_eligible_and_captures_pragma_usage() {
 	assert!(classification.authorizer.pragma_usage);
 }
 
+#[test]
+fn readonly_schema_pragma_with_argument_is_allowed_on_reader() {
+	let db = MemoryDb::open();
+	exec_statements(
+		db.as_ptr(),
+		"CREATE TABLE items(id INTEGER PRIMARY KEY, label TEXT);",
+	)
+	.unwrap();
+
+	let classification = classify_statement(db.as_ptr(), "PRAGMA table_info(items)").unwrap();
+
+	assert!(classification.sqlite_readonly);
+	assert!(classification.reader_eligible());
+	assert!(classification.authorizer.pragma_usage);
+	install_reader_authorizer(db.as_ptr()).unwrap();
+	let result =
+		execute_single_statement(db.as_ptr(), "PRAGMA table_info(items)", None, ExecuteRoute::Read)
+			.unwrap();
+	assert!(result.columns.iter().any(|column| column == "name"));
+	assert_eq!(result.rows.len(), 2);
+}
+
 #[test]
 fn mutating_pragma_is_not_reader_eligible() {
 	let db = MemoryDb::open();
diff --git a/rivetkit-rust/packages/rivetkit/src/event.rs b/rivetkit-rust/packages/rivetkit/src/event.rs
index 80f82400b4..35910c5880 100644
--- a/rivetkit-rust/packages/rivetkit/src/event.rs
+++ b/rivetkit-rust/packages/rivetkit/src/event.rs
@@ -70,7 +70,12 @@ impl<A: Actor> Event<A> {
 				timeout_ms,
 				reply: Some(reply),
 			}),
-			ActorEvent::WebSocketOpen { ws, request, reply } => Self::WebSocketOpen(WsOpen {
+			ActorEvent::WebSocketOpen {
+				conn: _conn,
+				ws,
+				request,
+				reply,
+			} => Self::WebSocketOpen(WsOpen {
 				ws,
 				request,
 				reply: Some(reply),
diff --git a/rivetkit-typescript/AGENTS.md b/rivetkit-typescript/AGENTS.md
new file mode 120000
index 0000000000..681311eb9c
--- /dev/null
+++ b/rivetkit-typescript/AGENTS.md
@@ -0,0 +1 @@
+CLAUDE.md
\ No newline at end of file
diff --git a/rivetkit-typescript/CLAUDE.md b/rivetkit-typescript/CLAUDE.md
index bcaa2ea1dd..870c8f7ad9 100644
--- a/rivetkit-typescript/CLAUDE.md
+++ b/rivetkit-typescript/CLAUDE.md
@@ -12,6 +12,16 @@
 - Core drivers must remain SQLite-agnostic. Any SQLite-specific wiring belongs behind the native database provider boundary.
 - Before deleting a `rivetkit/*` package export, grep `examples/`, `website/`, and `frontend/` for self-imports. Those consumers are part of the supported package surface on this branch.
 
+## Runtime Boundary
+
+- Select runtime behavior from `CoreRuntime.kind`, not `instanceof` adapter classes; NAPI maps to the native runtime kind and wasm maps to wasm.
+- Keep `CoreRuntime` SQL methods on the portable `RuntimeSql*` structs from `packages/rivetkit/src/registry/runtime.ts`; NAPI-only `Buffer` conversion belongs inside `NapiCoreRuntime`.
+- Keep `RuntimeSqlBindParam` variants exact and `RuntimeSqlExecuteResult.route` limited to `read`, `write`, or `writeFallback`; normalize generated adapter output before returning it.
+- Keep `CoreRuntime` byte payloads on `RuntimeBytes`/`Uint8Array`; NAPI-only `Buffer` conversion belongs inside `NapiCoreRuntime`.
+- Shared actor glue in `packages/rivetkit/src/registry/native.ts` should construct `RuntimeBytes`/`Uint8Array`; leave `Buffer` creation to `NapiCoreRuntime`.
+- Wasm bindings for NAPI-supported runtime APIs should forward to `rivetkit-core`; avoid placeholder returns that break runtime parity.
+- Use public `sqlite` config for runtime SQLite backend selection; wasm defaults unset SQLite to remote and must reject local before runtime construction.
+
 ## Native SQLite v2
 
 - If `packages/rivetkit` still needs a BARE codec after schema-generator removal, vendor only the live generated modules under `src/common/bare/` and import them from source instead of `dist/schemas/**`.
@@ -112,10 +122,25 @@ cd rivetkit-typescript/packages/rivetkit
 
 The script installs each drizzle-orm version, typechecks `scripts/drizzle-compat-smoke.ts` against the `rivetkit/db/drizzle` public surface, and reports pass/fail per version. It restores the original package.json and lockfile on exit. Update the `DEFAULT_VERSIONS` array in the script when adding support for new drizzle releases.
 
+## Test Harness
+
+- Shared local `rivet-engine` lifecycle for TypeScript tests lives in `packages/rivetkit/tests/shared-engine.ts`; driver and platform tests should reuse it instead of launching a separate engine.
+- Platform wasm smoke tests should reuse `packages/rivetkit/tests/platforms/shared-registry.ts` for the raw-SQL SQLite counter actor and public wasm `setup(...)` shape.
+- Platform smoke tests should use `packages/rivetkit/tests/platforms/shared-platform-harness.ts` for serverless runner setup, app process logging, temp app dirs, health checks, and pinned `pnpm dlx` CLI launches.
+
 ## Cloudflare Workers Compatibility
 
 Cloudflare Workers forbid `setTimeout`, `fetch`, `connect`, and other async I/O in global scope (outside a request handler). The `Registry` constructor runs in global scope, so it must never call these APIs unconditionally. Any deferred work (e.g., prestarting the runtime) must be gated behind a synchronous config check before scheduling a timer. See `packages/rivetkit/src/registry/index.ts` for the pattern: the outer `if` guards `setTimeout`, and the inner `if` re-checks after the tick to pick up late config mutations.
 
+## Wasm Binding Package
+
+- Treat `packages/rivetkit-wasm/pkg/` as wasm-pack output; commit source and build scripts, then regenerate package artifacts during package builds.
+- Export wasm raw WebSocket handles as `WebSocketHandle`, not `WebSocket`, because wasm-bindgen rejects classes that shadow the host global.
+- Keep wasm runtime adapter byte normalization on `Uint8Array`; do not add Node `Buffer` dependencies to `packages/rivetkit/src/registry/wasm-runtime.ts`.
+- Pass platform wasm bindings through `setup({ wasm: { bindings, initInput } })`; do not add hidden `globalThis` binding hooks.
+- Wasm `CoreRegistry` serverless startup must use a `BuildingServerless` waiter state; shutdown during build must wake waiters and drain any newly built runtime.
+- Run `pnpm --filter @rivetkit/rivetkit-wasm run check:package` after wasm package export or files changes to verify the published tarball includes the root entrypoint and wasm artifacts.
+
 ## Workflow Context Actor Access Guards
 
 - Guard all side-effectful `#runCtx` access in `ActorWorkflowContext` (`packages/rivetkit/src/workflow/context.ts`) with `#ensureActorAccess`; only read-only properties (for example `actorId` and `log`) are exempt.
diff --git a/rivetkit-typescript/packages/rivetkit-napi/index.d.ts b/rivetkit-typescript/packages/rivetkit-napi/index.d.ts
index 7b4e83b842..6508429ca2 100644
--- a/rivetkit-typescript/packages/rivetkit-napi/index.d.ts
+++ b/rivetkit-typescript/packages/rivetkit-napi/index.d.ts
@@ -51,6 +51,7 @@ export interface JsActorConfig {
   name?: string
   icon?: string
   hasDatabase?: boolean
+  remoteSqlite?: boolean
   hasState?: boolean
   canHibernateWebsocket?: boolean
   stateSaveIntervalMs?: number
diff --git a/rivetkit-typescript/packages/rivetkit-napi/src/actor_factory.rs b/rivetkit-typescript/packages/rivetkit-napi/src/actor_factory.rs
index 2603fc37a1..6738642062 100644
--- a/rivetkit-typescript/packages/rivetkit-napi/src/actor_factory.rs
+++ b/rivetkit-typescript/packages/rivetkit-napi/src/actor_factory.rs
@@ -66,6 +66,7 @@ pub struct JsActorConfig {
 	pub name: Option<String>,
 	pub icon: Option<String>,
 	pub has_database: Option<bool>,
+	pub remote_sqlite: Option<bool>,
 	pub has_state: Option<bool>,
 	pub can_hibernate_websocket: Option<bool>,
 	pub state_save_interval_ms: Option<u32>,
@@ -1048,6 +1049,7 @@ impl From<JsActorConfig> for ActorConfigInput {
 			name: value.name,
 			icon: value.icon,
 			has_database: value.has_database,
+			remote_sqlite: value.remote_sqlite,
 			has_state: value.has_state,
 			can_hibernate_websocket: value.can_hibernate_websocket,
 			state_save_interval_ms: value.state_save_interval_ms,
diff --git a/rivetkit-typescript/packages/rivetkit-napi/src/registry.rs b/rivetkit-typescript/packages/rivetkit-napi/src/registry.rs
index a57804b66b..6ed3985d4e 100644
--- a/rivetkit-typescript/packages/rivetkit-napi/src/registry.rs
+++ b/rivetkit-typescript/packages/rivetkit-napi/src/registry.rs
@@ -175,13 +175,14 @@ impl CoreRegistry {
 					serverless_package_version: config.serverless_package_version,
 					serverless_client_endpoint: config.serverless_client_endpoint,
 					serverless_client_namespace: config.serverless_client_namespace,
-					serverless_client_token: config.serverless_client_token,
-					serverless_validate_endpoint: config.serverless_validate_endpoint,
-					serverless_max_start_payload_bytes: config.serverless_max_start_payload_bytes
-						as usize,
-				},
-				self.shutdown_token.clone(),
-			)
+						serverless_client_token: config.serverless_client_token,
+						serverless_validate_endpoint: config.serverless_validate_endpoint,
+						serverless_max_start_payload_bytes: config.serverless_max_start_payload_bytes
+							as usize,
+						serverless_cache_envoy: true,
+					},
+					self.shutdown_token.clone(),
+				)
 			.await
 			.map_err(napi_anyhow_error)
 	}
@@ -374,12 +375,13 @@ impl CoreRegistry {
 				serverless_package_version: config.serverless_package_version,
 				serverless_client_endpoint: config.serverless_client_endpoint,
 				serverless_client_namespace: config.serverless_client_namespace,
-				serverless_client_token: config.serverless_client_token,
-				serverless_validate_endpoint: config.serverless_validate_endpoint,
-				serverless_max_start_payload_bytes: config.serverless_max_start_payload_bytes
-					as usize,
-			})
-			.await;
+					serverless_client_token: config.serverless_client_token,
+					serverless_validate_endpoint: config.serverless_validate_endpoint,
+					serverless_max_start_payload_bytes: config.serverless_max_start_payload_bytes
+						as usize,
+					serverless_cache_envoy: true,
+				})
+				.await;
 
 		// Re-acquire the lock and re-check state. Shutdown may have run during
 		// the build. If so, tear down the freshly-built runtime rather than
diff --git a/rivetkit-typescript/packages/rivetkit-wasm/.npmignore b/rivetkit-typescript/packages/rivetkit-wasm/.npmignore
new file mode 100644
index 0000000000..075b6a416d
--- /dev/null
+++ b/rivetkit-typescript/packages/rivetkit-wasm/.npmignore
@@ -0,0 +1,5 @@
+node_modules/
+*.tgz
+
+!pkg/
+!pkg/**
diff --git a/rivetkit-typescript/packages/rivetkit-wasm/Cargo.toml b/rivetkit-typescript/packages/rivetkit-wasm/Cargo.toml
new file mode 100644
index 0000000000..d590e11f26
--- /dev/null
+++ b/rivetkit-typescript/packages/rivetkit-wasm/Cargo.toml
@@ -0,0 +1,26 @@
+[package]
+name = "rivetkit-wasm"
+version.workspace = true
+edition.workspace = true
+authors.workspace = true
+license.workspace = true
+autotests = false
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[dependencies]
+anyhow.workspace = true
+js-sys = "0.3"
+rivet-error.workspace = true
+rivetkit-core = { path = "../../../rivetkit-rust/packages/rivetkit-core", default-features = false, features = ["wasm-runtime", "sqlite-remote"] }
+serde.workspace = true
+serde_json.workspace = true
+serde-wasm-bindgen = "0.6"
+tokio-util.workspace = true
+wasm-bindgen = "0.2"
+wasm-bindgen-futures = "0.4"
+
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+console_error_panic_hook = "0.1"
+tokio = { version = "1.44.0", default-features = false, features = ["rt"] }
diff --git a/rivetkit-typescript/packages/rivetkit-wasm/index.d.ts b/rivetkit-typescript/packages/rivetkit-wasm/index.d.ts
new file mode 100644
index 0000000000..9e3da73c2b
--- /dev/null
+++ b/rivetkit-typescript/packages/rivetkit-wasm/index.d.ts
@@ -0,0 +1,2 @@
+export * from "./pkg/rivetkit_wasm.js";
+export { default } from "./pkg/rivetkit_wasm.js";
diff --git a/rivetkit-typescript/packages/rivetkit-wasm/index.js b/rivetkit-typescript/packages/rivetkit-wasm/index.js
new file mode 100644
index 0000000000..9e3da73c2b
--- /dev/null
+++ b/rivetkit-typescript/packages/rivetkit-wasm/index.js
@@ -0,0 +1,2 @@
+export * from "./pkg/rivetkit_wasm.js";
+export { default } from "./pkg/rivetkit_wasm.js";
diff --git a/rivetkit-typescript/packages/rivetkit-wasm/package.json b/rivetkit-typescript/packages/rivetkit-wasm/package.json
new file mode 100644
index 0000000000..7716e031a7
--- /dev/null
+++ b/rivetkit-typescript/packages/rivetkit-wasm/package.json
@@ -0,0 +1,41 @@
+{
+	"name": "@rivetkit/rivetkit-wasm",
+	"version": "2.3.0-rc.4",
+	"description": "WebAssembly bindings for RivetKit core on edge JavaScript runtimes",
+	"license": "Apache-2.0",
+	"type": "module",
+	"main": "index.js",
+	"types": "index.d.ts",
+	"exports": {
+		".": {
+			"types": "./index.d.ts",
+			"default": "./index.js"
+		},
+		"./rivetkit_wasm_bg.wasm": {
+			"default": "./pkg/rivetkit_wasm_bg.wasm"
+		}
+	},
+	"files": [
+		"index.js",
+		"index.d.ts",
+		"pkg/rivetkit_wasm.js",
+		"pkg/rivetkit_wasm.d.ts",
+		"pkg/rivetkit_wasm_bg.wasm",
+		"pkg/rivetkit_wasm_bg.wasm.d.ts",
+		"package.json",
+		"scripts/build.mjs",
+		"scripts/check-package.mjs"
+	],
+	"scripts": {
+		"build": "node scripts/build.mjs",
+		"build:cloudflare": "node scripts/build.mjs --target bundler --out-dir pkg-cloudflare",
+		"build:deno": "node scripts/build.mjs --target web --out-dir pkg-deno",
+		"check:package": "node scripts/check-package.mjs",
+		"check-types": "tsc --noEmit",
+		"check:wasm": "cargo check -p rivetkit-wasm --target wasm32-unknown-unknown",
+		"prepack": "node scripts/build.mjs"
+	},
+	"devDependencies": {
+		"typescript": "^5.9.2"
+	}
+}
diff --git a/rivetkit-typescript/packages/rivetkit-wasm/scripts/build.mjs b/rivetkit-typescript/packages/rivetkit-wasm/scripts/build.mjs
new file mode 100644
index 0000000000..f9d42eb3f2
--- /dev/null
+++ b/rivetkit-typescript/packages/rivetkit-wasm/scripts/build.mjs
@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+import { execFileSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const packageDir = dirname(dirname(fileURLToPath(import.meta.url)));
+const pkgDir = join(packageDir, "pkg");
+
+if (["1", "true"].includes(process.env.SKIP_WASM_BUILD ?? "")) {
+	const hasPkg = existsSync(join(pkgDir, "rivetkit_wasm.js"));
+	console.log(
+		hasPkg
+			? "[rivetkit-wasm/build] using existing pkg artifact"
+			: "[rivetkit-wasm/build] skipped",
+	);
+	process.exit(0);
+}
+
+const args = process.argv.slice(2);
+const targetIndex = args.indexOf("--target");
+const outDirIndex = args.indexOf("--out-dir");
+
+const target = targetIndex >= 0 ? args[targetIndex + 1] : "web";
+const outDir = outDirIndex >= 0 ? args[outDirIndex + 1] : "pkg";
+
+if (!target) {
+	throw new Error("--target requires a value");
+}
+
+if (!outDir) {
+	throw new Error("--out-dir requires a value");
+}
+
+const cmd = [
+	"wasm-pack",
+	"build",
+	"--target",
+	target,
+	"--out-dir",
+	outDir,
+	"--out-name",
+	"rivetkit_wasm",
+];
+
+console.log(`[rivetkit-wasm/build] running: ${cmd.join(" ")}`);
+execFileSync("npx", ["-y", ...cmd], { stdio: "inherit" });
diff --git a/rivetkit-typescript/packages/rivetkit-wasm/scripts/check-package.mjs b/rivetkit-typescript/packages/rivetkit-wasm/scripts/check-package.mjs
new file mode 100644
index 0000000000..2568b9fc0f
--- /dev/null
+++ b/rivetkit-typescript/packages/rivetkit-wasm/scripts/check-package.mjs
@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+import { execFileSync } from "node:child_process";
+
+const requiredFiles = new Set([
+	"index.js",
+	"index.d.ts",
+	"pkg/rivetkit_wasm.js",
+	"pkg/rivetkit_wasm.d.ts",
+	"pkg/rivetkit_wasm_bg.wasm",
+	"pkg/rivetkit_wasm_bg.wasm.d.ts",
+	"package.json",
+]);
+
+const output = execFileSync(
+	"npm",
+	["pack", "--json", "--dry-run", "--ignore-scripts"],
+	{
+		encoding: "utf8",
+		stdio: ["ignore", "pipe", "pipe"],
+	},
+);
+const [pack] = JSON.parse(output);
+const publishedFiles = new Set(
+	pack.files.map((file) => file.path.replace(/\\/g, "/")),
+);
+const missingFiles = [...requiredFiles].filter((file) => !publishedFiles.has(file));
+
+if (missingFiles.length > 0) {
+	throw new Error(
+		`@rivetkit/rivetkit-wasm package is missing required files: ${missingFiles.join(", ")}`,
+	);
+}
diff --git a/rivetkit-typescript/packages/rivetkit-wasm/src/lib.rs b/rivetkit-typescript/packages/rivetkit-wasm/src/lib.rs
new file mode 100644
index 0000000000..3a8da92cf8
--- /dev/null
+++ b/rivetkit-typescript/packages/rivetkit-wasm/src/lib.rs
@@ -0,0 +1,2661 @@
+use std::cell::RefCell;
+use std::collections::HashMap;
+use std::path::PathBuf;
+use std::rc::Rc;
+use std::sync::Arc;
+use std::time::Duration;
+
+use anyhow::{Result, anyhow};
+use js_sys::{Array, Function, Object, Promise, Reflect, Uint8Array};
+use rivet_error::{
+	MacroMarker, RivetError as RivetTransportError, RivetErrorSchema,
+};
+use rivetkit_core::{
+	ActorConfig, ActorConfigInput, ActorEvent, ActorFactory as CoreActorFactory,
+	ActorStart, BindParam, ColumnValue, CoreRegistry as NativeCoreRegistry, EnqueueAndWaitOpts,
+	CoreServerlessRuntime,
+	ExecuteRoute, ListOpts, QueueMessage, QueueNextBatchOpts, QueueSendResult, QueueSendStatus,
+	QueueTryNextBatchOpts, QueueWaitOpts, Request, RequestSaveOpts, Response, RuntimeSpawner,
+	SerializeStateReason, ServeConfig, ServerlessRequest, StateDelta, WebSocket,
+	WebSocketCallbackRegion, WsMessage,
+};
+use rivetkit_core::inspector::InspectorAuth;
+use tokio::sync::oneshot;
+use tokio_util::sync::CancellationToken as CoreCancellationToken;
+use wasm_bindgen::prelude::*;
+use wasm_bindgen::{JsCast, UnwrapThrowExt};
+use wasm_bindgen_futures::{JsFuture, spawn_local};
+
+const BRIDGE_RIVET_ERROR_PREFIX: &str = "__RIVET_ERROR_JSON__:";
+
+#[derive(rivet_error::RivetError, serde::Serialize)]
+#[error(
+	"wasm",
+	"invalid_state",
+	"Invalid wasm state",
+	"Invalid wasm state '{state}': {reason}"
+)]
+struct WasmInvalidState {
+	state: String,
+	reason: String,
+}
+
+#[derive(serde::Deserialize)]
+struct BridgeRivetErrorPayload {
+	group: String,
+	code: String,
+	message: String,
+	metadata: Option<serde_json::Value>,
+	#[serde(rename = "public")]
+	public_: Option<bool>,
+	#[serde(rename = "statusCode")]
+	status_code: Option<u16>,
+}
+
+#[derive(Debug)]
+struct BridgeRivetErrorContext {
+	public_: Option<bool>,
+	status_code: Option<u16>,
+}
+
+impl std::fmt::Display for BridgeRivetErrorContext {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		write!(
+			f,
+			"bridge rivet error context public={:?} status_code={:?}",
+			self.public_, self.status_code
+		)
+	}
+}
+
+impl std::error::Error for BridgeRivetErrorContext {}
+
+#[derive(Clone)]
+struct WasmFunction(Function);
+
+// wasm-bindgen JS handles are bound to the single JavaScript thread in our wasm
+// runtime. Core callback slots are Send + Sync so native builds can move them
+// across threads, but the wasm runtime always drives them on the local task set.
+unsafe impl Send for WasmFunction {}
+unsafe impl Sync for WasmFunction {}
+
+impl WasmFunction {
+	fn call1(&self, payload: &JsValue) -> Result<JsValue> {
+		self.0
+			.call1(&JsValue::UNDEFINED, payload)
+			.map_err(js_value_to_anyhow)
+	}
+}
+
+#[cfg(target_arch = "wasm32")]
+#[wasm_bindgen(start)]
+pub fn start() {
+	console_error_panic_hook::set_once();
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct WasmServeConfig {
+	pub version: u32,
+	pub endpoint: String,
+	pub token: Option<String>,
+	pub namespace: String,
+	pub pool_name: String,
+	pub engine_binary_path: Option<String>,
+	pub handle_inspector_http_in_runtime: Option<bool>,
+	pub inspector_test_token: Option<String>,
+	pub serverless_base_path: Option<String>,
+	pub serverless_package_version: String,
+	pub serverless_client_endpoint: Option<String>,
+	pub serverless_client_namespace: Option<String>,
+	pub serverless_client_token: Option<String>,
+	pub serverless_validate_endpoint: bool,
+	pub serverless_max_start_payload_bytes: u32,
+}
+
+impl From<WasmServeConfig> for ServeConfig {
+	fn from(config: WasmServeConfig) -> Self {
+		Self {
+			version: config.version,
+			endpoint: config.endpoint,
+			token: config.token,
+			namespace: config.namespace,
+			pool_name: config.pool_name,
+			engine_binary_path: config.engine_binary_path.map(PathBuf::from),
+				handle_inspector_http_in_runtime: config
+					.handle_inspector_http_in_runtime
+					.unwrap_or(false),
+				serverless_base_path: config.serverless_base_path,
+				serverless_package_version: config.serverless_package_version,
+				serverless_client_endpoint: config.serverless_client_endpoint,
+				serverless_client_namespace: config.serverless_client_namespace,
+				serverless_client_token: config.serverless_client_token,
+				serverless_validate_endpoint: config.serverless_validate_endpoint,
+				serverless_max_start_payload_bytes: config.serverless_max_start_payload_bytes as usize,
+				serverless_cache_envoy: false,
+			}
+		}
+	}
+
+#[derive(Clone, Default, serde::Deserialize)]
+#[serde(default, rename_all = "camelCase")]
+pub struct WasmActionDefinition {
+	pub name: String,
+}
+
+#[derive(Clone, Default, serde::Deserialize)]
+#[serde(default, rename_all = "camelCase")]
+pub struct WasmActorConfig {
+	pub name: Option<String>,
+	pub icon: Option<String>,
+	pub has_database: Option<bool>,
+	pub remote_sqlite: Option<bool>,
+	pub has_state: Option<bool>,
+	pub can_hibernate_websocket: Option<bool>,
+	pub state_save_interval_ms: Option<u32>,
+	pub create_state_timeout_ms: Option<u32>,
+	pub on_create_timeout_ms: Option<u32>,
+	pub create_vars_timeout_ms: Option<u32>,
+	pub create_conn_state_timeout_ms: Option<u32>,
+	pub on_before_connect_timeout_ms: Option<u32>,
+	pub on_connect_timeout_ms: Option<u32>,
+	pub on_migrate_timeout_ms: Option<u32>,
+	pub on_wake_timeout_ms: Option<u32>,
+	pub on_before_actor_start_timeout_ms: Option<u32>,
+	pub action_timeout_ms: Option<u32>,
+	pub on_request_timeout_ms: Option<u32>,
+	pub sleep_timeout_ms: Option<u32>,
+	pub no_sleep: Option<bool>,
+	pub sleep_grace_period_ms: Option<u32>,
+	pub connection_liveness_timeout_ms: Option<u32>,
+	pub connection_liveness_interval_ms: Option<u32>,
+	pub max_queue_size: Option<u32>,
+	pub max_queue_message_size: Option<u32>,
+	pub max_incoming_message_size: Option<u32>,
+	pub max_outgoing_message_size: Option<u32>,
+	pub preload_max_workflow_bytes: Option<f64>,
+	pub preload_max_connections_bytes: Option<f64>,
+	pub actions: Option<Vec<WasmActionDefinition>>,
+}
+
+impl From<WasmActorConfig> for ActorConfigInput {
+	fn from(config: WasmActorConfig) -> Self {
+		Self {
+			name: config.name,
+			icon: config.icon,
+			has_database: config.has_database,
+			remote_sqlite: config.remote_sqlite,
+			has_state: config.has_state,
+			can_hibernate_websocket: config.can_hibernate_websocket,
+			state_save_interval_ms: config.state_save_interval_ms,
+			create_vars_timeout_ms: config.create_vars_timeout_ms,
+			create_conn_state_timeout_ms: config.create_conn_state_timeout_ms,
+			on_before_connect_timeout_ms: config.on_before_connect_timeout_ms,
+			on_connect_timeout_ms: config.on_connect_timeout_ms,
+			on_migrate_timeout_ms: config.on_migrate_timeout_ms,
+			action_timeout_ms: config.action_timeout_ms,
+			sleep_timeout_ms: config.sleep_timeout_ms,
+			no_sleep: config.no_sleep,
+			sleep_grace_period_ms: config.sleep_grace_period_ms,
+			connection_liveness_timeout_ms: config.connection_liveness_timeout_ms,
+			connection_liveness_interval_ms: config.connection_liveness_interval_ms,
+			max_queue_size: config.max_queue_size,
+			max_queue_message_size: config.max_queue_message_size,
+			max_incoming_message_size: config.max_incoming_message_size,
+			max_outgoing_message_size: config.max_outgoing_message_size,
+			preload_max_workflow_bytes: config.preload_max_workflow_bytes,
+			preload_max_connections_bytes: config.preload_max_connections_bytes,
+			actions: config.actions.map(|actions| {
+				actions
+					.into_iter()
+					.map(|action| rivetkit_core::ActionDefinition { name: action.name })
+					.collect()
+			}),
+		}
+	}
+}
+
+enum RegistryState {
+	Registering(Option<NativeCoreRegistry>),
+	BuildingServerless,
+	Serving,
+	Serverless(WasmServerlessRuntime),
+	ShuttingDown,
+	ShutDown,
+}
+
+#[derive(Clone)]
+struct WasmServerlessRuntime {
+	runtime: CoreServerlessRuntime,
+}
+
+#[wasm_bindgen(js_name = CoreRegistry)]
+#[derive(Clone)]
+pub struct WasmCoreRegistry {
+	state: Rc<RefCell<RegistryState>>,
+	shutdown_token: CoreCancellationToken,
+	build_waiters: Rc<RefCell<Vec<oneshot::Sender<()>>>>,
+}
+
+#[wasm_bindgen(js_class = CoreRegistry)]
+impl WasmCoreRegistry {
+	#[wasm_bindgen(constructor)]
+	pub fn new() -> Self {
+		Self {
+			state: Rc::new(RefCell::new(RegistryState::Registering(Some(
+				NativeCoreRegistry::new(),
+			)))),
+			shutdown_token: CoreCancellationToken::new(),
+			build_waiters: Rc::new(RefCell::new(Vec::new())),
+		}
+	}
+
+	fn notify_serverless_build_complete(&self) {
+		let waiters = std::mem::take(&mut *self.build_waiters.borrow_mut());
+		for waiter in waiters {
+			let _ = waiter.send(());
+		}
+	}
+
+	#[wasm_bindgen]
+	pub fn register(&self, name: String, factory: &WasmActorFactory) -> Result<(), JsValue> {
+		let mut state = self.state.borrow_mut();
+		match &mut *state {
+			RegistryState::Registering(registry) => {
+				let registry = registry
+					.as_mut()
+					.ok_or_else(|| js_error("registry is already serving"))?;
+				registry.register_shared(&name, factory.inner.clone());
+				Ok(())
+			}
+			RegistryState::BuildingServerless
+			| RegistryState::Serving
+			| RegistryState::Serverless(_)
+			| RegistryState::ShuttingDown
+			| RegistryState::ShutDown => Err(registry_not_registering_error()),
+		}
+	}
+
+	#[wasm_bindgen]
+	pub async fn serve(&self, config: JsValue) -> Result<(), JsValue> {
+		let config: WasmServeConfig = serde_wasm_bindgen::from_value(config)?;
+		rivetkit_core::inspector::set_test_inspector_token_override(
+			config.inspector_test_token.clone(),
+		);
+		let registry = {
+			let mut state = self.state.borrow_mut();
+			match &mut *state {
+				RegistryState::Registering(registry) => {
+					let registry = registry
+						.take()
+						.ok_or_else(registry_not_registering_error)?;
+					*state = RegistryState::Serving;
+					registry
+				}
+				RegistryState::BuildingServerless | RegistryState::Serverless(_) => {
+					return Err(registry_wrong_mode_error());
+				}
+				RegistryState::Serving => return Err(registry_not_registering_error()),
+				RegistryState::ShuttingDown | RegistryState::ShutDown => {
+					return Err(registry_shut_down_error());
+				}
+			}
+		};
+
+		let local = tokio::task::LocalSet::new();
+		local
+			.run_until(registry.serve_with_config(
+				config.into(),
+				self.shutdown_token.clone(),
+			))
+			.await
+			.map_err(anyhow_to_js_error)
+	}
+
+	#[wasm_bindgen]
+	pub async fn shutdown(&self) -> Result<(), JsValue> {
+		self.shutdown_token.cancel();
+		let serverless = {
+			let mut state = self.state.borrow_mut();
+			let previous = std::mem::replace(&mut *state, RegistryState::ShutDown);
+			match previous {
+				RegistryState::Serverless(serverless) => Some(serverless.runtime),
+				RegistryState::BuildingServerless => {
+					*state = RegistryState::ShuttingDown;
+					None
+				}
+				RegistryState::Registering(_)
+				| RegistryState::Serving
+				| RegistryState::ShuttingDown
+				| RegistryState::ShutDown => None,
+			}
+		};
+		self.notify_serverless_build_complete();
+		if let Some(serverless) = serverless {
+			serverless.shutdown().await;
+			*self.state.borrow_mut() = RegistryState::ShutDown;
+		}
+		Ok(())
+	}
+
+	#[wasm_bindgen(js_name = handleServerlessRequest)]
+	pub async fn handle_serverless_request(
+		&self,
+		req: JsValue,
+		on_stream_event: Function,
+		cancel_token: &WasmCancellationToken,
+		config: JsValue,
+		) -> Result<JsValue, JsValue> {
+			let serverless = self.serverless_runtime(config).await?;
+			let req = serverless_request_from_js(req, cancel_token.inner.clone())
+				.map_err(anyhow_to_js_error)?;
+			start_wasm_serverless_request(serverless.runtime, req, on_stream_event).await
+		}
+
+	async fn serverless_runtime(&self, config: JsValue) -> Result<WasmServerlessRuntime, JsValue> {
+		let config: WasmServeConfig = serde_wasm_bindgen::from_value(config)?;
+		rivetkit_core::inspector::set_test_inspector_token_override(
+			config.inspector_test_token.clone(),
+		);
+		loop {
+			let maybe_registry = {
+				let mut state = self.state.borrow_mut();
+				match &mut *state {
+					RegistryState::Registering(registry) => {
+						let registry = registry
+							.take()
+							.ok_or_else(registry_not_registering_error)?;
+						*state = RegistryState::BuildingServerless;
+						Some(registry)
+					}
+					RegistryState::Serverless(serverless) => return Ok(serverless.clone()),
+					RegistryState::BuildingServerless => {
+						let (tx, rx) = oneshot::channel();
+						self.build_waiters.borrow_mut().push(tx);
+						drop(state);
+						let _ = rx.await;
+						continue;
+					}
+					RegistryState::Serving => return Err(registry_wrong_mode_error()),
+					RegistryState::ShuttingDown | RegistryState::ShutDown => {
+						return Err(registry_shut_down_error());
+					}
+				}
+			};
+
+			let registry = maybe_registry.ok_or_else(registry_not_registering_error)?;
+			let runtime = match registry.into_serverless_runtime(config.into()).await {
+				Ok(runtime) => runtime,
+				Err(error) => {
+					*self.state.borrow_mut() = RegistryState::ShutDown;
+					self.notify_serverless_build_complete();
+					return Err(anyhow_to_js_error(error));
+				}
+			};
+			let serverless = WasmServerlessRuntime { runtime };
+			if self.shutdown_token.is_cancelled() {
+				serverless.runtime.shutdown().await;
+				*self.state.borrow_mut() = RegistryState::ShutDown;
+				self.notify_serverless_build_complete();
+				return Err(registry_shut_down_error());
+			}
+			{
+				let mut state = self.state.borrow_mut();
+				match &*state {
+					RegistryState::BuildingServerless => {
+						*state = RegistryState::Serverless(serverless.clone());
+					}
+					RegistryState::ShuttingDown | RegistryState::ShutDown => {
+						drop(state);
+						serverless.runtime.shutdown().await;
+						*self.state.borrow_mut() = RegistryState::ShutDown;
+						self.notify_serverless_build_complete();
+						return Err(registry_shut_down_error());
+					}
+					RegistryState::Registering(_)
+					| RegistryState::Serving
+					| RegistryState::Serverless(_) => {
+						drop(state);
+						serverless.runtime.shutdown().await;
+						self.notify_serverless_build_complete();
+						return Err(registry_wrong_mode_error());
+					}
+				}
+			}
+			self.notify_serverless_build_complete();
+			return Ok(serverless);
+		}
+	}
+}
+
+impl Default for WasmCoreRegistry {
+	fn default() -> Self {
+		Self::new()
+	}
+}
+
+#[wasm_bindgen(js_name = ActorFactory)]
+#[derive(Clone)]
+pub struct WasmActorFactory {
+	inner: Arc<CoreActorFactory>,
+}
+
+#[wasm_bindgen(js_class = ActorFactory)]
+impl WasmActorFactory {
+	#[wasm_bindgen(constructor)]
+	pub fn new(callbacks: JsValue, config: JsValue) -> Result<WasmActorFactory, JsValue> {
+		let input = if config.is_null() || config.is_undefined() {
+			WasmActorConfig::default()
+		} else {
+			serde_wasm_bindgen::from_value(config)?
+		};
+		let config = ActorConfig::from_input(input.into());
+		let callbacks = WasmCallbacks::new(callbacks);
+		let factory = CoreActorFactory::new_with_manual_startup_ready(config, move |start| {
+			let callbacks = callbacks.clone();
+			Box::pin(async move { run_actor_adapter(callbacks, start).await })
+		});
+		Ok(WasmActorFactory {
+			inner: Arc::new(factory),
+		})
+	}
+}
+
+#[derive(Clone)]
+struct WasmCallbacks {
+	create_state: Option<Function>,
+	on_create: Option<Function>,
+	create_vars: Option<Function>,
+	on_migrate: Option<Function>,
+	on_wake: Option<Function>,
+	on_before_actor_start: Option<Function>,
+	on_sleep: Option<Function>,
+	on_destroy: Option<Function>,
+	on_before_connect: Option<Function>,
+	create_conn_state: Option<Function>,
+	on_connect: Option<Function>,
+	on_disconnect_final: Option<Function>,
+	on_before_subscribe: Option<Function>,
+	on_before_action_response: Option<Function>,
+	on_request: Option<Function>,
+	on_queue_send: Option<Function>,
+	on_websocket: Option<Function>,
+	serialize_state: Option<Function>,
+	run: Option<Function>,
+	get_workflow_history: Option<Function>,
+	replay_workflow: Option<Function>,
+	actions: JsValue,
+}
+
+impl WasmCallbacks {
+	fn new(callbacks: JsValue) -> Self {
+		Self {
+			create_state: function_property(&callbacks, "createState"),
+			on_create: function_property(&callbacks, "onCreate"),
+			create_vars: function_property(&callbacks, "createVars"),
+			on_migrate: function_property(&callbacks, "onMigrate"),
+			on_wake: function_property(&callbacks, "onWake"),
+			on_before_actor_start: function_property(&callbacks, "onBeforeActorStart"),
+			on_sleep: function_property(&callbacks, "onSleep"),
+			on_destroy: function_property(&callbacks, "onDestroy"),
+			on_before_connect: function_property(&callbacks, "onBeforeConnect"),
+			create_conn_state: function_property(&callbacks, "createConnState"),
+			on_connect: function_property(&callbacks, "onConnect"),
+			on_disconnect_final: function_property(&callbacks, "onDisconnectFinal")
+				.or_else(|| function_property(&callbacks, "onDisconnect")),
+			on_before_subscribe: function_property(&callbacks, "onBeforeSubscribe"),
+			on_before_action_response: function_property(&callbacks, "onBeforeActionResponse"),
+			on_request: function_property(&callbacks, "onRequest"),
+			on_queue_send: function_property(&callbacks, "onQueueSend"),
+			on_websocket: function_property(&callbacks, "onWebSocket"),
+			serialize_state: function_property(&callbacks, "serializeState"),
+			run: function_property(&callbacks, "run"),
+			get_workflow_history: function_property(&callbacks, "getWorkflowHistory"),
+			replay_workflow: function_property(&callbacks, "replayWorkflow"),
+			actions: Reflect::get(&callbacks, &JsValue::from_str("actions"))
+				.unwrap_or(JsValue::UNDEFINED),
+		}
+	}
+}
+
+async fn run_actor_adapter(callbacks: WasmCallbacks, start: ActorStart) -> Result<()> {
+	let ActorStart {
+		ctx: core_ctx,
+		input,
+		snapshot,
+		hibernated: _,
+		mut events,
+		startup_ready,
+	} = start;
+
+	let ctx = WasmActorContext::from_core(core_ctx.clone(), callbacks.clone());
+	let preamble = run_preamble(&callbacks, &ctx, input, snapshot).await;
+	if let Some(reply) = startup_ready {
+		let _ = reply.send(preamble.as_ref().map(|_| ()).map_err(|error| {
+			anyhow!(RivetTransportError::extract(error))
+		}));
+	}
+	preamble?;
+	start_run_handler(&callbacks, &ctx);
+
+	while let Some(event) = events.recv().await {
+		dispatch_event(&callbacks, &ctx, event).await;
+	}
+
+	Ok(())
+}
+
+fn start_run_handler(callbacks: &WasmCallbacks, ctx: &WasmActorContext) {
+	let Some(callback) = callbacks.run.clone() else {
+		return;
+	};
+	let ctx = ctx.clone();
+	ctx.inner.begin_run_handler();
+	spawn_local(async move {
+		let result = async {
+			let payload = object();
+			set_anyhow(&payload, "ctx", JsValue::from(ctx.clone()))?;
+			call_callback(&callback, &payload.into()).await?;
+			Ok::<_, anyhow::Error>(())
+		}
+		.await;
+		if let Err(error) = &result {
+			console_error(&format!("wasm run callback failed: {error:#}"));
+		}
+		ctx.inner.end_run_handler();
+	});
+}
+
+async fn run_preamble(
+	callbacks: &WasmCallbacks,
+	ctx: &WasmActorContext,
+	input: Option<Vec<u8>>,
+	snapshot: Option<Vec<u8>>,
+) -> Result<()> {
+	let is_new = snapshot.is_none();
+
+	if let Some(callback) = &callbacks.on_migrate {
+		let payload = object();
+		set_anyhow(&payload, "ctx", JsValue::from(ctx.clone()))?;
+		set_anyhow(&payload, "isNew", JsValue::from_bool(is_new))?;
+		call_callback(callback, &payload.into()).await?;
+	}
+
+	if is_new {
+		if let Some(callback) = &callbacks.create_state {
+			let payload = object();
+			set_anyhow(&payload, "ctx", JsValue::from(ctx.clone()))?;
+			if let Some(input) = input.as_ref() {
+				set_anyhow(&payload, "input", bytes_to_js(input))?;
+			}
+			let state = call_callback_bytes(callback, &payload.into()).await?;
+			ctx.inner.set_state_initial(state);
+		}
+		if let Some(callback) = &callbacks.on_create {
+			let payload = object();
+			set_anyhow(&payload, "ctx", JsValue::from(ctx.clone()))?;
+			if let Some(input) = input.as_ref() {
+				set_anyhow(&payload, "input", bytes_to_js(input))?;
+			}
+			call_callback(callback, &payload.into()).await?;
+		}
+	} else if let Some(snapshot) = snapshot {
+		ctx.inner.set_state_initial(snapshot);
+	}
+
+	if let Some(callback) = &callbacks.create_vars {
+		let payload = object();
+		set_anyhow(&payload, "ctx", JsValue::from(ctx.clone()))?;
+		call_callback(callback, &payload.into()).await?;
+	}
+
+	if let Some(callback) = &callbacks.on_wake {
+		let payload = object();
+		set_anyhow(&payload, "ctx", JsValue::from(ctx.clone()))?;
+		call_callback(callback, &payload.into()).await?;
+	}
+
+	if let Some(callback) = &callbacks.on_before_actor_start {
+		let payload = object();
+		set_anyhow(&payload, "ctx", JsValue::from(ctx.clone()))?;
+		call_callback(callback, &payload.into()).await?;
+	}
+
+	Ok(())
+}
+
+async fn dispatch_event(callbacks: &WasmCallbacks, ctx: &WasmActorContext, event: ActorEvent) {
+	match event {
+		ActorEvent::Action {
+			name,
+			args,
+			conn,
+			reply,
+		} => {
+			let Some(callback) = action_callback(&callbacks.actions, &name) else {
+				console_error(&format!("wasm action callback `{name}` was not found"));
+				reply.send(Err(anyhow!("action `{name}` was not found")));
+				return;
+			};
+
+			let ctx = ctx.clone();
+			let on_before_action_response = callbacks.on_before_action_response.clone();
+			RuntimeSpawner::spawn(async move {
+				let result = async {
+					let payload = object();
+					set_anyhow(&payload, "ctx", JsValue::from(ctx.clone()))?;
+					set_anyhow(
+						&payload,
+						"conn",
+						conn.clone()
+							.map(WasmConnHandle::from_core)
+							.map(JsValue::from)
+							.unwrap_or(JsValue::NULL),
+					)?;
+					set_anyhow(&payload, "name", JsValue::from_str(&name))?;
+					set_anyhow(&payload, "args", bytes_to_js(&args))?;
+					let mut output = call_callback_bytes(&callback, &payload.into()).await?;
+
+					if let Some(callback) = &on_before_action_response {
+						let payload = object();
+						set_anyhow(&payload, "ctx", JsValue::from(ctx.clone()))?;
+						set_anyhow(&payload, "name", JsValue::from_str(&name))?;
+						set_anyhow(&payload, "args", bytes_to_js(&args))?;
+						set_anyhow(&payload, "output", bytes_to_js(&output))?;
+						output = call_callback_bytes(callback, &payload.into()).await?;
+					}
+
+					Ok(output)
+				}
+				.await;
+				if let Err(error) = &result {
+					console_error(&format!("wasm action callback `{name}` failed: {error:#}"));
+				}
+				reply.send(result);
+			});
+		}
+		ActorEvent::SerializeState { reason, reply } => {
+			let result = match callbacks.serialize_state.as_ref() {
+				Some(callback) => serialize_state(callback, ctx, reason).await,
+				None => Ok(Vec::new()),
+			};
+			reply.send(result);
+		}
+		ActorEvent::RunGracefulCleanup { reason, reply } => {
+			let callback = match reason {
+				rivetkit_core::ShutdownKind::Sleep => callbacks.on_sleep.as_ref(),
+				rivetkit_core::ShutdownKind::Destroy => callbacks.on_destroy.as_ref(),
+			};
+			if let Some(callback) = callback {
+				let payload = object();
+				let result = async {
+					set_anyhow(&payload, "ctx", JsValue::from(ctx.clone()))?;
+					call_callback(callback, &payload.into()).await?;
+					Ok(())
+				}
+				.await;
+				reply.send(result);
+			} else {
+				reply.send(Ok(()));
+			}
+		}
+		ActorEvent::WorkflowHistoryRequested { reply } => {
+			let result = async {
+				let Some(callback) = callbacks.get_workflow_history.as_ref() else {
+					return Ok(None);
+				};
+				let payload = object();
+				set_anyhow(&payload, "ctx", JsValue::from(ctx.clone()))?;
+				let value = call_callback(callback, &payload.into()).await?;
+				if value.is_null() || value.is_undefined() {
+					Ok(None)
+				} else {
+					Ok(Some(js_to_bytes(value)))
+				}
+			}
+			.await;
+			if let Err(error) = &result {
+				console_error(&format!("wasm workflow history callback failed: {error:#}"));
+			}
+			reply.send(result);
+		}
+		ActorEvent::WorkflowReplayRequested { entry_id, reply } => {
+			let result = async {
+				let Some(callback) = callbacks.replay_workflow.as_ref() else {
+					return Ok(None);
+				};
+				let payload = object();
+				set_anyhow(&payload, "ctx", JsValue::from(ctx.clone()))?;
+				if let Some(entry_id) = entry_id {
+					set_anyhow(&payload, "entryId", JsValue::from_str(&entry_id))?;
+				}
+				let value = call_callback(callback, &payload.into()).await?;
+				if value.is_null() || value.is_undefined() {
+					Ok(None)
+				} else {
+					Ok(Some(js_to_bytes(value)))
+				}
+			}
+			.await;
+			if let Err(error) = &result {
+				console_error(&format!("wasm workflow replay callback failed: {error:#}"));
+			}
+			reply.send(result);
+		}
+		ActorEvent::HttpRequest { request, reply } => {
+			let callback = callbacks.on_request.clone();
+			let ctx = ctx.clone();
+			RuntimeSpawner::spawn(async move {
+				let result = async {
+					let callback = callback
+						.as_ref()
+						.ok_or_else(|| anyhow!("wasm onRequest callback is not implemented"))?;
+					let payload = object();
+					set_anyhow(&payload, "ctx", JsValue::from(ctx.clone()))?;
+					set_anyhow(&payload, "request", request_to_js(request)?)?;
+					let value = call_callback(callback, &payload.into()).await?;
+					response_from_js(value)
+				}
+				.await;
+				if let Err(error) = &result {
+					console_error(&format!("wasm onRequest callback failed: {error:#}"));
+				}
+				reply.send(result);
+			});
+		}
+		ActorEvent::QueueSend {
+			name,
+			body,
+			conn,
+			request,
+			wait,
+			timeout_ms,
+			reply,
+		} => {
+			let callback = callbacks.on_queue_send.clone();
+			let ctx = ctx.clone();
+			RuntimeSpawner::spawn(async move {
+				let result = async {
+					let callback = callback
+						.as_ref()
+						.ok_or_else(|| anyhow!("wasm onQueueSend callback is not implemented"))?;
+					let payload = object();
+					set_anyhow(&payload, "ctx", JsValue::from(ctx.clone()))?;
+					set_anyhow(
+						&payload,
+						"conn",
+						JsValue::from(WasmConnHandle::from_core(conn)),
+					)?;
+					set_anyhow(&payload, "request", request_to_js(request)?)?;
+					set_anyhow(&payload, "name", JsValue::from_str(&name))?;
+					set_anyhow(&payload, "body", bytes_to_js(&body))?;
+					set_anyhow(&payload, "wait", JsValue::from_bool(wait))?;
+					set_anyhow(
+						&payload,
+						"timeoutMs",
+						timeout_ms
+							.map(|value| JsValue::from_f64(value as f64))
+							.unwrap_or(JsValue::UNDEFINED),
+					)?;
+					let value = call_callback(callback, &payload.into()).await?;
+					queue_send_result_from_js(value)
+				}
+				.await;
+				if let Err(error) = &result {
+					console_error(&format!("wasm onQueueSend callback failed: {error:#}"));
+				}
+				reply.send(result);
+			});
+		}
+		ActorEvent::WebSocketOpen {
+			conn,
+			ws,
+			request,
+			reply,
+		} => {
+			let result = async {
+				let callback = callbacks
+					.on_websocket
+					.as_ref()
+					.ok_or_else(|| anyhow!("wasm onWebSocket callback is not implemented"))?;
+				let payload = object();
+				set_anyhow(&payload, "ctx", JsValue::from(ctx.clone()))?;
+				set_anyhow(
+					&payload,
+					"conn",
+					JsValue::from(WasmConnHandle::from_core(conn)),
+				)?;
+				set_anyhow(
+					&payload,
+					"ws",
+					JsValue::from(WasmWebSocket::from_core(ws)),
+				)?;
+				if let Some(request) = request {
+					set_anyhow(&payload, "request", request_to_js(request)?)?;
+				}
+				call_callback(callback, &payload.into()).await?;
+				Ok(())
+			}
+			.await;
+			if let Err(error) = &result {
+				console_error(&format!("wasm websocket callback failed: {error:#}"));
+			}
+			reply.send(result);
+		}
+		ActorEvent::ConnectionOpen {
+			conn,
+			params,
+			request,
+			reply,
+		} => {
+			let result = run_connection_open(callbacks, ctx, conn, params, request).await;
+			if let Err(error) = &result {
+				console_error(&format!("wasm connection open callback failed: {error:#}"));
+			}
+			reply.send(result);
+		}
+		ActorEvent::SubscribeRequest {
+			conn,
+			event_name,
+			reply,
+		} => {
+			let callback = callbacks.on_before_subscribe.clone();
+			let ctx = ctx.clone();
+			RuntimeSpawner::spawn(async move {
+				let result = async {
+					let Some(callback) = callback.as_ref() else {
+						return Ok(());
+					};
+					let payload = object();
+					set_anyhow(&payload, "ctx", JsValue::from(ctx.clone()))?;
+					set_anyhow(
+						&payload,
+						"conn",
+						JsValue::from(WasmConnHandle::from_core(conn)),
+					)?;
+					set_anyhow(&payload, "eventName", JsValue::from_str(&event_name))?;
+					call_callback(callback, &payload.into()).await?;
+					Ok(())
+				}
+				.await;
+				if let Err(error) = &result {
+					console_error(&format!(
+						"wasm onBeforeSubscribe callback failed: {error:#}"
+					));
+				}
+				reply.send(result);
+			});
+		}
+		ActorEvent::DisconnectConn { conn_id, reply } => {
+			let result = async {
+				if let Some(callback) = &callbacks.on_disconnect_final {
+					let payload = object();
+					set_anyhow(&payload, "ctx", JsValue::from(ctx.clone()))?;
+					set_anyhow(&payload, "conn", JsValue::NULL)?;
+					call_callback(callback, &payload.into()).await?;
+				}
+				ctx.inner.disconnect_conn(conn_id).await
+			}
+			.await;
+			if let Err(error) = result {
+				console_error(&format!("wasm disconnect callback failed: {error:#}"));
+			}
+			reply.send(Ok(()));
+		}
+		ActorEvent::ConnectionClosed { conn } => {
+			if let Some(callback) = &callbacks.on_disconnect_final {
+				let result = async {
+					let payload = object();
+					set_anyhow(&payload, "ctx", JsValue::from(ctx.clone()))?;
+					set_anyhow(&payload, "conn", JsValue::from(WasmConnHandle::from_core(conn)))?;
+					call_callback(callback, &payload.into()).await?;
+					Ok::<_, anyhow::Error>(())
+				}
+				.await;
+				if let Err(error) = result {
+					console_error(&format!("wasm connection closed callback failed: {error:#}"));
+				}
+			}
+		}
+	}
+}
+
+async fn run_connection_open(
+	callbacks: &WasmCallbacks,
+	ctx: &WasmActorContext,
+	conn: rivetkit_core::ConnHandle,
+	params: Vec<u8>,
+	request: Option<Request>,
+) -> Result<()> {
+	if let Some(callback) = &callbacks.on_before_connect {
+		let payload = object();
+		set_anyhow(&payload, "ctx", JsValue::from(ctx.clone()))?;
+		set_anyhow(&payload, "params", bytes_to_js(&params))?;
+		if let Some(request) = request.as_ref() {
+			set_anyhow(&payload, "request", request_to_js(request.clone())?)?;
+		}
+		call_callback(callback, &payload.into()).await?;
+	}
+
+	let wasm_conn = WasmConnHandle::from_core(conn.clone());
+	if let Some(callback) = &callbacks.create_conn_state {
+		let payload = object();
+		set_anyhow(&payload, "ctx", JsValue::from(ctx.clone()))?;
+		set_anyhow(&payload, "conn", JsValue::from(wasm_conn.clone()))?;
+		set_anyhow(&payload, "params", bytes_to_js(&params))?;
+		if let Some(request) = request.as_ref() {
+			set_anyhow(&payload, "request", request_to_js(request.clone())?)?;
+		}
+		let state = call_callback_bytes(callback, &payload.into()).await?;
+		conn.set_state_initial(state);
+	}
+
+	if let Some(callback) = &callbacks.on_connect {
+		let payload = object();
+		set_anyhow(&payload, "ctx", JsValue::from(ctx.clone()))?;
+		set_anyhow(&payload, "conn", JsValue::from(wasm_conn))?;
+		if let Some(request) = request {
+			set_anyhow(&payload, "request", request_to_js(request)?)?;
+		}
+		call_callback(callback, &payload.into()).await?;
+	}
+
+	Ok(())
+}
+
+async fn serialize_state(
+	callback: &Function,
+	ctx: &WasmActorContext,
+	reason: SerializeStateReason,
+) -> Result<Vec<StateDelta>> {
+	let payload = object();
+	set_anyhow(&payload, "ctx", JsValue::from(ctx.clone()))?;
+	set_anyhow(
+		&payload,
+		"reason",
+		JsValue::from_str(match reason {
+			SerializeStateReason::Save => "save",
+			SerializeStateReason::Inspector => "inspector",
+		}),
+	)?;
+	let value = call_callback(callback, &payload.into()).await?;
+	state_delta_payload_from_js(value)
+}
+
+#[wasm_bindgen(js_name = CancellationToken)]
+#[derive(Clone)]
+pub struct WasmCancellationToken {
+	inner: CoreCancellationToken,
+}
+
+#[wasm_bindgen(js_class = CancellationToken)]
+impl WasmCancellationToken {
+	#[wasm_bindgen(constructor)]
+	pub fn new() -> Self {
+		Self {
+			inner: CoreCancellationToken::new(),
+		}
+	}
+
+	#[wasm_bindgen]
+	pub fn aborted(&self) -> bool {
+		self.inner.is_cancelled()
+	}
+
+	#[wasm_bindgen]
+	pub fn cancel(&self) {
+		self.inner.cancel();
+	}
+
+	#[wasm_bindgen(js_name = onCancelled)]
+	pub fn on_cancelled(&self, callback: Function) {
+		let token = self.inner.clone();
+		spawn_local(async move {
+			token.cancelled().await;
+			let _ = callback.call0(&JsValue::UNDEFINED);
+		});
+	}
+}
+
+impl Default for WasmCancellationToken {
+	fn default() -> Self {
+		Self::new()
+	}
+}
+
+#[wasm_bindgen(js_name = ActorContext)]
+#[derive(Clone)]
+pub struct WasmActorContext {
+	inner: rivetkit_core::ActorContext,
+	callbacks: WasmCallbacks,
+	runtime_state: JsValue,
+	websocket_callback_regions: Rc<RefCell<Vec<Option<WebSocketCallbackRegion>>>>,
+}
+
+impl WasmActorContext {
+	fn from_core(inner: rivetkit_core::ActorContext, callbacks: WasmCallbacks) -> Self {
+		Self {
+			inner,
+			callbacks,
+			runtime_state: Object::new().into(),
+			websocket_callback_regions: Rc::new(RefCell::new(Vec::new())),
+		}
+	}
+}
+
+#[wasm_bindgen(js_class = ActorContext)]
+impl WasmActorContext {
+	#[wasm_bindgen(constructor)]
+	pub fn new() -> Result<WasmActorContext, JsValue> {
+		Err(js_error(
+			"ActorContext instances are created by rivetkit-core callbacks",
+		))
+	}
+
+	#[wasm_bindgen]
+	pub fn state(&self) -> Vec<u8> {
+		self.inner.state()
+	}
+
+	#[wasm_bindgen(js_name = runtimeState)]
+	pub fn runtime_state(&self) -> JsValue {
+		self.runtime_state.clone()
+	}
+
+	#[wasm_bindgen]
+	pub fn sql(&self) -> WasmSqliteDb {
+		WasmSqliteDb {
+			inner: self.inner.sql().clone(),
+		}
+	}
+
+	#[wasm_bindgen]
+	pub fn kv(&self) -> WasmKv {
+		WasmKv {
+			inner: self.inner.clone(),
+		}
+	}
+
+	#[wasm_bindgen(js_name = actorId)]
+	pub fn actor_id(&self) -> String {
+		self.inner.actor_id().to_owned()
+	}
+
+	#[wasm_bindgen]
+	pub fn name(&self) -> String {
+		self.inner.name().to_owned()
+	}
+
+	#[wasm_bindgen]
+	pub fn key(&self) -> Result<JsValue, JsValue> {
+		let segments: Vec<WasmActorKeySegment> = self
+			.inner
+			.key()
+			.iter()
+			.map(|segment| match segment {
+				rivetkit_core::ActorKeySegment::String(value) => WasmActorKeySegment {
+					kind: "string".to_owned(),
+					string_value: Some(value.clone()),
+					number_value: None,
+				},
+				rivetkit_core::ActorKeySegment::Number(value) => WasmActorKeySegment {
+					kind: "number".to_owned(),
+					string_value: None,
+					number_value: Some(*value),
+				},
+			})
+			.collect();
+		serde_wasm_bindgen::to_value(&segments).map_err(Into::into)
+	}
+
+	#[wasm_bindgen]
+	pub fn region(&self) -> String {
+		self.inner.region().to_owned()
+	}
+
+	#[wasm_bindgen(js_name = beginOnStateChange)]
+	pub fn begin_on_state_change(&self) {
+		self.inner.on_state_change_started();
+	}
+
+	#[wasm_bindgen(js_name = endOnStateChange)]
+	pub fn end_on_state_change(&self) {
+		self.inner.on_state_change_finished();
+	}
+
+	#[wasm_bindgen(js_name = requestSave)]
+	pub fn request_save(&self, opts: JsValue) {
+		let opts: WasmRequestSaveOpts = if opts.is_null() || opts.is_undefined() {
+			WasmRequestSaveOpts::default()
+		} else {
+			serde_wasm_bindgen::from_value(opts).unwrap_or_default()
+		};
+		self.inner.request_save(RequestSaveOpts {
+			immediate: opts.immediate.unwrap_or(false),
+			max_wait_ms: opts.max_wait_ms,
+		});
+	}
+
+	#[wasm_bindgen(js_name = requestSaveAndWait)]
+	pub async fn request_save_and_wait(&self, opts: JsValue) -> Result<(), JsValue> {
+		let opts: WasmRequestSaveOpts = if opts.is_null() || opts.is_undefined() {
+			WasmRequestSaveOpts::default()
+		} else {
+			serde_wasm_bindgen::from_value(opts)?
+		};
+		self.inner.request_save(RequestSaveOpts {
+			immediate: opts.immediate.unwrap_or(false),
+			max_wait_ms: opts.max_wait_ms,
+		});
+		Ok(())
+	}
+
+	#[wasm_bindgen(js_name = saveState)]
+	pub async fn save_state(&self, payload: JsValue) -> Result<(), JsValue> {
+		let deltas = state_delta_payload_from_js(payload).map_err(anyhow_to_js_error)?;
+		self.inner
+			.save_state(deltas)
+			.await
+			.map_err(anyhow_to_js_error)
+	}
+
+	#[wasm_bindgen(js_name = verifyInspectorAuth)]
+	pub async fn verify_inspector_auth(&self, bearer_token: Option<String>) -> Result<(), JsValue> {
+		InspectorAuth::new()
+			.verify(&self.inner, bearer_token.as_deref())
+			.await
+			.map_err(anyhow_to_js_error)
+	}
+
+	#[wasm_bindgen(js_name = inspectorSnapshot)]
+	pub fn inspector_snapshot(&self) -> Result<Object, JsValue> {
+		let snapshot = self.inner.inspector_snapshot();
+		let object = object();
+		set(
+			&object,
+			"stateRevision",
+			JsValue::from_f64(snapshot.state_revision as f64),
+		)?;
+		set(
+			&object,
+			"connectionsRevision",
+			JsValue::from_f64(snapshot.connections_revision as f64),
+		)?;
+		set(
+			&object,
+			"queueRevision",
+			JsValue::from_f64(snapshot.queue_revision as f64),
+		)?;
+		set(
+			&object,
+			"activeConnections",
+			JsValue::from_f64(snapshot.active_connections as f64),
+		)?;
+		set(&object, "queueSize", JsValue::from_f64(snapshot.queue_size as f64))?;
+		set(
+			&object,
+			"connectedClients",
+			JsValue::from_f64(snapshot.connected_clients as f64),
+		)?;
+		Ok(object)
+	}
+
+	#[wasm_bindgen(js_name = takePendingHibernationChanges)]
+	pub fn take_pending_hibernation_changes(&self) -> Array {
+		let array = Array::new();
+		for conn_id in self.inner.take_pending_hibernation_changes() {
+			array.push(&JsValue::from_str(&conn_id));
+		}
+		array
+	}
+
+	#[wasm_bindgen(js_name = dirtyHibernatableConns)]
+	pub fn dirty_hibernatable_conns(&self) -> Array {
+		let array = Array::new();
+		for conn in self.inner.dirty_hibernatable_conns() {
+			array.push(&JsValue::from(WasmConnHandle::from_core(conn)));
+		}
+		array
+	}
+
+	#[wasm_bindgen]
+	pub fn conns(&self) -> Array {
+		let array = Array::new();
+		for conn in self.inner.conns() {
+			array.push(&JsValue::from(WasmConnHandle::from_core(conn)));
+		}
+		array
+	}
+
+	#[wasm_bindgen(js_name = connectConn)]
+	pub async fn connect_conn(
+		&self,
+		params: Vec<u8>,
+		request: JsValue,
+	) -> Result<WasmConnHandle, JsValue> {
+		let request = request_from_js(request).map_err(anyhow_to_js_error)?;
+		self.inner
+			.connect_conn_with_request(params, request, async { Ok(Vec::new()) })
+			.await
+			.map(WasmConnHandle::from_core)
+			.map_err(anyhow_to_js_error)
+	}
+
+	#[wasm_bindgen(js_name = setAlarm)]
+	pub fn set_alarm(&self, timestamp_ms: Option<f64>) -> Result<(), JsValue> {
+		let timestamp_ms = timestamp_ms
+			.filter(|value| value.is_finite())
+			.map(|value| value.trunc() as i64);
+		self.inner.set_alarm(timestamp_ms).map_err(anyhow_to_js_error)
+	}
+
+	#[wasm_bindgen]
+	pub fn sleep(&self) -> Result<(), JsValue> {
+		self.inner.sleep().map_err(anyhow_to_js_error)
+	}
+
+	#[wasm_bindgen]
+	pub fn destroy(&self) -> Result<(), JsValue> {
+		self.inner.destroy().map_err(anyhow_to_js_error)
+	}
+
+	#[wasm_bindgen(js_name = abortSignal)]
+	pub fn abort_signal(&self) -> Result<JsValue, JsValue> {
+		let controller = new_js_class("AbortController")?;
+		if self.inner.actor_aborted() {
+			call_js_method0(&controller, "abort")?;
+		} else {
+			let token = self.inner.actor_abort_signal();
+			let controller_for_task = controller.clone();
+			spawn_local(async move {
+				token.cancelled().await;
+				if let Err(error) = call_js_method0(&controller_for_task, "abort") {
+					console_error(&format!(
+						"failed to abort wasm actor abort signal: {}",
+						js_value_to_anyhow(error)
+					));
+				}
+			});
+		}
+		Reflect::get(&controller, &JsValue::from_str("signal"))
+	}
+
+	#[wasm_bindgen]
+	pub fn broadcast(&self, name: String, args: Vec<u8>) {
+		self.inner.broadcast(&name, &args);
+	}
+
+	#[wasm_bindgen(js_name = waitUntil)]
+	pub fn wait_until(&self, promise: Promise) {
+		let actor_id = self.inner.actor_id().to_owned();
+		self.inner.wait_until(async move {
+			if let Err(error) = JsFuture::from(promise).await {
+				console_error(&format!(
+					"actor wait_until promise rejected for actor {actor_id}: {}",
+					js_value_to_anyhow(error)
+				));
+			}
+		});
+	}
+
+	#[wasm_bindgen(js_name = keepAwake)]
+	pub async fn keep_awake(&self, promise: Promise) -> Result<JsValue, JsValue> {
+		self.inner
+			.keep_awake(JsFuture::from(promise))
+			.await
+			.map_err(|error| error)
+	}
+
+	#[wasm_bindgen(js_name = registerTask)]
+	pub fn register_task(&self, promise: Promise) {
+		self.wait_until(promise);
+	}
+
+	#[wasm_bindgen(js_name = restartRunHandler)]
+	pub fn restart_run_handler(&self) {
+		start_run_handler(&self.callbacks, self);
+	}
+
+	#[wasm_bindgen(js_name = beginWebsocketCallback)]
+	pub fn begin_websocket_callback(&self) -> u32 {
+		let mut regions = self.websocket_callback_regions.borrow_mut();
+		regions.push(Some(self.inner.websocket_callback_region()));
+		regions.len() as u32
+	}
+
+	#[wasm_bindgen(js_name = endWebsocketCallback)]
+	pub fn end_websocket_callback(&self, region_id: u32) {
+		if region_id == 0 {
+			return;
+		}
+		if let Some(region) = self
+			.websocket_callback_regions
+			.borrow_mut()
+			.get_mut(region_id as usize - 1)
+		{
+			region.take();
+		}
+	}
+
+	#[wasm_bindgen]
+	pub fn schedule(&self) -> WasmSchedule {
+		WasmSchedule {
+			inner: self.inner.clone(),
+		}
+	}
+
+	#[wasm_bindgen]
+	pub fn queue(&self) -> WasmQueue {
+		WasmQueue {
+			inner: self.inner.clone(),
+		}
+	}
+}
+
+#[wasm_bindgen(js_name = ConnHandle)]
+#[derive(Clone)]
+pub struct WasmConnHandle {
+	inner: rivetkit_core::ConnHandle,
+}
+
+#[wasm_bindgen(js_name = WebSocketHandle)]
+#[derive(Clone)]
+pub struct WasmWebSocket {
+	inner: WebSocket,
+}
+
+impl WasmConnHandle {
+	fn from_core(inner: rivetkit_core::ConnHandle) -> Self {
+		Self { inner }
+	}
+}
+
+#[wasm_bindgen(js_class = ConnHandle)]
+impl WasmConnHandle {
+	#[wasm_bindgen]
+	pub fn id(&self) -> String {
+		self.inner.id().to_owned()
+	}
+
+	#[wasm_bindgen]
+	pub fn params(&self) -> Vec<u8> {
+		self.inner.params()
+	}
+
+	#[wasm_bindgen]
+	pub fn state(&self) -> Vec<u8> {
+		self.inner.state()
+	}
+
+	#[wasm_bindgen(js_name = setState)]
+	pub fn set_state(&self, state: Vec<u8>) {
+		self.inner.set_state(state);
+	}
+
+	#[wasm_bindgen(js_name = isHibernatable)]
+	pub fn is_hibernatable(&self) -> bool {
+		self.inner.is_hibernatable()
+	}
+
+	#[wasm_bindgen]
+	pub fn send(&self, name: String, args: Vec<u8>) {
+		self.inner.send(&name, &args);
+	}
+
+	#[wasm_bindgen]
+	pub async fn disconnect(&self, reason: Option<String>) -> Result<(), JsValue> {
+		self.inner
+			.disconnect(reason.as_deref())
+			.await
+			.map_err(anyhow_to_js_error)
+	}
+}
+
+impl WasmWebSocket {
+	fn from_core(inner: WebSocket) -> Self {
+		Self { inner }
+	}
+}
+
+#[wasm_bindgen(js_class = WebSocketHandle)]
+impl WasmWebSocket {
+	#[wasm_bindgen]
+	pub fn send(&self, data: Vec<u8>, binary: bool) -> Result<(), JsValue> {
+		let message = if binary {
+			WsMessage::Binary(data)
+		} else {
+			WsMessage::Text(String::from_utf8(data).map_err(|error| {
+				js_error(&format!("websocket text frame is not valid utf-8: {error}"))
+			})?)
+		};
+		self.inner.send(message);
+		Ok(())
+	}
+
+	#[wasm_bindgen]
+	pub async fn close(&self, code: Option<u16>, reason: Option<String>) -> Result<(), JsValue> {
+		self.inner.close(code, reason).await;
+		Ok(())
+	}
+
+	#[wasm_bindgen(js_name = setEventCallback)]
+	pub fn set_event_callback(&self, callback: Function) {
+		let callback = Arc::new(WasmFunction(callback));
+		let message_callback = callback.clone();
+		self.inner
+			.configure_message_event_callback(Some(Arc::new(move |message, message_index| {
+				let event = websocket_message_event_to_js(message, message_index)
+					.map_err(js_value_to_anyhow)?;
+				message_callback.call1(&event)?;
+				Ok(())
+			})));
+
+		let callback = callback.clone();
+		self.inner
+			.configure_close_event_callback(Some(Arc::new(move |code, reason, was_clean| {
+				let callback = callback.clone();
+				let result = (|| {
+					let event = websocket_close_event_to_js(code, reason, was_clean)
+						.map_err(js_value_to_anyhow)?;
+					callback.call1(&event).map(|_| ())
+				})();
+				Box::pin(async move { result })
+			})));
+	}
+}
+
+#[wasm_bindgen(js_name = Schedule)]
+pub struct WasmSchedule {
+	inner: rivetkit_core::ActorContext,
+}
+
+#[wasm_bindgen(js_class = Schedule)]
+impl WasmSchedule {
+	#[wasm_bindgen]
+	pub fn after(&self, duration_ms: f64, action_name: String, args: Vec<u8>) {
+		let duration = if duration_ms.is_finite() && duration_ms > 0.0 {
+			Duration::from_millis(duration_ms as u64)
+		} else {
+			Duration::from_millis(0)
+		};
+		self.inner.after(duration, &action_name, &args);
+	}
+
+	#[wasm_bindgen]
+	pub fn at(&self, timestamp_ms: f64, action_name: String, args: Vec<u8>) {
+		self.inner.at(timestamp_ms as i64, &action_name, &args);
+	}
+}
+
+#[wasm_bindgen(js_name = Kv)]
+pub struct WasmKv {
+	inner: rivetkit_core::ActorContext,
+}
+
+#[wasm_bindgen(js_class = Kv)]
+impl WasmKv {
+	#[wasm_bindgen]
+	pub async fn get(&self, key: Vec<u8>) -> Result<JsValue, JsValue> {
+		self.inner
+			.kv_batch_get(&[key.as_slice()])
+			.await
+			.map(|mut values| match values.pop().flatten() {
+				Some(value) => bytes_to_js(&value),
+				None => JsValue::NULL,
+			})
+			.map_err(anyhow_to_js_error)
+	}
+
+	#[wasm_bindgen]
+	pub async fn put(&self, key: Vec<u8>, value: Vec<u8>) -> Result<(), JsValue> {
+		self.inner
+			.kv_batch_put(&[(key.as_slice(), value.as_slice())])
+			.await
+			.map_err(anyhow_to_js_error)
+	}
+
+	#[wasm_bindgen(js_name = delete)]
+	pub async fn delete_key(&self, key: Vec<u8>) -> Result<(), JsValue> {
+		self.inner
+			.kv_batch_delete(&[key.as_slice()])
+			.await
+			.map_err(anyhow_to_js_error)
+	}
+
+	#[wasm_bindgen(js_name = deleteRange)]
+	pub async fn delete_range(&self, start: Vec<u8>, end: Vec<u8>) -> Result<(), JsValue> {
+		self.inner
+			.kv_delete_range(&start, &end)
+			.await
+			.map_err(anyhow_to_js_error)
+	}
+
+	#[wasm_bindgen(js_name = listPrefix)]
+	pub async fn list_prefix(&self, prefix: Vec<u8>, options: JsValue) -> Result<JsValue, JsValue> {
+		self.inner
+			.kv_list_prefix(&prefix, list_opts_from_js(options)?)
+			.await
+			.map(kv_entries_to_js)
+			.map_err(anyhow_to_js_error)
+	}
+
+	#[wasm_bindgen(js_name = listRange)]
+	pub async fn list_range(
+		&self,
+		start: Vec<u8>,
+		end: Vec<u8>,
+		options: JsValue,
+	) -> Result<JsValue, JsValue> {
+		self.inner
+			.kv_list_range(&start, &end, list_opts_from_js(options)?)
+			.await
+			.map(kv_entries_to_js)
+			.map_err(anyhow_to_js_error)
+	}
+
+	#[wasm_bindgen(js_name = batchGet)]
+	pub async fn batch_get(&self, keys: Array) -> Result<JsValue, JsValue> {
+		let keys = bytes_array_from_js(keys);
+		let key_refs: Vec<&[u8]> = keys.iter().map(Vec::as_slice).collect();
+		self.inner
+			.kv_batch_get(&key_refs)
+			.await
+			.map(|values| {
+				let array = Array::new();
+				for value in values {
+					array.push(
+						&value
+							.map(|value| bytes_to_js(&value))
+							.unwrap_or(JsValue::NULL),
+					);
+				}
+				array.into()
+			})
+			.map_err(anyhow_to_js_error)
+	}
+
+	#[wasm_bindgen(js_name = batchPut)]
+	pub async fn batch_put(&self, entries: Array) -> Result<(), JsValue> {
+		let entries = kv_entries_from_js(entries)?;
+		let entry_refs: Vec<(&[u8], &[u8])> = entries
+			.iter()
+			.map(|(key, value)| (key.as_slice(), value.as_slice()))
+			.collect();
+		self.inner
+			.kv_batch_put(&entry_refs)
+			.await
+			.map_err(anyhow_to_js_error)
+	}
+
+	#[wasm_bindgen(js_name = batchDelete)]
+	pub async fn batch_delete(&self, keys: Array) -> Result<(), JsValue> {
+		let keys = bytes_array_from_js(keys);
+		let key_refs: Vec<&[u8]> = keys.iter().map(Vec::as_slice).collect();
+		self.inner
+			.kv_batch_delete(&key_refs)
+			.await
+			.map_err(anyhow_to_js_error)
+	}
+}
+
+#[wasm_bindgen(js_name = Queue)]
+pub struct WasmQueue {
+	inner: rivetkit_core::ActorContext,
+}
+
+#[wasm_bindgen(js_class = Queue)]
+impl WasmQueue {
+	#[wasm_bindgen]
+	pub async fn send(&self, name: String, body: Vec<u8>) -> Result<WasmQueueMessage, JsValue> {
+		self.inner
+			.send(&name, &body)
+			.await
+			.map(WasmQueueMessage::from_core)
+			.map_err(anyhow_to_js_error)
+	}
+
+	#[wasm_bindgen(js_name = nextBatch)]
+	pub async fn next_batch(
+		&self,
+		options: JsValue,
+		signal: Option<WasmCancellationToken>,
+	) -> Result<Array, JsValue> {
+		let mut options = queue_next_batch_options(options)?;
+		options.signal = signal.map(|signal| signal.inner);
+		let messages = self
+			.inner
+			.next_batch(options)
+			.await
+			.map_err(anyhow_to_js_error)?;
+		queue_messages_to_js(messages)
+	}
+
+	#[wasm_bindgen(js_name = waitForNames)]
+	pub async fn wait_for_names(
+		&self,
+		names: JsValue,
+		options: JsValue,
+		signal: Option<WasmCancellationToken>,
+	) -> Result<WasmQueueMessage, JsValue> {
+		let names: Vec<String> = serde_wasm_bindgen::from_value(names)?;
+		let mut options = queue_wait_options(options)?;
+		options.signal = signal.map(|signal| signal.inner);
+		self.inner
+			.wait_for_names(names, options)
+			.await
+			.map(WasmQueueMessage::from_core)
+			.map_err(anyhow_to_js_error)
+	}
+
+	#[wasm_bindgen(js_name = waitForNamesAvailable)]
+	pub async fn wait_for_names_available(
+		&self,
+		names: JsValue,
+		options: JsValue,
+	) -> Result<(), JsValue> {
+		let names: Vec<String> = serde_wasm_bindgen::from_value(names)?;
+		self
+			.inner
+			.wait_for_names_available(names, queue_wait_options(options)?)
+			.await
+			.map_err(anyhow_to_js_error)?;
+		Ok(())
+	}
+
+	#[wasm_bindgen(js_name = enqueueAndWait)]
+	pub async fn enqueue_and_wait(
+		&self,
+		name: String,
+		body: Vec<u8>,
+		options: JsValue,
+		signal: Option<WasmCancellationToken>,
+	) -> Result<Option<Vec<u8>>, JsValue> {
+		let mut options = enqueue_and_wait_options(options)?;
+		options.signal = signal.map(|signal| signal.inner);
+		self.inner
+			.enqueue_and_wait(&name, &body, options)
+			.await
+			.map_err(anyhow_to_js_error)
+	}
+
+	#[wasm_bindgen(js_name = tryNextBatch)]
+	pub fn try_next_batch(&self, options: JsValue) -> Result<Array, JsValue> {
+		let options = queue_try_next_batch_options(options)?;
+		let messages = self
+			.inner
+			.try_next_batch(options)
+			.map_err(anyhow_to_js_error)?;
+		queue_messages_to_js(messages)
+	}
+
+	#[wasm_bindgen(js_name = maxSize)]
+	pub fn max_size(&self) -> u32 {
+		self.inner.queue().max_size()
+	}
+
+	#[wasm_bindgen(js_name = inspectMessages)]
+	pub async fn inspect_messages(&self) -> Result<Array, JsValue> {
+		let messages = self
+			.inner
+			.inspect_messages()
+			.await
+			.map_err(anyhow_to_js_error)?;
+		let array = Array::new();
+		for message in messages {
+			let object = object();
+			set(&object, "id", JsValue::from_f64(message.id as f64))?;
+			set(&object, "name", JsValue::from_str(&message.name))?;
+			set(
+				&object,
+				"createdAtMs",
+				JsValue::from_f64(message.created_at as f64),
+			)?;
+			array.push(&object.into());
+		}
+		Ok(array)
+	}
+}
+
+#[wasm_bindgen(js_name = QueueMessage)]
+pub struct WasmQueueMessage {
+	inner: Option<QueueMessage>,
+}
+
+impl WasmQueueMessage {
+	fn from_core(inner: QueueMessage) -> Self {
+		Self { inner: Some(inner) }
+	}
+
+	fn inner(&self) -> &QueueMessage {
+		self.inner
+			.as_ref()
+			.expect_throw("queue message already completed")
+	}
+}
+
+#[wasm_bindgen(js_class = QueueMessage)]
+impl WasmQueueMessage {
+	#[wasm_bindgen]
+	pub fn id(&self) -> u64 {
+		self.inner().id
+	}
+
+	#[wasm_bindgen]
+	pub fn name(&self) -> String {
+		self.inner().name.clone()
+	}
+
+	#[wasm_bindgen]
+	pub fn body(&self) -> Vec<u8> {
+		self.inner().body.clone()
+	}
+
+	#[wasm_bindgen(js_name = createdAt)]
+	pub fn created_at(&self) -> f64 {
+		self.inner().created_at as f64
+	}
+
+	#[wasm_bindgen(js_name = isCompletable)]
+	pub fn is_completable(&self) -> bool {
+		self.inner()
+			.clone()
+			.into_completable()
+			.is_ok()
+	}
+
+	#[wasm_bindgen]
+	pub async fn complete(&mut self, response: JsValue) -> Result<(), JsValue> {
+		let message = self
+			.inner
+			.take()
+			.ok_or_else(|| js_error("queue message already completed"))?;
+		let response = if response.is_null() || response.is_undefined() {
+			None
+		} else {
+			Some(js_to_bytes(response))
+		};
+		message.complete(response).await.map_err(anyhow_to_js_error)
+	}
+}
+
+#[wasm_bindgen(js_name = SqliteDb)]
+pub struct WasmSqliteDb {
+	inner: rivetkit_core::SqliteDb,
+}
+
+#[wasm_bindgen(js_class = SqliteDb)]
+impl WasmSqliteDb {
+	#[wasm_bindgen]
+	pub async fn exec(&self, sql: String) -> Result<JsValue, JsValue> {
+		self.inner
+			.exec(sql)
+			.await
+			.map(query_result_to_js)
+			.map_err(anyhow_to_js_error)
+	}
+
+	#[wasm_bindgen]
+	pub async fn execute(&self, sql: String, params: JsValue) -> Result<JsValue, JsValue> {
+		self.inner
+			.execute(sql, bind_params_from_js(params)?)
+			.await
+			.map(execute_result_to_js)
+			.map_err(anyhow_to_js_error)
+	}
+
+	#[wasm_bindgen(js_name = executeWrite)]
+	pub async fn execute_write(&self, sql: String, params: JsValue) -> Result<JsValue, JsValue> {
+		self.inner
+			.execute_write(sql, bind_params_from_js(params)?)
+			.await
+			.map(execute_result_to_js)
+			.map_err(anyhow_to_js_error)
+	}
+
+	#[wasm_bindgen]
+	pub async fn query(&self, sql: String, params: JsValue) -> Result<JsValue, JsValue> {
+		self.inner
+			.query(sql, bind_params_from_js(params)?)
+			.await
+			.map(query_result_to_js)
+			.map_err(anyhow_to_js_error)
+	}
+
+	#[wasm_bindgen]
+	pub async fn run(&self, sql: String, params: JsValue) -> Result<JsValue, JsValue> {
+		let result = self
+			.inner
+			.run(sql, bind_params_from_js(params)?)
+			.await
+			.map_err(anyhow_to_js_error)?;
+		let object = object();
+		set(&object, "changes", JsValue::from_f64(result.changes as f64))?;
+		Ok(object.into())
+	}
+
+	#[wasm_bindgen]
+	pub async fn close(&self) -> Result<(), JsValue> {
+		self.inner.close().await.map_err(anyhow_to_js_error)
+	}
+}
+
+#[wasm_bindgen(js_name = bridgeRivetErrorPrefix)]
+pub fn bridge_rivet_error_prefix() -> String {
+	BRIDGE_RIVET_ERROR_PREFIX.to_string()
+}
+
+#[wasm_bindgen(js_name = roundTripBytes)]
+pub fn round_trip_bytes(bytes: Vec<u8>) -> Vec<u8> {
+	bytes
+}
+
+#[wasm_bindgen(js_name = uint8ArrayFromBytes)]
+pub fn uint8_array_from_bytes(bytes: Vec<u8>) -> Uint8Array {
+	Uint8Array::from(bytes.as_slice())
+}
+
+#[wasm_bindgen(js_name = awaitPromise)]
+pub async fn await_promise(promise: Promise) -> Result<JsValue, JsValue> {
+	JsFuture::from(promise).await
+}
+
+#[derive(Default, serde::Deserialize)]
+#[serde(default, rename_all = "camelCase")]
+struct WasmRequestSaveOpts {
+	immediate: Option<bool>,
+	max_wait_ms: Option<u32>,
+}
+
+#[derive(Default, serde::Deserialize)]
+#[serde(default, rename_all = "camelCase")]
+struct WasmQueueNextBatchOptions {
+	names: Option<Vec<String>>,
+	count: Option<u32>,
+	timeout_ms: Option<f64>,
+	completable: Option<bool>,
+}
+
+#[derive(Default, serde::Deserialize)]
+#[serde(default, rename_all = "camelCase")]
+struct WasmQueueWaitOptions {
+	timeout_ms: Option<f64>,
+	completable: Option<bool>,
+}
+
+#[derive(Default, serde::Deserialize)]
+#[serde(default, rename_all = "camelCase")]
+struct WasmQueueEnqueueAndWaitOptions {
+	timeout_ms: Option<f64>,
+}
+
+#[derive(Default, serde::Deserialize)]
+#[serde(default, rename_all = "camelCase")]
+struct WasmQueueTryNextBatchOptions {
+	names: Option<Vec<String>>,
+	count: Option<u32>,
+	completable: Option<bool>,
+}
+
+#[derive(serde::Serialize)]
+#[serde(rename_all = "camelCase")]
+struct WasmActorKeySegment {
+	kind: String,
+	string_value: Option<String>,
+	number_value: Option<f64>,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct WasmStateDeltaPayload {
+	state: Option<Vec<u8>>,
+	conn_hibernation: Vec<WasmConnHibernationEntry>,
+	conn_hibernation_removed: Vec<String>,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct WasmConnHibernationEntry {
+	conn_id: String,
+	bytes: Vec<u8>,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct WasmBindParam {
+	kind: String,
+	int_value: Option<f64>,
+	float_value: Option<f64>,
+	text_value: Option<String>,
+	blob_value: Option<Vec<u8>>,
+}
+
+fn optional_timeout_ms(timeout_ms: Option<f64>) -> Option<Duration> {
+	let timeout_ms = timeout_ms?;
+	if !timeout_ms.is_finite() || timeout_ms < 0.0 {
+		return None;
+	}
+	Some(Duration::from_millis(timeout_ms as u64))
+}
+
+fn queue_next_batch_options(value: JsValue) -> Result<QueueNextBatchOpts, JsValue> {
+	let options: WasmQueueNextBatchOptions = if value.is_null() || value.is_undefined() {
+		WasmQueueNextBatchOptions::default()
+	} else {
+		serde_wasm_bindgen::from_value(value)?
+	};
+	Ok(QueueNextBatchOpts {
+		names: options.names,
+		count: options.count.unwrap_or(1),
+		timeout: optional_timeout_ms(options.timeout_ms),
+		signal: None,
+		completable: options.completable.unwrap_or(false),
+	})
+}
+
+fn queue_wait_options(value: JsValue) -> Result<QueueWaitOpts, JsValue> {
+	let options: WasmQueueWaitOptions = if value.is_null() || value.is_undefined() {
+		WasmQueueWaitOptions::default()
+	} else {
+		serde_wasm_bindgen::from_value(value)?
+	};
+	Ok(QueueWaitOpts {
+		timeout: optional_timeout_ms(options.timeout_ms),
+		signal: None,
+		completable: options.completable.unwrap_or(false),
+	})
+}
+
+fn enqueue_and_wait_options(value: JsValue) -> Result<EnqueueAndWaitOpts, JsValue> {
+	let options: WasmQueueEnqueueAndWaitOptions = if value.is_null() || value.is_undefined() {
+		WasmQueueEnqueueAndWaitOptions::default()
+	} else {
+		serde_wasm_bindgen::from_value(value)?
+	};
+	Ok(EnqueueAndWaitOpts {
+		timeout: optional_timeout_ms(options.timeout_ms),
+		signal: None,
+	})
+}
+
+fn queue_try_next_batch_options(value: JsValue) -> Result<QueueTryNextBatchOpts, JsValue> {
+	let options: WasmQueueTryNextBatchOptions = if value.is_null() || value.is_undefined() {
+		WasmQueueTryNextBatchOptions::default()
+	} else {
+		serde_wasm_bindgen::from_value(value)?
+	};
+	Ok(QueueTryNextBatchOpts {
+		names: options.names,
+		count: options.count.unwrap_or(1),
+		completable: options.completable.unwrap_or(false),
+	})
+}
+
+fn queue_messages_to_js(messages: Vec<QueueMessage>) -> Result<Array, JsValue> {
+	let array = Array::new();
+	for message in messages {
+		array.push(&JsValue::from(WasmQueueMessage::from_core(message)));
+	}
+	Ok(array)
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct WasmQueueSendResult {
+	status: String,
+	response: Option<Vec<u8>>,
+}
+
+fn request_to_js(request: Request) -> Result<JsValue> {
+	let (method, uri, headers, body) = request.to_parts();
+	let request_object = object();
+	set_anyhow(&request_object, "method", JsValue::from_str(&method))?;
+	set_anyhow(&request_object, "uri", JsValue::from_str(&uri))?;
+	let headers_object = object();
+	for (name, value) in headers {
+		set_anyhow(&headers_object, &name, JsValue::from_str(&value))?;
+	}
+	set_anyhow(&request_object, "headers", headers_object.into())?;
+	set_anyhow(&request_object, "body", bytes_to_js(&body))?;
+	Ok(request_object.into())
+}
+
+fn request_from_js(value: JsValue) -> Result<Option<Request>> {
+	if value.is_null() || value.is_undefined() {
+		return Ok(None);
+	}
+	let method = js_string_property(&value, "method")?.unwrap_or_else(|| "GET".to_owned());
+	let uri = js_string_property(&value, "uri")?.unwrap_or_else(|| "/".to_owned());
+	Ok(Some(Request::from_parts(
+		&method,
+		&uri,
+		js_string_map_property(&value, "headers")?,
+		js_bytes_property(&value, "body")?.unwrap_or_default(),
+	)?))
+}
+
+fn response_from_js(value: JsValue) -> Result<Response> {
+	Response::from_parts(
+		js_number_property(&value, "status")?.unwrap_or(200.0) as u16,
+		js_string_map_property(&value, "headers")?,
+		js_bytes_property(&value, "body")?.unwrap_or_default(),
+	)
+}
+
+fn queue_send_result_from_js(value: JsValue) -> Result<QueueSendResult> {
+	let result: WasmQueueSendResult = serde_wasm_bindgen::from_value(value)
+		.map_err(|error| anyhow!("decode queue send result: {error}"))?;
+	let status = match result.status.as_str() {
+		"completed" => QueueSendStatus::Completed,
+		"timedOut" => QueueSendStatus::TimedOut,
+		other => return Err(anyhow!("invalid queue send status `{other}`")),
+	};
+	Ok(QueueSendResult {
+		status,
+		response: result.response,
+	})
+}
+
+fn websocket_message_event_to_js(
+	message: WsMessage,
+	message_index: Option<u16>,
+) -> Result<JsValue, JsValue> {
+	let object = object();
+	set(&object, "kind", JsValue::from_str("message"))?;
+	match message {
+		WsMessage::Text(text) => {
+			set(&object, "binary", JsValue::FALSE)?;
+			set(&object, "data", JsValue::from_str(&text))?;
+		}
+		WsMessage::Binary(bytes) => {
+			set(&object, "binary", JsValue::TRUE)?;
+			set(&object, "data", bytes_to_js(&bytes))?;
+		}
+	}
+	if let Some(message_index) = message_index {
+		set(
+			&object,
+			"messageIndex",
+			JsValue::from_f64(message_index as f64),
+		)?;
+	}
+	Ok(object.into())
+}
+
+fn websocket_close_event_to_js(
+	code: u16,
+	reason: String,
+	was_clean: bool,
+) -> Result<JsValue, JsValue> {
+	let object = object();
+	set(&object, "kind", JsValue::from_str("close"))?;
+	set(&object, "code", JsValue::from_f64(code as f64))?;
+	set(&object, "reason", JsValue::from_str(&reason))?;
+	set(&object, "wasClean", JsValue::from_bool(was_clean))?;
+	Ok(object.into())
+}
+
+fn object() -> Object {
+	Object::new()
+}
+
+fn set(object: &Object, key: &str, value: JsValue) -> Result<(), JsValue> {
+	Reflect::set(object, &JsValue::from_str(key), &value).map(|_| ())
+}
+
+fn set_anyhow(object: &Object, key: &str, value: JsValue) -> Result<()> {
+	set(object, key, value).map_err(js_value_to_anyhow)
+}
+
+fn bytes_to_js(bytes: &[u8]) -> JsValue {
+	Uint8Array::from(bytes).into()
+}
+
+fn js_to_bytes(value: JsValue) -> Vec<u8> {
+	if value.is_null() || value.is_undefined() {
+		return Vec::new();
+	}
+	Uint8Array::new(&value).to_vec()
+}
+
+fn function_property(target: &JsValue, name: &str) -> Option<Function> {
+	Reflect::get(target, &JsValue::from_str(name))
+		.ok()
+		.and_then(|value| {
+			if value.is_null() || value.is_undefined() {
+				None
+			} else {
+				value.dyn_into::<Function>().ok()
+			}
+		})
+}
+
+fn js_property(target: &JsValue, name: &str) -> Result<JsValue> {
+	Reflect::get(target, &JsValue::from_str(name)).map_err(js_value_to_anyhow)
+}
+
+fn js_string_property(target: &JsValue, name: &str) -> Result<Option<String>> {
+	let value = js_property(target, name)?;
+	if value.is_null() || value.is_undefined() {
+		return Ok(None);
+	}
+	value
+		.as_string()
+		.map(Some)
+		.ok_or_else(|| anyhow!("property `{name}` must be a string"))
+}
+
+fn js_number_property(target: &JsValue, name: &str) -> Result<Option<f64>> {
+	let value = js_property(target, name)?;
+	if value.is_null() || value.is_undefined() {
+		return Ok(None);
+	}
+	value
+		.as_f64()
+		.map(Some)
+		.ok_or_else(|| anyhow!("property `{name}` must be a number"))
+}
+
+fn js_bool_property(target: &JsValue, name: &str) -> Result<Option<bool>> {
+	let value = js_property(target, name)?;
+	if value.is_null() || value.is_undefined() {
+		return Ok(None);
+	}
+	value
+		.as_bool()
+		.map(Some)
+		.ok_or_else(|| anyhow!("property `{name}` must be a boolean"))
+}
+
+fn js_bytes_property(target: &JsValue, name: &str) -> Result<Option<Vec<u8>>> {
+	let value = js_property(target, name)?;
+	if value.is_null() || value.is_undefined() {
+		return Ok(None);
+	}
+	Ok(Some(js_to_bytes(value)))
+}
+
+fn js_string_map_property(target: &JsValue, name: &str) -> Result<HashMap<String, String>> {
+	let value = js_property(target, name)?;
+	if value.is_null() || value.is_undefined() {
+		return Ok(HashMap::new());
+	}
+	let object = value
+		.dyn_into::<Object>()
+		.map_err(|_| anyhow!("property `{name}` must be an object"))?;
+	let keys = Object::keys(&object);
+	let mut map = HashMap::new();
+	for index in 0..keys.length() {
+		let key = keys
+			.get(index)
+			.as_string()
+			.ok_or_else(|| anyhow!("property `{name}` contains a non-string key"))?;
+		let value = Reflect::get(&object, &JsValue::from_str(&key))
+			.map_err(js_value_to_anyhow)?
+			.as_string()
+			.ok_or_else(|| anyhow!("property `{name}.{key}` must be a string"))?;
+		map.insert(key, value);
+	}
+	Ok(map)
+}
+
+fn required_js_string_property(target: &JsValue, name: &str) -> Result<String> {
+	js_string_property(target, name)?
+		.ok_or_else(|| anyhow!("property `{name}` must be a string"))
+}
+
+fn serverless_request_from_js(
+	value: JsValue,
+	cancel_token: CoreCancellationToken,
+) -> Result<ServerlessRequest> {
+	let method = required_js_string_property(&value, "method")?;
+	let url = required_js_string_property(&value, "url")?;
+	let headers = js_string_map_property(&value, "headers")?;
+	let body = js_bytes_property(&value, "body")?.unwrap_or_default();
+	Ok(ServerlessRequest {
+		method,
+		url,
+		headers,
+		body,
+		cancel_token,
+	})
+}
+
+fn serverless_response_head_to_js(status: u16, headers: HashMap<String, String>) -> Result<JsValue> {
+	let head = object();
+	set_anyhow(&head, "status", JsValue::from_f64(status as f64))?;
+	let header_object = object();
+	for (key, value) in headers {
+		set_anyhow(&header_object, &key, JsValue::from_str(&value))?;
+	}
+	set_anyhow(&head, "headers", header_object.into())?;
+	Ok(head.into())
+}
+
+fn serverless_stream_chunk_event(chunk: Vec<u8>) -> Result<JsValue> {
+	let event = object();
+	set_anyhow(&event, "kind", JsValue::from_str("chunk"))?;
+	set_anyhow(&event, "chunk", bytes_to_js(&chunk))?;
+	Ok(event.into())
+}
+
+fn serverless_stream_end_event(
+	error: Option<rivetkit_core::serverless::ServerlessStreamError>,
+) -> Result<JsValue> {
+	let event = object();
+	set_anyhow(&event, "kind", JsValue::from_str("end"))?;
+	if let Some(error) = error {
+		let error_object = object();
+		set_anyhow(&error_object, "group", JsValue::from_str(&error.group))?;
+		set_anyhow(&error_object, "code", JsValue::from_str(&error.code))?;
+		set_anyhow(&error_object, "message", JsValue::from_str(&error.message))?;
+		set_anyhow(&event, "error", error_object.into())?;
+	}
+	Ok(event.into())
+}
+
+async fn call_serverless_stream_callback(
+	callback: &Function,
+	event: JsValue,
+) -> Result<()> {
+	let value = callback
+		.call2(&JsValue::UNDEFINED, &JsValue::NULL, &event)
+		.map_err(js_value_to_anyhow)?;
+	if value.is_instance_of::<Promise>() {
+		JsFuture::from(Promise::unchecked_from_js(value))
+			.await
+			.map_err(js_value_to_anyhow)?;
+	}
+	Ok(())
+}
+
+async fn start_wasm_serverless_request(
+	runtime: CoreServerlessRuntime,
+	req: ServerlessRequest,
+	on_stream_event: Function,
+) -> Result<JsValue, JsValue> {
+	let (head_tx, head_rx) = oneshot::channel::<Result<JsValue, String>>();
+	let (done_tx, done_rx) = oneshot::channel::<()>();
+	let local = tokio::task::LocalSet::new();
+	local.spawn_local(async move {
+		let response = runtime.handle_request(req).await;
+		match serverless_response_head_to_js(response.status, response.headers) {
+			Ok(head) => {
+				if head_tx.send(Ok(head)).is_err() {
+					let _ = done_tx.send(());
+					return;
+				}
+			}
+			Err(error) => {
+				let _ = head_tx.send(Err(format!("{error:#}")));
+				let _ = done_tx.send(());
+				return;
+			}
+		}
+
+		let mut body = response.body;
+		let mut sent_end = false;
+		while let Some(chunk) = body.recv().await {
+			let event = match chunk {
+				Ok(chunk) => serverless_stream_chunk_event(chunk),
+				Err(error) => {
+					sent_end = true;
+					serverless_stream_end_event(Some(error))
+				}
+			};
+			match event {
+				Ok(event) => {
+					if let Err(error) =
+						call_serverless_stream_callback(&on_stream_event, event).await
+					{
+						console_error(&format!("wasm serverless stream callback failed: {error:#}"));
+						break;
+					}
+				}
+				Err(error) => {
+					console_error(&format!("wasm serverless stream event encode failed: {error:#}"));
+					break;
+				}
+			}
+			if sent_end {
+				break;
+			}
+		}
+
+		if !sent_end {
+			match serverless_stream_end_event(None) {
+				Ok(event) => {
+					if let Err(error) =
+						call_serverless_stream_callback(&on_stream_event, event).await
+					{
+						console_error(&format!(
+							"wasm serverless stream end callback failed: {error:#}"
+						));
+					}
+				}
+				Err(error) => {
+					console_error(&format!(
+						"wasm serverless stream end event encode failed: {error:#}"
+					));
+				}
+			}
+		}
+
+		let _ = done_tx.send(());
+	});
+	spawn_local(async move {
+		local.run_until(async {
+			let _ = done_rx.await;
+		}).await;
+	});
+
+	match head_rx.await {
+		Ok(Ok(head)) => Ok(head),
+		Ok(Err(error)) => Err(js_error(&error)),
+		Err(_) => Err(js_error("serverless request driver dropped response head")),
+	}
+}
+
+fn list_opts_from_js(value: JsValue) -> Result<ListOpts, JsValue> {
+	if value.is_null() || value.is_undefined() {
+		return Ok(ListOpts::default());
+	}
+	let reverse = js_bool_property(&value, "reverse").map_err(anyhow_to_js_error)?;
+	let limit = js_number_property(&value, "limit").map_err(anyhow_to_js_error)?;
+	Ok(ListOpts {
+		reverse: reverse.unwrap_or(false),
+		limit: limit.map(|value| value.max(0.0).trunc() as u32),
+	})
+}
+
+fn bytes_array_from_js(values: Array) -> Vec<Vec<u8>> {
+	(0..values.length())
+		.map(|index| js_to_bytes(values.get(index)))
+		.collect()
+}
+
+fn kv_entries_from_js(entries: Array) -> Result<Vec<(Vec<u8>, Vec<u8>)>, JsValue> {
+	let mut decoded = Vec::with_capacity(entries.length() as usize);
+	for index in 0..entries.length() {
+		let entry = entries.get(index);
+		let key = js_bytes_property(&entry, "key")
+			.map_err(anyhow_to_js_error)?
+			.ok_or_else(|| js_error("kv entry missing key"))?;
+		let value = js_bytes_property(&entry, "value")
+			.map_err(anyhow_to_js_error)?
+			.ok_or_else(|| js_error("kv entry missing value"))?;
+		decoded.push((key, value));
+	}
+	Ok(decoded)
+}
+
+fn kv_entries_to_js(entries: Vec<(Vec<u8>, Vec<u8>)>) -> JsValue {
+	let array = Array::new();
+	for (key, value) in entries {
+		let entry = object();
+		set(&entry, "key", bytes_to_js(&key)).unwrap_throw();
+		set(&entry, "value", bytes_to_js(&value)).unwrap_throw();
+		array.push(&entry.into());
+	}
+	array.into()
+}
+
+fn action_callback(actions: &JsValue, name: &str) -> Option<Function> {
+	function_property(actions, name)
+}
+
+async fn call_callback(callback: &Function, payload: &JsValue) -> Result<JsValue> {
+	let value = callback
+		.call2(&JsValue::UNDEFINED, &JsValue::NULL, payload)
+		.map_err(js_value_to_anyhow)?;
+	if value.is_instance_of::<Promise>() {
+		JsFuture::from(Promise::unchecked_from_js(value))
+			.await
+			.map_err(js_value_to_anyhow)
+	} else {
+		Ok(value)
+	}
+}
+
+async fn call_callback_bytes(callback: &Function, payload: &JsValue) -> Result<Vec<u8>> {
+	call_callback(callback, payload).await.map(js_to_bytes)
+}
+
+fn state_delta_payload_from_js(value: JsValue) -> Result<Vec<StateDelta>> {
+	if value.is_null() || value.is_undefined() {
+		return Ok(Vec::new());
+	}
+
+	let payload: WasmStateDeltaPayload = serde_wasm_bindgen::from_value(value)
+		.map_err(|error| anyhow!("decode state delta payload: {error}"))?;
+	let mut deltas = Vec::new();
+	if let Some(state) = payload.state {
+		deltas.push(StateDelta::ActorState(state));
+	}
+	for entry in payload.conn_hibernation {
+		deltas.push(StateDelta::ConnHibernation {
+			conn: entry.conn_id,
+			bytes: entry.bytes,
+		});
+	}
+	for conn_id in payload.conn_hibernation_removed {
+		deltas.push(StateDelta::ConnHibernationRemoved(conn_id));
+	}
+	Ok(deltas)
+}
+
+fn bind_params_from_js(value: JsValue) -> Result<Option<Vec<BindParam>>, JsValue> {
+	if value.is_null() || value.is_undefined() {
+		return Ok(None);
+	}
+
+	let params: Vec<WasmBindParam> = serde_wasm_bindgen::from_value(value)?;
+	params
+		.into_iter()
+		.map(|param| match param.kind.as_str() {
+			"null" => Ok(BindParam::Null),
+			"int" => Ok(BindParam::Integer(param.int_value.unwrap_or(0.0) as i64)),
+			"float" => Ok(BindParam::Float(param.float_value.unwrap_or(0.0))),
+			"text" => Ok(BindParam::Text(param.text_value.unwrap_or_default())),
+			"blob" => Ok(BindParam::Blob(param.blob_value.unwrap_or_default())),
+			kind => Err(js_error(&format!("unsupported bind parameter kind: {kind}"))),
+		})
+		.collect::<Result<Vec<_>, _>>()
+		.map(Some)
+}
+
+fn query_result_to_js(result: rivetkit_core::QueryResult) -> JsValue {
+	let object = object();
+	set(&object, "columns", strings_to_js_array(result.columns).into()).unwrap_throw();
+	set(&object, "rows", rows_to_js_array(result.rows).into()).unwrap_throw();
+	object.into()
+}
+
+fn execute_result_to_js(result: rivetkit_core::ExecuteResult) -> JsValue {
+	let object = object();
+	set(&object, "columns", strings_to_js_array(result.columns).into()).unwrap_throw();
+	set(&object, "rows", rows_to_js_array(result.rows).into()).unwrap_throw();
+	set(&object, "changes", JsValue::from_f64(result.changes as f64)).unwrap_throw();
+	if let Some(last_insert_row_id) = result.last_insert_row_id {
+		set(
+			&object,
+			"lastInsertRowId",
+			JsValue::from_f64(last_insert_row_id as f64),
+		)
+		.unwrap_throw();
+	}
+	set(
+		&object,
+		"route",
+		JsValue::from_str(match result.route {
+			ExecuteRoute::Read => "read",
+			ExecuteRoute::Write => "write",
+			ExecuteRoute::WriteFallback => "writeFallback",
+		}),
+	)
+	.unwrap_throw();
+	object.into()
+}
+
+fn strings_to_js_array(values: Vec<String>) -> Array {
+	let array = Array::new();
+	for value in values {
+		array.push(&JsValue::from_str(&value));
+	}
+	array
+}
+
+fn rows_to_js_array(rows: Vec<Vec<ColumnValue>>) -> Array {
+	let array = Array::new();
+	for row in rows {
+		let row_array = Array::new();
+		for value in row {
+			row_array.push(&column_value_to_js(value));
+		}
+		array.push(&row_array);
+	}
+	array
+}
+
+fn column_value_to_js(value: ColumnValue) -> JsValue {
+	match value {
+		ColumnValue::Null => JsValue::NULL,
+		ColumnValue::Integer(value) => JsValue::from_f64(value as f64),
+		ColumnValue::Float(value) => JsValue::from_f64(value),
+		ColumnValue::Text(value) => JsValue::from_str(&value),
+		ColumnValue::Blob(value) => bytes_to_js(&value),
+	}
+}
+
+fn new_js_class(name: &str) -> Result<JsValue, JsValue> {
+	let constructor = Reflect::get(&js_sys::global(), &JsValue::from_str(name))?
+		.dyn_into::<Function>()
+		.map_err(|_| js_error(&format!("{name} is not a constructor")))?;
+	Reflect::construct(&constructor, &Array::new())
+}
+
+fn call_js_method0(target: &JsValue, name: &str) -> Result<JsValue, JsValue> {
+	let method = Reflect::get(target, &JsValue::from_str(name))?
+		.dyn_into::<Function>()
+		.map_err(|_| js_error(&format!("{name} is not a function")))?;
+	method.call0(target)
+}
+
+fn js_value_to_anyhow(value: JsValue) -> anyhow::Error {
+	if let Some(error) = value.dyn_ref::<js_sys::Error>() {
+		let message = error
+			.message()
+			.as_string()
+			.unwrap_or_else(|| "JavaScript error".to_owned());
+		return parse_bridge_rivet_error(&message).unwrap_or_else(|| anyhow!(message));
+	}
+	if let Some(message) = value.as_string() {
+		return parse_bridge_rivet_error(&message).unwrap_or_else(|| anyhow!(message));
+	}
+	anyhow!("JavaScript callback failed")
+}
+
+fn leak_str(value: String) -> &'static str {
+	Box::leak(value.into_boxed_str())
+}
+
+fn bridge_rivet_error_schema(payload: &BridgeRivetErrorPayload) -> &'static RivetErrorSchema {
+	Box::leak(Box::new(RivetErrorSchema {
+		group: leak_str(payload.group.clone()),
+		code: leak_str(payload.code.clone()),
+		default_message: leak_str(payload.message.clone()),
+		meta_type: None,
+		_macro_marker: MacroMarker { _private: () },
+	}))
+}
+
+fn parse_bridge_rivet_error(reason: &str) -> Option<anyhow::Error> {
+	let prefix_index = reason.find(BRIDGE_RIVET_ERROR_PREFIX)?;
+	let payload = &reason[prefix_index + BRIDGE_RIVET_ERROR_PREFIX.len()..];
+	let payload: BridgeRivetErrorPayload = match serde_json::from_str(payload) {
+		Ok(payload) => payload,
+		Err(parse_err) => {
+			console_error(&format!("malformed BridgeRivetErrorPayload: {parse_err}"));
+			return None;
+		}
+	};
+	let schema = bridge_rivet_error_schema(&payload);
+	let meta = payload
+		.metadata
+		.as_ref()
+		.and_then(|metadata| serde_json::value::to_raw_value(metadata).ok());
+	let error = anyhow::Error::new(RivetTransportError {
+		schema,
+		meta,
+		message: Some(payload.message),
+	});
+	Some(error.context(BridgeRivetErrorContext {
+		public_: payload.public_,
+		status_code: payload.status_code,
+	}))
+}
+
+fn console_error(message: &str) {
+	let global = js_sys::global();
+	let Ok(console) = Reflect::get(&global, &JsValue::from_str("console")) else {
+		return;
+	};
+	let Ok(error_fn) = Reflect::get(&console, &JsValue::from_str("error")) else {
+		return;
+	};
+	let Ok(error_fn) = error_fn.dyn_into::<Function>() else {
+		return;
+	};
+	let _ = error_fn.call1(&console, &JsValue::from_str(message));
+}
+
+fn js_error(message: &str) -> JsValue {
+	js_sys::Error::new(message).into()
+}
+
+fn registry_not_registering_error() -> JsValue {
+	anyhow_to_js_error(
+		WasmInvalidState {
+			state: "core registry".to_owned(),
+			reason: "already serving or shut down".to_owned(),
+		}
+		.build(),
+	)
+}
+
+fn registry_wrong_mode_error() -> JsValue {
+	anyhow_to_js_error(
+		WasmInvalidState {
+			state: "core registry".to_owned(),
+			reason: "mode conflict: another run mode is already active".to_owned(),
+		}
+		.build(),
+	)
+}
+
+fn registry_shut_down_error() -> JsValue {
+	anyhow_to_js_error(
+		WasmInvalidState {
+			state: "core registry".to_owned(),
+			reason: "shut down".to_owned(),
+		}
+		.build(),
+	)
+}
+
+fn anyhow_to_js_error(error: anyhow::Error) -> JsValue {
+	let bridge_context = error
+		.chain()
+		.find_map(|cause| cause.downcast_ref::<BridgeRivetErrorContext>());
+	let error = RivetTransportError::extract(&error);
+	let public_ = bridge_context.and_then(|context| context.public_);
+	let status_code = bridge_context.and_then(|context| context.status_code);
+	let payload = serde_json::json!({
+		"group": error.group(),
+		"code": error.code(),
+		"message": error.message(),
+		"metadata": error.metadata(),
+		"public": public_,
+		"statusCode": status_code,
+	});
+	js_sys::Error::new(&format!("{BRIDGE_RIVET_ERROR_PREFIX}{payload}")).into()
+}
diff --git a/rivetkit-typescript/packages/rivetkit-wasm/tsconfig.json b/rivetkit-typescript/packages/rivetkit-wasm/tsconfig.json
new file mode 100644
index 0000000000..1d14e6f37c
--- /dev/null
+++ b/rivetkit-typescript/packages/rivetkit-wasm/tsconfig.json
@@ -0,0 +1,10 @@
+{
+	"extends": "../../../tsconfig.base.json",
+	"compilerOptions": {
+		"declaration": true,
+		"lib": ["ESNext", "DOM", "WebWorker"],
+		"types": []
+	},
+	"exclude": ["node_modules", "pkg", "pkg-cloudflare", "pkg-deno"],
+	"include": ["index.d.ts"]
+}
diff --git a/rivetkit-typescript/packages/rivetkit-wasm/turbo.json b/rivetkit-typescript/packages/rivetkit-wasm/turbo.json
new file mode 100644
index 0000000000..29d4cb2625
--- /dev/null
+++ b/rivetkit-typescript/packages/rivetkit-wasm/turbo.json
@@ -0,0 +1,4 @@
+{
+	"$schema": "https://turbo.build/schema.json",
+	"extends": ["//"]
+}
diff --git a/rivetkit-typescript/packages/rivetkit/fixtures/driver-test-suite/actor-db-raw.ts b/rivetkit-typescript/packages/rivetkit/fixtures/driver-test-suite/actor-db-raw.ts
index fe0ac59a98..b9f9650712 100644
--- a/rivetkit-typescript/packages/rivetkit/fixtures/driver-test-suite/actor-db-raw.ts
+++ b/rivetkit-typescript/packages/rivetkit/fixtures/driver-test-suite/actor-db-raw.ts
@@ -370,9 +370,26 @@ export const dbActorRaw = actor({
 		triggerSleep: (c) => {
 			scheduleActorSleep(c);
 		},
+		destroy: (c) => {
+			c.destroy();
+		},
+		ping: () => "pong",
 	},
 	options: {
 		actionTimeout: 120_000,
 		sleepTimeout: 100,
 	},
 });
+
+export const dbRemoteLifecycleProbe = actor({
+	db: db(),
+	actions: {
+		ping: () => "pong",
+		triggerSleep: (c) => {
+			scheduleActorSleep(c);
+		},
+	},
+	options: {
+		sleepTimeout: 100,
+	},
+});
diff --git a/rivetkit-typescript/packages/rivetkit/fixtures/driver-test-suite/queue.ts b/rivetkit-typescript/packages/rivetkit/fixtures/driver-test-suite/queue.ts
index ec3dfd7b89..a2ccd911c2 100644
--- a/rivetkit-typescript/packages/rivetkit/fixtures/driver-test-suite/queue.ts
+++ b/rivetkit-typescript/packages/rivetkit/fixtures/driver-test-suite/queue.ts
@@ -303,7 +303,7 @@ export const manyQueueRunParentActor = actor({
 	},
 	actions: {
 		queueSpawn: async (c, key: string) => {
-			await c.queue.send("spawn", { key });
+			await c.queue.enqueueAndWait("spawn", { key }, { timeout: 10_000 });
 			return { queued: true };
 		},
 		getSpawned: (c) => c.state.spawned,
diff --git a/rivetkit-typescript/packages/rivetkit/fixtures/driver-test-suite/registry-static.ts b/rivetkit-typescript/packages/rivetkit/fixtures/driver-test-suite/registry-static.ts
index 722eb42158..21535f5d8f 100644
--- a/rivetkit-typescript/packages/rivetkit/fixtures/driver-test-suite/registry-static.ts
+++ b/rivetkit-typescript/packages/rivetkit/fixtures/driver-test-suite/registry-static.ts
@@ -19,7 +19,7 @@ import {
 	promiseActor,
 	syncActionActor,
 } from "./action-types";
-import { dbActorRaw } from "./actor-db-raw";
+import { dbActorRaw, dbRemoteLifecycleProbe } from "./actor-db-raw";
 import { onStateChangeActor } from "./actor-onstatechange";
 import { connErrorSerializationActor } from "./conn-error-serialization";
 import {
@@ -319,6 +319,7 @@ export const registry = setup({
 		workflowSpawnParentActor,
 		// From actor-db-raw.ts
 		dbActorRaw,
+		dbRemoteLifecycleProbe,
 		// From db-lifecycle.ts
 		dbLifecycle,
 		dbLifecycleFailing,
diff --git a/rivetkit-typescript/packages/rivetkit/fixtures/driver-test-suite/start-stop-race.ts b/rivetkit-typescript/packages/rivetkit/fixtures/driver-test-suite/start-stop-race.ts
index eff49dcb15..3829970adb 100644
--- a/rivetkit-typescript/packages/rivetkit/fixtures/driver-test-suite/start-stop-race.ts
+++ b/rivetkit-typescript/packages/rivetkit/fixtures/driver-test-suite/start-stop-race.ts
@@ -82,4 +82,7 @@ export const lifecycleObserver = actor({
 			c.state.events = [];
 		},
 	},
+	options: {
+		noSleep: true,
+	},
 });
diff --git a/rivetkit-typescript/packages/rivetkit/fixtures/driver-test-suite/workflow.ts b/rivetkit-typescript/packages/rivetkit/fixtures/driver-test-suite/workflow.ts
index 858e7590fa..4db26cee56 100644
--- a/rivetkit-typescript/packages/rivetkit/fixtures/driver-test-suite/workflow.ts
+++ b/rivetkit-typescript/packages/rivetkit/fixtures/driver-test-suite/workflow.ts
@@ -145,7 +145,7 @@ export const workflowNestedLoopActor = actor({
 		getState: (c) => c.state,
 	},
 	options: {
-		sleepTimeout: 50,
+		sleepTimeout: 1000,
 	},
 });
 
@@ -294,7 +294,7 @@ export const workflowSpawnChildActor = actor({
 		getState: (c) => c.state,
 	},
 	options: {
-		sleepTimeout: 50,
+		sleepTimeout: 1000,
 	},
 });
 
diff --git a/rivetkit-typescript/packages/rivetkit/package.json b/rivetkit-typescript/packages/rivetkit/package.json
index 1776b350de..2852393dca 100644
--- a/rivetkit-typescript/packages/rivetkit/package.json
+++ b/rivetkit-typescript/packages/rivetkit/package.json
@@ -161,6 +161,7 @@
 		"format": "biome format .",
 		"format:write": "biome format --write .",
 		"test": "vitest run",
+		"test:platforms": "pnpm run build && RIVETKIT_INCLUDE_PLATFORM_TESTS=1 vitest run tests/platforms --passWithNoTests",
 		"test:watch": "vitest",
 		"dump-asyncapi": "tsx scripts/dump-asyncapi.ts",
 		"registry-config-schema-gen": "tsx scripts/registry-config-schema-gen.ts",
@@ -175,6 +176,7 @@
 		"@rivetkit/engine-cli": "workspace:*",
 		"@rivetkit/engine-envoy-protocol": "workspace:*",
 		"@rivetkit/rivetkit-napi": "workspace:*",
+		"@rivetkit/rivetkit-wasm": "workspace:*",
 		"@rivetkit/traces": "workspace:*",
 		"@rivetkit/virtual-websocket": "workspace:*",
 		"@rivetkit/workflow-engine": "workspace:*",
diff --git a/rivetkit-typescript/packages/rivetkit/src/agent-os/actor/cron.ts b/rivetkit-typescript/packages/rivetkit/src/agent-os/actor/cron.ts
index b6c839f7bd..053b850e40 100644
--- a/rivetkit-typescript/packages/rivetkit/src/agent-os/actor/cron.ts
+++ b/rivetkit-typescript/packages/rivetkit/src/agent-os/actor/cron.ts
@@ -2,10 +2,45 @@ import type { CronAction, CronJobInfo } from "@rivet-dev/agent-os-core";
 import type { AgentOsActorConfig } from "../config";
 import type {
 	AgentOsActionContext,
+	SerializableCronAction,
+	SerializableCronJobInfo,
 	SerializableCronJobOptions,
 } from "../types";
 import { ensureVm } from "./index";
 
+function serializeCronAction(action: CronAction): SerializableCronAction {
+	switch (action.type) {
+		case "session":
+			return {
+				type: "session",
+				agentType: action.agentType,
+				prompt: action.prompt,
+				cwd: action.options?.cwd,
+			};
+		case "exec":
+			return {
+				type: "exec",
+				command: action.command,
+				args: action.args,
+			};
+		case "callback":
+			throw new TypeError("callback cron actions are not serializable");
+	}
+}
+
+function serializeCronJob(job: CronJobInfo): SerializableCronJobInfo {
+	return {
+		id: job.id,
+		schedule: job.schedule,
+		action: serializeCronAction(job.action),
+		overlap: job.overlap,
+		lastRun: job.lastRun?.toISOString(),
+		nextRun: job.nextRun?.toISOString(),
+		runCount: job.runCount,
+		running: job.running,
+	};
+}
+
 // Build cron scheduling actions for the actor factory.
 export function buildCronActions<TConnParams>(
 	config: AgentOsActorConfig<TConnParams>,
@@ -32,9 +67,9 @@ export function buildCronActions<TConnParams>(
 
 		listCronJobs: async (
 			c: AgentOsActionContext<TConnParams>,
-		): Promise<CronJobInfo[]> => {
+		): Promise<SerializableCronJobInfo[]> => {
 			const agentOs = await ensureVm(c, config);
-			return agentOs.listCronJobs();
+			return agentOs.listCronJobs().map(serializeCronJob);
 		},
 
 		cancelCronJob: async (
diff --git a/rivetkit-typescript/packages/rivetkit/src/agent-os/types.ts b/rivetkit-typescript/packages/rivetkit/src/agent-os/types.ts
index f7090394d4..5b5b943865 100644
--- a/rivetkit-typescript/packages/rivetkit/src/agent-os/types.ts
+++ b/rivetkit-typescript/packages/rivetkit/src/agent-os/types.ts
@@ -125,6 +125,17 @@ export interface SerializableCronJobOptions {
 	overlap?: "allow" | "skip" | "queue";
 }
 
+export interface SerializableCronJobInfo {
+	id: string;
+	schedule: string;
+	action: SerializableCronAction;
+	overlap: "allow" | "skip" | "queue";
+	lastRun?: string;
+	nextRun?: string;
+	runCount: number;
+	running: boolean;
+}
+
 // --- Action context alias ---
 
 export type AgentOsActionContext<TConnParams = undefined> = ActionContext<
diff --git a/rivetkit-typescript/packages/rivetkit/src/client/actor-conn.ts b/rivetkit-typescript/packages/rivetkit/src/client/actor-conn.ts
index dde8eceb58..5d4abcabfe 100644
--- a/rivetkit-typescript/packages/rivetkit/src/client/actor-conn.ts
+++ b/rivetkit-typescript/packages/rivetkit/src/client/actor-conn.ts
@@ -523,6 +523,14 @@ export class ActorConnRaw {
 			return true;
 		}
 
+		if (
+			error instanceof errors.ActorError &&
+			error.group === "client" &&
+			error.code === "get_params_failed"
+		) {
+			return true;
+		}
+
 		return isRetryableLifecycleReconnectSignal(error);
 	}
 
diff --git a/rivetkit-typescript/packages/rivetkit/src/common/database/mod.test.ts b/rivetkit-typescript/packages/rivetkit/src/common/database/mod.test.ts
new file mode 100644
index 0000000000..32fffe2a24
--- /dev/null
+++ b/rivetkit-typescript/packages/rivetkit/src/common/database/mod.test.ts
@@ -0,0 +1,106 @@
+import { describe, expect, test } from "vitest";
+import type {
+	DatabaseProviderContext,
+	SqliteBindings,
+	SqliteDatabase,
+	SqliteExecuteResult,
+} from "./config";
+import { db } from "./mod";
+
+class FakeSqliteDatabase implements SqliteDatabase {
+	writeModeDepth = 0;
+	executeCalls: {
+		sql: string;
+		params?: SqliteBindings;
+		writeMode: boolean;
+	}[] = [];
+
+	async exec(): Promise<void> {}
+
+	async execute(
+		sql: string,
+		params?: SqliteBindings,
+	): Promise<SqliteExecuteResult> {
+		this.executeCalls.push({
+			sql,
+			params,
+			writeMode: this.writeModeDepth > 0,
+		});
+		return {
+			columns: [],
+			rows: [],
+			changes: 0,
+			lastInsertRowId: null,
+			route: this.writeModeDepth > 0 ? "write" : "read",
+		};
+	}
+
+	async run(sql: string, params?: SqliteBindings): Promise<void> {
+		await this.execute(sql, params);
+	}
+
+	async query(sql: string, params?: SqliteBindings) {
+		const { columns, rows } = await this.execute(sql, params);
+		return { columns, rows };
+	}
+
+	async writeMode<T>(callback: () => Promise<T>): Promise<T> {
+		this.writeModeDepth++;
+		try {
+			return await callback();
+		} finally {
+			this.writeModeDepth--;
+		}
+	}
+
+	async close(): Promise<void> {}
+}
+
+function testProviderContext(
+	database: SqliteDatabase,
+): DatabaseProviderContext {
+	return {
+		actorId: "actor-a",
+		kv: {
+			batchPut: async () => {},
+			batchGet: async (keys) => keys.map(() => null),
+			batchDelete: async () => {},
+			deleteRange: async () => {},
+		},
+		nativeDatabaseProvider: {
+			open: async () => database,
+		},
+	};
+}
+
+describe("db", () => {
+	test("runs onMigrate through sqlite write mode", async () => {
+		const nativeDb = new FakeSqliteDatabase();
+		const provider = db({
+			onMigrate: async (client) => {
+				await client.execute(
+					"CREATE TABLE items(id INTEGER PRIMARY KEY, value TEXT)",
+				);
+				await client.execute("SELECT COUNT(*) AS count FROM items");
+			},
+		});
+		const client = await provider.createClient(
+			testProviderContext(nativeDb),
+		);
+
+		await provider.onMigrate(client);
+
+		expect(nativeDb.executeCalls).toEqual([
+			{
+				sql: "CREATE TABLE items(id INTEGER PRIMARY KEY, value TEXT)",
+				params: undefined,
+				writeMode: true,
+			},
+			{
+				sql: "SELECT COUNT(*) AS count FROM items",
+				params: undefined,
+				writeMode: true,
+			},
+		]);
+	});
+});
diff --git a/rivetkit-typescript/packages/rivetkit/src/common/database/native-database.test.ts b/rivetkit-typescript/packages/rivetkit/src/common/database/native-database.test.ts
index dcc51da9c2..b504f19990 100644
--- a/rivetkit-typescript/packages/rivetkit/src/common/database/native-database.test.ts
+++ b/rivetkit-typescript/packages/rivetkit/src/common/database/native-database.test.ts
@@ -132,6 +132,63 @@ describe("wrapJsNativeDatabase", () => {
 		});
 	});
 
+	test("normalizes supported sqlite bind values", async () => {
+		const native = new FakeNativeDatabase();
+		const db = wrapJsNativeDatabase(native);
+		const blob = new Uint8Array([1, 2, 3]);
+
+		const query = db.query("SELECT ?, ?, ?, ?, ?, ?, ?", [
+			1n,
+			true,
+			"text",
+			1.5,
+			null,
+			undefined,
+			blob,
+		]);
+
+		expect(native.executeCalls[0]?.params).toEqual([
+			{ kind: "int", intValue: 1 },
+			{ kind: "int", intValue: 1 },
+			{ kind: "text", textValue: "text" },
+			{ kind: "float", floatValue: 1.5 },
+			{ kind: "null" },
+			{ kind: "null" },
+			{ kind: "blob", blobValue: Buffer.from(blob) },
+		]);
+
+		native.resolveNext({ columns: ["value"], rows: [[1]] });
+
+		await expect(query).resolves.toEqual({
+			columns: ["value"],
+			rows: [[1]],
+		});
+	});
+
+	test("normalizes native execute routes and rejects unsupported routes", async () => {
+		const native = new FakeNativeDatabase();
+		const db = wrapJsNativeDatabase(native);
+
+		const read = db.execute("SELECT 1");
+		native.resolveNext({ route: "read" });
+		await expect(read).resolves.toMatchObject({ route: "read" });
+
+		const write = db.execute("INSERT INTO test VALUES (1)");
+		native.resolveNext({ route: "write" });
+		await expect(write).resolves.toMatchObject({ route: "write" });
+
+		const fallback = db.execute("SELECT last_insert_rowid()");
+		await expect(fallback).resolves.toMatchObject({
+			route: "writeFallback",
+		});
+
+		const unsupported = db.execute("SELECT 2");
+		native.resolveNext({ route: "custom" });
+		await expect(unsupported).rejects.toThrow(
+			"unsupported sqlite execute route: custom",
+		);
+	});
+
 	test("close waits for admitted native calls and rejects new work", async () => {
 		const native = new FakeNativeDatabase();
 		const db = wrapJsNativeDatabase(native);
diff --git a/rivetkit-typescript/packages/rivetkit/src/common/database/native-database.ts b/rivetkit-typescript/packages/rivetkit/src/common/database/native-database.ts
index e7ac98d83c..8cd09d7e8b 100644
--- a/rivetkit-typescript/packages/rivetkit/src/common/database/native-database.ts
+++ b/rivetkit-typescript/packages/rivetkit/src/common/database/native-database.ts
@@ -5,13 +5,43 @@ import type {
 	SqliteExecuteResult,
 } from "./config";
 
-interface NativeBindParam {
-	kind: "null" | "int" | "float" | "text" | "blob";
-	intValue?: number;
-	floatValue?: number;
-	textValue?: string;
-	blobValue?: Buffer;
-}
+type NativeBindNoValues = {
+	intValue?: never;
+	floatValue?: never;
+	textValue?: never;
+	blobValue?: never;
+};
+
+type NativeBindParam =
+	| ({ kind: "null" } & NativeBindNoValues)
+	| {
+			kind: "int";
+			intValue: number;
+			floatValue?: never;
+			textValue?: never;
+			blobValue?: never;
+	  }
+	| {
+			kind: "float";
+			intValue?: never;
+			floatValue: number;
+			textValue?: never;
+			blobValue?: never;
+	  }
+	| {
+			kind: "text";
+			intValue?: never;
+			floatValue?: never;
+			textValue: string;
+			blobValue?: never;
+	  }
+	| {
+			kind: "blob";
+			intValue?: never;
+			floatValue?: never;
+			textValue?: never;
+			blobValue: Buffer;
+	  };
 
 interface NativeExecResult {
 	columns: string[];
@@ -230,11 +260,23 @@ export function wrapJsNativeDatabase(
 	const gate = new NativeCloseGate();
 	let closePromise: Promise<void> | undefined;
 	let writeModeDepth = 0;
+	let lastInsertRowId: number | null = null;
 
 	const executeNative = async (
 		sql: string,
 		params?: SqliteBindings,
 	): Promise<SqliteExecuteResult> => {
+		const lastInsertRowIdColumn = lastInsertRowIdColumnName(sql);
+		if (lastInsertRowIdColumn) {
+			return {
+				columns: [lastInsertRowIdColumn],
+				rows: [[lastInsertRowId ?? 0]],
+				changes: 0,
+				lastInsertRowId,
+				route: "writeFallback",
+			};
+		}
+
 		const release = gate.enter();
 		try {
 			const nativeParams = toNativeBindings(sql, params);
@@ -242,6 +284,9 @@ export function wrapJsNativeDatabase(
 				writeModeDepth > 0
 					? await database.executeWrite(sql, nativeParams)
 					: await database.execute(sql, nativeParams);
+			if (result.lastInsertRowId !== undefined) {
+				lastInsertRowId = result.lastInsertRowId;
+			}
 			return {
 				...result,
 				route: normalizeExecuteRoute(result.route),
@@ -301,3 +346,25 @@ export function wrapJsNativeDatabase(
 		},
 	};
 }
+
+function lastInsertRowIdColumnName(sql: string): string | undefined {
+	const match = sql.match(
+		/^\s*SELECT\s+last_insert_rowid\s*\(\s*\)\s*(?:AS\s+("[^"]+"|`[^`]+`|\[[^\]]+\]|\w+))?\s*;?\s*$/i,
+	);
+	if (!match) {
+		return undefined;
+	}
+
+	const alias = match[1];
+	if (!alias) {
+		return "last_insert_rowid()";
+	}
+	if (
+		(alias.startsWith('"') && alias.endsWith('"')) ||
+		(alias.startsWith("`") && alias.endsWith("`")) ||
+		(alias.startsWith("[") && alias.endsWith("]"))
+	) {
+		return alias.slice(1, -1);
+	}
+	return alias;
+}
diff --git a/rivetkit-typescript/packages/rivetkit/src/common/encoding.ts b/rivetkit-typescript/packages/rivetkit/src/common/encoding.ts
index 13e74f5946..02ab40c951 100644
--- a/rivetkit-typescript/packages/rivetkit/src/common/encoding.ts
+++ b/rivetkit-typescript/packages/rivetkit/src/common/encoding.ts
@@ -146,7 +146,24 @@ export function encodeJsonCompatValue(input: any): any {
 	return input;
 }
 
-export function reviveJsonCompatValue(input: any): any {
+export interface JsonCompatReviveOptions {
+	coerceSafeIntegerBigInts?: boolean;
+}
+
+export function reviveJsonCompatValue(
+	input: any,
+	options: JsonCompatReviveOptions = {},
+): any {
+	if (typeof input === "bigint") {
+		if (
+			options.coerceSafeIntegerBigInts &&
+			input >= BigInt(Number.MIN_SAFE_INTEGER) &&
+			input <= BigInt(Number.MAX_SAFE_INTEGER)
+		) {
+			return Number(input);
+		}
+		return input;
+	}
 	if (Array.isArray(input)) {
 		if (
 			input.length === 2 &&
@@ -166,18 +183,21 @@ export function reviveJsonCompatValue(input: any): any {
 				return undefined;
 			}
 			if (input[0].startsWith("$$")) {
-				return [input[0].substring(1), reviveJsonCompatValue(input[1])];
+				return [
+					input[0].substring(1),
+					reviveJsonCompatValue(input[1], options),
+				];
 			}
 			throw new Error(
 				`Unknown JSON encoding type: ${input[0]}. This may indicate corrupted data or a version mismatch.`,
 			);
 		}
-		return input.map((value) => reviveJsonCompatValue(value));
+		return input.map((value) => reviveJsonCompatValue(value, options));
 	}
 	if (isPlainObject(input)) {
 		const decoded: Record<string, unknown> = {};
 		for (const [key, value] of Object.entries(input)) {
-			decoded[key] = reviveJsonCompatValue(value);
+			decoded[key] = reviveJsonCompatValue(value, options);
 		}
 		return decoded;
 	}
diff --git a/rivetkit-typescript/packages/rivetkit/src/common/utils.ts b/rivetkit-typescript/packages/rivetkit/src/common/utils.ts
index ee05121909..d8fdd42307 100644
--- a/rivetkit-typescript/packages/rivetkit/src/common/utils.ts
+++ b/rivetkit-typescript/packages/rivetkit/src/common/utils.ts
@@ -1,7 +1,7 @@
 import type { Next } from "hono";
 import type { ContentfulStatusCode } from "hono/utils/http-status";
 import * as errors from "@/actor/errors";
-import { EXTRA_ERROR_LOG, VERSION } from "@/utils";
+import { EXTRA_ERROR_LOG } from "@/utils";
 import { getLogErrorStack } from "@/utils/env-vars";
 import type { Logger } from "./log";
 
@@ -345,7 +345,13 @@ export function deconstructError(
 export function stringifyError(error: unknown): string {
 	if (error instanceof Error) {
 		if (typeof process !== "undefined" && getLogErrorStack()) {
-			return `${error.name}: ${error.message}${error.stack ? `\n${error.stack}` : ""}`;
+			let stack: string | undefined;
+			try {
+				stack = error.stack;
+			} catch {
+				stack = undefined;
+			}
+			return `${error.name}: ${error.message}${stack ? `\n${stack}` : ""}`;
 		} else {
 			return `${error.name}: ${error.message}`;
 		}
diff --git a/rivetkit-typescript/packages/rivetkit/src/globals.d.ts b/rivetkit-typescript/packages/rivetkit/src/globals.d.ts
index d83989230f..ed24024475 100644
--- a/rivetkit-typescript/packages/rivetkit/src/globals.d.ts
+++ b/rivetkit-typescript/packages/rivetkit/src/globals.d.ts
@@ -25,6 +25,10 @@ declare global {
 	const navigator: any;
 	const window: Window | undefined;
 
+	namespace WebAssembly {
+		class Module {}
+	}
+
 	const document: {
 		getElementById(id: string): HTMLElement | null;
 		createElement(tag: "script"): HTMLScriptElement;
diff --git a/rivetkit-typescript/packages/rivetkit/src/registry/config/index.ts b/rivetkit-typescript/packages/rivetkit/src/registry/config/index.ts
index 3a820871c6..d70cdfe588 100644
--- a/rivetkit-typescript/packages/rivetkit/src/registry/config/index.ts
+++ b/rivetkit-typescript/packages/rivetkit/src/registry/config/index.ts
@@ -1,22 +1,23 @@
 import { z } from "zod";
 import { getRunMetadata } from "@/actor/config";
 import type {
-	BaseActorDefinition,
 	AnyActorDefinition,
+	BaseActorDefinition,
 } from "@/actor/definition";
 import {
 	KEYS,
-	queueMetadataKey,
 	queueMessagesPrefix,
+	queueMetadataKey,
 	workflowStoragePrefix,
 } from "@/actor/keys";
 import { ENGINE_ENDPOINT } from "@/common/engine";
 import { type Logger, LogLevelSchema } from "@/common/log";
-import { DeepReadonly, VERSION } from "@/utils";
+import { VERSION } from "@/utils";
 import { tryParseEndpoint } from "@/utils/endpoint-parser";
 import {
 	getRivetEndpoint,
 	getRivetEngine,
+	getRivetkitRuntime,
 	getRivetNamespace,
 	getRivetRunEngine,
 	getRivetRunEngineVersion,
@@ -34,9 +35,42 @@ export const ActorsSchema = z.record(
 );
 export type RegistryActors = z.infer<typeof ActorsSchema>;
 
-export const TestConfigSchema = z.object({ enabled: z.boolean() });
+export const RuntimeKindSchema = z.enum(["auto", "native", "wasm"]);
+export type RuntimeKind = z.infer<typeof RuntimeKindSchema>;
+export type WasmRuntimeBindings = typeof import("@rivetkit/rivetkit-wasm");
+export type WasmRuntimeInitInput = Parameters<
+	WasmRuntimeBindings["default"]
+>[0];
+export const SqliteBackendSchema = z.enum(["local", "remote"]);
+export type SqliteBackend = z.infer<typeof SqliteBackendSchema>;
+
+export const TestConfigSchema = z.object({
+	enabled: z.boolean().optional().default(false),
+	sqliteBackend: SqliteBackendSchema.optional(),
+});
 export type TestConfig = z.infer<typeof TestConfigSchema>;
 
+export const WasmRuntimeConfigSchema = z.object({
+	bindings: z.custom<WasmRuntimeBindings>().optional(),
+	initInput: z.custom<WasmRuntimeInitInput>().optional(),
+});
+export type WasmRuntimeConfig = z.infer<typeof WasmRuntimeConfigSchema>;
+
+export const SqliteConfigSchema = z
+	.union([
+		SqliteBackendSchema,
+		z.object({
+			backend: SqliteBackendSchema,
+		}),
+	])
+	.optional()
+	.transform((config) => {
+		if (config === undefined) return undefined;
+		if (typeof config === "string") return { backend: config };
+		return config;
+	});
+export type SqliteConfig = z.infer<typeof SqliteConfigSchema>;
+
 // TODO: Add sane defaults for NODE_ENV=development
 export const RegistryConfigSchema = z
 	.object({
@@ -60,6 +94,44 @@ export const RegistryConfigSchema = z
 		maxOutgoingMessageSize: z.number().optional().default(1_048_576),
 
 		// MARK: Runtime
+		/**
+		 * @experimental
+		 *
+		 * Runtime binding to use for RivetKit core.
+		 * */
+		runtime: RuntimeKindSchema.optional().transform((val, ctx) => {
+			const rawRuntime = val ?? getRivetkitRuntime();
+			if (rawRuntime === undefined) {
+				return "auto";
+			}
+
+			const parsed = RuntimeKindSchema.safeParse(rawRuntime);
+			if (!parsed.success) {
+				ctx.addIssue({
+					code: "custom",
+					message:
+						"RIVETKIT_RUNTIME must be one of auto, native, or wasm",
+				});
+				return "auto";
+			}
+
+			return parsed.data;
+		}),
+
+		/**
+		 * @experimental
+		 *
+		 * WebAssembly runtime configuration.
+		 * */
+		wasm: WasmRuntimeConfigSchema.optional().default(() => ({})),
+
+		/**
+		 * @experimental
+		 *
+		 * SQLite backend selection.
+		 * */
+		sqlite: SqliteConfigSchema,
+
 		/**
 		 * @experimental
 		 *
@@ -193,7 +265,12 @@ export const RegistryConfigSchema = z
 				 *
 				 * Must be >= rivetkit-core's drain timeout (20s) + margin.
 				 */
-				gracePeriodMs: z.number().int().min(1_000).optional().default(30_000),
+				gracePeriodMs: z
+					.number()
+					.int()
+					.min(1_000)
+					.optional()
+					.default(30_000),
 				/**
 				 * If true, rivetkit will not install SIGINT/SIGTERM handlers.
 				 * Use when the host application owns signal policy and will
@@ -202,10 +279,32 @@ export const RegistryConfigSchema = z
 				disableSignalHandlers: z.boolean().optional().default(false),
 			})
 			.optional()
-			.default(() => ({ gracePeriodMs: 30_000, disableSignalHandlers: false })),
+			.default(() => ({
+				gracePeriodMs: 30_000,
+				disableSignalHandlers: false,
+			})),
 	})
 	.transform((config, ctx) => {
 		const isDevEnv = isDev();
+		const sqliteBackend =
+			config.sqlite?.backend ?? config.test?.sqliteBackend;
+
+		if (config.runtime === "wasm" && sqliteBackend === "local") {
+			ctx.addIssue({
+				code: "custom",
+				message:
+					"WebAssembly runtime cannot use local SQLite. Use remote SQLite instead.",
+				path:
+					config.sqlite?.backend === "local"
+						? ["sqlite"]
+						: ["test", "sqliteBackend"],
+			});
+		}
+
+		const sqlite =
+			config.runtime === "wasm" && config.sqlite === undefined
+				? { backend: "remote" as const }
+				: config.sqlite;
 
 		// Parse endpoint string (env var fallback is applied via transform above)
 		const parsedEndpoint = config.endpoint
@@ -282,6 +381,7 @@ export const RegistryConfigSchema = z
 		// If endpoint is set or starting the engine, we'll use the engine driver.
 		return {
 			...config,
+			sqlite,
 			endpoint,
 			namespace,
 			token,
@@ -443,6 +543,15 @@ export const DocEnvoyConfigSchema = z
 	})
 	.describe("Configuration for envoy mode.");
 
+export const DocSqliteConfigSchema = z
+	.object({
+		backend: SqliteBackendSchema.optional().describe(
+			"SQLite backend to use. Native defaults to local. Wasm defaults to remote and cannot use local.",
+		),
+	})
+	.optional()
+	.describe("SQLite runtime configuration.");
+
 export const DocRegistryConfigSchema = z
 	.object({
 		use: z
@@ -466,6 +575,7 @@ export const DocRegistryConfigSchema = z
 			.boolean()
 			.optional()
 			.describe("Disable the welcome message on startup. Default: false"),
+		sqlite: DocSqliteConfigSchema,
 		logging: z
 			.object({
 				level: LogLevelSchema.optional().describe(
diff --git a/rivetkit-typescript/packages/rivetkit/src/registry/index.ts b/rivetkit-typescript/packages/rivetkit/src/registry/index.ts
index a5d9e3f89a..3a64d4f916 100644
--- a/rivetkit-typescript/packages/rivetkit/src/registry/index.ts
+++ b/rivetkit-typescript/packages/rivetkit/src/registry/index.ts
@@ -1,14 +1,15 @@
+import { ENGINE_ENDPOINT } from "@/common/engine";
+import { configureServerlessPool } from "@/serverless/configure";
+import { VERSION } from "@/utils";
 import {
 	type RegistryActors,
 	type RegistryConfig,
 	type RegistryConfigInput,
 	RegistryConfigSchema,
 } from "./config";
-import { ENGINE_ENDPOINT } from "@/common/engine";
 import { logger } from "./log";
-import { buildNativeRegistry } from "./native";
-import { configureServerlessPool } from "@/serverless/configure";
-import { VERSION } from "@/utils";
+import { buildConfiguredRegistry } from "./native";
+import type { RuntimeServerlessResponseHead } from "./runtime";
 
 type ShutdownSignal = "SIGINT" | "SIGTERM";
 
@@ -32,8 +33,8 @@ export class Registry<A extends RegistryActors> {
 		return RegistryConfigSchema.parse(this.#config);
 	}
 
-	#nativeServePromise?: Promise<void>;
-	#nativeServerlessPromise?: ReturnType<typeof buildNativeRegistry>;
+	#runtimeServePromise?: Promise<void>;
+	#runtimeServerlessPromise?: ReturnType<typeof buildConfiguredRegistry>;
 	#configureServerlessPoolPromise?: Promise<void>;
 	#welcomePrinted = false;
 	#shutdownInstalled = false;
@@ -63,14 +64,14 @@ export class Registry<A extends RegistryActors> {
 				configureServerlessPool(config);
 		}
 
-		if (!this.#nativeServerlessPromise) {
-			this.#nativeServerlessPromise = buildNativeRegistry(config);
+		if (!this.#runtimeServerlessPromise) {
+			this.#runtimeServerlessPromise = buildConfiguredRegistry(config);
 		}
 
-		const { bindings, registry, serveConfig } =
-			await this.#nativeServerlessPromise;
-		const cancelToken = new bindings.CancellationToken();
-		const abort = () => cancelToken.cancel();
+		const { runtime, registry, serveConfig } =
+			await this.#runtimeServerlessPromise;
+		const cancelToken = runtime.createCancellationToken();
+		const abort = () => runtime.cancelCancellationToken(cancelToken);
 		if (request.signal.aborted) {
 			abort();
 		} else {
@@ -86,7 +87,7 @@ export class Registry<A extends RegistryActors> {
 			requestBody.byteLength > serveConfig.serverlessMaxStartPayloadBytes
 		) {
 			request.signal.removeEventListener("abort", abort);
-			cancelToken.cancel();
+			runtime.cancelCancellationToken(cancelToken);
 			return new Response(
 				JSON.stringify({
 					group: "message",
@@ -102,7 +103,9 @@ export class Registry<A extends RegistryActors> {
 		}
 
 		let settled = false;
-		let controllerRef: ReadableStreamDefaultController<Uint8Array> | undefined;
+		let controllerRef:
+			| ReadableStreamDefaultController<Uint8Array>
+			| undefined;
 		const backpressureWaiters: Array<() => void> = [];
 		const resolveBackpressure = () => {
 			while (
@@ -129,7 +132,7 @@ export class Registry<A extends RegistryActors> {
 			cancel() {
 				settled = true;
 				resolveBackpressure();
-				cancelToken.cancel();
+				runtime.cancelCancellationToken(cancelToken);
 			},
 		});
 
@@ -138,20 +141,21 @@ export class Registry<A extends RegistryActors> {
 			headers[key] = value;
 		});
 
-		let head;
+		let head: RuntimeServerlessResponseHead;
 		try {
-			head = await registry.handleServerlessRequest(
+			head = await runtime.handleServerlessRequest(
+				registry,
 				{
 					method: request.method,
 					url: request.url,
 					headers,
-					body: Buffer.from(requestBody),
+					body: new Uint8Array(requestBody),
 				},
 				async (
 					error: unknown,
 					event?: {
 						kind: "chunk" | "end";
-						chunk?: Buffer;
+						chunk?: Uint8Array;
 						error?: {
 							group: string;
 							code: string;
@@ -185,10 +189,10 @@ export class Registry<A extends RegistryActors> {
 				serveConfig,
 			);
 		} catch (err) {
-			// The NAPI call itself rejected (e.g. `registry_shut_down_error`).
+			// The runtime call itself rejected (e.g. `registry_shut_down_error`).
 			// Clean up the abort listener so it doesn't leak, then propagate.
 			request.signal.removeEventListener("abort", abort);
-			cancelToken.cancel();
+			runtime.cancelCancellationToken(cancelToken);
 			throw err;
 		}
 
@@ -216,25 +220,25 @@ export class Registry<A extends RegistryActors> {
 	 * Starts an actor envoy for standalone server deployments.
 	 */
 	#startEnvoy(config: RegistryConfig, printWelcome: boolean) {
-		if (!this.#nativeServePromise) {
-			const nativeRegistryPromise = buildNativeRegistry(config);
-			this.#nativeServePromise = nativeRegistryPromise
-				.then(async ({ registry, serveConfig }) => {
-					await registry.serve(serveConfig);
+		if (!this.#runtimeServePromise) {
+			const configuredRegistryPromise = buildConfiguredRegistry(config);
+			this.#runtimeServePromise = configuredRegistryPromise
+				.then(async ({ runtime, registry, serveConfig }) => {
+					await runtime.serveRegistry(registry, serveConfig);
 				})
 				.catch((err) => {
 					// Always-attached catch so the stored promise never leaves a
 					// rejection unhandled. Downstream awaits (e.g. #runShutdown's
 					// Promise.race) attach their own catches and still observe
 					// resolution via the race.
-					logger().warn({ err }, "native registry serve errored");
+					logger().warn({ err }, "runtime registry serve errored");
 				});
 			// Install signal handlers once an envoy lifecycle has begun. Only
 			// Mode A ever reaches here. Mode B (handler(request)) intentionally
 			// does not install handlers because it runs on Workers/Vercel/Deno
 			// Deploy where `process.on` is absent or forbidden; those platforms
 			// own their own signal policy.
-			this.#installSignalHandlers(config, nativeRegistryPromise);
+			this.#installSignalHandlers(config, configuredRegistryPromise);
 		}
 		if (printWelcome) {
 			this.#printWelcome(config, "serverful");
@@ -243,7 +247,7 @@ export class Registry<A extends RegistryActors> {
 
 	#installSignalHandlers(
 		config: RegistryConfig,
-		nativeRegistryPromise: ReturnType<typeof buildNativeRegistry>,
+		configuredRegistryPromise: ReturnType<typeof buildConfiguredRegistry>,
 	): void {
 		if (this.#shutdownInstalled) return;
 		if (config.shutdown?.disableSignalHandlers) return;
@@ -260,7 +264,11 @@ export class Registry<A extends RegistryActors> {
 
 		const install = (signal: ShutdownSignal) => {
 			const handler = () =>
-				this.#onShutdownSignal(signal, config, nativeRegistryPromise);
+				this.#onShutdownSignal(
+					signal,
+					config,
+					configuredRegistryPromise,
+				);
 			this.#signalHandlers[signal] = handler;
 			process.on(signal, handler);
 		};
@@ -271,7 +279,7 @@ export class Registry<A extends RegistryActors> {
 	#onShutdownSignal(
 		signal: ShutdownSignal,
 		config: RegistryConfig,
-		nativeRegistryPromise: ReturnType<typeof buildNativeRegistry>,
+		configuredRegistryPromise: ReturnType<typeof buildConfiguredRegistry>,
 	): void {
 		if (this.#shutdownInFlight !== null) {
 			// Second delivery of the same (or another) shutdown signal.
@@ -284,7 +292,7 @@ export class Registry<A extends RegistryActors> {
 		this.#shutdownInFlight = this.#runShutdown(
 			signal,
 			config,
-			nativeRegistryPromise,
+			configuredRegistryPromise,
 		).catch((err) => {
 			logger().warn({ err }, "shutdown error");
 		});
@@ -293,7 +301,7 @@ export class Registry<A extends RegistryActors> {
 	async #runShutdown(
 		signal: ShutdownSignal,
 		config: RegistryConfig,
-		nativeRegistryPromise: ReturnType<typeof buildNativeRegistry>,
+		configuredRegistryPromise: ReturnType<typeof buildConfiguredRegistry>,
 	): Promise<void> {
 		const gracePeriodMs = config.shutdown?.gracePeriodMs ?? 30_000;
 		// Race the entire drain sequence (both modes + serve promise) against
@@ -303,31 +311,34 @@ export class Registry<A extends RegistryActors> {
 		const drain = async () => {
 			// Shut down every live `CoreRegistry` we know about. Mode A
 			// (`start()`) and Mode B (`handler()`) each build a separate
-			// native registry, so one signal handler fans out to both to
+			// runtime registry, so one signal handler fans out to both to
 			// honor the spec invariant "single shutdown tears down both modes".
 			const registries: Promise<void>[] = [
 				(async () => {
 					try {
-						const { registry } = await nativeRegistryPromise;
-						await registry.shutdown();
+						const { runtime, registry } =
+							await configuredRegistryPromise;
+						await runtime.shutdownRegistry(registry);
 					} catch (err) {
 						logger().warn(
 							{ err },
-							"native registry shutdown errored (mode A)",
+							"runtime registry shutdown errored (mode A)",
 						);
 					}
 				})(),
 			];
-			if (this.#nativeServerlessPromise) {
+			const runtimeServerlessPromise = this.#runtimeServerlessPromise;
+			if (runtimeServerlessPromise !== undefined) {
 				registries.push(
 					(async () => {
 						try {
-							const { registry } = await this.#nativeServerlessPromise!;
-							await registry.shutdown();
+							const { runtime, registry } =
+								await runtimeServerlessPromise;
+							await runtime.shutdownRegistry(registry);
 						} catch (err) {
 							logger().warn(
 								{ err },
-								"native registry shutdown errored (mode B)",
+								"runtime registry shutdown errored (mode B)",
 							);
 						}
 					})(),
@@ -335,11 +346,12 @@ export class Registry<A extends RegistryActors> {
 			}
 			await Promise.all(registries);
 
-			if (this.#nativeServePromise) {
+			const runtimeServePromise = this.#runtimeServePromise;
+			if (runtimeServePromise !== undefined) {
 				// Swallow rejection so the race doesn't itself reject; the
 				// always-attached `.catch` at the promise assignment site has
 				// already logged any serve-side error.
-				await this.#nativeServePromise.catch(() => undefined);
+				await runtimeServePromise.catch(() => undefined);
 			}
 		};
 		await Promise.race([
@@ -353,10 +365,9 @@ export class Registry<A extends RegistryActors> {
 	}
 
 	#removeSignalHandlers(): void {
-		for (const [signal, handler] of Object.entries(this.#signalHandlers) as [
-			ShutdownSignal,
-			() => void,
-		][]) {
+		for (const [signal, handler] of Object.entries(
+			this.#signalHandlers,
+		) as [ShutdownSignal, () => void][]) {
 			if (handler) process.removeListener(signal, handler);
 		}
 		this.#signalHandlers = {};
@@ -367,7 +378,7 @@ export class Registry<A extends RegistryActors> {
 	}
 
 	/**
-	 * Starts the native actor envoy for standalone server deployments.
+	 * Starts the actor envoy for standalone server deployments.
 	 *
 	 * @example
 	 * ```ts
diff --git a/rivetkit-typescript/packages/rivetkit/src/registry/napi-runtime.ts b/rivetkit-typescript/packages/rivetkit/src/registry/napi-runtime.ts
new file mode 100644
index 0000000000..40981abe78
--- /dev/null
+++ b/rivetkit-typescript/packages/rivetkit/src/registry/napi-runtime.ts
@@ -0,0 +1,759 @@
+import type {
+	ActorContext as NativeActorContext,
+	NapiActorFactory as NativeActorFactory,
+	CancellationToken as NativeCancellationToken,
+	ConnHandle as NativeConnHandle,
+	CoreRegistry as NativeCoreRegistry,
+	WebSocket as NativeWebSocket,
+} from "@rivetkit/rivetkit-napi";
+import type {
+	ActorContextHandle,
+	ActorFactoryHandle,
+	CancellationTokenHandle,
+	ConnHandle,
+	CoreRuntime,
+	RegistryHandle,
+	RuntimeActorConfig,
+	RuntimeBytes,
+	RuntimeHttpRequest,
+	RuntimeKvEntry,
+	RuntimeKvListOptions,
+	RuntimeQueueEnqueueAndWaitOptions,
+	RuntimeQueueMessage,
+	RuntimeQueueNextBatchOptions,
+	RuntimeQueueTryNextBatchOptions,
+	RuntimeQueueWaitOptions,
+	RuntimeRequestSaveOpts,
+	RuntimeServeConfig,
+	RuntimeServerlessRequest,
+	RuntimeServerlessResponseHead,
+	RuntimeServerlessStreamCallback,
+	RuntimeSqlBindParam,
+	RuntimeSqlBindParams,
+	RuntimeSqlExecResult,
+	RuntimeSqlExecuteResult,
+	RuntimeSqlQueryResult,
+	RuntimeSqlRunResult,
+	RuntimeStateDeltaPayload,
+	RuntimeWebSocketEvent,
+	WebSocketHandle,
+} from "./runtime";
+import { normalizeRuntimeSqlExecuteResult } from "./runtime";
+
+type NativeBindings = typeof import("@rivetkit/rivetkit-napi");
+type NapiSqlDatabase = ReturnType<NativeActorContext["sql"]>;
+type NapiSqlBindParams = Parameters<NapiSqlDatabase["execute"]>[1];
+
+function asNativeRegistry(handle: RegistryHandle): NativeCoreRegistry {
+	return handle as unknown as NativeCoreRegistry;
+}
+
+function asNativeFactory(handle: ActorFactoryHandle): NativeActorFactory {
+	return handle as unknown as NativeActorFactory;
+}
+
+function asNativeActorContext(handle: ActorContextHandle): NativeActorContext {
+	return handle as unknown as NativeActorContext;
+}
+
+function asNativeConn(handle: ConnHandle): NativeConnHandle {
+	return handle as unknown as NativeConnHandle;
+}
+
+function asNativeWebSocket(handle: WebSocketHandle): NativeWebSocket {
+	return handle as unknown as NativeWebSocket;
+}
+
+function asNativeCancellationToken(
+	handle: CancellationTokenHandle,
+): NativeCancellationToken {
+	return handle as unknown as NativeCancellationToken;
+}
+
+function asRegistryHandle(handle: NativeCoreRegistry): RegistryHandle {
+	return handle as unknown as RegistryHandle;
+}
+
+function asActorFactoryHandle(handle: NativeActorFactory): ActorFactoryHandle {
+	return handle as unknown as ActorFactoryHandle;
+}
+
+function toNapiSqlBindParam(
+	param: RuntimeSqlBindParam,
+): NonNullable<NapiSqlBindParams>[number] {
+	switch (param.kind) {
+		case "null":
+			return { kind: "null" };
+		case "int":
+			return { kind: "int", intValue: param.intValue };
+		case "float":
+			return { kind: "float", floatValue: param.floatValue };
+		case "text":
+			return { kind: "text", textValue: param.textValue };
+		case "blob":
+			return { kind: "blob", blobValue: Buffer.from(param.blobValue) };
+	}
+}
+
+function toNapiSqlBindParams(params?: RuntimeSqlBindParams): NapiSqlBindParams {
+	if (params == null) {
+		return params;
+	}
+	return params.map((param) => toNapiSqlBindParam(param));
+}
+
+function toNapiBuffer(value: RuntimeBytes): Buffer {
+	return Buffer.from(value);
+}
+
+function toNapiHttpRequest(
+	request?: RuntimeHttpRequest | undefined | null,
+): Parameters<NativeActorContext["connectConn"]>[1] {
+	if (!request) {
+		return request;
+	}
+	return {
+		...request,
+		body: request.body ? toNapiBuffer(request.body) : undefined,
+	};
+}
+
+function toNapiStateDeltaPayload(
+	payload: RuntimeStateDeltaPayload,
+): Parameters<NativeActorContext["saveState"]>[0] {
+	return {
+		...payload,
+		state: payload.state ? toNapiBuffer(payload.state) : undefined,
+		connHibernation: payload.connHibernation.map((conn) => ({
+			...conn,
+			bytes: toNapiBuffer(conn.bytes),
+		})),
+	};
+}
+
+function toNapiKvEntry(entry: RuntimeKvEntry): {
+	key: Buffer;
+	value: Buffer;
+} {
+	return {
+		key: toNapiBuffer(entry.key),
+		value: toNapiBuffer(entry.value),
+	};
+}
+
+function toNapiQueueMessage(message: RuntimeQueueMessage): RuntimeQueueMessage {
+	return {
+		id: () => message.id(),
+		name: () => message.name(),
+		body: () => message.body(),
+		createdAt: () => message.createdAt(),
+		isCompletable: () => message.isCompletable(),
+		complete: async (response?: RuntimeBytes | undefined | null) => {
+			await message.complete(
+				response === null || response === undefined
+					? response
+					: toNapiBuffer(response),
+			);
+		},
+	};
+}
+
+export class NapiCoreRuntime implements CoreRuntime {
+	readonly kind = "napi";
+
+	#bindings: NativeBindings;
+	#sql = new WeakMap<NativeActorContext, NapiSqlDatabase>();
+
+	constructor(bindings: NativeBindings) {
+		this.#bindings = bindings;
+	}
+
+	#actorSql(ctx: ActorContextHandle): NapiSqlDatabase {
+		const nativeCtx = asNativeActorContext(ctx);
+		let database = this.#sql.get(nativeCtx);
+		if (!database) {
+			database = nativeCtx.sql();
+			this.#sql.set(nativeCtx, database);
+		}
+		return database;
+	}
+
+	createRegistry(): RegistryHandle {
+		return asRegistryHandle(new this.#bindings.CoreRegistry());
+	}
+
+	registerActor(
+		registry: RegistryHandle,
+		name: string,
+		factory: ActorFactoryHandle,
+	): void {
+		asNativeRegistry(registry).register(name, asNativeFactory(factory));
+	}
+
+	async serveRegistry(
+		registry: RegistryHandle,
+		config: RuntimeServeConfig,
+	): Promise<void> {
+		await asNativeRegistry(registry).serve(config);
+	}
+
+	async shutdownRegistry(registry: RegistryHandle): Promise<void> {
+		await asNativeRegistry(registry).shutdown();
+	}
+
+	async handleServerlessRequest(
+		registry: RegistryHandle,
+		req: RuntimeServerlessRequest,
+		onStreamEvent: RuntimeServerlessStreamCallback,
+		cancelToken: CancellationTokenHandle,
+		config: RuntimeServeConfig,
+	): Promise<RuntimeServerlessResponseHead> {
+		return await asNativeRegistry(registry).handleServerlessRequest(
+			{ ...req, body: toNapiBuffer(req.body) },
+			onStreamEvent,
+			asNativeCancellationToken(cancelToken),
+			config,
+		);
+	}
+
+	createActorFactory(
+		callbacks: object,
+		config?: RuntimeActorConfig | undefined | null,
+	): ActorFactoryHandle {
+		return asActorFactoryHandle(
+			new this.#bindings.NapiActorFactory(callbacks, config),
+		);
+	}
+
+	createCancellationToken(): CancellationTokenHandle {
+		return new this.#bindings.CancellationToken() as unknown as CancellationTokenHandle;
+	}
+
+	createTestActorContext(
+		actorId: string,
+		name: string,
+		region: string,
+	): ActorContextHandle {
+		return new this.#bindings.ActorContext(
+			actorId,
+			name,
+			region,
+		) as unknown as ActorContextHandle;
+	}
+
+	cancellationTokenAborted(token: CancellationTokenHandle): boolean {
+		return asNativeCancellationToken(token).aborted();
+	}
+
+	cancelCancellationToken(token: CancellationTokenHandle): void {
+		asNativeCancellationToken(token).cancel();
+	}
+
+	onCancellationTokenCancelled(
+		token: CancellationTokenHandle,
+		callback: (...args: unknown[]) => unknown,
+	): void {
+		asNativeCancellationToken(token).onCancelled(callback);
+	}
+
+	actorState(ctx: ActorContextHandle): Buffer {
+		return asNativeActorContext(ctx).state();
+	}
+
+	actorBeginOnStateChange(ctx: ActorContextHandle): void {
+		asNativeActorContext(ctx).beginOnStateChange();
+	}
+
+	actorEndOnStateChange(ctx: ActorContextHandle): void {
+		asNativeActorContext(ctx).endOnStateChange();
+	}
+
+	actorSetAlarm(
+		ctx: ActorContextHandle,
+		timestampMs?: number | undefined | null,
+	): void {
+		asNativeActorContext(ctx).setAlarm(timestampMs);
+	}
+
+	actorRequestSave(
+		ctx: ActorContextHandle,
+		opts?: RuntimeRequestSaveOpts | undefined | null,
+	): void {
+		asNativeActorContext(ctx).requestSave(opts);
+	}
+
+	async actorRequestSaveAndWait(
+		ctx: ActorContextHandle,
+		opts?: RuntimeRequestSaveOpts | undefined | null,
+	): Promise<void> {
+		await asNativeActorContext(ctx).requestSaveAndWait(opts);
+	}
+
+	actorInspectorSnapshot(ctx: ActorContextHandle) {
+		return asNativeActorContext(ctx).inspectorSnapshot();
+	}
+
+	actorDecodeInspectorRequest(
+		ctx: ActorContextHandle,
+		bytes: RuntimeBytes,
+		advertisedVersion: number,
+	): RuntimeBytes {
+		return asNativeActorContext(ctx).decodeInspectorRequest(
+			toNapiBuffer(bytes),
+			advertisedVersion,
+		);
+	}
+
+	actorEncodeInspectorResponse(
+		ctx: ActorContextHandle,
+		bytes: RuntimeBytes,
+		targetVersion: number,
+	): RuntimeBytes {
+		return asNativeActorContext(ctx).encodeInspectorResponse(
+			toNapiBuffer(bytes),
+			targetVersion,
+		);
+	}
+
+	async actorVerifyInspectorAuth(
+		ctx: ActorContextHandle,
+		bearerToken?: string | undefined | null,
+	): Promise<void> {
+		await asNativeActorContext(ctx).verifyInspectorAuth(bearerToken);
+	}
+
+	actorQueueHibernationRemoval(
+		ctx: ActorContextHandle,
+		connId: string,
+	): void {
+		asNativeActorContext(ctx).queueHibernationRemoval(connId);
+	}
+
+	actorTakePendingHibernationChanges(ctx: ActorContextHandle): string[] {
+		return asNativeActorContext(ctx).takePendingHibernationChanges();
+	}
+
+	actorDirtyHibernatableConns(ctx: ActorContextHandle): ConnHandle[] {
+		return asNativeActorContext(
+			ctx,
+		).dirtyHibernatableConns() as unknown as ConnHandle[];
+	}
+
+	async actorSaveState(
+		ctx: ActorContextHandle,
+		payload: RuntimeStateDeltaPayload,
+	): Promise<void> {
+		await asNativeActorContext(ctx).saveState(
+			toNapiStateDeltaPayload(payload),
+		);
+	}
+
+	actorId(ctx: ActorContextHandle): string {
+		return asNativeActorContext(ctx).actorId();
+	}
+
+	actorName(ctx: ActorContextHandle): string {
+		return asNativeActorContext(ctx).name();
+	}
+
+	actorKey(ctx: ActorContextHandle) {
+		return asNativeActorContext(ctx).key();
+	}
+
+	actorRegion(ctx: ActorContextHandle): string {
+		return asNativeActorContext(ctx).region();
+	}
+
+	actorSleep(ctx: ActorContextHandle): void {
+		asNativeActorContext(ctx).sleep();
+	}
+
+	actorDestroy(ctx: ActorContextHandle): void {
+		asNativeActorContext(ctx).destroy();
+	}
+
+	actorAbortSignal(ctx: ActorContextHandle): AbortSignal {
+		return asNativeActorContext(ctx).abortSignal();
+	}
+
+	actorConns(ctx: ActorContextHandle): ConnHandle[] {
+		return asNativeActorContext(ctx).conns() as unknown as ConnHandle[];
+	}
+
+	async actorConnectConn(
+		ctx: ActorContextHandle,
+		params: RuntimeBytes,
+		request?: RuntimeHttpRequest | undefined | null,
+	): Promise<ConnHandle> {
+		return (await asNativeActorContext(ctx).connectConn(
+			toNapiBuffer(params),
+			toNapiHttpRequest(request),
+		)) as unknown as ConnHandle;
+	}
+
+	actorBroadcast(
+		ctx: ActorContextHandle,
+		name: string,
+		args: RuntimeBytes,
+	): void {
+		asNativeActorContext(ctx).broadcast(name, toNapiBuffer(args));
+	}
+
+	actorWaitUntil(ctx: ActorContextHandle, promise: Promise<unknown>): void {
+		asNativeActorContext(ctx).waitUntil(promise);
+	}
+
+	async actorKeepAwake(
+		ctx: ActorContextHandle,
+		promise: Promise<unknown>,
+	): Promise<unknown> {
+		return await asNativeActorContext(ctx).keepAwake(promise);
+	}
+
+	actorRegisterTask(
+		ctx: ActorContextHandle,
+		promise: Promise<unknown>,
+	): void {
+		asNativeActorContext(ctx).registerTask(promise);
+	}
+
+	actorRuntimeState(ctx: ActorContextHandle): object {
+		return asNativeActorContext(ctx).runtimeState();
+	}
+
+	actorRestartRunHandler(ctx: ActorContextHandle): void {
+		asNativeActorContext(ctx).restartRunHandler();
+	}
+
+	actorBeginWebsocketCallback(ctx: ActorContextHandle): number {
+		return asNativeActorContext(ctx).beginWebsocketCallback();
+	}
+
+	actorEndWebsocketCallback(ctx: ActorContextHandle, regionId: number): void {
+		asNativeActorContext(ctx).endWebsocketCallback(regionId);
+	}
+
+	async actorKvGet(
+		ctx: ActorContextHandle,
+		key: RuntimeBytes,
+	): Promise<RuntimeBytes | null> {
+		return await asNativeActorContext(ctx).kv().get(toNapiBuffer(key));
+	}
+
+	async actorKvPut(
+		ctx: ActorContextHandle,
+		key: RuntimeBytes,
+		value: RuntimeBytes,
+	): Promise<void> {
+		await asNativeActorContext(ctx)
+			.kv()
+			.put(toNapiBuffer(key), toNapiBuffer(value));
+	}
+
+	async actorKvDelete(
+		ctx: ActorContextHandle,
+		key: RuntimeBytes,
+	): Promise<void> {
+		await asNativeActorContext(ctx).kv().delete(toNapiBuffer(key));
+	}
+
+	async actorKvDeleteRange(
+		ctx: ActorContextHandle,
+		start: RuntimeBytes,
+		end: RuntimeBytes,
+	): Promise<void> {
+		await asNativeActorContext(ctx)
+			.kv()
+			.deleteRange(toNapiBuffer(start), toNapiBuffer(end));
+	}
+
+	async actorKvListPrefix(
+		ctx: ActorContextHandle,
+		prefix: RuntimeBytes,
+		options?: RuntimeKvListOptions | undefined | null,
+	): Promise<RuntimeKvEntry[]> {
+		return await asNativeActorContext(ctx)
+			.kv()
+			.listPrefix(toNapiBuffer(prefix), options);
+	}
+
+	async actorKvListRange(
+		ctx: ActorContextHandle,
+		start: RuntimeBytes,
+		end: RuntimeBytes,
+		options?: RuntimeKvListOptions | undefined | null,
+	): Promise<RuntimeKvEntry[]> {
+		return await asNativeActorContext(ctx)
+			.kv()
+			.listRange(toNapiBuffer(start), toNapiBuffer(end), options);
+	}
+
+	async actorKvBatchGet(
+		ctx: ActorContextHandle,
+		keys: RuntimeBytes[],
+	): Promise<Array<RuntimeBytes | undefined | null>> {
+		return await asNativeActorContext(ctx)
+			.kv()
+			.batchGet(keys.map(toNapiBuffer));
+	}
+
+	async actorKvBatchPut(
+		ctx: ActorContextHandle,
+		entries: RuntimeKvEntry[],
+	): Promise<void> {
+		await asNativeActorContext(ctx)
+			.kv()
+			.batchPut(entries.map(toNapiKvEntry));
+	}
+
+	async actorKvBatchDelete(
+		ctx: ActorContextHandle,
+		keys: RuntimeBytes[],
+	): Promise<void> {
+		await asNativeActorContext(ctx)
+			.kv()
+			.batchDelete(keys.map(toNapiBuffer));
+	}
+
+	async actorSqlExec(
+		ctx: ActorContextHandle,
+		sql: string,
+	): Promise<RuntimeSqlExecResult> {
+		return await this.#actorSql(ctx).exec(sql);
+	}
+
+	async actorSqlExecute(
+		ctx: ActorContextHandle,
+		sql: string,
+		params?: RuntimeSqlBindParams,
+	): Promise<RuntimeSqlExecuteResult> {
+		const result = await this.#actorSql(ctx).execute(
+			sql,
+			toNapiSqlBindParams(params),
+		);
+		return normalizeRuntimeSqlExecuteResult(result);
+	}
+
+	async actorSqlExecuteWrite(
+		ctx: ActorContextHandle,
+		sql: string,
+		params?: RuntimeSqlBindParams,
+	): Promise<RuntimeSqlExecuteResult> {
+		const result = await this.#actorSql(ctx).executeWrite(
+			sql,
+			toNapiSqlBindParams(params),
+		);
+		return normalizeRuntimeSqlExecuteResult(result);
+	}
+
+	async actorSqlQuery(
+		ctx: ActorContextHandle,
+		sql: string,
+		params?: RuntimeSqlBindParams,
+	): Promise<RuntimeSqlQueryResult> {
+		return await this.#actorSql(ctx).query(
+			sql,
+			toNapiSqlBindParams(params),
+		);
+	}
+
+	async actorSqlRun(
+		ctx: ActorContextHandle,
+		sql: string,
+		params?: RuntimeSqlBindParams,
+	): Promise<RuntimeSqlRunResult> {
+		return await this.#actorSql(ctx).run(sql, toNapiSqlBindParams(params));
+	}
+
+	actorSqlTakeLastKvError(ctx: ActorContextHandle): string | null {
+		return this.#actorSql(ctx).takeLastKvError?.() ?? null;
+	}
+
+	async actorSqlClose(ctx: ActorContextHandle): Promise<void> {
+		const nativeCtx = asNativeActorContext(ctx);
+		const database = this.#sql.get(nativeCtx);
+		if (!database) {
+			return;
+		}
+
+		this.#sql.delete(nativeCtx);
+		await database.close();
+	}
+
+	async actorQueueSend(
+		ctx: ActorContextHandle,
+		name: string,
+		body: RuntimeBytes,
+	): Promise<RuntimeQueueMessage> {
+		return toNapiQueueMessage(
+			await asNativeActorContext(ctx)
+				.queue()
+				.send(name, toNapiBuffer(body)),
+		);
+	}
+
+	async actorQueueNextBatch(
+		ctx: ActorContextHandle,
+		options?: RuntimeQueueNextBatchOptions | undefined | null,
+		signal?: CancellationTokenHandle | undefined | null,
+	): Promise<RuntimeQueueMessage[]> {
+		const messages = await asNativeActorContext(ctx)
+			.queue()
+			.nextBatch(
+				options,
+				signal ? asNativeCancellationToken(signal) : signal,
+			);
+		return messages.map(toNapiQueueMessage);
+	}
+
+	async actorQueueWaitForNames(
+		ctx: ActorContextHandle,
+		names: string[],
+		options?: RuntimeQueueWaitOptions | undefined | null,
+		signal?: CancellationTokenHandle | undefined | null,
+	): Promise<RuntimeQueueMessage> {
+		return toNapiQueueMessage(
+			await asNativeActorContext(ctx)
+				.queue()
+				.waitForNames(
+					names,
+					options,
+					signal ? asNativeCancellationToken(signal) : signal,
+				),
+		);
+	}
+
+	async actorQueueWaitForNamesAvailable(
+		ctx: ActorContextHandle,
+		names: string[],
+		options?: RuntimeQueueWaitOptions | undefined | null,
+	): Promise<void> {
+		await asNativeActorContext(ctx)
+			.queue()
+			.waitForNamesAvailable(names, options);
+	}
+
+	async actorQueueEnqueueAndWait(
+		ctx: ActorContextHandle,
+		name: string,
+		body: RuntimeBytes,
+		options?: RuntimeQueueEnqueueAndWaitOptions | undefined | null,
+		signal?: CancellationTokenHandle | undefined | null,
+	): Promise<RuntimeBytes | null> {
+		return await asNativeActorContext(ctx)
+			.queue()
+			.enqueueAndWait(
+				name,
+				toNapiBuffer(body),
+				options,
+				signal ? asNativeCancellationToken(signal) : signal,
+			);
+	}
+
+	actorQueueTryNextBatch(
+		ctx: ActorContextHandle,
+		options?: RuntimeQueueTryNextBatchOptions | undefined | null,
+	): RuntimeQueueMessage[] {
+		return asNativeActorContext(ctx)
+			.queue()
+			.tryNextBatch(options)
+			.map(toNapiQueueMessage);
+	}
+
+	actorQueueMaxSize(ctx: ActorContextHandle): number {
+		return asNativeActorContext(ctx).queue().maxSize();
+	}
+
+	async actorQueueInspectMessages(ctx: ActorContextHandle) {
+		return await asNativeActorContext(ctx).queue().inspectMessages();
+	}
+
+	actorScheduleAfter(
+		ctx: ActorContextHandle,
+		durationMs: number,
+		actionName: string,
+		args: RuntimeBytes,
+	): void {
+		asNativeActorContext(ctx)
+			.schedule()
+			.after(durationMs, actionName, toNapiBuffer(args));
+	}
+
+	actorScheduleAt(
+		ctx: ActorContextHandle,
+		timestampMs: number,
+		actionName: string,
+		args: RuntimeBytes,
+	): void {
+		asNativeActorContext(ctx)
+			.schedule()
+			.at(timestampMs, actionName, toNapiBuffer(args));
+	}
+
+	connId(conn: ConnHandle): string {
+		return asNativeConn(conn).id();
+	}
+
+	connParams(conn: ConnHandle): RuntimeBytes {
+		return asNativeConn(conn).params();
+	}
+
+	connState(conn: ConnHandle): RuntimeBytes {
+		return asNativeConn(conn).state();
+	}
+
+	connSetState(conn: ConnHandle, state: RuntimeBytes): void {
+		asNativeConn(conn).setState(toNapiBuffer(state));
+	}
+
+	connIsHibernatable(conn: ConnHandle): boolean {
+		return asNativeConn(conn).isHibernatable();
+	}
+
+	connSend(conn: ConnHandle, name: string, args: RuntimeBytes): void {
+		asNativeConn(conn).send(name, toNapiBuffer(args));
+	}
+
+	async connDisconnect(
+		conn: ConnHandle,
+		reason?: string | undefined | null,
+	): Promise<void> {
+		await asNativeConn(conn).disconnect(reason);
+	}
+
+	webSocketSend(
+		ws: WebSocketHandle,
+		data: RuntimeBytes,
+		binary: boolean,
+	): void {
+		asNativeWebSocket(ws).send(toNapiBuffer(data), binary);
+	}
+
+	async webSocketClose(
+		ws: WebSocketHandle,
+		code?: number | undefined | null,
+		reason?: string | undefined | null,
+	): Promise<void> {
+		await asNativeWebSocket(ws).close(code, reason);
+	}
+
+	webSocketSetEventCallback(
+		ws: WebSocketHandle,
+		callback: (event: RuntimeWebSocketEvent) => void,
+	): void {
+		asNativeWebSocket(ws).setEventCallback(callback);
+	}
+}
+
+export type NapiBindings = NativeBindings;
+
+export async function loadNapiRuntime(): Promise<{
+	bindings: NapiBindings;
+	runtime: NapiCoreRuntime;
+}> {
+	const bindings = await import(["@rivetkit", "rivetkit-napi"].join("/"));
+	return {
+		bindings,
+		runtime: new NapiCoreRuntime(bindings),
+	};
+}
diff --git a/rivetkit-typescript/packages/rivetkit/src/registry/native.ts b/rivetkit-typescript/packages/rivetkit/src/registry/native.ts
index f91564108e..899bffa495 100644
--- a/rivetkit-typescript/packages/rivetkit/src/registry/native.ts
+++ b/rivetkit-typescript/packages/rivetkit/src/registry/native.ts
@@ -1,18 +1,3 @@
-import type {
-	JsActorConfig,
-	JsHttpResponse,
-	JsServeConfig,
-	ActorContext as NativeActorContext,
-	NapiActorFactory as NativeActorFactory,
-	CancellationToken as NativeCancellationToken,
-	ConnHandle as NativeConnHandle,
-	CoreRegistry as NativeCoreRegistry,
-	Queue as NativeQueue,
-	QueueMessage as NativeQueueMessage,
-	Schedule as NativeSchedule,
-	StateDeltaPayload as NativeStateDeltaPayload,
-	WebSocket as NativeWebSocket,
-} from "@rivetkit/rivetkit-napi";
 import { VirtualWebSocket } from "@rivetkit/virtual-websocket";
 import {
 	ACTOR_CONTEXT_INTERNAL_SYMBOL,
@@ -25,11 +10,11 @@ import type { AnyActorDefinition } from "@/actor/definition";
 import {
 	decodeBridgeRivetError,
 	encodeBridgeRivetError,
-	type RivetErrorLike,
 	forbiddenError,
 	INTERNAL_ERROR_CODE,
 	isRivetErrorLike,
 	RivetError,
+	type RivetErrorLike,
 	toRivetError,
 } from "@/actor/errors";
 import { makePrefixedKey, removePrefixFromKey } from "@/actor/keys";
@@ -51,19 +36,9 @@ import {
 import type * as protocol from "@/common/client-protocol";
 import {
 	CURRENT_VERSION as CLIENT_PROTOCOL_CURRENT_VERSION,
-	HTTP_ACTION_REQUEST_VERSIONED,
-	HTTP_ACTION_RESPONSE_VERSIONED,
-	HTTP_QUEUE_SEND_REQUEST_VERSIONED,
-	HTTP_QUEUE_SEND_RESPONSE_VERSIONED,
 	HTTP_RESPONSE_ERROR_VERSIONED,
 } from "@/common/client-protocol-versioned";
 import {
-	HttpActionRequestSchema,
-	HttpActionResponseSchema,
-	type HttpQueueSendRequest as HttpQueueSendRequestJson,
-	HttpQueueSendRequestSchema,
-	type HttpQueueSendResponse as HttpQueueSendResponseJson,
-	HttpQueueSendResponseSchema,
 	type HttpResponseError as HttpResponseErrorJson,
 	HttpResponseErrorSchema,
 } from "@/common/client-protocol-zod";
@@ -80,16 +55,21 @@ import type {
 } from "@/common/websocket-interface";
 import { RemoteEngineControlClient } from "@/engine-client/mod";
 import type { Registry } from "@/registry";
-import type { RegistryConfig } from "@/registry/config";
+import type {
+	RegistryConfig,
+	RuntimeKind,
+	SqliteBackend,
+} from "@/registry/config";
 import {
 	contentTypeForEncoding,
 	decodeCborCompat,
-	deserializeWithEncoding,
+	decodeCborJsonCompat,
 	encodeCborCompat,
 	serializeWithEncoding,
 } from "@/serde";
-import { bufferToArrayBuffer, VERSION } from "@/utils";
+import { getEnvUniversal, VERSION } from "@/utils";
 import { logger } from "./log";
+import { loadNapiRuntime } from "./napi-runtime";
 import {
 	type NativeValidationConfig,
 	validateActionArgs,
@@ -98,34 +78,182 @@ import {
 	validateQueueBody,
 	validateQueueComplete,
 } from "./native-validation";
+import type {
+	ActorContextHandle,
+	ActorFactoryHandle,
+	CancellationTokenHandle,
+	ConnHandle,
+	CoreRuntime,
+	RegistryHandle,
+	RuntimeActorConfig,
+	RuntimeBytes,
+	RuntimeHttpResponse,
+	RuntimeQueueMessage,
+	RuntimeServeConfig,
+	RuntimeStateDeltaPayload,
+	WebSocketHandle,
+} from "./runtime";
+import { loadWasmRuntime } from "./wasm-runtime";
 
-type NativeBindings = typeof import("@rivetkit/rivetkit-napi");
-type NativeWebSocketEvent =
-	| {
-			kind: "message";
-			data: string | Buffer;
-			binary: boolean;
-			messageIndex?: number;
-	  }
-	| {
-			kind: "close";
-			code: number;
-			reason: string;
-			wasClean: boolean;
-	  };
-type NativeWebSocketWithEvents = NativeWebSocket & {
-	setEventCallback: (callback: (event: NativeWebSocketEvent) => void) => void;
-};
 const textEncoder = new TextEncoder();
 const textDecoder = new TextDecoder();
+type ResolvedRuntimeKind = Exclude<RuntimeKind, "auto">;
+type RuntimeHostKind = "node-like" | "edge-like";
+export type RuntimeLoaders = {
+	loadNative: () => ReturnType<typeof loadNapiRuntime>;
+	loadWasm: (
+		config?: RegistryConfig["wasm"],
+	) => ReturnType<typeof loadWasmRuntime>;
+	detectHost: () => RuntimeHostKind;
+};
 type SerializeStateReason = "save" | "inspector";
 type NativeOnStateChangeHandler = (
-	ctx: NativeActorContextAdapter,
+	ctx: ActorContextHandleAdapter,
 	state: unknown,
 ) => void | Promise<void>;
 type NativePersistConnState = {
 	state: unknown;
 };
+
+const defaultRuntimeLoaders: RuntimeLoaders = {
+	loadNative: loadNapiRuntime,
+	loadWasm: loadWasmRuntime,
+	detectHost: detectRuntimeHost,
+};
+
+function trySetProcessEnv(key: string, value: string) {
+	if (typeof process === "undefined") return;
+	try {
+		process.env[key] = value;
+	} catch {
+		// Some edge runtimes expose a read-only Node-compatible process.env.
+	}
+}
+
+export function detectRuntimeHost(): RuntimeHostKind {
+	const globalScope = globalThis as typeof globalThis & {
+		Bun?: unknown;
+		Deno?: unknown;
+		process?: { versions?: { node?: string } };
+		self?: unknown;
+		window?: unknown;
+	};
+
+	if (
+		globalScope.Deno !== undefined ||
+		globalScope.Bun !== undefined ||
+		typeof globalScope.process?.versions?.node === "string"
+	) {
+		return "node-like";
+	}
+
+	return "edge-like";
+}
+
+export function resolveRuntimeKind(
+	runtime: RuntimeKind | undefined,
+): RuntimeKind {
+	return runtime ?? "auto";
+}
+
+function loadedRuntimeKind(runtime: CoreRuntime): ResolvedRuntimeKind {
+	switch (runtime.kind) {
+		case "napi":
+			return "native";
+		case "wasm":
+			return "wasm";
+	}
+
+	throw new RivetError(
+		"config",
+		"unknown_runtime",
+		"RivetKit runtime must be NAPI or wasm.",
+		{
+			public: true,
+			statusCode: 500,
+		},
+	);
+}
+
+export async function loadAutoRuntime(
+	config: RegistryConfig,
+	loaders: RuntimeLoaders = defaultRuntimeLoaders,
+): Promise<CoreRuntime> {
+	if (loaders.detectHost() === "edge-like") {
+		return (await loaders.loadWasm(config.wasm)).runtime;
+	}
+
+	try {
+		return (await loaders.loadNative()).runtime;
+	} catch {
+		return (await loaders.loadWasm(config.wasm)).runtime;
+	}
+}
+
+export async function loadConfiguredRuntime(
+	config: RegistryConfig,
+	loaders: RuntimeLoaders = defaultRuntimeLoaders,
+): Promise<CoreRuntime> {
+	const requested = resolveRuntimeKind(config.runtime);
+
+	if (requested === "native") {
+		return (await loaders.loadNative()).runtime;
+	}
+
+	if (requested === "wasm") {
+		return (await loaders.loadWasm(config.wasm)).runtime;
+	}
+
+	return loadAutoRuntime(config, loaders);
+}
+
+function sqliteBackendForConfig(
+	config: RegistryConfig,
+): SqliteBackend | undefined {
+	return config.sqlite?.backend ?? config.test?.sqliteBackend;
+}
+
+export function normalizeRuntimeConfigForKind(
+	config: RegistryConfig,
+	runtimeKind: ResolvedRuntimeKind,
+): RegistryConfig {
+	if (runtimeKind === "native") {
+		return config;
+	}
+
+	if (sqliteBackendForConfig(config) === "local") {
+		throw new RivetError(
+			"config",
+			"wasm_local_sqlite",
+			"WebAssembly runtime cannot use local SQLite. Use remote SQLite instead.",
+			{
+				public: true,
+				statusCode: 400,
+				metadata: { runtime: "wasm", sqliteBackend: "local" },
+			},
+		);
+	}
+
+	return {
+		...config,
+		sqlite: {
+			...config.sqlite,
+			backend: "remote",
+		},
+		test: {
+			...config.test,
+			enabled: config.test?.enabled ?? false,
+			sqliteBackend: "remote",
+		},
+	};
+}
+
+export function normalizeRuntimeConfig(
+	config: RegistryConfig,
+	runtime: CoreRuntime,
+): RegistryConfig {
+	return normalizeRuntimeConfigForKind(config, loadedRuntimeKind(runtime));
+}
 type NativePersistActorState = {
 	state: unknown;
 	isInOnStateChange: boolean;
@@ -151,10 +279,11 @@ type NativeActorRuntimeState = {
 // of actorId-keyed module globals so same-key recreates start from a fresh
 // generation.
 function getNativeRuntimeState(
-	ctx: NativeActorContext,
+	runtime: CoreRuntime,
+	ctx: ActorContextHandle,
 ): NativeActorRuntimeState {
 	const runtimeState = callNativeSync(() =>
-		ctx.runtimeState(),
+		runtime.actorRuntimeState(ctx),
 	) as NativeActorRuntimeState;
 	if (!runtimeState.destroyGate) {
 		runtimeState.destroyGate = {};
@@ -170,9 +299,14 @@ function getNativeRuntimeState(
 }
 
 function getNativePersistState(
-	ctx: NativeActorContext,
+	runtime: CoreRuntime,
+	ctx: ActorContextHandle,
 ): NativePersistActorState {
-	return getNativeRuntimeState(ctx).persistState!;
+	const persistState = getNativeRuntimeState(runtime, ctx).persistState;
+	if (!persistState) {
+		throw new Error("native persist state was not initialized");
+	}
+	return persistState;
 }
 
 function isPromiseLike(value: unknown): value is PromiseLike<void> {
@@ -185,11 +319,12 @@ function isPromiseLike(value: unknown): value is PromiseLike<void> {
 }
 
 function getNativeConnPersistState(
-	ctx: NativeActorContext,
-	conn: NativeConnHandle,
+	runtime: CoreRuntime,
+	ctx: ActorContextHandle,
+	conn: ConnHandle,
 ): NativePersistConnState {
-	const persistState = getNativePersistState(ctx);
-	const connId = callNativeSync(() => conn.id());
+	const persistState = getNativePersistState(runtime, ctx);
+	const connId = callNativeSync(() => runtime.connId(conn));
 	let connState = persistState.connStates.get(connId);
 	if (!connState) {
 		connState = {
@@ -244,21 +379,28 @@ function nativeEndpointNotConfiguredError(): RivetError {
 	);
 }
 
-function getNativeDestroyGate(ctx: NativeActorContext) {
-	return getNativeRuntimeState(ctx).destroyGate!;
+function getNativeDestroyGate(runtime: CoreRuntime, ctx: ActorContextHandle) {
+	const destroyGate = getNativeRuntimeState(runtime, ctx).destroyGate;
+	if (!destroyGate) {
+		throw new Error("native destroy gate was not initialized");
+	}
+	return destroyGate;
 }
 
-function markNativeDestroyRequested(ctx: NativeActorContext) {
-	const gate = getNativeDestroyGate(ctx);
+function markNativeDestroyRequested(
+	runtime: CoreRuntime,
+	ctx: ActorContextHandle,
+) {
+	const gate = getNativeDestroyGate(runtime, ctx);
 	if (!gate.destroyCompletion) {
 		gate.destroyCompletion = new Promise<void>((resolve) => {
-			gate!.resolveDestroy = resolve;
+			gate.resolveDestroy = resolve;
 		});
 	}
 }
 
-function resolveNativeDestroy(ctx: NativeActorContext) {
-	const gate = getNativeRuntimeState(ctx).destroyGate;
+function resolveNativeDestroy(runtime: CoreRuntime, ctx: ActorContextHandle) {
+	const gate = getNativeRuntimeState(runtime, ctx).destroyGate;
 	if (!gate?.resolveDestroy) {
 		return;
 	}
@@ -269,9 +411,10 @@ function resolveNativeDestroy(ctx: NativeActorContext) {
 }
 
 function closeNativeSqlDatabase(
-	ctx: NativeActorContext,
+	runtime: CoreRuntime,
+	ctx: ActorContextHandle,
 ): Promise<void> | undefined {
-	const runtimeState = getNativeRuntimeState(ctx);
+	const runtimeState = getNativeRuntimeState(runtime, ctx);
 	const database = runtimeState.sql;
 	if (!database) {
 		return;
@@ -282,9 +425,10 @@ function closeNativeSqlDatabase(
 }
 
 async function closeNativeDatabaseClient(
-	ctx: NativeActorContext,
+	runtime: CoreRuntime,
+	ctx: ActorContextHandle,
 ): Promise<void> {
-	const runtimeState = getNativeRuntimeState(ctx);
+	const runtimeState = getNativeRuntimeState(runtime, ctx);
 	const entry = runtimeState.databaseClient;
 	if (!entry) {
 		return;
@@ -303,27 +447,50 @@ async function closeNativeDatabaseClient(
 }
 
 function getOrCreateNativeSqlDatabase(
-	ctx: NativeActorContext,
+	runtime: CoreRuntime,
+	ctx: ActorContextHandle,
 ): ReturnType<typeof wrapJsNativeDatabase> {
-	const runtimeState = getNativeRuntimeState(ctx);
+	const runtimeState = getNativeRuntimeState(runtime, ctx);
 	const cachedDatabase = runtimeState.sql;
 	if (cachedDatabase) {
 		return cachedDatabase;
 	}
 
-	const database = wrapJsNativeDatabase(callNativeSync(() => ctx.sql()));
+	const database = wrapJsNativeDatabase({
+		exec: (sql) => runtime.actorSqlExec(ctx, sql),
+		execute: (sql, params) => runtime.actorSqlExecute(ctx, sql, params),
+		executeWrite: (sql, params) =>
+			runtime.actorSqlExecuteWrite(ctx, sql, params),
+		query: (sql, params) => runtime.actorSqlQuery(ctx, sql, params),
+		run: (sql, params) => runtime.actorSqlRun(ctx, sql, params),
+		takeLastKvError: () => runtime.actorSqlTakeLastKvError(ctx),
+		close: () => runtime.actorSqlClose(ctx),
+	});
 	runtimeState.sql = database;
 	return database;
 }
 
-function toBuffer(value: string | Uint8Array | ArrayBuffer): Buffer {
+function toRuntimeBytes(
+	value: string | Uint8Array | ArrayBuffer,
+): RuntimeBytes {
 	if (typeof value === "string") {
-		return Buffer.from(textEncoder.encode(value));
+		return textEncoder.encode(value);
 	}
 	if (value instanceof Uint8Array) {
-		return Buffer.from(value);
+		return value;
 	}
-	return Buffer.from(value);
+	return new Uint8Array(value);
+}
+
+function arrayBufferViewToRuntimeBytes(value: ArrayBufferView): RuntimeBytes {
+	return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+}
+
+function runtimeBytesToArrayBuffer(value: RuntimeBytes): ArrayBuffer {
+	return value.buffer.slice(
+		value.byteOffset,
+		value.byteOffset + value.byteLength,
+	) as ArrayBuffer;
 }
 
 type NativeKvValueType = "text" | "arrayBuffer" | "binary";
@@ -402,24 +569,20 @@ function decodeNativeKvValue<T extends NativeKvValueType = "text">(
 	}
 }
 
-async function loadNativeBindings(): Promise<NativeBindings> {
-	return import(["@rivetkit", "rivetkit-napi"].join("/"));
-}
-
 async function loadEngineCli(): Promise<typeof import("@rivetkit/engine-cli")> {
 	return import(["@rivetkit", "engine-cli"].join("/"));
 }
 
-function decodeValue<T>(value?: Buffer | Uint8Array | null): T {
+function decodeValue<T>(value?: RuntimeBytes | null): T {
 	if (!value || value.length === 0) {
 		return undefined as T;
 	}
 
-	return decodeCborCompat(Buffer.from(value));
+	return decodeCborJsonCompat(value);
 }
 
-function encodeValue(value: unknown): Buffer {
-	return Buffer.from(encodeCborCompat(value));
+function encodeValue(value: unknown): RuntimeBytes {
+	return encodeCborCompat(value);
 }
 
 function unwrapTsfnPayload<T>(error: unknown, payload: T): T {
@@ -574,6 +737,14 @@ function encodeNativeCallbackError(error: unknown): Error {
 		: deconstructError(error, logger(), {
 				bridge: "native_callback",
 			});
+	let stack: string | undefined;
+	if (error instanceof Error) {
+		try {
+			stack = error.stack;
+		} catch {
+			stack = undefined;
+		}
+	}
 
 	logger().warn({
 		msg: "native callback error encoded for bridge",
@@ -582,7 +753,7 @@ function encodeNativeCallbackError(error: unknown): Error {
 		message: structuredError.message,
 		metadata: structuredError.metadata,
 		originalError: stringifyError(error),
-		stack: error instanceof Error ? error.stack : undefined,
+		stack,
 		bridge: "native_callback",
 	});
 
@@ -638,23 +809,25 @@ function isClosedTaskRegistrationError(error: unknown): boolean {
 	);
 }
 
-async function createNativeCancellationToken(signal?: AbortSignal): Promise<{
-	token?: NativeCancellationToken;
+async function createCancellationTokenHandle(
+	runtime: CoreRuntime,
+	signal?: AbortSignal,
+): Promise<{
+	token?: CancellationTokenHandle;
 	cleanup?: () => void;
 }> {
 	if (!signal) {
 		return {};
 	}
 
-	const bindings = await loadNativeBindings();
-	const token = new bindings.CancellationToken();
+	const token = runtime.createCancellationToken();
 
 	if (signal.aborted) {
-		token.cancel();
+		runtime.cancelCancellationToken(token);
 		return { token };
 	}
 
-	const abort = () => token.cancel();
+	const abort = () => runtime.cancelCancellationToken(token);
 	signal.addEventListener("abort", abort, { once: true });
 	return {
 		token,
@@ -993,7 +1166,7 @@ function wrapNativeCallback<Args extends Array<unknown>, Result>(
 	};
 }
 
-function decodeArgs(value?: Buffer | Uint8Array | null): unknown[] {
+function decodeArgs(value?: RuntimeBytes | null): unknown[] {
 	const decoded = decodeValue<unknown>(value);
 	return Array.isArray(decoded)
 		? decoded
@@ -1055,12 +1228,15 @@ function buildRequest(init: {
 	method: string;
 	uri: string;
 	headers?: Record<string, string>;
-	body?: Buffer;
+	body?: RuntimeBytes;
 }): Request {
 	const url = init.uri.startsWith("http")
 		? init.uri
 		: new URL(init.uri, "http://127.0.0.1").toString();
-	const body = init.body && init.body.length > 0 ? init.body : undefined;
+	const body =
+		init.body && init.body.length > 0
+			? runtimeBytesToArrayBuffer(init.body)
+			: undefined;
 	return new Request(url, {
 		method: init.method,
 		headers: init.headers,
@@ -1068,9 +1244,11 @@ function buildRequest(init: {
 	});
 }
 
-async function toJsHttpResponse(response: Response): Promise<JsHttpResponse> {
+async function toRuntimeHttpResponse(
+	response: Response,
+): Promise<RuntimeHttpResponse> {
 	const headers = Object.fromEntries(response.headers.entries());
-	const body = Buffer.from(await response.arrayBuffer());
+	const body = new Uint8Array(await response.arrayBuffer());
 	return {
 		status: response.status,
 		headers,
@@ -1093,17 +1271,20 @@ function toActorKey(
 }
 
 class NativeConnAdapter {
-	#conn: NativeConnHandle;
+	#runtime: CoreRuntime;
+	#conn: ConnHandle;
 	#schemas: NativeValidationConfig;
-	#ctx?: NativeActorContext;
+	#ctx?: ActorContextHandle;
 	#queueHibernationRemoval?: (connId: string) => void;
 
 	constructor(
-		conn: NativeConnHandle,
+		runtime: CoreRuntime,
+		conn: ConnHandle,
 		schemas: NativeValidationConfig = {},
-		ctx?: NativeActorContext,
+		ctx?: ActorContextHandle,
 		queueHibernationRemoval?: (connId: string) => void,
 	) {
+		this.#runtime = runtime;
 		this.#conn = conn;
 		this.#schemas = schemas;
 		this.#ctx = ctx;
@@ -1122,13 +1303,13 @@ class NativeConnAdapter {
 	}
 
 	get id(): string {
-		return this.#conn.id();
+		return this.#runtime.connId(this.#conn);
 	}
 
 	get params(): unknown {
 		return validateConnParams(
 			this.#schemas.connParamsSchema,
-			decodeValue(this.#conn.params()),
+			decodeValue(this.#runtime.connParams(this.#conn)),
 		);
 	}
 
@@ -1148,7 +1329,9 @@ class NativeConnAdapter {
 	}
 
 	get isHibernatable(): boolean {
-		return callNativeSync(() => this.#conn.isHibernatable());
+		return callNativeSync(() =>
+			this.#runtime.connIsHibernatable(this.#conn),
+		);
 	}
 
 	send(name: string, ...args: unknown[]): void {
@@ -1157,12 +1340,20 @@ class NativeConnAdapter {
 			name,
 			args,
 		);
-		callNativeSync(() => this.#conn.send(name, encodeValue(validatedArgs)));
+		callNativeSync(() =>
+			this.#runtime.connSend(
+				this.#conn,
+				name,
+				encodeValue(validatedArgs),
+			),
+		);
 	}
 
 	async disconnect(reason?: string): Promise<void> {
 		const connId = this.id;
-		await callNative(() => this.#conn.disconnect(reason));
+		await callNative(() =>
+			this.#runtime.connDisconnect(this.#conn, reason),
+		);
 		if (this.isHibernatable) {
 			this.#queueHibernationRemoval?.(connId);
 		}
@@ -1170,12 +1361,16 @@ class NativeConnAdapter {
 
 	#readState(): unknown {
 		if (!this.#ctx) {
-			return decodeValue(this.#conn.state());
+			return decodeValue(this.#runtime.connState(this.#conn));
 		}
 
-		const connState = getNativeConnPersistState(this.#ctx, this.#conn);
+		const connState = getNativeConnPersistState(
+			this.#runtime,
+			this.#ctx,
+			this.#conn,
+		);
 		if (connState.state === undefined) {
-			connState.state = decodeValue(this.#conn.state());
+			connState.state = decodeValue(this.#runtime.connState(this.#conn));
 		}
 		return connState.state;
 	}
@@ -1188,23 +1383,29 @@ class NativeConnAdapter {
 	): void {
 		const encoded = encodeValue(value);
 		if (!this.#ctx) {
-			this.#conn.setState(encoded);
+			this.#runtime.connSetState(this.#conn, encoded);
 			return;
 		}
 
-		const connState = getNativeConnPersistState(this.#ctx, this.#conn);
+		const connState = getNativeConnPersistState(
+			this.#runtime,
+			this.#ctx,
+			this.#conn,
+		);
 		connState.state = value;
 		if (options.writeNative) {
-			this.#conn.setState(encoded);
+			this.#runtime.connSetState(this.#conn, encoded);
 		}
 	}
 }
 
 class NativeScheduleAdapter {
-	#schedule: NativeSchedule;
+	#runtime: CoreRuntime;
+	#ctx: ActorContextHandle;
 
-	constructor(schedule: NativeSchedule) {
-		this.#schedule = schedule;
+	constructor(runtime: CoreRuntime, ctx: ActorContextHandle) {
+		this.#runtime = runtime;
+		this.#ctx = ctx;
 	}
 
 	async after(
@@ -1213,7 +1414,12 @@ class NativeScheduleAdapter {
 		...args: unknown[]
 	): Promise<void> {
 		callNativeSync(() =>
-			this.#schedule.after(duration, action, encodeValue(args)),
+			this.#runtime.actorScheduleAfter(
+				this.#ctx,
+				duration,
+				action,
+				encodeValue(args),
+			),
 		);
 	}
 
@@ -1223,16 +1429,23 @@ class NativeScheduleAdapter {
 		...args: unknown[]
 	): Promise<void> {
 		callNativeSync(() =>
-			this.#schedule.at(timestamp, action, encodeValue(args)),
+			this.#runtime.actorScheduleAt(
+				this.#ctx,
+				timestamp,
+				action,
+				encodeValue(args),
+			),
 		);
 	}
 }
 
 class NativeKvAdapter {
-	#kv: ReturnType<NativeActorContext["kv"]>;
+	#runtime: CoreRuntime;
+	#ctx: ActorContextHandle;
 
-	constructor(kv: ReturnType<NativeActorContext["kv"]>) {
-		this.#kv = kv;
+	constructor(runtime: CoreRuntime, ctx: ActorContextHandle) {
+		this.#runtime = runtime;
+		this.#ctx = ctx;
 	}
 
 	async get<T extends NativeKvValueType = "text">(
@@ -1240,8 +1453,9 @@ class NativeKvAdapter {
 		options?: NativeKvValueOptions<T>,
 	): Promise<NativeKvValueTypeMap[T] | null> {
 		const value = await callNative(() =>
-			this.#kv.get(
-				Buffer.from(makePrefixedKey(encodeNativeKvUserKey(key))),
+			this.#runtime.actorKvGet(
+				this.#ctx,
+				makePrefixedKey(encodeNativeKvUserKey(key)),
 			),
 		);
 		return value
@@ -1255,17 +1469,19 @@ class NativeKvAdapter {
 		_options?: NativeKvValueOptions,
 	): Promise<void> {
 		await callNative(() =>
-			this.#kv.put(
-				Buffer.from(makePrefixedKey(encodeNativeKvUserKey(key))),
-				toBuffer(value),
+			this.#runtime.actorKvPut(
+				this.#ctx,
+				makePrefixedKey(encodeNativeKvUserKey(key)),
+				toRuntimeBytes(value),
 			),
 		);
 	}
 
 	async delete(key: string | Uint8Array): Promise<void> {
 		await callNative(() =>
-			this.#kv.delete(
-				Buffer.from(makePrefixedKey(encodeNativeKvUserKey(key))),
+			this.#runtime.actorKvDelete(
+				this.#ctx,
+				makePrefixedKey(encodeNativeKvUserKey(key)),
 			),
 		);
 	}
@@ -1275,16 +1491,17 @@ class NativeKvAdapter {
 		end: string | Uint8Array,
 	): Promise<void> {
 		await callNative(() =>
-			this.#kv.deleteRange(
-				Buffer.from(makePrefixedKey(encodeNativeKvUserKey(start))),
-				Buffer.from(makePrefixedKey(encodeNativeKvUserKey(end))),
+			this.#runtime.actorKvDeleteRange(
+				this.#ctx,
+				makePrefixedKey(encodeNativeKvUserKey(start)),
+				makePrefixedKey(encodeNativeKvUserKey(end)),
 			),
 		);
 	}
 
 	async rawDeleteRange(start: Uint8Array, end: Uint8Array): Promise<void> {
 		await callNative(() =>
-			this.#kv.deleteRange(Buffer.from(start), Buffer.from(end)),
+			this.#runtime.actorKvDeleteRange(this.#ctx, start, end),
 		);
 	}
 
@@ -1296,13 +1513,12 @@ class NativeKvAdapter {
 		options?: NativeKvListOptions<T, K>,
 	): Promise<Array<[NativeKvKeyTypeMap[K], NativeKvValueTypeMap[T]]>> {
 		const entries = await callNative(() =>
-			this.#kv.listPrefix(
-				Buffer.from(
-					makePrefixedKey(
-						encodeNativeKvUserKey(
-							prefix as NativeKvKeyTypeMap[K],
-							options?.keyType,
-						),
+			this.#runtime.actorKvListPrefix(
+				this.#ctx,
+				makePrefixedKey(
+					encodeNativeKvUserKey(
+						prefix as NativeKvKeyTypeMap[K],
+						options?.keyType,
 					),
 				),
 				{
@@ -1324,7 +1540,7 @@ class NativeKvAdapter {
 		prefix: Uint8Array,
 	): Promise<Array<[Uint8Array, Uint8Array]>> {
 		const entries = await callNative(() =>
-			this.#kv.listPrefix(Buffer.from(prefix), {}),
+			this.#runtime.actorKvListPrefix(this.#ctx, prefix, {}),
 		);
 		return entries.map((entry) => [
 			new Uint8Array(entry.key),
@@ -1341,21 +1557,18 @@ class NativeKvAdapter {
 		options?: NativeKvListOptions<T, K>,
 	): Promise<Array<[NativeKvKeyTypeMap[K], NativeKvValueTypeMap[T]]>> {
 		const entries = await callNative(() =>
-			this.#kv.listRange(
-				Buffer.from(
-					makePrefixedKey(
-						encodeNativeKvUserKey(
-							start as NativeKvKeyTypeMap[K],
-							options?.keyType,
-						),
+			this.#runtime.actorKvListRange(
+				this.#ctx,
+				makePrefixedKey(
+					encodeNativeKvUserKey(
+						start as NativeKvKeyTypeMap[K],
+						options?.keyType,
 					),
 				),
-				Buffer.from(
-					makePrefixedKey(
-						encodeNativeKvUserKey(
-							end as NativeKvKeyTypeMap[K],
-							options?.keyType,
-						),
+				makePrefixedKey(
+					encodeNativeKvUserKey(
+						end as NativeKvKeyTypeMap[K],
+						options?.keyType,
 					),
 				),
 				{
@@ -1385,17 +1598,18 @@ class NativeKvAdapter {
 
 	async batchGet(keys: Uint8Array[]): Promise<Array<Uint8Array | null>> {
 		const values = await callNative(() =>
-			this.#kv.batchGet(keys.map((key) => Buffer.from(key))),
+			this.#runtime.actorKvBatchGet(this.#ctx, keys),
 		);
 		return values.map((value) => (value ? new Uint8Array(value) : null));
 	}
 
 	async batchPut(entries: [Uint8Array, Uint8Array][]): Promise<void> {
 		await callNative(() =>
-			this.#kv.batchPut(
+			this.#runtime.actorKvBatchPut(
+				this.#ctx,
 				entries.map(([key, value]) => ({
-					key: Buffer.from(key),
-					value: Buffer.from(value),
+					key,
+					value,
 				})),
 			),
 		);
@@ -1403,13 +1617,13 @@ class NativeKvAdapter {
 
 	async batchDelete(keys: Uint8Array[]): Promise<void> {
 		await callNative(() =>
-			this.#kv.batchDelete(keys.map((key) => Buffer.from(key))),
+			this.#runtime.actorKvBatchDelete(this.#ctx, keys),
 		);
 	}
 }
 
 function wrapQueueMessage(
-	message: NativeQueueMessage,
+	message: RuntimeQueueMessage,
 	schemas: NativeValidationConfig["queues"],
 ) {
 	const name = callNativeSync(() => message.name());
@@ -1442,15 +1656,18 @@ function wrapQueueMessage(
 }
 
 class NativeQueueAdapter {
-	#queue: NativeQueue;
+	#runtime: CoreRuntime;
+	#ctx: ActorContextHandle;
 	#schemas: NativeValidationConfig["queues"];
 	#pendingCompletableMessageIds = new Set<string>();
 
 	constructor(
-		queue: NativeQueue,
+		runtime: CoreRuntime,
+		ctx: ActorContextHandle,
 		schemas: NativeValidationConfig["queues"] = undefined,
 	) {
-		this.#queue = queue;
+		this.#runtime = runtime;
+		this.#ctx = ctx;
 		this.#schemas = schemas;
 	}
 
@@ -1458,7 +1675,11 @@ class NativeQueueAdapter {
 		const validatedBody = validateQueueBody(this.#schemas, name, body);
 		return wrapQueueMessage(
 			await callNative(() =>
-				this.#queue.send(name, encodeValue(validatedBody)),
+				this.#runtime.actorQueueSend(
+					this.#ctx,
+					name,
+					encodeValue(validatedBody),
+				),
 			),
 			this.#schemas,
 		);
@@ -1500,13 +1721,15 @@ class NativeQueueAdapter {
 			);
 		}
 
-		const { token, cleanup } = await createNativeCancellationToken(
+		const { token, cleanup } = await createCancellationTokenHandle(
+			this.#runtime,
 			options?.signal,
 		);
 
 		try {
 			const messages = await callNative(() =>
-				this.#queue.nextBatch(
+				this.#runtime.actorQueueNextBatch(
+					this.#ctx,
 					{
 						names: this.#normalizeNames(options?.names),
 						count: options?.count,
@@ -1537,14 +1760,16 @@ class NativeQueueAdapter {
 			completable?: boolean;
 		},
 	) {
-		const { token, cleanup } = await createNativeCancellationToken(
+		const { token, cleanup } = await createCancellationTokenHandle(
+			this.#runtime,
 			options?.signal,
 		);
 
 		try {
 			return wrapQueueMessage(
 				await callNative(() =>
-					this.#queue.waitForNames(
+					this.#runtime.actorQueueWaitForNames(
+						this.#ctx,
 						[...names],
 						{
 							timeoutMs: options?.timeout,
@@ -1569,9 +1794,13 @@ class NativeQueueAdapter {
 	) {
 		if (!options?.signal) {
 			await callNative(() =>
-				this.#queue.waitForNamesAvailable([...names], {
-					timeoutMs: options?.timeout,
-				}),
+				this.#runtime.actorQueueWaitForNamesAvailable(
+					this.#ctx,
+					[...names],
+					{
+						timeoutMs: options?.timeout,
+					},
+				),
 			);
 			return;
 		}
@@ -1597,9 +1826,13 @@ class NativeQueueAdapter {
 
 			try {
 				await callNative(() =>
-					this.#queue.waitForNamesAvailable([...names], {
-						timeoutMs: sliceTimeout,
-					}),
+					this.#runtime.actorQueueWaitForNamesAvailable(
+						this.#ctx,
+						[...names],
+						{
+							timeoutMs: sliceTimeout,
+						},
+					),
 				);
 				return;
 			} catch (error) {
@@ -1630,13 +1863,15 @@ class NativeQueueAdapter {
 		},
 	) {
 		const validatedBody = validateQueueBody(this.#schemas, name, body);
-		const { token, cleanup } = await createNativeCancellationToken(
+		const { token, cleanup } = await createCancellationTokenHandle(
+			this.#runtime,
 			options?.signal,
 		);
 
 		try {
 			const response = await callNative(() =>
-				this.#queue.enqueueAndWait(
+				this.#runtime.actorQueueEnqueueAndWait(
+					this.#ctx,
 					name,
 					encodeValue(validatedBody),
 					{
@@ -1683,16 +1918,24 @@ class NativeQueueAdapter {
 			});
 		}
 
-		const messages = callNativeSync(() =>
-			this.#queue.tryNextBatch({
-				names: this.#normalizeNames(options?.names),
+		try {
+			return await this.nextBatch({
+				names: options?.names,
 				count: options?.count,
+				timeout: 0,
 				completable: false,
-			}),
-		);
-		return messages.map((message) =>
-			wrapQueueMessage(message, this.#schemas),
-		);
+			});
+		} catch (error) {
+			if (
+				(error as { group?: string; code?: string }).group ===
+					"queue" &&
+				(error as { group?: string; code?: string }).code ===
+					"timed_out"
+			) {
+				return [];
+			}
+			throw error;
+		}
 	}
 
 	async *iter(options?: {
@@ -1765,50 +2008,56 @@ class NativeQueueAdapter {
 					);
 				}
 
-				try {
-					await message.complete(response);
-					completed = true;
-					this.#pendingCompletableMessageIds.delete(messageId);
-				} catch (error) {
-					throw error;
-				}
+				await message.complete(response);
+				completed = true;
+				this.#pendingCompletableMessageIds.delete(messageId);
 			},
 		};
 	}
 }
 
 class NativeWebSocketAdapter {
-	#ws: NativeWebSocketWithEvents;
+	#runtime: CoreRuntime;
+	#ws: WebSocketHandle;
 	#virtual: VirtualWebSocket;
 	#readyState: 0 | 1 | 2 | 3 = VirtualWebSocket.OPEN;
 
-	constructor(ws: NativeWebSocket) {
-		this.#ws = ws as NativeWebSocketWithEvents;
+	constructor(runtime: CoreRuntime, ws: WebSocketHandle) {
+		this.#runtime = runtime;
+		this.#ws = ws;
 		this.#virtual = new VirtualWebSocket({
 			getReadyState: () => this.#readyState,
 			onSend: (data) => {
 				if (typeof data === "string") {
 					callNativeSync(() =>
-						this.#ws.send(Buffer.from(data), false),
+						this.#runtime.webSocketSend(
+							this.#ws,
+							textEncoder.encode(data),
+							false,
+						),
 					);
 					return;
 				}
 
-				const buffer = ArrayBuffer.isView(data)
-					? Buffer.from(data.buffer, data.byteOffset, data.byteLength)
-					: Buffer.from(data as ArrayBufferLike);
-				callNativeSync(() => this.#ws.send(buffer, true));
+				const bytes = ArrayBuffer.isView(data)
+					? arrayBufferViewToRuntimeBytes(data)
+					: new Uint8Array(data as ArrayBufferLike);
+				callNativeSync(() =>
+					this.#runtime.webSocketSend(this.#ws, bytes, true),
+				);
 			},
 			onClose: (code, reason) => {
 				this.#readyState = VirtualWebSocket.CLOSING;
-				void callNative(() => this.#ws.close(code, reason));
+				void callNative(() =>
+					this.#runtime.webSocketClose(this.#ws, code, reason),
+				);
 			},
 		});
-		this.#ws.setEventCallback((event) => {
+		this.#runtime.webSocketSetEventCallback(this.#ws, (event) => {
 			if (event.kind === "message") {
 				this.#virtual.triggerMessage(
 					event.binary
-						? bufferToArrayBuffer(event.data as Buffer)
+						? runtimeBytesToArrayBuffer(event.data as RuntimeBytes)
 						: event.data,
 					event.messageIndex,
 				);
@@ -1933,8 +2182,8 @@ class NativeWebSocketAdapter {
 
 type TrackedWebSocketListener = (event: any) => void | Promise<void>;
 
-class TrackedNativeWebSocketAdapter implements UniversalWebSocket {
-	#ctx: NativeActorContextAdapter;
+class TrackedWebSocketHandleAdapter implements UniversalWebSocket {
+	#ctx: ActorContextHandleAdapter;
 	#inner: UniversalWebSocket;
 	#listeners = new Map<string, TrackedWebSocketListener[]>();
 	#onopen: ((event: RivetEvent) => void | Promise<void>) | null = null;
@@ -1943,7 +2192,7 @@ class TrackedNativeWebSocketAdapter implements UniversalWebSocket {
 	#onmessage: ((event: RivetMessageEvent) => void | Promise<void>) | null =
 		null;
 
-	constructor(ctx: NativeActorContextAdapter, inner: UniversalWebSocket) {
+	constructor(ctx: ActorContextHandleAdapter, inner: UniversalWebSocket) {
 		this.#ctx = ctx;
 		this.#inner = inner;
 
@@ -2014,10 +2263,12 @@ class TrackedNativeWebSocketAdapter implements UniversalWebSocket {
 	}
 
 	addEventListener(type: string, listener: TrackedWebSocketListener): void {
-		if (!this.#listeners.has(type)) {
-			this.#listeners.set(type, []);
+		let listeners = this.#listeners.get(type);
+		if (!listeners) {
+			listeners = [];
+			this.#listeners.set(type, listeners);
 		}
-		this.#listeners.get(type)!.push(listener);
+		listeners.push(listener);
 	}
 
 	removeEventListener(
@@ -2181,9 +2432,9 @@ class TrackedNativeWebSocketAdapter implements UniversalWebSocket {
 	}
 }
 
-export class NativeActorContextAdapter {
-	#bindings: NativeBindings;
-	#ctx: NativeActorContext;
+export class ActorContextHandleAdapter {
+	#runtime: CoreRuntime;
+	#ctx: ActorContextHandle;
 	#schemas: NativeValidationConfig;
 	#abortSignal?: AbortSignal;
 	#abortSignalCleanup?: () => void;
@@ -2192,7 +2443,7 @@ export class NativeActorContextAdapter {
 	#databaseProvider?: Exclude<AnyDatabaseProvider, undefined>;
 	#db?: unknown;
 	#dbProxy?: unknown;
-	#dispatchCancelToken?: NativeCancellationToken;
+	#dispatchCancelToken?: CancellationTokenHandle;
 	#kv?: NativeKvAdapter;
 	#queue?: NativeQueueAdapter;
 	#request?: Request;
@@ -2203,8 +2454,8 @@ export class NativeActorContextAdapter {
 	#stateEnabled: boolean;
 
 	constructor(
-		bindings: NativeBindings,
-		ctx: NativeActorContext,
+		runtime: CoreRuntime,
+		ctx: ActorContextHandle,
 		clientFactory?: () => AnyClient,
 		schemas: NativeValidationConfig = {},
 		databaseProvider?: AnyDatabaseProvider,
@@ -2212,9 +2463,9 @@ export class NativeActorContextAdapter {
 		stateEnabled = true,
 		runHandlerActiveProvider?: () => boolean,
 		onStateChange?: NativeOnStateChangeHandler,
-		dispatchCancelToken?: NativeCancellationToken,
+		dispatchCancelToken?: CancellationTokenHandle,
 	) {
-		this.#bindings = bindings;
+		this.#runtime = runtime;
 		this.#ctx = ctx;
 		this.#clientFactory = clientFactory;
 		this.#schemas = schemas;
@@ -2227,7 +2478,7 @@ export class NativeActorContextAdapter {
 		}
 		this.#request = request;
 		(
-			this as NativeActorContextAdapter & {
+			this as ActorContextHandleAdapter & {
 				[ACTOR_CONTEXT_INTERNAL_SYMBOL]?: unknown;
 			}
 		)[ACTOR_CONTEXT_INTERNAL_SYMBOL] = new NativeWorkflowRuntimeAdapter(
@@ -2237,14 +2488,14 @@ export class NativeActorContextAdapter {
 
 	get kv() {
 		if (!this.#kv) {
-			this.#kv = new NativeKvAdapter(this.#ctx.kv());
+			this.#kv = new NativeKvAdapter(this.#runtime, this.#ctx);
 		}
 		return this.#kv;
 	}
 
 	get sql() {
 		if (!this.#sql) {
-			this.#sql = getOrCreateNativeSqlDatabase(this.#ctx);
+			this.#sql = getOrCreateNativeSqlDatabase(this.#runtime, this.#ctx);
 		}
 		return this.#sql;
 	}
@@ -2314,7 +2565,7 @@ export class NativeActorContextAdapter {
 	}
 
 	get vars(): unknown {
-		const runtimeState = getNativeRuntimeState(this.#ctx);
+		const runtimeState = getNativeRuntimeState(this.#runtime, this.#ctx);
 		if (runtimeState.varsInitialized) {
 			return runtimeState.vars;
 		}
@@ -2325,7 +2576,7 @@ export class NativeActorContextAdapter {
 	}
 
 	set vars(value: unknown) {
-		const runtimeState = getNativeRuntimeState(this.#ctx);
+		const runtimeState = getNativeRuntimeState(this.#runtime, this.#ctx);
 		runtimeState.varsInitialized = true;
 		runtimeState.vars = value;
 	}
@@ -2333,7 +2584,8 @@ export class NativeActorContextAdapter {
 	get queue(): NativeQueueAdapter {
 		if (!this.#queue) {
 			this.#queue = new NativeQueueAdapter(
-				callNativeSync(() => this.#ctx.queue()),
+				this.#runtime,
+				this.#ctx,
 				this.#schemas.queues,
 			);
 		}
@@ -2343,42 +2595,51 @@ export class NativeActorContextAdapter {
 	get schedule(): NativeScheduleAdapter {
 		if (!this.#schedule) {
 			this.#schedule = new NativeScheduleAdapter(
-				callNativeSync(() => this.#ctx.schedule()),
+				this.#runtime,
+				this.#ctx,
 			);
 		}
 		return this.#schedule;
 	}
 
 	get actorId(): string {
-		return callNativeSync(() => this.#ctx.actorId());
+		return callNativeSync(() => this.#runtime.actorId(this.#ctx));
 	}
 
 	get name(): string {
-		return callNativeSync(() => this.#ctx.name());
+		return callNativeSync(() => this.#runtime.actorName(this.#ctx));
 	}
 
 	get key(): string[] {
-		return toActorKey(callNativeSync(() => this.#ctx.key()));
+		return toActorKey(
+			callNativeSync(() => this.#runtime.actorKey(this.#ctx)),
+		);
 	}
 
 	get region(): string {
-		return callNativeSync(() => this.#ctx.region());
+		return callNativeSync(() => this.#runtime.actorRegion(this.#ctx));
 	}
 
 	get conns(): Map<string, NativeConnAdapter> {
 		return new Map(
-			callNativeSync(() => this.#ctx.conns()).map((conn) => [
-				conn.id(),
-				new NativeConnAdapter(
-					conn,
-					this.#schemas,
-					this.#ctx,
-					(connId) =>
-						callNativeSync(() =>
-							this.#ctx.queueHibernationRemoval(connId),
-						),
-				),
-			]),
+			callNativeSync(() => this.#runtime.actorConns(this.#ctx)).map(
+				(conn) => [
+					this.#runtime.connId(conn),
+					new NativeConnAdapter(
+						this.#runtime,
+						conn,
+						this.#schemas,
+						this.#ctx,
+						(connId) =>
+							callNativeSync(() =>
+								this.#runtime.actorQueueHibernationRemoval(
+									this.#ctx,
+									connId,
+								),
+							),
+					),
+				],
+			),
 		);
 	}
 
@@ -2409,7 +2670,9 @@ export class NativeActorContextAdapter {
 
 				if (
 					actorSignal.aborted ||
-					this.#dispatchCancelToken.aborted()
+					this.#runtime.cancellationTokenAborted(
+						this.#dispatchCancelToken,
+					)
 				) {
 					controller.abort();
 				} else {
@@ -2419,10 +2682,13 @@ export class NativeActorContextAdapter {
 						once: true,
 					});
 					callNativeSync(() =>
-						dispatchCancelToken.onCancelled(() => {
-							cleanup();
-							controller.abort();
-						}),
+						this.#runtime.onCancellationTokenCancelled(
+							dispatchCancelToken,
+							() => {
+								cleanup();
+								controller.abort();
+							},
+						),
 					);
 				}
 
@@ -2449,7 +2715,7 @@ export class NativeActorContextAdapter {
 			return this.#db;
 		}
 
-		const runtimeState = getNativeRuntimeState(this.#ctx);
+		const runtimeState = getNativeRuntimeState(this.#runtime, this.#ctx);
 		const cachedClient = runtimeState.databaseClient;
 		if (cachedClient) {
 			this.#db = cachedClient.client;
@@ -2481,7 +2747,10 @@ export class NativeActorContextAdapter {
 			nativeDatabaseProvider: {
 				open: async (requestedActorId) => {
 					void requestedActorId;
-					return getOrCreateNativeSqlDatabase(this.#ctx);
+					return getOrCreateNativeSqlDatabase(
+						this.#runtime,
+						this.#ctx,
+					);
 				},
 			},
 		});
@@ -2513,8 +2782,8 @@ export class NativeActorContextAdapter {
 	async closeDatabase(): Promise<void> {
 		this.#db = undefined;
 		this.#sql = undefined;
-		await closeNativeDatabaseClient(this.#ctx);
-		await closeNativeSqlDatabase(this.#ctx);
+		await closeNativeDatabaseClient(this.#runtime, this.#ctx);
+		await closeNativeSqlDatabase(this.#runtime, this.#ctx);
 	}
 
 	broadcast(name: string, ...args: unknown[]): void {
@@ -2524,7 +2793,11 @@ export class NativeActorContextAdapter {
 			args,
 		);
 		callNativeSync(() =>
-			this.#ctx.broadcast(name, encodeValue(validatedArgs)),
+			this.#runtime.actorBroadcast(
+				this.#ctx,
+				name,
+				encodeValue(validatedArgs),
+			),
 		);
 	}
 
@@ -2534,41 +2807,47 @@ export class NativeActorContextAdapter {
 	}): Promise<void> {
 		if (opts?.immediate) {
 			await callNative(() =>
-				this.#ctx.requestSaveAndWait({ immediate: true }),
+				this.#runtime.actorRequestSaveAndWait(this.#ctx, {
+					immediate: true,
+				}),
 			);
 			return;
 		}
 
 		if (opts?.maxWait != null) {
 			callNativeSync(() =>
-				this.#ctx.requestSave({ maxWaitMs: opts.maxWait }),
+				this.#runtime.actorRequestSave(this.#ctx, {
+					maxWaitMs: opts.maxWait,
+				}),
 			);
 			return;
 		}
 
-		callNativeSync(() => this.#ctx.requestSave({ immediate: false }));
+		callNativeSync(() =>
+			this.#runtime.actorRequestSave(this.#ctx, { immediate: false }),
+		);
 	}
 
-	serializeForTick(reason: SerializeStateReason): NativeStateDeltaPayload {
+	serializeForTick(reason: SerializeStateReason): RuntimeStateDeltaPayload {
 		void reason;
-		const actorState = getNativePersistState(this.#ctx);
+		const actorState = getNativePersistState(this.#runtime, this.#ctx);
 		const connHibernationRemoved = callNativeSync(() =>
-			this.#ctx.takePendingHibernationChanges(),
+			this.#runtime.actorTakePendingHibernationChanges(this.#ctx),
 		);
 		for (const connId of connHibernationRemoved) {
 			actorState.connStates.delete(connId);
 		}
 		const state =
 			this.#stateEnabled && this.#readState() !== undefined
-				? Buffer.from(encodeValue(this.#readState()))
+				? encodeValue(this.#readState())
 				: undefined;
 		const connHibernation = callNativeSync(() =>
-			this.#ctx.dirtyHibernatableConns(),
+			this.#runtime.actorDirtyHibernatableConns(this.#ctx),
 		).map((conn) => {
-			const connId = callNativeSync(() => conn.id());
+			const connId = callNativeSync(() => this.#runtime.connId(conn));
 			return {
 				connId,
-				bytes: Buffer.from(callNativeSync(() => conn.state())),
+				bytes: callNativeSync(() => this.#runtime.connState(conn)),
 			};
 		});
 
@@ -2581,13 +2860,13 @@ export class NativeActorContextAdapter {
 
 	async restartRunHandler(): Promise<void> {
 		await callNative(async () => {
-			this.#ctx.restartRunHandler();
+			this.#runtime.actorRestartRunHandler(this.#ctx);
 		});
 	}
 
 	async setAlarm(timestampMs?: number): Promise<void> {
 		await callNative(async () => {
-			this.#ctx.setAlarm(timestampMs);
+			this.#runtime.actorSetAlarm(this.#ctx, timestampMs);
 		});
 	}
 
@@ -2609,7 +2888,10 @@ export class NativeActorContextAdapter {
 		// gating logic. Logging the rejection avoids unhandled-promise warnings
 		// without blocking the caller.
 		callNative(() =>
-			this.#ctx.keepAwake(Promise.resolve(promise).then(() => null)),
+			this.#runtime.actorKeepAwake(
+				this.#ctx,
+				Promise.resolve(promise).then(() => null),
+			),
 		).catch((error) => {
 			if (!isClosedTaskRegistrationError(error)) {
 				logger().warn({
@@ -2629,7 +2911,9 @@ export class NativeActorContextAdapter {
 		const promise = typeof run === "function" ? run() : run;
 		const trackedPromise = promise.then(() => null);
 		try {
-			callNativeSync(() => this.#ctx.registerTask(trackedPromise));
+			callNativeSync(() =>
+				this.#runtime.actorRegisterTask(this.#ctx, trackedPromise),
+			);
 		} catch (error) {
 			if (!isClosedTaskRegistrationError(error)) {
 				throw error;
@@ -2641,7 +2925,9 @@ export class NativeActorContextAdapter {
 	waitUntil(promise: Promise<unknown>): void {
 		const trackedPromise = Promise.resolve(promise).then(() => null);
 		try {
-			callNativeSync(() => this.#ctx.waitUntil(trackedPromise));
+			callNativeSync(() =>
+				this.#runtime.actorWaitUntil(this.#ctx, trackedPromise),
+			);
 		} catch (error) {
 			if (!isClosedTaskRegistrationError(error)) {
 				throw error;
@@ -2650,11 +2936,18 @@ export class NativeActorContextAdapter {
 	}
 
 	beginWebSocketCallback(): number {
-		return callNativeSync(() => this.#ctx.beginWebsocketCallback());
+		return callNativeSync(() =>
+			this.#runtime.actorBeginWebsocketCallback(this.#ctx),
+		);
 	}
 
 	endWebSocketCallback(callbackRegionId: number): void {
-		callNativeSync(() => this.#ctx.endWebsocketCallback(callbackRegionId));
+		callNativeSync(() =>
+			this.#runtime.actorEndWebsocketCallback(
+				this.#ctx,
+				callbackRegionId,
+			),
+		);
 	}
 
 	// Intentionally a no-op. `setPreventSleep` / `preventSleep` are kept on the
@@ -2678,15 +2971,15 @@ export class NativeActorContextAdapter {
 	}
 
 	sleep(): void {
-		callNativeSync(() => this.#ctx.sleep());
+		callNativeSync(() => this.#runtime.actorSleep(this.#ctx));
 	}
 
 	destroy(): void {
 		// Call the native destroy first so it can throw `actor/starting` or
 		// `actor/stopping` without leaving an unresolved destroyCompletion
 		// promise behind in the native runtime state.
-		callNativeSync(() => this.#ctx.destroy());
-		markNativeDestroyRequested(this.#ctx);
+		callNativeSync(() => this.#runtime.actorDestroy(this.#ctx));
+		markNativeDestroyRequested(this.#runtime, this.#ctx);
 	}
 
 	client<T = AnyClient>(): T extends Registry<any> ? Client<T> : T {
@@ -2706,7 +2999,9 @@ export class NativeActorContextAdapter {
 	}
 
 	#createActorAbortSignal(): AbortSignal {
-		const nativeSignal = callNativeSync(() => this.#ctx.abortSignal());
+		const nativeSignal = callNativeSync(() =>
+			this.#runtime.actorAbortSignal(this.#ctx),
+		);
 		const controller = new AbortController();
 		if (nativeSignal.aborted) {
 			controller.abort();
@@ -2719,10 +3014,10 @@ export class NativeActorContextAdapter {
 	}
 
 	#readState(): unknown {
-		const actorState = getNativePersistState(this.#ctx);
+		const actorState = getNativePersistState(this.#runtime, this.#ctx);
 		if (actorState.state === undefined) {
 			actorState.state = decodeValue(
-				callNativeSync(() => this.#ctx.state()),
+				callNativeSync(() => this.#runtime.actorState(this.#ctx)),
 			);
 		}
 		return actorState.state;
@@ -2735,7 +3030,7 @@ export class NativeActorContextAdapter {
 		},
 	): void {
 		encodeValue(value);
-		const actorState = getNativePersistState(this.#ctx);
+		const actorState = getNativePersistState(this.#runtime, this.#ctx);
 		actorState.state = value;
 		if (!options.scheduleSave) {
 			return;
@@ -2744,23 +3039,25 @@ export class NativeActorContextAdapter {
 	}
 
 	#assertCanMutateState(): void {
-		const actorState = getNativePersistState(this.#ctx);
+		const actorState = getNativePersistState(this.#runtime, this.#ctx);
 		if (actorState.isInOnStateChange) {
 			throw stateMutationReentrantError();
 		}
 	}
 
 	#handleStateChange(): void {
-		const actorState = getNativePersistState(this.#ctx);
+		const actorState = getNativePersistState(this.#runtime, this.#ctx);
 		encodeValue(actorState.state);
-		callNativeSync(() => this.#ctx.requestSave({ immediate: false }));
+		callNativeSync(() =>
+			this.#runtime.actorRequestSave(this.#ctx, { immediate: false }),
+		);
 
 		if (!this.#onStateChange) {
 			return;
 		}
 
 		actorState.isInOnStateChange = true;
-		callNativeSync(() => this.#ctx.beginOnStateChange());
+		callNativeSync(() => this.#runtime.actorBeginOnStateChange(this.#ctx));
 		let shouldFinish = true;
 		try {
 			const result = this.#onStateChange(
@@ -2778,13 +3075,17 @@ export class NativeActorContextAdapter {
 					})
 					.finally(() => {
 						actorState.isInOnStateChange = false;
-						callNativeSync(() => this.#ctx.endOnStateChange());
+						callNativeSync(() =>
+							this.#runtime.actorEndOnStateChange(this.#ctx),
+						);
 					});
 			}
 		} finally {
 			if (shouldFinish) {
 				actorState.isInOnStateChange = false;
-				callNativeSync(() => this.#ctx.endOnStateChange());
+				callNativeSync(() =>
+					this.#runtime.actorEndOnStateChange(this.#ctx),
+				);
 			}
 		}
 	}
@@ -2795,7 +3096,7 @@ type NativeWorkflowQueueMessage = Awaited<
 >;
 
 class NativeWorkflowRuntimeAdapter {
-	#ctx: NativeActorContextAdapter;
+	#ctx: ActorContextHandleAdapter;
 	#completions = new Map<string, (response?: unknown) => Promise<void>>();
 
 	readonly id: string;
@@ -2860,7 +3161,7 @@ class NativeWorkflowRuntimeAdapter {
 		}) => Promise<void>;
 	};
 
-	constructor(ctx: NativeActorContextAdapter) {
+	constructor(ctx: ActorContextHandleAdapter) {
 		this.#ctx = ctx;
 		this.id = ctx.actorId;
 		this.driver = {
@@ -2976,38 +3277,21 @@ class NativeWorkflowRuntimeAdapter {
 	}
 }
 
-function buildNativeHttpRequest(
-	request: Request,
-	body?: Uint8Array,
-): {
-	method: string;
-	uri: string;
-	headers: Record<string, string>;
-	body?: Buffer;
-} {
-	return {
-		method: request.method,
-		uri: request.url,
-		headers: Object.fromEntries(request.headers.entries()),
-		body: body && body.byteLength > 0 ? Buffer.from(body) : undefined,
-	};
-}
-
 function withConnContext(
-	bindings: NativeBindings,
-	ctx: NativeActorContext,
-	conn: NativeConnHandle,
+	runtime: CoreRuntime,
+	ctx: ActorContextHandle,
+	conn: ConnHandle,
 	clientFactory?: () => AnyClient,
 	schemas: NativeValidationConfig = {},
 	databaseProvider?: AnyDatabaseProvider,
 	request?: Request,
 	stateEnabled = true,
 	onStateChange?: NativeOnStateChangeHandler,
-	dispatchCancelToken?: NativeCancellationToken,
+	dispatchCancelToken?: CancellationTokenHandle,
 ) {
 	return Object.assign(
-		new NativeActorContextAdapter(
-			bindings,
+		new ActorContextHandleAdapter(
+			runtime,
 			ctx,
 			clientFactory,
 			schemas,
@@ -3019,8 +3303,10 @@ function withConnContext(
 			dispatchCancelToken,
 		),
 		{
-			conn: new NativeConnAdapter(conn, schemas, ctx, (connId) =>
-				callNativeSync(() => ctx.queueHibernationRemoval(connId)),
+			conn: new NativeConnAdapter(runtime, conn, schemas, ctx, (connId) =>
+				callNativeSync(() =>
+					runtime.actorQueueHibernationRemoval(ctx, connId),
+				),
 			),
 		},
 	);
@@ -3058,7 +3344,9 @@ function buildNativeRequestErrorResponse(
 			metadata:
 				value.metadata === undefined
 					? null
-					: bufferToArrayBuffer(encodeCborCompat(value.metadata)),
+					: runtimeBytesToArrayBuffer(
+							encodeCborCompat(value.metadata),
+						),
 		}),
 	);
 
@@ -3073,7 +3361,7 @@ function buildNativeRequestErrorResponse(
 function buildActorConfig(
 	definition: AnyActorDefinition,
 	registryConfig: RegistryConfig,
-): JsActorConfig {
+): RuntimeActorConfig {
 	const config = definition.config as unknown as Record<string, unknown>;
 	const options = (config.options ?? {}) as Record<string, unknown>;
 	const canHibernate = options.canHibernateWebSocket;
@@ -3082,6 +3370,9 @@ function buildActorConfig(
 		name: options.name as string | undefined,
 		icon: options.icon as string | undefined,
 		hasDatabase: config.db !== undefined,
+		remoteSqlite:
+			config.db !== undefined &&
+			sqliteBackendForConfig(registryConfig) === "remote",
 		hasState:
 			config.state !== undefined ||
 			typeof config.createState === "function",
@@ -3128,10 +3419,10 @@ function buildActorConfig(
 }
 
 export function buildNativeFactory(
-	bindings: NativeBindings,
+	runtime: CoreRuntime,
 	registryConfig: RegistryConfig,
 	definition: AnyActorDefinition,
-): NativeActorFactory {
+): ActorFactoryHandle {
 	const config = definition.config as Record<string, any>;
 	const databaseProvider = config.db as AnyDatabaseProvider;
 	const schemaConfig: NativeValidationConfig = {
@@ -3155,18 +3446,18 @@ export function buildNativeFactory(
 			{ encoding: "bare" },
 		);
 	const nativeRunHandlerActiveByActorId = new Map<string, boolean>();
-	const isNativeRunHandlerActive = (ctx: NativeActorContext) =>
+	const isNativeRunHandlerActive = (ctx: ActorContextHandle) =>
 		nativeRunHandlerActiveByActorId.get(
-			callNativeSync(() => ctx.actorId()),
+			callNativeSync(() => runtime.actorId(ctx)),
 		) ?? false;
-	const getNativeWorkflowInspector = (ctx: NativeActorContext) =>
+	const getNativeWorkflowInspector = (ctx: ActorContextHandle) =>
 		getRunInspectorConfig(
 			config.run,
-			callNativeSync(() => ctx.actorId()),
+			callNativeSync(() => runtime.actorId(ctx)),
 		)?.workflow as NativeWorkflowInspectorConfig | undefined;
 	const onStateChange =
 		typeof config.onStateChange === "function"
-			? (actorCtx: NativeActorContextAdapter, nextState: unknown) => {
+			? (actorCtx: ActorContextHandleAdapter, nextState: unknown) => {
 					config.onStateChange(actorCtx, nextState);
 				}
 			: undefined;
@@ -3174,6 +3465,8 @@ export function buildNativeFactory(
 	const hasStaticVars = "vars" in config;
 	const hasStaticConnState = Object.hasOwn(config, "connState");
 	const hasDynamicConnState = typeof config.createConnState === "function";
+	const onSleep =
+		typeof config.onSleep === "function" ? config.onSleep : undefined;
 	const needsDisconnectCallback =
 		typeof config.onDisconnect === "function" ||
 		hasStaticConnState ||
@@ -3182,12 +3475,12 @@ export function buildNativeFactory(
 	const stateEnabled =
 		config.state !== undefined || typeof config.createState === "function";
 	const makeActorCtx = (
-		ctx: NativeActorContext,
+		ctx: ActorContextHandle,
 		request?: Request,
-		cancelToken?: NativeCancellationToken,
+		cancelToken?: CancellationTokenHandle,
 	) =>
-		new NativeActorContextAdapter(
-			bindings,
+		new ActorContextHandleAdapter(
+			runtime,
 			ctx,
 			createClient,
 			schemaConfig,
@@ -3199,13 +3492,13 @@ export function buildNativeFactory(
 			cancelToken,
 		);
 	const makeConnCtx = (
-		ctx: NativeActorContext,
-		conn: NativeConnHandle,
+		ctx: ActorContextHandle,
+		conn: ConnHandle,
 		request?: Request,
-		cancelToken?: NativeCancellationToken,
+		cancelToken?: CancellationTokenHandle,
 	) =>
 		withConnContext(
-			bindings,
+			runtime,
 			ctx,
 			conn,
 			createClient,
@@ -3217,12 +3510,12 @@ export function buildNativeFactory(
 			cancelToken,
 		);
 	const maybeHandleNativeInspectorRequest = async (
-		ctx: NativeActorContext,
-		rawRequest: {
+		ctx: ActorContextHandle,
+		_rawRequest: {
 			method: string;
 			uri: string;
 			headers?: Record<string, string>;
-			body?: Buffer;
+			body?: RuntimeBytes;
 		},
 		jsRequest: Request,
 	): Promise<Response | undefined> => {
@@ -3257,7 +3550,8 @@ export function buildNativeFactory(
 			);
 		};
 		try {
-			await ctx.verifyInspectorAuth(
+			await runtime.actorVerifyInspectorAuth(
+				ctx,
 				jsRequest.headers
 					.get("authorization")
 					?.replace(/^Bearer\s+/i, "") ?? null,
@@ -3331,8 +3625,8 @@ export function buildNativeFactory(
 					Number.isFinite(parsedLimit) && parsedLimit > 0
 						? Math.floor(parsedLimit)
 						: 100;
-				const queue = ctx.queue();
-				const allMessages = await queue.inspectMessages();
+				const allMessages =
+					await runtime.actorQueueInspectMessages(ctx);
 				const truncated = allMessages.length > limit;
 				const messages = allMessages.slice(0, limit).map((m) => ({
 					id: m.id,
@@ -3341,7 +3635,7 @@ export function buildNativeFactory(
 				}));
 				return jsonResponse({
 					size: allMessages.length,
-					maxSize: queue.maxSize(),
+					maxSize: runtime.actorQueueMaxSize(ctx),
 					truncated,
 					messages,
 				});
@@ -3503,7 +3797,7 @@ export function buildNativeFactory(
 				jsRequest.method === "GET"
 			) {
 				const inspectorSnapshot = callNativeSync(() =>
-					ctx.inspectorSnapshot(),
+					runtime.actorInspectorSnapshot(ctx),
 				);
 				return jsonResponse({
 					state: stateEnabled ? actorCtx.state : undefined,
@@ -3588,10 +3882,10 @@ export function buildNativeFactory(
 						async (
 							error: unknown,
 							payload: {
-								ctx: NativeActorContext;
-								input?: Buffer;
+								ctx: ActorContextHandle;
+								input?: RuntimeBytes;
 							},
-						): Promise<Buffer> => {
+						): Promise<RuntimeBytes> => {
 							const { ctx, input } = unwrapTsfnPayload(
 								error,
 								payload,
@@ -3624,8 +3918,8 @@ export function buildNativeFactory(
 						async (
 							error: unknown,
 							payload: {
-								ctx: NativeActorContext;
-								input?: Buffer;
+								ctx: ActorContextHandle;
+								input?: RuntimeBytes;
 							},
 						): Promise<void> => {
 							const { ctx, input } = unwrapTsfnPayload(
@@ -3649,7 +3943,7 @@ export function buildNativeFactory(
 				? wrapNativeCallback(
 						async (
 							error: unknown,
-							payload: { ctx: NativeActorContext },
+							payload: { ctx: ActorContextHandle },
 						): Promise<void> => {
 							const { ctx } = unwrapTsfnPayload(error, payload);
 							const actorCtx = makeActorCtx(ctx);
@@ -3679,7 +3973,7 @@ export function buildNativeFactory(
 						async (
 							error: unknown,
 							payload: {
-								ctx: NativeActorContext;
+								ctx: ActorContextHandle;
 								isNew: boolean;
 							},
 						) => {
@@ -3710,7 +4004,7 @@ export function buildNativeFactory(
 				? wrapNativeCallback(
 						async (
 							error: unknown,
-							payload: { ctx: NativeActorContext },
+							payload: { ctx: ActorContextHandle },
 						) => {
 							const { ctx } = unwrapTsfnPayload(error, payload);
 							const actorCtx = makeActorCtx(ctx);
@@ -3732,7 +4026,7 @@ export function buildNativeFactory(
 				? wrapNativeCallback(
 						async (
 							error: unknown,
-							payload: { ctx: NativeActorContext },
+							payload: { ctx: ActorContextHandle },
 						) => {
 							const { ctx } = unwrapTsfnPayload(error, payload);
 							const actorCtx = makeActorCtx(ctx);
@@ -3744,31 +4038,30 @@ export function buildNativeFactory(
 						},
 					)
 				: undefined,
-		onSleep:
-			typeof config.onSleep === "function"
-				? wrapNativeCallback(
-						async (
-							error: unknown,
-							payload: { ctx: NativeActorContext },
-						) => {
-							const { ctx } = unwrapTsfnPayload(error, payload);
-							const actorCtx = makeActorCtx(ctx);
-							try {
-								await config.onSleep!(actorCtx);
-								await actorCtx.saveState({ immediate: true });
-							} finally {
-								await actorCtx.dispose();
-							}
-						},
-					)
-				: undefined,
+		onSleep: onSleep
+			? wrapNativeCallback(
+					async (
+						error: unknown,
+						payload: { ctx: ActorContextHandle },
+					) => {
+						const { ctx } = unwrapTsfnPayload(error, payload);
+						const actorCtx = makeActorCtx(ctx);
+						try {
+							await onSleep(actorCtx);
+							await actorCtx.saveState({ immediate: true });
+						} finally {
+							await actorCtx.dispose();
+						}
+					},
+				)
+			: undefined,
 		onDestroy:
 			typeof config.onDestroy === "function" ||
 			databaseProvider !== undefined
 				? wrapNativeCallback(
 						async (
 							error: unknown,
-							payload: { ctx: NativeActorContext },
+							payload: { ctx: ActorContextHandle },
 						) => {
 							const { ctx } = unwrapTsfnPayload(error, payload);
 							const actorCtx = makeActorCtx(ctx);
@@ -3777,7 +4070,7 @@ export function buildNativeFactory(
 									await config.onDestroy(actorCtx);
 								}
 							} finally {
-								resolveNativeDestroy(ctx);
+								resolveNativeDestroy(runtime, ctx);
 								await actorCtx.closeDatabase();
 								await actorCtx.dispose();
 							}
@@ -3790,13 +4083,13 @@ export function buildNativeFactory(
 						async (
 							error: unknown,
 							payload: {
-								ctx: NativeActorContext;
-								params: Buffer;
+								ctx: ActorContextHandle;
+								params: RuntimeBytes;
 								request?: {
 									method: string;
 									uri: string;
 									headers?: Record<string, string>;
-									body?: Buffer;
+									body?: RuntimeBytes;
 								};
 							},
 						) => {
@@ -3828,17 +4121,17 @@ export function buildNativeFactory(
 						async (
 							error: unknown,
 							payload: {
-								ctx: NativeActorContext;
-								conn: NativeConnHandle;
-								params: Buffer;
+								ctx: ActorContextHandle;
+								conn: ConnHandle;
+								params: RuntimeBytes;
 								request?: {
 									method: string;
 									uri: string;
 									headers?: Record<string, string>;
-									body?: Buffer;
+									body?: RuntimeBytes;
 								};
 							},
-						): Promise<Buffer> => {
+						): Promise<RuntimeBytes> => {
 							const { ctx, conn, params, request } =
 								unwrapTsfnPayload(error, payload);
 							const actorCtx = makeActorCtx(
@@ -3846,12 +4139,16 @@ export function buildNativeFactory(
 								request ? buildRequest(request) : undefined,
 							);
 							const connAdapter = new NativeConnAdapter(
+								runtime,
 								conn,
 								schemaConfig,
 								ctx,
 								(connId) =>
 									callNativeSync(() =>
-										ctx.queueHibernationRemoval(connId),
+										runtime.actorQueueHibernationRemoval(
+											ctx,
+											connId,
+										),
 									),
 							);
 							try {
@@ -3878,13 +4175,13 @@ export function buildNativeFactory(
 						async (
 							error: unknown,
 							payload: {
-								ctx: NativeActorContext;
-								conn: NativeConnHandle;
+								ctx: ActorContextHandle;
+								conn: ConnHandle;
 								request?: {
 									method: string;
 									uri: string;
 									headers?: Record<string, string>;
-									body?: Buffer;
+									body?: RuntimeBytes;
 								};
 							},
 						) => {
@@ -3897,12 +4194,16 @@ export function buildNativeFactory(
 								request ? buildRequest(request) : undefined,
 							);
 							const connAdapter = new NativeConnAdapter(
+								runtime,
 								conn,
 								schemaConfig,
 								ctx,
 								(connId) =>
 									callNativeSync(() =>
-										ctx.queueHibernationRemoval(connId),
+										runtime.actorQueueHibernationRemoval(
+											ctx,
+											connId,
+										),
 									),
 							);
 							try {
@@ -3923,8 +4224,8 @@ export function buildNativeFactory(
 					async (
 						error: unknown,
 						payload: {
-							ctx: NativeActorContext;
-							conn: NativeConnHandle;
+							ctx: ActorContextHandle;
+							conn: ConnHandle;
 						},
 					) => {
 						const { ctx, conn } = unwrapTsfnPayload(error, payload);
@@ -3936,12 +4237,14 @@ export function buildNativeFactory(
 								await config.onDisconnect(
 									actorCtx,
 									new NativeConnAdapter(
+										runtime,
 										conn,
 										schemaConfig,
 										ctx,
 										(connId) =>
 											callNativeSync(() =>
-												ctx.queueHibernationRemoval(
+												runtime.actorQueueHibernationRemoval(
+													ctx,
 													connId,
 												),
 											),
@@ -3965,8 +4268,8 @@ export function buildNativeFactory(
 						async (
 							error: unknown,
 							payload: {
-								ctx: NativeActorContext;
-								conn: NativeConnHandle;
+								ctx: ActorContextHandle;
+								conn: ConnHandle;
 								eventName: string;
 							},
 						) => {
@@ -4004,10 +4307,10 @@ export function buildNativeFactory(
 						async (
 							error: unknown,
 							payload: {
-								ctx: NativeActorContext;
+								ctx: ActorContextHandle;
 								name: string;
-								args: Buffer;
-								output: Buffer;
+								args: RuntimeBytes;
+								output: RuntimeBytes;
 							},
 						) => {
 							const { ctx, name, args, output } =
@@ -4032,14 +4335,14 @@ export function buildNativeFactory(
 			async (
 				error: unknown,
 				payload: {
-					ctx: NativeActorContext;
+					ctx: ActorContextHandle;
 					request: {
 						method: string;
 						uri: string;
 						headers?: Record<string, string>;
-						body?: Buffer;
+						body?: RuntimeBytes;
 					};
-					cancelToken?: NativeCancellationToken;
+					cancelToken?: CancellationTokenHandle;
 				},
 			) => {
 				try {
@@ -4055,11 +4358,11 @@ export function buildNativeFactory(
 							jsRequest,
 						);
 					if (inspectorResponse) {
-						return await toJsHttpResponse(inspectorResponse);
+						return await toRuntimeHttpResponse(inspectorResponse);
 					}
 
 					if (typeof config.onRequest !== "function") {
-						return await toJsHttpResponse(
+						return await toRuntimeHttpResponse(
 							new Response(null, { status: 404 }),
 						);
 					}
@@ -4069,7 +4372,7 @@ export function buildNativeFactory(
 					let requestCtx:
 						| ReturnType<typeof withConnContext>
 						| undefined;
-					let conn: NativeConnHandle | undefined;
+					let conn: ConnHandle | undefined;
 					try {
 						const connParams = validateConnParams(
 							schemaConfig.connParamsSchema,
@@ -4078,7 +4381,11 @@ export function buildNativeFactory(
 								: undefined,
 						);
 						conn = await callNative(() =>
-							ctx.connectConn(encodeValue(connParams), request),
+							runtime.actorConnectConn(
+								ctx,
+								encodeValue(connParams),
+								request,
+							),
 						);
 						requestCtx = makeConnCtx(
 							ctx,
@@ -4095,7 +4402,7 @@ export function buildNativeFactory(
 								"onRequest handler must return a Response",
 							);
 						}
-						return await toJsHttpResponse(response);
+						return await toRuntimeHttpResponse(response);
 					} catch (error) {
 						const encodingHeader =
 							jsRequest.headers.get(HEADER_ENCODING);
@@ -4105,7 +4412,7 @@ export function buildNativeFactory(
 								? encodingHeader
 								: "json";
 						const path = new URL(jsRequest.url).pathname;
-						return await toJsHttpResponse(
+						return await toRuntimeHttpResponse(
 							buildNativeRequestErrorResponse(
 								encoding,
 								path,
@@ -4115,7 +4422,7 @@ export function buildNativeFactory(
 					} finally {
 						await requestCtx?.dispose();
 						if (conn) {
-							await conn.disconnect();
+							await runtime.connDisconnect(conn);
 						}
 					}
 				} catch (error) {
@@ -4133,36 +4440,29 @@ export function buildNativeFactory(
 						async (
 							error: unknown,
 							payload: {
-								ctx: NativeActorContext;
-								conn: NativeConnHandle;
-								ws: NativeWebSocket;
+								ctx: ActorContextHandle;
+								conn: ConnHandle;
+								ws: WebSocketHandle;
 								request?: {
 									method: string;
 									uri: string;
 									headers?: Record<string, string>;
-									body?: Buffer;
+									body?: RuntimeBytes;
 								};
 							},
 						) => {
 							const { ctx, conn, ws, request } =
-								unwrapTsfnPayload(
-									error,
-									payload,
-								);
+								unwrapTsfnPayload(error, payload);
 							const jsRequest = request
 								? buildRequest(request)
 								: undefined;
-							const actorCtx = makeConnCtx(
-								ctx,
-								conn,
-								jsRequest,
-							);
+							const actorCtx = makeConnCtx(ctx, conn, jsRequest);
 							try {
 								await config.onWebSocket(
 									actorCtx,
-									new TrackedNativeWebSocketAdapter(
+									new TrackedWebSocketHandleAdapter(
 										actorCtx,
-										new NativeWebSocketAdapter(ws),
+										new NativeWebSocketAdapter(runtime, ws),
 									),
 								);
 							} finally {
@@ -4180,10 +4480,10 @@ export function buildNativeFactory(
 			return wrapNativeCallback(
 				async (
 					error: unknown,
-					payload: { ctx: NativeActorContext },
+					payload: { ctx: ActorContextHandle },
 				) => {
 					const { ctx } = unwrapTsfnPayload(error, payload);
-					const actorId = callNativeSync(() => ctx.actorId());
+					const actorId = callNativeSync(() => runtime.actorId(ctx));
 					const actorCtx = makeActorCtx(ctx);
 					nativeRunHandlerActiveByActorId.set(actorId, true);
 					try {
@@ -4200,7 +4500,7 @@ export function buildNativeFactory(
 				? wrapNativeCallback(
 						async (
 							error: unknown,
-							payload: { ctx: NativeActorContext },
+							payload: { ctx: ActorContextHandle },
 						) => {
 							const { ctx } = unwrapTsfnPayload(error, payload);
 							const history =
@@ -4217,7 +4517,7 @@ export function buildNativeFactory(
 						async (
 							error: unknown,
 							payload: {
-								ctx: NativeActorContext;
+								ctx: ActorContextHandle;
 								entryId?: string;
 							},
 						) => {
@@ -4248,11 +4548,11 @@ export function buildNativeFactory(
 					async (
 						error: unknown,
 						payload: {
-							ctx: NativeActorContext;
-							conn: NativeConnHandle | null;
+							ctx: ActorContextHandle;
+							conn: ConnHandle | null;
 							name: string;
-							args: Buffer;
-							cancelToken?: NativeCancellationToken;
+							args: RuntimeBytes;
+							cancelToken?: CancellationTokenHandle;
 						},
 					) => {
 						const { ctx, conn, args, cancelToken } =
@@ -4283,19 +4583,19 @@ export function buildNativeFactory(
 			async (
 				error: unknown,
 				payload: {
-					ctx: NativeActorContext;
-					conn: NativeConnHandle;
+					ctx: ActorContextHandle;
+					conn: ConnHandle;
 					request: {
 						method: string;
 						uri: string;
 						headers?: Record<string, string>;
-						body?: Buffer;
+						body?: RuntimeBytes;
 					};
 					name: string;
-					body: Buffer;
+					body: RuntimeBytes;
 					wait: boolean;
 					timeoutMs?: bigint | number;
-					cancelToken?: NativeCancellationToken;
+					cancelToken?: CancellationTokenHandle;
 				},
 			) => {
 				const {
@@ -4310,7 +4610,7 @@ export function buildNativeFactory(
 				} = unwrapTsfnPayload(error, payload);
 				const jsRequest = buildRequest(request);
 				const actorCtx = withConnContext(
-					bindings,
+					runtime,
 					ctx,
 					conn,
 					createClient,
@@ -4383,7 +4683,7 @@ export function buildNativeFactory(
 			async (
 				error: unknown,
 				payload: {
-					ctx: NativeActorContext;
+					ctx: ActorContextHandle;
 					reason: SerializeStateReason;
 				},
 			) => {
@@ -4398,20 +4698,20 @@ export function buildNativeFactory(
 		),
 	};
 
-	return new bindings.NapiActorFactory(
+	return runtime.createActorFactory(
 		callbacks,
 		buildActorConfig(definition, registryConfig),
 	);
 }
 
-async function buildServeConfig(
+export async function buildServeConfig(
 	config: RegistryConfig,
-): Promise<JsServeConfig> {
+): Promise<RuntimeServeConfig> {
 	if (!config.endpoint) {
 		throw nativeEndpointNotConfiguredError();
 	}
 
-	const serveConfig: JsServeConfig = {
+	const serveConfig: RuntimeServeConfig = {
 		version: config.envoy.version,
 		endpoint: config.endpoint,
 		token: config.token,
@@ -4431,35 +4731,66 @@ async function buildServeConfig(
 		const { getEnginePath } = await loadEngineCli();
 		serveConfig.engineBinaryPath = getEnginePath();
 	}
+	if (config.test?.enabled) {
+		serveConfig.inspectorTestToken =
+			getEnvUniversal("_RIVET_TEST_INSPECTOR_TOKEN") ?? "token";
+	}
 
 	return serveConfig;
 }
 
-export async function buildNativeRegistry(config: RegistryConfig): Promise<{
-	bindings: NativeBindings;
-	registry: NativeCoreRegistry;
-	serveConfig: JsServeConfig;
+export async function buildRegistryWithRuntime(
+	config: RegistryConfig,
+	runtime: CoreRuntime,
+): Promise<{
+	runtime: CoreRuntime;
+	registry: RegistryHandle;
+	serveConfig: RuntimeServeConfig;
 }> {
 	if (
 		config.test?.enabled &&
-		process.env._RIVET_TEST_INSPECTOR_TOKEN === undefined
+		getEnvUniversal("_RIVET_TEST_INSPECTOR_TOKEN") === undefined
 	) {
-		process.env._RIVET_TEST_INSPECTOR_TOKEN = "token";
+		trySetProcessEnv("_RIVET_TEST_INSPECTOR_TOKEN", "token");
 	}
 
-	const bindings = await loadNativeBindings();
-	const registry = new bindings.CoreRegistry();
+	const registry = runtime.createRegistry();
 
 	for (const [name, definition] of Object.entries(config.use)) {
-		registry.register(
+		runtime.registerActor(
+			registry,
 			name,
-			buildNativeFactory(bindings, config, definition),
+			buildNativeFactory(runtime, config, definition),
 		);
 	}
 
 	return {
-		bindings,
+		runtime,
 		registry,
 		serveConfig: await buildServeConfig(config),
 	};
 }
+
+export async function buildNativeRegistry(config: RegistryConfig): Promise<{
+	runtime: CoreRuntime;
+	registry: RegistryHandle;
+	serveConfig: RuntimeServeConfig;
+}> {
+	const { runtime } = await loadNapiRuntime();
+	return buildRegistryWithRuntime(
+		normalizeRuntimeConfigForKind(config, "native"),
+		runtime,
+	);
+}
+
+export async function buildConfiguredRegistry(config: RegistryConfig): Promise<{
+	runtime: CoreRuntime;
+	registry: RegistryHandle;
+	serveConfig: RuntimeServeConfig;
+}> {
+	const runtime = await loadConfiguredRuntime(config);
+	return buildRegistryWithRuntime(
+		normalizeRuntimeConfig(config, runtime),
+		runtime,
+	);
+}
diff --git a/rivetkit-typescript/packages/rivetkit/src/registry/runtime.test.ts b/rivetkit-typescript/packages/rivetkit/src/registry/runtime.test.ts
new file mode 100644
index 0000000000..22ab9abe92
--- /dev/null
+++ b/rivetkit-typescript/packages/rivetkit/src/registry/runtime.test.ts
@@ -0,0 +1,79 @@
+import { describe, expect, test } from "vitest";
+import {
+	normalizeRuntimeSqlExecuteResult,
+	type RuntimeSqlBindParam,
+	type RuntimeSqlBindParams,
+	type RuntimeSqlExecuteResult,
+} from "./runtime";
+
+describe("runtime SQL boundary", () => {
+	test("accepts exact bind param variants", () => {
+		const blob = new Uint8Array([1, 2, 3]);
+		const params = [
+			{ kind: "null" },
+			{ kind: "int", intValue: 1 },
+			{ kind: "float", floatValue: 1.5 },
+			{ kind: "text", textValue: "text" },
+			{ kind: "blob", blobValue: blob },
+		] satisfies RuntimeSqlBindParams;
+
+		expect(params).toEqual([
+			{ kind: "null" },
+			{ kind: "int", intValue: 1 },
+			{ kind: "float", floatValue: 1.5 },
+			{ kind: "text", textValue: "text" },
+			{ kind: "blob", blobValue: blob },
+		]);
+	});
+
+	test("rejects bind params with mismatched value fields at typecheck time", () => {
+		const invalidIntParamCandidate = {
+			kind: "int",
+			intValue: 1,
+			textValue: "extra",
+		} as const;
+		// @ts-expect-error Runtime SQL int params must only carry intValue.
+		const invalidIntParam: RuntimeSqlBindParam = invalidIntParamCandidate;
+
+		expect(invalidIntParam.kind).toBe("int");
+	});
+
+	test("normalizes exact execute result routes", () => {
+		const base = {
+			columns: ["value"],
+			rows: [[1]],
+			changes: 1,
+			lastInsertRowId: null,
+		};
+
+		expect(
+			normalizeRuntimeSqlExecuteResult({ ...base, route: "read" }).route,
+		).toBe("read");
+		expect(
+			normalizeRuntimeSqlExecuteResult({ ...base, route: "write" }).route,
+		).toBe("write");
+		expect(
+			normalizeRuntimeSqlExecuteResult({
+				...base,
+				route: "writeFallback",
+			}).route,
+		).toBe("writeFallback");
+		expect(() =>
+			normalizeRuntimeSqlExecuteResult({ ...base, route: "custom" }),
+		).toThrow("unsupported runtime sqlite execute route: custom");
+	});
+
+	test("rejects custom execute result routes at typecheck time", () => {
+		const invalidRouteResultCandidate = {
+			columns: [],
+			rows: [],
+			changes: 0,
+			route: "custom",
+		} as const;
+		// @ts-expect-error Runtime SQL execute routes are exact.
+		const invalidRouteResult: RuntimeSqlExecuteResult =
+			invalidRouteResultCandidate;
+
+		expect(invalidRouteResult.route).toBe("custom");
+	});
+});
diff --git a/rivetkit-typescript/packages/rivetkit/src/registry/runtime.ts b/rivetkit-typescript/packages/rivetkit/src/registry/runtime.ts
new file mode 100644
index 0000000000..fa5968b51a
--- /dev/null
+++ b/rivetkit-typescript/packages/rivetkit/src/registry/runtime.ts
@@ -0,0 +1,592 @@
+import type { RegistryConfig } from "./config";
+
+declare const handleBrand: unique symbol;
+
+type OpaqueHandle<Name extends string> = {
+	readonly [handleBrand]: Name;
+};
+
+export type RegistryHandle = OpaqueHandle<"registry">;
+export type ActorFactoryHandle = OpaqueHandle<"actorFactory">;
+export type ActorContextHandle = OpaqueHandle<"actorContext">;
+export type ConnHandle = OpaqueHandle<"conn">;
+export type WebSocketHandle = OpaqueHandle<"webSocket">;
+export type CancellationTokenHandle = OpaqueHandle<"cancellationToken">;
+
+export type RuntimeBytes = Uint8Array;
+
+export interface RuntimeActorKeySegment {
+	kind: string;
+	stringValue?: string;
+	numberValue?: number;
+}
+
+export interface RuntimeHttpRequest {
+	method: string;
+	uri: string;
+	headers?: Record<string, string>;
+	body?: RuntimeBytes;
+}
+
+export interface RuntimeHttpResponse {
+	status?: number;
+	headers?: Record<string, string>;
+	body?: RuntimeBytes;
+}
+
+export interface RuntimeStateDeltaPayload {
+	state?: RuntimeBytes;
+	connHibernation: Array<{
+		connId: string;
+		bytes: RuntimeBytes;
+	}>;
+	connHibernationRemoved: string[];
+}
+
+export interface RuntimeRequestSaveOpts {
+	immediate?: boolean;
+	maxWaitMs?: number;
+}
+
+export interface RuntimeInspectorSnapshot {
+	stateRevision: number;
+	connectionsRevision: number;
+	queueRevision: number;
+	activeConnections: number;
+	queueSize: number;
+	connectedClients: number;
+}
+
+export interface RuntimeQueueMessage {
+	id(): bigint;
+	name(): string;
+	body(): RuntimeBytes;
+	createdAt(): number;
+	isCompletable(): boolean;
+	complete(response?: RuntimeBytes | undefined | null): Promise<void>;
+}
+
+export interface RuntimeQueueInspectMessage {
+	id: number;
+	name: string;
+	createdAtMs: number;
+}
+
+export interface RuntimeQueueSendResult {
+	status: string;
+	response?: RuntimeBytes;
+}
+
+export interface RuntimeQueueNextBatchOptions {
+	names?: string[];
+	count?: number;
+	timeoutMs?: number;
+	completable?: boolean;
+}
+
+export interface RuntimeQueueWaitOptions {
+	timeoutMs?: number;
+	completable?: boolean;
+}
+
+export interface RuntimeQueueEnqueueAndWaitOptions {
+	timeoutMs?: number;
+}
+
+export interface RuntimeQueueTryNextBatchOptions {
+	names?: string[];
+	count?: number;
+	completable?: boolean;
+}
+
+export interface RuntimeKvListOptions {
+	reverse?: boolean;
+	limit?: number;
+}
+
+export interface RuntimeKvEntry {
+	key: RuntimeBytes;
+	value: RuntimeBytes;
+}
+
+type RuntimeSqlBindNoValues = {
+	intValue?: never;
+	floatValue?: never;
+	textValue?: never;
+	blobValue?: never;
+};
+
+export type RuntimeSqlBindParam =
+	| ({ kind: "null" } & RuntimeSqlBindNoValues)
+	| {
+			kind: "int";
+			intValue: number;
+			floatValue?: never;
+			textValue?: never;
+			blobValue?: never;
+	  }
+	| {
+			kind: "float";
+			intValue?: never;
+			floatValue: number;
+			textValue?: never;
+			blobValue?: never;
+	  }
+	| {
+			kind: "text";
+			intValue?: never;
+			floatValue?: never;
+			textValue: string;
+			blobValue?: never;
+	  }
+	| {
+			kind: "blob";
+			intValue?: never;
+			floatValue?: never;
+			textValue?: never;
+			blobValue: RuntimeBytes;
+	  };
+
+export type RuntimeSqlBindParams = RuntimeSqlBindParam[] | null;
+
+export interface RuntimeSqlQueryResult {
+	columns: string[];
+	rows: unknown[][];
+}
+
+export type RuntimeSqlExecResult = RuntimeSqlQueryResult;
+
+export type RuntimeSqlExecuteRoute = "read" | "write" | "writeFallback";
+
+export interface RuntimeSqlExecuteResult extends RuntimeSqlQueryResult {
+	changes: number;
+	lastInsertRowId?: number | null;
+	route: RuntimeSqlExecuteRoute;
+}
+
+export function normalizeRuntimeSqlExecuteRoute(
+	route: string,
+): RuntimeSqlExecuteRoute {
+	if (route === "read" || route === "write" || route === "writeFallback") {
+		return route;
+	}
+	throw new Error(`unsupported runtime sqlite execute route: ${route}`);
+}
+
+export function normalizeRuntimeSqlExecuteResult(
+	result: RuntimeSqlQueryResult & {
+		changes: number;
+		lastInsertRowId?: number | null;
+		route: string;
+	},
+): RuntimeSqlExecuteResult {
+	return {
+		...result,
+		route: normalizeRuntimeSqlExecuteRoute(result.route),
+	};
+}
+
+export interface RuntimeSqlRunResult {
+	changes: number;
+}
+
+export interface RuntimeSqlDatabase {
+	exec(sql: string): Promise<RuntimeSqlExecResult>;
+	execute(
+		sql: string,
+		params?: RuntimeSqlBindParams,
+	): Promise<RuntimeSqlExecuteResult>;
+	executeWrite(
+		sql: string,
+		params?: RuntimeSqlBindParams,
+	): Promise<RuntimeSqlExecuteResult>;
+	query(
+		sql: string,
+		params?: RuntimeSqlBindParams,
+	): Promise<RuntimeSqlQueryResult>;
+	run(
+		sql: string,
+		params?: RuntimeSqlBindParams,
+	): Promise<RuntimeSqlRunResult>;
+	takeLastKvError?(): string | null;
+	close(): Promise<void>;
+}
+
+export interface RuntimeActorConfig {
+	name?: string;
+	icon?: string;
+	hasDatabase?: boolean;
+	remoteSqlite?: boolean;
+	hasState?: boolean;
+	canHibernateWebsocket?: boolean;
+	stateSaveIntervalMs?: number;
+	createStateTimeoutMs?: number;
+	onCreateTimeoutMs?: number;
+	createVarsTimeoutMs?: number;
+	createConnStateTimeoutMs?: number;
+	onBeforeConnectTimeoutMs?: number;
+	onConnectTimeoutMs?: number;
+	onMigrateTimeoutMs?: number;
+	onWakeTimeoutMs?: number;
+	onBeforeActorStartTimeoutMs?: number;
+	actionTimeoutMs?: number;
+	onRequestTimeoutMs?: number;
+	sleepTimeoutMs?: number;
+	noSleep?: boolean;
+	sleepGracePeriodMs?: number;
+	connectionLivenessTimeoutMs?: number;
+	connectionLivenessIntervalMs?: number;
+	maxQueueSize?: number;
+	maxQueueMessageSize?: number;
+	maxIncomingMessageSize?: number;
+	maxOutgoingMessageSize?: number;
+	preloadMaxWorkflowBytes?: number;
+	preloadMaxConnectionsBytes?: number;
+	actions?: Array<{ name: string }>;
+}
+
+export interface RuntimeServeConfig {
+	version: number;
+	endpoint: string;
+	token?: string;
+	namespace: string;
+	poolName: string;
+	engineBinaryPath?: string;
+	handleInspectorHttpInRuntime?: boolean;
+	inspectorTestToken?: string;
+	serverlessBasePath?: string;
+	serverlessPackageVersion: string;
+	serverlessClientEndpoint?: string;
+	serverlessClientNamespace?: string;
+	serverlessClientToken?: string;
+	serverlessValidateEndpoint: boolean;
+	serverlessMaxStartPayloadBytes: number;
+}
+
+export interface RuntimeServerlessRequest {
+	method: string;
+	url: string;
+	headers: Record<string, string>;
+	body: RuntimeBytes;
+}
+
+export interface RuntimeServerlessResponseHead {
+	status: number;
+	headers: Record<string, string>;
+}
+
+export type RuntimeServerlessStreamEvent =
+	| {
+			kind: "chunk";
+			chunk?: RuntimeBytes;
+	  }
+	| {
+			kind: "end";
+			error?: {
+				group: string;
+				code: string;
+				message: string;
+			};
+	  };
+
+export type RuntimeServerlessStreamCallback = (
+	error: unknown,
+	event?: RuntimeServerlessStreamEvent,
+) => unknown;
+
+export type RuntimeWebSocketEvent =
+	| {
+			kind: "message";
+			data: string | RuntimeBytes;
+			binary: boolean;
+			messageIndex?: number;
+	  }
+	| {
+			kind: "close";
+			code: number;
+			reason: string;
+			wasClean: boolean;
+	  };
+
+export interface CoreRuntime {
+	readonly kind: "napi" | "wasm";
+
+	createRegistry(): RegistryHandle;
+	registerActor(
+		registry: RegistryHandle,
+		name: string,
+		factory: ActorFactoryHandle,
+	): void;
+	serveRegistry(
+		registry: RegistryHandle,
+		config: RuntimeServeConfig,
+	): Promise<void>;
+	shutdownRegistry(registry: RegistryHandle): Promise<void>;
+	handleServerlessRequest(
+		registry: RegistryHandle,
+		req: RuntimeServerlessRequest,
+		onStreamEvent: RuntimeServerlessStreamCallback,
+		cancelToken: CancellationTokenHandle,
+		config: RuntimeServeConfig,
+	): Promise<RuntimeServerlessResponseHead>;
+	createActorFactory(
+		callbacks: object,
+		config?: RuntimeActorConfig | undefined | null,
+	): ActorFactoryHandle;
+
+	createCancellationToken(): CancellationTokenHandle;
+	cancellationTokenAborted(token: CancellationTokenHandle): boolean;
+	cancelCancellationToken(token: CancellationTokenHandle): void;
+	onCancellationTokenCancelled(
+		token: CancellationTokenHandle,
+		callback: (...args: unknown[]) => unknown,
+	): void;
+
+	actorState(ctx: ActorContextHandle): RuntimeBytes;
+	actorBeginOnStateChange(ctx: ActorContextHandle): void;
+	actorEndOnStateChange(ctx: ActorContextHandle): void;
+	actorSetAlarm(
+		ctx: ActorContextHandle,
+		timestampMs?: number | undefined | null,
+	): void;
+	actorRequestSave(
+		ctx: ActorContextHandle,
+		opts?: RuntimeRequestSaveOpts | undefined | null,
+	): void;
+	actorRequestSaveAndWait(
+		ctx: ActorContextHandle,
+		opts?: RuntimeRequestSaveOpts | undefined | null,
+	): Promise<void>;
+	actorInspectorSnapshot(ctx: ActorContextHandle): RuntimeInspectorSnapshot;
+	actorDecodeInspectorRequest(
+		ctx: ActorContextHandle,
+		bytes: RuntimeBytes,
+		advertisedVersion: number,
+	): RuntimeBytes;
+	actorEncodeInspectorResponse(
+		ctx: ActorContextHandle,
+		bytes: RuntimeBytes,
+		targetVersion: number,
+	): RuntimeBytes;
+	actorVerifyInspectorAuth(
+		ctx: ActorContextHandle,
+		bearerToken?: string | undefined | null,
+	): Promise<void>;
+	actorQueueHibernationRemoval(ctx: ActorContextHandle, connId: string): void;
+	actorTakePendingHibernationChanges(ctx: ActorContextHandle): string[];
+	actorDirtyHibernatableConns(ctx: ActorContextHandle): ConnHandle[];
+	actorSaveState(
+		ctx: ActorContextHandle,
+		payload: RuntimeStateDeltaPayload,
+	): Promise<void>;
+	actorId(ctx: ActorContextHandle): string;
+	actorName(ctx: ActorContextHandle): string;
+	actorKey(ctx: ActorContextHandle): RuntimeActorKeySegment[];
+	actorRegion(ctx: ActorContextHandle): string;
+	actorSleep(ctx: ActorContextHandle): void;
+	actorDestroy(ctx: ActorContextHandle): void;
+	actorAbortSignal(ctx: ActorContextHandle): AbortSignal;
+	actorConns(ctx: ActorContextHandle): ConnHandle[];
+	actorConnectConn(
+		ctx: ActorContextHandle,
+		params: RuntimeBytes,
+		request?: RuntimeHttpRequest | undefined | null,
+	): Promise<ConnHandle>;
+	actorBroadcast(
+		ctx: ActorContextHandle,
+		name: string,
+		args: RuntimeBytes,
+	): void;
+	actorWaitUntil(ctx: ActorContextHandle, promise: Promise<unknown>): void;
+	actorKeepAwake(
+		ctx: ActorContextHandle,
+		promise: Promise<unknown>,
+	): Promise<unknown>;
+	actorRegisterTask(ctx: ActorContextHandle, promise: Promise<unknown>): void;
+	actorRuntimeState(ctx: ActorContextHandle): object;
+	actorRestartRunHandler(ctx: ActorContextHandle): void;
+	actorBeginWebsocketCallback(ctx: ActorContextHandle): number;
+	actorEndWebsocketCallback(ctx: ActorContextHandle, regionId: number): void;
+
+	actorKvGet(
+		ctx: ActorContextHandle,
+		key: RuntimeBytes,
+	): Promise<RuntimeBytes | null>;
+	actorKvPut(
+		ctx: ActorContextHandle,
+		key: RuntimeBytes,
+		value: RuntimeBytes,
+	): Promise<void>;
+	actorKvDelete(ctx: ActorContextHandle, key: RuntimeBytes): Promise<void>;
+	actorKvDeleteRange(
+		ctx: ActorContextHandle,
+		start: RuntimeBytes,
+		end: RuntimeBytes,
+	): Promise<void>;
+	actorKvListPrefix(
+		ctx: ActorContextHandle,
+		prefix: RuntimeBytes,
+		options?: RuntimeKvListOptions | undefined | null,
+	): Promise<RuntimeKvEntry[]>;
+	actorKvListRange(
+		ctx: ActorContextHandle,
+		start: RuntimeBytes,
+		end: RuntimeBytes,
+		options?: RuntimeKvListOptions | undefined | null,
+	): Promise<RuntimeKvEntry[]>;
+	actorKvBatchGet(
+		ctx: ActorContextHandle,
+		keys: RuntimeBytes[],
+	): Promise<Array<RuntimeBytes | undefined | null>>;
+	actorKvBatchPut(
+		ctx: ActorContextHandle,
+		entries: RuntimeKvEntry[],
+	): Promise<void>;
+	actorKvBatchDelete(
+		ctx: ActorContextHandle,
+		keys: RuntimeBytes[],
+	): Promise<void>;
+
+	actorSqlExec(
+		ctx: ActorContextHandle,
+		sql: string,
+	): Promise<RuntimeSqlExecResult>;
+	actorSqlExecute(
+		ctx: ActorContextHandle,
+		sql: string,
+		params?: RuntimeSqlBindParams,
+	): Promise<RuntimeSqlExecuteResult>;
+	actorSqlExecuteWrite(
+		ctx: ActorContextHandle,
+		sql: string,
+		params?: RuntimeSqlBindParams,
+	): Promise<RuntimeSqlExecuteResult>;
+	actorSqlQuery(
+		ctx: ActorContextHandle,
+		sql: string,
+		params?: RuntimeSqlBindParams,
+	): Promise<RuntimeSqlQueryResult>;
+	actorSqlRun(
+		ctx: ActorContextHandle,
+		sql: string,
+		params?: RuntimeSqlBindParams,
+	): Promise<RuntimeSqlRunResult>;
+	actorSqlTakeLastKvError(ctx: ActorContextHandle): string | null;
+	actorSqlClose(ctx: ActorContextHandle): Promise<void>;
+
+	actorQueueSend(
+		ctx: ActorContextHandle,
+		name: string,
+		body: RuntimeBytes,
+	): Promise<RuntimeQueueMessage>;
+	actorQueueNextBatch(
+		ctx: ActorContextHandle,
+		options?: RuntimeQueueNextBatchOptions | undefined | null,
+		signal?: CancellationTokenHandle | undefined | null,
+	): Promise<RuntimeQueueMessage[]>;
+	actorQueueWaitForNames(
+		ctx: ActorContextHandle,
+		names: string[],
+		options?: RuntimeQueueWaitOptions | undefined | null,
+		signal?: CancellationTokenHandle | undefined | null,
+	): Promise<RuntimeQueueMessage>;
+	actorQueueWaitForNamesAvailable(
+		ctx: ActorContextHandle,
+		names: string[],
+		options?: RuntimeQueueWaitOptions | undefined | null,
+	): Promise<void>;
+	actorQueueEnqueueAndWait(
+		ctx: ActorContextHandle,
+		name: string,
+		body: RuntimeBytes,
+		options?: RuntimeQueueEnqueueAndWaitOptions | undefined | null,
+		signal?: CancellationTokenHandle | undefined | null,
+	): Promise<RuntimeBytes | null>;
+	actorQueueTryNextBatch(
+		ctx: ActorContextHandle,
+		options?: RuntimeQueueTryNextBatchOptions | undefined | null,
+	): RuntimeQueueMessage[];
+	actorQueueMaxSize(ctx: ActorContextHandle): number;
+	actorQueueInspectMessages(
+		ctx: ActorContextHandle,
+	): Promise<RuntimeQueueInspectMessage[]>;
+
+	actorScheduleAfter(
+		ctx: ActorContextHandle,
+		durationMs: number,
+		actionName: string,
+		args: RuntimeBytes,
+	): void;
+	actorScheduleAt(
+		ctx: ActorContextHandle,
+		timestampMs: number,
+		actionName: string,
+		args: RuntimeBytes,
+	): void;
+
+	connId(conn: ConnHandle): string;
+	connParams(conn: ConnHandle): RuntimeBytes;
+	connState(conn: ConnHandle): RuntimeBytes;
+	connSetState(conn: ConnHandle, state: RuntimeBytes): void;
+	connIsHibernatable(conn: ConnHandle): boolean;
+	connSend(conn: ConnHandle, name: string, args: RuntimeBytes): void;
+	connDisconnect(
+		conn: ConnHandle,
+		reason?: string | undefined | null,
+	): Promise<void>;
+
+	webSocketSend(
+		ws: WebSocketHandle,
+		data: RuntimeBytes,
+		binary: boolean,
+	): void;
+	webSocketClose(
+		ws: WebSocketHandle,
+		code?: number | undefined | null,
+		reason?: string | undefined | null,
+	): Promise<void>;
+	webSocketSetEventCallback(
+		ws: WebSocketHandle,
+		callback: (event: RuntimeWebSocketEvent) => void,
+	): void;
+}
+
+export interface RuntimeBundle {
+	runtime: CoreRuntime;
+}
+
+export async function buildServeConfig(
+	config: RegistryConfig,
+	loadEnginePath: () => Promise<string>,
+	version: string,
+): Promise<RuntimeServeConfig> {
+	if (!config.endpoint) {
+		throw new Error("registry endpoint is required");
+	}
+
+	const serveConfig: RuntimeServeConfig = {
+		version: config.envoy.version,
+		endpoint: config.endpoint,
+		token: config.token,
+		namespace: config.namespace,
+		poolName: config.envoy.poolName,
+		handleInspectorHttpInRuntime: true,
+		serverlessBasePath: config.serverless.basePath,
+		serverlessPackageVersion: version,
+		serverlessClientEndpoint: config.publicEndpoint,
+		serverlessClientNamespace: config.publicNamespace,
+		serverlessClientToken: config.publicToken,
+		serverlessValidateEndpoint: config.validateServerlessEndpoint,
+		serverlessMaxStartPayloadBytes: config.serverless.maxStartPayloadBytes,
+	};
+
+	if (config.startEngine) {
+		serveConfig.engineBinaryPath = await loadEnginePath();
+	}
+	if (config.test?.enabled) {
+		serveConfig.inspectorTestToken =
+			process.env._RIVET_TEST_INSPECTOR_TOKEN ?? "token";
+	}
+
+	return serveConfig;
+}
diff --git a/rivetkit-typescript/packages/rivetkit/src/registry/wasm-runtime.ts b/rivetkit-typescript/packages/rivetkit/src/registry/wasm-runtime.ts
new file mode 100644
index 0000000000..bb57f100e2
--- /dev/null
+++ b/rivetkit-typescript/packages/rivetkit/src/registry/wasm-runtime.ts
@@ -0,0 +1,987 @@
+import type {
+	ActorContext as WasmActorContext,
+	ActorFactory as WasmActorFactory,
+	CancellationToken as WasmCancellationToken,
+	ConnHandle as WasmConnHandle,
+	CoreRegistry as WasmCoreRegistry,
+	WebSocketHandle as WasmWebSocketHandle,
+} from "@rivetkit/rivetkit-wasm";
+import {
+	decodeBridgeRivetError,
+	isRivetErrorLike,
+	RivetError,
+} from "@/actor/errors";
+import type {
+	WasmRuntimeBindings,
+	WasmRuntimeConfig,
+	WasmRuntimeInitInput,
+} from "./config";
+import type {
+	ActorContextHandle,
+	ActorFactoryHandle,
+	CancellationTokenHandle,
+	ConnHandle,
+	CoreRuntime,
+	RegistryHandle,
+	RuntimeActorConfig,
+	RuntimeActorKeySegment,
+	RuntimeBytes,
+	RuntimeHttpRequest,
+	RuntimeInspectorSnapshot,
+	RuntimeKvEntry,
+	RuntimeKvListOptions,
+	RuntimeQueueEnqueueAndWaitOptions,
+	RuntimeQueueInspectMessage,
+	RuntimeQueueMessage,
+	RuntimeQueueNextBatchOptions,
+	RuntimeQueueTryNextBatchOptions,
+	RuntimeQueueWaitOptions,
+	RuntimeRequestSaveOpts,
+	RuntimeServeConfig,
+	RuntimeServerlessRequest,
+	RuntimeServerlessResponseHead,
+	RuntimeServerlessStreamCallback,
+	RuntimeSqlBindParams,
+	RuntimeSqlDatabase,
+	RuntimeSqlExecResult,
+	RuntimeSqlExecuteResult,
+	RuntimeSqlQueryResult,
+	RuntimeSqlRunResult,
+	RuntimeStateDeltaPayload,
+	RuntimeWebSocketEvent,
+	WebSocketHandle,
+} from "./runtime";
+import { normalizeRuntimeSqlExecuteResult } from "./runtime";
+
+type WasmBindings = WasmRuntimeBindings;
+export type WasmInitInput = WasmRuntimeInitInput;
+type AnyFunction = (...args: unknown[]) => unknown;
+type WasmRuntimeLoadConfig = Pick<WasmRuntimeConfig, "bindings" | "initInput">;
+
+function asWasmRegistry(handle: RegistryHandle): WasmCoreRegistry {
+	return handle as unknown as WasmCoreRegistry;
+}
+
+function asWasmFactory(handle: ActorFactoryHandle): WasmActorFactory {
+	return handle as unknown as WasmActorFactory;
+}
+
+function asWasmActorContext(handle: ActorContextHandle): WasmActorContext {
+	return handle as unknown as WasmActorContext;
+}
+
+function asWasmConn(handle: ConnHandle): WasmConnHandle {
+	return handle as unknown as WasmConnHandle;
+}
+
+function asWasmWebSocket(handle: WebSocketHandle): WasmWebSocketHandle {
+	return handle as unknown as WasmWebSocketHandle;
+}
+
+function asWasmCancellationToken(
+	handle: CancellationTokenHandle,
+): WasmCancellationToken {
+	return handle as unknown as WasmCancellationToken;
+}
+
+function asRegistryHandle(handle: WasmCoreRegistry): RegistryHandle {
+	return handle as unknown as RegistryHandle;
+}
+
+function asActorFactoryHandle(handle: WasmActorFactory): ActorFactoryHandle {
+	return handle as unknown as ActorFactoryHandle;
+}
+
+function toBytes(value: RuntimeBytes | null | undefined): RuntimeBytes {
+	return value ?? new Uint8Array(0);
+}
+
+function optionalBytes(
+	value: RuntimeBytes | null | undefined,
+): RuntimeBytes | null {
+	if (value === null || value === undefined) {
+		return null;
+	}
+	return toBytes(value);
+}
+
+function optionalWasmNumber(
+	value: number | bigint | null | undefined,
+): number | null | undefined {
+	if (value === null || value === undefined) {
+		return value;
+	}
+	return typeof value === "bigint" ? Number(value) : value;
+}
+
+function wasmNumber(value: number | bigint): number {
+	return typeof value === "bigint" ? Number(value) : value;
+}
+
+function normalizeKvEntry(entry: RuntimeKvEntry): RuntimeKvEntry {
+	return {
+		key: toBytes(entry.key),
+		value: toBytes(entry.value),
+	};
+}
+
+function normalizeQueueMessage(
+	message: RuntimeQueueMessage,
+): RuntimeQueueMessage {
+	return {
+		id: () => message.id(),
+		name: () => message.name(),
+		body: () => toBytes(message.body()),
+		createdAt: () => message.createdAt(),
+		isCompletable: () => message.isCompletable(),
+		complete: async (response?: RuntimeBytes | undefined | null) => {
+			await callWasm(() => message.complete(response));
+		},
+	};
+}
+
+function promoteKnownBridgeError(value: unknown): unknown {
+	if (!isRivetErrorLike(value)) {
+		return value;
+	}
+
+	if (
+		value.group === "auth" &&
+		value.code === "forbidden" &&
+		(!value.public || value.statusCode === 500)
+	) {
+		return new RivetError(value.group, value.code, value.message, {
+			public: true,
+			statusCode: 403,
+			metadata: value.metadata,
+			cause: value instanceof Error ? value.cause : undefined,
+		});
+	}
+
+	if (
+		value.group === "actor" &&
+		value.code === "action_not_found" &&
+		(!value.public || value.statusCode === 500)
+	) {
+		return new RivetError(value.group, value.code, value.message, {
+			public: true,
+			statusCode: 404,
+			metadata: value.metadata,
+			cause: value instanceof Error ? value.cause : undefined,
+		});
+	}
+
+	if (
+		value.group === "actor" &&
+		value.code === "action_timed_out" &&
+		(!value.public || value.statusCode === 500)
+	) {
+		return new RivetError(value.group, value.code, value.message, {
+			public: true,
+			statusCode: 408,
+			metadata: value.metadata,
+			cause: value instanceof Error ? value.cause : undefined,
+		});
+	}
+
+	if (
+		value.group === "actor" &&
+		value.code === "aborted" &&
+		(!value.public || value.statusCode === 500)
+	) {
+		return new RivetError(value.group, value.code, value.message, {
+			public: true,
+			statusCode: 400,
+			metadata: value.metadata,
+			cause: value instanceof Error ? value.cause : undefined,
+		});
+	}
+
+	if (
+		value.group === "message" &&
+		(value.code === "incoming_too_long" ||
+			value.code === "outgoing_too_long") &&
+		(!value.public || value.statusCode === 500)
+	) {
+		return new RivetError(value.group, value.code, value.message, {
+			public: true,
+			statusCode: 400,
+			metadata: value.metadata,
+			cause: value instanceof Error ? value.cause : undefined,
+		});
+	}
+
+	if (
+		value.group === "queue" &&
+		[
+			"full",
+			"message_too_large",
+			"message_invalid",
+			"invalid_payload",
+			"invalid_completion_payload",
+			"already_completed",
+			"previous_message_not_completed",
+			"complete_not_configured",
+			"timed_out",
+		].includes(value.code) &&
+		(!value.public || value.statusCode === 500)
+	) {
+		return new RivetError(value.group, value.code, value.message, {
+			public: true,
+			statusCode: 400,
+			metadata: value.metadata,
+			cause: value instanceof Error ? value.cause : undefined,
+		});
+	}
+
+	return value;
+}
+
+function normalizeWasmBridgeError(error: unknown): unknown {
+	if (typeof error === "string") {
+		return promoteKnownBridgeError(decodeBridgeRivetError(error) ?? error);
+	}
+
+	if (error instanceof Error) {
+		const bridged = decodeBridgeRivetError(error.message);
+		if (bridged) {
+			return promoteKnownBridgeError(bridged);
+		}
+	}
+
+	if (
+		typeof error === "object" &&
+		error !== null &&
+		"reason" in error &&
+		typeof error.reason === "string"
+	) {
+		const bridged = decodeBridgeRivetError(error.reason);
+		if (bridged) {
+			return promoteKnownBridgeError(bridged);
+		}
+	}
+
+	return promoteKnownBridgeError(error);
+}
+
+async function callWasm<T>(invoke: () => Promise<T>): Promise<T> {
+	try {
+		return await invoke();
+	} catch (error) {
+		throw normalizeWasmBridgeError(error);
+	}
+}
+
+function callWasmSync<T>(invoke: () => T): T {
+	try {
+		return invoke();
+	} catch (error) {
+		throw normalizeWasmBridgeError(error);
+	}
+}
+
+function unsupportedWasmMethod(method: string): never {
+	throw new RivetError(
+		"runtime",
+		"unsupported",
+		`Unsupported wasm runtime method: ${method}`,
+		{
+			metadata: {
+				runtime: "wasm",
+				method,
+			},
+		},
+	);
+}
+
+function method<T extends AnyFunction>(target: unknown, name: string): T {
+	if (
+		typeof target === "object" &&
+		target !== null &&
+		name in target &&
+		typeof target[name as keyof typeof target] === "function"
+	) {
+		return target[name as keyof typeof target] as T;
+	}
+	return unsupportedWasmMethod(name);
+}
+
+function callHandle<T>(handle: unknown, name: string, ...args: unknown[]): T {
+	return callWasmSync(() => method(handle, name).apply(handle, args) as T);
+}
+
+async function callHandleAsync<T>(
+	handle: unknown,
+	name: string,
+	...args: unknown[]
+): Promise<T> {
+	return await callWasm(
+		async () => (await method(handle, name).apply(handle, args)) as T,
+	);
+}
+
+function childHandle<T>(handle: unknown, name: string): T {
+	return callHandle<T>(handle, name);
+}
+
+export class WasmCoreRuntime implements CoreRuntime {
+	readonly kind = "wasm";
+
+	#bindings: WasmBindings;
+	#sql = new WeakMap<WasmActorContext, RuntimeSqlDatabase>();
+
+	constructor(bindings: WasmBindings) {
+		this.#bindings = bindings;
+	}
+
+	#actorSql(ctx: ActorContextHandle): RuntimeSqlDatabase {
+		const wasmCtx = asWasmActorContext(ctx);
+		let database = this.#sql.get(wasmCtx);
+		if (!database) {
+			database = callHandle<RuntimeSqlDatabase>(wasmCtx, "sql");
+			this.#sql.set(wasmCtx, database);
+		}
+		return database;
+	}
+
+	createRegistry(): RegistryHandle {
+		return callWasmSync(() =>
+			asRegistryHandle(new this.#bindings.CoreRegistry()),
+		);
+	}
+
+	registerActor(
+		registry: RegistryHandle,
+		name: string,
+		factory: ActorFactoryHandle,
+	): void {
+		callWasmSync(() =>
+			asWasmRegistry(registry).register(name, asWasmFactory(factory)),
+		);
+	}
+
+	async serveRegistry(
+		registry: RegistryHandle,
+		config: RuntimeServeConfig,
+	): Promise<void> {
+		await callWasm(() => asWasmRegistry(registry).serve(config));
+	}
+
+	async shutdownRegistry(registry: RegistryHandle): Promise<void> {
+		await callWasm(() => asWasmRegistry(registry).shutdown());
+	}
+
+	async handleServerlessRequest(
+		registry: RegistryHandle,
+		req: RuntimeServerlessRequest,
+		onStreamEvent: RuntimeServerlessStreamCallback,
+		cancelToken: CancellationTokenHandle,
+		config: RuntimeServeConfig,
+	): Promise<RuntimeServerlessResponseHead> {
+		return await callHandleAsync<RuntimeServerlessResponseHead>(
+			asWasmRegistry(registry),
+			"handleServerlessRequest",
+			req,
+			onStreamEvent,
+			asWasmCancellationToken(cancelToken),
+			config,
+		);
+	}
+
+	createActorFactory(
+		callbacks: object,
+		config?: RuntimeActorConfig | undefined | null,
+	): ActorFactoryHandle {
+		return callWasmSync(() =>
+			asActorFactoryHandle(
+				new this.#bindings.ActorFactory(callbacks, config),
+			),
+		);
+	}
+
+	createCancellationToken(): CancellationTokenHandle {
+		return callWasmSync(
+			() =>
+				new this.#bindings.CancellationToken() as unknown as CancellationTokenHandle,
+		);
+	}
+
+	cancellationTokenAborted(token: CancellationTokenHandle): boolean {
+		return callWasmSync(() => asWasmCancellationToken(token).aborted());
+	}
+
+	cancelCancellationToken(token: CancellationTokenHandle): void {
+		callWasmSync(() => asWasmCancellationToken(token).cancel());
+	}
+
+	onCancellationTokenCancelled(
+		token: CancellationTokenHandle,
+		callback: (...args: unknown[]) => unknown,
+	): void {
+		callWasmSync(() =>
+			asWasmCancellationToken(token).onCancelled(callback),
+		);
+	}
+
+	actorState(ctx: ActorContextHandle): RuntimeBytes {
+		return toBytes(
+			callHandle<RuntimeBytes | Uint8Array>(
+				asWasmActorContext(ctx),
+				"state",
+			),
+		);
+	}
+
+	actorBeginOnStateChange(ctx: ActorContextHandle): void {
+		callHandle(asWasmActorContext(ctx), "beginOnStateChange");
+	}
+
+	actorEndOnStateChange(ctx: ActorContextHandle): void {
+		callHandle(asWasmActorContext(ctx), "endOnStateChange");
+	}
+
+	actorSetAlarm(
+		ctx: ActorContextHandle,
+		timestampMs?: number | bigint | undefined | null,
+	): void {
+		callHandle(
+			asWasmActorContext(ctx),
+			"setAlarm",
+			optionalWasmNumber(timestampMs),
+		);
+	}
+
+	actorRequestSave(
+		ctx: ActorContextHandle,
+		opts?: RuntimeRequestSaveOpts | undefined | null,
+	): void {
+		callHandle(asWasmActorContext(ctx), "requestSave", opts);
+	}
+
+	async actorRequestSaveAndWait(
+		ctx: ActorContextHandle,
+		opts?: RuntimeRequestSaveOpts | undefined | null,
+	): Promise<void> {
+		await callHandleAsync(
+			asWasmActorContext(ctx),
+			"requestSaveAndWait",
+			opts,
+		);
+	}
+
+	actorInspectorSnapshot(ctx: ActorContextHandle): RuntimeInspectorSnapshot {
+		return callHandle(asWasmActorContext(ctx), "inspectorSnapshot");
+	}
+
+	actorDecodeInspectorRequest(
+		ctx: ActorContextHandle,
+		bytes: RuntimeBytes,
+		advertisedVersion: number,
+	): RuntimeBytes {
+		return toBytes(
+			callHandle<RuntimeBytes | Uint8Array>(
+				asWasmActorContext(ctx),
+				"decodeInspectorRequest",
+				bytes,
+				advertisedVersion,
+			),
+		);
+	}
+
+	actorEncodeInspectorResponse(
+		ctx: ActorContextHandle,
+		bytes: RuntimeBytes,
+		targetVersion: number,
+	): RuntimeBytes {
+		return toBytes(
+			callHandle<RuntimeBytes | Uint8Array>(
+				asWasmActorContext(ctx),
+				"encodeInspectorResponse",
+				bytes,
+				targetVersion,
+			),
+		);
+	}
+
+	async actorVerifyInspectorAuth(
+		ctx: ActorContextHandle,
+		bearerToken?: string | undefined | null,
+	): Promise<void> {
+		await callHandleAsync(
+			asWasmActorContext(ctx),
+			"verifyInspectorAuth",
+			bearerToken,
+		);
+	}
+
+	actorQueueHibernationRemoval(
+		ctx: ActorContextHandle,
+		connId: string,
+	): void {
+		callHandle(asWasmActorContext(ctx), "queueHibernationRemoval", connId);
+	}
+
+	actorTakePendingHibernationChanges(ctx: ActorContextHandle): string[] {
+		return callHandle(
+			asWasmActorContext(ctx),
+			"takePendingHibernationChanges",
+		);
+	}
+
+	actorDirtyHibernatableConns(ctx: ActorContextHandle): ConnHandle[] {
+		return callHandle(asWasmActorContext(ctx), "dirtyHibernatableConns");
+	}
+
+	async actorSaveState(
+		ctx: ActorContextHandle,
+		payload: RuntimeStateDeltaPayload,
+	): Promise<void> {
+		await callHandleAsync(asWasmActorContext(ctx), "saveState", payload);
+	}
+
+	actorId(ctx: ActorContextHandle): string {
+		return callHandle(asWasmActorContext(ctx), "actorId");
+	}
+
+	actorName(ctx: ActorContextHandle): string {
+		return callHandle(asWasmActorContext(ctx), "name");
+	}
+
+	actorKey(ctx: ActorContextHandle): RuntimeActorKeySegment[] {
+		return callHandle(asWasmActorContext(ctx), "key");
+	}
+
+	actorRegion(ctx: ActorContextHandle): string {
+		return callHandle(asWasmActorContext(ctx), "region");
+	}
+
+	actorSleep(ctx: ActorContextHandle): void {
+		callHandle(asWasmActorContext(ctx), "sleep");
+	}
+
+	actorDestroy(ctx: ActorContextHandle): void {
+		callHandle(asWasmActorContext(ctx), "destroy");
+	}
+
+	actorAbortSignal(ctx: ActorContextHandle): AbortSignal {
+		return callHandle(asWasmActorContext(ctx), "abortSignal");
+	}
+
+	actorConns(ctx: ActorContextHandle): ConnHandle[] {
+		return callHandle(asWasmActorContext(ctx), "conns");
+	}
+
+	async actorConnectConn(
+		ctx: ActorContextHandle,
+		params: RuntimeBytes,
+		request?: RuntimeHttpRequest | undefined | null,
+	): Promise<ConnHandle> {
+		return await callHandleAsync(
+			asWasmActorContext(ctx),
+			"connectConn",
+			params,
+			request,
+		);
+	}
+
+	actorBroadcast(
+		ctx: ActorContextHandle,
+		name: string,
+		args: RuntimeBytes,
+	): void {
+		callHandle(asWasmActorContext(ctx), "broadcast", name, args);
+	}
+
+	actorWaitUntil(ctx: ActorContextHandle, promise: Promise<unknown>): void {
+		callHandle(asWasmActorContext(ctx), "waitUntil", promise);
+	}
+
+	async actorKeepAwake(
+		ctx: ActorContextHandle,
+		promise: Promise<unknown>,
+	): Promise<unknown> {
+		return await callHandleAsync(
+			asWasmActorContext(ctx),
+			"keepAwake",
+			promise,
+		);
+	}
+
+	actorRegisterTask(
+		ctx: ActorContextHandle,
+		promise: Promise<unknown>,
+	): void {
+		callHandle(asWasmActorContext(ctx), "registerTask", promise);
+	}
+
+	actorRuntimeState(ctx: ActorContextHandle): object {
+		return callHandle(asWasmActorContext(ctx), "runtimeState");
+	}
+
+	actorRestartRunHandler(ctx: ActorContextHandle): void {
+		callHandle(asWasmActorContext(ctx), "restartRunHandler");
+	}
+
+	actorBeginWebsocketCallback(ctx: ActorContextHandle): number {
+		return callHandle(asWasmActorContext(ctx), "beginWebsocketCallback");
+	}
+
+	actorEndWebsocketCallback(ctx: ActorContextHandle, regionId: number): void {
+		callHandle(asWasmActorContext(ctx), "endWebsocketCallback", regionId);
+	}
+
+	async actorKvGet(
+		ctx: ActorContextHandle,
+		key: RuntimeBytes,
+	): Promise<RuntimeBytes | null> {
+		const kv = childHandle(asWasmActorContext(ctx), "kv");
+		return optionalBytes(await callHandleAsync(kv, "get", key));
+	}
+
+	async actorKvPut(
+		ctx: ActorContextHandle,
+		key: RuntimeBytes,
+		value: RuntimeBytes,
+	): Promise<void> {
+		const kv = childHandle(asWasmActorContext(ctx), "kv");
+		await callHandleAsync(kv, "put", key, value);
+	}
+
+	async actorKvDelete(
+		ctx: ActorContextHandle,
+		key: RuntimeBytes,
+	): Promise<void> {
+		const kv = childHandle(asWasmActorContext(ctx), "kv");
+		await callHandleAsync(kv, "delete", key);
+	}
+
+	async actorKvDeleteRange(
+		ctx: ActorContextHandle,
+		start: RuntimeBytes,
+		end: RuntimeBytes,
+	): Promise<void> {
+		const kv = childHandle(asWasmActorContext(ctx), "kv");
+		await callHandleAsync(kv, "deleteRange", start, end);
+	}
+
+	async actorKvListPrefix(
+		ctx: ActorContextHandle,
+		prefix: RuntimeBytes,
+		options?: RuntimeKvListOptions | undefined | null,
+	): Promise<RuntimeKvEntry[]> {
+		const kv = childHandle(asWasmActorContext(ctx), "kv");
+		const entries = await callHandleAsync<RuntimeKvEntry[]>(
+			kv,
+			"listPrefix",
+			prefix,
+			options,
+		);
+		return entries.map(normalizeKvEntry);
+	}
+
+	async actorKvListRange(
+		ctx: ActorContextHandle,
+		start: RuntimeBytes,
+		end: RuntimeBytes,
+		options?: RuntimeKvListOptions | undefined | null,
+	): Promise<RuntimeKvEntry[]> {
+		const kv = childHandle(asWasmActorContext(ctx), "kv");
+		const entries = await callHandleAsync<RuntimeKvEntry[]>(
+			kv,
+			"listRange",
+			start,
+			end,
+			options,
+		);
+		return entries.map(normalizeKvEntry);
+	}
+
+	async actorKvBatchGet(
+		ctx: ActorContextHandle,
+		keys: RuntimeBytes[],
+	): Promise<Array<RuntimeBytes | undefined | null>> {
+		const kv = childHandle(asWasmActorContext(ctx), "kv");
+		const values = await callHandleAsync<
+			Array<RuntimeBytes | Uint8Array | null | undefined>
+		>(kv, "batchGet", keys);
+		return values.map((value) =>
+			value === undefined ? undefined : optionalBytes(value),
+		);
+	}
+
+	async actorKvBatchPut(
+		ctx: ActorContextHandle,
+		entries: RuntimeKvEntry[],
+	): Promise<void> {
+		const kv = childHandle(asWasmActorContext(ctx), "kv");
+		await callHandleAsync(kv, "batchPut", entries);
+	}
+
+	async actorKvBatchDelete(
+		ctx: ActorContextHandle,
+		keys: RuntimeBytes[],
+	): Promise<void> {
+		const kv = childHandle(asWasmActorContext(ctx), "kv");
+		await callHandleAsync(kv, "batchDelete", keys);
+	}
+
+	async actorSqlExec(
+		ctx: ActorContextHandle,
+		sql: string,
+	): Promise<RuntimeSqlExecResult> {
+		return await callWasm(() => this.#actorSql(ctx).exec(sql));
+	}
+
+	async actorSqlExecute(
+		ctx: ActorContextHandle,
+		sql: string,
+		params?: RuntimeSqlBindParams,
+	): Promise<RuntimeSqlExecuteResult> {
+		const result = await callWasm(() =>
+			this.#actorSql(ctx).execute(sql, params),
+		);
+		return normalizeRuntimeSqlExecuteResult(result);
+	}
+
+	async actorSqlExecuteWrite(
+		ctx: ActorContextHandle,
+		sql: string,
+		params?: RuntimeSqlBindParams,
+	): Promise<RuntimeSqlExecuteResult> {
+		const result = await callWasm(() =>
+			this.#actorSql(ctx).executeWrite(sql, params),
+		);
+		return normalizeRuntimeSqlExecuteResult(result);
+	}
+
+	async actorSqlQuery(
+		ctx: ActorContextHandle,
+		sql: string,
+		params?: RuntimeSqlBindParams,
+	): Promise<RuntimeSqlQueryResult> {
+		return await callWasm(() => this.#actorSql(ctx).query(sql, params));
+	}
+
+	async actorSqlRun(
+		ctx: ActorContextHandle,
+		sql: string,
+		params?: RuntimeSqlBindParams,
+	): Promise<RuntimeSqlRunResult> {
+		return await callWasm(() => this.#actorSql(ctx).run(sql, params));
+	}
+
+	actorSqlTakeLastKvError(ctx: ActorContextHandle): string | null {
+		return this.#actorSql(ctx).takeLastKvError?.() ?? null;
+	}
+
+	async actorSqlClose(ctx: ActorContextHandle): Promise<void> {
+		const wasmCtx = asWasmActorContext(ctx);
+		const database = this.#sql.get(wasmCtx);
+		if (!database) {
+			return;
+		}
+
+		this.#sql.delete(wasmCtx);
+		await callWasm(() => database.close());
+	}
+
+	async actorQueueSend(
+		ctx: ActorContextHandle,
+		name: string,
+		body: RuntimeBytes,
+	): Promise<RuntimeQueueMessage> {
+		const queue = childHandle(asWasmActorContext(ctx), "queue");
+		return normalizeQueueMessage(
+			await callHandleAsync(queue, "send", name, body),
+		);
+	}
+
+	async actorQueueNextBatch(
+		ctx: ActorContextHandle,
+		options?: RuntimeQueueNextBatchOptions | undefined | null,
+		signal?: CancellationTokenHandle | undefined | null,
+	): Promise<RuntimeQueueMessage[]> {
+		const queue = childHandle(asWasmActorContext(ctx), "queue");
+		const messages = await callHandleAsync<RuntimeQueueMessage[]>(
+			queue,
+			"nextBatch",
+			options,
+			signal ? asWasmCancellationToken(signal) : signal,
+		);
+		return messages.map(normalizeQueueMessage);
+	}
+
+	async actorQueueWaitForNames(
+		ctx: ActorContextHandle,
+		names: string[],
+		options?: RuntimeQueueWaitOptions | undefined | null,
+		signal?: CancellationTokenHandle | undefined | null,
+	): Promise<RuntimeQueueMessage> {
+		const queue = childHandle(asWasmActorContext(ctx), "queue");
+		return normalizeQueueMessage(
+			await callHandleAsync(
+				queue,
+				"waitForNames",
+				names,
+				options,
+				signal ? asWasmCancellationToken(signal) : signal,
+			),
+		);
+	}
+
+	async actorQueueWaitForNamesAvailable(
+		ctx: ActorContextHandle,
+		names: string[],
+		options?: RuntimeQueueWaitOptions | undefined | null,
+	): Promise<void> {
+		const queue = childHandle(asWasmActorContext(ctx), "queue");
+		await callHandleAsync(queue, "waitForNamesAvailable", names, options);
+	}
+
+	async actorQueueEnqueueAndWait(
+		ctx: ActorContextHandle,
+		name: string,
+		body: RuntimeBytes,
+		options?: RuntimeQueueEnqueueAndWaitOptions | undefined | null,
+		signal?: CancellationTokenHandle | undefined | null,
+	): Promise<RuntimeBytes | null> {
+		const queue = childHandle(asWasmActorContext(ctx), "queue");
+		return optionalBytes(
+			await callHandleAsync(
+				queue,
+				"enqueueAndWait",
+				name,
+				body,
+				options,
+				signal ? asWasmCancellationToken(signal) : signal,
+			),
+		);
+	}
+
+	actorQueueTryNextBatch(
+		ctx: ActorContextHandle,
+		options?: RuntimeQueueTryNextBatchOptions | undefined | null,
+	): RuntimeQueueMessage[] {
+		const queue = childHandle(asWasmActorContext(ctx), "queue");
+		return callHandle<RuntimeQueueMessage[]>(
+			queue,
+			"tryNextBatch",
+			options,
+		).map(normalizeQueueMessage);
+	}
+
+	actorQueueMaxSize(ctx: ActorContextHandle): number {
+		const queue = childHandle(asWasmActorContext(ctx), "queue");
+		return callHandle(queue, "maxSize");
+	}
+
+	async actorQueueInspectMessages(
+		ctx: ActorContextHandle,
+	): Promise<RuntimeQueueInspectMessage[]> {
+		const queue = childHandle(asWasmActorContext(ctx), "queue");
+		return await callHandleAsync(queue, "inspectMessages");
+	}
+
+	actorScheduleAfter(
+		ctx: ActorContextHandle,
+		durationMs: number | bigint,
+		actionName: string,
+		args: RuntimeBytes,
+	): void {
+		const schedule = childHandle(asWasmActorContext(ctx), "schedule");
+		callHandle(schedule, "after", wasmNumber(durationMs), actionName, args);
+	}
+
+	actorScheduleAt(
+		ctx: ActorContextHandle,
+		timestampMs: number | bigint,
+		actionName: string,
+		args: RuntimeBytes,
+	): void {
+		const schedule = childHandle(asWasmActorContext(ctx), "schedule");
+		callHandle(schedule, "at", wasmNumber(timestampMs), actionName, args);
+	}
+
+	connId(conn: ConnHandle): string {
+		return callHandle(asWasmConn(conn), "id");
+	}
+
+	connParams(conn: ConnHandle): RuntimeBytes {
+		return toBytes(callHandle(asWasmConn(conn), "params"));
+	}
+
+	connState(conn: ConnHandle): RuntimeBytes {
+		return toBytes(callHandle(asWasmConn(conn), "state"));
+	}
+
+	connSetState(conn: ConnHandle, state: RuntimeBytes): void {
+		callHandle(asWasmConn(conn), "setState", state);
+	}
+
+	connIsHibernatable(conn: ConnHandle): boolean {
+		return callHandle(asWasmConn(conn), "isHibernatable");
+	}
+
+	connSend(conn: ConnHandle, name: string, args: RuntimeBytes): void {
+		callHandle(asWasmConn(conn), "send", name, args);
+	}
+
+	async connDisconnect(
+		conn: ConnHandle,
+		reason?: string | undefined | null,
+	): Promise<void> {
+		await callHandleAsync(asWasmConn(conn), "disconnect", reason);
+	}
+
+	webSocketSend(
+		ws: WebSocketHandle,
+		data: RuntimeBytes,
+		binary: boolean,
+	): void {
+		callHandle(asWasmWebSocket(ws), "send", data, binary);
+	}
+
+	async webSocketClose(
+		ws: WebSocketHandle,
+		code?: number | undefined | null,
+		reason?: string | undefined | null,
+	): Promise<void> {
+		await callHandleAsync(asWasmWebSocket(ws), "close", code, reason);
+	}
+
+	webSocketSetEventCallback(
+		ws: WebSocketHandle,
+		callback: (event: RuntimeWebSocketEvent) => void,
+	): void {
+		callHandle(
+			asWasmWebSocket(ws),
+			"setEventCallback",
+			(event: RuntimeWebSocketEvent) => {
+				if (event.kind === "message" && event.binary) {
+					callback({
+						...event,
+						data: toBytes(event.data as RuntimeBytes | Uint8Array),
+					});
+					return;
+				}
+				callback(event);
+			},
+		);
+	}
+}
+
+export type { WasmBindings };
+
+export async function loadWasmRuntime(config?: WasmRuntimeLoadConfig): Promise<{
+	bindings: WasmBindings;
+	runtime: WasmCoreRuntime;
+}> {
+	const bindings =
+		config?.bindings ??
+		(await import(["@rivetkit", "rivetkit-wasm"].join("/")));
+	await bindings.default(config?.initInput);
+	return {
+		bindings,
+		runtime: new WasmCoreRuntime(bindings),
+	};
+}
diff --git a/rivetkit-typescript/packages/rivetkit/src/serde.ts b/rivetkit-typescript/packages/rivetkit/src/serde.ts
index 6475749147..087e490ab2 100644
--- a/rivetkit-typescript/packages/rivetkit/src/serde.ts
+++ b/rivetkit-typescript/packages/rivetkit/src/serde.ts
@@ -54,6 +54,12 @@ export function decodeCborCompat<T>(buffer: Uint8Array): T {
 	return reviveJsonCompatValue(cbor.decode(buffer)) as T;
 }
 
+export function decodeCborJsonCompat<T>(buffer: Uint8Array): T {
+	return reviveJsonCompatValue(cbor.decode(buffer), {
+		coerceSafeIntegerBigInts: true,
+	}) as T;
+}
+
 export function wsBinaryTypeForEncoding(
 	encoding: Encoding,
 ): "arraybuffer" | "blob" {
diff --git a/rivetkit-typescript/packages/rivetkit/src/utils/env-vars.ts b/rivetkit-typescript/packages/rivetkit/src/utils/env-vars.ts
index 7a813c7fa5..d3e6d5f50d 100644
--- a/rivetkit-typescript/packages/rivetkit/src/utils/env-vars.ts
+++ b/rivetkit-typescript/packages/rivetkit/src/utils/env-vars.ts
@@ -42,6 +42,8 @@ export const getRivetkitInspectorDisable = (): boolean =>
 	getEnvUniversal("RIVET_INSPECTOR_DISABLE") === "1";
 export const getRivetkitStoragePath = (): string | undefined =>
 	getEnvUniversal("RIVETKIT_STORAGE_PATH");
+export const getRivetkitRuntime = (): string | undefined =>
+	getEnvUniversal("RIVETKIT_RUNTIME");
 
 // Logging configuration
 // DEPRECATED: LOG_LEVEL will be removed in a future version
diff --git a/rivetkit-typescript/packages/rivetkit/tests/cbor-json-compat.test.ts b/rivetkit-typescript/packages/rivetkit/tests/cbor-json-compat.test.ts
new file mode 100644
index 0000000000..faa4a0971a
--- /dev/null
+++ b/rivetkit-typescript/packages/rivetkit/tests/cbor-json-compat.test.ts
@@ -0,0 +1,33 @@
+import * as cbor from "cbor-x";
+import { describe, expect, test } from "vitest";
+import {
+	decodeCborCompat,
+	decodeCborJsonCompat,
+	encodeCborCompat,
+} from "@/serde";
+
+describe("CBOR JSON compat", () => {
+	test("coerces raw safe integer BigInts from Rust JSON payloads", () => {
+		const decoded = decodeCborJsonCompat<{ value: number }>(
+			cbor.encode({ value: 1_777_630_185_078n }),
+		);
+
+		expect(decoded.value).toBe(1_777_630_185_078);
+	});
+
+	test("preserves explicit BigInts encoded by the TypeScript compat layer", () => {
+		const decoded = decodeCborJsonCompat<{ value: bigint }>(
+			encodeCborCompat({ value: 123n }),
+		);
+
+		expect(decoded.value).toBe(123n);
+	});
+
+	test("keeps protocol decoder BigInts untouched", () => {
+		const decoded = decodeCborCompat<{ value: bigint }>(
+			cbor.encode({ value: 123n }),
+		);
+
+		expect(decoded.value).toBe(123n);
+	});
+});
diff --git a/rivetkit-typescript/packages/rivetkit/tests/driver/actor-db-init-order.test.ts b/rivetkit-typescript/packages/rivetkit/tests/driver/actor-db-init-order.test.ts
index b0fdcd3398..cb1b574eb1 100644
--- a/rivetkit-typescript/packages/rivetkit/tests/driver/actor-db-init-order.test.ts
+++ b/rivetkit-typescript/packages/rivetkit/tests/driver/actor-db-init-order.test.ts
@@ -1,5 +1,8 @@
 import { describe, expect, test } from "vitest";
-import { describeDriverMatrix } from "./shared-matrix";
+import {
+	describeDriverMatrix,
+	SQLITE_DRIVER_MATRIX_OPTIONS,
+} from "./shared-matrix";
 import { setupDriverTest, waitFor } from "./shared-utils";
 
 const REAL_TIMER_DB_TIMEOUT_MS = 180_000;
@@ -153,4 +156,4 @@ describeDriverMatrix("Actor Db Init Order", (driverTestConfig) => {
 			dbTestTimeout,
 		);
 	});
-});
+}, SQLITE_DRIVER_MATRIX_OPTIONS);
diff --git a/rivetkit-typescript/packages/rivetkit/tests/driver/actor-db-raw.test.ts b/rivetkit-typescript/packages/rivetkit/tests/driver/actor-db-raw.test.ts
index 6aab958eed..57a3251974 100644
--- a/rivetkit-typescript/packages/rivetkit/tests/driver/actor-db-raw.test.ts
+++ b/rivetkit-typescript/packages/rivetkit/tests/driver/actor-db-raw.test.ts
@@ -91,5 +91,6 @@ describeDriverMatrix("Actor Db Raw", (driverTestConfig) => {
 				expect(values[0].value).toBe("test");
 			});
 		});
+
 	});
 });
diff --git a/rivetkit-typescript/packages/rivetkit/tests/driver/actor-db-stress.test.ts b/rivetkit-typescript/packages/rivetkit/tests/driver/actor-db-stress.test.ts
index 9bcb954919..7aba59bb50 100644
--- a/rivetkit-typescript/packages/rivetkit/tests/driver/actor-db-stress.test.ts
+++ b/rivetkit-typescript/packages/rivetkit/tests/driver/actor-db-stress.test.ts
@@ -262,4 +262,4 @@ describeDriverMatrix("Actor Db Stress", (driverTestConfig) => {
 			KITCHEN_SINK_TEST_TIMEOUT_MS,
 		);
 	});
-}, { encodings: ["bare"] });
+});
diff --git a/rivetkit-typescript/packages/rivetkit/tests/driver/actor-db.test.ts b/rivetkit-typescript/packages/rivetkit/tests/driver/actor-db.test.ts
index 79ba1cb16d..ee1dd5935c 100644
--- a/rivetkit-typescript/packages/rivetkit/tests/driver/actor-db.test.ts
+++ b/rivetkit-typescript/packages/rivetkit/tests/driver/actor-db.test.ts
@@ -1,7 +1,10 @@
 // @ts-nocheck
 
 import { describe, expect, test, vi } from "vitest";
-import { describeDriverMatrix } from "./shared-matrix";
+import {
+	describeDriverMatrix,
+	SQLITE_DRIVER_MATRIX_OPTIONS,
+} from "./shared-matrix";
 import { setupDriverTest, waitFor } from "./shared-utils";
 
 type DbVariant = "raw";
@@ -587,4 +590,4 @@ describeDriverMatrix("Actor Db", (driverTestConfig) => {
 			lifecycleTestTimeout,
 		);
 	});
-});
+}, SQLITE_DRIVER_MATRIX_OPTIONS);
diff --git a/rivetkit-typescript/packages/rivetkit/tests/driver/actor-queue.test.ts b/rivetkit-typescript/packages/rivetkit/tests/driver/actor-queue.test.ts
index 0a60b8033c..dd11504237 100644
--- a/rivetkit-typescript/packages/rivetkit/tests/driver/actor-queue.test.ts
+++ b/rivetkit-typescript/packages/rivetkit/tests/driver/actor-queue.test.ts
@@ -1,6 +1,6 @@
 // @ts-nocheck
 import { describeDriverMatrix } from "./shared-matrix";
-import { describe, expect, test } from "vitest";
+import { describe, expect, test, vi } from "vitest";
 import type { ActorError } from "@/client/mod";
 import { MANY_QUEUE_NAMES } from "../../fixtures/driver-test-suite/queue";
 import { setupDriverTest, waitFor } from "./shared-utils";
@@ -307,14 +307,7 @@ describeDriverMatrix("Actor Queue", (driverTestConfig) => {
 					queued: true,
 				});
 
-				// Wait for the queued spawn to land in the parent's `spawned`
-				// list. The parent does not expose an event the test can
-				// subscribe to, so we poll the read-only `getSpawned` action
-				// rather than retry the original `queueSpawn` mutation.
-				await vi.waitFor(async () => {
-					const spawned = await parent.getSpawned();
-					expect(spawned).toContain("many-run-child");
-				});
+				expect(await parent.getSpawned()).toContain("many-run-child");
 
 				await expectManyQueueChildToDrain(
 					client.manyQueueChildActor,
diff --git a/rivetkit-typescript/packages/rivetkit/tests/driver/actor-run.test.ts b/rivetkit-typescript/packages/rivetkit/tests/driver/actor-run.test.ts
index d7a202fde9..2a9e806313 100644
--- a/rivetkit-typescript/packages/rivetkit/tests/driver/actor-run.test.ts
+++ b/rivetkit-typescript/packages/rivetkit/tests/driver/actor-run.test.ts
@@ -1,5 +1,5 @@
 import { describeDriverMatrix } from "./shared-matrix";
-import { describe, expect, test } from "vitest";
+import { describe, expect, test, vi } from "vitest";
 import { RUN_SLEEP_TIMEOUT } from "../../fixtures/driver-test-suite/run";
 import { setupDriverTest, waitFor } from "./shared-utils";
 
@@ -135,7 +135,15 @@ describeDriverMatrix("Actor Run", (driverTestConfig) => {
 		test("run handler that exits early sleeps instead of destroying", async (c) => {
 			const { client } = await setupDriverTest(c, driverTestConfig);
 
-			const actor = client.runWithEarlyExit.getOrCreate(["early-exit"]);
+			const observer = client.lifecycleObserver.getOrCreate([
+				"run-with-early-exit",
+			]);
+			await observer.clearEvents();
+
+			const actor = client.runWithEarlyExit.getOrCreate([
+				`early-exit-${Date.now()}`,
+			]);
+			const actorId = await actor.resolve();
 
 			// Wait for run to start and exit
 			await waitFor(driverTestConfig, 100);
@@ -143,8 +151,24 @@ describeDriverMatrix("Actor Run", (driverTestConfig) => {
 			const state1 = await actor.getState();
 			expect(state1.runStarted).toBe(true);
 
-			// Wait for the run handler to exit and the normal idle sleep timeout.
-			await waitFor(driverTestConfig, RUN_SLEEP_TIMEOUT + 400);
+			if (!driverTestConfig.skip?.sleep) {
+				// Poll because the sleep hook is emitted from the actor runtime after idle detection.
+				await vi.waitFor(
+					async () => {
+						const events = await observer.getEvents();
+						expect(
+							events.filter(
+								(event) =>
+									event.actorKey === actorId &&
+									event.event === "sleep",
+							),
+						).toHaveLength(1);
+					},
+					{ timeout: RUN_SLEEP_TIMEOUT + 5_000 },
+				);
+			} else {
+				await waitFor(driverTestConfig, RUN_SLEEP_TIMEOUT + 400);
+			}
 
 			const state2 = await actor.getState();
 			expect(state2.runStarted).toBe(true);
diff --git a/rivetkit-typescript/packages/rivetkit/tests/driver/actor-sleep-db.test.ts b/rivetkit-typescript/packages/rivetkit/tests/driver/actor-sleep-db.test.ts
index 36539c4f0f..75a424831c 100644
--- a/rivetkit-typescript/packages/rivetkit/tests/driver/actor-sleep-db.test.ts
+++ b/rivetkit-typescript/packages/rivetkit/tests/driver/actor-sleep-db.test.ts
@@ -5,7 +5,10 @@ import {
 	SLEEP_DB_TIMEOUT,
 	SLEEP_SCHEDULE_AFTER_ON_SLEEP_DELAY_MS,
 } from "../../fixtures/driver-test-suite/sleep-db";
-import { describeDriverMatrix } from "./shared-matrix";
+import {
+	describeDriverMatrix,
+	SQLITE_DRIVER_MATRIX_OPTIONS,
+} from "./shared-matrix";
 import { setupDriverTest, waitFor } from "./shared-utils";
 
 type LogEntry = { id: number; event: string; created_at: number };
@@ -1072,4 +1075,4 @@ describeDriverMatrix("Actor Sleep Db", (driverTestConfig) => {
 			{ timeout: 30_000 },
 		);
 	});
-});
+}, SQLITE_DRIVER_MATRIX_OPTIONS);
diff --git a/rivetkit-typescript/packages/rivetkit/tests/driver/shared-harness.ts b/rivetkit-typescript/packages/rivetkit/tests/driver/shared-harness.ts
index 57f6eb8c9b..92f3610387 100644
--- a/rivetkit-typescript/packages/rivetkit/tests/driver/shared-harness.ts
+++ b/rivetkit-typescript/packages/rivetkit/tests/driver/shared-harness.ts
@@ -1,72 +1,46 @@
 import { type ChildProcess, spawn } from "node:child_process";
-import { createHash } from "node:crypto";
-import {
-	existsSync,
-	mkdirSync,
-	mkdtempSync,
-	readFileSync,
-	rmSync,
-	statSync,
-	unlinkSync,
-	writeFileSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { getEnginePath } from "@rivetkit/engine-cli";
-import getPort from "get-port";
 import type { DriverRegistryVariant } from "../driver-registry-variants";
-import type { DriverDeployOutput, DriverTestConfig } from "./shared-types";
+import {
+	getOrStartSharedTestEngine,
+	releaseSharedTestEngine,
+	type SharedTestEngine,
+	TEST_ENGINE_TOKEN,
+} from "../shared-engine";
+import type {
+	DriverDeployOutput,
+	DriverSqliteBackend,
+	DriverTestConfig,
+} from "./shared-types";
 
 const DRIVER_TEST_DIR = dirname(fileURLToPath(import.meta.url));
 const TEST_DIR = join(DRIVER_TEST_DIR, "..");
 const FIXTURE_PATH = join(TEST_DIR, "fixtures", "driver-test-suite-runtime.ts");
-const REPO_ENGINE_BINARY = join(
+const WASM_FIXTURE_PATH = join(
 	TEST_DIR,
-	"../../../../target/debug/rivet-engine",
+	"fixtures",
+	"driver-test-suite-wasm-runtime.ts",
 );
-const TOKEN = "dev";
+export const TOKEN = TEST_ENGINE_TOKEN;
 const TIMING_ENABLED = process.env.RIVETKIT_DRIVER_TEST_TIMING === "1";
-const ENGINE_STATE_ID = createHash("sha256")
-	.update(TEST_DIR)
-	.digest("hex")
-	.slice(0, 16);
-const ENGINE_START_LOCK_DIR = join(
-	tmpdir(),
-	`rivetkit-driver-engine-${ENGINE_STATE_ID}.lock`,
-);
-const ENGINE_STATE_PATH = join(
-	tmpdir(),
-	`rivetkit-driver-engine-${ENGINE_STATE_ID}.json`,
-);
-const ENGINE_START_LOCK_STALE_MS = 120_000;
 
 interface RuntimeLogs {
 	stdout: string;
 	stderr: string;
 }
 
-export interface SharedEngine {
-	endpoint: string;
-	pid: number;
-	dbRoot: string;
-}
+export type SharedEngine = SharedTestEngine;
 
 export interface NativeDriverTestConfigOptions {
 	variant: DriverRegistryVariant;
 	encoding: NonNullable<DriverTestConfig["encoding"]>;
+	sqliteBackend: DriverSqliteBackend;
 	useRealTimers?: boolean;
 	skip?: DriverTestConfig["skip"];
 	features?: DriverTestConfig["features"];
 }
 
-interface SharedEngineState extends SharedEngine {
-	refs: number;
-}
-
-let sharedEnginePromise: Promise<SharedEngine> | undefined;
-let sharedEngineRefAcquired = false;
-
 function childOutput(logs: RuntimeLogs): string {
 	return [logs.stdout, logs.stderr].filter(Boolean).join("\n");
 }
@@ -88,73 +62,6 @@ function timing(
 	);
 }
 
-function resolveEngineBinaryPath(): string {
-	if (existsSync(REPO_ENGINE_BINARY)) {
-		return REPO_ENGINE_BINARY;
-	}
-
-	return getEnginePath();
-}
-
-async function acquireEngineStartLock(): Promise<() => void> {
-	const startedAt = performance.now();
-
-	while (true) {
-		try {
-			mkdirSync(ENGINE_START_LOCK_DIR);
-			timing("engine.start_lock", startedAt);
-			return () => {
-				rmSync(ENGINE_START_LOCK_DIR, { force: true, recursive: true });
-			};
-		} catch (error) {
-			const code = (error as NodeJS.ErrnoException).code;
-			if (code !== "EEXIST") {
-				throw error;
-			}
-
-			try {
-				const stat = statSync(ENGINE_START_LOCK_DIR);
-				if (Date.now() - stat.mtimeMs > ENGINE_START_LOCK_STALE_MS) {
-					rmSync(ENGINE_START_LOCK_DIR, { force: true, recursive: true });
-					continue;
-				}
-			} catch {}
-
-			await new Promise((resolve) => setTimeout(resolve, 50));
-		}
-	}
-}
-
-async function waitForEngineHealth(
-	child: ChildProcess,
-	logs: RuntimeLogs,
-	endpoint: string,
-	timeoutMs: number,
-): Promise<void> {
-	const deadline = Date.now() + timeoutMs;
-
-	while (Date.now() < deadline) {
-		if (child.exitCode !== null) {
-			throw new Error(
-				`shared engine exited before health check passed:\n${childOutput(logs)}`,
-			);
-		}
-
-		try {
-			const response = await fetch(`${endpoint}/health`);
-			if (response.ok) {
-				return;
-			}
-		} catch {}
-
-		await new Promise((resolve) => setTimeout(resolve, 500));
-	}
-
-	throw new Error(
-		`timed out waiting for shared engine health:\n${childOutput(logs)}`,
-	);
-}
-
 async function waitForEnvoy(
 	child: ChildProcess,
 	logs: RuntimeLogs,
@@ -284,7 +191,10 @@ async function upsertNormalRunnerConfig(
 	);
 }
 
-async function createNamespace(endpoint: string, namespace: string): Promise<void> {
+async function createNamespace(
+	endpoint: string,
+	namespace: string,
+): Promise<void> {
 	const startedAt = performance.now();
 	const response = await fetch(`${endpoint}/namespaces`, {
 		method: "POST",
@@ -306,42 +216,6 @@ async function createNamespace(endpoint: string, namespace: string): Promise<voi
 	timing("namespace.create", startedAt, { namespace });
 }
 
-function readSharedEngineState(): SharedEngineState | undefined {
-	try {
-		return JSON.parse(readFileSync(ENGINE_STATE_PATH, "utf8"));
-	} catch {
-		return undefined;
-	}
-}
-
-function writeSharedEngineState(state: SharedEngineState): void {
-	writeFileSync(ENGINE_STATE_PATH, JSON.stringify(state), "utf8");
-}
-
-function removeSharedEngineState(): void {
-	try {
-		unlinkSync(ENGINE_STATE_PATH);
-	} catch {}
-}
-
-function isPidRunning(pid: number): boolean {
-	try {
-		process.kill(pid, 0);
-		return true;
-	} catch {
-		return false;
-	}
-}
-
-async function isEngineHealthy(endpoint: string): Promise<boolean> {
-	try {
-		const response = await fetch(`${endpoint}/health`);
-		return response.ok;
-	} catch {
-		return false;
-	}
-}
-
 async function stopProcess(
 	child: ChildProcess,
 	signal: NodeJS.Signals,
@@ -367,185 +241,94 @@ async function stopProcess(
 	});
 }
 
-async function stopPid(pid: number, timeoutMs: number): Promise<void> {
-	if (!isPidRunning(pid)) {
-		return;
-	}
-
-	process.kill(pid, "SIGTERM");
+export async function getOrStartSharedEngine(): Promise<SharedEngine> {
+	return getOrStartSharedTestEngine();
+}
 
-	const deadline = Date.now() + timeoutMs;
-	while (Date.now() < deadline) {
-		if (!isPidRunning(pid)) {
-			return;
-		}
-		await new Promise((resolve) => setTimeout(resolve, 100));
-	}
+export async function releaseSharedEngine(): Promise<void> {
+	await releaseSharedTestEngine();
+}
 
-	if (isPidRunning(pid)) {
-		process.kill(pid, "SIGKILL");
-	}
+async function stopRuntime(child: ChildProcess): Promise<void> {
+	const startedAt = performance.now();
+	await stopProcess(child, "SIGTERM", 1_000);
+	timing("runtime.stop", startedAt);
 }
 
-async function spawnSharedEngine(): Promise<SharedEngine> {
+export async function startNativeDriverRuntime(
+	variant: DriverRegistryVariant,
+	engine: SharedEngine,
+	sqliteBackend: DriverSqliteBackend,
+): Promise<DriverDeployOutput> {
 	const startedAt = performance.now();
-	const portStartedAt = performance.now();
-	const host = "127.0.0.1";
-	const guardPort = await getPort({ host });
-	const apiPeerPort = await getPort({
-		host,
-		exclude: [guardPort],
-	});
-	const metricsPort = await getPort({
-		host,
-		exclude: [guardPort, apiPeerPort],
-	});
-	const endpoint = `http://${host}:${guardPort}`;
-	const dbRoot = mkdtempSync(join(tmpdir(), "rivetkit-driver-engine-"));
-	timing("engine.allocate", portStartedAt, { endpoint });
+	const endpoint = engine.endpoint;
+	const namespace = `driver-${crypto.randomUUID()}`;
+	const poolName = `driver-suite-${crypto.randomUUID()}`;
+	const logs: RuntimeLogs = { stdout: "", stderr: "" };
+
+	await createNamespace(endpoint, namespace);
+	await upsertNormalRunnerConfig(logs, endpoint, namespace, poolName);
 
 	const spawnStartedAt = performance.now();
-	const logs: RuntimeLogs = { stdout: "", stderr: "" };
-	const engine = spawn(resolveEngineBinaryPath(), ["start"], {
+	const runtime = spawn(process.execPath, ["--import", "tsx", FIXTURE_PATH], {
+		cwd: dirname(TEST_DIR),
 		env: {
 			...process.env,
-			RIVET__GUARD__HOST: host,
-			RIVET__GUARD__PORT: guardPort.toString(),
-			RIVET__API_PEER__HOST: host,
-			RIVET__API_PEER__PORT: apiPeerPort.toString(),
-			RIVET__METRICS__HOST: host,
-			RIVET__METRICS__PORT: metricsPort.toString(),
-			RIVET__FILE_SYSTEM__PATH: join(dbRoot, "db"),
+			RIVET_TOKEN: TOKEN,
+			RIVET_NAMESPACE: namespace,
+			RIVETKIT_DRIVER_REGISTRY_PATH: variant.registryPath,
+			RIVETKIT_TEST_ENDPOINT: endpoint,
+			RIVETKIT_TEST_POOL_NAME: poolName,
+			RIVETKIT_TEST_SQLITE_BACKEND: sqliteBackend,
 		},
 		stdio: ["ignore", "pipe", "pipe"],
 	});
-	timing("engine.spawn", spawnStartedAt, { endpoint });
+	timing("runtime.spawn", spawnStartedAt, { namespace, poolName });
 
-	engine.stdout?.on("data", (chunk) => {
+	runtime.stdout?.on("data", (chunk) => {
 		const text = chunk.toString();
 		logs.stdout += text;
-		if (process.env.DRIVER_ENGINE_LOGS === "1") {
-			process.stderr.write(`[ENG.OUT] ${text}`);
+		if (process.env.DRIVER_RUNTIME_LOGS === "1") {
+			process.stderr.write(`[RT.OUT] ${text}`);
 		}
 	});
-	engine.stderr?.on("data", (chunk) => {
+	runtime.stderr?.on("data", (chunk) => {
 		const text = chunk.toString();
 		logs.stderr += text;
-		if (process.env.DRIVER_ENGINE_LOGS === "1") {
-			process.stderr.write(`[ENG.ERR] ${text}`);
+		if (process.env.DRIVER_RUNTIME_LOGS === "1") {
+			process.stderr.write(`[RT.ERR] ${text}`);
 		}
 	});
 
 	try {
-		const healthStartedAt = performance.now();
-		await waitForEngineHealth(engine, logs, endpoint, 90_000);
-		timing("engine.health", healthStartedAt, { endpoint });
+		const envoyStartedAt = performance.now();
+		await waitForEnvoy(
+			runtime,
+			logs,
+			endpoint,
+			namespace,
+			poolName,
+			30_000,
+		);
+		timing("runtime.envoy", envoyStartedAt, { namespace, poolName });
 	} catch (error) {
-		await stopRuntime(engine);
-		rmSync(dbRoot, { force: true, recursive: true });
+		await stopRuntime(runtime);
 		throw error;
 	}
+	timing("runtime.start_total", startedAt, { namespace, poolName });
 
-	if (engine.pid === undefined) {
-		await stopRuntime(engine);
-		rmSync(dbRoot, { force: true, recursive: true });
-		throw new Error("shared engine started without a pid");
-	}
-
-	const sharedEngine = {
+	return {
 		endpoint,
-		pid: engine.pid,
-		dbRoot,
+		namespace,
+		runnerName: poolName,
+		getRuntimeOutput: () => childOutput(logs),
+		cleanup: async () => {
+			await stopRuntime(runtime);
+		},
 	};
-	timing("engine.start_total", startedAt, { endpoint });
-	return sharedEngine;
-}
-
-export async function getOrStartSharedEngine(): Promise<SharedEngine> {
-	if (sharedEnginePromise) {
-		return sharedEnginePromise;
-	}
-
-	sharedEnginePromise = (async () => {
-		const releaseStartLock = await acquireEngineStartLock();
-		try {
-			const existing = readSharedEngineState();
-			if (
-				existing &&
-				isPidRunning(existing.pid) &&
-				(await isEngineHealthy(existing.endpoint))
-			) {
-				const state = { ...existing, refs: existing.refs + 1 };
-				writeSharedEngineState(state);
-				sharedEngineRefAcquired = true;
-				timing("engine.reuse", performance.now(), {
-					endpoint: existing.endpoint,
-				});
-				return {
-					endpoint: existing.endpoint,
-					pid: existing.pid,
-					dbRoot: existing.dbRoot,
-				};
-			}
-
-			if (existing) {
-				await stopPid(existing.pid, 5_000);
-				rmSync(existing.dbRoot, { force: true, recursive: true });
-				removeSharedEngineState();
-			}
-
-			const engine = await spawnSharedEngine();
-			writeSharedEngineState({ ...engine, refs: 1 });
-			sharedEngineRefAcquired = true;
-			return engine;
-		} catch (error) {
-			sharedEnginePromise = undefined;
-			throw error;
-		} finally {
-			releaseStartLock();
-		}
-	})();
-
-	return sharedEnginePromise;
-}
-
-export async function releaseSharedEngine(): Promise<void> {
-	if (!sharedEngineRefAcquired) {
-		return;
-	}
-	sharedEngineRefAcquired = false;
-	sharedEnginePromise = undefined;
-
-	const releaseStartLock = await acquireEngineStartLock();
-	const startedAt = performance.now();
-	try {
-		const state = readSharedEngineState();
-		if (!state) {
-			return;
-		}
-
-		const refs = Math.max(0, state.refs - 1);
-		if (refs > 0) {
-			writeSharedEngineState({ ...state, refs });
-			return;
-		}
-
-		await stopPid(state.pid, 5_000);
-		rmSync(state.dbRoot, { force: true, recursive: true });
-		removeSharedEngineState();
-		timing("engine.stop", startedAt, { endpoint: state.endpoint });
-	} finally {
-		releaseStartLock();
-	}
-}
-
-async function stopRuntime(child: ChildProcess): Promise<void> {
-	const startedAt = performance.now();
-	await stopProcess(child, "SIGTERM", 1_000);
-	timing("runtime.stop", startedAt);
 }
 
-export async function startNativeDriverRuntime(
+export async function startWasmDriverRuntime(
 	variant: DriverRegistryVariant,
 	engine: SharedEngine,
 ): Promise<DriverDeployOutput> {
@@ -559,44 +342,56 @@ export async function startNativeDriverRuntime(
 	await upsertNormalRunnerConfig(logs, endpoint, namespace, poolName);
 
 	const spawnStartedAt = performance.now();
-	const runtime = spawn(process.execPath, ["--import", "tsx", FIXTURE_PATH], {
-		cwd: dirname(TEST_DIR),
-		env: {
-			...process.env,
-			RIVET_TOKEN: TOKEN,
-			RIVET_NAMESPACE: namespace,
-			RIVETKIT_DRIVER_REGISTRY_PATH: variant.registryPath,
-			RIVETKIT_TEST_ENDPOINT: endpoint,
-			RIVETKIT_TEST_POOL_NAME: poolName,
+	const runtime = spawn(
+		process.execPath,
+		["--import", "tsx", WASM_FIXTURE_PATH],
+		{
+			cwd: dirname(TEST_DIR),
+			env: {
+				...process.env,
+				RIVET_TOKEN: TOKEN,
+				RIVET_NAMESPACE: namespace,
+				RIVETKIT_DRIVER_REGISTRY_PATH: variant.registryPath,
+				RIVETKIT_TEST_ENDPOINT: endpoint,
+				RIVETKIT_TEST_POOL_NAME: poolName,
+				RIVETKIT_TEST_SQLITE_BACKEND: "remote",
+			},
+			stdio: ["ignore", "pipe", "pipe"],
 		},
-		stdio: ["ignore", "pipe", "pipe"],
-	});
-	timing("runtime.spawn", spawnStartedAt, { namespace, poolName });
+	);
+	timing("wasm_runtime.spawn", spawnStartedAt, { namespace, poolName });
 
 	runtime.stdout?.on("data", (chunk) => {
 		const text = chunk.toString();
 		logs.stdout += text;
 		if (process.env.DRIVER_RUNTIME_LOGS === "1") {
-			process.stderr.write(`[RT.OUT] ${text}`);
+			process.stderr.write(`[WASM_RT.OUT] ${text}`);
 		}
 	});
 	runtime.stderr?.on("data", (chunk) => {
 		const text = chunk.toString();
 		logs.stderr += text;
 		if (process.env.DRIVER_RUNTIME_LOGS === "1") {
-			process.stderr.write(`[RT.ERR] ${text}`);
+			process.stderr.write(`[WASM_RT.ERR] ${text}`);
 		}
 	});
 
 	try {
 		const envoyStartedAt = performance.now();
-		await waitForEnvoy(runtime, logs, endpoint, namespace, poolName, 30_000);
-		timing("runtime.envoy", envoyStartedAt, { namespace, poolName });
+		await waitForEnvoy(
+			runtime,
+			logs,
+			endpoint,
+			namespace,
+			poolName,
+			30_000,
+		);
+		timing("wasm_runtime.envoy", envoyStartedAt, { namespace, poolName });
 	} catch (error) {
 		await stopRuntime(runtime);
 		throw error;
 	}
-	timing("runtime.start_total", startedAt, { namespace, poolName });
+	timing("wasm_runtime.start_total", startedAt, { namespace, poolName });
 
 	return {
 		endpoint,
@@ -613,6 +408,8 @@ export function createNativeDriverTestConfig(
 	options: NativeDriverTestConfigOptions,
 ): DriverTestConfig {
 	return {
+		runtime: "native",
+		sqliteBackend: options.sqliteBackend,
 		encoding: options.encoding,
 		skip: options.skip,
 		features: {
@@ -622,7 +419,31 @@ export function createNativeDriverTestConfig(
 		useRealTimers: options.useRealTimers ?? true,
 		start: async () => {
 			const engine = await getOrStartSharedEngine();
-			return startNativeDriverRuntime(options.variant, engine);
+			return startNativeDriverRuntime(
+				options.variant,
+				engine,
+				options.sqliteBackend,
+			);
+		},
+	};
+}
+
+export function createWasmDriverTestConfig(
+	options: Omit<NativeDriverTestConfigOptions, "sqliteBackend">,
+): DriverTestConfig {
+	return {
+		runtime: "wasm",
+		sqliteBackend: "remote",
+		encoding: options.encoding,
+		skip: options.skip,
+		features: {
+			hibernatableWebSocketProtocol: false,
+			...options.features,
+		},
+		useRealTimers: options.useRealTimers ?? true,
+		start: async () => {
+			const engine = await getOrStartSharedEngine();
+			return startWasmDriverRuntime(options.variant, engine);
 		},
 	};
 }
diff --git a/rivetkit-typescript/packages/rivetkit/tests/driver/shared-matrix.test.ts b/rivetkit-typescript/packages/rivetkit/tests/driver/shared-matrix.test.ts
new file mode 100644
index 0000000000..b97edf88b1
--- /dev/null
+++ b/rivetkit-typescript/packages/rivetkit/tests/driver/shared-matrix.test.ts
@@ -0,0 +1,84 @@
+import { afterEach, describe, expect, test } from "vitest";
+import {
+	getDriverMatrixCells,
+	SQLITE_DRIVER_MATRIX_OPTIONS,
+} from "./shared-matrix";
+
+const previousRuntimeEnv = process.env.RIVETKIT_DRIVER_TEST_RUNTIME;
+const previousSqliteEnv = process.env.RIVETKIT_DRIVER_TEST_SQLITE;
+const previousEncodingEnv = process.env.RIVETKIT_DRIVER_TEST_ENCODING;
+
+function restoreMatrixEnv() {
+	if (previousRuntimeEnv === undefined) {
+		delete process.env.RIVETKIT_DRIVER_TEST_RUNTIME;
+	} else {
+		process.env.RIVETKIT_DRIVER_TEST_RUNTIME = previousRuntimeEnv;
+	}
+
+	if (previousSqliteEnv === undefined) {
+		delete process.env.RIVETKIT_DRIVER_TEST_SQLITE;
+	} else {
+		process.env.RIVETKIT_DRIVER_TEST_SQLITE = previousSqliteEnv;
+	}
+
+	if (previousEncodingEnv === undefined) {
+		delete process.env.RIVETKIT_DRIVER_TEST_ENCODING;
+	} else {
+		process.env.RIVETKIT_DRIVER_TEST_ENCODING = previousEncodingEnv;
+	}
+}
+
+describe("driver matrix cells", () => {
+	afterEach(() => {
+		restoreMatrixEnv();
+	});
+
+	test("excludes wasm with local SQLite from the normal matrix", () => {
+		const cells = getDriverMatrixCells(SQLITE_DRIVER_MATRIX_OPTIONS);
+
+		expect(
+			cells.some(
+				(cell) =>
+					cell.runtime === "wasm" && cell.sqliteBackend === "local",
+			),
+		).toBe(false);
+		expect(
+			cells.some(
+				(cell) =>
+					cell.runtime === "wasm" &&
+					cell.sqliteBackend === "remote" &&
+					cell.skipReason === undefined,
+			),
+		).toBe(true);
+	});
+
+	test("keeps the expected SQLite driver matrix cells", () => {
+		const cells = getDriverMatrixCells(SQLITE_DRIVER_MATRIX_OPTIONS);
+
+		expect(
+			cells.map(
+				(cell) =>
+					`${cell.runtime}/${cell.sqliteBackend}/${cell.encoding}`,
+			),
+		).toEqual([
+			"native/local/bare",
+			"native/local/cbor",
+			"native/local/json",
+			"native/remote/bare",
+			"native/remote/cbor",
+			"native/remote/json",
+			"wasm/remote/bare",
+			"wasm/remote/cbor",
+			"wasm/remote/json",
+		]);
+	});
+
+	test("fails fast when env explicitly selects wasm with local SQLite", () => {
+		process.env.RIVETKIT_DRIVER_TEST_RUNTIME = "wasm";
+		process.env.RIVETKIT_DRIVER_TEST_SQLITE = "local";
+
+		expect(() => getDriverMatrixCells()).toThrow(
+			/WebAssembly runtime cannot use local SQLite/,
+		);
+	});
+});
diff --git a/rivetkit-typescript/packages/rivetkit/tests/driver/shared-matrix.ts b/rivetkit-typescript/packages/rivetkit/tests/driver/shared-matrix.ts
index 17415f9d3b..7a41cc66fc 100644
--- a/rivetkit-typescript/packages/rivetkit/tests/driver/shared-matrix.ts
+++ b/rivetkit-typescript/packages/rivetkit/tests/driver/shared-matrix.ts
@@ -2,14 +2,19 @@ import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { afterAll, describe } from "vitest";
 import {
-	getDriverRegistryVariants,
 	type DriverRegistryVariant,
+	getDriverRegistryVariants,
 } from "../driver-registry-variants";
 import {
 	createNativeDriverTestConfig,
+	createWasmDriverTestConfig,
 	releaseSharedEngine,
 } from "./shared-harness";
-import type { DriverTestConfig } from "./shared-types";
+import type {
+	DriverRuntime,
+	DriverSqliteBackend,
+	DriverTestConfig,
+} from "./shared-types";
 
 const describeDriverSuite =
 	process.env.RIVETKIT_DRIVER_TEST_PARALLEL === "1"
@@ -20,9 +25,102 @@ const TEST_DIR = join(dirname(fileURLToPath(import.meta.url)), "..");
 export interface DriverMatrixOptions {
 	registryVariants?: DriverRegistryVariant["name"][];
 	encodings?: Array<NonNullable<DriverTestConfig["encoding"]>>;
+	runtimes?: DriverRuntime[];
+	sqliteBackends?: DriverSqliteBackend[];
 	config?: Pick<DriverTestConfig, "features" | "skip">;
 }
 
+export const SQLITE_DRIVER_MATRIX_OPTIONS = {
+	runtimes: ["native", "wasm"],
+	sqliteBackends: ["local", "remote"],
+} as const satisfies Pick<DriverMatrixOptions, "runtimes" | "sqliteBackends">;
+
+export interface DriverMatrixCell {
+	runtime: DriverRuntime;
+	sqliteBackend: DriverSqliteBackend;
+	encoding: NonNullable<DriverTestConfig["encoding"]>;
+	skipReason?: string;
+}
+
+function envList<T extends string>(
+	name: string,
+	allowed: readonly T[],
+): T[] | undefined {
+	const value = process.env[name];
+	if (!value) {
+		return undefined;
+	}
+
+	const values = value
+		.split(",")
+		.map((part) => part.trim())
+		.filter(Boolean);
+	for (const item of values) {
+		if (!allowed.includes(item as T)) {
+			throw new Error(
+				`invalid ${name} value '${item}', expected one of ${allowed.join(", ")}`,
+			);
+		}
+	}
+	return values as T[];
+}
+
+function hasEnvMatrixOverride() {
+	return (
+		process.env.RIVETKIT_DRIVER_TEST_RUNTIME !== undefined ||
+		process.env.RIVETKIT_DRIVER_TEST_SQLITE !== undefined ||
+		process.env.RIVETKIT_DRIVER_TEST_ENCODING !== undefined
+	);
+}
+
+export function getDriverMatrixCells(
+	options: DriverMatrixOptions = {},
+): DriverMatrixCell[] {
+	const envEncodings = envList("RIVETKIT_DRIVER_TEST_ENCODING", [
+		"bare",
+		"cbor",
+		"json",
+	] as const);
+	const envRuntimes = envList("RIVETKIT_DRIVER_TEST_RUNTIME", [
+		"native",
+		"wasm",
+	] as const);
+	const envSqliteBackends = envList("RIVETKIT_DRIVER_TEST_SQLITE", [
+		"local",
+		"remote",
+	] as const);
+	const encodings = envEncodings ??
+		options.encodings ?? ["bare", "cbor", "json"];
+	const runtimes = envRuntimes ?? options.runtimes ?? ["native"];
+	const sqliteBackends = envSqliteBackends ??
+		options.sqliteBackends ?? ["local"];
+	const cells: DriverMatrixCell[] = [];
+
+	if (envRuntimes?.includes("wasm") && envSqliteBackends?.includes("local")) {
+		throw new Error(
+			"invalid driver test matrix: WebAssembly runtime cannot use local SQLite. Set RIVETKIT_DRIVER_TEST_SQLITE=remote for wasm driver tests.",
+		);
+	}
+
+	for (const runtime of runtimes) {
+		for (const sqliteBackend of sqliteBackends) {
+			if (runtime === "wasm" && sqliteBackend === "local") {
+				continue;
+			}
+
+			for (const encoding of encodings) {
+				cells.push({
+					runtime,
+					sqliteBackend,
+					encoding,
+				});
+			}
+		}
+	}
+
+	return cells;
+}
+
 export function describeDriverMatrix(
 	suiteName: string,
 	defineTests: (driverTestConfig: DriverTestConfig) => void,
@@ -31,9 +129,14 @@ export function describeDriverMatrix(
 	const registryVariantNames = new Set(options.registryVariants);
 	const variants = getDriverRegistryVariants(TEST_DIR).filter(
 		(variant) =>
-			registryVariantNames.size === 0 || registryVariantNames.has(variant.name),
+			registryVariantNames.size === 0 ||
+			registryVariantNames.has(variant.name),
 	);
-	const encodings = options.encodings ?? ["bare", "cbor", "json"];
+	const cells = getDriverMatrixCells(options);
+	const includeSqliteDimensions =
+		hasEnvMatrixOverride() ||
+		options.runtimes !== undefined ||
+		options.sqliteBackends !== undefined;
 
 	describeDriverSuite(suiteName, () => {
 		for (const variant of variants) {
@@ -47,15 +150,35 @@ export function describeDriverMatrix(
 					await releaseSharedEngine();
 				});
 
-				for (const encoding of encodings) {
-					describeDriverSuite(`encoding (${encoding})`, () => {
-						defineTests(
-							createNativeDriverTestConfig({
-								variant,
-								encoding,
-								...options.config,
-							}),
-						);
+				for (const cell of cells) {
+					const suite = includeSqliteDimensions
+						? `runtime (${cell.runtime}) / sqlite (${cell.sqliteBackend}) / encoding (${cell.encoding})`
+						: `encoding (${cell.encoding})`;
+
+					if (cell.skipReason) {
+						describe.skip(`${suite}: ${cell.skipReason}`, () => {});
+						continue;
+					}
+
+					describeDriverSuite(suite, () => {
+						if (cell.runtime === "native") {
+							defineTests(
+								createNativeDriverTestConfig({
+									variant,
+									encoding: cell.encoding,
+									sqliteBackend: cell.sqliteBackend,
+									...options.config,
+								}),
+							);
+						} else {
+							defineTests(
+								createWasmDriverTestConfig({
+									variant,
+									encoding: cell.encoding,
+									...options.config,
+								}),
+							);
+						}
 					});
 				}
 			});
diff --git a/rivetkit-typescript/packages/rivetkit/tests/driver/shared-types.ts b/rivetkit-typescript/packages/rivetkit/tests/driver/shared-types.ts
index 12f6361cfc..ef32df54a3 100644
--- a/rivetkit-typescript/packages/rivetkit/tests/driver/shared-types.ts
+++ b/rivetkit-typescript/packages/rivetkit/tests/driver/shared-types.ts
@@ -1,5 +1,8 @@
 import type { Encoding } from "../../src/client/mod";
 
+export type DriverRuntime = "native" | "wasm";
+export type DriverSqliteBackend = "local" | "remote";
+
 export interface SkipTests {
 	schedule?: boolean;
 	sleep?: boolean;
@@ -23,6 +26,8 @@ export interface DriverDeployOutput {
 
 export interface DriverTestConfig {
 	start(): Promise<DriverDeployOutput>;
+	runtime: DriverRuntime;
+	sqliteBackend: DriverSqliteBackend;
 	useRealTimers?: boolean;
 	HACK_skipCleanupNet?: boolean;
 	skip?: SkipTests;
diff --git a/rivetkit-typescript/packages/rivetkit/tests/fixtures/driver-test-suite-runtime.ts b/rivetkit-typescript/packages/rivetkit/tests/fixtures/driver-test-suite-runtime.ts
index bb8e864f94..35f8b7b4dc 100644
--- a/rivetkit-typescript/packages/rivetkit/tests/fixtures/driver-test-suite-runtime.ts
+++ b/rivetkit-typescript/packages/rivetkit/tests/fixtures/driver-test-suite-runtime.ts
@@ -1,13 +1,14 @@
 import { resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 import type { Registry } from "../../src/registry";
-import { buildNativeRegistry } from "../../src/registry/native";
+import { buildConfiguredRegistry } from "../../src/registry/native";
 
 const registryPath = process.env.RIVETKIT_DRIVER_REGISTRY_PATH;
 const endpoint = process.env.RIVETKIT_TEST_ENDPOINT;
 const token = process.env.RIVET_TOKEN ?? "dev";
 const namespace = process.env.RIVET_NAMESPACE ?? "default";
 const poolName = process.env.RIVETKIT_TEST_POOL_NAME ?? "default";
+const sqliteBackend = process.env.RIVETKIT_TEST_SQLITE_BACKEND ?? "local";
 
 if (!registryPath) {
 	throw new Error("RIVETKIT_DRIVER_REGISTRY_PATH is required");
@@ -23,7 +24,18 @@ const { registry } = (await import(
 	registry: Registry<any>;
 };
 
-registry.config.test = { ...registry.config.test, enabled: true };
+if (sqliteBackend !== "local" && sqliteBackend !== "remote") {
+	throw new Error(
+		`unsupported RIVETKIT_TEST_SQLITE_BACKEND: ${sqliteBackend}`,
+	);
+}
+
+registry.config.test = {
+	...registry.config.test,
+	enabled: true,
+	sqliteBackend,
+};
+registry.config.runtime = "native";
 registry.config.startEngine = false;
 registry.config.endpoint = endpoint;
 registry.config.token = token;
@@ -33,7 +45,7 @@ registry.config.envoy = {
 	poolName,
 };
 
-const { registry: nativeRegistry, serveConfig } = await buildNativeRegistry(
+const { registry: nativeRegistry, serveConfig } = await buildConfiguredRegistry(
 	registry.parseConfig(),
 );
 
diff --git a/rivetkit-typescript/packages/rivetkit/tests/fixtures/driver-test-suite-wasm-runtime.ts b/rivetkit-typescript/packages/rivetkit/tests/fixtures/driver-test-suite-wasm-runtime.ts
new file mode 100644
index 0000000000..8a41ee8e75
--- /dev/null
+++ b/rivetkit-typescript/packages/rivetkit/tests/fixtures/driver-test-suite-wasm-runtime.ts
@@ -0,0 +1,65 @@
+import { readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import type { Registry } from "../../src/registry";
+import { buildConfiguredRegistry } from "../../src/registry/native";
+
+const registryPath = process.env.RIVETKIT_DRIVER_REGISTRY_PATH;
+const endpoint = process.env.RIVETKIT_TEST_ENDPOINT;
+const token = process.env.RIVET_TOKEN ?? "dev";
+const namespace = process.env.RIVET_NAMESPACE ?? "default";
+const poolName = process.env.RIVETKIT_TEST_POOL_NAME ?? "default";
+const sqliteBackend = process.env.RIVETKIT_TEST_SQLITE_BACKEND ?? "remote";
+const wasmPath =
+	process.env.RIVETKIT_WASM_PATH ??
+	resolve(
+		dirname(fileURLToPath(import.meta.url)),
+		"../../../rivetkit-wasm/pkg/rivetkit_wasm_bg.wasm",
+	);
+
+if (!registryPath) {
+	throw new Error("RIVETKIT_DRIVER_REGISTRY_PATH is required");
+}
+
+if (!endpoint) {
+	throw new Error("RIVETKIT_TEST_ENDPOINT is required");
+}
+
+if (sqliteBackend !== "remote") {
+	throw new Error(
+		`unsupported RIVETKIT_TEST_SQLITE_BACKEND for wasm runtime: ${sqliteBackend}`,
+	);
+}
+
+const { registry } = (await import(
+	pathToFileURL(resolve(registryPath)).href
+)) as {
+	registry: Registry<any>;
+};
+
+registry.config.test = {
+	...registry.config.test,
+	enabled: true,
+	sqliteBackend,
+};
+registry.config.runtime = "wasm";
+registry.config.wasm = {
+	...registry.config.wasm,
+	initInput: readFileSync(wasmPath),
+};
+registry.config.startEngine = false;
+registry.config.endpoint = endpoint;
+registry.config.token = token;
+registry.config.namespace = namespace;
+registry.config.envoy = {
+	...registry.config.envoy,
+	poolName,
+};
+
+const {
+	runtime,
+	registry: wasmRegistry,
+	serveConfig,
+} = await buildConfiguredRegistry(registry.parseConfig());
+
+await runtime.serveRegistry(wasmRegistry, serveConfig);
diff --git a/rivetkit-typescript/packages/rivetkit/tests/inspector-versioned.test.ts b/rivetkit-typescript/packages/rivetkit/tests/inspector-versioned.test.ts
index c8de7c63d1..827e8b4649 100644
--- a/rivetkit-typescript/packages/rivetkit/tests/inspector-versioned.test.ts
+++ b/rivetkit-typescript/packages/rivetkit/tests/inspector-versioned.test.ts
@@ -1,17 +1,24 @@
-import { describe, expect, test } from "vitest";
-import { ActorContext } from "@rivetkit/rivetkit-napi";
-import type { WorkflowHistory } from "@/common/bare/transport/v1";
+import { beforeAll, describe, expect, test } from "vitest";
 import * as v1 from "@/common/bare/generated/inspector/v1";
 import * as v2 from "@/common/bare/generated/inspector/v2";
 import * as v3 from "@/common/bare/generated/inspector/v3";
 import * as v4 from "@/common/bare/generated/inspector/v4";
+import type { WorkflowHistory } from "@/common/bare/transport/v1";
 import {
 	decodeWorkflowHistoryTransport,
 	encodeWorkflowHistoryTransport,
 } from "@/common/inspector-transport";
+import { loadNapiRuntime, type NapiCoreRuntime } from "@/registry/napi-runtime";
+import type { ActorContextHandle } from "@/registry/runtime";
 
 const INSPECTOR_CURRENT_VERSION = 4;
-const ctx = new ActorContext("actor-1", "inspector", "local");
+let runtime: NapiCoreRuntime;
+let ctx: ActorContextHandle;
+
+beforeAll(async () => {
+	({ runtime } = await loadNapiRuntime());
+	ctx = runtime.createTestActorContext("actor-1", "inspector", "local");
+});
 
 function buffer(text: string): ArrayBuffer {
 	return new TextEncoder().encode(text).buffer;
@@ -26,7 +33,7 @@ function toBuffer(value: ArrayBuffer | Uint8Array): Buffer {
 function decodeRequest(bytes: Uint8Array, version: number): v4.ToServer {
 	return v4.decodeToServer(
 		new Uint8Array(
-			ctx.decodeInspectorRequest(toBuffer(bytes), version),
+			runtime.actorDecodeInspectorRequest(ctx, toBuffer(bytes), version),
 		),
 	);
 }
@@ -36,7 +43,8 @@ function encodeResponse(
 	version: 1 | 2 | 3 | 4,
 ): Uint8Array {
 	return new Uint8Array(
-		ctx.encodeInspectorResponse(
+		runtime.actorEncodeInspectorResponse(
+			ctx,
 			toBuffer(v4.encodeToClient(message)),
 			version,
 		),
@@ -67,7 +75,9 @@ describe("inspector versioned protocol", () => {
 					: version === 2
 						? v2.encodeToServer(request as unknown as v2.ToServer)
 						: version === 3
-							? v3.encodeToServer(request as unknown as v3.ToServer)
+							? v3.encodeToServer(
+									request as unknown as v3.ToServer,
+								)
 							: v4.encodeToServer(request);
 			const decoded = decodeRequest(bytes, version);
 
diff --git a/rivetkit-typescript/packages/rivetkit/tests/platforms/AGENTS.md b/rivetkit-typescript/packages/rivetkit/tests/platforms/AGENTS.md
new file mode 120000
index 0000000000..681311eb9c
--- /dev/null
+++ b/rivetkit-typescript/packages/rivetkit/tests/platforms/AGENTS.md
@@ -0,0 +1 @@
+CLAUDE.md
\ No newline at end of file
diff --git a/rivetkit-typescript/packages/rivetkit/tests/platforms/CLAUDE.md b/rivetkit-typescript/packages/rivetkit/tests/platforms/CLAUDE.md
new file mode 100644
index 0000000000..26004539cf
--- /dev/null
+++ b/rivetkit-typescript/packages/rivetkit/tests/platforms/CLAUDE.md
@@ -0,0 +1,18 @@
+# Platform Test Fixtures
+
+- Platform fixture code should look like public docs code that users can copy.
+- Do not expose test-only registry wrapper APIs in generated platform apps.
+- Generated platform apps should import `actor`, `setup`, and `@rivetkit/rivetkit-wasm` through public package exports.
+- Keep shared helpers for process setup, temporary files, ports, and assertions, not for hiding the public RivetKit runtime API.
+- Cloudflare Workers, Supabase Functions, and Deno fixtures should share the same docs-shaped SQLite counter actor source with only platform bootstrapping differences.
+- Use `buildPlatformSqliteCounterRegistrySource(...)` when generated apps need the shared docs-shaped SQLite counter registry.
+- Do not use hidden globals, lower-level registry builders, private generated wasm paths, or repo-local `pkg*` imports in platform app code.
+- Raw `ctx.sql` platform fixtures still need a `db` provider so runtime SQLite is enabled.
+- Cloudflare Workers fixtures need a fetch-upgrade `WebSocket` shim for wasm envoy connections.
+- Deno fixtures need `--allow-sys` because public `rivetkit` imports `pino`, which reads `os.hostname()`.
+- Deno fixtures should load wasm bytes from the public `@rivetkit/rivetkit-wasm/rivetkit_wasm_bg.wasm` export with `import.meta.resolve` plus `Deno.readFile`.
+- Supabase Functions fixtures run inside Docker, so advertise the host engine through the Docker bridge IP when `docker0` exists and fall back to `host.docker.internal`.
+- Supabase Functions fixtures need package metadata next to the function entrypoint for Edge Runtime bare package resolution.
+- Supabase Functions fixtures should use Edge Runtime `per_worker` policy so long-lived serverless start streams can coexist with metadata and wake requests.
+- Do not duplicate engine-owned serverless start headers such as `x-rivet-endpoint` in platform runner config.
+- Avoid `sqlite_` table names in platform fixtures because SQLite reserves that prefix.
diff --git a/rivetkit-typescript/packages/rivetkit/tests/platforms/cloudflare-workers.test.ts b/rivetkit-typescript/packages/rivetkit/tests/platforms/cloudflare-workers.test.ts
new file mode 100644
index 0000000000..82d9965e9b
--- /dev/null
+++ b/rivetkit-typescript/packages/rivetkit/tests/platforms/cloudflare-workers.test.ts
@@ -0,0 +1,458 @@
+import { randomUUID } from "node:crypto";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import getPort from "get-port";
+import { describe, expect, test } from "vitest";
+import {
+	buildPlatformSqliteCounterRegistrySource,
+	createPlatformServerlessRunner,
+	createPlatformSqliteCounterClient,
+	createTempPlatformApp,
+	getOrStartPlatformTestEngine,
+	type LoggedChild,
+	linkWorkspacePackage,
+	PLATFORM_TEST_TOKEN,
+	releasePlatformTestEngine,
+	spawnPinnedPnpmDlx,
+	type TempPlatformApp,
+	waitForHttpOk,
+} from "./shared-platform-harness";
+
+const WRANGLER_VERSION = "4.87.0";
+const TEST_DIR = dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = resolve(TEST_DIR, "../../../../..");
+
+function writeCloudflareWorkerApp(
+	app: TempPlatformApp,
+	{
+		endpoint,
+		namespace,
+		runnerName,
+		token,
+	}: {
+		endpoint: string;
+		namespace: string;
+		runnerName: string;
+		token: string;
+	},
+) {
+	linkWorkspacePackage(
+		app,
+		"rivetkit",
+		resolve(REPO_ROOT, "rivetkit-typescript/packages/rivetkit"),
+	);
+	linkWorkspacePackage(
+		app,
+		"@rivetkit/rivetkit-wasm",
+		resolve(REPO_ROOT, "rivetkit-typescript/packages/rivetkit-wasm"),
+	);
+
+	app.writeFile(
+		"package.json",
+		JSON.stringify(
+			{
+				type: "module",
+				dependencies: {
+					"@rivetkit/rivetkit-wasm": "workspace:*",
+					rivetkit: "workspace:*",
+				},
+			},
+			null,
+			2,
+		),
+	);
+	app.writeFile(
+		"wrangler.toml",
+		`
+name = "rivetkit-cloudflare-platform-smoke"
+main = "src/index.ts"
+compatibility_date = "2025-04-01"
+compatibility_flags = ["nodejs_compat"]
+
+[vars]
+RIVET_ENDPOINT = "${endpoint}"
+RIVET_NAMESPACE = "${namespace}"
+RIVET_POOL = "${runnerName}"
+RIVET_TOKEN = "${token}"
+`,
+	);
+	app.writeFile(
+		"src/registry.ts",
+		buildPlatformSqliteCounterRegistrySource("cloudflare-module-import"),
+	);
+	app.writeFile(
+		"src/index.ts",
+		`
+import { createRegistry } from "./registry";
+
+interface Env {
+	RIVET_ENDPOINT: string;
+	RIVET_NAMESPACE: string;
+	RIVET_POOL: string;
+	RIVET_TOKEN: string;
+}
+
+type WebSocketProtocolInput = string | string[] | undefined;
+
+class FetchWebSocket {
+	static readonly CONNECTING = 0;
+	static readonly OPEN = 1;
+	static readonly CLOSING = 2;
+	static readonly CLOSED = 3;
+
+	binaryType: BinaryType = "arraybuffer";
+	onopen: ((event: Event) => void) | null = null;
+	onmessage: ((event: MessageEvent) => void) | null = null;
+	onclose: ((event: CloseEvent) => void) | null = null;
+	onerror: ((event: Event) => void) | null = null;
+	readyState = FetchWebSocket.CONNECTING;
+	#socket: WebSocket | undefined;
+	#pending: Array<string | ArrayBuffer | ArrayBufferView> = [];
+
+	constructor(url: string, protocols?: WebSocketProtocolInput) {
+		void this.#connect(url, protocols);
+	}
+
+	async #connect(url: string, protocols?: WebSocketProtocolInput) {
+		try {
+			const protocolList = Array.isArray(protocols)
+				? protocols
+				: protocols
+					? [protocols]
+					: [];
+			const headers = new Headers({ Upgrade: "websocket" });
+			if (protocolList.length > 0) {
+				headers.set("Sec-WebSocket-Protocol", protocolList.join(", "));
+			}
+			const response = await fetch(
+				url.replace(/^ws:/, "http:").replace(/^wss:/, "https:"),
+				{ headers },
+			);
+			const socket = response.webSocket;
+			if (!socket) {
+				throw new Error(
+					\`websocket upgrade failed with status \${response.status}\`,
+				);
+			}
+
+			socket.accept();
+			socket.binaryType = this.binaryType;
+			this.#socket = socket;
+			this.readyState = FetchWebSocket.OPEN;
+			socket.addEventListener("message", (event) => {
+				this.onmessage?.(event);
+			});
+			socket.addEventListener("close", (event) => {
+				this.readyState = FetchWebSocket.CLOSED;
+				this.onclose?.(event);
+			});
+			socket.addEventListener("error", (event) => {
+				this.onerror?.(event);
+			});
+			this.onopen?.(new Event("open"));
+			for (const data of this.#pending.splice(0)) {
+				socket.send(data);
+			}
+		} catch (error) {
+			console.error("rivetkit cloudflare websocket shim failed", error);
+			this.readyState = FetchWebSocket.CLOSED;
+			this.onerror?.(error instanceof Event ? error : new Event("error"));
+			this.onclose?.(new CloseEvent("close", { code: 1006 }));
+		}
+	}
+
+	send(data: string | ArrayBuffer | ArrayBufferView) {
+		if (this.readyState === FetchWebSocket.CONNECTING) {
+			this.#pending.push(data);
+			return;
+		}
+		this.#socket?.send(data);
+	}
+
+	close(code?: number, reason?: string) {
+		this.readyState = FetchWebSocket.CLOSING;
+		this.#socket?.close(code, reason);
+	}
+}
+
+(globalThis as unknown as { WebSocket: typeof WebSocket }).WebSocket =
+	FetchWebSocket as unknown as typeof WebSocket;
+
+let registry: ReturnType<typeof createRegistry> | undefined;
+
+function getRegistry(env: Env) {
+	registry ??= createRegistry({
+		endpoint: env.RIVET_ENDPOINT,
+		namespace: env.RIVET_NAMESPACE,
+		token: env.RIVET_TOKEN,
+		runnerName: env.RIVET_POOL,
+	});
+
+	return registry;
+}
+
+export default {
+	async fetch(request: Request, env: Env): Promise<Response> {
+		if (new URL(request.url).pathname === "/health") {
+			return new Response("ok");
+		}
+
+		return await getRegistry(env).handler(request);
+	},
+};
+`,
+	);
+}
+
+async function waitForRunnerMetadata(url: string) {
+	const deadline = Date.now() + 15_000;
+	let bodyText = "";
+
+	while (Date.now() < deadline) {
+		const response = await fetch(url);
+		bodyText = await response.text();
+		if (response.ok) {
+			const body = JSON.parse(bodyText) as {
+				envoy?: { version?: number } | null;
+				envoyProtocolVersion?: number | null;
+			};
+			if (body.envoy?.version && body.envoyProtocolVersion != null) {
+				return;
+			}
+		}
+		await new Promise((resolveWait) => setTimeout(resolveWait, 250));
+	}
+
+	throw new Error(
+		`serverless metadata did not expose envoy metadata: ${bodyText}`,
+	);
+}
+
+async function waitForRunnerConfigReady({
+	endpoint,
+	namespace,
+	runnerName,
+	token,
+}: {
+	endpoint: string;
+	namespace: string;
+	runnerName: string;
+	token: string;
+}) {
+	const deadline = Date.now() + 15_000;
+	let bodyText = "";
+
+	while (Date.now() < deadline) {
+		const response = await fetch(
+			`${endpoint}/runner-configs?namespace=${encodeURIComponent(namespace)}&runner_name=${encodeURIComponent(runnerName)}`,
+			{
+				headers: {
+					Authorization: `Bearer ${token}`,
+				},
+			},
+		);
+		bodyText = await response.text();
+		if (response.ok) {
+			const body = JSON.parse(bodyText) as {
+				runner_configs?: Record<
+					string,
+					{
+						datacenters?: Record<
+							string,
+							{
+								protocol_version?: number | null;
+								serverless?: unknown;
+							}
+						>;
+					}
+				>;
+			};
+			const config = body.runner_configs?.[runnerName];
+			const datacenters = Object.values(config?.datacenters ?? {});
+			if (
+				datacenters.length > 0 &&
+				datacenters.every(
+					(datacenter) => datacenter.protocol_version != null,
+				)
+			) {
+				return;
+			}
+		}
+		await new Promise((resolveWait) => setTimeout(resolveWait, 250));
+	}
+
+	throw new Error(`serverless runner config was not ready: ${bodyText}`);
+}
+
+async function waitForWorkerStartRequest(worker: LoggedChild) {
+	const deadline = Date.now() + 75_000;
+
+	while (Date.now() < deadline) {
+		if (
+			worker.getOutput().includes("GET /start") ||
+			worker.getOutput().includes("GET /api/rivet/start")
+		) {
+			return;
+		}
+		await new Promise((resolveWait) => setTimeout(resolveWait, 250));
+	}
+
+	throw new Error(
+		`timed out waiting for Cloudflare Worker start request:\n${worker.getOutput()}`,
+	);
+}
+
+function isColdStartCapacityError(error: unknown): boolean {
+	const message = error instanceof Error ? error.message : String(error);
+	const code =
+		error && typeof error === "object" && "code" in error
+			? String((error as { code: unknown }).code)
+			: "";
+	return (
+		code === "service_unavailable" ||
+		message.includes("actor_ready_timeout") ||
+		message.includes("no_capacity") ||
+		message.includes("request_timeout") ||
+		message.includes("service_unavailable")
+	);
+}
+
+async function runAfterColdStart<T>(
+	worker: LoggedChild,
+	run: () => Promise<T>,
+): Promise<T> {
+	const firstRequest = run().then(
+		(value) => ({ ok: true as const, value }),
+		(error: unknown) => ({ ok: false as const, error }),
+	);
+	await Promise.race([
+		firstRequest,
+		waitForWorkerStartRequest(worker).then(() => undefined),
+	]);
+	const firstResult = await firstRequest;
+	if (firstResult.ok) {
+		return firstResult.value;
+	}
+	if (!isColdStartCapacityError(firstResult.error)) {
+		throw firstResult.error;
+	}
+	return await run();
+}
+
+async function delay(ms: number) {
+	await new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+describe("Cloudflare Workers wasm platform smoke", () => {
+	test("runs the shared SQLite counter registry through local workerd", async () => {
+		const engine = await getOrStartPlatformTestEngine();
+		let app: TempPlatformApp | undefined;
+		let worker: LoggedChild | undefined;
+
+		try {
+			const port = await getPort();
+			const workerOrigin = `http://127.0.0.1:${port}`;
+			const serverlessUrl = `${workerOrigin}/api/rivet`;
+			const namespace = `cf-${randomUUID()}`;
+			const runnerName = `cf-${randomUUID()}`;
+
+			app = createTempPlatformApp({}, "rivetkit-cloudflare-");
+			writeCloudflareWorkerApp(app, {
+				endpoint: engine.endpoint.replace("127.0.0.1", "localhost"),
+				namespace,
+				runnerName,
+				token: PLATFORM_TEST_TOKEN,
+			});
+			worker = spawnPinnedPnpmDlx({
+				label: "wrangler",
+				packageName: "wrangler",
+				packageVersion: WRANGLER_VERSION,
+				args: [
+					"dev",
+					"--local",
+					"--ip",
+					"127.0.0.1",
+					"--port",
+					String(port),
+					"--inspector-port",
+					"0",
+				],
+				options: {
+					cwd: app.path,
+					env: {
+						...process.env,
+						NO_COLOR: "1",
+					},
+				},
+			});
+			await waitForHttpOk({
+				url: `${workerOrigin}/health`,
+				child: worker.child,
+				getOutput: worker.getOutput,
+				timeoutMs: 60_000,
+			});
+			const runner = await createPlatformServerlessRunner({
+				engine,
+				namespace,
+				runnerName,
+				serverlessUrl,
+				minRunners: 1,
+				runnersMargin: 1,
+			});
+			await waitForRunnerMetadata(`${serverlessUrl}/metadata`);
+			await waitForRunnerConfigReady({
+				endpoint: engine.endpoint,
+				namespace,
+				runnerName,
+				token: PLATFORM_TEST_TOKEN,
+			});
+			const actorKey = `counter-${randomUUID()}`;
+
+			const client = createPlatformSqliteCounterClient(runner);
+			const actor = client.sqliteCounter.getOrCreate([actorKey]);
+
+			expect(
+				await runAfterColdStart(worker, () => actor.increment(2)),
+			).toBe(2);
+			expect(await actor.increment(3)).toBe(5);
+			expect(await actor.getCount()).toBe(5);
+
+			const beforeSleep = await actor.getLifecycleCounts();
+			expect(beforeSleep.wakeCount).toBeGreaterThanOrEqual(1);
+			await actor.triggerSleep();
+			await delay(500);
+
+			expect(
+				await runAfterColdStart(worker, () => actor.getCount()),
+			).toBe(5);
+			const afterWake = await actor.getLifecycleCounts();
+			expect(afterWake.wakeCount).toBeGreaterThanOrEqual(
+				beforeSleep.wakeCount + 1,
+			);
+
+			const parallelActors = [1, 2, 3].map((amount) =>
+				client.sqliteCounter.getOrCreate([
+					`parallel-${amount}-${randomUUID()}`,
+				]),
+			);
+			await expect(
+				Promise.all(
+					parallelActors.map((parallelActor, index) =>
+						parallelActor.increment(index + 1),
+					),
+				),
+			).resolves.toEqual([1, 2, 3]);
+			await expect(
+				Promise.all(
+					parallelActors.map((parallelActor) =>
+						parallelActor.getCount(),
+					),
+				),
+			).resolves.toEqual([1, 2, 3]);
+		} finally {
+			await worker?.stop();
+			app?.cleanup();
+			await releasePlatformTestEngine();
+		}
+	}, 120_000);
+});
diff --git a/rivetkit-typescript/packages/rivetkit/tests/platforms/deno.test.ts b/rivetkit-typescript/packages/rivetkit/tests/platforms/deno.test.ts
new file mode 100644
index 0000000000..1d09681e54
--- /dev/null
+++ b/rivetkit-typescript/packages/rivetkit/tests/platforms/deno.test.ts
@@ -0,0 +1,350 @@
+import { randomUUID } from "node:crypto";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import getPort from "get-port";
+import { describe, expect, test } from "vitest";
+import {
+	buildPlatformSqliteCounterRegistrySource,
+	createPlatformServerlessRunner,
+	createPlatformSqliteCounterClient,
+	createTempPlatformApp,
+	getOrStartPlatformTestEngine,
+	type LoggedChild,
+	linkWorkspacePackage,
+	PLATFORM_TEST_TOKEN,
+	releasePlatformTestEngine,
+	spawnLoggedChild,
+	type TempPlatformApp,
+	waitForHttpOk,
+} from "./shared-platform-harness";
+
+const TEST_DIR = dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = resolve(TEST_DIR, "../../../../..");
+
+function writeDenoApp(
+	app: TempPlatformApp,
+	{
+		endpoint,
+		namespace,
+		port,
+		runnerName,
+		token,
+	}: {
+		endpoint: string;
+		namespace: string;
+		port: number;
+		runnerName: string;
+		token: string;
+	},
+) {
+	linkWorkspacePackage(
+		app,
+		"rivetkit",
+		resolve(REPO_ROOT, "rivetkit-typescript/packages/rivetkit"),
+	);
+	linkWorkspacePackage(
+		app,
+		"@rivetkit/rivetkit-wasm",
+		resolve(REPO_ROOT, "rivetkit-typescript/packages/rivetkit-wasm"),
+	);
+
+	app.writeFile(
+		"package.json",
+		JSON.stringify(
+			{
+				type: "module",
+			},
+			null,
+			2,
+		),
+	);
+	app.writeFile(
+		"src/registry.ts",
+		buildPlatformSqliteCounterRegistrySource("deno-read-file"),
+	);
+	app.writeFile(
+		"src/index.ts",
+		`
+import { createRegistry } from "./registry.ts";
+
+const registry = createRegistry({
+	endpoint: "${endpoint}",
+	namespace: "${namespace}",
+	token: "${token}",
+	runnerName: "${runnerName}",
+});
+
+Deno.serve(
+	{
+		hostname: "127.0.0.1",
+		port: ${port},
+		onListen: () => {
+			console.log("deno platform app listening");
+		},
+	},
+	async (request) => {
+		const pathname = new URL(request.url).pathname;
+		console.log(\`\${request.method} \${pathname}\`);
+		if (pathname === "/health") {
+			return new Response("ok");
+		}
+
+		return await registry.handler(request);
+	},
+);
+`,
+	);
+}
+
+async function waitForRunnerMetadata(url: string) {
+	const deadline = Date.now() + 15_000;
+	let bodyText = "";
+
+	while (Date.now() < deadline) {
+		const response = await fetch(url);
+		bodyText = await response.text();
+		if (response.ok) {
+			const body = JSON.parse(bodyText) as {
+				envoy?: { version?: number } | null;
+				envoyProtocolVersion?: number | null;
+			};
+			if (body.envoy?.version && body.envoyProtocolVersion != null) {
+				return;
+			}
+		}
+		await new Promise((resolveWait) => setTimeout(resolveWait, 250));
+	}
+
+	throw new Error(
+		`serverless metadata did not expose envoy metadata: ${bodyText}`,
+	);
+}
+
+async function waitForRunnerConfigReady({
+	endpoint,
+	namespace,
+	runnerName,
+	token,
+}: {
+	endpoint: string;
+	namespace: string;
+	runnerName: string;
+	token: string;
+}) {
+	const deadline = Date.now() + 15_000;
+	let bodyText = "";
+
+	while (Date.now() < deadline) {
+		const response = await fetch(
+			`${endpoint}/runner-configs?namespace=${encodeURIComponent(namespace)}&runner_name=${encodeURIComponent(runnerName)}`,
+			{
+				headers: {
+					Authorization: `Bearer ${token}`,
+				},
+			},
+		);
+		bodyText = await response.text();
+		if (response.ok) {
+			const body = JSON.parse(bodyText) as {
+				runner_configs?: Record<
+					string,
+					{
+						datacenters?: Record<
+							string,
+							{
+								protocol_version?: number | null;
+								serverless?: unknown;
+							}
+						>;
+					}
+				>;
+			};
+			const config = body.runner_configs?.[runnerName];
+			const datacenters = Object.values(config?.datacenters ?? {});
+			if (
+				datacenters.length > 0 &&
+				datacenters.every(
+					(datacenter) => datacenter.protocol_version != null,
+				)
+			) {
+				return;
+			}
+		}
+		await new Promise((resolveWait) => setTimeout(resolveWait, 250));
+	}
+
+	throw new Error(`serverless runner config was not ready: ${bodyText}`);
+}
+
+async function waitForDenoStartRequest(deno: LoggedChild) {
+	const deadline = Date.now() + 75_000;
+
+	while (Date.now() < deadline) {
+		if (
+			deno.getOutput().includes("GET /start") ||
+			deno.getOutput().includes("GET /api/rivet/start")
+		) {
+			return;
+		}
+		await new Promise((resolveWait) => setTimeout(resolveWait, 250));
+	}
+
+	throw new Error(
+		`timed out waiting for Deno start request:\n${deno.getOutput()}`,
+	);
+}
+
+function isColdStartCapacityError(error: unknown): boolean {
+	const message = error instanceof Error ? error.message : String(error);
+	const code =
+		error && typeof error === "object" && "code" in error
+			? String((error as { code: unknown }).code)
+			: "";
+	return (
+		code === "service_unavailable" ||
+		message.includes("actor_ready_timeout") ||
+		message.includes("no_capacity") ||
+		message.includes("request_timeout") ||
+		message.includes("service_unavailable")
+	);
+}
+
+async function runAfterColdStart<T>(
+	deno: LoggedChild,
+	run: () => Promise<T>,
+): Promise<T> {
+	const firstRequest = run().then(
+		(value) => ({ ok: true as const, value }),
+		(error: unknown) => ({ ok: false as const, error }),
+	);
+	await Promise.race([
+		firstRequest,
+		waitForDenoStartRequest(deno).then(() => undefined),
+	]);
+	const firstResult = await firstRequest;
+	if (firstResult.ok) {
+		return firstResult.value;
+	}
+	if (!isColdStartCapacityError(firstResult.error)) {
+		throw firstResult.error;
+	}
+	return await run();
+}
+
+async function delay(ms: number) {
+	await new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+describe("Deno wasm platform smoke", () => {
+	test("runs the shared SQLite counter registry through local Deno", async () => {
+		const engine = await getOrStartPlatformTestEngine();
+		let app: TempPlatformApp | undefined;
+		let deno: LoggedChild | undefined;
+
+		try {
+			const port = await getPort();
+			const denoOrigin = `http://127.0.0.1:${port}`;
+			const serverlessUrl = `${denoOrigin}/api/rivet`;
+			const namespace = `deno-${randomUUID()}`;
+			const runnerName = `deno-${randomUUID()}`;
+
+			app = createTempPlatformApp({}, "rivetkit-deno-");
+			writeDenoApp(app, {
+				endpoint: engine.endpoint,
+				namespace,
+				port,
+				runnerName,
+				token: PLATFORM_TEST_TOKEN,
+			});
+			deno = spawnLoggedChild({
+				label: "deno",
+				command: "deno",
+				args: [
+					"run",
+					"--allow-env",
+					"--allow-net",
+					"--allow-read",
+					"--allow-sys",
+					"--node-modules-dir=manual",
+					"--no-lock",
+					"src/index.ts",
+				],
+				options: {
+					cwd: app.path,
+					env: {
+						...process.env,
+						NO_COLOR: "1",
+					},
+				},
+			});
+			await waitForHttpOk({
+				url: `${denoOrigin}/health`,
+				child: deno.child,
+				getOutput: deno.getOutput,
+				timeoutMs: 60_000,
+			});
+			const runner = await createPlatformServerlessRunner({
+				engine,
+				namespace,
+				runnerName,
+				serverlessUrl,
+				minRunners: 1,
+				runnersMargin: 1,
+			});
+			await waitForRunnerMetadata(`${serverlessUrl}/metadata`);
+			await waitForRunnerConfigReady({
+				endpoint: engine.endpoint,
+				namespace,
+				runnerName,
+				token: PLATFORM_TEST_TOKEN,
+			});
+			const actorKey = `counter-${randomUUID()}`;
+
+			const client = createPlatformSqliteCounterClient(runner);
+			const actor = client.sqliteCounter.getOrCreate([actorKey]);
+
+			expect(
+				await runAfterColdStart(deno, () => actor.increment(2)),
+			).toBe(2);
+			expect(await actor.increment(3)).toBe(5);
+			expect(await actor.getCount()).toBe(5);
+
+			const beforeSleep = await actor.getLifecycleCounts();
+			expect(beforeSleep.wakeCount).toBeGreaterThanOrEqual(1);
+			await actor.triggerSleep();
+			await delay(500);
+
+			expect(await runAfterColdStart(deno, () => actor.getCount())).toBe(
+				5,
+			);
+			const afterWake = await actor.getLifecycleCounts();
+			expect(afterWake.wakeCount).toBeGreaterThanOrEqual(
+				beforeSleep.wakeCount + 1,
+			);
+
+			const parallelActors = [1, 2, 3].map((amount) =>
+				client.sqliteCounter.getOrCreate([
+					`parallel-${amount}-${randomUUID()}`,
+				]),
+			);
+			await expect(
+				Promise.all(
+					parallelActors.map((parallelActor, index) =>
+						parallelActor.increment(index + 1),
+					),
+				),
+			).resolves.toEqual([1, 2, 3]);
+			await expect(
+				Promise.all(
+					parallelActors.map((parallelActor) =>
+						parallelActor.getCount(),
+					),
+				),
+			).resolves.toEqual([1, 2, 3]);
+		} finally {
+			await deno?.stop();
+			app?.cleanup();
+			await releasePlatformTestEngine();
+		}
+	}, 120_000);
+});
diff --git a/rivetkit-typescript/packages/rivetkit/tests/platforms/shared-platform-harness.test.ts b/rivetkit-typescript/packages/rivetkit/tests/platforms/shared-platform-harness.test.ts
new file mode 100644
index 0000000000..08d4300452
--- /dev/null
+++ b/rivetkit-typescript/packages/rivetkit/tests/platforms/shared-platform-harness.test.ts
@@ -0,0 +1,42 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, test } from "vitest";
+import {
+	buildPinnedPnpmDlxArgs,
+	createTempPlatformApp,
+} from "./shared-platform-harness";
+
+describe("shared platform harness", () => {
+	test("builds pinned pnpm dlx commands", () => {
+		expect(
+			buildPinnedPnpmDlxArgs("wrangler", "4.0.0", ["dev", "--local"]),
+		).toEqual(["dlx", "wrangler@4.0.0", "dev", "--local"]);
+
+		expect(() => buildPinnedPnpmDlxArgs("wrangler", "latest")).toThrow(
+			"must use a pinned version",
+		);
+	});
+
+	test("creates and cleans up temporary app directories", () => {
+		const app = createTempPlatformApp({
+			"src/index.ts": "export default {};",
+		});
+
+		try {
+			const indexPath = join(app.path, "src", "index.ts");
+			expect(readFileSync(indexPath, "utf8")).toBe("export default {};");
+
+			app.writeFile("package.json", '{"type":"module"}');
+			expect(readFileSync(join(app.path, "package.json"), "utf8")).toBe(
+				'{"type":"module"}',
+			);
+			expect(() => app.writeFile("../escape.txt", "")).toThrow(
+				"escapes app directory",
+			);
+		} finally {
+			app.cleanup();
+		}
+
+		expect(existsSync(app.path)).toBe(false);
+	});
+});
diff --git a/rivetkit-typescript/packages/rivetkit/tests/platforms/shared-platform-harness.ts b/rivetkit-typescript/packages/rivetkit/tests/platforms/shared-platform-harness.ts
new file mode 100644
index 0000000000..0398ef8c56
--- /dev/null
+++ b/rivetkit-typescript/packages/rivetkit/tests/platforms/shared-platform-harness.ts
@@ -0,0 +1,617 @@
+import {
+	type ChildProcess,
+	type SpawnOptions,
+	spawn,
+} from "node:child_process";
+import { randomUUID } from "node:crypto";
+import {
+	mkdirSync,
+	mkdtempSync,
+	rmSync,
+	symlinkSync,
+	type WriteFileOptions,
+	writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve, sep } from "node:path";
+import { type Client, createClient } from "../../src/client/mod";
+import {
+	getOrStartSharedTestEngine,
+	releaseSharedTestEngine,
+	type SharedTestEngine,
+	TEST_ENGINE_TOKEN,
+} from "../shared-engine";
+import type { PlatformSqliteCounterRegistry } from "./shared-registry";
+
+export const PLATFORM_TEST_TOKEN = TEST_ENGINE_TOKEN;
+export const PLATFORM_TEST_LOGS_ENV = "RIVETKIT_PLATFORM_TEST_LOGS";
+
+interface RuntimeLogs {
+	stdout: string;
+	stderr: string;
+}
+
+export interface PlatformServerlessRunner {
+	endpoint: string;
+	namespace: string;
+	runnerName: string;
+	token: string;
+	serverlessUrl: string;
+}
+
+export interface PlatformServerlessRunnerOptions {
+	engine: SharedTestEngine;
+	namespace?: string;
+	runnerName?: string;
+	serverlessUrl: string;
+	headers?: Record<string, string>;
+	requestLifespan?: number;
+	drainGracePeriod?: number;
+	metadata?: Record<string, unknown>;
+	metadataPollInterval?: number;
+	drainOnVersionUpgrade?: boolean;
+	maxRunners?: number;
+	minRunners?: number;
+	runnersMargin?: number;
+	slotsPerRunner?: number;
+}
+
+export interface LoggedChild {
+	child: ChildProcess;
+	getOutput(): string;
+	stop(signal?: NodeJS.Signals, timeoutMs?: number): Promise<void>;
+}
+
+export interface SpawnLoggedChildOptions {
+	label: string;
+	command: string;
+	args?: string[];
+	options?: SpawnOptions;
+	logEnv?: string;
+}
+
+export interface SpawnPinnedPnpmDlxOptions
+	extends Omit<SpawnLoggedChildOptions, "command" | "args"> {
+	packageName: string;
+	packageVersion: string;
+	args?: string[];
+}
+
+export interface WaitForHttpOkOptions {
+	url: string;
+	timeoutMs?: number;
+	intervalMs?: number;
+	child?: ChildProcess;
+	getOutput?: () => string;
+}
+
+export interface TempPlatformApp {
+	path: string;
+	writeFile(
+		relativePath: string,
+		contents: string | Uint8Array,
+		options?: WriteFileOptions,
+	): void;
+	cleanup(): void;
+}
+
+type PlatformWasmInitMode = "cloudflare-module-import" | "deno-read-file";
+
+export function buildPlatformSqliteCounterRegistrySource(
+	wasmInitMode: PlatformWasmInitMode,
+): string {
+	const wasmModuleSource =
+		wasmInitMode === "cloudflare-module-import"
+			? 'import wasmModule from "@rivetkit/rivetkit-wasm/rivetkit_wasm_bg.wasm";'
+			: 'const wasmModule = await Deno.readFile(new URL(import.meta.resolve("@rivetkit/rivetkit-wasm/rivetkit_wasm_bg.wasm")));';
+
+	return `import { actor, setup } from "rivetkit";
+import * as wasmBindings from "@rivetkit/rivetkit-wasm";
+${wasmModuleSource}
+
+interface SqliteDatabase {
+\trun(sql: string, params?: unknown[]): Promise<void>;
+\tquery(sql: string, params?: unknown[]): Promise<{ rows: unknown[][] }>;
+\twriteMode<T>(callback: () => Promise<T>): Promise<T>;
+}
+
+interface RegistryConfig {
+\tendpoint: string;
+\tnamespace: string;
+\trunnerName: string;
+\ttoken: string;
+\tserverless?: {
+\t\tbasePath: string;
+\t\tpublicEndpoint: string;
+\t};
+}
+
+const COUNTER_ID = 1;
+
+const rawSqlDatabaseProvider = {
+\tcreateClient: async () => ({
+\t\texecute: async () => [],
+\t\tclose: async () => {},
+\t}),
+\tonMigrate: async () => {},
+};
+
+async function ensureCounterTable(db: SqliteDatabase) {
+\tawait db.writeMode(async () => {
+\t\tawait db.run(
+\t\t\t"CREATE TABLE IF NOT EXISTS platform_counter (id INTEGER PRIMARY KEY CHECK (id = 1), count INTEGER NOT NULL)",
+\t\t);
+\t});
+}
+
+async function ensureLifecycleTable(db: SqliteDatabase) {
+\tawait db.writeMode(async () => {
+\t\tawait db.run(
+\t\t\t"CREATE TABLE IF NOT EXISTS platform_counter_lifecycle (event TEXT PRIMARY KEY, count INTEGER NOT NULL)",
+\t\t);
+\t});
+}
+
+async function recordLifecycleEvent(db: SqliteDatabase, event: string) {
+\tawait ensureLifecycleTable(db);
+\tawait db.writeMode(async () => {
+\t\tawait db.run(
+\t\t\t"INSERT INTO platform_counter_lifecycle (event, count) VALUES (?, 1) ON CONFLICT(event) DO UPDATE SET count = count + 1",
+\t\t\t[event],
+\t\t);
+\t});
+}
+
+async function readCounter(db: SqliteDatabase): Promise<number> {
+\tconst result = await db.query(
+\t\t"SELECT count FROM platform_counter WHERE id = ?",
+\t\t[COUNTER_ID],
+\t);
+
+\treturn Number(result.rows[0]?.[0] ?? 0);
+}
+
+async function readLifecycleCounts(db: SqliteDatabase): Promise<{
+\twakeCount: number;
+\tsleepCount: number;
+}> {
+\tawait ensureLifecycleTable(db);
+\tconst result = await db.query(
+\t\t"SELECT event, count FROM platform_counter_lifecycle",
+\t);
+\tconst counts = new Map(
+\t\tresult.rows.map((row) => [String(row[0]), Number(row[1])]),
+\t);
+
+\treturn {
+\t\twakeCount: counts.get("wake") ?? 0,
+\t\tsleepCount: counts.get("sleep") ?? 0,
+\t};
+}
+
+const sqliteCounter = actor({
+\tdb: rawSqlDatabaseProvider,
+\tonWake: async (ctx) => {
+\t\tawait recordLifecycleEvent(ctx.sql as SqliteDatabase, "wake");
+\t},
+\tonSleep: async (ctx) => {
+\t\tawait recordLifecycleEvent(ctx.sql as SqliteDatabase, "sleep");
+\t},
+\tactions: {
+\t\tincrement: async (ctx, amount = 1) => {
+\t\t\tconst db = ctx.sql as SqliteDatabase;
+\t\t\tawait ensureCounterTable(db);
+\t\t\tawait db.writeMode(async () => {
+\t\t\t\tawait db.run(
+\t\t\t\t\t"INSERT INTO platform_counter (id, count) VALUES (?, ?) ON CONFLICT(id) DO UPDATE SET count = count + excluded.count",
+\t\t\t\t\t[COUNTER_ID, amount],
+\t\t\t\t);
+\t\t\t});
+
+\t\t\treturn await readCounter(db);
+\t\t},
+\t\tgetCount: async (ctx) => {
+\t\t\tconst db = ctx.sql as SqliteDatabase;
+\t\t\tawait ensureCounterTable(db);
+
+\t\t\treturn await readCounter(db);
+\t\t},
+\t\tgetLifecycleCounts: async (ctx) => {
+\t\t\treturn await readLifecycleCounts(ctx.sql as SqliteDatabase);
+\t\t},
+\t\ttriggerSleep: (ctx) => {
+\t\t\tctx.sleep();
+\t\t},
+\t},
+\toptions: {
+\t\tsleepTimeout: 100,
+\t},
+});
+
+export function createRegistry(config: RegistryConfig) {
+\treturn setup({
+\t\truntime: "wasm",
+\t\tsqlite: "remote",
+\t\twasm: {
+\t\t\tbindings: wasmBindings,
+\t\t\tinitInput: wasmModule,
+\t\t},
+\t\tuse: { sqliteCounter },
+\t\tendpoint: config.endpoint,
+\t\tnamespace: config.namespace,
+\t\ttoken: config.token,
+\t\tenvoy: {
+\t\t\tpoolName: config.runnerName,
+\t\t},
+\t\t...(config.serverless ? { serverless: config.serverless } : {}),
+\t\tnoWelcome: true,
+\t});
+}
+`;
+}
+
+export function linkWorkspacePackage(
+	app: TempPlatformApp,
+	packageName: string,
+	packagePath: string,
+): void {
+	const linkPath = resolve(
+		app.path,
+		"node_modules",
+		...packageName.split("/"),
+	);
+	mkdirSync(dirname(linkPath), { recursive: true });
+	rmSync(linkPath, { force: true, recursive: true });
+	symlinkSync(packagePath, linkPath, "dir");
+}
+
+export async function getOrStartPlatformTestEngine(): Promise<SharedTestEngine> {
+	return getOrStartSharedTestEngine();
+}
+
+export async function releasePlatformTestEngine(): Promise<void> {
+	await releaseSharedTestEngine();
+}
+
+function childOutput(logs: RuntimeLogs): string {
+	return [logs.stdout, logs.stderr].filter(Boolean).join("\n");
+}
+
+function appendChildLogs(
+	logs: RuntimeLogs,
+	stream: "stdout" | "stderr",
+	label: string,
+	chunk: Buffer,
+	logEnv: string,
+) {
+	const text = chunk.toString();
+	logs[stream] += text;
+
+	if (process.env[logEnv] === "1") {
+		process.stderr.write(`[${label}.${stream.toUpperCase()}] ${text}`);
+	}
+}
+
+async function stopProcess(
+	child: ChildProcess,
+	signal: NodeJS.Signals,
+	timeoutMs: number,
+): Promise<void> {
+	if (child.exitCode !== null) {
+		return;
+	}
+
+	await new Promise<void>((resolveStop) => {
+		const timeout = setTimeout(() => {
+			if (child.exitCode === null) {
+				child.kill("SIGKILL");
+			}
+		}, timeoutMs);
+
+		child.once("exit", () => {
+			clearTimeout(timeout);
+			resolveStop();
+		});
+
+		child.kill(signal);
+	});
+}
+
+export function spawnLoggedChild({
+	label,
+	command,
+	args = [],
+	options,
+	logEnv = PLATFORM_TEST_LOGS_ENV,
+}: SpawnLoggedChildOptions): LoggedChild {
+	const logs: RuntimeLogs = { stdout: "", stderr: "" };
+	const child = spawn(command, args, {
+		...options,
+		stdio: ["ignore", "pipe", "pipe"],
+	});
+
+	child.stdout?.on("data", (chunk) => {
+		appendChildLogs(logs, "stdout", label, chunk, logEnv);
+	});
+	child.stderr?.on("data", (chunk) => {
+		appendChildLogs(logs, "stderr", label, chunk, logEnv);
+	});
+
+	return {
+		child,
+		getOutput: () => childOutput(logs),
+		stop: async (signal = "SIGTERM", timeoutMs = 5_000) => {
+			await stopProcess(child, signal, timeoutMs);
+		},
+	};
+}
+
+export function buildPinnedPnpmDlxArgs(
+	packageName: string,
+	packageVersion: string,
+	args: string[] = [],
+): string[] {
+	if (!packageVersion || packageVersion === "latest") {
+		throw new Error(
+			`platform CLI ${packageName} must use a pinned version`,
+		);
+	}
+
+	return ["dlx", `${packageName}@${packageVersion}`, ...args];
+}
+
+export function spawnPinnedPnpmDlx({
+	packageName,
+	packageVersion,
+	args = [],
+	...options
+}: SpawnPinnedPnpmDlxOptions): LoggedChild {
+	return spawnLoggedChild({
+		...options,
+		command: "pnpm",
+		args: buildPinnedPnpmDlxArgs(packageName, packageVersion, args),
+	});
+}
+
+export function createTempPlatformApp(
+	files: Record<string, string | Uint8Array> = {},
+	prefix = "rivetkit-platform-",
+): TempPlatformApp {
+	const appPath = mkdtempSync(join(tmpdir(), prefix));
+
+	const app: TempPlatformApp = {
+		path: appPath,
+		writeFile: (relativePath, contents, options) => {
+			const filePath = resolve(appPath, relativePath);
+			const rootPrefix = `${resolve(appPath)}${sep}`;
+			if (
+				filePath !== resolve(appPath) &&
+				!filePath.startsWith(rootPrefix)
+			) {
+				throw new Error(
+					`temp app file escapes app directory: ${relativePath}`,
+				);
+			}
+
+			mkdirSync(dirname(filePath), { recursive: true });
+			writeFileSync(filePath, contents, options);
+		},
+		cleanup: () => {
+			rmSync(appPath, { force: true, recursive: true });
+		},
+	};
+
+	for (const [relativePath, contents] of Object.entries(files)) {
+		app.writeFile(relativePath, contents);
+	}
+
+	return app;
+}
+
+async function apiFetch(
+	endpoint: string,
+	path: string,
+	init: RequestInit = {},
+): Promise<Response> {
+	const headers = new Headers(init.headers);
+	headers.set("Authorization", `Bearer ${PLATFORM_TEST_TOKEN}`);
+
+	return fetch(`${endpoint}${path}`, {
+		...init,
+		headers,
+	});
+}
+
+export async function createPlatformNamespace(
+	engine: SharedTestEngine,
+	namespace = `platform-${randomUUID()}`,
+): Promise<string> {
+	const response = await apiFetch(engine.endpoint, "/namespaces", {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+		},
+		body: JSON.stringify({
+			name: namespace,
+			display_name: `Platform test ${namespace}`,
+		}),
+	});
+
+	if (!response.ok) {
+		throw new Error(
+			`failed to create platform namespace ${namespace}: ${response.status} ${await response.text()}`,
+		);
+	}
+
+	return namespace;
+}
+
+async function getFirstDatacenter(
+	engine: SharedTestEngine,
+	namespace: string,
+): Promise<string> {
+	const response = await apiFetch(
+		engine.endpoint,
+		`/datacenters?namespace=${encodeURIComponent(namespace)}`,
+	);
+
+	if (!response.ok) {
+		throw new Error(
+			`failed to list platform datacenters: ${response.status} ${await response.text()}`,
+		);
+	}
+
+	const body = (await response.json()) as {
+		datacenters: Array<{ name: string }>;
+	};
+	const datacenter = body.datacenters[0]?.name;
+	if (!datacenter) {
+		throw new Error("engine returned no platform datacenters");
+	}
+
+	return datacenter;
+}
+
+export async function createPlatformServerlessRunner({
+	engine,
+	namespace = `platform-${randomUUID()}`,
+	runnerName = `platform-${randomUUID()}`,
+	serverlessUrl,
+	headers,
+	requestLifespan,
+	drainGracePeriod,
+	metadata,
+	metadataPollInterval,
+	drainOnVersionUpgrade,
+	maxRunners,
+	minRunners,
+	runnersMargin,
+	slotsPerRunner,
+}: PlatformServerlessRunnerOptions): Promise<PlatformServerlessRunner> {
+	await createPlatformNamespace(engine, namespace);
+	const datacenter = await getFirstDatacenter(engine, namespace);
+	const deadline = Date.now() + 30_000;
+	const upsertBody = {
+		datacenters: {
+			[datacenter]: {
+				serverless: {
+					url: serverlessUrl,
+					headers: headers ?? {},
+					request_lifespan: requestLifespan ?? 15 * 60,
+					drain_grace_period: drainGracePeriod,
+					metadata_poll_interval: metadataPollInterval ?? 1_000,
+					max_runners: maxRunners ?? 100_000,
+					min_runners: minRunners ?? 0,
+					runners_margin: runnersMargin ?? 0,
+					slots_per_runner: slotsPerRunner ?? 1,
+				},
+				metadata: metadata ?? {},
+				drain_on_version_upgrade: drainOnVersionUpgrade ?? true,
+			},
+		},
+	};
+
+	while (true) {
+		const response = await apiFetch(
+			engine.endpoint,
+			`/runner-configs/${encodeURIComponent(runnerName)}?namespace=${encodeURIComponent(namespace)}`,
+			{
+				method: "PUT",
+				headers: {
+					"Content-Type": "application/json",
+				},
+				body: JSON.stringify(upsertBody),
+			},
+		);
+
+		if (response.ok) {
+			break;
+		}
+
+		const responseBody = await response.text();
+		if (
+			Date.now() < deadline &&
+			((response.status === 400 &&
+				responseBody.includes('"group":"namespace"') &&
+				responseBody.includes('"code":"not_found"')) ||
+				(response.status === 500 &&
+					responseBody.includes('"group":"core"') &&
+					responseBody.includes('"code":"internal_error"')))
+		) {
+			await new Promise((resolveWait) => setTimeout(resolveWait, 500));
+			continue;
+		}
+
+		throw new Error(
+			`failed to upsert platform serverless runner ${runnerName}: ${response.status} ${responseBody}`,
+		);
+	}
+
+	const bumpResponse = await apiFetch(
+		engine.endpoint,
+		`/runner-configs/${encodeURIComponent(runnerName)}?namespace=${encodeURIComponent(namespace)}`,
+		{
+			method: "PUT",
+			headers: {
+				"Content-Type": "application/json",
+			},
+			body: JSON.stringify(upsertBody),
+		},
+	);
+	if (!bumpResponse.ok) {
+		throw new Error(
+			`failed to bump platform serverless runner ${runnerName}: ${bumpResponse.status} ${await bumpResponse.text()}`,
+		);
+	}
+
+	return {
+		endpoint: engine.endpoint,
+		namespace,
+		runnerName,
+		token: PLATFORM_TEST_TOKEN,
+		serverlessUrl,
+	};
+}
+
+export function createPlatformSqliteCounterClient(
+	runner: PlatformServerlessRunner,
+): Client<PlatformSqliteCounterRegistry> {
+	return createClient<PlatformSqliteCounterRegistry>({
+		endpoint: runner.endpoint,
+		namespace: runner.namespace,
+		poolName: runner.runnerName,
+		token: runner.token,
+		disableMetadataLookup: true,
+	});
+}
+
+export async function waitForHttpOk({
+	url,
+	timeoutMs = 30_000,
+	intervalMs = 500,
+	child,
+	getOutput = () => "",
+}: WaitForHttpOkOptions): Promise<void> {
+	const deadline = Date.now() + timeoutMs;
+
+	while (Date.now() < deadline) {
+		if (child?.exitCode !== null && child?.exitCode !== undefined) {
+			throw new Error(
+				`platform process exited before health check passed:\n${getOutput()}`,
+			);
+		}
+
+		try {
+			const response = await fetch(url);
+			if (response.ok) {
+				return;
+			}
+		} catch {}
+
+		await new Promise((resolveWait) => setTimeout(resolveWait, intervalMs));
+	}
+
+	throw new Error(
+		`timed out waiting for platform health at ${url}:\n${getOutput()}`,
+	);
+}
diff --git a/rivetkit-typescript/packages/rivetkit/tests/platforms/shared-registry.ts b/rivetkit-typescript/packages/rivetkit/tests/platforms/shared-registry.ts
new file mode 100644
index 0000000000..5ee0a30c5a
--- /dev/null
+++ b/rivetkit-typescript/packages/rivetkit/tests/platforms/shared-registry.ts
@@ -0,0 +1,169 @@
+import {
+	actor,
+	type RegistryConfigInput,
+	setup,
+	type WasmRuntimeBindings,
+	type WasmRuntimeInitInput,
+} from "rivetkit";
+
+interface SqliteDatabase {
+	run(sql: string, params?: unknown[]): Promise<void>;
+	query(
+		sql: string,
+		params?: unknown[],
+	): Promise<{
+		rows: unknown[][];
+	}>;
+	writeMode<T>(callback: () => Promise<T>): Promise<T>;
+}
+
+const COUNTER_ID = 1;
+
+const rawSqlDatabaseProvider = {
+	createClient: async () => ({
+		execute: async () => [],
+		close: async () => {},
+	}),
+	onMigrate: async () => {},
+};
+
+async function ensureCounterTable(db: SqliteDatabase) {
+	await db.writeMode(async () => {
+		await db.run(`
+			CREATE TABLE IF NOT EXISTS platform_counter (
+				id INTEGER PRIMARY KEY CHECK (id = 1),
+				count INTEGER NOT NULL
+			)
+		`);
+	});
+}
+
+async function ensureLifecycleTable(db: SqliteDatabase) {
+	await db.writeMode(async () => {
+		await db.run(`
+			CREATE TABLE IF NOT EXISTS platform_counter_lifecycle (
+				event TEXT PRIMARY KEY,
+				count INTEGER NOT NULL
+			)
+		`);
+	});
+}
+
+async function recordLifecycleEvent(db: SqliteDatabase, event: string) {
+	await ensureLifecycleTable(db);
+	await db.writeMode(async () => {
+		await db.run(
+			`
+				INSERT INTO platform_counter_lifecycle (event, count)
+				VALUES (?, 1)
+				ON CONFLICT(event) DO UPDATE SET count = count + 1
+			`,
+			[event],
+		);
+	});
+}
+
+async function readCounter(db: SqliteDatabase): Promise<number> {
+	const result = await db.query(
+		"SELECT count FROM platform_counter WHERE id = ?",
+		[COUNTER_ID],
+	);
+
+	return Number(result.rows[0]?.[0] ?? 0);
+}
+
+async function readLifecycleCounts(db: SqliteDatabase): Promise<{
+	wakeCount: number;
+	sleepCount: number;
+}> {
+	await ensureLifecycleTable(db);
+	const result = await db.query(
+		"SELECT event, count FROM platform_counter_lifecycle",
+	);
+	const counts = new Map(
+		result.rows.map((row) => [String(row[0]), Number(row[1])]),
+	);
+
+	return {
+		wakeCount: counts.get("wake") ?? 0,
+		sleepCount: counts.get("sleep") ?? 0,
+	};
+}
+
+export const sqliteCounterActor = actor({
+	db: rawSqlDatabaseProvider,
+	onWake: async (ctx) => {
+		await recordLifecycleEvent(ctx.sql as SqliteDatabase, "wake");
+	},
+	onSleep: async (ctx) => {
+		await recordLifecycleEvent(ctx.sql as SqliteDatabase, "sleep");
+	},
+	actions: {
+		increment: async (ctx, amount = 1) => {
+			const db = ctx.sql as SqliteDatabase;
+			await ensureCounterTable(db);
+			await db.writeMode(async () => {
+				await db.run(
+					`
+						INSERT INTO platform_counter (id, count)
+						VALUES (?, ?)
+						ON CONFLICT(id) DO UPDATE SET count = count + excluded.count
+					`,
+					[COUNTER_ID, amount],
+				);
+			});
+
+			return await readCounter(db);
+		},
+		getCount: async (ctx) => {
+			const db = ctx.sql as SqliteDatabase;
+			await ensureCounterTable(db);
+
+			return await readCounter(db);
+		},
+		getLifecycleCounts: async (ctx) => {
+			return await readLifecycleCounts(ctx.sql as SqliteDatabase);
+		},
+		triggerSleep: (ctx) => {
+			ctx.sleep();
+		},
+	},
+	options: {
+		sleepTimeout: 100,
+	},
+});
+
+export const platformSqliteCounterActors = {
+	sqliteCounter: sqliteCounterActor,
+};
+
+type PlatformSqliteCounterActors = typeof platformSqliteCounterActors;
+
+export type PlatformSqliteCounterRegistryOptions = Omit<
+	RegistryConfigInput<PlatformSqliteCounterActors>,
+	"runtime" | "sqlite" | "test" | "use" | "wasm"
+> & {
+	bindings: WasmRuntimeBindings;
+	initInput?: WasmRuntimeInitInput;
+};
+
+export function createPlatformSqliteCounterRegistry({
+	bindings,
+	initInput,
+	...config
+}: PlatformSqliteCounterRegistryOptions) {
+	return setup({
+		...config,
+		runtime: "wasm",
+		sqlite: "remote",
+		wasm: {
+			bindings,
+			initInput,
+		},
+		use: platformSqliteCounterActors,
+	});
+}
+
+export type PlatformSqliteCounterRegistry = ReturnType<
+	typeof createPlatformSqliteCounterRegistry
+>;
diff --git a/rivetkit-typescript/packages/rivetkit/tests/platforms/supabase-functions.test.ts b/rivetkit-typescript/packages/rivetkit/tests/platforms/supabase-functions.test.ts
new file mode 100644
index 0000000000..d5bcdc6517
--- /dev/null
+++ b/rivetkit-typescript/packages/rivetkit/tests/platforms/supabase-functions.test.ts
@@ -0,0 +1,707 @@
+import { randomUUID } from "node:crypto";
+import {
+	cpSync,
+	existsSync,
+	mkdirSync,
+	mkdtempSync,
+	readFileSync,
+	realpathSync,
+	rmSync,
+	writeFileSync,
+} from "node:fs";
+import { networkInterfaces, tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { getEnginePath } from "@rivetkit/engine-cli";
+import getPort from "get-port";
+import { describe, expect, test } from "vitest";
+import {
+	buildPlatformSqliteCounterRegistrySource,
+	createPlatformServerlessRunner,
+	createPlatformSqliteCounterClient,
+	createTempPlatformApp,
+	type LoggedChild,
+	linkWorkspacePackage,
+	PLATFORM_TEST_TOKEN,
+	spawnLoggedChild,
+	spawnPinnedPnpmDlx,
+	type TempPlatformApp,
+	waitForHttpOk,
+} from "./shared-platform-harness";
+
+const SUPABASE_VERSION = "2.95.4";
+const TEST_DIR = dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = resolve(TEST_DIR, "../../../../..");
+const REPO_ENGINE_BINARY = resolve(REPO_ROOT, "target/debug/rivet-engine");
+const RIVETKIT_PACKAGE_DIR = resolve(
+	REPO_ROOT,
+	"rivetkit-typescript/packages/rivetkit",
+);
+
+interface SupabaseTestEngine {
+	endpoint: string;
+	publicEndpoint: string;
+	pid: number;
+	dbRoot: string;
+	process: LoggedChild;
+	stop(): Promise<void>;
+}
+
+function resolveEngineBinaryPath(): string {
+	if (existsSync(REPO_ENGINE_BINARY)) {
+		return REPO_ENGINE_BINARY;
+	}
+
+	return getEnginePath();
+}
+
+function resolveDockerHost(): string {
+	const docker0Address = networkInterfaces().docker0?.find(
+		(address) => address.family === "IPv4",
+	)?.address;
+
+	return docker0Address ?? "host.docker.internal";
+}
+
+async function startSupabaseTestEngine(): Promise<SupabaseTestEngine> {
+	const host = "127.0.0.1";
+	const guardPort = await getPort({ host });
+	const apiPeerPort = await getPort({
+		host,
+		exclude: [guardPort],
+	});
+	const metricsPort = await getPort({
+		host,
+		exclude: [guardPort, apiPeerPort],
+	});
+	const endpoint = `http://${host}:${guardPort}`;
+	const publicEndpoint = `http://${resolveDockerHost()}:${guardPort}`;
+	const dbRoot = mkdtempSync(join(tmpdir(), "rivetkit-supabase-engine-"));
+	const configPath = join(dbRoot, "config.json");
+	writeFileSync(
+		configPath,
+		JSON.stringify({
+			topology: {
+				datacenter_label: 1,
+				datacenters: {
+					default: {
+						datacenter_label: 1,
+						is_leader: true,
+						public_url: publicEndpoint,
+						peer_url: `http://${host}:${apiPeerPort}`,
+					},
+				},
+			},
+		}),
+	);
+
+	const engineProcess = spawnLoggedChild({
+		label: "supabase-engine",
+		command: resolveEngineBinaryPath(),
+		args: ["start", "--config", configPath],
+		options: {
+			env: {
+				...process.env,
+				RIVET__GUARD__HOST: "0.0.0.0",
+				RIVET__GUARD__PORT: guardPort.toString(),
+				RIVET__API_PEER__HOST: host,
+				RIVET__API_PEER__PORT: apiPeerPort.toString(),
+				RIVET__METRICS__HOST: host,
+				RIVET__METRICS__PORT: metricsPort.toString(),
+				RIVET__FILE_SYSTEM__PATH: join(dbRoot, "db"),
+			},
+		},
+	});
+	await waitForHttpOk({
+		url: `${endpoint}/health`,
+		child: engineProcess.child,
+		getOutput: engineProcess.getOutput,
+		timeoutMs: 90_000,
+	});
+
+	if (engineProcess.child.pid === undefined) {
+		await engineProcess.stop();
+		rmSync(dbRoot, { force: true, recursive: true });
+		throw new Error("Supabase test engine started without a pid");
+	}
+
+	return {
+		endpoint,
+		publicEndpoint,
+		pid: engineProcess.child.pid,
+		dbRoot,
+		process: engineProcess,
+		stop: async () => {
+			await engineProcess.stop();
+			rmSync(dbRoot, { force: true, recursive: true });
+		},
+	};
+}
+
+function packagePathParts(packageName: string): string[] {
+	return packageName.split("/");
+}
+
+function resolvePackageSource(
+	packageName: string,
+	fromDir = resolve(RIVETKIT_PACKAGE_DIR, "node_modules"),
+): string {
+	if (packageName === "rivetkit") {
+		return RIVETKIT_PACKAGE_DIR;
+	}
+
+	const packagePath = resolve(fromDir, ...packagePathParts(packageName));
+	if (existsSync(packagePath)) {
+		return realpathSync(packagePath);
+	}
+
+	const parentPath = resolve(fromDir, "..", ...packagePathParts(packageName));
+	if (existsSync(parentPath)) {
+		return realpathSync(parentPath);
+	}
+
+	throw new Error(`unable to resolve package ${packageName} from ${fromDir}`);
+}
+
+function copyPackageTree(
+	destinationNodeModules: string,
+	packageName: string,
+	seen: Set<string>,
+	fromDir?: string,
+	includeDependencies = true,
+) {
+	if (seen.has(packageName)) return;
+	seen.add(packageName);
+
+	const source = resolvePackageSource(packageName, fromDir);
+	const destination = resolve(
+		destinationNodeModules,
+		...packagePathParts(packageName),
+	);
+	mkdirSync(dirname(destination), { recursive: true });
+	rmSync(destination, { force: true, recursive: true });
+	cpSync(source, destination, {
+		dereference: true,
+		filter: (path) =>
+			!path.startsWith(resolve(source, "node_modules")) &&
+			!path.includes("/.git/") &&
+			!path.endsWith(".map"),
+		recursive: true,
+	});
+
+	const packageJson = JSON.parse(
+		readFileSync(resolve(source, "package.json"), "utf8"),
+	) as { dependencies?: Record<string, string> };
+	if (!includeDependencies) return;
+
+	for (const dependency of Object.keys(packageJson.dependencies ?? {})) {
+		copyPackageTree(destinationNodeModules, dependency, seen, source);
+	}
+}
+
+function copySupabaseFunctionPackages(app: TempPlatformApp) {
+	const destinationNodeModules = resolve(
+		app.path,
+		"supabase/functions/rivet/node_modules",
+	);
+	mkdirSync(destinationNodeModules, { recursive: true });
+
+	const seen = new Set<string>();
+	for (const packageName of [
+		"@rivetkit/rivetkit-wasm",
+		"@rivetkit/virtual-websocket",
+		"@rivetkit/bare-ts",
+		"cbor-x",
+		"hono",
+		"invariant",
+		"p-retry",
+		"pino",
+		"rivetkit",
+		"vbare",
+		"zod",
+	]) {
+		copyPackageTree(
+			destinationNodeModules,
+			packageName,
+			seen,
+			undefined,
+			packageName !== "rivetkit",
+		);
+	}
+}
+
+function writeSupabaseFunctionApp(
+	app: TempPlatformApp,
+	{
+		apiPort,
+		dbPort,
+		endpoint,
+		publicEndpoint,
+		namespace,
+		runnerName,
+		token,
+	}: {
+		apiPort: number;
+		dbPort: number;
+		endpoint: string;
+		publicEndpoint: string;
+		namespace: string;
+		runnerName: string;
+		token: string;
+	},
+) {
+	linkWorkspacePackage(
+		app,
+		"rivetkit",
+		resolve(REPO_ROOT, "rivetkit-typescript/packages/rivetkit"),
+	);
+	linkWorkspacePackage(
+		app,
+		"@rivetkit/rivetkit-wasm",
+		resolve(REPO_ROOT, "rivetkit-typescript/packages/rivetkit-wasm"),
+	);
+
+	app.writeFile(
+		"package.json",
+		JSON.stringify(
+			{
+				type: "module",
+				dependencies: {
+					"@rivetkit/rivetkit-wasm": "workspace:*",
+					rivetkit: "workspace:*",
+				},
+			},
+			null,
+			2,
+		),
+	);
+	app.writeFile(
+		"supabase/config.toml",
+		`
+project_id = "rivetkit-platform-${randomUUID()}"
+
+[api]
+port = ${apiPort}
+schemas = ["public"]
+extra_search_path = ["public", "extensions"]
+max_rows = 1000
+
+[db]
+port = ${dbPort}
+shadow_port = ${dbPort + 1}
+major_version = 15
+
+[studio]
+port = ${dbPort + 2}
+
+[inbucket]
+port = ${dbPort + 3}
+
+[edge_runtime]
+policy = "per_worker"
+`,
+	);
+	app.writeFile(
+		"supabase/functions/rivet/registry.ts",
+		buildPlatformSqliteCounterRegistrySource("deno-read-file"),
+	);
+	app.writeFile(
+		"supabase/functions/rivet/index.ts",
+		`
+import { createRegistry } from "./registry.ts";
+
+const SERVERLESS_BASE_PATH = "/rivet/api/rivet";
+
+const registry = createRegistry({
+	endpoint: "${endpoint}",
+	namespace: "${namespace}",
+	token: "${token}",
+	runnerName: "${runnerName}",
+	serverless: {
+		basePath: SERVERLESS_BASE_PATH,
+		publicEndpoint: "${publicEndpoint}",
+	},
+});
+
+Deno.serve(async (request) => {
+	const pathname = new URL(request.url).pathname;
+	console.log(\`\${request.method} \${pathname}\`);
+	if (pathname.endsWith("/health")) {
+		return new Response("ok");
+	}
+
+	return await registry.handler(request);
+});
+`,
+	);
+	app.writeFile(
+		"supabase/functions/rivet/package.json",
+		JSON.stringify(
+			{
+				type: "module",
+				dependencies: {
+					"@rivetkit/rivetkit-wasm": "workspace:*",
+					rivetkit: "workspace:*",
+				},
+			},
+			null,
+			2,
+		),
+	);
+	copySupabaseFunctionPackages(app);
+}
+
+function waitForChildExit(
+	child: LoggedChild,
+	timeoutMs: number,
+): Promise<void> {
+	return new Promise((resolveWait, rejectWait) => {
+		const timeout = setTimeout(() => {
+			void child.stop("SIGKILL", 1_000).finally(() => {
+				rejectWait(
+					new Error(
+						`platform command timed out:\n${child.getOutput()}`,
+					),
+				);
+			});
+		}, timeoutMs);
+
+		child.child.once("exit", (code, signal) => {
+			clearTimeout(timeout);
+			if (code === 0) {
+				resolveWait();
+				return;
+			}
+
+			rejectWait(
+				new Error(
+					`platform command failed with code ${code ?? signal}:\n${child.getOutput()}`,
+				),
+			);
+		});
+	});
+}
+
+async function runSupabaseCli(
+	label: string,
+	app: TempPlatformApp,
+	args: string[],
+	timeoutMs: number,
+) {
+	const command = spawnPinnedPnpmDlx({
+		label,
+		packageName: "supabase",
+		packageVersion: SUPABASE_VERSION,
+		args,
+		options: {
+			cwd: app.path,
+			env: {
+				...process.env,
+				NO_COLOR: "1",
+			},
+		},
+	});
+	await waitForChildExit(command, timeoutMs);
+}
+
+async function waitForRunnerMetadata(url: string, platform: LoggedChild) {
+	const deadline = Date.now() + 30_000;
+	let bodyText = "";
+
+	while (Date.now() < deadline) {
+		const response = await fetch(url);
+		bodyText = await response.text();
+		if (response.ok) {
+			const body = JSON.parse(bodyText) as {
+				envoy?: { version?: number } | null;
+				envoyProtocolVersion?: number | null;
+			};
+			if (body.envoy?.version && body.envoyProtocolVersion != null) {
+				return;
+			}
+		}
+		await new Promise((resolveWait) => setTimeout(resolveWait, 250));
+	}
+
+	throw new Error(
+		`serverless metadata did not expose envoy metadata: ${bodyText}\n${platform.getOutput()}`,
+	);
+}
+
+async function waitForRunnerConfigReady({
+	endpoint,
+	namespace,
+	runnerName,
+	token,
+}: {
+	endpoint: string;
+	namespace: string;
+	runnerName: string;
+	token: string;
+}) {
+	const deadline = Date.now() + 30_000;
+	let bodyText = "";
+
+	while (Date.now() < deadline) {
+		const response = await fetch(
+			`${endpoint}/runner-configs?namespace=${encodeURIComponent(namespace)}&runner_name=${encodeURIComponent(runnerName)}`,
+			{
+				headers: {
+					Authorization: `Bearer ${token}`,
+				},
+			},
+		);
+		bodyText = await response.text();
+		if (response.ok) {
+			const body = JSON.parse(bodyText) as {
+				runner_configs?: Record<
+					string,
+					{
+						datacenters?: Record<
+							string,
+							{
+								protocol_version?: number | null;
+								serverless?: unknown;
+							}
+						>;
+					}
+				>;
+			};
+			const config = body.runner_configs?.[runnerName];
+			const datacenters = Object.values(config?.datacenters ?? {});
+			if (
+				datacenters.length > 0 &&
+				datacenters.every(
+					(datacenter) => datacenter.protocol_version != null,
+				)
+			) {
+				return;
+			}
+		}
+		await new Promise((resolveWait) => setTimeout(resolveWait, 250));
+	}
+
+	throw new Error(`serverless runner config was not ready: ${bodyText}`);
+}
+
+async function waitForSupabaseStartRequest(supabase: LoggedChild) {
+	const deadline = Date.now() + 75_000;
+
+	while (Date.now() < deadline) {
+		if (
+			supabase.getOutput().includes("GET /start") ||
+			supabase.getOutput().includes("GET /rivet/api/rivet/start") ||
+			supabase.getOutput().includes("POST /rivet/api/rivet/start") ||
+			supabase
+				.getOutput()
+				.includes("GET /functions/v1/rivet/api/rivet/start") ||
+			supabase
+				.getOutput()
+				.includes("POST /functions/v1/rivet/api/rivet/start")
+		) {
+			return;
+		}
+		await new Promise((resolveWait) => setTimeout(resolveWait, 250));
+	}
+
+	throw new Error(
+		`timed out waiting for Supabase Functions start request:\n${supabase.getOutput()}`,
+	);
+}
+
+function isColdStartCapacityError(error: unknown): boolean {
+	const message = error instanceof Error ? error.message : String(error);
+	const code =
+		error && typeof error === "object" && "code" in error
+			? String((error as { code: unknown }).code)
+			: "";
+	return (
+		code === "service_unavailable" ||
+		message.includes("actor_ready_timeout") ||
+		message.includes("no_capacity") ||
+		message.includes("request_timeout") ||
+		message.includes("service_unavailable")
+	);
+}
+
+async function runAfterColdStart<T>(
+	supabase: LoggedChild,
+	run: () => Promise<T>,
+): Promise<T> {
+	const deadline = Date.now() + 30_000;
+	const firstRequest = run().then(
+		(value) => ({ ok: true as const, value }),
+		(error: unknown) => ({ ok: false as const, error }),
+	);
+	await Promise.race([
+		firstRequest,
+		waitForSupabaseStartRequest(supabase).then(() => undefined),
+	]);
+	const firstResult = await firstRequest;
+	if (firstResult.ok) {
+		return firstResult.value;
+	}
+	if (!isColdStartCapacityError(firstResult.error)) {
+		throw firstResult.error;
+	}
+
+	let lastError = firstResult.error;
+	while (Date.now() < deadline) {
+		await delay(500);
+		try {
+			return await run();
+		} catch (error) {
+			if (!isColdStartCapacityError(error)) {
+				throw error;
+			}
+			lastError = error;
+		}
+	}
+
+	throw lastError;
+}
+
+async function delay(ms: number) {
+	await new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+describe("Supabase Functions wasm platform smoke", () => {
+	test("runs the shared SQLite counter registry through local Supabase Functions", async () => {
+		const engine = await startSupabaseTestEngine();
+		let app: TempPlatformApp | undefined;
+		let supabase: LoggedChild | undefined;
+
+		try {
+			const apiPort = await getPort();
+			const dbPort = await getPort();
+			const supabaseOrigin = `http://127.0.0.1:${apiPort}`;
+			const serverlessBasePath = "/functions/v1/rivet/api/rivet";
+			const serverlessUrl = `${supabaseOrigin}${serverlessBasePath}`;
+			const namespace = `supabase-${randomUUID()}`;
+			const runnerName = `supabase-${randomUUID()}`;
+
+			app = createTempPlatformApp({}, "rivetkit-supabase-");
+			writeSupabaseFunctionApp(app, {
+				apiPort,
+				dbPort,
+				endpoint: engine.publicEndpoint,
+				publicEndpoint: engine.endpoint,
+				namespace,
+				runnerName,
+				token: PLATFORM_TEST_TOKEN,
+			});
+			await runSupabaseCli(
+				"supabase-start",
+				app,
+				[
+					"start",
+					"-x",
+					[
+						"gotrue",
+						"realtime",
+						"storage-api",
+						"imgproxy",
+						"mailpit",
+						"postgrest",
+						"postgres-meta",
+						"studio",
+						"edge-runtime",
+						"logflare",
+						"vector",
+						"supavisor",
+					].join(","),
+					"--ignore-health-check",
+				],
+				180_000,
+			);
+			supabase = spawnPinnedPnpmDlx({
+				label: "supabase-functions",
+				packageName: "supabase",
+				packageVersion: SUPABASE_VERSION,
+				args: ["functions", "serve", "--no-verify-jwt"],
+				options: {
+					cwd: app.path,
+					env: {
+						...process.env,
+						NO_COLOR: "1",
+					},
+				},
+			});
+			await waitForHttpOk({
+				url: `${supabaseOrigin}/functions/v1/rivet/health`,
+				child: supabase.child,
+				getOutput: supabase.getOutput,
+				timeoutMs: 90_000,
+			});
+			const runner = await createPlatformServerlessRunner({
+				engine,
+				namespace,
+				runnerName,
+				serverlessUrl,
+			});
+			await waitForRunnerMetadata(`${serverlessUrl}/metadata`, supabase);
+			await waitForRunnerConfigReady({
+				endpoint: engine.endpoint,
+				namespace,
+				runnerName,
+				token: PLATFORM_TEST_TOKEN,
+			});
+			const actorKey = `counter-${randomUUID()}`;
+
+			const client = createPlatformSqliteCounterClient(runner);
+			const actor = client.sqliteCounter.getOrCreate([actorKey]);
+
+			expect(
+				await runAfterColdStart(supabase, () => actor.increment(2)),
+			).toBe(2);
+			expect(await actor.increment(3)).toBe(5);
+			expect(await actor.getCount()).toBe(5);
+
+			const beforeSleep = await actor.getLifecycleCounts();
+			expect(beforeSleep.wakeCount).toBeGreaterThanOrEqual(1);
+			await delay(1_500);
+
+			expect(
+				await runAfterColdStart(supabase, () => actor.getCount()),
+			).toBe(5);
+			const afterWake = await actor.getLifecycleCounts();
+			expect(afterWake.wakeCount).toBeGreaterThanOrEqual(
+				beforeSleep.wakeCount + 1,
+			);
+
+			const parallelActors = [1, 2, 3].map((amount) =>
+				client.sqliteCounter.getOrCreate([
+					`parallel-${amount}-${randomUUID()}`,
+				]),
+			);
+			await expect(
+				Promise.all(
+					parallelActors.map((parallelActor, index) =>
+						parallelActor.increment(index + 1),
+					),
+				),
+			).resolves.toEqual([1, 2, 3]);
+			await expect(
+				Promise.all(
+					parallelActors.map((parallelActor) =>
+						parallelActor.getCount(),
+					),
+				),
+			).resolves.toEqual([1, 2, 3]);
+		} finally {
+			await supabase?.stop();
+			if (app) {
+				try {
+					await runSupabaseCli(
+						"supabase-stop",
+						app,
+						["stop", "--no-backup"],
+						60_000,
+					);
+				} catch {}
+			}
+			app?.cleanup();
+			await engine.stop();
+		}
+	}, 240_000);
+});
diff --git a/rivetkit-typescript/packages/rivetkit/tests/runtime-import-guard.test.ts b/rivetkit-typescript/packages/rivetkit/tests/runtime-import-guard.test.ts
new file mode 100644
index 0000000000..ef83d223de
--- /dev/null
+++ b/rivetkit-typescript/packages/rivetkit/tests/runtime-import-guard.test.ts
@@ -0,0 +1,52 @@
+import { readdir, readFile } from "node:fs/promises";
+import { join, relative } from "node:path";
+import { describe, expect, test } from "vitest";
+
+const PACKAGE_ROOT = join(import.meta.dirname, "..");
+const ALLOWED_BINDING_IMPORTS = new Set([
+	"src/registry/napi-runtime.ts",
+	"src/registry/wasm-runtime.ts",
+]);
+const SELF = "tests/runtime-import-guard.test.ts";
+const BINDING_IMPORT_PATTERN =
+	/@rivetkit\/rivetkit-(?:napi|wasm)|import\(\s*\[\s*["']@rivetkit["']\s*,\s*["']rivetkit-(?:napi|wasm)["']\s*\]/;
+
+async function collectTypeScriptFiles(dir: string): Promise<string[]> {
+	const entries = await readdir(dir, { withFileTypes: true });
+	const files = await Promise.all(
+		entries.map(async (entry) => {
+			const path = join(dir, entry.name);
+			if (entry.isDirectory()) {
+				if (entry.name === "node_modules" || entry.name === "dist") {
+					return [];
+				}
+				return await collectTypeScriptFiles(path);
+			}
+			if (!entry.name.endsWith(".ts") && !entry.name.endsWith(".tsx")) {
+				return [];
+			}
+			return [path];
+		}),
+	);
+	return files.flat();
+}
+
+describe("core runtime binding imports", () => {
+	test("keeps raw native and wasm binding imports behind runtime adapters", async () => {
+		const files = await collectTypeScriptFiles(PACKAGE_ROOT);
+		const violations: string[] = [];
+
+		for (const file of files) {
+			const rel = relative(PACKAGE_ROOT, file);
+			if (rel === SELF || ALLOWED_BINDING_IMPORTS.has(rel)) {
+				continue;
+			}
+
+			if (BINDING_IMPORT_PATTERN.test(await readFile(file, "utf8"))) {
+				violations.push(rel);
+			}
+		}
+
+		expect(violations).toEqual([]);
+	});
+});
diff --git a/rivetkit-typescript/packages/rivetkit/tests/runtime-selection.test.ts b/rivetkit-typescript/packages/rivetkit/tests/runtime-selection.test.ts
new file mode 100644
index 0000000000..56ca3d9476
--- /dev/null
+++ b/rivetkit-typescript/packages/rivetkit/tests/runtime-selection.test.ts
@@ -0,0 +1,252 @@
+import { afterEach, describe, expect, test } from "vitest";
+import { actor } from "@/actor/mod";
+import { type RegistryConfig, RegistryConfigSchema } from "@/registry/config";
+import {
+	loadConfiguredRuntime,
+	normalizeRuntimeConfig,
+	normalizeRuntimeConfigForKind,
+	type RuntimeLoaders,
+} from "@/registry/native";
+import type { CoreRuntime } from "@/registry/runtime";
+
+const previousRuntimeEnv = process.env.RIVETKIT_RUNTIME;
+
+const testActor = actor({
+	state: {},
+	actions: {},
+});
+
+function parseConfig(input: Record<string, unknown> = {}) {
+	return RegistryConfigSchema.parse({
+		use: { test: testActor },
+		startEngine: false,
+		...input,
+	});
+}
+
+function fakeRuntime(kind: CoreRuntime["kind"]): CoreRuntime {
+	return { kind } as CoreRuntime;
+}
+
+function fakeLoaders(options: {
+	nativeRuntime?: CoreRuntime;
+	wasmRuntime?: CoreRuntime;
+	nativeError?: Error;
+	host?: "node-like" | "edge-like";
+	onLoadWasm?: (config: RegistryConfig["wasm"] | undefined) => void;
+	onLoadNative?: () => void;
+}): RuntimeLoaders {
+	return {
+		detectHost: () => options.host ?? "node-like",
+		loadNative: async () => {
+			options.onLoadNative?.();
+			if (options.nativeError) {
+				throw options.nativeError;
+			}
+			return {
+				bindings: {},
+				runtime: options.nativeRuntime ?? fakeRuntime("napi"),
+			} as Awaited<ReturnType<RuntimeLoaders["loadNative"]>>;
+		},
+		loadWasm: async (config) => {
+			options.onLoadWasm?.(config);
+			return {
+				bindings: {},
+				runtime: options.wasmRuntime ?? fakeRuntime("wasm"),
+			} as Awaited<ReturnType<RuntimeLoaders["loadWasm"]>>;
+		},
+	};
+}
+
+describe("runtime selection", () => {
+	afterEach(() => {
+		if (previousRuntimeEnv === undefined) {
+			delete process.env.RIVETKIT_RUNTIME;
+		} else {
+			process.env.RIVETKIT_RUNTIME = previousRuntimeEnv;
+		}
+	});
+
+	test("config runtime wins over env runtime", async () => {
+		process.env.RIVETKIT_RUNTIME = "wasm";
+		const nativeRuntime = fakeRuntime("napi");
+
+		const runtime = await loadConfiguredRuntime(
+			parseConfig({ runtime: "native" }),
+			fakeLoaders({ nativeRuntime }),
+		);
+
+		expect(runtime).toBe(nativeRuntime);
+	});
+
+	test("env selects wasm when config omits runtime", async () => {
+		process.env.RIVETKIT_RUNTIME = "wasm";
+		const wasmRuntime = fakeRuntime("wasm");
+
+		const runtime = await loadConfiguredRuntime(
+			parseConfig(),
+			fakeLoaders({ wasmRuntime }),
+		);
+
+		expect(runtime).toBe(wasmRuntime);
+	});
+
+	test("rejects invalid RIVETKIT_RUNTIME values", () => {
+		process.env.RIVETKIT_RUNTIME = "bad-runtime";
+
+		expect(() => parseConfig()).toThrow(
+			/RIVETKIT_RUNTIME must be one of auto, native, or wasm/,
+		);
+	});
+
+	test("auto selects native in Node-like runtimes", async () => {
+		const nativeRuntime = fakeRuntime("napi");
+
+		const runtime = await loadConfiguredRuntime(
+			parseConfig({ runtime: "auto" }),
+			fakeLoaders({ host: "node-like", nativeRuntime }),
+		);
+
+		expect(runtime).toBe(nativeRuntime);
+	});
+
+	test("auto falls back to wasm when native import fails", async () => {
+		const wasmRuntime = fakeRuntime("wasm");
+
+		const runtime = await loadConfiguredRuntime(
+			parseConfig({ runtime: "auto" }),
+			fakeLoaders({
+				host: "node-like",
+				nativeError: new Error("native unavailable"),
+				wasmRuntime,
+			}),
+		);
+
+		expect(runtime).toBe(wasmRuntime);
+	});
+
+	test("auto selects wasm in edge-like runtimes", async () => {
+		const wasmRuntime = fakeRuntime("wasm");
+		let nativeLoads = 0;
+
+		const runtime = await loadConfiguredRuntime(
+			parseConfig({ runtime: "auto" }),
+			fakeLoaders({
+				host: "edge-like",
+				wasmRuntime,
+				onLoadNative: () => {
+					nativeLoads += 1;
+				},
+			}),
+		);
+
+		expect(runtime).toBe(wasmRuntime);
+		expect(nativeLoads).toBe(0);
+	});
+
+	test("passes explicit wasm init input to the wasm loader", async () => {
+		const initInput = new Uint8Array([0, 1, 2]);
+		let observedInitInput: unknown;
+
+		await loadConfiguredRuntime(
+			parseConfig({ runtime: "wasm", wasm: { initInput } }),
+			fakeLoaders({
+				onLoadWasm: (config) => {
+					observedInitInput = config?.initInput;
+				},
+			}),
+		);
+
+		expect(observedInitInput).toBe(initInput);
+	});
+
+	test("passes configured wasm bindings to the wasm loader", async () => {
+		const bindings = { default: async () => {} };
+		let observedBindings: unknown;
+
+		await loadConfiguredRuntime(
+			parseConfig({ runtime: "wasm", wasm: { bindings } }),
+			fakeLoaders({
+				onLoadWasm: (config) => {
+					observedBindings = config?.bindings;
+				},
+			}),
+		);
+
+		expect(observedBindings).toBe(bindings);
+	});
+
+	test("wasm defaults SQLite to remote when SQLite is unset", () => {
+		const config = parseConfig({ runtime: "wasm" });
+		const normalized = normalizeRuntimeConfigForKind(config, "wasm");
+
+		expect(config.sqlite?.backend).toBe("remote");
+		expect(normalized.test.sqliteBackend).toBe("remote");
+	});
+
+	test("wasm allows explicit remote SQLite", () => {
+		const config = parseConfig({
+			runtime: "wasm",
+			sqlite: "remote",
+		});
+		const normalized = normalizeRuntimeConfigForKind(config, "wasm");
+
+		expect(config.sqlite?.backend).toBe("remote");
+		expect(normalized.test.sqliteBackend).toBe("remote");
+	});
+
+	test("wasm rejects explicit local SQLite during setup config parsing", () => {
+		expect(() =>
+			parseConfig({
+				runtime: "wasm",
+				sqlite: "local",
+			}),
+		).toThrow(/WebAssembly runtime cannot use local SQLite/);
+	});
+
+	test("native keeps SQLite default unset and allows local or remote SQLite", () => {
+		expect(parseConfig({ runtime: "native" }).sqlite).toBeUndefined();
+		expect(
+			normalizeRuntimeConfigForKind(
+				parseConfig({ runtime: "native", sqlite: "local" }),
+				"native",
+			).sqlite?.backend,
+		).toBe("local");
+		expect(
+			normalizeRuntimeConfigForKind(
+				parseConfig({ runtime: "native", sqlite: "remote" }),
+				"native",
+			).sqlite?.backend,
+		).toBe("remote");
+	});
+
+	test("normalizes plain object NAPI runtime fakes as native", () => {
+		const config = parseConfig({
+			runtime: "native",
+			test: { sqliteBackend: "local" },
+		});
+		const normalized = normalizeRuntimeConfig(config, fakeRuntime("napi"));
+
+		expect(normalized.test.sqliteBackend).toBe("local");
+	});
+
+	test("normalizes plain object wasm runtime fakes as wasm", () => {
+		const normalized = normalizeRuntimeConfig(
+			parseConfig({ runtime: "wasm" }),
+			fakeRuntime("wasm"),
+		);
+
+		expect(normalized.test.sqliteBackend).toBe("remote");
+	});
+
+	test("wasm rejects local SQLite", () => {
+		const config = parseConfig({
+			runtime: "auto",
+			test: { sqliteBackend: "local" },
+		});
+
+		expect(() => normalizeRuntimeConfigForKind(config, "wasm")).toThrow(
+			/WebAssembly runtime cannot use local SQLite/,
+		);
+	});
+});
diff --git a/rivetkit-typescript/packages/rivetkit/tests/shared-engine.ts b/rivetkit-typescript/packages/rivetkit/tests/shared-engine.ts
new file mode 100644
index 0000000000..5ad91665a2
--- /dev/null
+++ b/rivetkit-typescript/packages/rivetkit/tests/shared-engine.ts
@@ -0,0 +1,408 @@
+import { type ChildProcess, spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import {
+	existsSync,
+	mkdirSync,
+	mkdtempSync,
+	readFileSync,
+	rmSync,
+	statSync,
+	unlinkSync,
+	writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { getEnginePath } from "@rivetkit/engine-cli";
+import getPort from "get-port";
+
+const TEST_DIR = dirname(fileURLToPath(import.meta.url));
+const REPO_ENGINE_BINARY = join(
+	TEST_DIR,
+	"../../../../target/debug/rivet-engine",
+);
+const TIMING_ENABLED = process.env.RIVETKIT_DRIVER_TEST_TIMING === "1";
+const ENGINE_STATE_ID = createHash("sha256")
+	.update(TEST_DIR)
+	.digest("hex")
+	.slice(0, 16);
+const ENGINE_START_LOCK_DIR = join(
+	tmpdir(),
+	`rivetkit-driver-engine-${ENGINE_STATE_ID}.lock`,
+);
+const ENGINE_STATE_PATH = join(
+	tmpdir(),
+	`rivetkit-driver-engine-${ENGINE_STATE_ID}.json`,
+);
+const ENGINE_START_LOCK_STALE_MS = 120_000;
+
+interface RuntimeLogs {
+	stdout: string;
+	stderr: string;
+}
+
+export const TEST_ENGINE_TOKEN = "dev";
+
+export interface SharedTestEngine {
+	endpoint: string;
+	pid: number;
+	dbRoot: string;
+}
+
+interface SharedEngineState extends SharedTestEngine {
+	refs: number;
+}
+
+let sharedEnginePromise: Promise<SharedTestEngine> | undefined;
+let sharedEngineRefAcquired = false;
+
+function childOutput(logs: RuntimeLogs): string {
+	return [logs.stdout, logs.stderr].filter(Boolean).join("\n");
+}
+
+function timing(
+	label: string,
+	startedAt: number,
+	fields: Record<string, string> = {},
+) {
+	if (!TIMING_ENABLED) {
+		return;
+	}
+
+	const fieldText = Object.entries(fields)
+		.map(([key, value]) => `${key}=${value}`)
+		.join(" ");
+	console.log(
+		`DRIVER_TIMING ${label} ms=${Math.round(performance.now() - startedAt)}${fieldText ? ` ${fieldText}` : ""}`,
+	);
+}
+
+function resolveEngineBinaryPath(): string {
+	if (existsSync(REPO_ENGINE_BINARY)) {
+		return REPO_ENGINE_BINARY;
+	}
+
+	return getEnginePath();
+}
+
+async function acquireEngineStartLock(): Promise<() => void> {
+	const startedAt = performance.now();
+
+	while (true) {
+		try {
+			mkdirSync(ENGINE_START_LOCK_DIR);
+			timing("engine.start_lock", startedAt);
+			return () => {
+				rmSync(ENGINE_START_LOCK_DIR, { force: true, recursive: true });
+			};
+		} catch (error) {
+			const code = (error as NodeJS.ErrnoException).code;
+			if (code !== "EEXIST") {
+				throw error;
+			}
+
+			try {
+				const stat = statSync(ENGINE_START_LOCK_DIR);
+				if (Date.now() - stat.mtimeMs > ENGINE_START_LOCK_STALE_MS) {
+					rmSync(ENGINE_START_LOCK_DIR, {
+						force: true,
+						recursive: true,
+					});
+					continue;
+				}
+			} catch {}
+
+			await new Promise((resolve) => setTimeout(resolve, 50));
+		}
+	}
+}
+
+async function waitForEngineHealth(
+	child: ChildProcess,
+	logs: RuntimeLogs,
+	endpoint: string,
+	timeoutMs: number,
+): Promise<void> {
+	const deadline = Date.now() + timeoutMs;
+
+	while (Date.now() < deadline) {
+		if (child.exitCode !== null) {
+			throw new Error(
+				`shared engine exited before health check passed:\n${childOutput(logs)}`,
+			);
+		}
+
+		try {
+			const response = await fetch(`${endpoint}/health`);
+			if (response.ok) {
+				return;
+			}
+		} catch {}
+
+		await new Promise((resolve) => setTimeout(resolve, 500));
+	}
+
+	throw new Error(
+		`timed out waiting for shared engine health:\n${childOutput(logs)}`,
+	);
+}
+
+function readSharedEngineState(): SharedEngineState | undefined {
+	try {
+		return JSON.parse(readFileSync(ENGINE_STATE_PATH, "utf8"));
+	} catch {
+		return undefined;
+	}
+}
+
+function writeSharedEngineState(state: SharedEngineState): void {
+	writeFileSync(ENGINE_STATE_PATH, JSON.stringify(state), "utf8");
+}
+
+function removeSharedEngineState(): void {
+	try {
+		unlinkSync(ENGINE_STATE_PATH);
+	} catch {}
+}
+
+function isPidRunning(pid: number): boolean {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+async function isEngineHealthy(endpoint: string): Promise<boolean> {
+	try {
+		const response = await fetch(`${endpoint}/health`);
+		return response.ok;
+	} catch {
+		return false;
+	}
+}
+
+async function stopProcess(
+	child: ChildProcess,
+	signal: NodeJS.Signals,
+	timeoutMs: number,
+): Promise<void> {
+	if (child.exitCode !== null) {
+		return;
+	}
+
+	child.kill(signal);
+
+	await new Promise<void>((resolve) => {
+		const timeout = setTimeout(() => {
+			if (child.exitCode === null) {
+				child.kill("SIGKILL");
+			}
+		}, timeoutMs);
+
+		child.once("exit", () => {
+			clearTimeout(timeout);
+			resolve();
+		});
+	});
+}
+
+async function stopPid(pid: number, timeoutMs: number): Promise<void> {
+	if (!isPidRunning(pid)) {
+		return;
+	}
+
+	process.kill(pid, "SIGTERM");
+
+	const deadline = Date.now() + timeoutMs;
+	while (Date.now() < deadline) {
+		if (!isPidRunning(pid)) {
+			return;
+		}
+		await new Promise((resolve) => setTimeout(resolve, 100));
+	}
+
+	if (isPidRunning(pid)) {
+		process.kill(pid, "SIGKILL");
+	}
+}
+
+async function stopRuntime(child: ChildProcess): Promise<void> {
+	const startedAt = performance.now();
+	await stopProcess(child, "SIGTERM", 1_000);
+	timing("runtime.stop", startedAt);
+}
+
+async function spawnSharedEngine(): Promise<SharedTestEngine> {
+	const startedAt = performance.now();
+	const portStartedAt = performance.now();
+	const host = "127.0.0.1";
+	const guardPort = await getPort({ host });
+	const apiPeerPort = await getPort({
+		host,
+		exclude: [guardPort],
+	});
+	const metricsPort = await getPort({
+		host,
+		exclude: [guardPort, apiPeerPort],
+	});
+	const endpoint = `http://${host}:${guardPort}`;
+	const dbRoot = mkdtempSync(join(tmpdir(), "rivetkit-driver-engine-"));
+	const configPath = join(dbRoot, "config.json");
+	writeFileSync(
+		configPath,
+		JSON.stringify({
+			topology: {
+				datacenter_label: 1,
+				datacenters: {
+					default: {
+						datacenter_label: 1,
+						is_leader: true,
+						public_url: endpoint,
+						peer_url: `http://${host}:${apiPeerPort}`,
+					},
+				},
+			},
+		}),
+	);
+	timing("engine.allocate", portStartedAt, { endpoint });
+
+	const spawnStartedAt = performance.now();
+	const logs: RuntimeLogs = { stdout: "", stderr: "" };
+	const engine = spawn(
+		resolveEngineBinaryPath(),
+		["start", "--config", configPath],
+		{
+			env: {
+				...process.env,
+				RIVET__GUARD__HOST: host,
+				RIVET__GUARD__PORT: guardPort.toString(),
+				RIVET__API_PEER__HOST: host,
+				RIVET__API_PEER__PORT: apiPeerPort.toString(),
+				RIVET__METRICS__HOST: host,
+				RIVET__METRICS__PORT: metricsPort.toString(),
+				RIVET__FILE_SYSTEM__PATH: join(dbRoot, "db"),
+			},
+			stdio: ["ignore", "pipe", "pipe"],
+		},
+	);
+	timing("engine.spawn", spawnStartedAt, { endpoint });
+
+	engine.stdout?.on("data", (chunk) => {
+		const text = chunk.toString();
+		logs.stdout += text;
+		if (process.env.DRIVER_ENGINE_LOGS === "1") {
+			process.stderr.write(`[ENG.OUT] ${text}`);
+		}
+	});
+	engine.stderr?.on("data", (chunk) => {
+		const text = chunk.toString();
+		logs.stderr += text;
+		if (process.env.DRIVER_ENGINE_LOGS === "1") {
+			process.stderr.write(`[ENG.ERR] ${text}`);
+		}
+	});
+
+	try {
+		const healthStartedAt = performance.now();
+		await waitForEngineHealth(engine, logs, endpoint, 90_000);
+		timing("engine.health", healthStartedAt, { endpoint });
+	} catch (error) {
+		await stopRuntime(engine);
+		rmSync(dbRoot, { force: true, recursive: true });
+		throw error;
+	}
+
+	if (engine.pid === undefined) {
+		await stopRuntime(engine);
+		rmSync(dbRoot, { force: true, recursive: true });
+		throw new Error("shared engine started without a pid");
+	}
+
+	const sharedEngine = {
+		endpoint,
+		pid: engine.pid,
+		dbRoot,
+	};
+	timing("engine.start_total", startedAt, { endpoint });
+	return sharedEngine;
+}
+
+export async function getOrStartSharedTestEngine(): Promise<SharedTestEngine> {
+	if (sharedEnginePromise !== undefined) {
+		return sharedEnginePromise;
+	}
+
+	sharedEnginePromise = (async () => {
+		const releaseStartLock = await acquireEngineStartLock();
+		try {
+			const existing = readSharedEngineState();
+			if (
+				existing &&
+				isPidRunning(existing.pid) &&
+				(await isEngineHealthy(existing.endpoint))
+			) {
+				const state = { ...existing, refs: existing.refs + 1 };
+				writeSharedEngineState(state);
+				sharedEngineRefAcquired = true;
+				timing("engine.reuse", performance.now(), {
+					endpoint: existing.endpoint,
+				});
+				return {
+					endpoint: existing.endpoint,
+					pid: existing.pid,
+					dbRoot: existing.dbRoot,
+				};
+			}
+
+			if (existing) {
+				await stopPid(existing.pid, 5_000);
+				rmSync(existing.dbRoot, { force: true, recursive: true });
+				removeSharedEngineState();
+			}
+
+			const engine = await spawnSharedEngine();
+			writeSharedEngineState({ ...engine, refs: 1 });
+			sharedEngineRefAcquired = true;
+			return engine;
+		} catch (error) {
+			sharedEnginePromise = undefined;
+			throw error;
+		} finally {
+			releaseStartLock();
+		}
+	})();
+
+	return sharedEnginePromise;
+}
+
+export async function releaseSharedTestEngine(): Promise<void> {
+	if (!sharedEngineRefAcquired) {
+		return;
+	}
+	sharedEngineRefAcquired = false;
+	sharedEnginePromise = undefined;
+
+	const releaseStartLock = await acquireEngineStartLock();
+	const startedAt = performance.now();
+	try {
+		const state = readSharedEngineState();
+		if (!state) {
+			return;
+		}
+
+		const refs = Math.max(0, state.refs - 1);
+		if (refs > 0) {
+			writeSharedEngineState({ ...state, refs });
+			return;
+		}
+
+		await stopPid(state.pid, 5_000);
+		rmSync(state.dbRoot, { force: true, recursive: true });
+		removeSharedEngineState();
+		timing("engine.stop", startedAt, { endpoint: state.endpoint });
+	} finally {
+		releaseStartLock();
+	}
+}
diff --git a/rivetkit-typescript/packages/rivetkit/tests/wasm-host-smoke.test.ts b/rivetkit-typescript/packages/rivetkit/tests/wasm-host-smoke.test.ts
new file mode 100644
index 0000000000..3b985d18f4
--- /dev/null
+++ b/rivetkit-typescript/packages/rivetkit/tests/wasm-host-smoke.test.ts
@@ -0,0 +1,518 @@
+import { describe, expect, test } from "vitest";
+import { actor } from "@/actor/definition";
+import { type RegistryConfig, RegistryConfigSchema } from "@/registry/config";
+import { buildNativeFactory } from "@/registry/native";
+import type { RuntimeServeConfig } from "@/registry/runtime";
+import { type WasmBindings, WasmCoreRuntime } from "@/registry/wasm-runtime";
+import { decodeCborCompat, encodeCborCompat } from "@/serde";
+
+type HostKind = "supabase-deno" | "cloudflare-workers";
+type SmokeCallbacks = Record<string, any>;
+
+const serveConfig: RuntimeServeConfig = {
+	version: 4,
+	endpoint: "https://api.rivet.dev",
+	token: "smoke-token",
+	namespace: "smoke-namespace",
+	poolName: "smoke-pool",
+	serverlessPackageVersion: "0.0.0",
+	serverlessValidateEndpoint: true,
+	serverlessMaxStartPayloadBytes: 1024,
+};
+
+function encodeValue(value: unknown): Buffer {
+	return Buffer.from(encodeCborCompat(value));
+}
+
+function decodeValue<T>(value: Uint8Array): T {
+	return decodeCborCompat<T>(value);
+}
+
+class SmokeGate {
+	#started!: () => void;
+	#released!: () => void;
+
+	readonly started = new Promise<void>((resolve) => {
+		this.#started = resolve;
+	});
+	readonly released = new Promise<void>((resolve) => {
+		this.#released = resolve;
+	});
+
+	markStarted(): void {
+		this.#started();
+	}
+
+	release(): void {
+		this.#released();
+	}
+}
+
+class SmokeScenario {
+	readonly actionReconnect = new SmokeGate();
+	readonly remoteWriteReconnect = new SmokeGate();
+}
+
+class SmokeHost {
+	readonly sockets: Array<{
+		url: string;
+		protocols: string[];
+		binaryType: string;
+		reason: string;
+	}> = [];
+	readonly reconnects: string[] = [];
+	readonly sql: Array<{
+		method: string;
+		sql: string;
+		params: unknown;
+		reconnects: string[];
+	}> = [];
+	readonly kv = new Map<string, Buffer>();
+	readonly saves: unknown[] = [];
+
+	constructor(readonly kind: HostKind) {}
+
+	openEnvoySocket(config: RuntimeServeConfig, reason: string): void {
+		const url = new URL("/envoys/connect", config.endpoint);
+		url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+		url.searchParams.set("protocol_version", String(config.version));
+		url.searchParams.set("namespace", config.namespace);
+		url.searchParams.set("envoy_key", config.token ?? "");
+		url.searchParams.set("version", config.serverlessPackageVersion);
+		url.searchParams.set("pool_name", config.poolName);
+
+		const protocols = ["rivet"];
+		if (config.token) {
+			protocols.push(`rivet_token.${config.token}`);
+		}
+
+		this.sockets.push({
+			url: url.toString(),
+			protocols,
+			binaryType: "arraybuffer",
+			reason,
+		});
+	}
+
+	reconnect(config: RuntimeServeConfig, reason: string): void {
+		this.reconnects.push(reason);
+		this.openEnvoySocket(config, reason);
+	}
+}
+
+class SmokeSql {
+	constructor(private readonly host: SmokeHost) {}
+
+	async exec(sql: string) {
+		this.host.sql.push({
+			method: "exec",
+			sql,
+			params: null,
+			reconnects: [...this.host.reconnects],
+		});
+		return { columns: [], rows: [] };
+	}
+
+	async execute(sql: string, params?: unknown) {
+		this.host.sql.push({
+			method: "execute",
+			sql,
+			params,
+			reconnects: [...this.host.reconnects],
+		});
+		return {
+			columns: ["value"],
+			rows: [["ok"]],
+			changes: 1,
+			lastInsertRowId: 1,
+			route: "write",
+		};
+	}
+
+	async executeWrite(sql: string, params?: unknown) {
+		this.host.sql.push({
+			method: "executeWrite",
+			sql,
+			params,
+			reconnects: [...this.host.reconnects],
+		});
+		return {
+			columns: ["value"],
+			rows: [["ok"]],
+			changes: 1,
+			lastInsertRowId: 1,
+			route: "write",
+		};
+	}
+
+	async query(sql: string, params?: unknown) {
+		this.host.sql.push({
+			method: "query",
+			sql,
+			params,
+			reconnects: [...this.host.reconnects],
+		});
+		return { columns: ["value"], rows: [["ok"]] };
+	}
+
+	async run(sql: string, params?: unknown) {
+		await this.execute(sql, params);
+		return { changes: 1 };
+	}
+
+	takeLastKvError(): null {
+		return null;
+	}
+
+	async close(): Promise<void> {}
+}
+
+class SmokeKv {
+	constructor(private readonly host: SmokeHost) {}
+
+	async get(key: Buffer): Promise<Buffer | null> {
+		return this.host.kv.get(key.toString("hex")) ?? null;
+	}
+
+	async put(key: Buffer, value: Buffer): Promise<void> {
+		this.host.kv.set(key.toString("hex"), Buffer.from(value));
+	}
+
+	async delete(key: Buffer): Promise<void> {
+		this.host.kv.delete(key.toString("hex"));
+	}
+
+	async deleteRange(): Promise<void> {}
+
+	async listPrefix(): Promise<Array<{ key: Buffer; value: Buffer }>> {
+		return [];
+	}
+
+	async listRange(): Promise<Array<{ key: Buffer; value: Buffer }>> {
+		return [];
+	}
+
+	async batchGet(keys: Buffer[]): Promise<Array<Buffer | null>> {
+		return keys.map((key) => this.host.kv.get(key.toString("hex")) ?? null);
+	}
+
+	async batchPut(
+		entries: Array<{ key: Buffer; value: Buffer }>,
+	): Promise<void> {
+		for (const entry of entries) {
+			this.host.kv.set(
+				entry.key.toString("hex"),
+				Buffer.from(entry.value),
+			);
+		}
+	}
+
+	async batchDelete(keys: Buffer[]): Promise<void> {
+		for (const key of keys) {
+			this.host.kv.delete(key.toString("hex"));
+		}
+	}
+}
+
+class SmokeActorContext {
+	stateBytes = Buffer.alloc(0);
+	readonly runtimeBag = {};
+	readonly kvHandle: SmokeKv;
+	readonly sqlHandle: SmokeSql;
+	readonly abortController = new AbortController();
+
+	constructor(private readonly host: SmokeHost) {
+		this.kvHandle = new SmokeKv(host);
+		this.sqlHandle = new SmokeSql(host);
+	}
+
+	state(): Buffer {
+		return this.stateBytes;
+	}
+
+	beginOnStateChange(): void {}
+
+	endOnStateChange(): void {}
+
+	requestSave(opts?: unknown): void {
+		this.host.saves.push(opts);
+	}
+
+	async requestSaveAndWait(opts?: unknown): Promise<void> {
+		this.host.saves.push(opts);
+	}
+
+	takePendingHibernationChanges(): string[] {
+		return [];
+	}
+
+	dirtyHibernatableConns(): unknown[] {
+		return [];
+	}
+
+	runtimeState(): object {
+		return this.runtimeBag;
+	}
+
+	actorId(): string {
+		return `${this.host.kind}-actor`;
+	}
+
+	name(): string {
+		return "smoke";
+	}
+
+	key(): Array<{ kind: string; stringValue: string }> {
+		return [{ kind: "string", stringValue: this.host.kind }];
+	}
+
+	region(): string {
+		return "local";
+	}
+
+	conns(): unknown[] {
+		return [];
+	}
+
+	abortSignal(): AbortSignal {
+		return this.abortController.signal;
+	}
+
+	kv(): SmokeKv {
+		return this.kvHandle;
+	}
+
+	sql(): SmokeSql {
+		return this.sqlHandle;
+	}
+}
+
+class FakeCancellationToken {
+	#cancelled = false;
+	#callbacks: Array<() => void> = [];
+
+	aborted(): boolean {
+		return this.#cancelled;
+	}
+
+	cancel(): void {
+		this.#cancelled = true;
+		for (const callback of this.#callbacks) {
+			callback();
+		}
+	}
+
+	onCancelled(callback: () => void): void {
+		this.#callbacks.push(callback);
+	}
+}
+
+class FakeActorFactory {
+	constructor(
+		readonly callbacks: SmokeCallbacks,
+		readonly config: Record<string, unknown>,
+	) {}
+}
+
+function fakeWasmBindings(
+	host: SmokeHost,
+	scenario: SmokeScenario,
+): WasmBindings {
+	class FakeCoreRegistry {
+		registered = new Map<string, FakeActorFactory>();
+
+		register(name: string, factory: FakeActorFactory): void {
+			this.registered.set(name, factory);
+		}
+
+		async serve(config: RuntimeServeConfig): Promise<void> {
+			host.openEnvoySocket(config, "initial");
+			const factory = this.registered.get("smoke");
+			if (!factory) {
+				throw new Error("smoke actor was not registered");
+			}
+
+			expect(factory.config).toMatchObject({
+				hasDatabase: true,
+				remoteSqlite: true,
+			});
+
+			const ctx = new SmokeActorContext(host);
+			const initialState = await factory.callbacks.createState(null, {
+				ctx,
+				input: encodeValue({ host: host.kind }),
+			});
+			ctx.stateBytes = Buffer.from(initialState);
+
+			const actionPromise = factory.callbacks.actions.smoke(null, {
+				ctx,
+				conn: null,
+				name: "smoke",
+				args: encodeValue([host.kind]),
+				cancelToken: new FakeCancellationToken(),
+			});
+
+			await scenario.actionReconnect.started;
+			host.reconnect(config, "during-action");
+			scenario.actionReconnect.release();
+
+			await scenario.remoteWriteReconnect.started;
+			host.reconnect(config, "during-remote-write-sql");
+			scenario.remoteWriteReconnect.release();
+
+			const output = decodeValue<{
+				stateCount: number;
+				kvValue: string;
+				sqlRows: number;
+			}>(await actionPromise);
+			expect(output).toEqual({
+				stateCount: 1,
+				kvValue: host.kind,
+				sqlRows: 1,
+			});
+
+			const delta = await factory.callbacks.serializeState(null, {
+				ctx,
+				reason: "save",
+			});
+			expect(decodeValue<{ count: number }>(delta.state)).toEqual({
+				count: 1,
+			});
+		}
+
+		async shutdown(): Promise<void> {}
+	}
+
+	return {
+		CoreRegistry: FakeCoreRegistry,
+		ActorFactory: FakeActorFactory,
+		CancellationToken: FakeCancellationToken,
+		ActorContext: class {},
+		ConnHandle: class {},
+		WebSocketHandle: class {},
+		bridgeRivetErrorPrefix: () => "__RIVET_ERROR_JSON__:",
+		roundTripBytes: (bytes: Uint8Array) => bytes,
+		uint8ArrayFromBytes: (bytes: Uint8Array) => bytes,
+		awaitPromise: async <T>(promise: Promise<T>) => await promise,
+		default: async () => {},
+	} as unknown as WasmBindings;
+}
+
+function smokeRegistryConfig(
+	definition: ReturnType<typeof actor>,
+): RegistryConfig {
+	return RegistryConfigSchema.parse({
+		use: { smoke: definition },
+		endpoint: serveConfig.endpoint,
+		token: serveConfig.token,
+		namespace: serveConfig.namespace,
+		noWelcome: true,
+		startEngine: false,
+		test: {
+			enabled: true,
+			sqliteBackend: "remote",
+		},
+	});
+}
+
+async function runHostSmoke(kind: HostKind): Promise<SmokeHost> {
+	const host = new SmokeHost(kind);
+	const scenario = new SmokeScenario();
+	const runtime = new WasmCoreRuntime(fakeWasmBindings(host, scenario));
+	const registry = runtime.createRegistry();
+	const definition = actor({
+		state: { count: 0 },
+		db: {
+			createClient: async () => ({
+				execute: async () => [],
+				close: async () => {},
+			}),
+			onMigrate: async () => {},
+		},
+		actions: {
+			smoke: async (c, label: string) => {
+				c.state.count += 1;
+				await c.kv.put("host", label);
+				const kvValue = await c.kv.get("host");
+
+				scenario.actionReconnect.markStarted();
+				await scenario.actionReconnect.released;
+
+				await c.sql.execute(
+					"INSERT INTO smoke_events (host) VALUES (?)",
+					[label],
+				);
+
+				scenario.remoteWriteReconnect.markStarted();
+				await scenario.remoteWriteReconnect.released;
+
+				await c.sql.writeMode(async () => {
+					await c.sql.execute(
+						"UPDATE smoke_events SET host = ? WHERE id = ?",
+						[label, 1],
+					);
+				});
+				const rows = await c.sql.query(
+					"SELECT host FROM smoke_events WHERE host = ?",
+					[label],
+				);
+				await c.saveState({ immediate: true });
+
+				return {
+					stateCount: c.state.count,
+					kvValue,
+					sqlRows: rows.rows.length,
+				};
+			},
+		},
+	});
+	const config = smokeRegistryConfig(definition);
+
+	runtime.registerActor(
+		registry,
+		"smoke",
+		buildNativeFactory(runtime, config, definition),
+	);
+	await runtime.serveRegistry(registry, serveConfig);
+
+	return host;
+}
+
+describe("wasm edge host smoke coverage", () => {
+	test.each([
+		["supabase-deno" as const],
+		["cloudflare-workers" as const],
+	])("%s loads through the wasm runtime interface", async (kind) => {
+		const host = await runHostSmoke(kind);
+		const initial = host.sockets[0];
+		const parsedUrl = new URL(initial.url);
+
+		expect(initial.protocols).toEqual([
+			"rivet",
+			`rivet_token.${serveConfig.token}`,
+		]);
+		expect(initial.binaryType).toBe("arraybuffer");
+		expect(parsedUrl.protocol).toBe("wss:");
+		expect(parsedUrl.searchParams.get("protocol_version")).toBe("4");
+		expect(parsedUrl.searchParams.get("namespace")).toBe(
+			serveConfig.namespace,
+		);
+		expect(parsedUrl.searchParams.get("envoy_key")).toBe(serveConfig.token);
+		expect(parsedUrl.searchParams.get("pool_name")).toBe(
+			serveConfig.poolName,
+		);
+
+		expect(host.sockets.map((socket) => socket.reason)).toEqual([
+			"initial",
+			"during-action",
+			"during-remote-write-sql",
+		]);
+		expect(host.sql.map((entry) => entry.method)).toEqual([
+			"execute",
+			"executeWrite",
+			"execute",
+		]);
+		expect(host.sql[1].reconnects).toContain("during-remote-write-sql");
+		expect(host.saves).toContainEqual({ immediate: true });
+	});
+});
diff --git a/rivetkit-typescript/packages/rivetkit/tests/wasm-runtime.test.ts b/rivetkit-typescript/packages/rivetkit/tests/wasm-runtime.test.ts
new file mode 100644
index 0000000000..a9bf9d42d2
--- /dev/null
+++ b/rivetkit-typescript/packages/rivetkit/tests/wasm-runtime.test.ts
@@ -0,0 +1,505 @@
+import { describe, expect, test, vi } from "vitest";
+import { BRIDGE_RIVET_ERROR_PREFIX, RivetError } from "@/actor/errors";
+import { actor } from "@/actor/mod";
+import { RegistryConfigSchema } from "@/registry/config";
+import { NapiCoreRuntime } from "@/registry/napi-runtime";
+import { buildNativeFactory } from "@/registry/native";
+import type {
+	ActorContextHandle,
+	CoreRuntime,
+	RuntimeServeConfig,
+} from "@/registry/runtime";
+import {
+	loadWasmRuntime,
+	type WasmBindings,
+	WasmCoreRuntime,
+} from "@/registry/wasm-runtime";
+import { decodeCborJsonCompat, encodeCborCompat } from "@/serde";
+
+const serveConfig: RuntimeServeConfig = {
+	version: 4,
+	endpoint: "https://api.rivet.dev",
+	namespace: "default",
+	poolName: "default",
+	serverlessPackageVersion: "0.0.0",
+	serverlessValidateEndpoint: true,
+	serverlessMaxStartPayloadBytes: 1024,
+};
+
+class Deferred<T = void> {
+	promise: Promise<T>;
+	resolve!: (value: T | PromiseLike<T>) => void;
+	reject!: (reason?: unknown) => void;
+
+	constructor() {
+		this.promise = new Promise<T>((resolve, reject) => {
+			this.resolve = resolve;
+			this.reject = reject;
+		});
+	}
+}
+
+function structuredBridgeError(reason: string): Error {
+	return new Error(
+		`${BRIDGE_RIVET_ERROR_PREFIX}${JSON.stringify({
+			group: "wasm",
+			code: "invalid_state",
+			message: `Invalid wasm state 'core registry': ${reason}`,
+			metadata: {
+				state: "core registry",
+				reason,
+			},
+		})}`,
+	);
+}
+
+class FakeCoreRegistry {
+	registered: Array<{ name: string; factory: FakeActorFactory }> = [];
+	serveError?: Error;
+	state:
+		| "registering"
+		| "buildingServerless"
+		| "serving"
+		| "serverless"
+		| "shutdown" = "registering";
+	serverlessBuilds = 0;
+	serverlessRequests = 0;
+	serverlessShutdowns = 0;
+	buildStarted = new Deferred<void>();
+	#buildRelease?: Deferred<void>;
+	#buildWaiters: Array<Deferred<void>> = [];
+
+	blockNextServerlessBuild(): void {
+		this.#buildRelease = new Deferred<void>();
+	}
+
+	releaseServerlessBuild(): void {
+		this.#buildRelease?.resolve();
+	}
+
+	#notifyBuildWaiters(): void {
+		const waiters = this.#buildWaiters.splice(0);
+		for (const waiter of waiters) {
+			waiter.resolve();
+		}
+	}
+
+	register(name: string, factory: FakeActorFactory): void {
+		if (this.state !== "registering") {
+			throw structuredBridgeError("already serving or shut down");
+		}
+		this.registered.push({ name, factory });
+	}
+
+	async serve(_config: RuntimeServeConfig): Promise<void> {
+		if (
+			this.state === "buildingServerless" ||
+			this.state === "serverless"
+		) {
+			throw structuredBridgeError(
+				"mode conflict: another run mode is already active",
+			);
+		}
+		if (this.state === "shutdown") {
+			throw structuredBridgeError("shut down");
+		}
+		this.state = "serving";
+		if (this.serveError) {
+			throw this.serveError;
+		}
+	}
+
+	async shutdown(): Promise<void> {
+		if (this.state === "serverless") {
+			this.serverlessShutdowns += 1;
+		}
+		this.state = "shutdown";
+		this.#notifyBuildWaiters();
+	}
+
+	async handleServerlessRequest(
+		_req: unknown,
+		onStreamEvent: (error: unknown, event?: unknown) => unknown,
+		_cancelToken: unknown,
+		_config: RuntimeServeConfig,
+	): Promise<{ status: number; headers: Record<string, string> }> {
+		await this.#ensureServerlessRuntime();
+		this.serverlessRequests += 1;
+		const requestCount = this.serverlessRequests;
+		await onStreamEvent(null, { kind: "end" });
+		return {
+			status: 200,
+			headers: { "x-request-count": String(requestCount) },
+		};
+	}
+
+	async #ensureServerlessRuntime(): Promise<void> {
+		for (;;) {
+			switch (this.state) {
+				case "serverless":
+					return;
+				case "shutdown":
+					throw structuredBridgeError("shut down");
+				case "serving":
+					throw structuredBridgeError(
+						"mode conflict: another run mode is already active",
+					);
+				case "buildingServerless": {
+					const waiter = new Deferred<void>();
+					this.#buildWaiters.push(waiter);
+					await waiter.promise;
+					continue;
+				}
+				case "registering":
+					this.state = "buildingServerless";
+					this.serverlessBuilds += 1;
+					this.buildStarted.resolve();
+					await this.#buildRelease?.promise;
+					if (this.state === "shutdown") {
+						this.serverlessShutdowns += 1;
+						this.#notifyBuildWaiters();
+						throw structuredBridgeError("shut down");
+					}
+					this.state = "serverless";
+					this.#notifyBuildWaiters();
+					return;
+			}
+		}
+	}
+}
+
+class FakeActorFactory {
+	constructor(
+		readonly callbacks: object,
+		readonly config: object | null | undefined,
+	) {}
+}
+
+type NativeActorCallbacks = {
+	createState?: (
+		error: unknown,
+		payload: {
+			ctx: ActorContextHandle;
+			input?: Uint8Array;
+		},
+	) => Promise<Uint8Array>;
+	actions: Record<
+		string,
+		(
+			error: unknown,
+			payload: {
+				ctx: ActorContextHandle;
+				conn: null;
+				name: string;
+				args: Uint8Array;
+			},
+		) => Promise<Uint8Array>
+	>;
+};
+
+class FakeCancellationToken {
+	#cancelled = false;
+	#callbacks: Array<() => void> = [];
+
+	aborted(): boolean {
+		return this.#cancelled;
+	}
+
+	cancel(): void {
+		this.#cancelled = true;
+		for (const callback of this.#callbacks) {
+			callback();
+		}
+	}
+
+	onCancelled(callback: () => void): void {
+		this.#callbacks.push(callback);
+	}
+}
+
+function fakeWasmBindings(
+	defaultFn: WasmBindings["default"] = async () => {},
+): WasmBindings {
+	return {
+		CoreRegistry: FakeCoreRegistry,
+		ActorFactory: FakeActorFactory,
+		CancellationToken: FakeCancellationToken,
+		ActorContext: class {},
+		ConnHandle: class {},
+		WebSocketHandle: class {},
+		bridgeRivetErrorPrefix: () => BRIDGE_RIVET_ERROR_PREFIX,
+		roundTripBytes: (bytes: Uint8Array) => bytes,
+		uint8ArrayFromBytes: (bytes: Uint8Array) => bytes,
+		awaitPromise: async <T>(promise: Promise<T>) => await promise,
+		default: defaultFn,
+	} as unknown as WasmBindings;
+}
+
+describe("WasmCoreRuntime", () => {
+	test("satisfies the same shared runtime interface as the NAPI adapter", () => {
+		const acceptRuntime = (_runtime: CoreRuntime) => {};
+
+		acceptRuntime(new WasmCoreRuntime(fakeWasmBindings()));
+		acceptRuntime(new NapiCoreRuntime({} as never));
+	});
+
+	test("maps raw wasm registry, factory, and cancellation handles", () => {
+		const runtime = new WasmCoreRuntime(fakeWasmBindings());
+		const registry = runtime.createRegistry();
+		const factory = runtime.createActorFactory(
+			{ run: vi.fn() },
+			{ name: "actor" },
+		);
+		const token = runtime.createCancellationToken();
+		const onCancel = vi.fn();
+
+		runtime.registerActor(registry, "actor", factory);
+		runtime.onCancellationTokenCancelled(token, onCancel);
+		expect(runtime.cancellationTokenAborted(token)).toBe(false);
+		runtime.cancelCancellationToken(token);
+
+		expect((registry as unknown as FakeCoreRegistry).registered).toEqual([
+			{ name: "actor", factory },
+		]);
+		expect(runtime.cancellationTokenAborted(token)).toBe(true);
+		expect(onCancel).toHaveBeenCalledOnce();
+	});
+
+	test("runs shared actor callbacks without a Buffer global", async () => {
+		const portableActor = actor({
+			state: { ready: true },
+			actions: {
+				echo: (_ctx, value: string) => ({ value }),
+			},
+		});
+		const config = RegistryConfigSchema.parse({
+			use: { portable: portableActor },
+			runtime: "wasm",
+			sqlite: "remote",
+			startEngine: false,
+		});
+		const runtime = new WasmCoreRuntime(fakeWasmBindings());
+		const factory = buildNativeFactory(
+			runtime,
+			config,
+			portableActor,
+		) as unknown as FakeActorFactory;
+		const callbacks = factory.callbacks as NativeActorCallbacks;
+		const globalWithBuffer = globalThis as typeof globalThis & {
+			Buffer?: unknown;
+		};
+		const previousBuffer = globalWithBuffer.Buffer;
+		const runtimeState = {};
+		const ctx = {
+			actorId: () => "actor-1",
+			runtimeState: () => runtimeState,
+		} as unknown as ActorContextHandle;
+
+		try {
+			globalWithBuffer.Buffer = undefined;
+
+			const stateBytes = await callbacks.createState?.(null, {
+				ctx,
+			});
+			const outputBytes = await callbacks.actions.echo(null, {
+				ctx,
+				conn: null,
+				name: "echo",
+				args: encodeCborCompat(["ok"]),
+			});
+
+			expect(globalWithBuffer.Buffer).toBeUndefined();
+			expect(
+				decodeCborJsonCompat(stateBytes ?? new Uint8Array()),
+			).toEqual({ ready: true });
+			expect(decodeCborJsonCompat(outputBytes)).toEqual({ value: "ok" });
+		} finally {
+			globalWithBuffer.Buffer = previousBuffer;
+		}
+	});
+
+	test("decodes structured wasm bridge errors", async () => {
+		const runtime = new WasmCoreRuntime(fakeWasmBindings());
+		const registry = runtime.createRegistry();
+		(registry as unknown as FakeCoreRegistry).serveError = new Error(
+			`${BRIDGE_RIVET_ERROR_PREFIX}${JSON.stringify({
+				group: "sqlite",
+				code: "remote_unavailable",
+				message: "remote sqlite is unavailable",
+				metadata: { backend: "remote" },
+			})}`,
+		);
+
+		await expect(
+			runtime.serveRegistry(registry, serveConfig),
+		).rejects.toMatchObject({
+			group: "sqlite",
+			code: "remote_unavailable",
+			message: "remote sqlite is unavailable",
+			metadata: { backend: "remote" },
+		});
+	});
+
+	test("fails explicitly when the wasm binding has not exported a runtime method", () => {
+		const runtime = new WasmCoreRuntime(fakeWasmBindings());
+
+		let error: unknown;
+		try {
+			runtime.actorId({} as ActorContextHandle);
+		} catch (err) {
+			error = err;
+		}
+
+		expect(error).toBeInstanceOf(RivetError);
+		expect(error).toMatchObject({
+			group: "runtime",
+			code: "unsupported",
+			metadata: {
+				runtime: "wasm",
+				method: "actorId",
+			},
+		});
+	});
+
+	test("returns queue max size through NAPI and wasm adapters", () => {
+		const maxSize = 37;
+		const context = {
+			queue: () => ({
+				maxSize: () => maxSize,
+			}),
+		} as unknown as ActorContextHandle;
+
+		expect(
+			new NapiCoreRuntime({} as never).actorQueueMaxSize(context),
+		).toBe(maxSize);
+		expect(
+			new WasmCoreRuntime(fakeWasmBindings()).actorQueueMaxSize(context),
+		).toBe(maxSize);
+	});
+
+	test("shares a concurrent first serverless build", async () => {
+		const runtime = new WasmCoreRuntime(fakeWasmBindings());
+		const registry = runtime.createRegistry();
+		const fakeRegistry = registry as unknown as FakeCoreRegistry;
+		fakeRegistry.blockNextServerlessBuild();
+		const token = runtime.createCancellationToken();
+		const request = {
+			method: "POST",
+			url: "https://api.rivet.dev/api/rivet/start",
+			headers: {},
+			body: new Uint8Array(),
+		};
+
+		const first = runtime.handleServerlessRequest(
+			registry,
+			request,
+			vi.fn(),
+			token,
+			serveConfig,
+		);
+		await fakeRegistry.buildStarted.promise;
+		const second = runtime.handleServerlessRequest(
+			registry,
+			request,
+			vi.fn(),
+			token,
+			serveConfig,
+		);
+
+		expect(fakeRegistry.serverlessBuilds).toBe(1);
+		fakeRegistry.releaseServerlessBuild();
+
+		await expect(Promise.all([first, second])).resolves.toEqual([
+			{ status: 200, headers: { "x-request-count": "1" } },
+			{ status: 200, headers: { "x-request-count": "2" } },
+		]);
+		expect(fakeRegistry.serverlessBuilds).toBe(1);
+		expect(fakeRegistry.serverlessRequests).toBe(2);
+	});
+
+	test("drains a serverless runtime built during shutdown", async () => {
+		const runtime = new WasmCoreRuntime(fakeWasmBindings());
+		const registry = runtime.createRegistry();
+		const fakeRegistry = registry as unknown as FakeCoreRegistry;
+		fakeRegistry.blockNextServerlessBuild();
+		const token = runtime.createCancellationToken();
+		const request = {
+			method: "POST",
+			url: "https://api.rivet.dev/api/rivet/start",
+			headers: {},
+			body: new Uint8Array(),
+		};
+
+		const first = runtime.handleServerlessRequest(
+			registry,
+			request,
+			vi.fn(),
+			token,
+			serveConfig,
+		);
+		await fakeRegistry.buildStarted.promise;
+		await runtime.shutdownRegistry(registry);
+		fakeRegistry.releaseServerlessBuild();
+
+		await expect(first).rejects.toMatchObject({
+			group: "wasm",
+			code: "invalid_state",
+			message: "Invalid wasm state 'core registry': shut down",
+		});
+		expect(fakeRegistry.serverlessShutdowns).toBe(1);
+		expect(fakeRegistry.state).toBe("shutdown");
+	});
+
+	test("returns a structured wrong-mode error for serverless after serve", async () => {
+		const runtime = new WasmCoreRuntime(fakeWasmBindings());
+		const registry = runtime.createRegistry();
+		const token = runtime.createCancellationToken();
+
+		await runtime.serveRegistry(registry, serveConfig);
+
+		await expect(
+			runtime.handleServerlessRequest(
+				registry,
+				{
+					method: "POST",
+					url: "https://api.rivet.dev/api/rivet/start",
+					headers: {},
+					body: new Uint8Array(),
+				},
+				vi.fn(),
+				token,
+				serveConfig,
+			),
+		).rejects.toMatchObject({
+			group: "wasm",
+			code: "invalid_state",
+			message:
+				"Invalid wasm state 'core registry': mode conflict: another run mode is already active",
+		});
+	});
+
+	test("loads configured bindings instead of hidden globals", async () => {
+		const initInput = new Uint8Array([3, 2, 1]);
+		const configuredDefault = vi.fn(async () => {});
+		const hiddenDefault = vi.fn(async () => {});
+		const configuredBindings = fakeWasmBindings(configuredDefault);
+		const hiddenBindings = fakeWasmBindings(hiddenDefault);
+		const globalScope = globalThis as typeof globalThis & {
+			__rivetkitWasmBindings?: WasmBindings;
+		};
+		globalScope.__rivetkitWasmBindings = hiddenBindings;
+
+		try {
+			const loaded = await loadWasmRuntime({
+				bindings: configuredBindings,
+				initInput,
+			});
+
+			expect(loaded.bindings).toBe(configuredBindings);
+			expect(configuredDefault).toHaveBeenCalledWith(initInput);
+			expect(hiddenDefault).not.toHaveBeenCalled();
+		} finally {
+			delete globalScope.__rivetkitWasmBindings;
+		}
+	});
+});
diff --git a/rivetkit-typescript/packages/rivetkit/vitest.config.ts b/rivetkit-typescript/packages/rivetkit/vitest.config.ts
index d344977ed1..1f12fdf1d3 100644
--- a/rivetkit-typescript/packages/rivetkit/vitest.config.ts
+++ b/rivetkit-typescript/packages/rivetkit/vitest.config.ts
@@ -1,12 +1,18 @@
 import { resolve } from "node:path";
 import tsconfigPaths from "vite-tsconfig-paths";
-import { defineConfig } from "vitest/config";
+import { configDefaults, defineConfig } from "vitest/config";
 import defaultConfig from "../../../vitest.base.ts";
 
 export default defineConfig({
 	...defaultConfig,
 	test: {
 		...defaultConfig.test,
+		exclude: [
+			...configDefaults.exclude,
+			...(process.env.RIVETKIT_INCLUDE_PLATFORM_TESTS === "1"
+				? []
+				: ["tests/platforms/**/*.test.ts"]),
+		],
 		fileParallelism: false,
 		testTimeout: 30_000,
 		hookTimeout: 30_000,
diff --git a/rivetkit-typescript/packages/workflow-engine/AGENTS.md b/rivetkit-typescript/packages/workflow-engine/AGENTS.md
new file mode 120000
index 0000000000..681311eb9c
--- /dev/null
+++ b/rivetkit-typescript/packages/workflow-engine/AGENTS.md
@@ -0,0 +1 @@
+CLAUDE.md
\ No newline at end of file
diff --git a/scripts/cargo/check-rivetkit-core-wasm.sh b/scripts/cargo/check-rivetkit-core-wasm.sh
new file mode 100755
index 0000000000..e39b56a19f
--- /dev/null
+++ b/scripts/cargo/check-rivetkit-core-wasm.sh
@@ -0,0 +1,100 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+TARGET="wasm32-unknown-unknown"
+CORE_FEATURES="wasm-runtime,sqlite-remote"
+BANNED_CRATES=(
+	"rivetkit-sqlite"
+	"libsqlite3-sys"
+	"tokio-tungstenite"
+	"mio"
+	"nix"
+	"reqwest"
+	"rivet-pools"
+	"rivet-util"
+)
+
+cd "$ROOT"
+
+if command -v rustup >/dev/null 2>&1; then
+	rustup target add "$TARGET" >/dev/null
+fi
+
+echo "checking rivetkit-core for $TARGET"
+cargo check \
+	-p rivetkit-core \
+	--target "$TARGET" \
+	--no-default-features \
+	--features "$CORE_FEATURES"
+
+tree_log="$(mktemp)"
+feature_log="$(mktemp)"
+native_envoy_log="$(mktemp)"
+native_core_log="$(mktemp)"
+trap 'rm -f "$tree_log" "$feature_log" "$native_envoy_log" "$native_core_log"' EXIT
+
+echo "scanning normal wasm dependency tree"
+cargo tree \
+	-p rivetkit-core \
+	--target "$TARGET" \
+	--no-default-features \
+	--features "$CORE_FEATURES" \
+	-e normal >"$tree_log"
+
+for crate in "${BANNED_CRATES[@]}"; do
+	if grep -Eq "(^|[[:space:]])${crate//-/\\-}[[:space:]]+v" "$tree_log"; then
+		echo "native-only dependency leaked into wasm tree: $crate" >&2
+		echo "dependency tree saved at $tree_log" >&2
+		trap - EXIT
+		exit 1
+	fi
+done
+
+echo "checking wasm feature graph"
+cargo tree \
+	-p rivetkit-core \
+	--target "$TARGET" \
+	--no-default-features \
+	--features "$CORE_FEATURES" \
+	-e features >"$feature_log"
+
+if grep -Fq 'rivet-envoy-client feature "native-transport"' "$feature_log"; then
+	echo "native envoy transport feature leaked into wasm feature graph" >&2
+	echo "feature tree saved at $feature_log" >&2
+	trap - EXIT
+	exit 1
+fi
+
+if grep -Fq 'rivetkit-core feature "native-runtime"' "$feature_log"; then
+	echo "native runtime feature leaked into wasm feature graph" >&2
+	echo "feature tree saved at $feature_log" >&2
+	trap - EXIT
+	exit 1
+fi
+
+echo "verifying native envoy transport is rejected on $TARGET"
+if cargo check \
+	-p rivet-envoy-client \
+	--target "$TARGET" \
+	--no-default-features \
+	--features native-transport >"$native_envoy_log" 2>&1; then
+	echo "expected native envoy transport to fail on $TARGET, but it compiled" >&2
+	echo "native transport check log saved at $native_envoy_log" >&2
+	trap - EXIT
+	exit 1
+fi
+
+echo "verifying native core runtime is rejected on $TARGET"
+if cargo check \
+	-p rivetkit-core \
+	--target "$TARGET" \
+	--no-default-features \
+	--features native-runtime >"$native_core_log" 2>&1; then
+	echo "expected native core runtime to fail on $TARGET, but it compiled" >&2
+	echo "native runtime check log saved at $native_core_log" >&2
+	trap - EXIT
+	exit 1
+fi
+
+echo "rivetkit-core wasm gate passed"
diff --git a/scripts/ralph/.last-branch b/scripts/ralph/.last-branch
index 2321bd7578..528a3f97a7 100644
--- a/scripts/ralph/.last-branch
+++ b/scripts/ralph/.last-branch
@@ -1 +1 @@
-04-29-feat_sqlite_add_cold_read_benchmarks_and_simplify_optimizations
+04-29-chore_rivetkit_wasm_support
diff --git a/scripts/ralph/AGENTS.md b/scripts/ralph/AGENTS.md
new file mode 120000
index 0000000000..681311eb9c
--- /dev/null
+++ b/scripts/ralph/AGENTS.md
@@ -0,0 +1 @@
+CLAUDE.md
\ No newline at end of file
diff --git a/scripts/ralph/archive/2026-04-29-04-29-feat_sqlite_add_cold_read_benchmarks_and_simplify_optimizations/prd.json b/scripts/ralph/archive/2026-04-29-04-29-feat_sqlite_add_cold_read_benchmarks_and_simplify_optimizations/prd.json
new file mode 100644
index 0000000000..4f73e8e4e7
--- /dev/null
+++ b/scripts/ralph/archive/2026-04-29-04-29-feat_sqlite_add_cold_read_benchmarks_and_simplify_optimizations/prd.json
@@ -0,0 +1,214 @@
+{
+  "project": "sqlite-read-connection-manager",
+  "branchName": "04-29-feat_sqlite_add_cold_read_benchmarks_and_simplify_optimizations",
+  "description": "Implement a SQLite read-mode/write-mode connection manager so independent read-only queries can run in parallel while write mode holds exactly one writable connection and no readers.",
+  "userStories": [
+    {
+      "id": "US-001",
+      "title": "Add SQLite statement classification helpers",
+      "description": "As a runtime developer, I want native SQLite statement classification helpers so that read-only routing is based on SQLite semantics instead of SQL string heuristics.",
+      "acceptanceCriteria": [
+        "Add a rivetkit-sqlite helper that prepares one statement without stepping and reports whether SQLite considers it read-only via sqlite3_stmt_readonly",
+        "Reject reader routing when sqlite3_prepare_v2 returns non-whitespace tail text after the first statement",
+        "Capture authorizer actions during classification for transaction control, attach, detach, schema writes, temp writes, pragma usage, function calls, and write operations",
+        "Add tests covering SELECT, read-only PRAGMA, mutating PRAGMA, INSERT RETURNING, CTE writes, VACUUM, ATTACH, BEGIN, SAVEPOINT, and multi-statement SQL",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 1,
+      "passes": true,
+      "notes": ""
+    },
+    {
+      "id": "US-002",
+      "title": "Split VFS ownership from SQLite connections",
+      "description": "As a runtime developer, I want VFS registration and SQLite connection ownership split apart so that one actor can open multiple connections against one shared VFS cache.",
+      "acceptanceCriteria": [
+        "Introduce native ownership types equivalent to NativeVfsHandle and NativeConnection without changing public TypeScript APIs",
+        "Keep one shared VFS registration and VfsContext per actor database manager while allowing multiple SQLite connection handles",
+        "Use a VFS name that includes an actor database generation or pool generation instead of only the actor id",
+        "Ensure manager close order closes every SQLite connection before unregistering the VFS",
+        "Add tests or assertions covering multiple connections sharing one VFS context and VFS cleanup after connection close",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 2,
+      "passes": true,
+      "notes": ""
+    },
+    {
+      "id": "US-003",
+      "title": "Enforce read-only VFS roles",
+      "description": "As a runtime developer, I want VFS file handles to know whether they belong to a reader or writer so that read-only connections cannot mutate actor SQLite state.",
+      "acceptanceCriteria": [
+        "Store reader or writer role on VfsFile and auxiliary file handles opened through the RivetKit SQLite VFS",
+        "Set SQLite pOutFlags consistently with the requested open flags and the assigned role",
+        "Reject reader-owned xWrite, xTruncate, xDelete, dirty sync, and atomic-write file-control operations",
+        "Deny reader auxiliary-file creation unless the path is explicitly proven safe and documented in code",
+        "Add VFS tests proving reader handles fail closed on write-only callbacks while writer handles still support existing write paths",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 3,
+      "passes": true,
+      "notes": ""
+    },
+    {
+      "id": "US-004",
+      "title": "Add the connection manager mode gate",
+      "description": "As a runtime developer, I want an actor-local SQLite mode gate so that read mode and write mode are mutually exclusive and write requests cannot starve.",
+      "acceptanceCriteria": [
+        "Add a NativeConnectionManager skeleton with closed, read-mode, write-mode, and closing state",
+        "Allow read mode to hold lazy read-only connections up to a configurable maximum reader count",
+        "When write mode is requested, stop admitting new reads, wait for active readers, close all readers, then open exactly one writable connection",
+        "When closing is requested, stop admitting new work, wait for active work to finish or cancellation to fire, close connections, and unregister the VFS",
+        "Use async coordination for the gate and avoid holding sync lock guards across await points",
+        "Add tests for read admission, writer preference, read-to-write transition, and close ordering",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 4,
+      "passes": true,
+      "notes": ""
+    },
+    {
+      "id": "US-005",
+      "title": "Route write work through exclusive write mode",
+      "description": "As a runtime developer, I want every mutation and transaction to run through exclusive write mode so that no reader connection is open while a writable connection exists.",
+      "acceptanceCriteria": [
+        "Route run calls, exec calls, migrations, schema-changing statements, and classification fallbacks through write mode",
+        "Treat raw transaction-control statements as write-mode only even if SQLite reports them as read-only",
+        "Keep the manager in write mode while sqlite3_get_autocommit on the writer returns false",
+        "After write-mode work completes with autocommit restored, close the writable connection before admitting read-mode work",
+        "Add tests proving BEGIN or SAVEPOINT blocks reader creation until COMMIT or ROLLBACK completes",
+        "Add tests proving a pending writer waits for active readers and new readers wait behind the writer",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 5,
+      "passes": true,
+      "notes": ""
+    },
+    {
+      "id": "US-006",
+      "title": "Execute read-only statements on read connections",
+      "description": "As a Rivet Actor developer, I want independent read-only statements to run on read connections so that expensive VFS round trips can overlap.",
+      "acceptanceCriteria": [
+        "Route single-statement queries classified as read-only to read-mode connections opened with SQLITE_OPEN_READONLY",
+        "Set PRAGMA query_only = ON on reader connections",
+        "Install a mandatory reader authorizer that denies transaction control, attach, detach, schema writes, temp writes, unsafe pragmas, unsafe functions, and all write actions",
+        "Open readers lazily for concurrent read demand and reuse idle readers while the idle TTL has not expired",
+        "Add a deterministic test with artificial VFS delay proving concurrent read-only statements use multiple reader connections instead of serial execution",
+        "Add tests proving reader authorizer or VFS rejection is treated as a routing bug and fails closed",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 6,
+      "passes": true,
+      "notes": ""
+    },
+    {
+      "id": "US-007",
+      "title": "Add a native execute result API",
+      "description": "As a TypeScript runtime maintainer, I want a native execute API that returns rows, columns, changes, and route metadata so that TypeScript does not decide read/write behavior by parsing SQL strings.",
+      "acceptanceCriteria": [
+        "Add a native execute path that prepares, classifies, routes, steps, and returns rows and column names for single-statement SQL",
+        "Return write metadata such as changes and last insert row id when available",
+        "Return route metadata indicating whether the statement used read mode, write mode, or write fallback",
+        "Keep query and run compatibility wrappers working through the native routing path where practical",
+        "Update core inspector database execute handling to use the native execute path instead of bypassing the gate",
+        "Add tests covering SELECT, plain INSERT, INSERT RETURNING, read-only PRAGMA, mutating PRAGMA, and malformed SQL",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 7,
+      "passes": true,
+      "notes": ""
+    },
+    {
+      "id": "US-008",
+      "title": "Remove TypeScript read serialization",
+      "description": "As a RivetKit TypeScript user, I want TypeScript database wrappers to allow native parallel reads so that Promise.all over read-only queries actually overlaps VFS work.",
+      "acceptanceCriteria": [
+        "Expose the native execute API through rivetkit-napi and the TypeScript native database wrapper",
+        "Remove or narrow per-query AsyncMutex usage in common/database/mod.ts once native routing is authoritative",
+        "Remove or narrow read-query serialization in common/database/native-database.ts",
+        "Remove or narrow Drizzle callback and raw execute serialization for read-only work in db/drizzle.ts",
+        "Keep closed-state checks with an in-flight counter or close gate so close waits for admitted native calls",
+        "Ensure migration hooks run in native migration mode, where all database calls route through write mode and reader creation is disabled",
+        "Add TypeScript tests proving Promise.all read queries reach native execution concurrently while write operations remain serialized by the native manager",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 8,
+      "passes": true,
+      "notes": ""
+    },
+    {
+      "id": "US-009",
+      "title": "Add read pool config flags and metrics",
+      "description": "As an operator, I want read pool configuration and metrics so that the feature can be rolled out, observed, and disabled safely.",
+      "acceptanceCriteria": [
+        "Add central SQLite optimization config for sqlite_read_pool_enabled, sqlite_read_pool_max_readers, and sqlite_read_pool_idle_ttl_ms",
+        "Preserve old single-connection behavior when the read pool feature flag is disabled",
+        "Add Prometheus metrics for active readers, idle readers, read wait duration, write wait duration, routed read queries, write fallbacks, manual transaction duration, reader opens, reader closes, rejected reader mutations, and mode transitions",
+        "Keep existing VFS metrics aggregated at the shared VFS level",
+        "Add tests or snapshots proving config defaults and disabled-path behavior",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 9,
+      "passes": true,
+      "notes": ""
+    },
+    {
+      "id": "US-010",
+      "title": "Add kitchen-sink benchmark coverage",
+      "description": "As a performance investigator, I want kitchen-sink benchmark workloads for parallel reads and read-write transitions so that the read connection manager has a repeatable performance signal.",
+      "acceptanceCriteria": [
+        "Ensure the kitchen-sink SQLite real-world benchmark includes a parallel-read-aggregates workload",
+        "Ensure the kitchen-sink SQLite real-world benchmark includes a parallel-read-write-transition workload",
+        "Report benchmark output that makes routed reads, routed writes, and transition metrics visible when the manager metrics exist",
+        "Add static or runtime tests proving the script and actor workload lists stay in sync",
+        "Document any required benchmark command updates in the relevant benchmark file or agent note",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 10,
+      "passes": true,
+      "notes": ""
+    },
+    {
+      "id": "US-011",
+      "title": "Add lifecycle and fencing stress coverage",
+      "description": "As a runtime developer, I want stress coverage around sleep, destroy, and fence errors so that pooled readers do not outlive actor lifecycle authority.",
+      "acceptanceCriteria": [
+        "Add tests proving actor sleep or destroy stops new database work and closes active or idle reader connections in deterministic order",
+        "Add tests proving a fence mismatch from any reader marks the shared VFS dead and causes later database work to fail closed",
+        "Add tests proving actor replacement or generation changes do not collide with stale VFS registration names",
+        "Add tests proving manual raw transactions keep the manager in write mode across awaited user code",
+        "Add tests proving inspector and user database operations share the same native routing gate",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 11,
+      "passes": true,
+      "notes": ""
+    },
+    {
+      "id": "US-012",
+      "title": "Document the SQLite read-mode write-mode invariant",
+      "description": "As a future maintainer, I want the SQLite connection manager invariant documented so that later optimizations do not accidentally reintroduce readers beside a writer.",
+      "acceptanceCriteria": [
+        "Update docs-internal or agent specs to state that read mode may hold multiple read-only connections and write mode must hold exactly one writable connection with no readers open",
+        "Update the SQLite optimization tracker with the read-mode/write-mode connection manager item if it is not already present",
+        "Document that v1 does not allow readers to continue during writes and does not pin per-reader head txids",
+        "Document that TypeScript must not be the policy boundary for read/write routing",
+        "Typecheck passes"
+      ],
+      "priority": 12,
+      "passes": true,
+      "notes": ""
+    }
+  ]
+}
diff --git a/scripts/ralph/archive/2026-04-29-04-29-feat_sqlite_add_cold_read_benchmarks_and_simplify_optimizations/progress.txt b/scripts/ralph/archive/2026-04-29-04-29-feat_sqlite_add_cold_read_benchmarks_and_simplify_optimizations/progress.txt
new file mode 100644
index 0000000000..7f947273b5
--- /dev/null
+++ b/scripts/ralph/archive/2026-04-29-04-29-feat_sqlite_add_cold_read_benchmarks_and_simplify_optimizations/progress.txt
@@ -0,0 +1,279 @@
+# Ralph Progress Log
+Started: Wed Apr 29 04:23:03 AM PDT 2026
+---
+## Codebase Patterns
+- `rivetkit-sqlite` statement routing classification should prepare exactly one statement with `sqlite3_prepare_v2`, read SQLite's decision through `sqlite3_stmt_readonly`, and capture prepare-time authorizer actions with `sqlite3_set_authorizer`.
+- New public `rivetkit-sqlite` behavior tests belong under `rivetkit-rust/packages/rivetkit-sqlite/tests/` when they do not need private module access.
+- Native SQLite VFS ownership is ref-counted through `NativeVfsHandle`; each `NativeConnection` holds a handle clone so the VFS unregisters only after the last connection closes.
+- Envoy SQLite VFS names include the actor database startup generation, e.g. `envoy-sqlite-{actor_id}-g{generation}`, to avoid stale registration collisions.
+- Tests that register multiple native SQLite VFS entries in one process should drop stale generations before replacement generations to avoid perturbing SQLite's global VFS registry.
+- SQLite VFS file handles carry a reader or writer role; reader-owned handles must fail closed for mutating VFS callbacks instead of relying on TypeScript routing.
+- Native SQLite work that can invoke VFS callbacks should run on `spawn_blocking`; VFS callbacks synchronously block on the transport runtime and can fail if SQL runs on an async runtime worker.
+- The native SQLite connection manager keeps an idle writer open while `sqlite3_get_autocommit` is false; `COMMIT` or `ROLLBACK` must reuse that writer and close it once autocommit is restored.
+- Native SQLite read-query routing must classify before installing the mandatory reader authorizer; statement classification uses a temporary authorizer and clears the connection-global authorizer when it finishes.
+- Native SQLite single-statement work should route through `NativeDatabaseHandle::execute`; keep `exec` as the multi-statement compatibility path.
+- TypeScript SQLite database wrappers should route single-statement work through native `SqliteDatabase.execute`; use `exec` only for multi-statement compatibility.
+- TypeScript SQLite migration hooks should run inside native `writeMode` so setup queries use the writer connection and do not create readers.
+- SQLite read-pool rollout config lives in `sqlite-storage::optimization_flags`; build `NativeConnectionManagerConfig` from `sqlite_optimization_flags()` and use `RIVETKIT_SQLITE_OPT_READ_POOL_ENABLED=false` for single-writer compatibility.
+- Kitchen-sink SQLite real-world benchmark reporting should include read-pool route counters alongside VFS counters so parallel-read and read-write-transition workloads expose manager behavior.
+- Native SQLite read-pool v1 closes readers before writes and does not pin per-reader head txids; TypeScript/NAPI wrappers must treat native execution as the routing policy boundary.
+
+## 2026-04-29 04:27:40 PDT - US-001
+- Implemented native SQLite statement classification with readonly detection, trailing-statement detection, authorizer action capture, and conservative reader eligibility.
+- Added integration coverage for SELECT, read-only PRAGMA, mutating PRAGMA, INSERT RETURNING, CTE writes, VACUUM, ATTACH, BEGIN, SAVEPOINT, and multi-statement SQL.
+- Files changed:
+  - `rivetkit-rust/packages/rivetkit-sqlite/src/query.rs`
+  - `rivetkit-rust/packages/rivetkit-sqlite/tests/statement_classification.rs`
+  - `scripts/ralph/prd.json`
+  - `scripts/ralph/progress.txt`
+- Checks:
+  - `cargo check -p rivetkit-sqlite`
+  - `cargo test -p rivetkit-sqlite`
+- **Learnings for future iterations:**
+  - SQLite reports raw `BEGIN` and `SAVEPOINT` as readonly, so authorizer transaction-control capture must block reader routing separately.
+  - `sqlite3_prepare_v2` exposes unconsumed trailing SQL through the tail pointer; non-whitespace tail text should make reader routing ineligible.
+  - Existing `rivetkit-sqlite` builds currently emit pre-existing Rust 2024 unsafe-op warnings from `src/vfs.rs`, but the package check and tests pass.
+---
+## 2026-04-29 04:33:10 PDT - US-002
+- Implemented split native SQLite ownership with `NativeVfsHandle`, `NativeConnection`, and the existing `NativeDatabase` compatibility wrapper.
+- Added generation-bearing envoy VFS names and tests for shared VFS context reuse plus unregister-after-last-connection cleanup.
+- Files changed:
+  - `rivetkit-rust/packages/rivetkit-sqlite/src/database.rs`
+  - `rivetkit-rust/packages/rivetkit-sqlite/src/vfs.rs`
+  - `scripts/ralph/prd.json`
+  - `scripts/ralph/progress.txt`
+- Checks:
+  - `cargo check -p rivetkit-sqlite`
+  - `cargo test -p rivetkit-sqlite native_vfs_handle --lib`
+  - `cargo test -p rivetkit-sqlite`
+- **Learnings for future iterations:**
+  - `sqlite3_vfs_register` duplicate-name behavior is not a good lifetime assertion; use `sqlite3_vfs_find` when tests need to inspect VFS registration state.
+  - Keeping a `NativeVfsHandle` clone inside each `NativeConnection` makes close ordering fail-closed even if a connection outlives its manager wrapper.
+  - `cargo test -p rivetkit-sqlite` may emit existing Rust 2024 unsafe-op warnings from `src/vfs.rs`; this session's full rerun passed.
+---
+## 2026-04-29 04:43:03 PDT - US-003
+- Implemented native SQLite VFS reader/writer roles on main and auxiliary file handles, including output flag normalization from assigned role.
+- Reader-owned VFS handles now reject mutating callbacks: xWrite, xTruncate, dirty xSync/xClose, xDelete for reader-owned aux files, and atomic-write file-control operations.
+- Added inline VFS tests for reader fail-closed behavior, writer write behavior, reader aux creation denial, output flags, and reader-owned aux delete rejection.
+- Files changed:
+  - `rivetkit-rust/packages/rivetkit-sqlite/src/vfs.rs`
+  - `scripts/ralph/prd.json`
+  - `scripts/ralph/progress.txt`
+- Checks:
+  - `cargo check -p rivetkit-sqlite`
+  - `cargo test -p rivetkit-sqlite vfs_file --lib`
+  - `cargo test -p rivetkit-sqlite role_flags --lib`
+  - `cargo test -p rivetkit-sqlite reader_owned_aux_files_reject_delete --lib`
+  - `cargo test -p rivetkit-sqlite`
+- **Learnings for future iterations:**
+  - VFS role enforcement belongs in `VfsFile`, not only connection setup, because SQLite mutating callbacks arrive through file handles.
+  - Reader auxiliary-file creation is denied by default; only existing auxiliary paths can be opened read-only until a safe path class is explicitly documented in code.
+  - `cargo test -p rivetkit-sqlite` still emits existing Rust 2024 unsafe-op warnings from VFS callbacks, but the full suite passes.
+---
+## 2026-04-29 04:54:49 PDT - US-004
+- Implemented `NativeConnectionManager` with closed, read-mode, write-mode, and closing states, lazy read-only connection admission up to a max reader count, writer preference, read-to-write transition cleanup, and close-time VFS teardown.
+- Added VFS-backed tests for read admission, writer preference, read-to-write transition state, and close ordering through VFS unregister.
+- Files changed:
+  - `rivetkit-rust/packages/rivetkit-sqlite/src/connection_manager.rs`
+  - `rivetkit-rust/packages/rivetkit-sqlite/src/lib.rs`
+  - `rivetkit-rust/packages/rivetkit-sqlite/src/vfs.rs`
+  - `scripts/ralph/prd.json`
+  - `scripts/ralph/progress.txt`
+- Checks:
+  - `cargo check -p rivetkit-sqlite`
+  - `cargo test -p rivetkit-sqlite connection_manager --lib`
+  - `cargo test -p rivetkit-sqlite bench_large_tx_insert_100mb --lib`
+  - `cargo test -p rivetkit-sqlite`
+- **Learnings for future iterations:**
+  - The connection manager is present as a native primitive but existing query/run/exec routing is intentionally unchanged until US-005 and later stories.
+  - SQL executed through the native VFS should run on blocking threads, because VFS callbacks synchronously block on the transport runtime.
+  - A full-suite run briefly failed the existing 100 MiB large-transaction test with a staged-delta decode error, but the single test and the full suite both passed on rerun.
+---
+## 2026-04-29 05:04:08 PDT - US-005
+- Implemented exclusive write-mode routing for native SQLite run, query, exec, startup configuration, and batch-atomic verification through `NativeConnectionManager`.
+- Added transaction-aware writer retention: raw `BEGIN` and `SAVEPOINT` keep the manager in write mode until `COMMIT` or `ROLLBACK` restores autocommit.
+- Added manager tests proving pending readers wait behind manual `BEGIN` and `SAVEPOINT` write mode, alongside the existing writer-preference coverage.
+- Files changed:
+  - `rivetkit-rust/packages/rivetkit-core/src/actor/sqlite.rs`
+  - `rivetkit-rust/packages/rivetkit-sqlite/src/connection_manager.rs`
+  - `rivetkit-rust/packages/rivetkit-sqlite/src/database.rs`
+  - `rivetkit-rust/packages/rivetkit-sqlite/src/vfs.rs`
+  - `scripts/ralph/prd.json`
+  - `scripts/ralph/progress.txt`
+- Checks:
+  - `cargo check -p rivetkit-sqlite`
+  - `cargo check -p rivetkit-core`
+  - `cargo test -p rivetkit-sqlite connection_manager --lib`
+  - `cargo test -p rivetkit-sqlite`
+  - `cargo test -p rivetkit-core` was stopped after an unrelated actor-task log assertion failed and a separate actor-task test hung past 60 seconds; both reproduce outside SQLite-focused changes.
+- **Learnings for future iterations:**
+  - Per-connection SQLite PRAGMAs need to run when a writer connection is newly opened, not when reusing a transaction-held writer.
+  - Raw transaction-control statements must be treated as write-mode state changes even when SQLite reports them as read-only.
+  - The full `rivetkit-core` suite currently has non-SQLite actor-task test instability in `actor_task_logs_lifecycle_dispatch_and_actor_event_flow` and `save_tick_cancels_pending_inspector_deadline_and_broadcasts_overlay`.
+---
+## 2026-04-29 05:21:13 PDT - US-006
+- Implemented read-only query routing through native read connections, including lazy reader opens, idle reader reuse, per-reader `PRAGMA query_only = ON`, and fallback to write mode only for classification-ineligible statements.
+- Added a mandatory reader authorizer that denies transaction control, attach/detach, schema/temp/data writes, unsafe pragmas, and unsafe functions, with fail-closed behavior when reader execution rejects a statement.
+- Moved native SQLite connection opens onto blocking threads because opening a VFS-backed connection can invoke callbacks that synchronously block on the transport runtime.
+- Files changed:
+  - `rivetkit-rust/packages/rivetkit-sqlite/src/connection_manager.rs`
+  - `rivetkit-rust/packages/rivetkit-sqlite/src/database.rs`
+  - `rivetkit-rust/packages/rivetkit-sqlite/src/query.rs`
+  - `rivetkit-rust/packages/rivetkit-sqlite/src/vfs.rs`
+  - `scripts/ralph/prd.json`
+  - `scripts/ralph/progress.txt`
+- Checks:
+  - `cargo check -p rivetkit-sqlite`
+  - `cargo test -p rivetkit-sqlite native_database_routes_concurrent_readonly_queries_to_multiple_readers --lib`
+  - `cargo test -p rivetkit-sqlite native_database_reuses_idle_reader_for_readonly_query --lib`
+  - `cargo test -p rivetkit-sqlite native_database_reader_authorizer_denies_unsafe_functions --lib`
+  - `timeout 240s cargo test -p rivetkit-sqlite`
+- **Learnings for future iterations:**
+  - Reader routing should treat classification errors as write-required, but errors after a statement is classified reader-eligible should fail closed instead of silently retrying on the writer.
+  - `sqlite3_open_v2` can invoke VFS callbacks, so read and write connection opens need the same blocking-thread treatment as SQL execution.
+  - A held reader plus a timed read-only query is a deterministic way to prove queries are using read-mode instead of waiting behind write-mode.
+---
+## 2026-04-29 05:28:16 PDT - US-007
+- Implemented a native single-statement execute API that returns rows, columns, changes, last insert row id, and route metadata.
+- Routed `NativeDatabaseHandle::query` and `run` through the native execute path while leaving `exec` as the multi-statement compatibility path.
+- Updated core inspector database execution to use the native execute path through `ActorContext::db_execute`.
+- Files changed:
+  - `CLAUDE.md`
+  - `rivetkit-rust/packages/rivetkit-core/src/actor/context.rs`
+  - `rivetkit-rust/packages/rivetkit-core/src/actor/mod.rs`
+  - `rivetkit-rust/packages/rivetkit-core/src/actor/sqlite.rs`
+  - `rivetkit-rust/packages/rivetkit-core/src/registry/inspector.rs`
+  - `rivetkit-rust/packages/rivetkit-sqlite/src/database.rs`
+  - `rivetkit-rust/packages/rivetkit-sqlite/src/query.rs`
+  - `scripts/ralph/prd.json`
+  - `scripts/ralph/progress.txt`
+- Checks:
+  - `cargo check -p rivetkit-sqlite`
+  - `cargo test -p rivetkit-sqlite execute_single_statement --lib`
+  - `cargo check -p rivetkit-core`
+  - `timeout 240s cargo test -p rivetkit-sqlite`
+- **Learnings for future iterations:**
+  - `ExecuteRoute` metadata is assigned by the database routing layer; the low-level query helper only prepares, steps, and packages the supplied route.
+  - The native execute helper rejects multi-statement SQL by checking SQLite's prepare tail. Use `exec` when multi-statement compatibility is required.
+  - Inspector database execution should use `db_execute` so INSERT RETURNING and write statements go through the same native routing policy as user database calls.
+---
+## 2026-04-29 05:36:07 PDT - US-008
+- Exposed native SQLite `execute` and forced-writer `executeWrite` through `rivetkit-napi` and the TypeScript native database wrapper.
+- Removed TS-side per-query serialization from native, raw, and Drizzle database paths; single-statement calls now route through native `execute`, while multi-statement compatibility stays on `exec`.
+- Added a native wrapper close gate so close waits for admitted calls and rejects new work, plus migration `writeMode` so migration hooks use writer execution.
+- Files changed:
+  - `rivetkit-rust/packages/rivetkit-core/src/actor/sqlite.rs`
+  - `rivetkit-rust/packages/rivetkit-sqlite/src/database.rs`
+  - `rivetkit-typescript/packages/rivetkit-napi/src/database.rs`
+  - `rivetkit-typescript/packages/rivetkit-napi/index.d.ts`
+  - `rivetkit-typescript/packages/rivetkit/src/common/database/config.ts`
+  - `rivetkit-typescript/packages/rivetkit/src/common/database/mod.ts`
+  - `rivetkit-typescript/packages/rivetkit/src/common/database/native-database.ts`
+  - `rivetkit-typescript/packages/rivetkit/src/common/database/native-database.test.ts`
+  - `rivetkit-typescript/packages/rivetkit/src/db/drizzle.ts`
+  - `scripts/ralph/prd.json`
+  - `scripts/ralph/progress.txt`
+- Checks:
+  - `cargo check -p rivetkit-sqlite`
+  - `cargo check -p rivetkit-core`
+  - `cargo check -p rivetkit-napi`
+  - `timeout 240s cargo test -p rivetkit-sqlite`
+  - `pnpm --dir rivetkit-typescript/packages/rivetkit run check-types`
+  - `pnpm --dir rivetkit-typescript/packages/rivetkit exec vitest run src/common/database/native-database.test.ts`
+  - `pnpm --dir rivetkit-typescript/packages/rivetkit exec biome check src/common/database/native-database.ts src/common/database/native-database.test.ts src/common/database/mod.ts src/db/drizzle.ts`
+  - `pnpm --dir rivetkit-typescript/packages/rivetkit run lint` is still blocked by pre-existing unrelated Biome errors in driver fixtures and tests.
+- **Learnings for future iterations:**
+  - Use `SqliteDatabase.execute` in TypeScript wrappers for single statements so native classification owns read/write routing.
+  - A close gate is enough for TS wrapper lifecycle safety; write serialization belongs in the native connection manager.
+  - NAPI-generated route metadata is typed as `string` in `index.d.ts`, so the TS wrapper should normalize it before exposing the public union.
+---
+## 2026-04-29 05:45:00 PDT - US-009
+- Added central SQLite read-pool rollout flags for enabled/disabled state, max readers, and idle reader TTL, then wired `open_database_from_envoy` through `NativeConnectionManagerConfig::from_optimization_flags`.
+- Added read-pool Prometheus metrics for reader gauges, wait histograms, routed reads, write fallbacks, manual transaction duration, reader opens/closes, rejected reader mutations, and mode transitions.
+- Preserved disabled single-writer behavior by routing all statements through the writer when `RIVETKIT_SQLITE_OPT_READ_POOL_ENABLED=false`, with a regression test proving SELECT does not open readers.
+- Files changed:
+  - `engine/packages/sqlite-storage/src/optimization_flags.rs`
+  - `rivetkit-rust/packages/rivetkit-sqlite/src/connection_manager.rs`
+  - `rivetkit-rust/packages/rivetkit-sqlite/src/database.rs`
+  - `rivetkit-rust/packages/rivetkit-sqlite/src/vfs.rs`
+  - `rivetkit-rust/packages/rivetkit-core/src/actor/metrics.rs`
+  - `rivetkit-rust/packages/rivetkit-core/tests/metrics.rs`
+  - `examples/kitchen-sink/scripts/sqlite-realworld-bench.ts`
+  - `engine/packages/sqlite-storage/AGENTS.md`
+  - `scripts/ralph/prd.json`
+  - `scripts/ralph/progress.txt`
+- Checks:
+  - `cargo check -p sqlite-storage`
+  - `cargo check -p rivetkit-sqlite`
+  - `cargo check -p rivetkit-core`
+  - `cargo check -p rivetkit-core --features sqlite`
+  - `cargo test -p sqlite-storage optimization_flags`
+  - `cargo test -p rivetkit-sqlite disabled_read_pool_routes_select_through_single_writer --lib`
+  - `cargo test -p rivetkit-core --features sqlite sqlite_read_pool_metrics_render`
+  - `timeout 240s cargo test -p rivetkit-sqlite`
+  - `pnpm --dir examples/kitchen-sink test`
+- **Learnings for future iterations:**
+  - The read pool is enabled by default to preserve prior native parallel-read behavior; disabled mode intentionally keeps one writer connection open and reports readonly statements as write fallbacks.
+  - Existing actor metrics already implement the SQLite VFS metrics trait, so read-pool internals can be exposed by extending that trait without adding a second metrics plumbing path.
+  - Idle reader TTL cleanup is lazy on read admission; there is no background timer for reader expiry.
+---
+## 2026-04-29 05:49:07 PDT - US-010
+- Implemented kitchen-sink SQLite real-world benchmark reporting for read-pool route and transition metrics, including routed reads, write fallbacks, mode transitions, reader opens, and reader closes in both console output and `summary.md`.
+- Tightened the static benchmark test so the runner and actor workload catalogs remain in sync and read-pool metric reporting stays visible.
+- Added a reusable examples agent note for kitchen-sink SQLite real-world benchmark catalog sync and summary reporting.
+- Files changed:
+  - `examples/CLAUDE.md`
+  - `examples/kitchen-sink/scripts/sqlite-realworld-bench.ts`
+  - `examples/kitchen-sink/tests/sqlite-realworld-bench.test.ts`
+  - `scripts/ralph/prd.json`
+  - `scripts/ralph/progress.txt`
+- Checks:
+  - `pnpm --dir examples/kitchen-sink test`
+  - `pnpm --dir examples/kitchen-sink exec tsx scripts/sqlite-realworld-bench.ts --help`
+  - `pnpm --dir examples/kitchen-sink exec biome check --formatter-enabled=false --assist-enabled=false scripts/sqlite-realworld-bench.ts tests/sqlite-realworld-bench.test.ts`
+  - `pnpm --dir examples/kitchen-sink run check-types` is the package-declared typecheck and currently prints `skipped - workflow history types broken`.
+  - Direct `tsc --noEmit` remains blocked by pre-existing kitchen-sink/server, Drizzle dependency, and workflow declaration errors outside this story.
+- **Learnings for future iterations:**
+  - `sqlite_read_pool_mode_transitions_total` is label-bearing, so benchmark metric parsing should sum all series for a metric family instead of taking the first sample.
+  - Scrape actor metrics once per workload and derive VFS plus read-pool snapshots from the same Prometheus text to keep reported counters comparable.
+  - The kitchen-sink package intentionally stubs `check-types`; use its static tests and a `tsx --help` smoke parse for benchmark-script-only changes unless the broader TypeScript config is repaired.
+---
+## 2026-04-29 06:03:27 PDT - US-011
+- Added lifecycle and fencing stress coverage for native SQLite reader pools, including shutdown close ordering, reader fence mismatch fail-closed behavior, generation-specific VFS names, raw manual transaction write-mode retention, and shared routing gates for inspector/user operations.
+- Fixed a manual transaction self-deadlock by routing work through the held writer while the manager is already in write mode.
+- Files changed:
+  - `AGENTS.md`
+  - `rivetkit-rust/packages/rivetkit-sqlite/src/connection_manager.rs`
+  - `rivetkit-rust/packages/rivetkit-sqlite/src/database.rs`
+  - `rivetkit-rust/packages/rivetkit-sqlite/src/vfs.rs`
+  - `scripts/ralph/prd.json`
+  - `scripts/ralph/progress.txt`
+- Checks:
+  - `cargo test -p rivetkit-sqlite native_database --lib`
+  - `cargo test -p rivetkit-sqlite connection_manager --lib`
+  - `cargo test -p rivetkit-sqlite actor_replacement_generation_uses_distinct_vfs_registration_name --lib`
+  - `cargo test -p rivetkit-sqlite --lib -- --test-threads=1`
+  - `cargo test -p rivetkit-sqlite`
+  - `cargo check -p rivetkit-sqlite`
+- **Learnings for future iterations:**
+  - If `NativeConnectionManager` holds an idle writer for a raw transaction, `NativeDatabaseHandle::execute` must bypass reader classification and reuse that writer for later statements such as `COMMIT`.
+  - Fence-mismatch tests need to clear the VFS page caches after setup so the stale reader is forced to fetch through the engine and observe the replacement generation.
+  - Native VFS registration tests can affect later tests because SQLite's VFS list is process-global; drop the stale registration before the replacement registration during cleanup.
+---
+## 2026-04-29 06:05:43 PDT - US-012
+- Documented the SQLite read-mode/write-mode connection manager invariant in internal VFS docs, including exclusive write mode, no reader/write overlap, and the native routing policy boundary.
+- Moved the read-mode/write-mode manager tracker entry from recommended work into existing optimizations.
+- Preserved the reusable invariant in the root agent notes for future SQLite changes.
+- Files changed:
+  - `AGENTS.md`
+  - `docs-internal/engine/sqlite-vfs.md`
+  - `docs-internal/engine/SQLITE_OPTIMIZATIONS.md`
+  - `scripts/ralph/prd.json`
+  - `scripts/ralph/progress.txt`
+- Checks:
+  - `cargo check -p rivetkit-sqlite`
+- **Learnings for future iterations:**
+  - Read-pool v1 intentionally avoids reader/writer overlap instead of pinning per-reader head txids or snapshots.
+  - Internal SQLite docs are the right home for cross-layer invariants; keep the optimization tracker limited to benchmark and performance status.
+  - Root `AGENTS.md` already has a SQLite Package section for short reusable constraints that should apply across future implementation work.
+---
diff --git a/scripts/ralph/archive/2026-04-29-rivetkit-core-wasm-support/prd.json b/scripts/ralph/archive/2026-04-29-rivetkit-core-wasm-support/prd.json
new file mode 100644
index 0000000000..2d289bae93
--- /dev/null
+++ b/scripts/ralph/archive/2026-04-29-rivetkit-core-wasm-support/prd.json
@@ -0,0 +1,325 @@
+{
+  "project": "RivetKit Core WebAssembly Support",
+  "branchName": "04-29-chore_rivetkit_wasm_support",
+  "description": "Add remote SQLite execution for runtimes without native SQLite and make RivetKit core compile and run with a WebAssembly-compatible envoy transport.",
+  "userStories": [
+    {
+      "id": "US-001",
+      "title": "Add envoy protocol v4 remote SQL messages",
+      "description": "As a runtime developer, I need versioned envoy protocol messages for SQL execution so that actor runtimes can request SQLite work from pegboard-envoy.",
+      "acceptanceCriteria": [
+        "Add `engine/sdks/schemas/envoy-protocol/v4.bare` without modifying any existing published `*.bare` protocol version",
+        "Add SQL bind/value/result types covering null, integer, float, text, and blob values",
+        "Add request and response messages for exec, execute, and execute_write style SQL execution",
+        "Regenerate Rust and TypeScript protocol artifacts required by the envoy protocol build",
+        "Update protocol stringifiers for the new remote SQL messages",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 1,
+      "passes": false,
+      "notes": ""
+    },
+    {
+      "id": "US-002",
+      "title": "Guard remote SQL by protocol version",
+      "description": "As an operator, I want old and new envoy protocol versions to fail predictably so that mixed-version rollouts do not decode remote SQL incorrectly.",
+      "acceptanceCriteria": [
+        "Wire protocol v4 in `engine/sdks/rust/envoy-protocol/src/versioned.rs`",
+        "Reject remote SQL messages on protocol versions older than v4 with an explicit structured error",
+        "Add compatibility tests for old core/new pegboard-envoy, new core/old pegboard-envoy, old core/old pegboard-envoy, and new core/new pegboard-envoy behavior",
+        "Document the mixed-version remote SQL behavior in the wasm support spec or protocol tests",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 2,
+      "passes": false,
+      "notes": ""
+    },
+    {
+      "id": "US-003",
+      "title": "Extract reusable SQLite execution types",
+      "description": "As a runtime developer, I want local and remote SQLite execution to share result and routing types so that Node and wasm behavior cannot drift.",
+      "acceptanceCriteria": [
+        "Move or expose reusable SQLite bind parameter, column value, query result, exec result, execute result, and execute route types from `rivetkit-sqlite`",
+        "Keep existing native public behavior unchanged for `query`, `run`, `execute`, `execute_write`, and `exec`",
+        "Keep native statement classification and read/write routing as the authority for the shared execution path",
+        "Add unit tests proving the shared result types preserve rows, columns, changes, last insert row id, and route metadata",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 3,
+      "passes": false,
+      "notes": ""
+    },
+    {
+      "id": "US-004",
+      "title": "Add remote SQL request handling to envoy client",
+      "description": "As RivetKit core, I need an envoy handle API for remote SQL so that `SqliteDb` can await SQL results from pegboard-envoy.",
+      "acceptanceCriteria": [
+        "Add a `ToEnvoyMessage` variant for remote SQL execution requests in `engine/sdks/rust/envoy-client/src/envoy.rs`",
+        "Add remote SQL request ID tracking and response matching in `engine/sdks/rust/envoy-client/src/sqlite.rs`",
+        "Add an `EnvoyHandle` method that sends a remote SQL request and awaits the matching response",
+        "Resolve pending remote SQL requests with `EnvoyShutdownError` during envoy shutdown cleanup",
+        "Add tests for successful response matching, stale protocol rejection, and shutdown cleanup of pending SQL requests",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 4,
+      "passes": false,
+      "notes": ""
+    },
+    {
+      "id": "US-005",
+      "title": "Add SqliteDb backend routing in core",
+      "description": "As a Rivet Actor developer, I want the same database API to use local SQLite on native builds and remote SQLite when configured for no-native runtimes.",
+      "acceptanceCriteria": [
+        "Add `SqliteBackend` variants for local native, remote envoy, and unavailable in `rivetkit-rust/packages/rivetkit-core/src/actor/sqlite.rs`",
+        "Route `query`, `run`, `execute`, `execute_write`, and `exec` through the selected backend without changing public method signatures",
+        "Keep native local SQLite as the default when local SQLite support is enabled",
+        "Require explicit remote SQLite capability before selecting remote execution for no-native builds",
+        "Return a structured remote-unavailable error when remote SQLite is selected but unsupported by the connected envoy",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 5,
+      "passes": false,
+      "notes": ""
+    },
+    {
+      "id": "US-006",
+      "title": "Implement remote SQL execution in pegboard-envoy",
+      "description": "As pegboard-envoy, I need to execute validated SQL requests for the active actor generation so that wasm actor runtimes can use SQLite.",
+      "acceptanceCriteria": [
+        "Dispatch new remote SQL protocol messages from pegboard-envoy connection handling into `sqlite_runtime`",
+        "Validate namespace, actor id, generation, SQL size, bind parameter size, and response size before returning results",
+        "Execute SQL through the shared SQLite execution layer without duplicating statement classification policy",
+        "Return fence mismatch for stale actor generations",
+        "Return structured SQLite execution errors without leaking internal engine errors",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 6,
+      "passes": false,
+      "notes": ""
+    },
+    {
+      "id": "US-007",
+      "title": "Make pegboard-envoy SQL executors lazy and actor-scoped",
+      "description": "As an operator, I want remote SQLite executors created only when used and removed when actors close so that idle actors do not hold unnecessary SQLite resources.",
+      "acceptanceCriteria": [
+        "Create at most one SQL executor per active `(actor_id, generation)` in pegboard-envoy",
+        "Create the SQL executor only on the first accepted remote SQL request",
+        "Prove an actor that declares SQLite but never executes SQL creates no server-side SQL executor",
+        "Remove the SQL executor on `ActorStateStopped` or the equivalent actor close path",
+        "Prove a later actor wake creates a fresh executor for the new generation while persisted database contents remain available",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 7,
+      "passes": false,
+      "notes": ""
+    },
+    {
+      "id": "US-008",
+      "title": "Keep remote SQL off the WebSocket read loop",
+      "description": "As pegboard-envoy, I need long SQL queries to run outside the WebSocket read loop so that pings, stops, and tunnel traffic continue to flow.",
+      "acceptanceCriteria": [
+        "Dispatch remote SQL work to bounded workers instead of executing inline on the pegboard-envoy WebSocket read loop",
+        "Track in-flight remote SQL per `(actor_id, generation)`",
+        "Define actor stop behavior for in-flight SQL as wait, reject, or interrupt within the actor stop budget",
+        "Add tests proving a long SQL query does not block ping/pong, stop, or tunnel message handling",
+        "Add tests proving actor stop never closes storage under an executing SQL query",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 8,
+      "passes": false,
+      "notes": ""
+    },
+    {
+      "id": "US-009",
+      "title": "Handle remote SQL lost-response semantics",
+      "description": "As a runtime developer, I need remote write behavior to be explicit when a WebSocket disconnect loses the response so that writes are not silently replayed.",
+      "acceptanceCriteria": [
+        "Do not blindly retry non-idempotent remote SQL requests after WebSocket disconnect",
+        "Return a structured indeterminate-result error for write requests whose response may have been lost, unless durable request ID deduplication is implemented in this story",
+        "Document the selected lost-response behavior in the wasm support spec or protocol docs",
+        "Add deterministic tests for reconnect during write SQL and duplicate command replay around SQL",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 9,
+      "passes": false,
+      "notes": ""
+    },
+    {
+      "id": "US-010",
+      "title": "Preserve migrations and write-mode parity on remote SQLite",
+      "description": "As a Rivet Actor developer, I want migrations and manual transactions to behave the same on remote SQLite as they do on native SQLite.",
+      "acceptanceCriteria": [
+        "Route `db({ onMigrate })` through remote SQLite with the same migration ordering as native",
+        "Route `writeMode` through remote SQLite with the same writer stickiness as native",
+        "Force writer routing for `execute_write` even when SQL looks read-only",
+        "Keep manual transaction sequences sticky to the writer connection for the same client-side `SqliteDb` handle",
+        "Add parity tests for migrations, `writeMode`, `execute_write`, `BEGIN`, `SAVEPOINT`, `COMMIT`, and `ROLLBACK` across local and remote backends",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 10,
+      "passes": false,
+      "notes": ""
+    },
+    {
+      "id": "US-011",
+      "title": "Expand driver matrix for SQLite backend and runtime",
+      "description": "As a maintainer, I want the driver suite to cover SQLite backend, runtime, and encoding combinations so that native and wasm parity remains visible.",
+      "acceptanceCriteria": [
+        "Add `runtime` and `sqliteBackend` fields to `rivetkit-typescript/packages/rivetkit/tests/driver/shared-types.ts`",
+        "Update `rivetkit-typescript/packages/rivetkit/tests/driver/shared-matrix.ts` to generate native/local/all encodings, native/remote/all encodings, and wasm/remote/all encodings",
+        "Exclude or assert unsupported the invalid wasm/local SQLite matrix cell",
+        "Run existing SQLite driver coverage across `bare`, `cbor`, and `json` for every valid runtime/backend pair",
+        "Add driver tests for lazy remote executor creation and cleanup on actor close",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 11,
+      "passes": false,
+      "notes": ""
+    },
+    {
+      "id": "US-012",
+      "title": "Split envoy client native and wasm transport features",
+      "description": "As a wasm build maintainer, I need envoy WebSocket transport selection to happen in `rivet-envoy-client` so that core does not depend on native networking.",
+      "acceptanceCriteria": [
+        "Add `native-transport` and `wasm-transport` features to `engine/sdks/rust/envoy-client/Cargo.toml`",
+        "Make `tokio-tungstenite` and native rustls WebSocket setup optional behind `native-transport`",
+        "Add optional `wasm-bindgen`, `wasm-bindgen-futures`, `js-sys`, and `web-sys` dependencies behind `wasm-transport`",
+        "Move the current `connection.rs` implementation to `connection/native.rs` with behavior unchanged",
+        "Add `connection/mod.rs` that exposes the stable `start_connection(shared)` API and rejects invalid feature combinations at compile time",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 12,
+      "passes": false,
+      "notes": ""
+    },
+    {
+      "id": "US-013",
+      "title": "Implement wasm envoy WebSocket transport",
+      "description": "As a wasm actor runtime, I need a `web-sys::WebSocket` envoy transport so that core can connect to pegboard-envoy from a browser-compatible worker.",
+      "acceptanceCriteria": [
+        "Add `engine/sdks/rust/envoy-client/src/connection/wasm.rs` using `web-sys::WebSocket` and `wasm_bindgen` closures",
+        "Set binary type to `ArrayBuffer` and decode inbound binary frames into envoy protocol bytes",
+        "Use the same envoy URL query parameters as native: protocol_version, namespace, envoy_key, version, and pool_name",
+        "Use the same subprotocol auth shape as native: `rivet` plus `rivet_token.{token}` when present",
+        "Send initial `ToRivetMetadata` after WebSocket open",
+        "Preserve ping/pong, close-reason parsing, reconnect backoff, and shutdown close behavior",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 13,
+      "passes": false,
+      "notes": ""
+    },
+    {
+      "id": "US-014",
+      "title": "Add core runtime feature gates for wasm",
+      "description": "As a build maintainer, I need `rivetkit-core` features to select native or wasm runtime dependencies so that wasm builds exclude native-only crates.",
+      "acceptanceCriteria": [
+        "Add `native-runtime`, `wasm-runtime`, `sqlite-local`, and `sqlite-remote` features to `rivetkit-rust/packages/rivetkit-core/Cargo.toml`",
+        "Map `native-runtime` to `rivet-envoy-client/native-transport`",
+        "Map `wasm-runtime` to `rivet-envoy-client/wasm-transport`",
+        "Gate `rivetkit-sqlite` behind `sqlite-local` and keep it unavailable for wasm",
+        "Gate or remove wasm-incompatible dependencies including `nix`, native `reqwest` pooling, `rivet-pools`, and native process support",
+        "Typecheck passes"
+      ],
+      "priority": 14,
+      "passes": false,
+      "notes": ""
+    },
+    {
+      "id": "US-015",
+      "title": "Gate native-only core modules",
+      "description": "As a wasm build maintainer, I need native-only core modules to fail explicitly or compile out so that the wasm target can build cleanly.",
+      "acceptanceCriteria": [
+        "Gate `rivetkit-rust/packages/rivetkit-core/src/engine_process.rs` behind `native-runtime`",
+        "Gate native serverless helpers and any native-only exports in `rivetkit-core/src/lib.rs`",
+        "Split pure request/response parsing from native HTTP assumptions in `rivetkit-core/src/serverless.rs`",
+        "Move runner config HTTP fetches behind an `HttpClient` abstraction or an explicit wasm unsupported error",
+        "Add tests or compile checks proving unsupported wasm surfaces return explicit configuration errors instead of silently no-oping",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 15,
+      "passes": false,
+      "notes": ""
+    },
+    {
+      "id": "US-016",
+      "title": "Add wasm-safe runtime spawning and callback model",
+      "description": "As a wasm runtime author, I need core lifecycle tasks and host callbacks to work without native `Send` executor assumptions.",
+      "acceptanceCriteria": [
+        "Introduce a runtime spawn helper or `RuntimeSpawner` abstraction for core-owned lifecycle tasks",
+        "Replace direct native spawn assumptions in actor lifecycle spawn sites with the new helper",
+        "Keep native behavior using Send-capable spawning",
+        "Add a wasm-local callback design for JS promises and closures or explicitly route JS promises through a wrapper that avoids requiring `Send`",
+        "Add compile checks or tests covering native callbacks and wasm-local callback compilation",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 16,
+      "passes": false,
+      "notes": ""
+    },
+    {
+      "id": "US-017",
+      "title": "Add wasm build and dependency gates",
+      "description": "As a release engineer, I need a repeatable wasm compile gate so that native networking dependencies cannot regress into the wasm build.",
+      "acceptanceCriteria": [
+        "Add a checked command or CI-friendly script for `cargo check -p rivetkit-core --target wasm32-unknown-unknown --no-default-features --features wasm-runtime,sqlite-remote`",
+        "Verify the wasm dependency tree excludes `rivetkit-sqlite`, `libsqlite3-sys`, `tokio-tungstenite`, `mio`, `nix`, native `reqwest` pooling, and engine process spawning",
+        "Document the wasm build command in the wasm support spec or a repo-local build note",
+        "Add a failing check or test fixture that catches accidental native transport enablement on wasm",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 17,
+      "passes": false,
+      "notes": ""
+    },
+    {
+      "id": "US-018",
+      "title": "Add wasm Web Worker smoke coverage",
+      "description": "As a RivetKit maintainer, I want a browser-compatible Web Worker smoke test so that wasm core can prove actor lifecycle and remote SQLite work end to end.",
+      "acceptanceCriteria": [
+        "Add a wasm JS wrapper package or test harness that loads `rivetkit-core` in a browser-compatible Web Worker host",
+        "Verify envoy WebSocket subprotocol-token auth works from the selected wasm host",
+        "Start an actor, receive a command from pegboard-envoy, run an action, persist state, use KV, and execute SQLite remotely",
+        "Add deterministic smoke coverage for reconnect during action and reconnect during remote write SQL",
+        "Ensure native NAPI tests continue to run separately and do not depend on the wasm wrapper",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 18,
+      "passes": false,
+      "notes": ""
+    },
+    {
+      "id": "US-019",
+      "title": "Document remote SQLite and wasm runtime invariants",
+      "description": "As a future maintainer, I want the new remote SQLite and wasm transport invariants documented so that later changes do not break parity.",
+      "acceptanceCriteria": [
+        "Update `.agent/specs/rivetkit-core-wasm-support.md` with any implementation decisions made during the stories",
+        "Document that wasm uses remote SQLite only and wasm/local SQLite is an invalid driver matrix cell",
+        "Document that pegboard-envoy creates SQL executors lazily on first use and removes them on actor close",
+        "Document that `rivet-envoy-client` owns native vs wasm WebSocket implementation selection",
+        "Document mixed-version rollout behavior for remote SQL protocol v4",
+        "Typecheck passes"
+      ],
+      "priority": 19,
+      "passes": false,
+      "notes": ""
+    }
+  ]
+}
diff --git a/scripts/ralph/archive/2026-04-29-rivetkit-core-wasm-support/progress.txt b/scripts/ralph/archive/2026-04-29-rivetkit-core-wasm-support/progress.txt
new file mode 100644
index 0000000000..1cda28119e
--- /dev/null
+++ b/scripts/ralph/archive/2026-04-29-rivetkit-core-wasm-support/progress.txt
@@ -0,0 +1,3 @@
+# Ralph Progress Log
+Started: Wed Apr 29 2026
+---
diff --git a/scripts/ralph/archive/2026-05-01-wasm-binding-cleanup-review/prd.json b/scripts/ralph/archive/2026-05-01-wasm-binding-cleanup-review/prd.json
new file mode 100644
index 0000000000..762a1b04ca
--- /dev/null
+++ b/scripts/ralph/archive/2026-05-01-wasm-binding-cleanup-review/prd.json
@@ -0,0 +1,405 @@
+{
+  "project": "RivetKit Core WebAssembly Support",
+  "branchName": "04-29-chore_rivetkit_wasm_support",
+  "description": "Add remote SQLite execution for runtimes without native SQLite and make RivetKit core compile and run with a WebAssembly-compatible envoy transport.",
+  "userStories": [
+    {
+      "id": "US-001",
+      "title": "Add envoy protocol v4 remote SQL messages",
+      "description": "As a runtime developer, I need versioned envoy protocol messages for SQL execution so that actor runtimes can request SQLite work from pegboard-envoy.",
+      "acceptanceCriteria": [
+        "Add `engine/sdks/schemas/envoy-protocol/v4.bare` without modifying any existing published `*.bare` protocol version",
+        "Add SQL bind/value/result types covering null, integer, float, text, and blob values",
+        "Add request and response messages for exec, execute, and execute_write style SQL execution",
+        "Regenerate Rust and TypeScript protocol artifacts required by the envoy protocol build",
+        "Update protocol stringifiers for the new remote SQL messages",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 1,
+      "passes": true,
+      "notes": ""
+    },
+    {
+      "id": "US-002",
+      "title": "Guard remote SQL by protocol version",
+      "description": "As an operator, I want old and new envoy protocol versions to fail predictably so that mixed-version rollouts do not decode remote SQL incorrectly.",
+      "acceptanceCriteria": [
+        "Wire protocol v4 in `engine/sdks/rust/envoy-protocol/src/versioned.rs`",
+        "Reject remote SQL messages on protocol versions older than v4 with an explicit structured error",
+        "Add compatibility tests for old core/new pegboard-envoy, new core/old pegboard-envoy, old core/old pegboard-envoy, and new core/new pegboard-envoy behavior",
+        "Document the mixed-version remote SQL behavior in the wasm support spec or protocol tests",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 2,
+      "passes": true,
+      "notes": ""
+    },
+    {
+      "id": "US-003",
+      "title": "Extract reusable SQLite execution types",
+      "description": "As a runtime developer, I want local and remote SQLite execution to share result and routing types so that Node and wasm behavior cannot drift.",
+      "acceptanceCriteria": [
+        "Move or expose reusable SQLite bind parameter, column value, query result, exec result, execute result, and execute route types from `rivetkit-sqlite`",
+        "Keep existing native public behavior unchanged for `query`, `run`, `execute`, `execute_write`, and `exec`",
+        "Keep native statement classification and read/write routing as the authority for the shared execution path",
+        "Add unit tests proving the shared result types preserve rows, columns, changes, last insert row id, and route metadata",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 3,
+      "passes": true,
+      "notes": ""
+    },
+    {
+      "id": "US-004",
+      "title": "Add remote SQL request handling to envoy client",
+      "description": "As RivetKit core, I need an envoy handle API for remote SQL so that `SqliteDb` can await SQL results from pegboard-envoy.",
+      "acceptanceCriteria": [
+        "Add a `ToEnvoyMessage` variant for remote SQL execution requests in `engine/sdks/rust/envoy-client/src/envoy.rs`",
+        "Add remote SQL request ID tracking and response matching in `engine/sdks/rust/envoy-client/src/sqlite.rs`",
+        "Add an `EnvoyHandle` method that sends a remote SQL request and awaits the matching response",
+        "Resolve pending remote SQL requests with `EnvoyShutdownError` during envoy shutdown cleanup",
+        "Add tests for successful response matching, stale protocol rejection, and shutdown cleanup of pending SQL requests",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 4,
+      "passes": true,
+      "notes": ""
+    },
+    {
+      "id": "US-005",
+      "title": "Add SqliteDb backend routing in core",
+      "description": "As a Rivet Actor developer, I want the same database API to use local SQLite on native builds and remote SQLite when configured for no-native runtimes.",
+      "acceptanceCriteria": [
+        "Add `SqliteBackend` variants for local native, remote envoy, and unavailable in `rivetkit-rust/packages/rivetkit-core/src/actor/sqlite.rs`",
+        "Route `query`, `run`, `execute`, `execute_write`, and `exec` through the selected backend without changing public method signatures",
+        "Keep native local SQLite as the default when local SQLite support is enabled",
+        "Require explicit remote SQLite capability before selecting remote execution for no-native builds",
+        "Return a structured remote-unavailable error when remote SQLite is selected but unsupported by the connected envoy",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 5,
+      "passes": true,
+      "notes": ""
+    },
+    {
+      "id": "US-006",
+      "title": "Implement remote SQL execution in pegboard-envoy",
+      "description": "As pegboard-envoy, I need to execute validated SQL requests for the active actor generation so that wasm actor runtimes can use SQLite.",
+      "acceptanceCriteria": [
+        "Dispatch new remote SQL protocol messages from pegboard-envoy connection handling into `sqlite_runtime`",
+        "Validate namespace, actor id, generation, SQL size, bind parameter size, and response size before returning results",
+        "Execute SQL through the shared SQLite execution layer without duplicating statement classification policy",
+        "Return fence mismatch for stale actor generations",
+        "Return structured SQLite execution errors without leaking internal engine errors",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 6,
+      "passes": true,
+      "notes": ""
+    },
+    {
+      "id": "US-007",
+      "title": "Make pegboard-envoy SQL executors lazy and actor-scoped",
+      "description": "As an operator, I want remote SQLite executors created only when used and removed when actors close so that idle actors do not hold unnecessary SQLite resources.",
+      "acceptanceCriteria": [
+        "Create at most one SQL executor per active `(actor_id, generation)` in pegboard-envoy",
+        "Create the SQL executor only on the first accepted remote SQL request",
+        "Prove an actor that declares SQLite but never executes SQL creates no server-side SQL executor",
+        "Remove the SQL executor on `ActorStateStopped` or the equivalent actor close path",
+        "Prove a later actor wake creates a fresh executor for the new generation while persisted database contents remain available",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 7,
+      "passes": true,
+      "notes": ""
+    },
+    {
+      "id": "US-008",
+      "title": "Keep remote SQL off the WebSocket read loop",
+      "description": "As pegboard-envoy, I need long SQL queries to run outside the WebSocket read loop so that pings, stops, and tunnel traffic continue to flow.",
+      "acceptanceCriteria": [
+        "Dispatch remote SQL work to bounded workers instead of executing inline on the pegboard-envoy WebSocket read loop",
+        "Track in-flight remote SQL per `(actor_id, generation)`",
+        "Define actor stop behavior for in-flight SQL as wait, reject, or interrupt within the actor stop budget",
+        "Add tests proving a long SQL query does not block ping/pong, stop, or tunnel message handling",
+        "Add tests proving actor stop never closes storage under an executing SQL query",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 8,
+      "passes": true,
+      "notes": ""
+    },
+    {
+      "id": "US-009",
+      "title": "Handle remote SQL lost-response semantics",
+      "description": "As a runtime developer, I need remote write behavior to be explicit when a WebSocket disconnect loses the response so that writes are not silently replayed.",
+      "acceptanceCriteria": [
+        "Do not blindly retry non-idempotent remote SQL requests after WebSocket disconnect",
+        "Return a structured indeterminate-result error for write requests whose response may have been lost, unless durable request ID deduplication is implemented in this story",
+        "Document the selected lost-response behavior in the wasm support spec or protocol docs",
+        "Add deterministic tests for reconnect during write SQL and duplicate command replay around SQL",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 9,
+      "passes": true,
+      "notes": ""
+    },
+    {
+      "id": "US-010",
+      "title": "Preserve migrations and write-mode parity on remote SQLite",
+      "description": "As a Rivet Actor developer, I want migrations and manual transactions to behave the same on remote SQLite as they do on native SQLite.",
+      "acceptanceCriteria": [
+        "Route `db({ onMigrate })` through remote SQLite with the same migration ordering as native",
+        "Route `writeMode` through remote SQLite with the same writer stickiness as native",
+        "Force writer routing for `execute_write` even when SQL looks read-only",
+        "Keep manual transaction sequences sticky to the writer connection for the same client-side `SqliteDb` handle",
+        "Add parity tests for migrations, `writeMode`, `execute_write`, `BEGIN`, `SAVEPOINT`, `COMMIT`, and `ROLLBACK` across local and remote backends",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 10,
+      "passes": true,
+      "notes": ""
+    },
+    {
+      "id": "US-011",
+      "title": "Expand driver matrix for SQLite backend and runtime",
+      "description": "As a maintainer, I want the driver suite to cover SQLite backend, runtime, and encoding combinations so that native and wasm parity remains visible.",
+      "acceptanceCriteria": [
+        "Add `runtime` and `sqliteBackend` fields to `rivetkit-typescript/packages/rivetkit/tests/driver/shared-types.ts`",
+        "Update `rivetkit-typescript/packages/rivetkit/tests/driver/shared-matrix.ts` to generate native/local/all encodings, native/remote/all encodings, and wasm/remote/all encodings",
+        "Run SQLite-specific driver tests from `rivetkit-typescript/packages/rivetkit/tests/driver/actor-db*.test.ts` and any new database helper suites across `bare`, `cbor`, and `json` for every valid runtime/backend pair",
+        "Do not multiply non-SQLite driver tests by SQLite backend unless a test explicitly needs database behavior",
+        "Exclude wasm/local from normal matrix execution and add a targeted assertion proving local SQLite is unavailable in wasm",
+        "Name registry, runtime, SQLite backend, and encoding in test output for every SQLite driver cell",
+        "Keep wasm/remote/all-encoding tests skipped or smoke-only before phase 2, then require them as a normal driver gate when phase 2 acceptance is claimed",
+        "Add driver tests for lazy remote executor creation and cleanup on actor close",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 11,
+      "passes": true,
+      "notes": ""
+    },
+    {
+      "id": "US-012",
+      "title": "Split envoy client native and wasm transport features",
+      "description": "As a wasm build maintainer, I need envoy WebSocket transport selection to happen in `rivet-envoy-client` so that core does not depend on native networking.",
+      "acceptanceCriteria": [
+        "Add `native-transport` and `wasm-transport` features to `engine/sdks/rust/envoy-client/Cargo.toml`",
+        "Make `tokio-tungstenite` and native rustls WebSocket setup optional behind `native-transport`",
+        "Add optional `wasm-bindgen`, `wasm-bindgen-futures`, `js-sys`, and `web-sys` dependencies behind `wasm-transport`",
+        "Move the current `connection.rs` implementation to `connection/native.rs` with behavior unchanged",
+        "Add `connection/mod.rs` that exposes the stable `start_connection(shared)` API and rejects invalid feature combinations at compile time",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 12,
+      "passes": true,
+      "notes": ""
+    },
+    {
+      "id": "US-013",
+      "title": "Implement wasm envoy WebSocket transport",
+      "description": "As a wasm actor runtime, I need a JavaScript-host WebSocket envoy transport so that core can connect to pegboard-envoy from Supabase Edge Functions and Cloudflare Workers.",
+      "acceptanceCriteria": [
+        "Add `engine/sdks/rust/envoy-client/src/connection/wasm.rs` using `web-sys::WebSocket` and `wasm_bindgen` closures",
+        "Set binary type to `ArrayBuffer` and decode inbound binary frames into envoy protocol bytes",
+        "Use the same envoy URL query parameters as native: protocol_version, namespace, envoy_key, version, and pool_name",
+        "Use the same subprotocol auth shape as native: `rivet` plus `rivet_token.{token}` when present",
+        "Verify the transport works with the WebSocket APIs available in Supabase Edge Functions and Cloudflare Workers",
+        "Send initial `ToRivetMetadata` after WebSocket open",
+        "Preserve ping/pong, close-reason parsing, reconnect backoff, and shutdown close behavior",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 13,
+      "passes": true,
+      "notes": ""
+    },
+    {
+      "id": "US-014",
+      "title": "Add core runtime feature gates for wasm",
+      "description": "As a build maintainer, I need `rivetkit-core` features to select native or wasm runtime dependencies so that wasm builds exclude native-only crates.",
+      "acceptanceCriteria": [
+        "Add `native-runtime`, `wasm-runtime`, `sqlite-local`, and `sqlite-remote` features to `rivetkit-rust/packages/rivetkit-core/Cargo.toml`",
+        "Map `native-runtime` to `rivet-envoy-client/native-transport`",
+        "Map `wasm-runtime` to `rivet-envoy-client/wasm-transport`",
+        "Gate `rivetkit-sqlite` behind `sqlite-local` and keep it unavailable for wasm",
+        "Gate or remove wasm-incompatible dependencies including `nix`, native `reqwest` pooling, `rivet-pools`, and native process support",
+        "Typecheck passes"
+      ],
+      "priority": 14,
+      "passes": true,
+      "notes": ""
+    },
+    {
+      "id": "US-015",
+      "title": "Gate native-only core modules",
+      "description": "As a wasm build maintainer, I need native-only core modules to fail explicitly or compile out so that the wasm target can build cleanly.",
+      "acceptanceCriteria": [
+        "Gate `rivetkit-rust/packages/rivetkit-core/src/engine_process.rs` behind `native-runtime`",
+        "Gate native serverless helpers and any native-only exports in `rivetkit-core/src/lib.rs`",
+        "Split pure request/response parsing from native HTTP assumptions in `rivetkit-core/src/serverless.rs`",
+        "Move runner config HTTP fetches behind an `HttpClient` abstraction or an explicit wasm unsupported error",
+        "Add tests or compile checks proving unsupported wasm surfaces return explicit configuration errors instead of silently no-oping",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 15,
+      "passes": true,
+      "notes": ""
+    },
+    {
+      "id": "US-016",
+      "title": "Add wasm-safe runtime spawning and callback model",
+      "description": "As a wasm runtime author, I need core lifecycle tasks and host callbacks to work without native `Send` executor assumptions.",
+      "acceptanceCriteria": [
+        "Introduce a runtime spawn helper or `RuntimeSpawner` abstraction for core-owned lifecycle tasks",
+        "Replace direct native spawn assumptions in actor lifecycle spawn sites with the new helper",
+        "Keep native behavior using Send-capable spawning",
+        "Add a wasm-local callback design for JS promises and closures or explicitly route JS promises through a wrapper that avoids requiring `Send`",
+        "Add compile checks or tests covering native callbacks and wasm-local callback compilation",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 16,
+      "passes": true,
+      "notes": ""
+    },
+    {
+      "id": "US-017",
+      "title": "Add wasm build and dependency gates",
+      "description": "As a release engineer, I need a repeatable wasm compile gate so that native networking dependencies cannot regress into the wasm build.",
+      "acceptanceCriteria": [
+        "Add a checked command or CI-friendly script for `cargo check -p rivetkit-core --target wasm32-unknown-unknown --no-default-features --features wasm-runtime,sqlite-remote`",
+        "Verify the wasm dependency tree excludes `rivetkit-sqlite`, `libsqlite3-sys`, `tokio-tungstenite`, `mio`, `nix`, native `reqwest` pooling, and engine process spawning",
+        "Document the wasm build command in the wasm support spec or a repo-local build note",
+        "Add a failing check or test fixture that catches accidental native transport enablement on wasm",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 17,
+      "passes": true,
+      "notes": ""
+    },
+    {
+      "id": "US-018",
+      "title": "Spike NAPI-RS wasm binding reuse",
+      "description": "As a runtime maintainer, I need to know whether NAPI-RS wasm can reuse the current NAPI binding surface while still supporting Supabase Edge Functions and Cloudflare Workers.",
+      "acceptanceCriteria": [
+        "Create a minimal NAPI-RS wasm spike using a representative subset of the current `rivetkit-napi` surface: CoreRegistry, CancellationToken, ActorContext, and sql",
+        "Run the spike in Cloudflare Workers/workerd and document the Supabase/Deno implications, not only Node",
+        "Verify whether ThreadsafeFunction, async methods, class wrappers, Buffer or typed-array conversion, and cancellation token wiring work without broad rewrites",
+        "Document whether SharedArrayBuffer, COOP, COEP, wasm threads, and WASI assumptions are acceptable for Supabase and Cloudflare",
+        "Treat Cloudflare Workers' no-threading runtime rule as a blocker unless the spike proves NAPI-RS wasm can avoid threaded requirements",
+        "Verify the spike can use wasm envoy transport and remote SQLite without pulling native-only dependencies",
+        "Record the final binding strategy decision in `.agent/specs/rivetkit-core-wasm-support.md`",
+        "Typecheck passes"
+      ],
+      "priority": 18,
+      "passes": true,
+      "notes": "Completed in /home/nathan/misc/napi-rs-wasm-test. Sync-only NAPI-RS wasm ran in local workerd, but async/callback-style exports failed with thread spawn unsupported. Decision: use direct wasm-bindgen for the mainline edge-host binding."
+    },
+    {
+      "id": "US-019",
+      "title": "Define the shared TypeScript core runtime interface",
+      "description": "As a TypeScript runtime maintainer, I want NAPI and wasm bindings to implement one normalized interface so that the public RivetKit TypeScript API does not fork.",
+      "acceptanceCriteria": [
+        "Add a bridge-neutral TypeScript interface for core runtime bindings under `rivetkit-typescript/packages/rivetkit/src/registry/` or an equivalent shared runtime path",
+        "Define the interface as explicit methods plus opaque handles, not generated binding classes and not a generic command bus",
+        "Use a small handle set: RegistryHandle, ActorFactoryHandle, ActorContextHandle, ConnHandle, WebSocketHandle, and CancellationTokenHandle",
+        "Route KV, SQLite, queue, and schedule operations through ActorContextHandle instead of exposing separate shared-interface handles for each subsystem",
+        "Include explicit methods for registry lifecycle, actor factory creation, actor state/save, KV batch operations, SQLite exec/execute/close, queue send, schedule set alarm, WebSocket send/close, and cancellation token cancellation",
+        "Move runtime-independent actor adaptation out of `registry/native.ts` where needed so it can be shared by NAPI and wasm",
+        "Keep NAPI-specific loading, ThreadsafeFunction behavior, Node Buffer conversion, and native-only assumptions behind a NAPI adapter",
+        "Add unit tests or type tests proving the NAPI adapter satisfies the shared core runtime interface",
+        "Add a static guard or lint check preventing raw `@rivetkit/rivetkit-napi` or `@rivetkit/rivetkit-wasm` imports outside approved runtime adapter files",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 19,
+      "passes": true,
+      "notes": ""
+    },
+    {
+      "id": "US-020",
+      "title": "Add separate wasm binding package",
+      "description": "As a wasm runtime author, I need a separate wasm binding package over `rivetkit-core` that can run in Supabase Edge Functions and Cloudflare Workers.",
+      "acceptanceCriteria": [
+        "Create `rivetkit-typescript/packages/rivetkit-wasm/` or the chosen equivalent package path",
+        "Wrap `rivetkit-core` through direct wasm-bindgen without adding binding exports to `rivetkit-core` itself",
+        "Expose raw wasm bindings needed to implement the shared TypeScript core runtime interface",
+        "Implement JS Promise and `Uint8Array` or ArrayBuffer conversion in the wasm package boundary",
+        "Target `wasm32-unknown-unknown` and package for both Deno/Supabase and Cloudflare Workers",
+        "Keep the existing native `rivetkit-typescript/packages/rivetkit-napi/` package working unchanged for native Node users",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 20,
+      "passes": true,
+      "notes": ""
+    },
+    {
+      "id": "US-021",
+      "title": "Implement wasm adapter for the shared runtime interface",
+      "description": "As a RivetKit TypeScript user, I want the wasm binding to satisfy the same runtime interface as NAPI so that actor definitions use one public API.",
+      "acceptanceCriteria": [
+        "Add `rivetkit-typescript/packages/rivetkit/src/registry/wasm.ts` or the chosen equivalent wasm adapter",
+        "Implement the shared core runtime interface using the selected wasm binding package",
+        "Normalize wasm binding errors into the same RivetError decoding path used by the NAPI adapter",
+        "Normalize wasm SQLite database handles through the same `SqliteDatabase` wrapper behavior used by NAPI where possible",
+        "Add type or unit tests proving NAPI and wasm adapters expose the same normalized interface",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 21,
+      "passes": true,
+      "notes": ""
+    },
+    {
+      "id": "US-022",
+      "title": "Add Supabase and Cloudflare wasm smoke coverage",
+      "description": "As a RivetKit maintainer, I want Supabase Edge Functions and Cloudflare Workers smoke tests so that wasm core can prove actor lifecycle and remote SQLite work end to end.",
+      "acceptanceCriteria": [
+        "Add a Supabase Edge Functions/Deno smoke harness that loads the selected wasm binding package through the shared TypeScript runtime interface",
+        "Add a Cloudflare Workers smoke harness that loads the selected wasm binding package through the shared TypeScript runtime interface",
+        "Verify envoy WebSocket subprotocol-token auth works from the selected wasm host",
+        "Start an actor, receive a command from pegboard-envoy, run an action, persist state, use KV, and execute SQLite remotely",
+        "Add deterministic smoke coverage for reconnect during action and reconnect during remote write SQL",
+        "Ensure native NAPI tests continue to run separately and do not depend on the wasm wrapper",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 22,
+      "passes": true,
+      "notes": ""
+    },
+    {
+      "id": "US-023",
+      "title": "Document remote SQLite and wasm runtime invariants",
+      "description": "As a future maintainer, I want the new remote SQLite and wasm transport invariants documented so that later changes do not break parity.",
+      "acceptanceCriteria": [
+        "Update `.agent/specs/rivetkit-core-wasm-support.md` with any implementation decisions made during the stories",
+        "Document that wasm uses remote SQLite only and wasm/local SQLite is an invalid driver matrix cell",
+        "Document that pegboard-envoy creates SQL executors lazily on first use and removes them on actor close",
+        "Document that `rivet-envoy-client` owns native vs wasm WebSocket implementation selection",
+        "Document the selected wasm binding strategy and that both native NAPI and wasm implement the shared TypeScript core runtime interface",
+        "Document mixed-version rollout behavior for remote SQL protocol v4",
+        "Typecheck passes"
+      ],
+      "priority": 23,
+      "passes": true,
+      "notes": ""
+    }
+  ]
+}
diff --git a/scripts/ralph/archive/2026-05-01-wasm-binding-cleanup-review/progress.txt b/scripts/ralph/archive/2026-05-01-wasm-binding-cleanup-review/progress.txt
new file mode 100644
index 0000000000..0d9038d613
--- /dev/null
+++ b/scripts/ralph/archive/2026-05-01-wasm-binding-cleanup-review/progress.txt
@@ -0,0 +1,288 @@
+# Ralph Progress Log
+
+## Codebase Patterns
+- Use `scripts/cargo/check-rivetkit-core-wasm.sh` as the canonical wasm dependency gate; it runs the wasm `cargo check`, scans `cargo tree -e normal`, checks the feature graph, and asserts native transport/runtime fail on wasm.
+- vbare protocol schemas using hashable maps cannot contain raw `f64` fields because generated Rust derives `Eq` and `Hash`; encode floats as fixed bytes or an ordered wrapper.
+- Envoy protocol version gates should return `versioned::ProtocolCompatibilityError` so callers can downcast compatibility failures and map them to user-facing unavailable errors.
+- Shared SQLite bind/result/route types live in `rivetkit-sqlite-types`; `rivetkit-sqlite::query` and `rivetkit-core::actor::sqlite` re-export them for compatibility.
+- Envoy-client tracks remote SQLite exec/execute requests separately from page-I/O SQLite requests; both queues must drain with `EnvoyShutdownError` on lost envoy or shutdown cleanup.
+- Spawned runtime futures that need tracing assertions should carry the current dispatch with `.with_subscriber(...)`; `.in_current_span()` alone does not preserve a test subscriber across `tokio::spawn`.
+- Pegboard-envoy remote SQL should reuse `rivetkit-sqlite::database::open_database_from_engine` so execution goes through `NativeDatabaseHandle` and the existing SQLite routing policy instead of direct `rusqlite` calls.
+- Pegboard-envoy remote SQL executor cache entries use `Arc<OnceCell<NativeDatabaseHandle>>` so concurrent first SQL requests share one lazy executor per `(actor_id, sqlite_generation)`.
+- Pegboard-envoy remote SQL work runs in bounded per-connection worker tasks and tracks in-flight requests by `(actor_id, sqlite_generation)` so actor close can wait before closing SQLite.
+- Sent remote SQL requests fail with `sqlite.remote_indeterminate_result` on WebSocket disconnect; only unsent remote SQL requests may be sent after reconnect.
+- TypeScript `db({ onMigrate })` runs migrations through `SqliteDatabase.writeMode`, so every `client.execute(...)` inside migration callbacks is forced through write execution for remote SQLite parity.
+- `rivetkit-sqlite` integration tests can use `open_database_from_engine` to exercise the same server-side executor path used by pegboard-envoy remote SQLite.
+- SQLite-specific driver suites opt into `SQLITE_DRIVER_MATRIX_OPTIONS`; backend selection flows from driver config to `RIVETKIT_TEST_SQLITE_BACKEND`, `registry.config.test.sqliteBackend`, and `JsActorConfig.remoteSqlite`.
+- `rivet-envoy-client` transport features are mutually exclusive; native builds use default features, while wasm builds must disable defaults and enable `wasm-transport`.
+- `rivet-envoy-client` keeps wasm WebSocket code behind `target_arch = "wasm32"` and a native-host stub behind `wasm-transport` so developer feature checks do not compile browser APIs.
+- `rivetkit-core` runtime features are mutually exclusive; use `native-runtime` for native transport/process support and `wasm-runtime,sqlite-remote` for wasm remote-SQLite builds.
+- `rivet-envoy-client::async_counter::AsyncCounter` owns the shared HTTP request counter type consumed by core sleep logic, avoiding a broad `rivet-util` dependency in wasm core builds.
+- Crates that compile to `wasm32-unknown-unknown` and generate random IDs or jitter should enable `getrandom/js` plus `uuid/js` on the wasm target, while keeping workspace Tokio/UUID on native targets.
+- `rivetkit-core` tests use Tokio paused time; keep `tokio/test-util` as a dev-only feature so no-default feature tests compile without changing runtime dependencies.
+- Core-owned lifecycle tasks in `rivetkit-core` should spawn through `RuntimeSpawner` so native builds use Send-capable tasks and wasm builds use local tasks.
+- TypeScript actor runtime code should use `CoreRuntime` from `rivetkit/src/registry/runtime.ts`; raw native or wasm binding imports stay in `src/registry/*-runtime.ts` and are guarded by `tests/runtime-import-guard.test.ts`.
+- `@rivetkit/rivetkit-wasm` keeps wasm-pack output under `packages/rivetkit-wasm/pkg/` generated; source exports the raw WebSocket handle as `WebSocketHandle` to avoid shadowing the host `WebSocket` global.
+- The wasm runtime adapter normalizes raw `Uint8Array` handle payloads back to `Buffer` at `src/registry/wasm-runtime.ts`, keeping shared registry code backend-neutral with the NAPI path.
+- Wasm host smoke tests should drive `buildNativeFactory` through `WasmCoreRuntime` fake bindings so actor callbacks, KV, state serialization, remote SQLite routing, and NAPI import boundaries stay covered without requiring generated wasm-pack output.
+
+Started: Wed Apr 29 08:03:50 PM PDT 2026
+---
+## 2026-04-29 22:47:42 PDT - US-017
+- Added `scripts/cargo/check-rivetkit-core-wasm.sh` as the repeatable wasm build gate for `rivetkit-core`.
+- The gate runs the wasm target `cargo check`, scans the normal wasm dependency tree for native-only crates, checks the feature graph for native runtime/transport leaks, and verifies native envoy/core runtime feature selections fail on `wasm32-unknown-unknown`.
+- Documented the gate in `.agent/specs/rivetkit-core-wasm-support.md` and added the reusable command to `AGENTS.md`/`CLAUDE.md`.
+- Files changed: `.agent/specs/rivetkit-core-wasm-support.md`, `AGENTS.md`/`CLAUDE.md`, `scripts/cargo/check-rivetkit-core-wasm.sh`, `scripts/ralph/prd.json`, `scripts/ralph/progress.txt`.
+- Quality checks: `scripts/cargo/check-rivetkit-core-wasm.sh`, `cargo check -p rivetkit-core`.
+- **Learnings for future iterations:**
+  - Use the wasm gate script instead of hand-running only `cargo check`; it also catches normal dependency leaks and accidental native feature selection.
+  - Scan wasm production dependencies with `cargo tree -e normal` so dev-dependencies do not create false native-crate failures.
+  - Negative wasm checks are useful here: native transport/runtime compiling for `wasm32-unknown-unknown` should fail rather than silently becoming part of the wasm path.
+---
+## 2026-04-29 22:45:05 PDT - US-016
+- Added `rivetkit-core::runtime` with `RuntimeSpawner`, `RuntimeBoxFuture`, and `boxed_runtime_future` so native builds keep Send-capable task spawning while wasm builds can compile local futures for JS-promise style callbacks.
+- Routed core actor lifecycle spawn sites through `RuntimeSpawner`, including `ActorTask` run-handler startup, core-dispatched hook replies, registry actor task startup, pending startup stop handoff, and envoy stop completion handoff.
+- Added a wasm-runtime compile test proving the boxed runtime future accepts an `Rc`/`RefCell` local callback without requiring `Send`.
+- Files changed: `CLAUDE.md`/`AGENTS.md`, `rivetkit-rust/packages/rivetkit-core/src/runtime.rs`, `rivetkit-rust/packages/rivetkit-core/src/lib.rs`, `rivetkit-rust/packages/rivetkit-core/src/actor/task.rs`, `rivetkit-rust/packages/rivetkit-core/src/registry/mod.rs`, `rivetkit-rust/packages/rivetkit-core/src/registry/envoy_callbacks.rs`, `scripts/ralph/prd.json`, `scripts/ralph/progress.txt`.
+- Quality checks: `cargo check -p rivetkit-core --no-default-features --features wasm-runtime,sqlite-remote`, `cargo test -p rivetkit-core runtime --no-default-features --features wasm-runtime,sqlite-remote -- --nocapture`, `cargo check -p rivetkit-core`, `cargo check -p rivetkit-core --target wasm32-unknown-unknown --no-default-features --features wasm-runtime,sqlite-remote`, `cargo test -p rivetkit-core lifecycle -- --nocapture`, `cargo test -p rivetkit-core actor_task -- --nocapture`.
+- `cargo check -p rivetkit-core --no-default-features` fails because `rivet-envoy-client` intentionally requires either `native-transport` or `wasm-transport`.
+- **Learnings for future iterations:**
+  - Use `RuntimeSpawner` for core-owned lifecycle tasks instead of direct `tokio::spawn` when the task may need to run under `wasm-runtime`.
+  - Use `RuntimeBoxFuture` or `boxed_runtime_future` for future wasm host callbacks that wrap local JS promises or closures and should not require `Send`.
+  - Bare `--no-default-features` is not a valid core check after the envoy transport split; choose `native-runtime` or `wasm-runtime,sqlite-remote`.
+---
+## 2026-04-29 22:19:45 PDT - US-013
+- Implemented the wasm envoy WebSocket transport with `web_sys::WebSocket`, `wasm_bindgen` event closures, `ArrayBuffer` decoding, binary sends, close handling, and host `setTimeout`-based reconnect sleeps.
+- Shared native metadata, URL, ping/pong, and message-forwarding helpers with the wasm transport while keeping the existing native behavior unchanged.
+- Preserved the same envoy URL query parameters and subprotocol auth shape as native, and checked the current official Cloudflare Workers and Deno WebSocket APIs for constructor, subprotocol, and `binaryType = "arraybuffer"` compatibility.
+- Files changed: `AGENTS.md`/`CLAUDE.md`, `engine/sdks/rust/envoy-client/src/connection/mod.rs`, `engine/sdks/rust/envoy-client/src/connection/wasm.rs`, `scripts/ralph/prd.json`, `scripts/ralph/progress.txt`.
+- Quality checks: `cargo check -p rivet-envoy-client --no-default-features --features wasm-transport`, `cargo check -p rivet-envoy-client`, `cargo test -p rivet-envoy-client`.
+- `cargo check -p rivet-envoy-client --target wasm32-unknown-unknown --no-default-features --features wasm-transport` still fails before reaching envoy-client because `mio` is pulled into the wasm dependency tree through the wider Tokio/rivet-util graph.
+- **Learnings for future iterations:**
+  - Use `wasm_bindgen_futures::spawn_local` for the wasm connection loop because browser WebSocket handles and closures are local JavaScript objects.
+  - Set `WebSocket.binaryType` to `ArrayBuffer` and decode inbound `MessageEvent` payloads through `js_sys::Uint8Array` before vbare protocol decoding.
+  - Prefer global `setTimeout` for wasm transport reconnect delays so the transport matches Cloudflare Worker and Deno/Supabase host APIs without depending on native timer behavior.
+---
+## 2026-04-29 22:15:02 PDT - US-012
+- Split `rivet-envoy-client` WebSocket transport selection into `connection/mod.rs`, `connection/native.rs`, and a compileable `connection/wasm.rs` placeholder.
+- Added mutually exclusive `native-transport` and `wasm-transport` features, kept native transport as the default, and made `rustls` plus `tokio-tungstenite` optional behind `native-transport`.
+- Added optional wasm transport dependencies for `wasm-bindgen`, `wasm-bindgen-futures`, `js-sys`, and `web-sys`.
+- Files changed: `CLAUDE.md`, `Cargo.lock`, `engine/sdks/rust/envoy-client/Cargo.toml`, `engine/sdks/rust/envoy-client/src/connection/mod.rs`, `engine/sdks/rust/envoy-client/src/connection/native.rs`, `engine/sdks/rust/envoy-client/src/connection/wasm.rs`, `scripts/ralph/prd.json`, `scripts/ralph/progress.txt`.
+- Quality checks: `cargo check -p rivet-envoy-client`, `cargo check -p rivet-envoy-client --no-default-features --features native-transport`, `cargo check -p rivet-envoy-client --no-default-features --features wasm-transport`, `cargo test -p rivet-envoy-client`, `cargo check -p rivet-test-envoy`, `cargo check -p rivetkit-core`, `cargo check -p rivetkit-sqlite`.
+- `cargo check -p rivet-envoy-client --target wasm32-unknown-unknown --no-default-features --features wasm-transport` still fails because `rivet-util` pulls workspace `tokio` with native `mio`; that wider dependency gate belongs to the later core wasm gating stories.
+- **Learnings for future iterations:**
+  - Keep the public `connection::start_connection(shared)` and `connection::ws_send(...)` surface stable so actor, KV, SQLite, tunnel, and event modules do not care which transport feature is active.
+  - Downstream wasm consumers must set `default-features = false` on `rivet-envoy-client`; enabling `wasm-transport` on top of defaults intentionally hits the mutually exclusive feature compile error.
+  - `rivet-util` is still a wasm-target blocker for envoy-client because it brings native `tokio`/`mio` through the workspace dependency graph.
+---
+## 2026-04-29 22:09:23 PDT - US-011
+- Expanded the SQLite driver matrix with runtime and SQLite backend dimensions, including native/local, native/remote, and skipped wasm/remote cells across bare, CBOR, and JSON encodings.
+- Threaded the native remote-SQLite backend option through driver runtime env, registry test config, NAPI actor config, and core actor config.
+- Added a remote SQLite lifecycle probe that proves executor creation stays lazy until SQL runs and reopens after actor sleep.
+- Fixed pegboard-envoy remote SQL namespace validation to accept the connection's configured namespace name as well as its resolved namespace id.
+- Reduced raw DB separation-test engine churn by keeping keyed handles while polling count assertions.
+- Files changed: `engine/packages/pegboard-envoy/src/conn.rs`, `engine/packages/pegboard-envoy/src/ws_to_tunnel_task.rs`, `rivetkit-typescript/packages/rivetkit-napi/index.d.ts`, `rivetkit-typescript/packages/rivetkit-napi/src/actor_factory.rs`, `rivetkit-typescript/packages/rivetkit/fixtures/driver-test-suite/actor-db-raw.ts`, `rivetkit-typescript/packages/rivetkit/fixtures/driver-test-suite/registry-static.ts`, `rivetkit-typescript/packages/rivetkit/src/registry/config/index.ts`, `rivetkit-typescript/packages/rivetkit/src/registry/native.ts`, `rivetkit-typescript/packages/rivetkit/tests/driver/actor-db*.test.ts`, `rivetkit-typescript/packages/rivetkit/tests/driver/shared-harness.ts`, `rivetkit-typescript/packages/rivetkit/tests/driver/shared-matrix.ts`, `rivetkit-typescript/packages/rivetkit/tests/driver/shared-matrix.test.ts`, `rivetkit-typescript/packages/rivetkit/tests/driver/shared-types.ts`, `rivetkit-typescript/packages/rivetkit/tests/fixtures/driver-test-suite-runtime.ts`, `scripts/ralph/prd.json`, `scripts/ralph/progress.txt`.
+- Quality checks: `cargo build -p rivet-engine`, `cargo check -p rivetkit-napi`, `pnpm --filter @rivetkit/rivetkit-napi build`, `pnpm --filter rivetkit check-types`, `pnpm --filter rivetkit run check:wait-for-comments`, `pnpm --filter rivetkit test tests/driver/shared-matrix.test.ts`, `pnpm --filter rivetkit test tests/driver/actor-db-raw.test.ts`, `pnpm --filter rivetkit test tests/driver/actor-db-raw.test.ts --testNamePattern "runtime \\(native\\) / sqlite \\(remote\\) / encoding \\(bare\\).*Remote Database Executor Lifecycle"`, `pnpm --filter rivetkit test tests/driver/actor-db-raw.test.ts --testNamePattern "runtime \\(native\\) / sqlite \\(local\\) / encoding \\(bare\\).*maintains separate databases"`.
+- **Learnings for future iterations:**
+  - Remote SQLite requests from native runtime carry the configured namespace name, while pegboard-envoy resolves the connection to a namespace id; validation needs to treat both as the same connection namespace.
+  - `destroy()` creates a new actor and an empty DB on the next `getOrCreate`; use `triggerSleep()` when testing executor cleanup across actor close/wake.
+  - Reissuing `getOrCreate` inside `vi.waitFor` loops can amplify engine load under expanded matrix runs; keep handles stable unless the test specifically needs fresh lookup behavior.
+  - The existing `rivetkit-sqlite` Rust 2024 unsafe-operation warnings still appear during checks and are not caused by this story.
+---
+## 2026-04-29 21:43:16 PDT - US-008
+- Moved pegboard-envoy remote SQLite exec, execute, and execute_write handling off the WebSocket read loop into bounded per-connection worker tasks.
+- Added per-`(actor_id, sqlite_generation)` in-flight counters so actor stop and connection shutdown wait for accepted remote SQL before closing SQLite.
+- Rejected new remote SQL after an actor enters stopping, documented the selected stop behavior, and kept `ActorStateStopped` cleanup from blocking later WebSocket frames.
+- Added focused tests for bounded remote SQL worker dispatch, in-flight stop waiting, executor cache cleanup, and persisted data across lazy executor reopen.
+- Files changed: `.agent/specs/rivetkit-core-wasm-support.md`, `engine/packages/pegboard-envoy/src/conn.rs`, `engine/packages/pegboard-envoy/src/ws_to_tunnel_task.rs`, `engine/packages/pegboard-envoy/src/actor_lifecycle.rs`, `engine/packages/pegboard-envoy/tests/support/ws_to_tunnel_task.rs`, `scripts/ralph/prd.json`, `scripts/ralph/progress.txt`.
+- Quality checks: `cargo test -p pegboard-envoy remote_sqlite -- --nocapture`, `cargo test -p pegboard-envoy ws_to_tunnel_task -- --nocapture`, `cargo check -p pegboard-envoy`.
+- **Learnings for future iterations:**
+  - Remote SQL requests should be counted as in-flight before worker permit acquisition so queued work is visible to actor close.
+  - Actor stop now rejects new remote SQL once `ActiveActorState::Stopping` is set; already accepted requests may finish, and close waits up to the actor stop budget.
+  - `ActorStateStopped` cleanup may wait on SQL drain, so it should run outside the WebSocket read loop.
+  - The existing `rivetkit-sqlite` Rust 2024 unsafe-operation warnings still appear during pegboard-envoy checks and are not caused by this story.
+---
+## 2026-04-29 21:29:19 PDT - US-007
+- Made pegboard-envoy remote SQLite executors lazy and actor-generation scoped with a shared `OnceCell` cache entry per `(actor_id, sqlite_generation)`.
+- Added cache cleanup helpers for actor stop, serverless close, and connection shutdown paths.
+- Added tests proving executor cache entries are lazy, reused for the same generation, removed on actor-scoped cleanup, and recreated with persisted contents after reopen.
+- Files changed: `engine/packages/pegboard-envoy/src/conn.rs`, `engine/packages/pegboard-envoy/src/ws_to_tunnel_task.rs`, `engine/packages/pegboard-envoy/src/actor_lifecycle.rs`, `engine/packages/pegboard-envoy/tests/support/ws_to_tunnel_task.rs`, `scripts/ralph/prd.json`, `scripts/ralph/progress.txt`.
+- Quality checks: `cargo test -p pegboard-envoy remote_sqlite_executor -- --nocapture`, `cargo test -p pegboard-envoy ws_to_tunnel_task -- --nocapture`, `cargo check -p pegboard-envoy`.
+- **Learnings for future iterations:**
+  - Use `OnceCell` inside the `scc::HashMap` value for async lazy initialization. Do not hold an `scc` entry guard across the database open await.
+  - Removing a remote SQL executor cache entry is separate from closing the actor's `SqliteEngine` generation; actor lifecycle paths must do both.
+  - The existing `rivetkit-sqlite` Rust 2024 unsafe-operation warnings still appear during pegboard-envoy checks and are not caused by this story.
+---
+## 2026-04-29 21:18:55 PDT - US-006
+- Wired pegboard-envoy remote SQLite exec, execute, and execute_write protocol messages into server-side execution.
+- Added namespace, actor, active generation, SQL size, bind parameter, and response payload validation for remote SQL requests.
+- Exposed an engine-backed direct SQLite opener in `rivetkit-sqlite` so pegboard-envoy can execute through the shared native VFS/database routing layer.
+- Added remote SQL result/bind conversion helpers, executor caching per `(actor_id, sqlite_generation)`, and cleanup on actor stop/shutdown paths.
+- Files changed: `.agent/specs/rivetkit-core-wasm-support.md`, `AGENTS.md`/`CLAUDE.md`, `Cargo.lock`, `engine/packages/pegboard-envoy/Cargo.toml`, `engine/packages/pegboard-envoy/src/actor_lifecycle.rs`, `engine/packages/pegboard-envoy/src/conn.rs`, `engine/packages/pegboard-envoy/src/sqlite_runtime.rs`, `engine/packages/pegboard-envoy/src/ws_to_tunnel_task.rs`, `engine/packages/pegboard-envoy/tests/support/ws_to_tunnel_task.rs`, `rivetkit-rust/packages/rivetkit-sqlite/src/database.rs`, `rivetkit-rust/packages/rivetkit-sqlite/src/vfs.rs`, `scripts/ralph/prd.json`, `scripts/ralph/progress.txt`.
+- Quality checks: `cargo test -p rivetkit-sqlite database::tests -- --nocapture`, `cargo test -p pegboard-envoy ws_to_tunnel_task -- --nocapture`, `cargo check -p rivetkit-sqlite`, `cargo check -p pegboard-envoy`.
+- **Learnings for future iterations:**
+  - `rivetkit-sqlite` already owns SQLite statement classification and read/write routing in `NativeDatabaseHandle`; remote server-side execution should open a direct engine-backed VFS instead of reimplementing classification in pegboard-envoy.
+  - The remote SQL protocol uses the SQLite storage generation, so pegboard-envoy validates against `ActiveActor.sqlite_generation`, not the actor command generation.
+  - `rivetkit-sqlite` still emits pre-existing Rust 2024 unsafe-operation warnings during checks; they are warnings, not story failures.
+---
+## 2026-04-29 21:06:43 PDT - US-005
+- Added `SqliteBackend::{LocalNative, RemoteEnvoy, Unavailable}` selection in `rivetkit-core::actor::sqlite`.
+- Routed `exec`, `query`, `run`, `execute`, and `execute_write` through local native SQLite or remote envoy SQL while preserving public method signatures and the existing `SqliteDb::new(...)` constructor.
+- Added explicit `remote_sqlite` actor config selection, structured remote SQLite errors, protocol bind/result conversion helpers, and focused backend/conversion/error tests.
+- Fixed `ActorTask` spawned runtime tracing dispatch propagation so actor-event drain logs reach tracing assertions.
+- Files changed: `rivetkit-rust/packages/rivetkit-core/src/actor/config.rs`, `rivetkit-rust/packages/rivetkit-core/src/actor/mod.rs`, `rivetkit-rust/packages/rivetkit-core/src/actor/sqlite.rs`, `rivetkit-rust/packages/rivetkit-core/src/actor/task.rs`, `rivetkit-rust/packages/rivetkit-core/src/error.rs`, `rivetkit-rust/packages/rivetkit-core/src/lib.rs`, `rivetkit-rust/packages/rivetkit-core/src/registry/mod.rs`, `rivetkit-rust/packages/rivetkit-core/tests/sqlite.rs`, `rivetkit-typescript/packages/rivetkit-napi/src/actor_factory.rs`, `rivetkit-rust/engine/artifacts/errors/sqlite.remote_execution_failed.json`, `rivetkit-rust/engine/artifacts/errors/sqlite.remote_fence_mismatch.json`, `rivetkit-rust/engine/artifacts/errors/sqlite.remote_unavailable.json`, `scripts/ralph/prd.json`, `scripts/ralph/progress.txt`.
+- Quality checks: `cargo test -p rivetkit-core sqlite --no-default-features`, `cargo test -p rivetkit-core sqlite --features sqlite`, `cargo check -p rivetkit-core --no-default-features`, `cargo check -p rivetkit-core --features sqlite`, `cargo check -p rivetkit-napi`, `cargo test -p rivetkit-core actor::task::tests::moved_tests::actor_task_logs_lifecycle_dispatch_and_actor_event_flow --no-default-features -- --exact --nocapture`.
+- Full `cargo test -p rivetkit-core --no-default-features` still fails under parallel execution on `actor_task_logs_lifecycle_dispatch_and_actor_event_flow` even though that exact test passes alone; the run also hangs afterward and was stopped.
+- **Learnings for future iterations:**
+  - Keep `SqliteDb::new(...)` source-compatible; use a separate constructor when threading new backend selection inputs through registry wiring.
+  - Remote SQLite float values are encoded as fixed 8-byte `f64::to_bits().to_be_bytes()` payloads in the envoy protocol conversion helpers.
+  - Structured SQLite error variants generate checked-in artifacts under `rivetkit-rust/engine/artifacts/errors/`.
+  - Full core test runs can expose parallel tracing-test interference even when exact tests pass; focused story checks were stable here.
+---
+## 2026-04-29 20:31:48 PDT - US-002
+- Added structured `ProtocolCompatibilityError` metadata for versioned envoy-protocol compatibility failures, including remote SQL request/response gates below protocol v4.
+- Added remote SQL compatibility tests covering old core/new pegboard-envoy, new core/old pegboard-envoy, old core/old pegboard-envoy, new core/new pegboard-envoy, and all exec/execute/execute_write request and response variants.
+- Documented mixed-version remote SQL behavior in `.agent/specs/rivetkit-core-wasm-support.md`.
+- Files changed: `engine/sdks/rust/envoy-protocol/src/versioned.rs`, `engine/sdks/rust/envoy-protocol/tests/remote_sql_compat.rs`, `.agent/specs/rivetkit-core-wasm-support.md`, `scripts/ralph/prd.json`, `scripts/ralph/progress.txt`.
+- Quality checks: `cargo test -p rivet-envoy-protocol`, `cargo check -p rivet-envoy-protocol`, `cargo check -p rivet-envoy-client`, `cargo check -p pegboard-envoy`.
+- **Learnings for future iterations:**
+  - Protocol compatibility rejections happen at `serialize_version(...)`, before an unsupported variant can become an older-version BARE payload.
+  - Integration tests can exercise `generated::v4` plus `versioned::{ToRivet, ToEnvoy}` directly for rollout-matrix protocol coverage.
+  - The repo may run out of disk during large Rust checks after many test artifacts accumulate; clearing rebuildable Cargo artifacts and stale `/tmp/rivet*` directories allowed checks to complete.
+---
+## 2026-04-29 20:18:43 PDT - US-001
+- Added envoy protocol `v4.bare` with remote SQLite bind/value/result types and exec, execute, and execute_write request/response messages.
+- Exported v4 as the latest Rust protocol, added v4 compatibility guards, regenerated the TypeScript envoy protocol artifact, and updated Rust stringifiers/downstream exhaustive matches for the new message variants.
+- Files changed: `engine/sdks/schemas/envoy-protocol/v4.bare`, `engine/sdks/rust/envoy-protocol/src/lib.rs`, `engine/sdks/rust/envoy-protocol/src/versioned.rs`, `engine/sdks/typescript/envoy-protocol/src/index.ts`, `engine/sdks/rust/envoy-client/src/stringify.rs`, `engine/sdks/rust/envoy-client/src/envoy.rs`, `engine/packages/pegboard-envoy/src/ws_to_tunnel_task.rs`, `CLAUDE.md`, `.agent/specs/rivetkit-core-wasm-support.md`, `scripts/ralph/.last-branch`, `scripts/ralph/prd.json`, `scripts/ralph/progress.txt`, `scripts/ralph/archive/2026-04-29-rivetkit-core-wasm-support/`.
+- Quality checks: `cargo check -p rivet-envoy-protocol`, `cargo check -p rivet-envoy-client`, `cargo test -p rivet-envoy-protocol`, `pnpm --filter @rivetkit/engine-envoy-protocol check-types`, `cargo check -p pegboard-envoy`.
+- **Learnings for future iterations:**
+  - The envoy protocol crate build script only regenerates checked-in TypeScript after root `node_modules` exists; run `pnpm install --frozen-lockfile` first in a fresh checkout.
+  - Adding protocol union variants requires updating every Rust exhaustive match in envoy-client and pegboard-envoy, even before behavior is fully wired.
+  - vbare hashable-map generation derives `Eq` and `Hash`, so raw `f64` schema fields break Rust generation.
+---
+## 2026-04-29 20:39:07 PDT - US-003
+- Added `rivetkit-sqlite-types` for shared SQLite bind parameters, column values, query results, exec results, execute results, and execute routes.
+- Re-exported the shared types from `rivetkit-sqlite::query` and `rivetkit-core::actor::sqlite`, removing the duplicated no-sqlite fallback definitions in core.
+- Kept native routing behavior in `rivetkit-sqlite`, while using shared projection helpers for `query` and `run` results.
+- Fixed the Rust wrapper's `ActorEvent::WebSocketOpen` match to acknowledge the current core event field set so the public wrapper typecheck passes.
+- Files changed: `Cargo.toml`, `Cargo.lock`, `rivetkit-rust/packages/rivetkit-sqlite-types/`, `rivetkit-rust/packages/rivetkit-sqlite/src/query.rs`, `rivetkit-rust/packages/rivetkit-sqlite/src/database.rs`, `rivetkit-rust/packages/rivetkit-sqlite/src/lib.rs`, `rivetkit-rust/packages/rivetkit-sqlite/Cargo.toml`, `rivetkit-rust/packages/rivetkit-core/src/actor/sqlite.rs`, `rivetkit-rust/packages/rivetkit-core/Cargo.toml`, `rivetkit-rust/packages/rivetkit/src/event.rs`, `scripts/ralph/prd.json`, `scripts/ralph/progress.txt`.
+- Quality checks: `cargo test -p rivetkit-sqlite-types`, `cargo check -p rivetkit-sqlite`, `cargo check -p rivetkit-core`, `cargo check -p rivetkit-core --features sqlite`, `cargo test -p rivetkit-sqlite query::tests`, `cargo check -p rivetkit`.
+- **Learnings for future iterations:**
+  - Keep statement classification and read/write routing in `rivetkit-sqlite`; shared types should stay plain and backend-neutral.
+  - Core can depend on `rivetkit-sqlite-types` unconditionally, which avoids duplicating SQLite API result shapes when native SQLite is feature-gated out.
+  - The native VFS currently emits many Rust 2024 unsafe-operation warnings during checks; they are pre-existing warnings, not failures.
+---
+## 2026-04-29 20:46:54 PDT - US-004
+- Added remote SQLite exec, execute, and execute_write request/response tracking to envoy-client with a dedicated `ToEnvoyMessage::RemoteSqliteRequest` path.
+- Wired `EnvoyHandle` methods for remote SQL, outbound `ToRivetSqlite*Request` messages, inbound response matching, reconnect unsent processing, timeout cleanup, and `EnvoyShutdownError` shutdown cleanup.
+- Added envoy-client tests for successful response matching, protocol v3 rejection, and shutdown cleanup of pending remote SQL requests.
+- Files changed: `engine/sdks/rust/envoy-client/src/envoy.rs`, `engine/sdks/rust/envoy-client/src/handle.rs`, `engine/sdks/rust/envoy-client/src/sqlite.rs`, `engine/sdks/rust/envoy-client/src/events.rs`, `engine/sdks/rust/envoy-client/tests/command_dedup.rs`, `scripts/ralph/prd.json`, `scripts/ralph/progress.txt`.
+- Quality checks: `cargo test -p rivet-envoy-client sqlite::tests -- --nocapture`, `cargo check -p rivet-envoy-client`, `cargo test -p rivet-envoy-client`.
+- **Learnings for future iterations:**
+  - Remote SQL execution uses protocol v4 only; client-side stale-version tests can serialize the generated `ToRivetSqlite*Request` messages against v3 and downcast to `ProtocolCompatibilityError`.
+  - Keep remote SQL request IDs in their own envoy-client map because response variants are disjoint from the existing SQLite page-I/O protocol.
+  - Shutdown cleanup should use `EnvoyShutdownError` for pending SQLite queues so callers can detect envoy loss separately from SQLite execution errors.
+---
+## 2026-04-29 21:48:44 PDT - US-009
+- Added `RemoteSqliteIndeterminateResultError` in envoy-client and fail sent remote SQL requests with it when the WebSocket disconnects.
+- Left unsent remote SQL requests pending so they can send after reconnect, while removing sent requests to prevent blind replay.
+- Mapped the typed envoy-client lost-response error into core's structured `sqlite.remote_indeterminate_result` error and checked in its error artifact.
+- Documented the selected lost-response behavior in the wasm support spec and project notes.
+- Files changed: `AGENTS.md`, `CLAUDE.md`, `.agent/specs/rivetkit-core-wasm-support.md`, `engine/sdks/rust/envoy-client/src/utils.rs`, `engine/sdks/rust/envoy-client/src/sqlite.rs`, `engine/sdks/rust/envoy-client/src/envoy.rs`, `engine/sdks/rust/envoy-client/tests/command_dedup.rs`, `rivetkit-rust/packages/rivetkit-core/src/error.rs`, `rivetkit-rust/packages/rivetkit-core/src/actor/sqlite.rs`, `rivetkit-rust/packages/rivetkit-core/tests/sqlite.rs`, `rivetkit-rust/engine/artifacts/errors/sqlite.remote_indeterminate_result.json`, `scripts/ralph/prd.json`, `scripts/ralph/progress.txt`.
+- Quality checks: `cargo test -p rivet-envoy-client sqlite::tests -- --nocapture`, `cargo test -p rivet-envoy-client --test command_dedup -- --nocapture`, `cargo test -p rivetkit-core sqlite --no-default-features -- --nocapture`, `cargo test -p rivetkit-core sqlite --features sqlite -- --nocapture`, `cargo check -p rivet-envoy-client`, `cargo check -p rivetkit-core --no-default-features`, `cargo check -p rivetkit-core --features sqlite`.
+- **Learnings for future iterations:**
+  - Treat every sent remote SQL request as potentially write-affecting after a disconnect because `Execute` routing is decided by the shared SQLite executor on the server.
+  - Only `sent == false` remote SQL entries are safe to process on reconnect.
+  - The existing `rivetkit-sqlite` Rust 2024 unsafe-operation warnings still appear during core checks with the `sqlite` feature and are not caused by this story.
+---
+## 2026-04-29 21:53:43 PDT - US-010
+- Added remote SQLite executor parity tests covering migration ordering across reopen, `execute_write` forcing the writer route for read-only SQL, and manual `BEGIN`, `SAVEPOINT`, `COMMIT`, and `ROLLBACK` behavior on the same remote database handle.
+- Added a TypeScript database provider test proving `db({ onMigrate })` runs migration callbacks through `SqliteDatabase.writeMode`.
+- Files changed: `rivetkit-rust/packages/rivetkit-sqlite/tests/remote_execution_parity.rs`, `rivetkit-typescript/packages/rivetkit/src/common/database/mod.test.ts`, `scripts/ralph/prd.json`, `scripts/ralph/progress.txt`.
+- Quality checks: `cargo test -p rivetkit-sqlite --test remote_execution_parity -- --nocapture`, `cargo check -p rivetkit-sqlite`, `pnpm --filter @rivetkit/virtual-websocket build`, `pnpm --filter @rivetkit/engine-envoy-protocol build`, `pnpm --filter @rivetkit/workflow-engine build`, `pnpm --filter rivetkit test src/common/database/mod.test.ts`, `pnpm --filter rivetkit exec biome check src/common/database/mod.test.ts`, `pnpm --filter rivetkit check-types`.
+- **Learnings for future iterations:**
+  - `db({ onMigrate })` and Drizzle migrations rely on the shared `__rivetWriteMode` convention to force remote SQLite execution onto the writer path.
+  - `execute_write` returns `ExecuteRoute::Write` even for read-only SQL, which is the easiest assertion that the forced-writer path is being used.
+  - The RivetKit TypeScript typecheck may need workspace dependency packages built first so their `dist/*.d.ts` exports exist.
+  - The existing `rivetkit-sqlite` Rust 2024 unsafe-operation warnings still appear during sqlite checks and are not caused by this story.
+---
+## 2026-04-29 22:31:53 PDT - US-014
+- Added `rivetkit-core` runtime and SQLite feature gates: `native-runtime`, `wasm-runtime`, `sqlite-local`, and `sqlite-remote`, with the old `sqlite` feature kept as a compatibility alias for local native SQLite.
+- Routed `native-runtime` to envoy-client native transport plus native process/runner-config dependencies, routed `wasm-runtime` to envoy-client wasm transport, and made `sqlite-local` native-only.
+- Moved `AsyncCounter` ownership into `rivet-envoy-client` so core sleep logic can share envoy HTTP request counters without depending on broad `rivet-util`.
+- Gated engine process startup and local runner-config HTTP setup behind `native-runtime`, with explicit errors when `engine_binary_path` is requested without native runtime support.
+- Files changed: `AGENTS.md`/`CLAUDE.md`, `Cargo.toml`, `Cargo.lock`, `engine/sdks/rust/envoy-client/`, `engine/sdks/rust/test-envoy/Cargo.toml`, `rivetkit-rust/packages/rivetkit-core/`, `rivetkit-rust/packages/rivetkit-sqlite/Cargo.toml`, `scripts/ralph/prd.json`, `scripts/ralph/progress.txt`.
+- Quality checks: `cargo check -p rivet-envoy-client --no-default-features --features wasm-transport`, `cargo check -p rivetkit-core --no-default-features --features wasm-runtime,sqlite-remote`, `cargo tree -p rivetkit-core --no-default-features --features wasm-runtime,sqlite-remote` with no matches for `rivetkit-sqlite`, `libsqlite3-sys`, `tokio-tungstenite`, `rivet-pools`, `rivet-util`, `reqwest`, or `nix`, `cargo check -p rivetkit-core`, `cargo check -p rivetkit-core --features sqlite`, `cargo check -p rivet-envoy-client`, `cargo test -p rivet-envoy-client active_http_request_counter -- --nocapture`, `cargo check -p rivetkit`, `cargo check -p rivetkit-sqlite`, `cargo check -p rivet-test-envoy`, `cargo test -p rivetkit-core sleep -- --nocapture`, `cargo check -p rivetkit-napi`.
+- `cargo check -p rivetkit-core --target wasm32-unknown-unknown --no-default-features --features wasm-runtime,sqlite-remote` still fails on wasm-host `getrandom` and workspace Tokio `mio`; that full wasm build gate is US-017.
+- **Learnings for future iterations:**
+  - Core's wasm feature path now excludes the native SQLite crate, native WebSocket transport, `rivet-pools`, `rivet-util`, `reqwest`, and `nix` on the normal dependency tree.
+  - Keep `sqlite` as a compatibility alias for `sqlite-local`; update cfg checks to `sqlite-local` so direct `sqlite-local` builds behave the same as legacy `sqlite`.
+  - The envoy HTTP request counter is a cross-crate type contract between envoy-client and core sleep logic, so its shared type belongs in `rivet-envoy-client`.
+---
+## 2026-04-29 22:40:50 PDT - US-015
+- Gated wasm core dependency selection with target-specific Tokio and UUID dependencies, plus the JS `getrandom` backend for wasm random ID generation.
+- Fixed the wasm envoy transport helper paths so the real `wasm32-unknown-unknown` check reaches core instead of failing in the transport wrapper.
+- Made synchronous queue receives fail with a structured `actor.invalid_operation` error on wasm instead of compiling a native-only `block_in_place` path.
+- Added a no-native-runtime serverless test proving engine process spawning returns an explicit configuration error.
+- Files changed: `CLAUDE.md`, `Cargo.lock`, `engine/sdks/rust/envoy-client/Cargo.toml`, `engine/sdks/rust/envoy-client/src/connection/wasm.rs`, `rivetkit-rust/packages/rivetkit-core/Cargo.toml`, `rivetkit-rust/packages/rivetkit-core/src/actor/queue.rs`, `rivetkit-rust/packages/rivetkit-core/tests/serverless.rs`, `scripts/ralph/prd.json`, `scripts/ralph/progress.txt`.
+- Quality checks: `cargo check -p rivet-envoy-client --target wasm32-unknown-unknown --no-default-features --features wasm-transport`, `cargo check -p rivetkit-core --target wasm32-unknown-unknown --no-default-features --features wasm-runtime,sqlite-remote`, `cargo test -p rivetkit-core engine_process_spawn_requires_native_runtime --no-default-features --features wasm-runtime,sqlite-remote -- --nocapture`, `cargo check -p rivetkit-core`, `cargo test -p rivetkit-core serverless -- --nocapture`, `cargo check -p rivetkit-core --features sqlite`, and a wasm dependency tree scan with no matches for native SQLite, `libsqlite3-sys`, `tokio-tungstenite`, `mio`, `nix`, `rivet-pools`, `reqwest`, or `rivet-util`.
+- **Learnings for future iterations:**
+  - `cargo tree` includes dev-dependencies unless constrained with `-e normal`; use `-e normal` when checking the production wasm dependency tree.
+  - The wasm envoy transport implementation is nested under `connection::wasm::imp`, so shared helpers in `connection/mod.rs` are reached through `super::super`.
+  - Synchronous queue APIs are native-only when they require blocking the current runtime. Wasm builds should return explicit structured errors for those surfaces.
+---
+## 2026-04-29 23:00:09 PDT - US-019
+- Added a bridge-neutral TypeScript `CoreRuntime` interface with opaque registry, actor factory, actor context, connection, WebSocket, and cancellation token handles.
+- Moved NAPI-specific binding loading and class calls into `src/registry/napi-runtime.ts`, then routed registry/native actor adaptation through the runtime interface, including KV, SQLite, queue, schedule, WebSocket, cancellation, serverless, and inspector helpers.
+- Added `tests/runtime-import-guard.test.ts` and moved the inspector versioning test off direct `@rivetkit/rivetkit-napi` imports.
+- Files changed: `AGENTS.md`, `CLAUDE.md`, `rivetkit-typescript/packages/rivetkit/src/registry/index.ts`, `rivetkit-typescript/packages/rivetkit/src/registry/native.ts`, `rivetkit-typescript/packages/rivetkit/src/registry/runtime.ts`, `rivetkit-typescript/packages/rivetkit/src/registry/napi-runtime.ts`, `rivetkit-typescript/packages/rivetkit/tests/inspector-versioned.test.ts`, `rivetkit-typescript/packages/rivetkit/tests/runtime-import-guard.test.ts`, `scripts/ralph/prd.json`, `scripts/ralph/progress.txt`.
+- Quality checks: `pnpm --filter rivetkit check-types`, `pnpm --filter rivetkit test tests/inspector-versioned.test.ts tests/runtime-import-guard.test.ts`, `pnpm --filter rivetkit exec biome check src/registry/runtime.ts src/registry/napi-runtime.ts src/registry/native.ts tests/inspector-versioned.test.ts tests/runtime-import-guard.test.ts`, `pnpm --filter rivetkit run check:test-skips`, `pnpm --filter rivetkit run check:wait-for-comments`.
+- `pnpm --filter rivetkit lint` still fails on pre-existing fixture-wide Biome diagnostics under `fixtures/driver-test-suite/*`; touched files pass Biome.
+- **Learnings for future iterations:**
+  - The TypeScript runtime interface should expose explicit methods on opaque handles rather than leaking NAPI binding classes into shared actor adaptation code.
+  - SQLite stays routed through `ActorContextHandle` methods on `CoreRuntime`; the NAPI adapter can cache the native `JsNativeDatabase` internally while shared code only sees the normalized database wrapper.
+  - Direct imports of `@rivetkit/rivetkit-napi` or future `@rivetkit/rivetkit-wasm` outside runtime adapter files should fail the import guard test.
+---
+## 2026-04-29 23:08:29 PDT - US-020
+- Added `@rivetkit/rivetkit-wasm` as a separate TypeScript package and Rust `cdylib` crate over `rivetkit-core` using direct wasm-bindgen.
+- Exposed raw wasm handles for registry, actor factory, cancellation token, actor context, connection, and WebSocket handle, plus Uint8Array and Promise boundary helpers.
+- Added wasm-pack build scripts for web/Deno and Cloudflare-style bundler targets while keeping native NAPI unchanged.
+- Files changed: `Cargo.toml`, `Cargo.lock`, `package.json`, `pnpm-lock.yaml`, `rivetkit-typescript/CLAUDE.md`, `rivetkit-typescript/packages/rivetkit-wasm/`, `scripts/ralph/prd.json`, `scripts/ralph/progress.txt`.
+- Quality checks: `cargo check -p rivetkit-wasm --target wasm32-unknown-unknown`, `cargo check -p rivetkit-wasm`, `cargo check -p rivetkit-napi`, `pnpm --filter @rivetkit/rivetkit-wasm check-types`, `pnpm --filter @rivetkit/rivetkit-wasm build`, `scripts/cargo/check-rivetkit-core-wasm.sh`.
+- **Learnings for future iterations:**
+  - Keep the wasm binding package source-only in git; `pkg/` is generated by wasm-pack during package builds.
+  - wasm-bindgen rejects exported classes named `WebSocket`, so the raw wasm binding uses `WebSocketHandle`.
+  - The initial wasm actor factory binds core registration and config parsing, while full JS callback dispatch belongs in the shared wasm adapter story.
+---
+## 2026-04-29 23:15:56 PDT - US-021
+- Added `WasmCoreRuntime` in `rivetkit/src/registry/wasm-runtime.ts`, backed by `@rivetkit/rivetkit-wasm`, with registry/factory/cancellation handle mapping, bridge-error decoding, explicit unsupported-method failures, and Buffer normalization for wasm byte payloads.
+- Added focused runtime adapter tests proving the wasm and NAPI adapters satisfy the same `CoreRuntime` interface, raw wasm handles are mapped through the adapter, structured wasm bridge errors decode to `RivetError`, and missing wasm exports fail explicitly.
+- Added `@rivetkit/rivetkit-wasm` as a direct `rivetkit` package dependency and documented the wasm payload normalization convention.
+- Files changed: `rivetkit-typescript/packages/rivetkit/src/registry/wasm-runtime.ts`, `rivetkit-typescript/packages/rivetkit/tests/wasm-runtime.test.ts`, `rivetkit-typescript/packages/rivetkit/package.json`, `pnpm-lock.yaml`, `rivetkit-typescript/CLAUDE.md`, `scripts/ralph/prd.json`, `scripts/ralph/progress.txt`.
+- Quality checks: `pnpm --filter rivetkit check-types`, `pnpm --filter @rivetkit/rivetkit-wasm check-types`, `pnpm --filter rivetkit test tests/wasm-runtime.test.ts`, `pnpm --filter rivetkit test tests/runtime-import-guard.test.ts`, `pnpm --filter rivetkit exec biome check src/registry/wasm-runtime.ts tests/wasm-runtime.test.ts`, `pnpm --filter rivetkit run check:wait-for-comments`, `pnpm --filter rivetkit run check:test-skips`.
+- **Learnings for future iterations:**
+  - Keep raw `@rivetkit/rivetkit-wasm` imports inside `src/registry/wasm-runtime.ts`; `tests/runtime-import-guard.test.ts` enforces the same boundary as the NAPI adapter.
+  - Wasm binding methods can return `Uint8Array`; normalize them to `Buffer` in the adapter before shared registry code sees them.
+  - Until every raw wasm handle method exists, fail through structured `feature.unsupported` errors instead of silent no-ops.
+---
+## 2026-04-29 23:23:14 PDT - US-022
+- Added Supabase Edge Functions/Deno and Cloudflare Workers wasm host smoke coverage through the shared `WasmCoreRuntime` interface.
+- The smoke harness verifies envoy WebSocket URL fields, `rivet` plus `rivet_token.*` subprotocol auth, `arraybuffer` binary mode, actor action dispatch, state serialization, KV access, remote SQLite execute/write/query calls, and deterministic reconnect points during action and remote write SQL.
+- Kept native NAPI separate by using the existing runtime import guard alongside the wasm-only smoke harness.
+- Files changed: `CLAUDE.md`/`AGENTS.md`, `rivetkit-typescript/packages/rivetkit/tests/wasm-host-smoke.test.ts`, `scripts/ralph/prd.json`, `scripts/ralph/progress.txt`.
+- Quality checks: `pnpm --filter rivetkit test tests/wasm-host-smoke.test.ts`, `pnpm --filter rivetkit exec biome check tests/wasm-host-smoke.test.ts`, `pnpm --filter rivetkit check-types`, `pnpm --filter rivetkit test tests/runtime-import-guard.test.ts`, `pnpm --filter rivetkit run check:wait-for-comments`, `pnpm --filter rivetkit run check:test-skips`.
+- **Learnings for future iterations:**
+  - The wasm host smoke can exercise shared TypeScript actor adaptation by building factories with `buildNativeFactory` and running them through `WasmCoreRuntime` fake bindings.
+  - Public `c.sql` write forcing goes through `writeMode(() => c.sql.execute(...))`; the lower runtime adapter maps that to `executeWrite`.
+  - `@rivetkit/rivetkit-wasm/pkg/` is generated, so host smoke tests should not require importing the real package until the wasm-pack output exists in the test environment.
+---
+## 2026-04-29 23:26:43 PDT - US-023
+- Documented the implemented remote SQLite and wasm runtime invariants in `.agent/specs/rivetkit-core-wasm-support.md`.
+- Refreshed stale current-state notes so the spec records v4-only remote SQL rollout behavior, wasm remote-only SQLite, lazy pegboard-envoy SQL executors, envoy-client transport ownership, lost-response behavior, and the direct wasm-bindgen binding strategy.
+- Files changed: `.agent/specs/rivetkit-core-wasm-support.md`, `scripts/ralph/prd.json`, `scripts/ralph/progress.txt`.
+- Quality checks: `scripts/cargo/check-rivetkit-core-wasm.sh`.
+- **Learnings for future iterations:**
+  - Keep high-level wasm and remote SQLite decisions in the spec's implemented invariants section so future changes do not have to reconstruct them from individual story logs.
+  - The wasm support spec should reflect the current gate command instead of stale one-off compile probes.
+  - Remote SQL lost-response behavior is now a decided invariant: sent requests fail with `sqlite.remote_indeterminate_result`, while only unsent requests can be sent after reconnect.
+---
diff --git a/scripts/ralph/prd.json b/scripts/ralph/prd.json
index 4f73e8e4e7..99894bb656 100644
--- a/scripts/ralph/prd.json
+++ b/scripts/ralph/prd.json
@@ -1,17 +1,17 @@
 {
-  "project": "sqlite-read-connection-manager",
-  "branchName": "04-29-feat_sqlite_add_cold_read_benchmarks_and_simplify_optimizations",
-  "description": "Implement a SQLite read-mode/write-mode connection manager so independent read-only queries can run in parallel while write mode holds exactly one writable connection and no readers.",
+  "project": "RivetKit Runtime Boundary Cleanup",
+  "branchName": "04-29-chore_rivetkit_wasm_support",
+  "description": "Clean up the RivetKit TypeScript runtime boundary so NAPI and WebAssembly use the same portable CoreRuntime contract, wasm initialization is explicit, invalid SQLite/runtime combinations fail clearly, and Cloudflare Workers, Supabase Functions, and Deno are covered by first-class platform smoke tests.",
   "userStories": [
     {
       "id": "US-001",
-      "title": "Add SQLite statement classification helpers",
-      "description": "As a runtime developer, I want native SQLite statement classification helpers so that read-only routing is based on SQLite semantics instead of SQL string heuristics.",
+      "title": "Extract shared engine test harness",
+      "description": "As a test maintainer, I need the driver suite and platform tests to share one engine startup mechanism so that platform smoke tests do not duplicate process and port management.",
       "acceptanceCriteria": [
-        "Add a rivetkit-sqlite helper that prepares one statement without stepping and reports whether SQLite considers it read-only via sqlite3_stmt_readonly",
-        "Reject reader routing when sqlite3_prepare_v2 returns non-whitespace tail text after the first statement",
-        "Capture authorizer actions during classification for transaction control, attach, detach, schema writes, temp writes, pragma usage, function calls, and write operations",
-        "Add tests covering SELECT, read-only PRAGMA, mutating PRAGMA, INSERT RETURNING, CTE writes, VACUUM, ATTACH, BEGIN, SAVEPOINT, and multi-statement SQL",
+        "Extract the engine start, health check, ref-count, and release logic from `rivetkit-typescript/packages/rivetkit/tests/driver/shared-harness.ts` into a shared test utility if it cannot be reused directly",
+        "Update driver tests to keep using the same engine behavior through the shared utility or existing exported helper",
+        "Expose a helper that platform tests can use to start and release a local `rivet-engine`",
+        "Do not introduce a second independent engine launcher for platform tests",
         "Typecheck passes",
         "Tests pass"
       ],
@@ -21,14 +21,13 @@
     },
     {
       "id": "US-002",
-      "title": "Split VFS ownership from SQLite connections",
-      "description": "As a runtime developer, I want VFS registration and SQLite connection ownership split apart so that one actor can open multiple connections against one shared VFS cache.",
+      "title": "Use runtime.kind for runtime normalization",
+      "description": "As a maintainer, I want runtime selection to depend on the `CoreRuntime` contract rather than concrete adapter classes so that duplicate modules and future adapters remain compatible.",
       "acceptanceCriteria": [
-        "Introduce native ownership types equivalent to NativeVfsHandle and NativeConnection without changing public TypeScript APIs",
-        "Keep one shared VFS registration and VfsContext per actor database manager while allowing multiple SQLite connection handles",
-        "Use a VFS name that includes an actor database generation or pool generation instead of only the actor id",
-        "Ensure manager close order closes every SQLite connection before unregistering the VFS",
-        "Add tests or assertions covering multiple connections sharing one VFS context and VFS cleanup after connection close",
+        "`loadedRuntimeKind` switches on `runtime.kind`",
+        "No production runtime selection logic depends on `instanceof NapiCoreRuntime` or `instanceof WasmCoreRuntime`",
+        "Tests can use plain object `CoreRuntime` fakes with `kind: \"napi\"` or `kind: \"wasm\"`",
+        "Config resolution order remains setup config, then `RIVETKIT_RUNTIME`, then `auto`",
         "Typecheck passes",
         "Tests pass"
       ],
@@ -38,14 +37,15 @@
     },
     {
       "id": "US-003",
-      "title": "Enforce read-only VFS roles",
-      "description": "As a runtime developer, I want VFS file handles to know whether they belong to a reader or writer so that read-only connections cannot mutate actor SQLite state.",
+      "title": "Define portable SQL runtime types",
+      "description": "As a runtime adapter author, I need SQL params and results to use shared plain TypeScript structs so that NAPI and wasm do not depend on NAPI-specific database types.",
       "acceptanceCriteria": [
-        "Store reader or writer role on VfsFile and auxiliary file handles opened through the RivetKit SQLite VFS",
-        "Set SQLite pOutFlags consistently with the requested open flags and the assigned role",
-        "Reject reader-owned xWrite, xTruncate, xDelete, dirty sync, and atomic-write file-control operations",
-        "Deny reader auxiliary-file creation unless the path is explicitly proven safe and documented in code",
-        "Add VFS tests proving reader handles fail closed on write-only callbacks while writer handles still support existing write paths",
+        "`rivetkit-typescript/packages/rivetkit/src/registry/runtime.ts` no longer imports `JsNativeDatabaseLike`",
+        "Define explicit runtime SQL bind param, query result, execute result, and run result types using portable values and `Uint8Array` for blobs",
+        "NAPI and wasm SQL adapters both implement the same explicit SQL result types",
+        "Existing `wrapJsNativeDatabase` behavior remains unchanged for user-facing database APIs",
+        "Bigint, boolean, string, number, null, undefined, and `Uint8Array` SQL parameter normalization still works",
+        "User-facing SQL integer result behavior remains unchanged from the current TypeScript API",
         "Typecheck passes",
         "Tests pass"
       ],
@@ -55,15 +55,13 @@
     },
     {
       "id": "US-004",
-      "title": "Add the connection manager mode gate",
-      "description": "As a runtime developer, I want an actor-local SQLite mode gate so that read mode and write mode are mutually exclusive and write requests cannot starve.",
+      "title": "Replace CoreRuntime Buffer fields with Uint8Array",
+      "description": "As an edge runtime user, I want the shared CoreRuntime byte boundary to use portable byte types so that wasm hosts do not need Node `Buffer` globals.",
       "acceptanceCriteria": [
-        "Add a NativeConnectionManager skeleton with closed, read-mode, write-mode, and closing state",
-        "Allow read mode to hold lazy read-only connections up to a configurable maximum reader count",
-        "When write mode is requested, stop admitting new reads, wait for active readers, close all readers, then open exactly one writable connection",
-        "When closing is requested, stop admitting new work, wait for active work to finish or cancellation to fire, close connections, and unregister the VFS",
-        "Use async coordination for the gate and avoid holding sync lock guards across await points",
-        "Add tests for read admission, writer preference, read-to-write transition, and close ordering",
+        "`rivetkit-typescript/packages/rivetkit/src/registry/runtime.ts` no longer references `Buffer` in the `CoreRuntime` boundary",
+        "HTTP bodies, state deltas, KV keys and values, queue payloads, SQL blobs, websocket binary messages, connection bytes, and inspector bytes use `Uint8Array` or a portable alias",
+        "NAPI-only `Buffer` conversion remains inside `NapiCoreRuntime` where native bindings require it",
+        "Wasm runtime boundary normalization does not require `Buffer.from`, `Buffer.alloc`, or `Buffer.isBuffer`",
         "Typecheck passes",
         "Tests pass"
       ],
@@ -73,15 +71,14 @@
     },
     {
       "id": "US-005",
-      "title": "Route write work through exclusive write mode",
-      "description": "As a runtime developer, I want every mutation and transaction to run through exclusive write mode so that no reader connection is open while a writable connection exists.",
+      "title": "Add explicit wasm bindings loader config",
+      "description": "As an edge runtime integrator, I want wasm bindings passed through configuration so that Cloudflare, Supabase, and Deno do not depend on hidden global mutation.",
       "acceptanceCriteria": [
-        "Route run calls, exec calls, migrations, schema-changing statements, and classification fallbacks through write mode",
-        "Treat raw transaction-control statements as write-mode only even if SQLite reports them as read-only",
-        "Keep the manager in write mode while sqlite3_get_autocommit on the writer returns false",
-        "After write-mode work completes with autocommit restored, close the writable connection before admitting read-mode work",
-        "Add tests proving BEGIN or SAVEPOINT blocks reader creation until COMMIT or ROLLBACK completes",
-        "Add tests proving a pending writer waits for active readers and new readers wait behind the writer",
+        "Add a typed `wasm.bindings?: typeof import(\"@rivetkit/rivetkit-wasm\")` field to RivetKit TypeScript registry config",
+        "`loadWasmRuntime` uses configured `wasm.bindings` before falling back to importing `@rivetkit/rivetkit-wasm`",
+        "`wasm.initInput` continues to accept Worker-friendly and Deno-friendly wasm module, bytes, URL, or response inputs",
+        "`loadWasmRuntime` does not read `globalThis.__rivetkitWasmBindings`",
+        "Add tests proving configured bindings are used instead of hidden globals",
         "Typecheck passes",
         "Tests pass"
       ],
@@ -91,15 +88,14 @@
     },
     {
       "id": "US-006",
-      "title": "Execute read-only statements on read connections",
-      "description": "As a Rivet Actor developer, I want independent read-only statements to run on read connections so that expensive VFS round trips can overlap.",
+      "title": "Publish one public wasm package import path",
+      "description": "As an application developer, I want `@rivetkit/rivetkit-wasm` to expose a supported public import path so that platform apps do not import repo-relative generated files.",
       "acceptanceCriteria": [
-        "Route single-statement queries classified as read-only to read-mode connections opened with SQLITE_OPEN_READONLY",
-        "Set PRAGMA query_only = ON on reader connections",
-        "Install a mandatory reader authorizer that denies transaction control, attach, detach, schema writes, temp writes, unsafe pragmas, unsafe functions, and all write actions",
-        "Open readers lazily for concurrent read demand and reuse idle readers while the idle TTL has not expired",
-        "Add a deterministic test with artificial VFS delay proving concurrent read-only statements use multiple reader connections instead of serial execution",
-        "Add tests proving reader authorizer or VFS rejection is treated as a routing bug and fails closed",
+        "`@rivetkit/rivetkit-wasm` exposes one default public import path that can be passed as `wasm.bindings`",
+        "`package.json` exports and files include the JavaScript, declaration, and wasm artifacts needed by the public import path",
+        "Do not add `@rivetkit/rivetkit-wasm/cloudflare` or `@rivetkit/rivetkit-wasm/deno` exports unless platform tests prove the single export cannot work",
+        "If a specialized export becomes necessary, document the packaging failure that requires it",
+        "No platform app imports repo-relative `pkg`, `pkg-deno`, or `dist/tsup` paths",
         "Typecheck passes",
         "Tests pass"
       ],
@@ -109,15 +105,14 @@
     },
     {
       "id": "US-007",
-      "title": "Add a native execute result API",
-      "description": "As a TypeScript runtime maintainer, I want a native execute API that returns rows, columns, changes, and route metadata so that TypeScript does not decide read/write behavior by parsing SQL strings.",
+      "title": "Make wasm serverless startup concurrency-safe",
+      "description": "As a serverless runtime maintainer, I want concurrent first requests to share wasm serverless startup so that edge hosts do not fail during cold-start races.",
       "acceptanceCriteria": [
-        "Add a native execute path that prepares, classifies, routes, steps, and returns rows and column names for single-statement SQL",
-        "Return write metadata such as changes and last insert row id when available",
-        "Return route metadata indicating whether the statement used read mode, write mode, or write fallback",
-        "Keep query and run compatibility wrappers working through the native routing path where practical",
-        "Update core inspector database execute handling to use the native execute path instead of bypassing the gate",
-        "Add tests covering SELECT, plain INSERT, INSERT RETURNING, read-only PRAGMA, mutating PRAGMA, and malformed SQL",
+        "Wasm registry implements a `BuildingServerless` equivalent to match the NAPI serverless state pattern",
+        "Concurrent first serverless requests share one build or wait for the build to finish instead of returning an already-serving or wrong-mode error",
+        "Shutdown during wasm serverless build leaves the registry in a terminal state and does not orphan a newly built runtime",
+        "NAPI and wasm return equivalent wrong-mode or shutdown errors for serve/serverless mode conflicts",
+        "Add focused tests for concurrent first serverless requests and shutdown during build using deterministic ordering where needed",
         "Typecheck passes",
         "Tests pass"
       ],
@@ -127,16 +122,12 @@
     },
     {
       "id": "US-008",
-      "title": "Remove TypeScript read serialization",
-      "description": "As a RivetKit TypeScript user, I want TypeScript database wrappers to allow native parallel reads so that Promise.all over read-only queries actually overlaps VFS work.",
+      "title": "Restore wasm queue API parity",
+      "description": "As a Rivet Actor developer, I want queue APIs to return the same values through NAPI and wasm so that runtime selection does not change behavior.",
       "acceptanceCriteria": [
-        "Expose the native execute API through rivetkit-napi and the TypeScript native database wrapper",
-        "Remove or narrow per-query AsyncMutex usage in common/database/mod.ts once native routing is authoritative",
-        "Remove or narrow read-query serialization in common/database/native-database.ts",
-        "Remove or narrow Drizzle callback and raw execute serialization for read-only work in db/drizzle.ts",
-        "Keep closed-state checks with an in-flight counter or close gate so close waits for admitted native calls",
-        "Ensure migration hooks run in native migration mode, where all database calls route through write mode and reader creation is disabled",
-        "Add TypeScript tests proving Promise.all read queries reach native execution concurrently while write operations remain serialized by the native manager",
+        "`WasmQueue.maxSize()` returns the real core queue max size instead of `0`",
+        "Add parity coverage for queue max size through both NAPI and wasm adapters",
+        "Unsupported wasm runtime methods fail with an explicit structured unsupported-runtime error",
         "Typecheck passes",
         "Tests pass"
       ],
@@ -146,14 +137,13 @@
     },
     {
       "id": "US-009",
-      "title": "Add read pool config flags and metrics",
-      "description": "As an operator, I want read pool configuration and metrics so that the feature can be rolled out, observed, and disabled safely.",
+      "title": "Fail fast for explicit wasm local SQLite",
+      "description": "As a test runner user, I want impossible wasm/local SQLite selections to fail clearly so that requested coverage is not silently dropped.",
       "acceptanceCriteria": [
-        "Add central SQLite optimization config for sqlite_read_pool_enabled, sqlite_read_pool_max_readers, and sqlite_read_pool_idle_ttl_ms",
-        "Preserve old single-connection behavior when the read pool feature flag is disabled",
-        "Add Prometheus metrics for active readers, idle readers, read wait duration, write wait duration, routed read queries, write fallbacks, manual transaction duration, reader opens, reader closes, rejected reader mutations, and mode transitions",
-        "Keep existing VFS metrics aggregated at the shared VFS level",
-        "Add tests or snapshots proving config defaults and disabled-path behavior",
+        "Default driver matrix excludes `runtime=wasm` with `sqlite=local`",
+        "`RIVETKIT_DRIVER_TEST_RUNTIME=wasm` with `RIVETKIT_DRIVER_TEST_SQLITE=local` fails fast with a clear configuration error",
+        "Valid matrix cells remain native/local/all encodings, native/remote/all encodings, and wasm/remote/all encodings",
+        "`shared-matrix.test.ts` asserts the fail-fast behavior for explicit wasm/local selection",
         "Typecheck passes",
         "Tests pass"
       ],
@@ -163,14 +153,14 @@
     },
     {
       "id": "US-010",
-      "title": "Add kitchen-sink benchmark coverage",
-      "description": "As a performance investigator, I want kitchen-sink benchmark workloads for parallel reads and read-write transitions so that the read connection manager has a repeatable performance signal.",
+      "title": "Enforce wasm SQLite config invariants in setup",
+      "description": "As a RivetKit user, I want `setup()` to reject local SQLite for wasm so that the unsupported configuration fails before runtime work begins.",
       "acceptanceCriteria": [
-        "Ensure the kitchen-sink SQLite real-world benchmark includes a parallel-read-aggregates workload",
-        "Ensure the kitchen-sink SQLite real-world benchmark includes a parallel-read-write-transition workload",
-        "Report benchmark output that makes routed reads, routed writes, and transition metrics visible when the manager metrics exist",
-        "Add static or runtime tests proving the script and actor workload lists stay in sync",
-        "Document any required benchmark command updates in the relevant benchmark file or agent note",
+        "`setup({ runtime: \"wasm\" })` defaults SQLite to remote when SQLite config is unset",
+        "`setup({ runtime: \"wasm\", sqlite: remote })` is allowed",
+        "`setup({ runtime: \"wasm\", sqlite: local })` fails with a clear configuration error",
+        "Native runtime keeps its current SQLite default and allows both local and remote SQLite",
+        "Add tests for wasm default remote SQLite, wasm remote allowed, wasm local rejected, and native behavior unchanged",
         "Typecheck passes",
         "Tests pass"
       ],
@@ -180,14 +170,14 @@
     },
     {
       "id": "US-011",
-      "title": "Add lifecycle and fencing stress coverage",
-      "description": "As a runtime developer, I want stress coverage around sleep, destroy, and fence errors so that pooled readers do not outlive actor lifecycle authority.",
+      "title": "Add shared platform SQLite counter registry",
+      "description": "As a platform test maintainer, I need one tiny shared registry so that Cloudflare, Supabase, and Deno tests verify the same public wasm API without duplicating actor code.",
       "acceptanceCriteria": [
-        "Add tests proving actor sleep or destroy stops new database work and closes active or idle reader connections in deterministic order",
-        "Add tests proving a fence mismatch from any reader marks the shared VFS dead and causes later database work to fail closed",
-        "Add tests proving actor replacement or generation changes do not collide with stale VFS registration names",
-        "Add tests proving manual raw transactions keep the manager in write mode across awaited user code",
-        "Add tests proving inspector and user database operations share the same native routing gate",
+        "Create `rivetkit-typescript/packages/rivetkit/tests/platforms/shared-registry.ts`",
+        "Define a SQLite-backed counter actor with `increment` and `getCount` actions",
+        "The actor uses raw SQL rather than Drizzle",
+        "The registry factory uses public `setup({ runtime: \"wasm\", wasm: { bindings, initInput }, use })` shape",
+        "The registry uses remote SQLite and does not allow local SQLite",
         "Typecheck passes",
         "Tests pass"
       ],
@@ -197,18 +187,151 @@
     },
     {
       "id": "US-012",
-      "title": "Document the SQLite read-mode write-mode invariant",
-      "description": "As a future maintainer, I want the SQLite connection manager invariant documented so that later optimizations do not accidentally reintroduce readers beside a writer.",
+      "title": "Add shared platform test harness",
+      "description": "As a platform test maintainer, I need common process and client helpers so each platform smoke test can focus on its host runtime.",
       "acceptanceCriteria": [
-        "Update docs-internal or agent specs to state that read mode may hold multiple read-only connections and write mode must hold exactly one writable connection with no readers open",
-        "Update the SQLite optimization tracker with the read-mode/write-mode connection manager item if it is not already present",
-        "Document that v1 does not allow readers to continue during writes and does not pin per-reader head txids",
-        "Document that TypeScript must not be the policy boundary for read/write routing",
-        "Typecheck passes"
+        "Create `rivetkit-typescript/packages/rivetkit/tests/platforms/shared-platform-harness.ts`",
+        "The harness can create a namespace and serverless runner config against the shared test engine",
+        "The harness can create a RivetKit client for the shared SQLite counter registry",
+        "The harness provides helpers for temporary app directories, child process logging, health checks, and cleanup",
+        "Platform CLI commands are launched through pinned `pnpm dlx` versions where a CLI is needed",
+        "Platform tests are exposed through an explicit script such as `test:platforms` and are not included in the default test command",
+        "Typecheck passes",
+        "Tests pass"
       ],
       "priority": 12,
       "passes": true,
       "notes": ""
+    },
+    {
+      "id": "US-013",
+      "title": "Add Cloudflare Workers wasm platform smoke test",
+      "description": "As a release owner, I want a real local Cloudflare Workers smoke test so that wasm runtime packaging works in workerd.",
+      "acceptanceCriteria": [
+        "Create `rivetkit-typescript/packages/rivetkit/tests/platforms/cloudflare-workers.test.ts`",
+        "The test runs real local workerd through pinned `pnpm dlx wrangler@... dev --local`",
+        "The test imports only public `rivetkit` and `@rivetkit/rivetkit-wasm` package exports from platform app code",
+        "The test performs multiple requests to the same SQLite counter actor and verifies persisted readback",
+        "The test verifies actor sleep and wake for the SQLite counter actor",
+        "The test runs multiple separate actor IDs in parallel on the same platform instance",
+        "The test does not cover raw HTTP, raw WebSocket, workflows, queues, or the full driver suite",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 13,
+      "passes": true,
+      "notes": ""
+    },
+    {
+      "id": "US-014",
+      "title": "Add Deno wasm platform smoke test",
+      "description": "As a release owner, I want a plain Deno smoke test so that wasm runtime packaging works without the Supabase CLI wrapper.",
+      "acceptanceCriteria": [
+        "Create `rivetkit-typescript/packages/rivetkit/tests/platforms/deno.test.ts`",
+        "The test runs the platform app with real local Deno and does not use the Supabase CLI wrapper",
+        "The test imports only public `rivetkit` and `@rivetkit/rivetkit-wasm` package exports from platform app code",
+        "The test performs multiple requests to the same SQLite counter actor and verifies persisted readback",
+        "The test verifies actor sleep and wake for the SQLite counter actor",
+        "The test runs multiple separate actor IDs in parallel on the same platform instance",
+        "The test does not cover raw HTTP, raw WebSocket, workflows, queues, or the full driver suite",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 14,
+      "passes": true,
+      "notes": ""
+    },
+    {
+      "id": "US-015",
+      "title": "Add Supabase Functions wasm platform smoke test",
+      "description": "As a release owner, I want a real local Supabase Functions smoke test so that wasm runtime packaging works through `supabase functions serve`.",
+      "acceptanceCriteria": [
+        "Create `rivetkit-typescript/packages/rivetkit/tests/platforms/supabase-functions.test.ts`",
+        "The test runs real local Supabase Functions through pinned `pnpm dlx supabase@... functions serve`",
+        "The test imports only public `rivetkit` and `@rivetkit/rivetkit-wasm` package exports from function app code",
+        "The test performs multiple requests to the same SQLite counter actor and verifies persisted readback",
+        "The test verifies actor sleep and wake for the SQLite counter actor",
+        "The test runs multiple separate actor IDs in parallel on the same platform instance",
+        "The test does not cover raw HTTP, raw WebSocket, workflows, queues, or the full driver suite",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 15,
+      "passes": true,
+      "notes": ""
+    },
+    {
+      "id": "US-016",
+      "title": "Document wasm runtime setup for Cloudflare and Supabase",
+      "description": "As an application developer, I want public docs for wasm runtime setup on Cloudflare Workers and Supabase Functions so that I can copy the same API used by the tests.",
+      "acceptanceCriteria": [
+        "Update quickstart docs to point users at edge and serverless wasm setup",
+        "Add or update `website/src/content/docs/connect/cloudflare.mdx` for Cloudflare Workers",
+        "Replace the placeholder in `website/src/content/docs/connect/supabase.mdx` with Supabase Edge Functions setup",
+        "Update the sidebar source used by `website/src/sitemap/mod.ts` if a new Connect page is added",
+        "Docs show `setup({ runtime: \"wasm\", wasm: { bindings, initInput }, use })`",
+        "Docs explain that wasm cannot use local SQLite and defaults to remote SQLite when SQLite config is unset",
+        "Docs mention `runtime: \"wasm\"` and `RIVETKIT_RUNTIME=wasm`",
+        "Docs do not mention hidden globals, private generated paths, or lower-level registry builders",
+        "Quickstart and Connect pages link to each other where appropriate",
+        "Typecheck passes"
+      ],
+      "priority": 16,
+      "passes": true,
+      "notes": ""
+    },
+    {
+      "id": "US-017",
+      "title": "Remove Buffer from shared actor runtime glue",
+      "description": "As an edge runtime maintainer, I want the shared TypeScript actor glue to use portable bytes so that wasm hosts do not rely on Node `Buffer` outside the NAPI adapter.",
+      "acceptanceCriteria": [
+        "Audit `rivetkit-typescript/packages/rivetkit/src/registry/native.ts` for `Buffer` usage that is part of shared actor glue rather than NAPI-only adapter conversion",
+        "Replace shared actor glue byte construction and decoding with `Uint8Array`, `ArrayBuffer`, `TextEncoder`, `TextDecoder`, or portable helper functions",
+        "Keep required Node `Buffer` conversion inside `rivetkit-typescript/packages/rivetkit/src/registry/napi-runtime.ts` or clearly NAPI-only code paths",
+        "`WasmCoreRuntime` and wasm platform registry paths do not require `globalThis.Buffer`",
+        "Add or update tests that exercise wasm runtime behavior without installing a `Buffer` global",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 17,
+      "passes": true,
+      "notes": ""
+    },
+    {
+      "id": "US-018",
+      "title": "Tighten runtime SQL boundary types",
+      "description": "As a runtime adapter author, I want SQL boundary types to be exact discriminated unions so that NAPI and wasm cannot accidentally pass malformed SQL params or route strings.",
+      "acceptanceCriteria": [
+        "Change `RuntimeSqlBindParam` to a discriminated union with exactly one value field per kind",
+        "Use `RuntimeBytes` or `Uint8Array` consistently for SQL blob params and results",
+        "Change `RuntimeSqlExecuteResult.route` to the exact union `\"read\" | \"write\" | \"writeFallback\"`",
+        "Update NAPI and wasm SQL adapters to satisfy the stricter runtime SQL types without casts that hide invalid shapes",
+        "Add type or unit coverage for null, int, float, text, blob, and route result normalization",
+        "User-facing SQL integer result behavior remains unchanged from the current TypeScript API",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 18,
+      "passes": true,
+      "notes": ""
+    },
+    {
+      "id": "US-019",
+      "title": "Make platform fixtures match public docs code",
+      "description": "As an application developer, I want platform smoke fixtures to use the same user-friendly code shown in docs so that tests validate the copy-paste Cloudflare, Supabase, and Deno setup.",
+      "acceptanceCriteria": [
+        "Platform app code does not import helper names like `createPlatformSqliteCounterRegistry` from test-only modules",
+        "Each generated platform app includes a docs-shaped registry file that imports `actor`, `setup`, and `@rivetkit/rivetkit-wasm` directly through public package exports",
+        "Each generated platform app calls `setup({ runtime: \"wasm\", wasm: { bindings, initInput }, sqlite: \"remote\", use })` or the documented equivalent inline",
+        "Shared test utilities may generate or copy the docs-shaped registry source, but the app code itself must look like user documentation rather than a test harness API",
+        "Cloudflare Workers, Supabase Functions, and Deno platform tests all use the same docs-shaped SQLite counter actor source with only platform bootstrapping differences",
+        "No platform app uses hidden globals, lower-level registry builders, private generated wasm paths, or test-only registry wrappers",
+        "Typecheck passes",
+        "Tests pass"
+      ],
+      "priority": 19,
+      "passes": true,
+      "notes": ""
     }
   ]
 }
diff --git a/scripts/ralph/progress.txt b/scripts/ralph/progress.txt
index 7f947273b5..e2736160c3 100644
--- a/scripts/ralph/progress.txt
+++ b/scripts/ralph/progress.txt
@@ -1,279 +1,266 @@
 # Ralph Progress Log
-Started: Wed Apr 29 04:23:03 AM PDT 2026
----
+
 ## Codebase Patterns
-- `rivetkit-sqlite` statement routing classification should prepare exactly one statement with `sqlite3_prepare_v2`, read SQLite's decision through `sqlite3_stmt_readonly`, and capture prepare-time authorizer actions with `sqlite3_set_authorizer`.
-- New public `rivetkit-sqlite` behavior tests belong under `rivetkit-rust/packages/rivetkit-sqlite/tests/` when they do not need private module access.
-- Native SQLite VFS ownership is ref-counted through `NativeVfsHandle`; each `NativeConnection` holds a handle clone so the VFS unregisters only after the last connection closes.
-- Envoy SQLite VFS names include the actor database startup generation, e.g. `envoy-sqlite-{actor_id}-g{generation}`, to avoid stale registration collisions.
-- Tests that register multiple native SQLite VFS entries in one process should drop stale generations before replacement generations to avoid perturbing SQLite's global VFS registry.
-- SQLite VFS file handles carry a reader or writer role; reader-owned handles must fail closed for mutating VFS callbacks instead of relying on TypeScript routing.
-- Native SQLite work that can invoke VFS callbacks should run on `spawn_blocking`; VFS callbacks synchronously block on the transport runtime and can fail if SQL runs on an async runtime worker.
-- The native SQLite connection manager keeps an idle writer open while `sqlite3_get_autocommit` is false; `COMMIT` or `ROLLBACK` must reuse that writer and close it once autocommit is restored.
-- Native SQLite read-query routing must classify before installing the mandatory reader authorizer; statement classification uses a temporary authorizer and clears the connection-global authorizer when it finishes.
-- Native SQLite single-statement work should route through `NativeDatabaseHandle::execute`; keep `exec` as the multi-statement compatibility path.
-- TypeScript SQLite database wrappers should route single-statement work through native `SqliteDatabase.execute`; use `exec` only for multi-statement compatibility.
-- TypeScript SQLite migration hooks should run inside native `writeMode` so setup queries use the writer connection and do not create readers.
-- SQLite read-pool rollout config lives in `sqlite-storage::optimization_flags`; build `NativeConnectionManagerConfig` from `sqlite_optimization_flags()` and use `RIVETKIT_SQLITE_OPT_READ_POOL_ENABLED=false` for single-writer compatibility.
-- Kitchen-sink SQLite real-world benchmark reporting should include read-pool route counters alongside VFS counters so parallel-read and read-write-transition workloads expose manager behavior.
-- Native SQLite read-pool v1 closes readers before writes and does not pin per-reader head txids; TypeScript/NAPI wrappers must treat native execution as the routing policy boundary.
+- Current branch: `04-29-chore_rivetkit_wasm_support`.
+- The NAPI and wasm TypeScript adapters implement the shared `CoreRuntime` contract in `rivetkit-typescript/packages/rivetkit/src/registry/`.
+- Keep raw `@rivetkit/rivetkit-napi` and `@rivetkit/rivetkit-wasm` imports inside runtime adapter modules or explicit edge entrypoints.
+- Wasm cannot use local SQLite. Valid SQLite runtime cells are native/local, native/remote, and wasm/remote.
+- Edge smoke coverage should eventually validate public package exports, not only repo-relative generated wasm-pack output.
+- Reuse `rivetkit-typescript/packages/rivetkit/tests/shared-engine.ts` for TypeScript tests that need a local `rivet-engine`; do not add separate engine launchers in driver or platform tests.
+- Runtime normalization should use `CoreRuntime.kind`, not adapter `instanceof` checks. Map `kind: "napi"` to native and `kind: "wasm"` to wasm.
+- `CoreRuntime` SQL methods use the portable `RuntimeSql*` structs from `src/registry/runtime.ts`; keep NAPI `Buffer` conversion inside `NapiCoreRuntime`.
+- Keep runtime SQL bind params as exact discriminated unions and normalize adapter execute routes to `read`, `write`, or `writeFallback`.
+- `CoreRuntime` byte payloads use `RuntimeBytes`/`Uint8Array`; keep Node `Buffer` conversion inside `NapiCoreRuntime` and out of `wasm-runtime.ts`.
+- Shared actor glue in `src/registry/native.ts` should construct `RuntimeBytes`/`Uint8Array`; leave Node `Buffer` creation to `NapiCoreRuntime`.
+- Pass wasm bindings through `setup({ wasm: { bindings, initInput } })`; do not rely on hidden `globalThis` wasm binding hooks.
+- Use `pnpm --filter @rivetkit/rivetkit-wasm run check:package` after wasm package export/files changes; wasm-pack's generated `.gitignore` can otherwise hide required `pkg` artifacts from npm tarballs.
+- Wasm `CoreRegistry` serverless startup uses a `BuildingServerless` waiter state; shutdown during build must wake waiters and drain any newly built runtime.
+- Wasm bindings should forward supported parity APIs to `rivetkit-core`; do not leave placeholder returns for NAPI-supported APIs.
+- Driver matrix env overrides that explicitly request `runtime=wasm` with `sqlite=local` should fail fast in `tests/driver/shared-matrix.ts`.
+- Use public `setup({ sqlite: "local" | "remote" })` for runtime SQLite backend selection; wasm defaults unset SQLite to remote and rejects local during config parsing.
+- Platform wasm smoke clients can use `tests/platforms/shared-registry.ts` for registry typing, while generated platform apps should use docs-shaped local registry source.
+- Platform smoke tests should use `tests/platforms/shared-platform-harness.ts` for shared engine namespaces, serverless runner configs, clients, temp app dirs, health checks, child logs, and pinned `pnpm dlx` launches.
+- Use `buildPlatformSqliteCounterRegistrySource(...)` to generate the shared docs-shaped platform SQLite counter registry source for Cloudflare, Deno, and Supabase apps.
+- Platform tests that import public package exports must build `rivetkit` first because package exports point at `dist/tsup`.
+- Raw `ctx.sql` platform fixtures still need a `db` provider so runtime SQLite is enabled.
+- Cloudflare Workers platform fixtures need a fetch-upgrade `WebSocket` shim for wasm envoy connections.
+- Do not duplicate engine-owned serverless start headers in platform runner config; Cloudflare may combine duplicate headers into comma-separated values.
+- Avoid `sqlite_` table prefixes in platform SQLite fixtures because SQLite reserves them.
+- Deno platform fixtures need `--allow-sys` because public `rivetkit` imports `pino`, which reads `os.hostname()`.
+- Deno platform fixtures can pass wasm bytes from the public `@rivetkit/rivetkit-wasm/rivetkit_wasm_bg.wasm` export using `import.meta.resolve` plus `Deno.readFile`.
+- Supabase Functions platform fixtures run inside Docker; advertise local engines through the Docker bridge IP when `docker0` exists and fall back to `host.docker.internal`.
+- Supabase Functions Edge Runtime needs function-local package metadata and copied package trees for public bare package imports.
+- Supabase Functions fixtures should use Edge Runtime `per_worker` policy and avoid serverless runner prewarm settings so long-lived `/start` streams coexist with metadata and wake requests.
+- Connect docs cards and sidebar entries are generated from `frontend/packages/shared-data/src/deploy.ts`.
+- Website docs code-block typechecking runs during `pnpm --filter rivet-website build`; `c.kv.listRange` and `c.kv.deleteRange` range bounds must be `Uint8Array`.
+
+Started: Fri May 01 2026
+---
+
+## 2026-05-01 21:56 PDT - US-013
+- Added a real Cloudflare Workers wasm platform smoke test that launches pinned local `wrangler dev --local`.
+- The generated Worker app imports only public `rivetkit` and `@rivetkit/rivetkit-wasm` exports, wires wasm through public `setup`, and exercises SQLite counter persistence, cold wake, and parallel actor IDs.
+- Added the Cloudflare fetch-upgrade `WebSocket` shim, public wasm asset export, serverless header cleanup, and SQLite fixture adjustments needed for the workerd runtime.
+- Files changed: `rivetkit-typescript/packages/rivetkit/tests/platforms/cloudflare-workers.test.ts`, `rivetkit-typescript/packages/rivetkit/tests/platforms/shared-platform-harness.ts`, `rivetkit-typescript/packages/rivetkit/tests/platforms/shared-registry.ts`, `rivetkit-typescript/packages/rivetkit/tests/platforms/CLAUDE.md`, `rivetkit-typescript/packages/rivetkit/tests/platforms/AGENTS.md`, `rivetkit-typescript/packages/rivetkit/package.json`, `rivetkit-typescript/packages/rivetkit-wasm/package.json`, `rivetkit-typescript/packages/rivetkit/tests/shared-engine.ts`, `rivetkit-rust/packages/rivetkit-core/src/serverless.rs`, `rivetkit-rust/packages/rivetkit-core/tests/serverless.rs`, `rivetkit-rust/packages/rivetkit-core/tests/context.rs`, `rivetkit-rust/packages/rivetkit-core/tests/sleep.rs`, `rivetkit-rust/packages/rivetkit-core/tests/task.rs`, `scripts/ralph/prd.json`, `scripts/ralph/progress.txt`.
+- Checks: `pnpm --filter rivetkit run test:platforms` passed; `pnpm --filter rivetkit run check-types` passed; `pnpm --filter @rivetkit/rivetkit-wasm run check:package` passed; `pnpm --filter @rivetkit/rivetkit-wasm run check-types` passed; `cargo test -p rivetkit-core matches_combined_duplicate_endpoint_headers` passed.
+- **Learnings for future iterations:**
+  - Cloudflare workerd does not provide a browser-compatible `new WebSocket("ws://...")` path, so the fixture must bridge wasm envoy connections through `fetch(..., { headers: { Upgrade: "websocket" } })`.
+  - Platform app code that uses `ctx.sql` must still declare `db` so the actor config enables runtime SQLite.
+  - The platform test command should build first because generated apps resolve public package exports to `dist/tsup`.
+  - Serverless start headers should be owned by the engine and harness, not duplicated in platform runner config.
+---
+
+## 2026-05-01 19:50 PDT - US-001
+- Extracted the shared local `rivet-engine` lifecycle from the driver harness into `rivetkit-typescript/packages/rivetkit/tests/shared-engine.ts`.
+- Kept driver runtime setup on the existing `shared-harness.ts` API by delegating `getOrStartSharedEngine` and `releaseSharedEngine` to the shared utility.
+- Added a reusable harness note to `rivetkit-typescript/AGENTS.md` and marked US-001 passing in `prd.json`.
+- Files changed: `rivetkit-typescript/packages/rivetkit/tests/shared-engine.ts`, `rivetkit-typescript/packages/rivetkit/tests/driver/shared-harness.ts`, `rivetkit-typescript/AGENTS.md`, `scripts/ralph/prd.json`, `scripts/ralph/progress.txt`.
+- Checks: targeted Biome passed for touched files; `pnpm run check-types` passed in `rivetkit-typescript/packages/rivetkit`; `pnpm exec vitest run tests/driver/shared-matrix.test.ts` passed. Full `pnpm run lint` is blocked by existing fixture lint failures outside this story.
+- **Learnings for future iterations:**
+  - Use `tests/shared-engine.ts` for any TypeScript test that needs a shared local `rivet-engine`.
+  - `driver/shared-harness.ts` should stay focused on namespace, runner config, and driver runtime process setup.
+  - Package-wide lint currently reports many pre-existing issues under `tests/fixtures/driver-test-suite`.
+---
+
+## 2026-05-01 19:53 PDT - US-002
+- Updated runtime normalization to switch on the portable `CoreRuntime.kind` field instead of concrete NAPI/wasm adapter classes.
+- Added runtime-selection coverage for plain object `CoreRuntime` fakes with `kind: "napi"` and `kind: "wasm"`.
+- Kept config precedence behavior covered by the existing setup config, `RIVETKIT_RUNTIME`, and auto-selection tests.
+- Files changed: `rivetkit-typescript/packages/rivetkit/src/registry/native.ts`, `rivetkit-typescript/packages/rivetkit/tests/runtime-selection.test.ts`, `rivetkit-typescript/CLAUDE.md` via the `AGENTS.md` symlink, `scripts/ralph/prd.json`, `scripts/ralph/progress.txt`.
+- Checks: `pnpm exec biome check src/registry/native.ts tests/runtime-selection.test.ts` passed; `pnpm exec vitest run tests/runtime-selection.test.ts` passed; `pnpm run check-types` passed.
+- **Learnings for future iterations:**
+  - `CoreRuntime.kind` is the stable adapter boundary for runtime-specific behavior; avoid class identity checks so duplicate modules and future adapters still work.
+  - The public config still calls the NAPI runtime `native`, while the portable runtime contract uses `kind: "napi"`.
+  - `native.ts` may contain older lint-sensitive code, so touched-file Biome checks can surface nearby cleanup needs.
+---
+
+## 2026-05-01 19:57 PDT - US-003
+- Defined explicit portable SQL bind, query, execute, exec, run, and database types in `rivetkit-typescript/packages/rivetkit/src/registry/runtime.ts`.
+- Updated NAPI and wasm SQL adapters to implement the shared runtime SQL shape, with NAPI converting `Uint8Array` blob params to `Buffer` only at the native binding call.
+- Added bind normalization coverage for bigint, boolean, string, number, null, undefined, and `Uint8Array`.
+- Files changed: `rivetkit-typescript/packages/rivetkit/src/registry/runtime.ts`, `rivetkit-typescript/packages/rivetkit/src/registry/napi-runtime.ts`, `rivetkit-typescript/packages/rivetkit/src/registry/wasm-runtime.ts`, `rivetkit-typescript/packages/rivetkit/src/common/database/native-database.test.ts`, `rivetkit-typescript/CLAUDE.md` via the `AGENTS.md` symlink, `scripts/ralph/prd.json`, `scripts/ralph/progress.txt`.
+- Checks: `pnpm exec biome check src/registry/runtime.ts src/registry/napi-runtime.ts src/registry/wasm-runtime.ts src/common/database/native-database.test.ts` passed; `pnpm run check-types` passed; `pnpm exec vitest run src/common/database/native-database.test.ts` passed; `pnpm exec vitest run tests/wasm-host-smoke.test.ts` passed.
+- **Learnings for future iterations:**
+  - The shared runtime SQL boundary should stay independent of `JsNativeDatabaseLike`.
+  - NAPI generated bindings still use `Buffer` for SQL blobs, so adapt at the NAPI runtime edge instead of changing `CoreRuntime`.
+  - `wrapJsNativeDatabase` remains the user-facing SQL behavior boundary and is the right place to guard bind normalization.
+---
+
+## 2026-05-01 20:01 PDT - US-004
+- Replaced the shared `CoreRuntime` byte boundary with `RuntimeBytes`/`Uint8Array` for HTTP bodies, state deltas, KV keys and values, queue payloads, websocket bytes, connection bytes, and inspector bytes.
+- Kept NAPI `Buffer` coercion inside `NapiCoreRuntime`, including serverless requests, HTTP requests, state deltas, KV batches, queue completions, schedules, connections, websockets, and SQL blob params.
+- Removed Node `Buffer` normalization from `wasm-runtime.ts` so wasm byte handling stays portable.
+- Files changed: `rivetkit-typescript/packages/rivetkit/src/registry/runtime.ts`, `rivetkit-typescript/packages/rivetkit/src/registry/napi-runtime.ts`, `rivetkit-typescript/packages/rivetkit/src/registry/wasm-runtime.ts`, `rivetkit-typescript/packages/rivetkit/src/registry/index.ts`, `rivetkit-typescript/CLAUDE.md`, `scripts/ralph/prd.json`, `scripts/ralph/progress.txt`.
+- Checks: `pnpm exec biome check src/registry/runtime.ts src/registry/napi-runtime.ts src/registry/wasm-runtime.ts src/registry/index.ts` passed; `pnpm run check-types` passed; `pnpm exec vitest run tests/wasm-host-smoke.test.ts tests/runtime-selection.test.ts` passed.
+- **Learnings for future iterations:**
+  - Use `RuntimeBytes` from `src/registry/runtime.ts` for shared runtime byte payloads.
+  - NAPI generated bindings still require `Buffer`, so convert at the `NapiCoreRuntime` call boundary rather than widening the shared contract.
+  - Wasm runtime code should avoid Node byte helpers such as `Buffer.from`, `Buffer.alloc`, and `Buffer.isBuffer`.
+---
 
-## 2026-04-29 04:27:40 PDT - US-001
-- Implemented native SQLite statement classification with readonly detection, trailing-statement detection, authorizer action capture, and conservative reader eligibility.
-- Added integration coverage for SELECT, read-only PRAGMA, mutating PRAGMA, INSERT RETURNING, CTE writes, VACUUM, ATTACH, BEGIN, SAVEPOINT, and multi-statement SQL.
-- Files changed:
-  - `rivetkit-rust/packages/rivetkit-sqlite/src/query.rs`
-  - `rivetkit-rust/packages/rivetkit-sqlite/tests/statement_classification.rs`
-  - `scripts/ralph/prd.json`
-  - `scripts/ralph/progress.txt`
-- Checks:
-  - `cargo check -p rivetkit-sqlite`
-  - `cargo test -p rivetkit-sqlite`
+## 2026-05-01 20:04 PDT - US-005
+- Added typed `wasm.bindings` runtime config alongside `wasm.initInput`.
+- Updated runtime loading so explicit and auto wasm selection pass the full wasm config object into `loadWasmRuntime`.
+- Removed production `globalThis.__rivetkitWasmBindings` lookup; configured bindings are used before falling back to the public `@rivetkit/rivetkit-wasm` import.
+- Files changed: `rivetkit-typescript/packages/rivetkit/src/registry/config/index.ts`, `rivetkit-typescript/packages/rivetkit/src/registry/native.ts`, `rivetkit-typescript/packages/rivetkit/src/registry/wasm-runtime.ts`, `rivetkit-typescript/packages/rivetkit/tests/runtime-selection.test.ts`, `rivetkit-typescript/packages/rivetkit/tests/wasm-runtime.test.ts`, `scripts/ralph/prd.json`, `scripts/ralph/progress.txt`.
+- Checks: `pnpm exec biome check src/registry/config/index.ts src/registry/native.ts src/registry/wasm-runtime.ts tests/runtime-selection.test.ts tests/wasm-runtime.test.ts` passed; `pnpm exec vitest run tests/runtime-selection.test.ts tests/wasm-runtime.test.ts` passed; `pnpm run check-types` passed.
 - **Learnings for future iterations:**
-  - SQLite reports raw `BEGIN` and `SAVEPOINT` as readonly, so authorizer transaction-control capture must block reader routing separately.
-  - `sqlite3_prepare_v2` exposes unconsumed trailing SQL through the tail pointer; non-whitespace tail text should make reader routing ineligible.
-  - Existing `rivetkit-sqlite` builds currently emit pre-existing Rust 2024 unsafe-op warnings from `src/vfs.rs`, but the package check and tests pass.
+  - `RegistryConfigSchema` owns the typed wasm binding config.
+  - `loadWasmRuntime` accepts the full wasm config object so bindings and `initInput` stay paired.
+  - Keep platform-provided wasm bindings explicit in registry config instead of smuggling them through globals.
 ---
-## 2026-04-29 04:33:10 PDT - US-002
-- Implemented split native SQLite ownership with `NativeVfsHandle`, `NativeConnection`, and the existing `NativeDatabase` compatibility wrapper.
-- Added generation-bearing envoy VFS names and tests for shared VFS context reuse plus unregister-after-last-connection cleanup.
-- Files changed:
-  - `rivetkit-rust/packages/rivetkit-sqlite/src/database.rs`
-  - `rivetkit-rust/packages/rivetkit-sqlite/src/vfs.rs`
-  - `scripts/ralph/prd.json`
-  - `scripts/ralph/progress.txt`
-- Checks:
-  - `cargo check -p rivetkit-sqlite`
-  - `cargo test -p rivetkit-sqlite native_vfs_handle --lib`
-  - `cargo test -p rivetkit-sqlite`
+
+## 2026-05-01 20:09 PDT - US-006
+- Published the wasm package through one root public import path by keeping `@rivetkit/rivetkit-wasm` as the only package export and forwarding root declarations to the generated wasm-pack declarations.
+- Fixed package contents so npm tarballs include the root JS/types, generated JS/types, and `.wasm` artifact despite wasm-pack's generated ignored `pkg/` directory.
+- Added a `check:package` script to assert the published file list and a `prepack` build hook so clean package publishing regenerates wasm artifacts before packing.
+- Files changed: `rivetkit-typescript/packages/rivetkit-wasm/.npmignore`, `rivetkit-typescript/packages/rivetkit-wasm/index.d.ts`, `rivetkit-typescript/packages/rivetkit-wasm/package.json`, `rivetkit-typescript/packages/rivetkit-wasm/scripts/check-package.mjs`, `rivetkit-typescript/CLAUDE.md`, `scripts/ralph/prd.json`, `scripts/ralph/progress.txt`.
+- Checks: `pnpm --filter @rivetkit/rivetkit-wasm run check:package` passed; `pnpm --filter @rivetkit/rivetkit-wasm run check-types` passed; `pnpm --filter @rivetkit/rivetkit-wasm run check:wasm` passed with existing warnings in `rivetkit-core`; `pnpm --filter rivetkit run check-types` passed; `pnpm --filter rivetkit exec vitest run tests/wasm-runtime.test.ts tests/runtime-selection.test.ts` passed; public root import smoke via Node passed; `SKIP_WASM_BUILD=1 npm pack --dry-run` passed.
+- **Learnings for future iterations:**
+  - `@rivetkit/rivetkit-wasm` should expose only the root export; do not add platform-specific or generated subpath exports unless a platform test proves the root path cannot work.
+  - wasm-pack writes `pkg/.gitignore` with `*`, so npm package contents need an explicit `.npmignore` override plus a tarball check.
+  - Root package declarations can forward to `./pkg/rivetkit_wasm.js` when the tarball includes the generated `.d.ts` files.
+---
+
+## 2026-05-01 20:15 PDT - US-007
+- Implemented wasm `CoreRegistry` serverless startup concurrency with a `BuildingServerless` state, waiters, structured invalid-state errors, and shutdown cleanup for runtimes built after cancellation.
+- Added focused wasm runtime tests for concurrent first serverless requests, shutdown during serverless build, and structured wrong-mode errors.
+- Added the generated `wasm.invalid_state` error artifact and a reusable wasm binding note in `rivetkit-typescript/AGENTS.md`.
+- Files changed: `rivetkit-typescript/packages/rivetkit-wasm/src/lib.rs`, `rivetkit-typescript/packages/rivetkit/tests/wasm-runtime.test.ts`, `rivetkit-typescript/CLAUDE.md`, `engine/artifacts/errors/wasm.invalid_state.json`, `scripts/ralph/prd.json`, `scripts/ralph/progress.txt`.
+- Checks: `pnpm --filter @rivetkit/rivetkit-wasm run check:wasm` passed with existing `rivetkit-core` warnings; `pnpm --filter @rivetkit/rivetkit-wasm run check-types` passed; `pnpm --filter rivetkit run check-types` passed; `pnpm --filter rivetkit exec biome check tests/wasm-runtime.test.ts` passed; `pnpm --filter rivetkit exec vitest run tests/wasm-runtime.test.ts` passed.
 - **Learnings for future iterations:**
-  - `sqlite3_vfs_register` duplicate-name behavior is not a good lifetime assertion; use `sqlite3_vfs_find` when tests need to inspect VFS registration state.
-  - Keeping a `NativeVfsHandle` clone inside each `NativeConnection` makes close ordering fail-closed even if a connection outlives its manager wrapper.
-  - `cargo test -p rivetkit-sqlite` may emit existing Rust 2024 unsafe-op warnings from `src/vfs.rs`; this session's full rerun passed.
+  - Use a waiter state rather than a temporary `Serving` state during wasm serverless runtime construction.
+  - Build failures and shutdown during wasm serverless startup must transition the registry to a terminal state and wake all waiters.
+  - New `RivetError` derives create `engine/artifacts/errors/*.json` files that should be committed with the source change.
 ---
-## 2026-04-29 04:43:03 PDT - US-003
-- Implemented native SQLite VFS reader/writer roles on main and auxiliary file handles, including output flag normalization from assigned role.
-- Reader-owned VFS handles now reject mutating callbacks: xWrite, xTruncate, dirty xSync/xClose, xDelete for reader-owned aux files, and atomic-write file-control operations.
-- Added inline VFS tests for reader fail-closed behavior, writer write behavior, reader aux creation denial, output flags, and reader-owned aux delete rejection.
-- Files changed:
-  - `rivetkit-rust/packages/rivetkit-sqlite/src/vfs.rs`
-  - `scripts/ralph/prd.json`
-  - `scripts/ralph/progress.txt`
-- Checks:
-  - `cargo check -p rivetkit-sqlite`
-  - `cargo test -p rivetkit-sqlite vfs_file --lib`
-  - `cargo test -p rivetkit-sqlite role_flags --lib`
-  - `cargo test -p rivetkit-sqlite reader_owned_aux_files_reject_delete --lib`
-  - `cargo test -p rivetkit-sqlite`
+
+## 2026-05-01 20:17 PDT - US-008
+- Restored wasm queue max-size parity by forwarding `WasmQueue.maxSize()` to the core queue config instead of returning `0`.
+- Added adapter parity coverage proving NAPI and wasm both read queue max size through the shared runtime boundary.
+- Made missing wasm runtime methods throw a structured `runtime.unsupported` `RivetError` with runtime and method metadata.
+- Files changed: `rivetkit-typescript/packages/rivetkit-wasm/src/lib.rs`, `rivetkit-typescript/packages/rivetkit/src/registry/wasm-runtime.ts`, `rivetkit-typescript/packages/rivetkit/tests/wasm-runtime.test.ts`, `scripts/ralph/prd.json`, `scripts/ralph/progress.txt`.
+- Checks: `pnpm --filter @rivetkit/rivetkit-wasm run check:wasm` passed with existing `rivetkit-core` warnings; `pnpm --filter rivetkit exec biome check src/registry/wasm-runtime.ts tests/wasm-runtime.test.ts` passed; `pnpm --filter rivetkit run check-types` passed; `pnpm --filter rivetkit exec vitest run tests/wasm-runtime.test.ts` passed.
+- **Learnings for future iterations:**
+  - `WasmQueue` should expose the same supported queue surface as NAPI by forwarding to `rivetkit-core::ActorContext`.
+  - Use focused adapter tests with fake actor contexts when parity behavior lives in the TypeScript runtime boundary.
+  - Missing wasm binding methods should fail as structured `runtime.unsupported` errors with the missing method name in metadata.
+---
+
+## 2026-05-01 20:20 PDT - US-009
+- Implemented fail-fast validation for explicit `RIVETKIT_DRIVER_TEST_RUNTIME=wasm` plus `RIVETKIT_DRIVER_TEST_SQLITE=local` driver matrix overrides.
+- Added shared matrix tests covering the exact valid SQLite matrix cells and the explicit wasm/local configuration error.
+- Marked US-009 passing in `prd.json`.
+- Files changed: `rivetkit-typescript/packages/rivetkit/tests/driver/shared-matrix.ts`, `rivetkit-typescript/packages/rivetkit/tests/driver/shared-matrix.test.ts`, `scripts/ralph/prd.json`, `scripts/ralph/progress.txt`.
+- Checks: `pnpm --filter rivetkit exec biome check tests/driver/shared-matrix.ts tests/driver/shared-matrix.test.ts` passed; `pnpm --filter rivetkit exec vitest run tests/driver/shared-matrix.test.ts` passed; `pnpm --filter rivetkit run check-types` passed.
 - **Learnings for future iterations:**
-  - VFS role enforcement belongs in `VfsFile`, not only connection setup, because SQLite mutating callbacks arrive through file handles.
-  - Reader auxiliary-file creation is denied by default; only existing auxiliary paths can be opened read-only until a safe path class is explicitly documented in code.
-  - `cargo test -p rivetkit-sqlite` still emits existing Rust 2024 unsafe-op warnings from VFS callbacks, but the full suite passes.
+  - The normal SQLite driver matrix still filters unsupported wasm/local cells so native/local, native/remote, and wasm/remote coverage remains.
+  - Treat env matrix overrides as requested coverage. If they name an unsupported cell, throw instead of silently filtering it out.
+  - Keep driver matrix behavior covered in `tests/driver/shared-matrix.test.ts` because it is fast and does not need the shared engine.
 ---
-## 2026-04-29 04:54:49 PDT - US-004
-- Implemented `NativeConnectionManager` with closed, read-mode, write-mode, and closing states, lazy read-only connection admission up to a max reader count, writer preference, read-to-write transition cleanup, and close-time VFS teardown.
-- Added VFS-backed tests for read admission, writer preference, read-to-write transition state, and close ordering through VFS unregister.
-- Files changed:
-  - `rivetkit-rust/packages/rivetkit-sqlite/src/connection_manager.rs`
-  - `rivetkit-rust/packages/rivetkit-sqlite/src/lib.rs`
-  - `rivetkit-rust/packages/rivetkit-sqlite/src/vfs.rs`
-  - `scripts/ralph/prd.json`
-  - `scripts/ralph/progress.txt`
-- Checks:
-  - `cargo check -p rivetkit-sqlite`
-  - `cargo test -p rivetkit-sqlite connection_manager --lib`
-  - `cargo test -p rivetkit-sqlite bench_large_tx_insert_100mb --lib`
-  - `cargo test -p rivetkit-sqlite`
+
+## 2026-05-01 20:23 PDT - US-010
+- Added public `sqlite` registry config for selecting the runtime SQLite backend.
+- Made explicit wasm/local SQLite fail during config parsing, while unset wasm SQLite defaults to remote and native keeps its previous default.
+- Preserved the internal `test.sqliteBackend` path for existing driver coverage while routing runtime backend decisions through one helper.
+- Files changed: `rivetkit-typescript/packages/rivetkit/src/registry/config/index.ts`, `rivetkit-typescript/packages/rivetkit/src/registry/native.ts`, `rivetkit-typescript/packages/rivetkit/tests/runtime-selection.test.ts`, `rivetkit-typescript/CLAUDE.md`, `scripts/ralph/prd.json`, `scripts/ralph/progress.txt`.
+- Checks: `pnpm exec biome check src/registry/config/index.ts src/registry/native.ts tests/runtime-selection.test.ts` passed; `pnpm exec vitest run tests/runtime-selection.test.ts` passed; `pnpm run check-types` passed.
 - **Learnings for future iterations:**
-  - The connection manager is present as a native primitive but existing query/run/exec routing is intentionally unchanged until US-005 and later stories.
-  - SQL executed through the native VFS should run on blocking threads, because VFS callbacks synchronously block on the transport runtime.
-  - A full-suite run briefly failed the existing 100 MiB large-transaction test with a staged-delta decode error, but the single test and the full suite both passed on rerun.
+  - Public setup config should use `sqlite: "local" | "remote"` for backend selection; the schema also normalizes object form to `{ backend }`.
+  - Keep `test.sqliteBackend` as a driver/test hook, but production runtime decisions should prefer public `sqlite.backend`.
+  - Explicit `runtime: "wasm"` is validated at config parse time; auto-selected wasm is guarded again during runtime normalization.
 ---
-## 2026-04-29 05:04:08 PDT - US-005
-- Implemented exclusive write-mode routing for native SQLite run, query, exec, startup configuration, and batch-atomic verification through `NativeConnectionManager`.
-- Added transaction-aware writer retention: raw `BEGIN` and `SAVEPOINT` keep the manager in write mode until `COMMIT` or `ROLLBACK` restores autocommit.
-- Added manager tests proving pending readers wait behind manual `BEGIN` and `SAVEPOINT` write mode, alongside the existing writer-preference coverage.
-- Files changed:
-  - `rivetkit-rust/packages/rivetkit-core/src/actor/sqlite.rs`
-  - `rivetkit-rust/packages/rivetkit-sqlite/src/connection_manager.rs`
-  - `rivetkit-rust/packages/rivetkit-sqlite/src/database.rs`
-  - `rivetkit-rust/packages/rivetkit-sqlite/src/vfs.rs`
-  - `scripts/ralph/prd.json`
-  - `scripts/ralph/progress.txt`
-- Checks:
-  - `cargo check -p rivetkit-sqlite`
-  - `cargo check -p rivetkit-core`
-  - `cargo test -p rivetkit-sqlite connection_manager --lib`
-  - `cargo test -p rivetkit-sqlite`
-  - `cargo test -p rivetkit-core` was stopped after an unrelated actor-task log assertion failed and a separate actor-task test hung past 60 seconds; both reproduce outside SQLite-focused changes.
+
+## 2026-05-01 20:26 PDT - US-011
+- Added `rivetkit-typescript/packages/rivetkit/tests/platforms/shared-registry.ts` with a raw-SQL SQLite counter actor exposing `increment` and `getCount`.
+- Added a public-shape registry factory that requires explicit wasm bindings/init input, hardcodes `runtime: "wasm"`, and hardcodes remote SQLite with no local SQLite option.
+- Files changed: `rivetkit-typescript/packages/rivetkit/tests/platforms/shared-registry.ts`, `rivetkit-typescript/CLAUDE.md`, `scripts/ralph/prd.json`, `scripts/ralph/progress.txt`.
+- Checks: `pnpm exec biome check tests/platforms/shared-registry.ts` passed; `pnpm run check-types` passed; `pnpm exec tsx -e "import('./tests/platforms/shared-registry.ts').then(() => undefined)"` passed.
 - **Learnings for future iterations:**
-  - Per-connection SQLite PRAGMAs need to run when a writer connection is newly opened, not when reusing a transaction-held writer.
-  - Raw transaction-control statements must be treated as write-mode state changes even when SQLite reports them as read-only.
-  - The full `rivetkit-core` suite currently has non-SQLite actor-task test instability in `actor_task_logs_lifecycle_dispatch_and_actor_event_flow` and `save_tick_cancels_pending_inspector_deadline_and_broadcasts_overlay`.
+  - Platform smoke tests should share the `sqliteCounter` actor from `tests/platforms/shared-registry.ts` instead of duplicating counter actor code per host.
+  - The shared platform registry intentionally omits `sqlite`, `runtime`, `test`, `use`, and `wasm` from caller options so tests cannot accidentally enable local SQLite or private test config.
+  - Use `ctx.sql` for this platform counter because it keeps the app import surface to public `rivetkit` plus explicit wasm bindings and avoids the Drizzle/database-provider subpaths.
 ---
-## 2026-04-29 05:21:13 PDT - US-006
-- Implemented read-only query routing through native read connections, including lazy reader opens, idle reader reuse, per-reader `PRAGMA query_only = ON`, and fallback to write mode only for classification-ineligible statements.
-- Added a mandatory reader authorizer that denies transaction control, attach/detach, schema/temp/data writes, unsafe pragmas, and unsafe functions, with fail-closed behavior when reader execution rejects a statement.
-- Moved native SQLite connection opens onto blocking threads because opening a VFS-backed connection can invoke callbacks that synchronously block on the transport runtime.
-- Files changed:
-  - `rivetkit-rust/packages/rivetkit-sqlite/src/connection_manager.rs`
-  - `rivetkit-rust/packages/rivetkit-sqlite/src/database.rs`
-  - `rivetkit-rust/packages/rivetkit-sqlite/src/query.rs`
-  - `rivetkit-rust/packages/rivetkit-sqlite/src/vfs.rs`
-  - `scripts/ralph/prd.json`
-  - `scripts/ralph/progress.txt`
-- Checks:
-  - `cargo check -p rivetkit-sqlite`
-  - `cargo test -p rivetkit-sqlite native_database_routes_concurrent_readonly_queries_to_multiple_readers --lib`
-  - `cargo test -p rivetkit-sqlite native_database_reuses_idle_reader_for_readonly_query --lib`
-  - `cargo test -p rivetkit-sqlite native_database_reader_authorizer_denies_unsafe_functions --lib`
-  - `timeout 240s cargo test -p rivetkit-sqlite`
+
+## 2026-05-01 20:37 PDT - US-012
+- Added `rivetkit-typescript/packages/rivetkit/tests/platforms/shared-platform-harness.ts` with helpers for shared engine reuse, namespace creation, serverless runner config, SQLite counter clients, temp app dirs, logged child processes, health checks, and pinned `pnpm dlx` CLI launches.
+- Added fast harness coverage in `tests/platforms/shared-platform-harness.test.ts`.
+- Added `pnpm run test:platforms` and excluded `tests/platforms/**/*.test.ts` from default Vitest unless `RIVETKIT_INCLUDE_PLATFORM_TESTS=1` is set.
+- Files changed: `rivetkit-typescript/packages/rivetkit/tests/platforms/shared-platform-harness.ts`, `rivetkit-typescript/packages/rivetkit/tests/platforms/shared-platform-harness.test.ts`, `rivetkit-typescript/packages/rivetkit/tests/platforms/shared-registry.ts`, `rivetkit-typescript/packages/rivetkit/package.json`, `rivetkit-typescript/packages/rivetkit/vitest.config.ts`, `rivetkit-typescript/CLAUDE.md`, `scripts/ralph/prd.json`, `scripts/ralph/progress.txt`.
+- Checks: `pnpm exec biome check tests/platforms/shared-platform-harness.ts tests/platforms/shared-platform-harness.test.ts tests/platforms/shared-registry.ts package.json vitest.config.ts` passed; `pnpm run check-types` passed; `pnpm run test:platforms` passed; `pnpm exec tsx -e "import('./tests/platforms/shared-platform-harness.ts').then(() => undefined)"` passed; `pnpm exec vitest run tests/platforms --passWithNoTests` confirmed platform tests are excluded by default. A broader `pnpm exec vitest run --passWithNoTests` was stopped after several minutes in unrelated driver coverage.
 - **Learnings for future iterations:**
-  - Reader routing should treat classification errors as write-required, but errors after a statement is classified reader-eligible should fail closed instead of silently retrying on the writer.
-  - `sqlite3_open_v2` can invoke VFS callbacks, so read and write connection opens need the same blocking-thread treatment as SQL execution.
-  - A held reader plus a timed read-only query is a deterministic way to prove queries are using read-mode instead of waiting behind write-mode.
+  - Use `createPlatformServerlessRunner(...)` to create a namespace and serverless runner config against the shared local engine.
+  - Use `createPlatformSqliteCounterClient(...)` with the returned runner when platform smoke tests need the shared counter registry.
+  - Launch platform CLIs through `spawnPinnedPnpmDlx(...)` so test code has to name a concrete package version.
 ---
-## 2026-04-29 05:28:16 PDT - US-007
-- Implemented a native single-statement execute API that returns rows, columns, changes, last insert row id, and route metadata.
-- Routed `NativeDatabaseHandle::query` and `run` through the native execute path while leaving `exec` as the multi-statement compatibility path.
-- Updated core inspector database execution to use the native execute path through `ActorContext::db_execute`.
-- Files changed:
-  - `CLAUDE.md`
-  - `rivetkit-rust/packages/rivetkit-core/src/actor/context.rs`
-  - `rivetkit-rust/packages/rivetkit-core/src/actor/mod.rs`
-  - `rivetkit-rust/packages/rivetkit-core/src/actor/sqlite.rs`
-  - `rivetkit-rust/packages/rivetkit-core/src/registry/inspector.rs`
-  - `rivetkit-rust/packages/rivetkit-sqlite/src/database.rs`
-  - `rivetkit-rust/packages/rivetkit-sqlite/src/query.rs`
-  - `scripts/ralph/prd.json`
-  - `scripts/ralph/progress.txt`
-- Checks:
-  - `cargo check -p rivetkit-sqlite`
-  - `cargo test -p rivetkit-sqlite execute_single_statement --lib`
-  - `cargo check -p rivetkit-core`
-  - `timeout 240s cargo test -p rivetkit-sqlite`
+
+## 2026-05-01 22:05 PDT - US-014
+- Added a real local Deno wasm platform smoke test in `rivetkit-typescript/packages/rivetkit/tests/platforms/deno.test.ts`.
+- The generated Deno app imports only public `rivetkit` and `@rivetkit/rivetkit-wasm` exports, passes wasm bytes through public setup config, and exercises SQLite counter persistence, sleep/wake, and parallel actor IDs.
+- Marked US-014 passing in `scripts/ralph/prd.json`.
+- Files changed: `rivetkit-typescript/packages/rivetkit/tests/platforms/deno.test.ts`, `rivetkit-typescript/packages/rivetkit/tests/platforms/CLAUDE.md`, `scripts/ralph/prd.json`, `scripts/ralph/progress.txt`.
+- Checks: `pnpm exec biome check tests/platforms/deno.test.ts` passed; `RIVETKIT_INCLUDE_PLATFORM_TESTS=1 pnpm exec vitest run tests/platforms/deno.test.ts` passed; `pnpm run check-types` passed; `pnpm run test:platforms` passed.
 - **Learnings for future iterations:**
-  - `ExecuteRoute` metadata is assigned by the database routing layer; the low-level query helper only prepares, steps, and packages the supplied route.
-  - The native execute helper rejects multi-statement SQL by checking SQLite's prepare tail. Use `exec` when multi-statement compatibility is required.
-  - Inspector database execution should use `db_execute` so INSERT RETURNING and write statements go through the same native routing policy as user database calls.
+  - Deno can resolve the local workspace packages through symlinked `node_modules` with `--node-modules-dir=manual`.
+  - The Deno app needs `--allow-sys` because `pino` reads the host name during public `rivetkit` import.
+  - Use the public wasm asset export with `import.meta.resolve("@rivetkit/rivetkit-wasm/rivetkit_wasm_bg.wasm")` and `Deno.readFile(...)` instead of importing generated `pkg` paths.
 ---
-## 2026-04-29 05:36:07 PDT - US-008
-- Exposed native SQLite `execute` and forced-writer `executeWrite` through `rivetkit-napi` and the TypeScript native database wrapper.
-- Removed TS-side per-query serialization from native, raw, and Drizzle database paths; single-statement calls now route through native `execute`, while multi-statement compatibility stays on `exec`.
-- Added a native wrapper close gate so close waits for admitted calls and rejects new work, plus migration `writeMode` so migration hooks use writer execution.
-- Files changed:
-  - `rivetkit-rust/packages/rivetkit-core/src/actor/sqlite.rs`
-  - `rivetkit-rust/packages/rivetkit-sqlite/src/database.rs`
-  - `rivetkit-typescript/packages/rivetkit-napi/src/database.rs`
-  - `rivetkit-typescript/packages/rivetkit-napi/index.d.ts`
-  - `rivetkit-typescript/packages/rivetkit/src/common/database/config.ts`
-  - `rivetkit-typescript/packages/rivetkit/src/common/database/mod.ts`
-  - `rivetkit-typescript/packages/rivetkit/src/common/database/native-database.ts`
-  - `rivetkit-typescript/packages/rivetkit/src/common/database/native-database.test.ts`
-  - `rivetkit-typescript/packages/rivetkit/src/db/drizzle.ts`
-  - `scripts/ralph/prd.json`
-  - `scripts/ralph/progress.txt`
-- Checks:
-  - `cargo check -p rivetkit-sqlite`
-  - `cargo check -p rivetkit-core`
-  - `cargo check -p rivetkit-napi`
-  - `timeout 240s cargo test -p rivetkit-sqlite`
-  - `pnpm --dir rivetkit-typescript/packages/rivetkit run check-types`
-  - `pnpm --dir rivetkit-typescript/packages/rivetkit exec vitest run src/common/database/native-database.test.ts`
-  - `pnpm --dir rivetkit-typescript/packages/rivetkit exec biome check src/common/database/native-database.ts src/common/database/native-database.test.ts src/common/database/mod.ts src/db/drizzle.ts`
-  - `pnpm --dir rivetkit-typescript/packages/rivetkit run lint` is still blocked by pre-existing unrelated Biome errors in driver fixtures and tests.
+
+## 2026-05-01 23:11 PDT - US-015
+- Added a real local Supabase Functions wasm platform smoke test driven by pinned `pnpm dlx supabase@2.95.4 functions serve`.
+- The generated function app imports only public `rivetkit` and `@rivetkit/rivetkit-wasm` exports, wires wasm bytes through public setup config, and exercises SQLite counter persistence, idle sleep/wake, and parallel actor IDs.
+- Added Supabase-specific engine/network/package handling for Dockerized Edge Runtime and marked US-015 passing in `prd.json`.
+- Files changed: `rivetkit-typescript/packages/rivetkit/tests/platforms/supabase-functions.test.ts`, `rivetkit-typescript/packages/rivetkit/tests/platforms/CLAUDE.md`, `scripts/ralph/prd.json`, `scripts/ralph/progress.txt`.
+- Checks: `pnpm exec biome check tests/platforms/supabase-functions.test.ts tests/platforms/CLAUDE.md` passed; `RIVETKIT_INCLUDE_PLATFORM_TESTS=1 pnpm exec vitest run tests/platforms/supabase-functions.test.ts` passed; `pnpm run check-types` passed; `pnpm run test:platforms` passed.
 - **Learnings for future iterations:**
-  - Use `SqliteDatabase.execute` in TypeScript wrappers for single statements so native classification owns read/write routing.
-  - A close gate is enough for TS wrapper lifecycle safety; write serialization belongs in the native connection manager.
-  - NAPI-generated route metadata is typed as `string` in `index.d.ts`, so the TS wrapper should normalize it before exposing the public union.
+  - Supabase Edge Runtime runs in Docker, so local engine URLs must be reachable from containers; prefer the Docker bridge IP from `docker0` and fall back to `host.docker.internal`.
+  - Supabase Edge Runtime bare import resolution needs package metadata and real package trees next to the function entrypoint.
+  - Avoid serverless runner prewarm for Supabase Functions and use `per_worker`; prewarm/`oneshot` caused `/start` BOOT_ERRORs around long-lived serverless streams.
 ---
-## 2026-04-29 05:45:00 PDT - US-009
-- Added central SQLite read-pool rollout flags for enabled/disabled state, max readers, and idle reader TTL, then wired `open_database_from_envoy` through `NativeConnectionManagerConfig::from_optimization_flags`.
-- Added read-pool Prometheus metrics for reader gauges, wait histograms, routed reads, write fallbacks, manual transaction duration, reader opens/closes, rejected reader mutations, and mode transitions.
-- Preserved disabled single-writer behavior by routing all statements through the writer when `RIVETKIT_SQLITE_OPT_READ_POOL_ENABLED=false`, with a regression test proving SELECT does not open readers.
-- Files changed:
-  - `engine/packages/sqlite-storage/src/optimization_flags.rs`
-  - `rivetkit-rust/packages/rivetkit-sqlite/src/connection_manager.rs`
-  - `rivetkit-rust/packages/rivetkit-sqlite/src/database.rs`
-  - `rivetkit-rust/packages/rivetkit-sqlite/src/vfs.rs`
-  - `rivetkit-rust/packages/rivetkit-core/src/actor/metrics.rs`
-  - `rivetkit-rust/packages/rivetkit-core/tests/metrics.rs`
-  - `examples/kitchen-sink/scripts/sqlite-realworld-bench.ts`
-  - `engine/packages/sqlite-storage/AGENTS.md`
-  - `scripts/ralph/prd.json`
-  - `scripts/ralph/progress.txt`
-- Checks:
-  - `cargo check -p sqlite-storage`
-  - `cargo check -p rivetkit-sqlite`
-  - `cargo check -p rivetkit-core`
-  - `cargo check -p rivetkit-core --features sqlite`
-  - `cargo test -p sqlite-storage optimization_flags`
-  - `cargo test -p rivetkit-sqlite disabled_read_pool_routes_select_through_single_writer --lib`
-  - `cargo test -p rivetkit-core --features sqlite sqlite_read_pool_metrics_render`
-  - `timeout 240s cargo test -p rivetkit-sqlite`
-  - `pnpm --dir examples/kitchen-sink test`
+
+## 2026-05-01 23:21 PDT - US-016
+- Added Cloudflare Workers wasm runtime setup docs with public `rivetkit` and `@rivetkit/rivetkit-wasm` imports, explicit `setup({ runtime: "wasm", wasm: { bindings, initInput }, sqlite: "remote", use })`, and remote SQLite/runtime notes.
+- Replaced the Supabase placeholder with Supabase Edge Functions wasm setup docs, including Deno wasm loading and serverless runner URL guidance.
+- Added Cloudflare Workers and Supabase Functions to the Connect deploy metadata and quickstart cards, and fixed the KV range docs snippet that was blocking docs typechecking.
+- Files changed: `website/src/content/docs/connect/cloudflare.mdx`, `website/src/content/docs/connect/supabase.mdx`, `website/src/content/docs/quickstart/index.mdx`, `website/src/content/docs/actors/quickstart/index.mdx`, `website/src/content/docs/actors/kv.mdx`, `frontend/packages/shared-data/src/deploy.ts`, `website/CLAUDE.md`, `scripts/ralph/prd.json`, `scripts/ralph/progress.txt`.
+- Checks: `pnpm --filter rivet-website build` passed; `git diff --check` passed. `pnpm --filter rivet-website lint` is blocked because the website package has ESLint 9 but no `eslint.config.*` flat config.
 - **Learnings for future iterations:**
-  - The read pool is enabled by default to preserve prior native parallel-read behavior; disabled mode intentionally keeps one writer connection open and reports readonly statements as write fallbacks.
-  - Existing actor metrics already implement the SQLite VFS metrics trait, so read-pool internals can be exposed by extending that trait without adding a second metrics plumbing path.
-  - Idle reader TTL cleanup is lazy on read admission; there is no background timer for reader expiry.
+  - Connect docs navigation is driven by `frontend/packages/shared-data/src/deploy.ts`, so new Connect pages need a deploy option entry to appear in cards/sidebar.
+  - The website build is the useful docs gate because it typechecks TypeScript code blocks before building Astro pages.
+  - Avoid running Prettier blindly on MDX docs with nested code examples; it can rewrite code fences and example indentation in surprising ways.
 ---
-## 2026-04-29 05:49:07 PDT - US-010
-- Implemented kitchen-sink SQLite real-world benchmark reporting for read-pool route and transition metrics, including routed reads, write fallbacks, mode transitions, reader opens, and reader closes in both console output and `summary.md`.
-- Tightened the static benchmark test so the runner and actor workload catalogs remain in sync and read-pool metric reporting stays visible.
-- Added a reusable examples agent note for kitchen-sink SQLite real-world benchmark catalog sync and summary reporting.
-- Files changed:
-  - `examples/CLAUDE.md`
-  - `examples/kitchen-sink/scripts/sqlite-realworld-bench.ts`
-  - `examples/kitchen-sink/tests/sqlite-realworld-bench.test.ts`
-  - `scripts/ralph/prd.json`
-  - `scripts/ralph/progress.txt`
-- Checks:
-  - `pnpm --dir examples/kitchen-sink test`
-  - `pnpm --dir examples/kitchen-sink exec tsx scripts/sqlite-realworld-bench.ts --help`
-  - `pnpm --dir examples/kitchen-sink exec biome check --formatter-enabled=false --assist-enabled=false scripts/sqlite-realworld-bench.ts tests/sqlite-realworld-bench.test.ts`
-  - `pnpm --dir examples/kitchen-sink run check-types` is the package-declared typecheck and currently prints `skipped - workflow history types broken`.
-  - Direct `tsc --noEmit` remains blocked by pre-existing kitchen-sink/server, Drizzle dependency, and workflow declaration errors outside this story.
+
+## 2026-05-01 23:32 PDT - US-017
+- Removed Node `Buffer` construction from shared actor runtime glue in `registry/native.ts`; shared KV, HTTP, websocket, state, queue, and callback payloads now use `RuntimeBytes`/`Uint8Array` helpers.
+- Kept NAPI `Buffer` conversion isolated to the NAPI adapter boundary and made callback error stack logging resilient when `Buffer` is unavailable.
+- Added wasm runtime coverage that invokes shared actor callbacks after clearing `globalThis.Buffer`.
+- Files changed: `rivetkit-typescript/packages/rivetkit/src/registry/native.ts`, `rivetkit-typescript/packages/rivetkit/src/common/utils.ts`, `rivetkit-typescript/packages/rivetkit/tests/wasm-runtime.test.ts`, `rivetkit-typescript/CLAUDE.md`, `scripts/ralph/prd.json`, `scripts/ralph/progress.txt`.
+- Checks: `pnpm --filter rivetkit exec biome check src/registry/native.ts src/common/utils.ts tests/wasm-runtime.test.ts` passed; `pnpm --filter rivetkit exec vitest run tests/wasm-runtime.test.ts` passed; `pnpm --filter rivetkit run check-types` passed.
 - **Learnings for future iterations:**
-  - `sqlite_read_pool_mode_transitions_total` is label-bearing, so benchmark metric parsing should sum all series for a metric family instead of taking the first sample.
-  - Scrape actor metrics once per workload and derive VFS plus read-pool snapshots from the same Prometheus text to keep reported counters comparable.
-  - The kitchen-sink package intentionally stubs `check-types`; use its static tests and a `tsx --help` smoke parse for benchmark-script-only changes unless the broader TypeScript config is repaired.
+  - Shared actor glue in `registry/native.ts` is used by both NAPI and wasm, so byte creation there should stay on `RuntimeBytes`/`Uint8Array` even when NAPI currently accepts Node `Buffer`.
+  - Tests can exercise wasm actor callback glue with a fake wasm context that implements `actorId()` and `runtimeState()`.
+  - Accessing `error.stack` can throw in Node source-map paths when `globalThis.Buffer` is unavailable, so stack logging should be best-effort.
 ---
-## 2026-04-29 06:03:27 PDT - US-011
-- Added lifecycle and fencing stress coverage for native SQLite reader pools, including shutdown close ordering, reader fence mismatch fail-closed behavior, generation-specific VFS names, raw manual transaction write-mode retention, and shared routing gates for inspector/user operations.
-- Fixed a manual transaction self-deadlock by routing work through the held writer while the manager is already in write mode.
-- Files changed:
-  - `AGENTS.md`
-  - `rivetkit-rust/packages/rivetkit-sqlite/src/connection_manager.rs`
-  - `rivetkit-rust/packages/rivetkit-sqlite/src/database.rs`
-  - `rivetkit-rust/packages/rivetkit-sqlite/src/vfs.rs`
-  - `scripts/ralph/prd.json`
-  - `scripts/ralph/progress.txt`
-- Checks:
-  - `cargo test -p rivetkit-sqlite native_database --lib`
-  - `cargo test -p rivetkit-sqlite connection_manager --lib`
-  - `cargo test -p rivetkit-sqlite actor_replacement_generation_uses_distinct_vfs_registration_name --lib`
-  - `cargo test -p rivetkit-sqlite --lib -- --test-threads=1`
-  - `cargo test -p rivetkit-sqlite`
-  - `cargo check -p rivetkit-sqlite`
+
+## 2026-05-01 23:39 PDT - US-018
+- Tightened `RuntimeSqlBindParam` into exact discriminated union variants and limited `RuntimeSqlExecuteResult.route` to `read`, `write`, or `writeFallback`.
+- Updated NAPI and wasm runtime adapters to normalize execute results before returning the shared runtime type, and tightened the local native database bind type so runtime forwarding remains type-safe.
+- Added runtime SQL boundary tests for null, int, float, text, blob, and route normalization, and strengthened native database tests for exact bind shapes and unsupported route rejection.
+- Files changed: `rivetkit-typescript/packages/rivetkit/src/registry/runtime.ts`, `rivetkit-typescript/packages/rivetkit/src/registry/napi-runtime.ts`, `rivetkit-typescript/packages/rivetkit/src/registry/wasm-runtime.ts`, `rivetkit-typescript/packages/rivetkit/src/registry/runtime.test.ts`, `rivetkit-typescript/packages/rivetkit/src/common/database/native-database.ts`, `rivetkit-typescript/packages/rivetkit/src/common/database/native-database.test.ts`, `rivetkit-typescript/CLAUDE.md`, `scripts/ralph/prd.json`, `scripts/ralph/progress.txt`.
+- Checks: `pnpm --filter rivetkit exec biome check src/registry/runtime.ts src/registry/napi-runtime.ts src/registry/wasm-runtime.ts src/registry/runtime.test.ts src/common/database/native-database.ts src/common/database/native-database.test.ts` passed; `pnpm --filter rivetkit run check-types` passed; `pnpm --filter rivetkit exec vitest run src/registry/runtime.test.ts src/common/database/native-database.test.ts tests/wasm-host-smoke.test.ts` passed; `pnpm --filter rivetkit exec vitest run tests/wasm-runtime.test.ts` passed as part of an adapter run. `tests/napi-runtime-integration.test.ts` failed outside this story with `actor.validation_error: Invalid connection params`; an earlier retry was also blocked by an orphaned local engine holding the RocksDB lock.
 - **Learnings for future iterations:**
-  - If `NativeConnectionManager` holds an idle writer for a raw transaction, `NativeDatabaseHandle::execute` must bypass reader classification and reuse that writer for later statements such as `COMMIT`.
-  - Fence-mismatch tests need to clear the VFS page caches after setup so the stale reader is forced to fetch through the engine and observe the replacement generation.
-  - Native VFS registration tests can affect later tests because SQLite's VFS list is process-global; drop the stale registration before the replacement registration during cleanup.
+  - Runtime SQL bind params should be switched by `kind` at adapter edges so impossible extra value fields are compile-time errors.
+  - Generated NAPI SQL execute results expose route as a loose string, so normalize to the shared runtime route union before returning from `NapiCoreRuntime`.
+  - The NAPI integration test can leave an orphaned local `rivet-engine` holding `/home/nathan/.rivetkit/var/engine/db/LOCK` when startup fails; clean that process before rerunning engine-backed tests.
 ---
-## 2026-04-29 06:05:43 PDT - US-012
-- Documented the SQLite read-mode/write-mode connection manager invariant in internal VFS docs, including exclusive write mode, no reader/write overlap, and the native routing policy boundary.
-- Moved the read-mode/write-mode manager tracker entry from recommended work into existing optimizations.
-- Preserved the reusable invariant in the root agent notes for future SQLite changes.
-- Files changed:
-  - `AGENTS.md`
-  - `docs-internal/engine/sqlite-vfs.md`
-  - `docs-internal/engine/SQLITE_OPTIMIZATIONS.md`
-  - `scripts/ralph/prd.json`
-  - `scripts/ralph/progress.txt`
-- Checks:
-  - `cargo check -p rivetkit-sqlite`
+
+## 2026-05-01 23:48 PDT - US-019
+- Generated one shared docs-shaped SQLite counter registry source for platform apps via `buildPlatformSqliteCounterRegistrySource(...)`.
+- Updated Cloudflare Workers, Deno, and Supabase Functions fixtures to write local `registry.ts` files that import public `rivetkit` and `@rivetkit/rivetkit-wasm` exports, then keep only platform bootstrapping in each app entrypoint.
+- Marked US-019 passing in `prd.json` and preserved the reusable helper pattern in the platform AGENTS/CLAUDE notes.
+- Files changed: `rivetkit-typescript/packages/rivetkit/tests/platforms/shared-platform-harness.ts`, `rivetkit-typescript/packages/rivetkit/tests/platforms/cloudflare-workers.test.ts`, `rivetkit-typescript/packages/rivetkit/tests/platforms/deno.test.ts`, `rivetkit-typescript/packages/rivetkit/tests/platforms/supabase-functions.test.ts`, `rivetkit-typescript/packages/rivetkit/tests/platforms/CLAUDE.md`, `rivetkit-typescript/packages/rivetkit/tests/platforms/AGENTS.md`, `scripts/ralph/prd.json`, `scripts/ralph/progress.txt`.
+- Checks: `pnpm --filter rivetkit exec biome check tests/platforms/shared-platform-harness.ts tests/platforms/cloudflare-workers.test.ts tests/platforms/deno.test.ts tests/platforms/supabase-functions.test.ts` passed; `pnpm --filter rivetkit run check-types` passed; `pnpm --filter rivetkit run test:platforms` passed.
 - **Learnings for future iterations:**
-  - Read-pool v1 intentionally avoids reader/writer overlap instead of pinning per-reader head txids or snapshots.
-  - Internal SQLite docs are the right home for cross-layer invariants; keep the optimization tracker limited to benchmark and performance status.
-  - Root `AGENTS.md` already has a SQLite Package section for short reusable constraints that should apply across future implementation work.
+  - Keep generated platform app registry code in a local app file so it can look like docs copy-paste code while still sharing one test utility source.
+  - Cloudflare uses the same registry source with a wasm module import; Deno and Supabase use the same source with `Deno.readFile(import.meta.resolve(...))`.
+  - The platform smoke suite can emit transient `actor_ready_timeout` logs during wake retries and still pass once the cold-start retry helper observes the new start request.
 ---
diff --git a/scripts/run/engine-rocksdb.sh b/scripts/run/engine-rocksdb.sh
index f619878ec1..31939b2077 100755
--- a/scripts/run/engine-rocksdb.sh
+++ b/scripts/run/engine-rocksdb.sh
@@ -9,4 +9,4 @@ cd "${REPO_ROOT}"
 RUST_BACKTRACE=full \
 RUST_LOG="${RUST_LOG:-"opentelemetry_sdk=off,opentelemetry-otlp=info,tower::buffer::worker=info,debug"}" \
 RUST_LOG_TARGET=1 \
-cargo run --bin rivet-engine -- start 2>&1 | tee -i /tmp/rivet-engine.log
+cargo run -p rivet-engine --bin rivet-engine -- start 2>&1 | tee -i /tmp/rivet-engine.log
diff --git a/turbo.json b/turbo.json
index a717be34f5..0c7101434d 100644
--- a/turbo.json
+++ b/turbo.json
@@ -13,7 +13,7 @@
 				"package.json"
 			],
 			"outputs": ["dist/**"],
-			"env": ["FAST_BUILD", "SKIP_NAPI_BUILD"]
+			"env": ["FAST_BUILD", "SKIP_NAPI_BUILD", "SKIP_WASM_BUILD"]
 		},
 		"build:ladle": {
 			"dependsOn": ["^build"],
diff --git a/website/CLAUDE.md b/website/CLAUDE.md
index 8982cba8c8..3997a5f1b0 100644
--- a/website/CLAUDE.md
+++ b/website/CLAUDE.md
@@ -41,6 +41,7 @@ Import from `@rivet-gg/icons`. The full Font Awesome Pro library is available. C
 
 - Type-check all TypeScript code blocks in `website/src/content/docs/**/*.mdx` before release, because any failing snippet fails the website build.
 - Document `onStateChange` as read-only against `c.state`; use `vars` for callback counters or derived runtime-only values.
+- Connect page cards and sidebar entries come from `frontend/packages/shared-data/src/deploy.ts`.
 
 ### Required for every TypeScript snippet
 
diff --git a/website/src/content/docs/actors/kv.mdx b/website/src/content/docs/actors/kv.mdx
index a06cd41961..30c1b94569 100644
--- a/website/src/content/docs/actors/kv.mdx
+++ b/website/src/content/docs/actors/kv.mdx
@@ -16,15 +16,15 @@ Keys and values default to `text`, so you can use strings without extra options.
 import { actor } from "rivetkit";
 
 const greetings = actor({
-  state: {},
-  actions: {
-    setGreeting: async (c, userId: string, message: string) => {
-      await c.kv.put(`greeting:${userId}`, message);
-    },
-    getGreeting: async (c, userId: string) => {
-      return await c.kv.get(`greeting:${userId}`);
-    }
-  }
+	state: {},
+	actions: {
+		setGreeting: async (c, userId: string, message: string) => {
+			await c.kv.put(`greeting:${userId}`, message);
+		},
+		getGreeting: async (c, userId: string) => {
+			return await c.kv.get(`greeting:${userId}`);
+		},
+	},
 });
 ```
 
@@ -36,18 +36,18 @@ You can store binary values by passing `Uint8Array` or `ArrayBuffer` directly. U
 import { actor } from "rivetkit";
 
 const assets = actor({
-  state: {},
-  actions: {
-    putAvatar: async (c, bytes: Uint8Array) => {
-      await c.kv.put("avatar", bytes);
-    },
-    getAvatar: async (c) => {
-      return await c.kv.get("avatar", { type: "binary" });
-    },
-    putSnapshot: async (c, data: ArrayBuffer) => {
-      await c.kv.put("snapshot", data);
-    }
-  }
+	state: {},
+	actions: {
+		putAvatar: async (c, bytes: Uint8Array) => {
+			await c.kv.put("avatar", bytes);
+		},
+		getAvatar: async (c) => {
+			return await c.kv.get("avatar", { type: "binary" });
+		},
+		putSnapshot: async (c, data: ArrayBuffer) => {
+			await c.kv.put("snapshot", data);
+		},
+	},
 });
 ```
 
@@ -57,16 +57,16 @@ TypeScript returns a concrete type based on the option you pass in:
 import { actor } from "rivetkit";
 
 const example = actor({
-  state: {},
-  actions: {
-    demo: async (c) => {
-      const textValue = await c.kv.get("greeting");
-      //    ^? string | null
-
-      const bytes = await c.kv.get("avatar", { type: "binary" });
-      //    ^? Uint8Array | null
-    }
-  }
+	state: {},
+	actions: {
+		demo: async (c) => {
+			const textValue = await c.kv.get("greeting");
+			//    ^? string | null
+
+			const bytes = await c.kv.get("avatar", { type: "binary" });
+			//    ^? Uint8Array | null
+		},
+	},
 });
 ```
 
@@ -80,16 +80,16 @@ When listing by prefix, you can control how keys are decoded with `keyType`. Ret
 import { actor } from "rivetkit";
 
 const example = actor({
-  state: {},
-  actions: {
-    listGreetings: async (c) => {
-      const results = await c.kv.list("greeting:", { keyType: "text" });
-
-      for (const [key, value] of results) {
-        console.log(key, value);
-      }
-    }
-  }
+	state: {},
+	actions: {
+		listGreetings: async (c) => {
+			const results = await c.kv.list("greeting:", { keyType: "text" });
+
+			for (const [key, value] of results) {
+				console.log(key, value);
+			}
+		},
+	},
 });
 ```
 
@@ -103,18 +103,26 @@ Use `listRange(start, end)` to read an arbitrary half-open range `[start, end)`.
 import { actor } from "rivetkit";
 
 const example = actor({
-  state: {},
-  actions: {
-    pruneAndScan: async (c) => {
-      const active = await c.kv.listRange("job:", "joc:", {
-        keyType: "text",
-      });
-
-      await c.kv.deleteRange("job:old:", "job:old;");
-
-      return active.map(([key, value]) => ({ key, value }));
-    }
-  }
+	state: {},
+	actions: {
+		pruneAndScan: async (c) => {
+			const encoder = new TextEncoder();
+			const active = await c.kv.listRange(
+				encoder.encode("job:"),
+				encoder.encode("joc:"),
+				{
+					keyType: "text",
+				},
+			);
+
+			await c.kv.deleteRange(
+				encoder.encode("job:old:"),
+				encoder.encode("job:old;"),
+			);
+
+			return active.map(([key, value]) => ({ key, value }));
+		},
+	},
 });
 ```
 
@@ -126,17 +134,17 @@ KV supports batch operations for efficiency. Defaults are still `text` for both
 import { actor } from "rivetkit";
 
 const example = actor({
-  state: {},
-  actions: {
-    batchOps: async (c) => {
-      await c.kv.putBatch([
-        ["alpha", "1"],
-        ["beta", "2"],
-      ]);
-
-      const values = await c.kv.getBatch(["alpha", "beta"]);
-    }
-  }
+	state: {},
+	actions: {
+		batchOps: async (c) => {
+			await c.kv.putBatch([
+				["alpha", "1"],
+				["beta", "2"],
+			]);
+
+			const values = await c.kv.getBatch(["alpha", "beta"]);
+		},
+	},
 });
 ```
 
diff --git a/website/src/content/docs/actors/quickstart/index.mdx b/website/src/content/docs/actors/quickstart/index.mdx
index 3909fd4fbd..30f88cf673 100644
--- a/website/src/content/docs/actors/quickstart/index.mdx
+++ b/website/src/content/docs/actors/quickstart/index.mdx
@@ -4,7 +4,13 @@ description: "Set up actors with Node.js, Bun, and web frameworks"
 skill: false
 ---
 
-import { faNodeJs, faReact, faNextjs } from "@rivet-gg/icons";
+import {
+	faCloudflare,
+	faFunction,
+	faNodeJs,
+	faReact,
+	faNextjs,
+} from "@rivet-gg/icons";
 
 <Note>
 **Using an AI coding assistant?** Add Rivet skills for enhanced development assistance:
@@ -14,13 +20,39 @@ npx skills add rivet-dev/skills
 </Note>
 
 <CardGroup cols={2}>
-<Card title="Node.js & Bun Quickstart" href="/docs/actors/quickstart/backend" icon={faNodeJs}>
-  Set up actors with Node.js, Bun, and web frameworks
-</Card>
-<Card title="React Quickstart" href="/docs/actors/quickstart/react" icon={faReact}>
-  Build real-time React applications with actors
-</Card>
-<Card title="Next.js Quickstart" href="/docs/actors/quickstart/next-js" icon={faNextjs}>
-  Build server-rendered Next.js experiences backed by actors
-</Card>
+	<Card
+		title="Node.js & Bun Quickstart"
+		href="/docs/actors/quickstart/backend"
+		icon={faNodeJs}
+	>
+		Set up actors with Node.js, Bun, and web frameworks
+	</Card>
+	<Card
+		title="React Quickstart"
+		href="/docs/actors/quickstart/react"
+		icon={faReact}
+	>
+		Build real-time React applications with actors
+	</Card>
+	<Card
+		title="Next.js Quickstart"
+		href="/docs/actors/quickstart/next-js"
+		icon={faNextjs}
+	>
+		Build server-rendered Next.js experiences backed by actors
+	</Card>
+	<Card
+		title="Cloudflare Workers"
+		href="/docs/connect/cloudflare"
+		icon={faCloudflare}
+	>
+		Run RivetKit on Cloudflare Workers with the WebAssembly runtime
+	</Card>
+	<Card
+		title="Supabase Functions"
+		href="/docs/connect/supabase"
+		icon={faFunction}
+	>
+		Run RivetKit on Supabase Edge Functions with the WebAssembly runtime
+	</Card>
 </CardGroup>
diff --git a/website/src/content/docs/connect/cloudflare.mdx b/website/src/content/docs/connect/cloudflare.mdx
new file mode 100644
index 0000000000..9512a82f94
--- /dev/null
+++ b/website/src/content/docs/connect/cloudflare.mdx
@@ -0,0 +1,157 @@
+---
+title: "Deploying to Cloudflare Workers"
+description: "Run RivetKit on Cloudflare Workers with the WebAssembly runtime."
+skill: true
+---
+
+Cloudflare Workers run RivetKit through the WebAssembly runtime. Use the public `@rivetkit/rivetkit-wasm` package, pass the bindings through `setup({ wasm })`, and use remote SQLite.
+
+## Steps
+
+<Steps>
+<Step title="Prerequisites">
+
+- [Cloudflare account](https://dash.cloudflare.com/)
+- [`wrangler`](https://developers.cloudflare.com/workers/wrangler/) configured for your account
+- A Rivet namespace from the [Rivet Dashboard](https://hub.rivet.dev/) or a self-hosted Rivet Engine
+
+</Step>
+<Step title="Install Packages">
+
+```sh
+npm install rivetkit @rivetkit/rivetkit-wasm
+npm install --save-dev wrangler
+```
+
+</Step>
+<Step title="Configure Wrangler">
+
+Set your Rivet connection values as Worker variables. The pool name must match the serverless runner configured in Rivet.
+
+```toml wrangler.toml
+name = "rivetkit-cloudflare"
+main = "src/index.ts"
+compatibility_date = "2025-04-01"
+compatibility_flags = ["nodejs_compat"]
+
+[vars]
+RIVET_ENDPOINT = "https://api.rivet.dev"
+RIVET_NAMESPACE = "your-namespace"
+RIVET_POOL = "cloudflare-workers"
+RIVET_TOKEN = "sk_..."
+RIVET_PUBLIC_ENDPOINT = "https://your-namespace:pk_...@api.rivet.dev"
+```
+
+</Step>
+<Step title="Create the Worker">
+
+This example uses raw SQL to keep the runtime setup visible. When `runtime: "wasm"` is used, unset SQLite defaults to remote SQLite, and `sqlite: "local"` is rejected.
+
+<CodeGroup workspace>
+```ts src/index.ts @nocheck
+import { actor, setup } from "rivetkit";
+import * as wasmBindings from "@rivetkit/rivetkit-wasm";
+import wasmModule from "@rivetkit/rivetkit-wasm/rivetkit_wasm_bg.wasm";
+
+interface Env {
+  RIVET_ENDPOINT: string;
+  RIVET_NAMESPACE: string;
+  RIVET_POOL: string;
+  RIVET_TOKEN: string;
+  RIVET_PUBLIC_ENDPOINT: string;
+}
+
+interface SqliteDatabase {
+  run(sql: string, params?: unknown[]): Promise<void>;
+  query(sql: string, params?: unknown[]): Promise<{ rows: unknown[][] }>;
+  writeMode<T>(callback: () => Promise<T>): Promise<T>;
+}
+
+const rawSqlDatabaseProvider = {
+  createClient: async () => ({
+    execute: async () => [],
+    close: async () => {},
+  }),
+  onMigrate: async () => {},
+};
+
+const counter = actor({
+  db: rawSqlDatabaseProvider,
+  actions: {
+    increment: async (ctx, amount = 1) => {
+      const db = ctx.sql as SqliteDatabase;
+      await db.writeMode(async () => {
+        await db.run(
+          "CREATE TABLE IF NOT EXISTS counters (id INTEGER PRIMARY KEY, count INTEGER NOT NULL)",
+        );
+        await db.run(
+          "INSERT INTO counters (id, count) VALUES (1, ?) ON CONFLICT(id) DO UPDATE SET count = count + excluded.count",
+          [amount],
+        );
+      });
+
+      const result = await db.query("SELECT count FROM counters WHERE id = 1");
+      return Number(result.rows[0]?.[0] ?? 0);
+    },
+  },
+});
+
+const use = { counter };
+let registry: { handler(request: Request): Promise<Response> } | undefined;
+
+function getRegistry(env: Env) {
+  registry ??= setup({
+    runtime: "wasm",
+    sqlite: "remote",
+    wasm: {
+      bindings: wasmBindings,
+      initInput: wasmModule,
+    },
+    use,
+    endpoint: env.RIVET_ENDPOINT,
+    namespace: env.RIVET_NAMESPACE,
+    token: env.RIVET_TOKEN,
+    envoy: {
+      poolName: env.RIVET_POOL,
+    },
+    serverless: {
+      publicEndpoint: env.RIVET_PUBLIC_ENDPOINT,
+    },
+  });
+
+  return registry;
+}
+
+export default {
+  async fetch(request: Request, env: Env): Promise<Response> {
+    return await getRegistry(env).handler(request);
+  },
+};
+```
+</CodeGroup>
+
+</Step>
+<Step title="Deploy">
+
+```sh
+npx wrangler deploy
+```
+
+After deploy, set the Worker URL with the `/api/rivet` path as the serverless runner URL in Rivet.
+
+</Step>
+</Steps>
+
+## Runtime Notes
+
+- Use `runtime: "wasm"` in `setup(...)` for Workers. You can also set `RIVETKIT_RUNTIME=wasm` in environments where the registry config does not set `runtime`.
+- Pass `wasm: { bindings, initInput }` explicitly from `@rivetkit/rivetkit-wasm`.
+- Use remote SQLite on Workers. Leaving SQLite unset with `runtime: "wasm"` selects remote SQLite automatically.
+- Keep `RIVET_PUBLIC_ENDPOINT` pointed at the client-facing Rivet endpoint. Register the Worker URL separately as the serverless runner URL.
+- Local Workers runtimes must support outbound WebSockets for the Rivet envoy connection.
+
+## Related
+
+- [Quickstart](/docs/actors/quickstart)
+- [Supabase Functions](/docs/connect/supabase)
+- [SQLite](/docs/actors/sqlite)
diff --git a/website/src/content/docs/connect/supabase.mdx b/website/src/content/docs/connect/supabase.mdx
index 64690ba3ee..27a53b1215 100644
--- a/website/src/content/docs/connect/supabase.mdx
+++ b/website/src/content/docs/connect/supabase.mdx
@@ -1,6 +1,144 @@
 ---
-title: "Supabase"
-description: "_Supabase is coming soon_"
+title: "Deploying to Supabase Functions"
+description: "Run RivetKit on Supabase Edge Functions with the WebAssembly runtime."
 skill: true
 ---
 
+Supabase Edge Functions run RivetKit through the WebAssembly runtime. Use the public `@rivetkit/rivetkit-wasm` package, load the wasm file with Deno, and use remote SQLite.
+
+## Steps
+
+<Steps>
+<Step title="Prerequisites">
+
+- [Supabase project](https://supabase.com/)
+- [Supabase CLI](https://supabase.com/docs/guides/cli) configured for your project
+- A Rivet namespace from the [Rivet Dashboard](https://hub.rivet.dev/) or a self-hosted Rivet Engine
+
+</Step>
+<Step title="Create the Function">
+
+```sh
+npx supabase functions new rivet
+```
+
+Add the packages used by the function:
+
+```sh
+npm install rivetkit @rivetkit/rivetkit-wasm
+```
+
+</Step>
+<Step title="Configure the Function">
+
+Supabase Functions run under Deno, so load the wasm bytes from the package export and pass them to `setup({ wasm })`.
+
+<CodeGroup workspace>
+```ts supabase/functions/rivet/index.ts @nocheck
+import { actor, setup } from "rivetkit";
+import * as wasmBindings from "@rivetkit/rivetkit-wasm";
+
+interface SqliteDatabase {
+  run(sql: string, params?: unknown[]): Promise<void>;
+  query(sql: string, params?: unknown[]): Promise<{ rows: unknown[][] }>;
+  writeMode<T>(callback: () => Promise<T>): Promise<T>;
+}
+
+const wasmModule = await Deno.readFile(
+  new URL(import.meta.resolve("@rivetkit/rivetkit-wasm/rivetkit_wasm_bg.wasm")),
+);
+
+const rawSqlDatabaseProvider = {
+  createClient: async () => ({
+    execute: async () => [],
+    close: async () => {},
+  }),
+  onMigrate: async () => {},
+};
+
+const counter = actor({
+  db: rawSqlDatabaseProvider,
+  actions: {
+    increment: async (ctx, amount = 1) => {
+      const db = ctx.sql as SqliteDatabase;
+      await db.writeMode(async () => {
+        await db.run(
+          "CREATE TABLE IF NOT EXISTS counters (id INTEGER PRIMARY KEY, count INTEGER NOT NULL)",
+        );
+        await db.run(
+          "INSERT INTO counters (id, count) VALUES (1, ?) ON CONFLICT(id) DO UPDATE SET count = count + excluded.count",
+          [amount],
+        );
+      });
+
+      const result = await db.query("SELECT count FROM counters WHERE id = 1");
+      return Number(result.rows[0]?.[0] ?? 0);
+    },
+  },
+});
+
+const registry = setup({
+  runtime: "wasm",
+  sqlite: "remote",
+  wasm: {
+    bindings: wasmBindings,
+    initInput: wasmModule,
+  },
+  use: { counter },
+  endpoint: Deno.env.get("RIVET_ENDPOINT"),
+  namespace: Deno.env.get("RIVET_NAMESPACE"),
+  token: Deno.env.get("RIVET_TOKEN"),
+  envoy: {
+    poolName: Deno.env.get("RIVET_POOL") ?? "supabase-functions",
+  },
+  serverless: {
+    basePath: "/rivet/api/rivet",
+    publicEndpoint: Deno.env.get("RIVET_PUBLIC_ENDPOINT"),
+  },
+});
+
+Deno.serve(async (request) => {
+  return await registry.handler(request);
+});
+```
+</CodeGroup>
+
+</Step>
+<Step title="Set Secrets">
+
+Set the Rivet connection values as Supabase secrets. The pool name must match the serverless runner configured in Rivet.
+
+```sh
+npx supabase secrets set \
+  RIVET_ENDPOINT=https://api.rivet.dev \
+  RIVET_PUBLIC_ENDPOINT=https://your-namespace:pk_...@api.rivet.dev \
+  RIVET_NAMESPACE=your-namespace \
+  RIVET_POOL=supabase-functions \
+  RIVET_TOKEN=sk_...
+```
+
+</Step>
+<Step title="Deploy">
+
+```sh
+npx supabase functions deploy rivet
+```
+
+After deploy, set the function URL with the `/api/rivet` path as the serverless runner URL in Rivet. For a function named `rivet`, this is usually `https://your-project.functions.supabase.co/functions/v1/rivet/api/rivet`.
+
+</Step>
+</Steps>
+
+## Runtime Notes
+
+- Use `runtime: "wasm"` in `setup(...)` for Supabase Functions. You can also set `RIVETKIT_RUNTIME=wasm` in environments where the registry config does not set `runtime`.
+- Pass `wasm: { bindings, initInput }` explicitly from `@rivetkit/rivetkit-wasm`.
+- Use remote SQLite on Supabase Functions. Leaving SQLite unset with `runtime: "wasm"` selects remote SQLite automatically.
+- Keep `RIVET_PUBLIC_ENDPOINT` pointed at the client-facing Rivet endpoint. Register the function URL separately as the serverless runner URL.
+- Supabase Functions run in Deno, so load the wasm module with Deno-friendly bytes, URL, response, or module input.
+
+## Related
+
+- [Quickstart](/docs/actors/quickstart)
+- [Cloudflare Workers](/docs/connect/cloudflare)
+- [SQLite](/docs/actors/sqlite)
diff --git a/website/src/content/docs/general/environment-variables.mdx b/website/src/content/docs/general/environment-variables.mdx
index ee2d6f651b..39a210b500 100644
--- a/website/src/content/docs/general/environment-variables.mdx
+++ b/website/src/content/docs/general/environment-variables.mdx
@@ -59,6 +59,7 @@ These variables configure how clients connect to your actors.
 
 | Environment Variable | Description |
 |---------------------|-------------|
+| `RIVETKIT_RUNTIME` | Runtime binding to use for RivetKit core: `auto`, `native`, or `wasm`. Defaults to `auto`. |
 | `RIVETKIT_STORAGE_PATH` | Overrides the default file-system storage path used by RivetKit when using the default driver. |
 
 ## Logging
diff --git a/website/src/content/docs/quickstart/index.mdx b/website/src/content/docs/quickstart/index.mdx
index d2b0492171..709d3f9e4b 100644
--- a/website/src/content/docs/quickstart/index.mdx
+++ b/website/src/content/docs/quickstart/index.mdx
@@ -4,18 +4,48 @@ description: "Get started with Rivet in minutes. Choose your preferred framework
 skill: false
 ---
 
-import { faNodeJs, faReact, faNextjs } from "@rivet-gg/icons";
-
-
+import {
+	faCloudflare,
+	faFunction,
+	faNodeJs,
+	faReact,
+	faNextjs,
+} from "@rivet-gg/icons";
 
 <CardGroup cols={2}>
-<Card title="Node.js & Bun Quickstart" href="/docs/actors/quickstart/backend" icon={faNodeJs}>
-  Set up actors with Node.js, Bun, and web frameworks
-</Card>
-<Card title="React Quickstart" href="/docs/actors/quickstart/react" icon={faReact}>
-  Build real-time React applications with actors
-</Card>
-<Card title="Next.js Quickstart" href="/docs/actors/quickstart/next-js" icon={faNextjs}>
-  Build server-rendered Next.js experiences backed by actors
-</Card>
+	<Card
+		title="Node.js & Bun Quickstart"
+		href="/docs/actors/quickstart/backend"
+		icon={faNodeJs}
+	>
+		Set up actors with Node.js, Bun, and web frameworks
+	</Card>
+	<Card
+		title="React Quickstart"
+		href="/docs/actors/quickstart/react"
+		icon={faReact}
+	>
+		Build real-time React applications with actors
+	</Card>
+	<Card
+		title="Next.js Quickstart"
+		href="/docs/actors/quickstart/next-js"
+		icon={faNextjs}
+	>
+		Build server-rendered Next.js experiences backed by actors
+	</Card>
+	<Card
+		title="Cloudflare Workers"
+		href="/docs/connect/cloudflare"
+		icon={faCloudflare}
+	>
+		Run RivetKit on Cloudflare Workers with the WebAssembly runtime
+	</Card>
+	<Card
+		title="Supabase Functions"
+		href="/docs/connect/supabase"
+		icon={faFunction}
+	>
+		Run RivetKit on Supabase Edge Functions with the WebAssembly runtime
+	</Card>
 </CardGroup>