@claxedo/workspace-relay 0.8.0 → 0.10.1

package/dist/server.d.ts

@@ -1,110 +1,11 @@
-import { Hono } from "hono";
-import type { RuntimeAccessVerifierClaims, TokenVerifier } from "@claxedo/workspace-relay-protocol";
-import { type HostTunnelTokenClaims, type RelayClaimPair, type RelayJwtAlgorithm, type RelayKey, type RelayRole, type RuntimeAccessTokenClaims } from "./auth";
+import { type RuntimeAccessVerifierClaims, type TokenVerifier } from "@claxedo/workspace-relay-protocol";
+import { type HostTunnelTokenClaims, type RelayJwtAlgorithm, type RelayKey, type RelayRole, type RuntimeAccessTokenClaims } from "./auth";
 import type { WorkspaceRelayDirectory } from "./directory";
-export type RelayHostPublicKey = {
-    publicKey: CryptoKey | Uint8Array;
-    kid: string;
-};
-export type WorkspaceRelayTarget = {
-    workspaceId: string;
-    hostId: string;
-    baseUrl: string;
-    upstreamHeaders?: Record<string, string>;
-} & RelayClaimPair;
-export type RuntimeAccessTokenActiveResult = {
-    active: true;
-} | {
-    active: false;
-    code: string;
-    reason: string;
-};
-/**
- * Both resolver clients — Bun (`main.ts`) and Worker (`worker.ts`) — read the
- * control plane's JSON with these two parsers rather than asserting a type onto
- * `Response.json()`. A half-built target used to travel all the way into
- * routing and fail there as a confusing upstream error; it is now rejected at
- * the one boundary that knows what the payload was supposed to be.
- */
-export declare function parseWorkspaceRelayTarget(input: unknown): WorkspaceRelayTarget | undefined;
-export declare function parseRuntimeAccessTokenActiveResult(input: unknown): RuntimeAccessTokenActiveResult | undefined;
-/**
- * `GET /internal/relay/host-generation?enrollmentId=` as the control plane
- * answers it: the enrollment's current serving generation, or 404 for an
- * enrollment it does not know (`undefined` here).
- */
-export type HostGenerationResult = {
-    enrollmentId: string;
-    generation: number;
-    revoked: boolean;
-};
-export declare function parseHostGenerationResult(input: unknown): HostGenerationResult | undefined;
-export type HostGenerationResolverLookupOptions = {
-    headers: Record<string, string>;
-    fetch?: (url: URL, init: RequestInit) => Promise<Response>;
-    /** Deadline per lookup; past it the lookup rejects, which the relay grades as unavailable. */
-    timeoutMs?: number;
-};
-/**
- * The HTTP lookup behind `resolveHostGeneration`, shared by the Bun process and
- * the Worker. Only the control plane's own "enrollment not found" 404 resolves
- * `undefined`; a bare 404 is a control plane without the route, and like every
- * other non-ok status, a malformed body, or a hit deadline it throws so the
- * relay refuses fenced tokens with a retryable 503 instead of grading them as
- * unknown enrollments.
- */
-export declare function createHostGenerationResolverLookup(url: string, options: HostGenerationResolverLookupOptions): HostGenerationLookup;
-/**
- * The fence between two host tunnels for one identity. An incumbent that
- * carries a generation is displaced only by a candidate at the same or a
- * higher generation — never by a lower one, and never by a token minted
- * without a generation. An incumbent without a generation is displaced by
- * any candidate, which is the pre-fence "newest wins" order.
- */
-export declare function hostTunnelIncumbentOutranks(incumbentGeneration: number | undefined, candidateGeneration: number | undefined): boolean;
-export type RevocationLookupArgs = {
-    jti: string;
-    workspaceId: string;
-    hostId: string;
-};
-export type RevocationLookup = (args: RevocationLookupArgs) => Promise<RuntimeAccessTokenActiveResult>;
-export type CachedRevocationOptions = {
-    /** TTL in milliseconds for cached revocation responses. Defaults to 10_000. */
-    ttlMs?: number;
-    /** Clock injection for tests. Defaults to `Date.now`. */
-    now?: () => number;
-};
-/**
- * `generation` is the value the caller holds (a token's, a socket's). The
- * cached client uses it to decide whether a cached answer may stand in for a
- * fresh one; an uncached lookup ignores it. Resolves `undefined` for an
- * unknown enrollment and THROWS when the control plane cannot be reached —
- * the throw is the "unavailable" signal every consumer grades separately.
- */
-export type HostGenerationLookupArgs = {
-    enrollmentId: string;
-    generation: number;
-};
-export type HostGenerationLookup = (args: HostGenerationLookupArgs) => Promise<HostGenerationResult | undefined>;
-export type CachedHostGenerationOptions = {
-    /** TTL in milliseconds for cached host-generation answers. Defaults to 10_000. */
-    ttlMs?: number;
-    /** Clock injection for tests. Defaults to `Date.now`. */
-    now?: () => number;
-};
-export type TargetLookupArgs = {
-    workspaceId: string;
-    hostId: string;
-};
-export type TargetLookup = (args: TargetLookupArgs) => Promise<WorkspaceRelayTarget | undefined>;
-export type CachedTargetOptions = {
-    /** TTL in milliseconds for positive target responses. Defaults to 5_000. */
-    ttlMs?: number;
-    /** Clock injection for tests. Defaults to `Date.now`. */
-    now?: () => number;
-};
+import { type WorkspaceRelayTarget } from "./relay-target";
+import type { HostGenerationLookup, RuntimeAccessTokenActiveResult } from "./resolver-clients";
+export declare function hostTunnelIncumbentOutranks(incumbentGeneration: number, candidateGeneration: number): boolean;
 export type WorkspaceRelayAuditEvent = {
-    action: "relay.request.accepted" | "relay.request.denied" | "relay.request.suppressed_summary" | "host_tunnel.connected" | "host_tunnel.disconnected" | "host_tunnel.denied";
+    action: "relay.request.accepted" | "relay.request.denied" | "relay.request.suppressed_summary";
     result: "allow" | "deny";
     reason?: string;
     actorId?: string;
@@ -125,10 +26,8 @@ export type WorkspaceRelayAuditEvent = {
 export type WorkspaceRelayAuthOptions = {
     runtimeAccessKey: RelayKey;
     /**
-     * Serving-generation fence for host tunnels. Unset on desktop and
-     * self-hosted relays, where nothing asks the control plane: tokens without
-     * a generation are admitted newest-wins, tokens with one are refused
-     * `host_generation_unverifiable`.
+     * Serving-generation fence for host tunnels. A relay composed without it
+     * refuses every host tunnel `host_generation_unverifiable`.
      */
     resolveHostGeneration?: HostGenerationLookup;
     /**
@@ -159,19 +58,11 @@ export type WorkspaceRelayAuthOptions = {
 export type WorkspaceRelayHostTokenOptions = {
     relayHostSigningKey: CryptoKey | Uint8Array;
     relayHostAlgorithm: RelayJwtAlgorithm;
-    /**
-     * Public keys to publish at `/.well-known/jwks.json`. The first entry is the
-     * "current" mint key; any further entries are "next" keys (for rolling
-     * rotation). Verifiers (workspace-runtime → workspace-host-service) consume
-     * this set via `jose.createRemoteJWKSet`. Omit to disable the endpoint
-     * (during rollout / for tests that do not need JWKS).
-     */
-    relayHostPublicKeys?: RelayHostPublicKey[];
     /**
      * `kid` to embed in the protected header of freshly minted RHTs. When
      * provided, verifiers can dispatch on `kid` to pick the matching key from
-     * the published JWKS. Should match the `kid` of the first entry in
-     * `relayHostPublicKeys` so JWKS and mint agree by construction.
+     * the published JWKS, so it must be the `kid` of the current key the Worker
+     * publishes at `/.well-known/jwks.json`.
      */
     relayHostMintKid?: string;
     /**
@@ -187,25 +78,15 @@ export type WorkspaceRelayRoutingOptions = {
     fetch?: typeof fetch;
     forwardTimeoutMs?: number;
     directory?: WorkspaceRelayDirectory;
-    allowedOrigins?: string[];
-};
-export type WorkspaceRelayDrainOptions = {
-    /**
-     * When this returns true the relay reports unhealthy via `/health` and
-     * fast-paths every workspace request to a 503 (`relay_draining`) before
-     * doing any auth or upstream work. Wired by `createWorkspaceRelayBun` to
-     * the drain controller it exposes.
-     */
-    isDraining?: () => boolean;
 };
 export type WorkspaceRelayTelemetryOptions = {
     audit?: (event: WorkspaceRelayAuditEvent) => void | Promise<void>;
     /**
      * Probability (0.0 – 1.0) at which `relay.request.accepted` audit
-     * events are emitted to the user `audit` callback. Denies and tunnel
-     * lifecycle events are never sampled. When unset, defaults to 1.0
-     * (emit every accept). Suppressed accepts are aggregated into a periodic
-     * `relay.request.suppressed_summary` event (see `auditFlushIntervalMs`).
+     * events are emitted to the user `audit` callback. Denies are never
+     * sampled. When unset, defaults to 1.0 (emit every accept). Suppressed
+     * accepts are aggregated into a periodic `relay.request.suppressed_summary`
+     * event (see `auditFlushIntervalMs`).
      */
     auditAcceptSampleRate?: number;
     /**
@@ -216,74 +97,12 @@ export type WorkspaceRelayTelemetryOptions = {
      */
     auditFlushIntervalMs?: number;
     /**
-     * Random source for the sampler. Defaults to `Math.random`. Override
-     * for deterministic tests.
+     * Random source for audit and trace sampling. Defaults to `Math.random`.
+     * Override for deterministic tests.
      */
     random?: () => number;
 };
-export type WorkspaceRelayMetricsOptions = {
-    /**
-     * Bearer token required to access `GET /metrics` from non-loopback
-     * remotes. When unset, the endpoint allows loopback callers only (using
-     * `metricsRemoteAddress` to identify the caller). When set, every request
-     * must present `Authorization: Bearer <metricsToken>` regardless of origin.
-     * Wired from `CLAXEDO_RELAY_METRICS_TOKEN` in main.ts.
-     */
-    metricsToken?: string;
-    /**
-     * Returns the remote IP of the inbound `/metrics` request (used to
-     * gate access to the loopback when `metricsToken` is unset). When this is
-     * also unset, `/metrics` fails closed. The Bun adapter wires this resolver
-     * through `Bun.Server.requestIP`; other callers should set either this or
-     * `metricsToken`.
-     */
-    metricsRemoteAddress?: (request: Request) => string | undefined;
-    /**
-     * Optional providers used to assemble the `/metrics` response body. The
-     * fragmentation/slow-consumer counters live in the bun adapter's per-handler
-     * telemetry, and the in-flight pending count lives on the drain controller.
-     * `createWorkspaceRelayBun` wires these to make ops counters visible on
-     * `/metrics` without giving `server.ts` a hard dependency on bun-only state.
-     */
-    metricsSources?: WorkspaceRelayMetricsSources;
-};
-export type WorkspaceRelayOptions = WorkspaceRelayAuthOptions & WorkspaceRelayHostTokenOptions & WorkspaceRelayRoutingOptions & WorkspaceRelayDrainOptions & WorkspaceRelayTelemetryOptions & WorkspaceRelayMetricsOptions;
-export type WorkspaceRelayMetricsSources = {
-    fragmentation?: () => {
-        fragmentsBuffered: number;
-        oversizedClosed: number;
-    };
-    slowConsumer?: () => {
-        overflowEvents: number;
-        timerFired: number;
-        droppedRequests: number;
-    };
-    drainPending?: () => number;
-};
-/**
- * Shape of the JSON body returned by `GET /metrics`. Exported so the
- * bun adapter and ops dashboards can type-narrow against it.
- */
-export type WorkspaceRelayMetrics = {
-    fragmentation: {
-        fragmentsBuffered: number;
-        oversizedClosed: number;
-    };
-    slowConsumer: {
-        overflowEvents: number;
-        timerFired: number;
-        droppedRequests: number;
-    };
-    directory: {
-        activeHostCount: number;
-    };
-    audit: {
-        suppressedAccepts: number;
-    };
-    drain?: {
-        pendingCount: number;
-    };
-};
+export type WorkspaceRelayOptions = WorkspaceRelayAuthOptions & WorkspaceRelayHostTokenOptions & WorkspaceRelayRoutingOptions & WorkspaceRelayTelemetryOptions;
 export type AuthorizedWorkspaceRelayRequest = {
     claims: RuntimeAccessTokenClaims;
     target: WorkspaceRelayTarget;
@@ -293,29 +112,12 @@ export type AuthorizedWorkspaceRelayRequest = {
 export type WorkspaceRelayAuthorizeTrace = {
     span<T>(name: string, run: () => Promise<T>): Promise<T>;
 };
-export type WorkspaceRelayTracePhase = {
-    name: string;
-    ms: number;
-};
-export type WorkspaceRelayTrace = WorkspaceRelayAuthorizeTrace & {
-    phases: WorkspaceRelayTracePhase[];
-};
-/**
- * Wraps a revocation lookup with a small in-memory cache keyed by `jti`.
- * Both positive and negative results are cached for the full TTL; revocation
- * lag is bounded by the same TTL by design. Concurrent misses share one lookup.
- */
-export declare function createCachedRevocationClient(inner: RevocationLookup, options?: CachedRevocationOptions): RevocationLookup;
+export declare const RUNTIME_ACCESS_TOKEN_ACTIVE_CHECK_INTERVAL_MS_DEFAULT = 30000;
 /**
- * Caches host-generation answers by enrollment id with the fence's own rules:
- * a cached answer stands only while it is at least the caller's generation
- * (equal admits; higher is a refusal that needs no fresh read), and a caller
- * holding a HIGHER generation than the cache — or than the answer an in-flight
- * lookup settles on — forces a refresh so a fresh `acquire` is never refused
- * on a stale answer. Unknown enrollments and failures are not cached;
- * concurrent misses share one lookup.
+ * `retryable: false` means the control plane refused this generation, so the
+ * host must not simply reconnect with it; `retryable: true` means the control
+ * plane could not be asked, and a reconnect is the recovery.
  */
-export declare function createCachedHostGenerationClient(inner: HostGenerationLookup, options?: CachedHostGenerationOptions): HostGenerationLookup;
 export type HostTunnelGenerationDecision = {
     ok: true;
 } | {
@@ -329,36 +131,16 @@ export type HostTunnelGenerationDecision = {
     code: "host_generation_lookup_unavailable";
     reason: string;
 };
-/**
- * The one admission/re-check verdict both relay adapters apply to a host
- * tunnel, on connect and on every registration update. A token without a
- * generation is always `ok` — that is the pre-fence behaviour desktop and
- * self-hosted relays keep. A token WITH a generation asserts a fence, so a
- * relay composed without a resolver refuses it rather than admit what it
- * cannot verify; that refusal is not retryable because the resolver is a
- * property of the composition, not of the moment. `retryable` otherwise
- * separates "the control plane said no" (the host must not simply reconnect)
- * from "the control plane could not be asked" (it should).
- */
 export declare function checkHostTunnelGeneration(lookup: HostGenerationLookup | undefined, claims: Pick<HostTunnelTokenClaims, "enrollment_id" | "generation">): Promise<HostTunnelGenerationDecision>;
-/**
- * Caches positive workspace target lookups by workspace+host. Missing targets
- * are only coalesced while in flight, not retained, so cold-start polling can
- * see readiness as soon as the control plane records it.
- */
-export declare function createCachedTargetClient(inner: TargetLookup, options?: CachedTargetOptions): TargetLookup;
 export type WorkspaceRelayForwardHeadersOptions = {
     /**
-     * When true, also strip the `Cookie` request header. User-hosted workspaces
-     * run on the user's laptop where the host process may share a cookie jar
-     * with the browser (e.g. localhost dev tooling); passing through cookies
-     * verbatim risks leaking sensitive session data to the host. Cloud-vm
-     * workspaces sit behind a dedicated network boundary where session cookies
-     * may legitimately be needed (e.g. workspace dashboards), so the default
-     * is to not strip cookies.
+     * When true, also strip the `Cookie` request header. A host tunnel ends on a
+     * machine somebody uses, whose cookie jar the browser may share (localhost
+     * dev tooling); passing cookies verbatim risks leaking session data to it. A
+     * cloud-vm sits behind a dedicated network boundary where a session cookie
+     * may legitimately be needed, so the default is to not strip cookies.
      */
-    userHosted?: boolean;
-    upstreamHeaders?: Record<string, string>;
+    hostTunnel?: boolean;
 };
 export type WorkspaceRelayForwardRequestInitOptions = WorkspaceRelayForwardHeadersOptions & {
     signal?: AbortSignal;
@@ -366,31 +148,6 @@ export type WorkspaceRelayForwardRequestInitOptions = WorkspaceRelayForwardHeade
 export declare function workspaceRelayTargetUrl(target: WorkspaceRelayTarget, path: string, search: string): URL;
 export declare function workspaceRelayForwardHeaders(input: Headers, relayHostToken: string, workspaceId: string, options?: WorkspaceRelayForwardHeadersOptions): Headers;
 export declare function workspaceRelayForwardRequestInit(request: Request, relayHostToken: string, workspaceId: string, options?: WorkspaceRelayForwardRequestInitOptions): RequestInit;
-/**
- * Dispose the sampler's periodic flush timer for a given options object.
- * Tests call this in cleanup so the bun process can exit.
- */
-export declare function disposeAuditSampler(options: WorkspaceRelayOptions): void;
-export declare function createWorkspaceRelayTrace(): WorkspaceRelayTrace;
-export declare function workspaceRelayServerTiming(trace: WorkspaceRelayTrace): string;
-export declare function workspaceRelayTimingResponse(response: Response, trace: WorkspaceRelayTrace): Response;
-/**
- * Request headers a browser may send to the relay, for every adapter.
- *
- * ONE list, because there were three identical copies — `server.ts`,
- * `cloudflare.ts` and `bun.ts` — and three copies of a list means the next
- * header is added to two of them. A header missing from the copy that serves a
- * given deployment does not degrade anything gracefully: the browser refuses to
- * send the request at all, and the failure surfaces somewhere else entirely.
- * The control plane's equivalent list is `BROWSER_ALLOWED_REQUEST_HEADERS` in
- * `claxedo-server-core`; a header the app sends to BOTH must be in both.
- *
- * `Traceparent`/`Tracestate` are W3C Trace Context, carried from the browser
- * through this relay to the laptop.
- */
-export declare const RELAY_ALLOWED_REQUEST_HEADER_LIST: readonly ["Accept", "Authorization", "Content-Type", "Last-Event-ID", "Traceparent", "Tracestate", "X-Fetch-Bypass-Throttle", "X-Daytona-Skip-Preview-Warning", "X-Workspace-Id", "X-OpenCode-Directory", "X-Claxedo-Runner", "X-Claxedo-Model", "X-Claxedo-Draft-Id", "X-Claxedo-Binary"];
-/** The same list as a header value, for the adapters that write it directly. */
-export declare const RELAY_ALLOWED_REQUEST_HEADERS: string;
 export declare function authorizeWorkspaceRelayRequest(options: WorkspaceRelayOptions, request: Request, workspaceId: string, trace?: WorkspaceRelayAuthorizeTrace): Promise<{
     ok: true;
     request: AuthorizedWorkspaceRelayRequest;
@@ -399,19 +156,3 @@ export declare function authorizeWorkspaceRelayRequest(options: WorkspaceRelayOp
     response: Response;
     code: string;
 }>;
-export declare function forwardWorkspaceRelayRequest(request: Request, target: WorkspaceRelayTarget, relayHostToken: string, path: string, requestFetch: typeof fetch, timeoutMs: number, trace?: WorkspaceRelayAuthorizeTrace, originAllowed?: (origin: string) => boolean): Promise<Response>;
-export type WorkspaceRelayApp = Hono & {
-    /**
-     * Clear the sampler's periodic flush timer. Tests must call this so
-     * `setInterval` doesn't keep the process alive after the test exits.
-     */
-    disposeAuditSampler(): void;
-};
-/**
- * Read the suppressed-accept counter for a given options object. Surfaced
- * for the `/metrics` route handler. Returns 0 if no sampler state has been
- * created yet (no requests have been audit-sampled), which is the same value
- * an external observer would see.
- */
-export declare function getAuditSuppressedCount(options: WorkspaceRelayOptions): number;
-export declare function createWorkspaceRelay(options: WorkspaceRelayOptions): WorkspaceRelayApp;

package/dist/session-host-forwarding.d.ts

@@ -0,0 +1,22 @@
+import type { RelayBacking } from "./auth";
+import { SESSION_HOST_LOCATION_HINT } from "./relay-location";
+import { type AuthorizedWorkspaceRelayRequest } from "./server";
+/** The `SESSION_HOST` binding: one Durable Object per top-level session, named by that session's id. */
+export type SessionHostNamespace = {
+    getByName: (name: string, options?: {
+        locationHint?: typeof SESSION_HOST_LOCATION_HINT;
+    }) => {
+        fetch: (input: string, init?: RequestInit) => Promise<Response>;
+    };
+};
+export declare function isSessionHostTarget(target: {
+    backing: RelayBacking;
+}): boolean;
+export declare function isSessionHostNamespace(value: unknown): value is SessionHostNamespace;
+/**
+ * Forwards one HTTP request to the session's Durable Object with the Relay
+ * Host Token the authorization minted. The browser's cookies never reach it,
+ * as they never reach a host tunnel, and the response body streams through
+ * untouched so a session's event stream stays open.
+ */
+export declare function forwardSessionHostHttp(namespace: SessionHostNamespace | undefined, request: Request, authorized: AuthorizedWorkspaceRelayRequest): Promise<Response>;

package/dist/test-support/unfenced-host-token.d.ts

@@ -0,0 +1,6 @@
+import { type mintHostTunnelToken } from "../auth";
+export declare function signUnfencedHostTunnelToken(input: {
+    subject: string;
+    hostId: string;
+    workspaceIds: string[];
+}, key: Parameters<typeof mintHostTunnelToken>[1]): Promise<string>;

package/dist/worker.d.ts

@@ -1,6 +1,6 @@
 import { type WorkspaceRelayDurableObjectNamespace, type WorkspaceRelayDurableObjectRoomOptions, type WorkspaceRelayDurableObjectSocket } from "./cloudflare";
-import type { RuntimeAccessTokenActiveResult, WorkspaceRelayTarget } from "./server";
-import { type HostGenerationLookup } from "./server";
+import { type WorkspaceRelayTarget } from "./relay-target";
+import { type HostGenerationLookup, type RuntimeAccessTokenActiveResult } from "./resolver-clients";
 type WorkspaceRelayWorkerBindings = {
     WORKSPACE_RELAY_ROOM?: WorkspaceRelayDurableObjectNamespace;
     CLAXEDO_RELAY_RESOLVER_URL?: string;
@@ -31,7 +31,7 @@ type WorkspaceRelayWorkerBindings = {
 };
 export type WorkspaceRelayWorkerEnv = Record<string, unknown> & WorkspaceRelayWorkerBindings;
 type ResolverClient = {
-    target(workspaceId: string, hostId: string): Promise<WorkspaceRelayTarget | undefined>;
+    target(workspaceId: string, hostId: string, routingId?: string): Promise<WorkspaceRelayTarget | undefined>;
     revocation(args: {
         jti: string;
         workspaceId: string;

package/dist/workerd-fixture/compatibility.d.ts

@@ -0,0 +1,2 @@
+/** The relay's deployed `compatibility_date`, so a real-workerd test boots the relay as it ships. */
+export declare function relayCompatibilityDate(config?: string): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "type": "module",
-  "description": "Relay/tunnel server that routes authenticated traffic to workspace runtimes: JWT workspace tokens, header-stripping trust boundary, Bun and Cloudflare adapters",
+  "description": "Relay/tunnel that routes authenticated traffic to workspace runtimes on Cloudflare: JWT workspace tokens and a header-stripping trust boundary",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -22,18 +22,8 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.mjs",
       "default": "./dist/index.mjs"
-    },
-    "./bun": {
-      "development": "./src/bun.ts",
-      "bun": "./src/bun.ts",
-      "types": "./dist/bun.d.ts",
-      "import": "./dist/bun.mjs",
-      "default": "./dist/bun.mjs"
     }
   },
-  "bin": {
-    "workspace-relay": "dist/main.mjs"
-  },
   "files": [
     "README.md",
     "LICENSE",
@@ -43,35 +33,26 @@
     "access": "public"
   },
   "name": "@claxedo/workspace-relay",
-  "version": "0.8.0",
+  "version": "0.10.1",
   "scripts": {
-    "start": "bun run src/main.ts",
-    "dev": "bun run --hot src/main.ts",
     "build": "tsx scripts/build.ts",
     "prepublishOnly": "npm run build",
     "typecheck": "tsc --noEmit -p tsconfig.json",
-    "typecheck:bench": "tsc --noEmit -p bench/tsconfig.json",
-    "test": "mkdir -p .artifacts/unit && node ../../scripts/test-deadline.mjs bun test src bench --path-ignore-patterns='**/relay-workerd-*' --path-ignore-patterns='**/bun.test.ts' --timeout 30000 --reporter=junit --reporter-outfile=.artifacts/unit/junit.xml && node ../../scripts/test-deadline.mjs bun test src/bun.test.ts --timeout 120000 --reporter=junit --reporter-outfile=.artifacts/unit/junit-bun-adapter.xml && node ../../scripts/test-deadline.mjs bun test src/relay-workerd-backpressure.test.ts src/relay-workerd-binary.test.ts --timeout 240000 --reporter=junit --reporter-outfile=.artifacts/unit/junit-workerd.xml",
-    "bench:gate": "bun bench/local-dry-run.ts",
-    "bench:gate:cf": "bun bench/cf-dev-smoke.ts"
+    "test": "mkdir -p .artifacts/unit && node ../../script/test-deadline.mjs bun test src scripts --path-ignore-patterns='**/relay-workerd-*' --timeout 30000 --reporter=junit --reporter-outfile=.artifacts/unit/junit.xml && node ../../script/test-deadline.mjs bun test src/relay-workerd-backpressure.test.ts src/relay-workerd-binary.test.ts src/relay-workerd-close.test.ts src/relay-workerd-session-host.test.ts --timeout 240000 --reporter=junit --reporter-outfile=.artifacts/unit/junit-workerd.xml"
   },
   "dependencies": {
-    "@claxedo/helpers": "0.1.0",
-    "@claxedo/workspace-relay-protocol": "0.8.0",
-    "hono": "4.10.7",
-    "jose": "6.0.11",
-    "posthog-node": "4.18.0"
+    "@claxedo/helpers": "0.2.1",
+    "@claxedo/workspace-relay-protocol": "0.10.1",
+    "jose": "6.0.11"
   },
   "devDependencies": {
-    "@claxedo/sandbox-manager": "0.9.0",
-    "@daytona/sdk": "0.192.0",
     "@tsconfig/node-lts": "22.0.4",
     "@types/bun": "1.3.13",
     "esbuild": "0.25.12",
-    "miniflare": "4.20260722.0",
+    "miniflare": "4.20260730.0",
     "tsx": "4.22.3",
     "typescript": "catalog:",
-    "wrangler": "4.114.0",
+    "wrangler": "4.116.0",
     "@cloudflare/workers-types": "catalog:"
   }
 }