Lets continue to work on the @packages/sessions/ project, where we have been building cloudflares capnweb transport onto the remote session api. We have created the connection between the opencode cli and server for syncing, now I want to add capnweb to the web code created by hono on the cloudflare worker.
We have good documentation with hono and cloudflare, so get up to speed and we will see what happens
Called the list tool with the following input: {"path":"/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/sessions/"}
/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/sessions/
examples/
storage-usage.ts
script/
backfill-index.ts
clean-malformed.ts
fix-malformed.ts
src/
views/
layout.tsx
not-found.tsx
session-detail.tsx
session-list.tsx
api.test.ts
broadcast.ts
durable-object.ts
index.test.ts
index.tsx
preload.ts
rpc-contract.ts
rpc.ts
storage.test.ts
storage.ts
test-utils.ts
types.ts
.gitignore
AGENTS.md
README.md
STORAGE_ADAPTER.md
bunfig.toml
package.json
tsconfig.json
wrangler.jsonc
All 5 tools executed successfully.
Keep using the batch tool for optimal performance in your next response!<file>
00001| # packages/sessions
00002|
00003| Cloudflare Worker that stores and serves shared OpenCode agent sessions. Provides a JSON API for the CLI and server-rendered HTML views for browsers.
00004|
00005| ## Build / Test / Deploy
00006|
00007| ```bash
00008| # Run all tests (40 tests across 3 files)
00009| bun test --preload ./src/preload.ts src/**/*.test.ts
00010|
00011| # Run specific test suites
00012| bun test --preload ./src/preload.ts src/api.test.ts
00013| bun test --preload ./src/preload.ts src/storage.test.ts
00014| bun test --preload ./src/preload.ts src/index.test.ts
00015|
00016| # Typecheck
00017| bun tsc --noEmit
00018|
00019| # Deploy (requires CLOUDFLARE_API_TOKEN and wrangler secret for SESSIONS_SHARED_SECRET)
00020| CLOUDFLARE_API_TOKEN=... bunx wrangler deploy
00021|
00022| # Local dev
00023| bunx wrangler dev
00024| ```
00025|
00026| The `--preload ./src/preload.ts` flag is required because bun:test needs a mock for the `cloudflare:workers` module (used by the Durable Object import).
00027|
00028| ## Architecture
00029|
00030| ```
00031| CLI (packages/opencode) Browser
00032| | |
00033| | POST /api/share | GET /sessions (HTML list)
00034| | POST /api/share/:id/sync | GET /share/:id (HTML detail)
00035| | DELETE /api/share/:id | GET /ws/:id (WebSocket)
00036| | |
00037| +----------> Hono app (src/index.tsx) <----+
00038| | |
00039| v v
00040| R2 Bucket Durable Object
00041| (storage) (SessionBroadcast)
00042| ```
00043|
00044| **Hono** handles all HTTP routing. **R2** stores session data. A **Durable Object** (`SessionBroadcast`) manages WebSocket connections for live updates -- when the CLI syncs new data, the DO broadcasts it to connected brows...<file>
00001| import { Hono } from "hono"
00002| import { cors } from "hono/cors"
00003| import { newWorkersRpcResponse } from "capnweb"
00004| import { zValidator } from "@hono/zod-validator"
00005| import { z } from "zod"
00006| import { v5 as uuidv5 } from "uuid"
00007| import type { SyncInfo, ShareCredentials, AgentSession, SessionIndex } from "./types.ts"
00008| import { createStorageAdapter, type StorageAdapter } from "./storage.ts"
00009| import SessionList from "./views/session-list.tsx"
00010| import SessionDetail from "./views/session-detail.tsx"
00011| import NotFound from "./views/not-found.tsx"
00012| import { ShareRpcImpl } from "./rpc.ts"
00013|
00014| import type { SessionBroadcast as SessionBroadcastType } from "./broadcast.ts"
00015|
00016| // Re-export Durable Object class (required by wrangler)
00017| export { SessionBroadcast } from "./broadcast.ts"
00018|
00019| /**
00020| * Environment bindings for Cloudflare Worker
00021| */
00022| type Env = {
00023| SESSIONS_STORE: R2Bucket
00024| SESSIONS_SHARED_SECRET: string
00025| SESSIONS_RPC_SHARED_KEY?: string
00026| API_DOMAIN: string
00027| SESSIONS_BROADCAST: DurableObjectNamespace<SessionBroadcastType>
00028| }
00029|
00030| function isAuthorizedRpcRequest(c: { req: { header: (name: string) => string | undefined }; env: Env }) {
00031| const configured = c.env.SESSIONS_RPC_SHARED_KEY
00032| if (!configured) return true
00033| const received = c.req.header("x-opencode-share-key")
00034| return received === configured
00035| }
00036|
00037| /**
00038| * Main Hono application
00039| */
00040| const app = new Hono<{ Bindings: Env }>()
00041|
00042| // Enable CORS for API routes only (not for WebSocket or HTML routes)
00043| app.use("/api/*", cors())
00044|
00045| app.all("/rpc/share", async (c) => {
00046| if (!isAuthorizedRpcRequest(c)) {
00047| return c.json({ error: "Unauthorized" }, 401)
00048| }
00049| return newWorkersRpcResponse(c.req.raw, new ShareRpcImp...<file>
00001| import { RpcTarget } from "capnweb"
00002| import { v5 as uuidv5 } from "uuid"
00003| import type { SessionBroadcast as SessionBroadcastType } from "./broadcast.ts"
00004| import type { ProbeCallback, ProbeValueInput, ProbeValueOutput } from "./rpc-contract.ts"
00005| import { createStorageAdapter, type StorageAdapter } from "./storage.ts"
00006| import type { AgentSession, SessionIndex, SyncData, SyncInfo } from "./types.ts"
00007|
00008| type Env = {
00009| SESSIONS_STORE: R2Bucket
00010| SESSIONS_SHARED_SECRET: string
00011| API_DOMAIN: string
00012| SESSIONS_BROADCAST: DurableObjectNamespace<SessionBroadcastType>
00013| }
00014|
00015| export class ShareRpcImpl extends RpcTarget {
00016| constructor(private env: Env) {
00017| super()
00018| }
00019|
00020| async createShare(sessionID: string): Promise<SyncInfo> {
00021| const { sessions, index } = this.storage()
00022| const shareID = sessionID.slice(-8)
00023| const secret = uuidv5(sessionID, this.env.SESSIONS_SHARED_SECRET)
00024| const now = Date.now()
00025| const info: SyncInfo = {
00026| id: shareID,
00027| secret,
00028| url: `${this.env.API_DOMAIN}/api/share/${shareID}`,
00029| }
00030|
00031| const initial: AgentSession = {
00032| session: {
00033| id: sessionID,
00034| slug: sessionID,
00035| projectID: "",
00036| directory: "",
00037| title: "",
00038| version: "1",
00039| time: {
00040| created: now,
00041| updated: now,
00042| },
00043| },
00044| messages: [],
00045| parts: [],
00046| diffs: [],
00047| models: [],
00048| metadata: {
00049| createdAt: now,
00050| lastUpdated: now,
00051| syncCount: 0,
00052| secret,
00053| sessionID,
00054| },
00055| }
00056|
00057| const initialIndex: SessionIndex = {
00058| id: shareID,
00059| s...<file>
00001| import type { RpcTarget } from "capnweb"
00002| import type * as SDK from "@opencode-ai/sdk/v2"
00003|
00004| export type SyncData =
00005| | {
00006| type: "session"
00007| data: SDK.Session
00008| }
00009| | {
00010| type: "message"
00011| data: SDK.Message
00012| }
00013| | {
00014| type: "part"
00015| data: SDK.Part
00016| }
00017| | {
00018| type: "session_diff"
00019| data: SDK.FileDiff[]
00020| }
00021| | {
00022| type: "model"
00023| data: SDK.Model[]
00024| }
00025|
00026| export type SyncInfo = {
00027| id: string
00028| url: string
00029| secret: string
00030| }
00031|
00032| export type ProbeValueInput = { when: Date; bytes: Uint8Array; nested: { x: number } }
00033| export type ProbeValueOutput = {
00034| when: string
00035| bytes: number[]
00036| size: number
00037| nested: { x: number }
00038| }
00039| export type ProbeCallback = (msg: string) => string | Promise<string>
00040|
00041| export interface ShareRpc extends RpcTarget {
00042| createShare: (sessionID: string) => Promise<SyncInfo>
00043| syncShare: (shareID: string, secret: string, data: SyncData[]) => Promise<{ success: boolean; syncCount: number }>
00044| probeValue: (input: ProbeValueInput) => ProbeValueOutput
00045| probeCallback: (cb: ProbeCallback) => Promise<string>
00046| }
00047|
(End of file - total 47 lines)
</file><file>
00001| /**
00002| * SDK Types for OpenCode Agent Sessions
00003| * Import core types from @opencode-ai/sdk/v2
00004| */
00005| import type { Session, Message, Part, FileDiff, Model } from "@opencode-ai/sdk/v2"
00006|
00007| // Re-export SDK types for convenience
00008| export type { Session, Message, Part, FileDiff, Model }
00009|
00010| /**
00011| * Sync data discriminated union type
00012| * Represents the different types of data that can be synchronized
00013| */
00014| export type SyncData =
00015| | { type: "session"; data: Session }
00016| | { type: "message"; data: Message }
00017| | { type: "part"; data: Part }
00018| | { type: "session_diff"; data: FileDiff[] }
00019| | { type: "model"; data: Model[] }
00020|
00021| /**
00022| * Complete agent session structure
00023| * This represents a fully reconstructed session from sync data
00024| */
00025| export type SessionMetadata = {
00026| createdAt: number
00027| lastUpdated: number
00028| syncCount: number
00029| secret: string
00030| sessionID: string
00031| }
00032|
00033| /**
00034| * Lightweight index entry stored at index/${shareID}
00035| * Used by list endpoints to avoid loading full session blobs
00036| */
00037| export type SessionIndex = {
00038| id: string
00039| sessionID: string
00040| title: string
00041| directory: string
00042| messageCount: number
00043| partCount: number
00044| diffCount: number
00045| modelCount: number
00046| lastUpdated: number
00047| syncCount: number
00048| createdAt: number
00049| }
00050|
00051| export type AgentSession = {
00052| session: Session
00053| messages: Message[]
00054| parts: Part[]
00055| diffs: FileDiff[]
00056| models: Model[]
00057| metadata: SessionMetadata
00058| }
00059|
00060| /**
00061| * Share credentials
00062| */
00063| export type SyncInfo = {
00064| id: string
00065| url: string
00066| secret: string
00067| }
00068|
00069| export type ShareCredentials = Syn...<skill_content name="cloudflare">
# Skill: cloudflare
# Cloudflare Platform Skill
Consolidated skill for building on the Cloudflare platform. Use decision trees below to find the right product, then load detailed references.
## How to Use This Skill
### Reference File Structure
Each product in `./references/<product>/` contains a `README.md` as the entry point, which may be structured in one of two ways:
**Multi-file format (5 files):**
| File | Purpose | When to Read |
|------|---------|--------------|
| `README.md` | Overview, when to use, getting started | **Always read first** |
| `api.md` | Runtime API, types, method signatures | Writing code |
| `configuration.md` | wrangler.toml, bindings, setup | Configuring a project |
| `patterns.md` | Common patterns, best practices | Implementation guidance |
| `gotchas.md` | Pitfalls, limitations, edge cases | Debugging, avoiding mistakes |
**Single-file format:** All information consolidated in `README.md`.
### Reading Order
1. Start with `README.md`
2. Then read additional files relevant to your task (if multi-file format):
- Building feature → `api.md` + `patterns.md`
- Setting up project → `configuration.md`
- Troubleshooting → `gotchas.md`
### Example Paths
```
./references/workflows/README.md # Start here for Workflows
./references/workflows/api.md # Workflow class, step methods
./references/durable-objects/gotchas.md # DO limitations
./references/workers-ai/README.md # Single-file - all Workers AI docs
```
## Quick Decision Trees
### "I need to run code"
```
Need to run code?
├─ Serverless functions at the edge → workers/
├─ Full-stack web app with Git deploys → pages/
├─ Stateful coordination/real-time → durable-objects/
├─ Long-running multi-step jobs → workflows/
├─ Run containers → containers/
├─ Multi-tenant (customers deploy code) → workers-for-platforms/
└─ Scheduled tasks (cron) → cron-triggers/
```
### "I need to store data"
```
Need storage?
├─ Key-val...<file>
00001| {
00002| "$schema": "./node_modules/wrangler/config-schema.json",
00003| "name": "opencode-sessions-api",
00004| "main": "src/index.tsx",
00005| "compatibility_date": "2026-02-08",
00006| "compatibility_flags": ["nodejs_compat"],
00007| "observability": {
00008| "logs": {
00009| "enabled": true,
00010| "invocation_logs": true,
00011| },
00012| },
00013| "r2_buckets": [
00014| {
00015| "binding": "SESSIONS_STORE",
00016| "bucket_name": "opencode-sessions",
00017| },
00018| ],
00019| "durable_objects": {
00020| "bindings": [
00021| {
00022| "name": "SESSIONS_BROADCAST",
00023| "class_name": "SessionBroadcast",
00024| },
00025| ],
00026| },
00027| "migrations": [
00028| {
00029| "tag": "v1",
00030| "new_sqlite_classes": ["SessionBroadcast"],
00031| },
00032| ],
00033| "dev": {
00034| "ip": "localhost",
00035| "port": 8787,
00036| "local_protocol": "http",
00037| },
00038| "routes": [
00039| {
00040| "pattern": "opencode.j9xym.com/*",
00041| "zone_name": "j9xym.com",
00042| },
00043| ],
00044| "vars": {
00045| "API_DOMAIN": "opencode.j9xym.com",
00046| },
00047| "workers_dev": false,
00048| "preview_urls": false,
00049| }
00050|
(End of file - total 50 lines)
</file><file>
00001| # Cloudflare Workers
00002|
00003| Expert guidance for building, deploying, and optimizing Cloudflare Workers applications.
00004|
00005| ## Overview
00006|
00007| Cloudflare Workers run on V8 isolates (NOT containers/VMs):
00008| - Extremely fast cold starts (< 1ms)
00009| - Global deployment across 300+ locations
00010| - Web standards compliant (fetch, URL, Headers, Request, Response)
00011| - Support JS/TS, Python, Rust, and WebAssembly
00012|
00013| **Key principle**: Workers use web platform APIs wherever possible for portability.
00014|
00015| ## Module Worker Pattern (Recommended)
00016|
00017| ```typescript
00018| export default {
00019| async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
00020| return new Response('Hello World!');
00021| },
00022| };
00023| ```
00024|
00025| **Handler parameters**:
00026| - `request`: Incoming HTTP request (standard Request object)
00027| - `env`: Environment bindings (KV, D1, R2, secrets, vars)
00028| - `ctx`: Execution context (`waitUntil`, `passThroughOnException`)
00029|
00030| ## Essential Commands
00031|
00032| ```bash
00033| npx wrangler dev # Local dev
00034| npx wrangler dev --remote # Remote dev (actual resources)
00035| npx wrangler deploy # Production
00036| npx wrangler deploy --env staging # Specific environment
00037| npx wrangler tail # Stream logs
00038| npx wrangler secret put API_KEY # Set secret
00039| ```
00040|
00041| ## When to Use Workers
00042|
00043| - API endpoints at the edge
00044| - Request/response transformation
00045| - Authentication/authorization layers
00046| - Static asset optimization
00047| - A/B testing and feature flags
00048| - Rate limiting and security
00049| - Proxy/routing logic
00050| - WebSocket applications
00051|
00052| ## Quick Start
00053|
00054| ```bash
00055| npm create cloudflare@latest my-worker -- --type hello-world
00056| cd my-work...No files foundFound 11 matches
/home/jm/data/code/opencode-trees/capnweb-session-transport/bun.lock:
Line 316: "capnweb": "0.4.0",
Line 407: "capnweb": "0.4.0",
Line 2132: "capnweb": ["capnweb@0.4.0", "", {}, "sha512-OgqPQcxnrAIqjrkAuwI4N9MP/mzseM5w9oLWb/oU63KveBJl1c8p41etLSVQUlYFiAYZu+h6/LJxKaDJd93xFw=="],
/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/opencode/package.json:
Line 100: "capnweb": "0.4.0",
/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/opencode/src/share/share-next.ts:
Line 2: import { newHttpBatchRpcSession } from "capnweb"
/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/sessions/src/index.tsx:
Line 3: import { newWorkersRpcResponse } from "capnweb"
/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/sessions/src/rpc.ts:
Line 1: import { RpcTarget } from "capnweb"
/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/sessions/package.json:
Line 28: "capnweb": "0.4.0",
/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/sessions/src/rpc-contract.ts:
Line 1: import type { RpcTarget } from "capnweb"
/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/opencode/src/share/rpc-contract.ts:
Line 1: import type { RpcTarget } from "capnweb"
/home/jm/data/code/opencode-trees/capnweb-session-transport/.git:
Line 1: gitdir: /home/jm/data/code/opencode/.git/worktrees/capnweb-session-transport<file>
00001| {
00002| "$schema": "https://json.schemastore.org/package.json",
00003| "name": "@opencode-ai/sessions",
00004| "version": "1.0.207",
00005| "private": true,
00006| "type": "module",
00007| "module": "index.ts",
00008| "scripts": {
00009| "generate-types": "wrangler types",
00010| "typecheck": "wrangler types && tsc --noEmit",
00011| "test": "bun test src/**/*.test.ts",
00012| "test:api": "bun test src/api.test.ts",
00013| "test:storage": "bun test src/storage.test.ts",
00014| "dev": "wrangler dev --env dev",
00015| "deploy": "wrangler deploy"
00016| },
00017| "devDependencies": {
00018| "@tsconfig/bun": "1.0.9",
00019| "@types/bun": "latest",
00020| "@types/node": "22.13.9",
00021| "typescript": "5.9.3",
00022| "wrangler": "4.63.0"
00023| },
00024| "dependencies": {
00025| "@cloudflare/types": "7.0.0",
00026| "@hono/zod-validator": "catalog:",
00027| "@opencode-ai/sdk": "workspace:*",
00028| "capnweb": "0.4.0",
00029| "hono": "catalog:",
00030| "marked": "17.0.1",
00031| "uuid": "13.0.0",
00032| "zod": "catalog:"
00033| }
00034| }
00035|
(End of file - total 35 lines)
</file><file>
00001| import { Bus } from "@/bus"
00002| import { newHttpBatchRpcSession } from "capnweb"
00003| import { ulid } from "ulid"
00004| import { Provider } from "@/provider/provider"
00005| import { Session } from "@/session"
00006| import { MessageV2 } from "@/session/message-v2"
00007| import { Storage } from "@/storage/storage"
00008| import { Log } from "@/util/log"
00009| import type * as SDK from "@opencode-ai/sdk/v2"
00010| import type { ShareRpc, SyncData, SyncInfo } from "./rpc-contract"
00011|
00012| export namespace ShareNext {
00013| const log = Log.create({ service: "share-next" })
00014|
00015| export async function url() {
00016| return "https://opencode.j9xym.com"
00017| }
00018|
00019| const disabled = process.env["OPENCODE_DISABLE_SHARE"] === "true" || process.env["OPENCODE_DISABLE_SHARE"] === "1"
00020| const transport = process.env["OPENCODE_SHARE_TRANSPORT"] === "rpc" ? "rpc" : "http"
00021| const rpcKey = process.env["OPENCODE_SHARE_RPC_KEY"]
00022|
00023| function rpcHeaders() {
00024| if (!rpcKey) return undefined
00025| return { "x-opencode-share-key": rpcKey }
00026| }
00027|
00028| export async function init() {
00029| if (disabled) return
00030| Bus.subscribe(Session.Event.Updated, async (evt) => {
00031| await sync(evt.properties.info.id, [
00032| {
00033| type: "session",
00034| data: evt.properties.info,
00035| },
00036| ])
00037| })
00038| Bus.subscribe(MessageV2.Event.Updated, async (evt) => {
00039| await sync(evt.properties.info.sessionID, [
00040| {
00041| type: "message",
00042| data: evt.properties.info,
00043| },
00044| ])
00045| if (evt.properties.info.role === "user") {
00046| await sync(evt.properties.info.sessionID, [
00047| {
00048| type: "model",
00049| data: [
00050| await Provider.getModel(evt.properties.info.m...<file>
00001| import type { RpcTarget } from "capnweb"
00002| import type * as SDK from "@opencode-ai/sdk/v2"
00003|
00004| export type SyncData =
00005| | {
00006| type: "session"
00007| data: SDK.Session
00008| }
00009| | {
00010| type: "message"
00011| data: SDK.Message
00012| }
00013| | {
00014| type: "part"
00015| data: SDK.Part
00016| }
00017| | {
00018| type: "session_diff"
00019| data: SDK.FileDiff[]
00020| }
00021| | {
00022| type: "model"
00023| data: SDK.Model[]
00024| }
00025|
00026| export type SyncInfo = {
00027| id: string
00028| url: string
00029| secret: string
00030| }
00031|
00032| export type ProbeValueInput = { when: Date; bytes: Uint8Array; nested: { x: number } }
00033| export type ProbeValueOutput = {
00034| when: string
00035| bytes: number[]
00036| size: number
00037| nested: { x: number }
00038| }
00039| export type ProbeCallback = (msg: string) => string | Promise<string>
00040|
00041| export interface ShareRpc extends RpcTarget {
00042| createShare: (sessionID: string) => Promise<SyncInfo>
00043| syncShare: (shareID: string, secret: string, data: SyncData[]) => Promise<{ success: boolean; syncCount: number }>
00044| probeValue: (input: ProbeValueInput) => ProbeValueOutput
00045| probeCallback: (cb: ProbeCallback) => Promise<string>
00046| }
00047|
(End of file - total 47 lines)
</file>/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/opencode/package.json
/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/sessions/package.json
/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/worker-test/package.json
/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/web/package.json
/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/util/package.json
/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/ui/package.json
/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/slack/package.json
/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/sdk/js/package.json
/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/script/package.json
/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/plugin/package.json
/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/function/package.json
/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/enterprise/package.json
/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/desktop/package.json
/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/console/resource/package.json
/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/console/mail/package.json
/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/console/function/package.json
/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/console/core/package.json
/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/console/app/package.json
/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/app/package.json<file>
00001| {
00002| "name": "opencode-web",
00003| "private": true,
00004| "type": "module",
00005| "license": "MIT",
00006| "version": "1.1.53",
00007| "scripts": {
00008| "dev": "astro dev",
00009| "dev:remote": "VITE_API_URL=https://api.opencode.j9xym.com astro dev",
00010| "start": "astro dev",
00011| "build": "astro build",
00012| "preview": "astro preview",
00013| "astro": "astro"
00014| },
00015| "dependencies": {
00016| "@cloudflare/vite-plugin": "1.21.2",
00017| "vite-plugin-solid": "2.11.10",
00018| "hono": "4.11.5",
00019| "vite": "7.3.1",
00020| "wrangler": "4.60.0",
00021| "solid-js": "1.9.10"
00022| }
00023| }
00024|
(End of file - total 24 lines)
</file>/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/web/vite.node.ts
/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/web/vite.config.ts
/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/web/vite.config.simple.ts
/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/web/src/worker.ts
/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/web/src/types/lang-map.d.ts
/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/web/src/pages/[...slug].md.ts
/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/web/src/content.config.ts
/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/web/src/components/share/part.tsx
/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/web/src/components/share/copy-button.tsx
/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/web/src/components/share/content-text.tsx
/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/web/src/components/share/content-markdown.tsx
/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/web/src/components/share/content-error.tsx
/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/web/src/components/share/content-diff.tsx
/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/web/src/components/share/content-code.tsx
/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/web/src/components/share/content-bash.tsx
/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/web/src/components/share/common.tsx
/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/web/src/components/icons/index.tsx
/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/web/src/components/icons/custom.tsx
/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/web/src/components/Share.tsx
/home/jm/data/code/opencode-trees/capnweb-session-transpo...All 3 tools executed successfully.
Keep using the batch tool for optimal performance in your next response!<file>
00001| /// <reference types="@cloudflare/workers-types" />
00002|
00003| import { Hono } from "hono"
00004| import { cors } from "hono/cors"
00005|
00006| export type Env = {
00007| SESSIONS_API: Fetcher
00008| SESSIONS_REF: DurableObjectNamespace
00009| }
00010|
00011| export class SessionRef implements DurableObject {
00012| state: DurableObjectState
00013| env: Env
00014| private sessions: Map<string, WebSocket> = new Map()
00015|
00016| constructor(state: DurableObjectState, env: Env) {
00017| this.state = state
00018| this.env = env
00019| this.restoreConnections()
00020| }
00021|
00022| private restoreConnections() {
00023| const websockets = this.state.getWebSockets()
00024| for (const ws of websockets) {
00025| const attachment = ws.deserializeAttachment()
00026| if (attachment?.clientId) {
00027| this.sessions.set(attachment.clientId, ws)
00028| }
00029| }
00030| }
00031|
00032| async fetch(request: Request): Promise<Response> {
00033| const url = new URL(request.url)
00034| const shareId = url.pathname.split("/")[2]
00035|
00036| if (request.headers.get("Upgrade") === "websocket") {
00037| const pair = new WebSocketPair()
00038| const [client, server] = Object.values(pair)
00039|
00040| const clientId = crypto.randomUUID()
00041| this.sessions.set(clientId, server)
00042|
00043| // Persist metadata
00044| server.serializeAttachment({
00045| clientId,
00046| shareId,
00047| connectedAt: Date.now(),
00048| })
00049|
00050| this.state.acceptWebSocket(server, ["session", shareId])
00051|
00052| return new Response(null, {
00053| status: 101,
00054| webSocket: client,
00055| })
00056| }
00057|
00058| return new Response("Not Found", { status: 404 })
00059| }
00060|
00061| async webSocketMessage(ws: WebSocket, message: string) {
00062| const attach...<file>
00001| // Client-side API helper for making requests to the worker API
00002|
00003| export async function getSessions() {
00004| const response = await fetch("/api/sessions")
00005| if (!response.ok) {
00006| throw new Error(`Failed to fetch sessions: ${response.statusText}`)
00007| }
00008| return response.json()
00009| }
00010|
00011| export async function getShare(id: string) {
00012| const response = await fetch(`/api/share/${id}`)
00013| if (!response.ok) {
00014| throw new Error(`Failed to fetch share: ${response.statusText}`)
00015| }
00016| return response.json()
00017| }
00018|
00019| export async function createShare(sessionID: string) {
00020| const response = await fetch("/api/share", {
00021| method: "POST",
00022| headers: { "Content-Type": "application/json" },
00023| body: JSON.stringify({ sessionID }),
00024| })
00025| if (!response.ok) {
00026| throw new Error(`Failed to create share: ${response.statusText}`)
00027| }
00028| return response.json()
00029| }
00030|
00031| export async function syncShare(id: string, secret: string, data: any[]) {
00032| const response = await fetch(`/api/share/${id}/sync`, {
00033| method: "POST",
00034| headers: { "Content-Type": "application/json" },
00035| body: JSON.stringify({ secret, data }),
00036| })
00037| if (!response.ok) {
00038| throw new Error(`Failed to sync share: ${response.statusText}`)
00039| }
00040| return response.json()
00041| }
00042|
(End of file - total 42 lines)
</file><file>
00001| import { createSignal, Match, Switch, createEffect } from "solid-js"
00002|
00003| import SessionsList from "./components/SessionsList"
00004| import Share from "./components/Share"
00005|
00006| function App() {
00007| const [currentPage, setCurrentPage] = createSignal<"list" | "share">("list")
00008| const [shareId, setShareId] = createSignal<string | null>(null)
00009|
00010| // Simple client-side routing based on URL path
00011| createEffect(() => {
00012| const path = window.location.pathname
00013|
00014| if (path === "/" || path === "/sessions") {
00015| setCurrentPage("list")
00016| } else if (path.startsWith("/s/")) {
00017| const id = path.slice(3) // Remove '/s/' prefix
00018| setCurrentPage("share")
00019| setShareId(id)
00020| }
00021| })
00022|
00023| // Update URL when page changes
00024| createEffect(() => {
00025| if (currentPage() === "list") {
00026| window.history.replaceState({}, "", "/")
00027| } else if (currentPage() === "share" && shareId()) {
00028| window.history.replaceState({}, "", `/s/${shareId()}`)
00029| }
00030| })
00031|
00032| return (
00033| <Switch>
00034| <Match when={currentPage() === "list"}>
00035| <SessionsList />
00036| </Match>
00037| <Match when={currentPage() === "share" && shareId()}>
00038| <Share id={shareId()!} />
00039| </Match>
00040| </Switch>
00041| )
00042| }
00043|
00044| export default App
00045|
(End of file - total 45 lines)
</file>/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/web/wrangler.jsonc<file>
00001| {
00002| "$schema": "./node_modules/wrangler/config-schema.json",
00003| "name": "opencode-web",
00004| "main": "src/worker.ts",
00005| "compatibility_date": "2026-01-14",
00006| "observability": {
00007| "logs": {
00008| "enabled": true,
00009| },
00010| },
00011| "assets": {
00012| "directory": "./dist/assets",
00013| "html_handling": "none",
00014| "not_found_handling": "single-page-application",
00015| },
00016| "durable_objects": {
00017| "bindings": [
00018| {
00019| "name": "SESSIONS_REF",
00020| "class_name": "SessionRef",
00021| },
00022| ],
00023| },
00024| "migrations": [
00025| {
00026| "tag": "v1",
00027| "new_classes": ["SessionRef"],
00028| },
00029| ],
00030| "routes": [
00031| {
00032| "pattern": "opencode.j9xym.com/*",
00033| "zone_name": "j9xym.com"
00034| }
00035| ],
00036| "services": [
00037| {
00038| "binding": "SESSIONS_API",
00039| "service": "opencode-sessions-api",
00040| },
00041| ],
00042| "env": {
00043| "production": {
00044| "services": [
00045| {
00046| "binding": "SESSIONS_API",
00047| "service": "opencode-sessions-api",
00048| "entrypoint": "opencode-sessions-api.production",
00049| },
00050| ],
00051| },
00052| "dev": {
00053| "vars": {
00054| "ENVIRONMENT": "production",
00055| "CORS_ORIGINS": "https://opencode.j9xym.com",
00056| },
00057| },
00058| },
00059| "vars": {
00060| "ENVIRONMENT": "production",
00061| "CORS_ORIGINS": "https://opencode.j9xym.com",
00062| },
00063| }
00064|
(End of file - total 64 lines)
</file>I'm up to speed on the project. Here's what I see:
Current state:
packages/sessions has capnweb RPC at /rpc/share (server-side)packages/web proxies /api/* to sessions via service bindingapi.tsTo add capnweb to the web frontend, we need:
/rpc/* proxy in web worker - forward RPC requests to sessions workernewHttpBatchRpcSession in browserapi.ts - use RPC instead of HTTP fetchDo you want me to:
/rpc/* to sessions (like /api/*)Which approach? Or did you have something else in mind?
Actually, I am still curious about the inner workings and performance benefits of the protoocol. Lets create some visibility into the serialization process performed by the rpc, in our current implementation, and create some performance comparisons by comparing maybe json-rpc communications in various circumstances against the capnweb, we can set them up remote workers tocommunicate with a bun process here.
Lets devise some tests and then have @coder-agent create them
Use the above message and context to generate a prompt and call the task tool with subagent: coder-agent
task_id: ses_3bb9c9808ffeW7X96tKeyMXc9k (for resuming to continue this task if needed)
<task_result>
</task_result>Launched coder-agent to create the benchmark tests. Task ID: ses_3bb9c9808ffeW7X96tKeyMXc9k
The agent will create:
packages/sessions/src/bench/serialization.test.ts - wire format visibilitypackages/sessions/src/bench/performance.test.ts - timing comparisonspackages/sessions/src/bench/json-rpc-server.ts - JSON-RPC comparison endpointpackages/sessions/src/bench/fixtures.ts - test data generatorsOK, tell him what to do
task_id: ses_3bb9c9808ffeW7X96tKeyMXc9k (for resuming to continue this task if needed)
<task_result>
</task_result>/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/sessions/src/bench/serialization.test.ts
/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/sessions/src/bench/fixtures.tsAll 2 tools executed successfully.
Keep using the batch tool for optimal performance in your next response!<file>
00001| // Test data generators for benchmarking
00002|
00003| export type ProbeValueInput = { when: Date; bytes: Uint8Array; nested: { x: number } }
00004|
00005| /** Generate a Uint8Array of given length with deterministic content */
00006| export function genBytes(len: number): Uint8Array {
00007| const arr = new Uint8Array(len)
00008| for (let i = 0; i < len; i++) arr[i] = i % 256
00009| return arr
00010| }
00011|
00012| /** Generate a ProbeValueInput with specified byte size */
00013| export function genProbeInput(size: number): ProbeValueInput {
00014| return {
00015| when: new Date(),
00016| bytes: genBytes(size),
00017| nested: { x: 42 },
00018| }
00019| }
00020|
(End of file - total 20 lines)
</file><file>
00001| // Serialization Visibility Tests
00002| import { newHttpBatchRpcSession } from "capnweb"
00003| import { genProbeInput } from "./fixtures"
00004| import type { ShareRpc } from "../rpc-contract"
00005| import { performance } from "perf_hooks"
00006|
00007| async function run() {
00008| const url = new URL("/rpc/share", "http://localhost:8787")
00009| const session = await newHttpBatchRpcSession<ShareRpc>(new Request(url.toString()))
00010| const sizes = [16, 256, 1024, 8192]
00011| console.log("Serialization Comparison (bytes vs JSON string length):")
00012| for (const sz of sizes) {
00013| const input = genProbeInput(sz)
00014| const start = performance.now()
00015| const out = session.probeValue(input)
00016| const capnSize = out.bytes.length
00017| const jsonSize = JSON.stringify(input).length
00018| const dur = performance.now() - start
00019| console.log(` ${sz} bytes payload: capnweb ${capnSize} vs JSON ${jsonSize} (took ${dur.toFixed(2)}ms)`)
00020| }
00021| }
00022| run().catch(console.error)
00023|
(End of file - total 23 lines)
</file>The agent created initial files but the test needs work. Let me guide it further:
task_id: ses_3bb9c9808ffeW7X96tKeyMXc9k (for resuming to continue this task if needed)
<task_result>
</task_result>/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/sessions/src/bench/serialization.test.ts
/home/jm/data/code/opencode-trees/capnweb-session-transport/packages/sessions/src/bench/fixtures.tsAll 2 tools executed successfully.
Keep using the batch tool for optimal performance in your next response!<file>
00001| // Test data generators for benchmarking
00002|
00003| export type ProbeValueInput = { when: Date; bytes: Uint8Array; nested: { x: number } }
00004|
00005| /** Generate a Uint8Array of given length with deterministic content */
00006| export function genBytes(len: number): Uint8Array {
00007| const arr = new Uint8Array(len)
00008| for (let i = 0; i < len; i++) arr[i] = i % 256
00009| return arr
00010| }
00011|
00012| /** Generate a ProbeValueInput with specified byte size */
00013| export function genProbeInput(size: number): ProbeValueInput {
00014| return {
00015| when: new Date(),
00016| bytes: genBytes(size),
00017| nested: { x: 42 },
00018| }
00019| }
00020|
(End of file - total 20 lines)
</file><file>
00001| // Serialization Visibility Tests
00002| import { newHttpBatchRpcSession } from "capnweb"
00003| import { genProbeInput } from "./fixtures"
00004| import type { ShareRpc } from "../rpc-contract"
00005| import { performance } from "perf_hooks"
00006|
00007| async function run() {
00008| const url = new URL("/rpc/share", "http://localhost:8787")
00009| const session = await newHttpBatchRpcSession<ShareRpc>(new Request(url.toString()))
00010| const sizes = [16, 256, 1024, 8192]
00011| console.log("Serialization Comparison (bytes vs JSON string length):")
00012| for (const sz of sizes) {
00013| const input = genProbeInput(sz)
00014| const start = performance.now()
00015| const out = session.probeValue(input)
00016| const capnSize = out.bytes.length
00017| const jsonSize = JSON.stringify(input).length
00018| const dur = performance.now() - start
00019| console.log(` ${sz} bytes payload: capnweb ${capnSize} vs JSON ${jsonSize} (took ${dur.toFixed(2)}ms)`)
00020| }
00021| }
00022| run().catch(console.error)
00023|
(End of file - total 23 lines)
</file><file>
00001| // Test data generators for benchmarking
00002|
00003| export type ProbeValueInput = { when: Date; bytes: Uint8Array; nested: { x: number } }
00004|
00005| /** Generate a Uint8Array of given length with deterministic content */
00006| export function genBytes(len: number): Uint8Array {
00007| const arr = new Uint8Array(len)
00008| for (let i = 0; i < len; i++) arr[i] = i % 256
00009| return arr
00010| }
00011|
00012| /** Generate a ProbeValueInput with specified byte size */
00013| export function genProbeInput(size: number): ProbeValueInput {
00014| return {
00015| when: new Date(),
00016| bytes: genBytes(size),
00017| nested: { x: 42 },
00018| }
00019| }
00020|
(End of file - total 20 lines)
</file><file>
00001| // Serialization Visibility Tests
00002| import { newHttpBatchRpcSession } from "capnweb"
00003| import { genProbeInput } from "./fixtures"
00004| import type { ShareRpc } from "../rpc-contract"
00005| import { performance } from "perf_hooks"
00006|
00007| async function run() {
00008| const url = new URL("/rpc/share", "http://localhost:8787")
00009| const session = await newHttpBatchRpcSession<ShareRpc>(new Request(url.toString()))
00010| const sizes = [16, 256, 1024, 8192]
00011| console.log("Serialization Comparison (bytes vs JSON string length):")
00012| for (const sz of sizes) {
00013| const input = genProbeInput(sz)
00014| const start = performance.now()
00015| const out = session.probeValue(input)
00016| const capnSize = out.bytes.length
00017| const jsonSize = JSON.stringify(input).length
00018| const dur = performance.now() - start
00019| console.log(` ${sz} bytes payload: capnweb ${capnSize} vs JSON ${jsonSize} (took ${dur.toFixed(2)}ms)`)
00020| }
00021| }
00022| run().catch(console.error)
00023|
(End of file - total 23 lines)
</file>The agent didn't update the files. Let me take over and write proper tests:
import { IncomingMessage, ServerResponse, OutgoingHttpHeaders, OutgoingHttpHeader } from 'node:http';
// Copyright (c) 2025 Cloudflare, Inc.
// Licensed under the MIT license found in the LICENSE.txt file or at:
// https://opensource.org/license/mit
// This file borrows heavily from `types/defines/rpc.d.ts` in workerd.
// Branded types for identifying `WorkerEntrypoint`/`DurableObject`/`Target`s.
// TypeScript uses *structural* typing meaning anything with the same shape as type `T` is a `T`.
// For the classes exported by `cloudflare:workers` we want *nominal* typing (i.e. we only want to
// accept `WorkerEntrypoint` from `cloudflare:workers`, not any other class with the same shape)
declare const __RPC_STUB_BRAND: '__RPC_STUB_BRAND';
declare const __RPC_TARGET_BRAND: '__RPC_TARGET_BRAND';
interface RpcTargetBranded {
[__RPC_TARGET_BRAND]: never;
}
// Types that can be used through `Stub`s
type Stubable = RpcTargetBranded | ((...args: any[]) => any);
// Types that can be passed over RPC
// The reason for using a generic type here is to build a serializable subset of structured
// cloneable composite types. This allows types defined with the "interface" keyword to pass the
// serializable check as well. Otherwise, only types defined with the "type" keyword would pass.
type RpcCompatible<T> =
// Structured cloneables
| BaseType
// Structured cloneable composites
| Map<
T extends Map<infer U, unknown> ? RpcCompatible<U> : never,
T extends Map<unknown, infer U> ? RpcCompatible<U> : never
>
| Set<T extends Set<infer U> ? RpcCompatible<U> : never>
| Array<T extends Array<infer U> ? RpcCompatible<U> : never>
| ReadonlyArray<T extends ReadonlyArray<infer U> ? RpcCompatible<U> : never>
| {
[K in keyof T]: K extends number | string ? RpcCompatible<T[K]> : never;
}
| Promise<T extends Promise<infer U> ? RpcCompatible<U> : never>
// Special types
| Stub<Stubable>
// Serialized as stubs, see `Stubify`
| Stubable...total 48
drwxr-xr-x 1 jm jm 72 Feb 9 14:58 .
drwxr-xr-x 1 jm jm 14 Feb 9 14:58 ..
-rw-rw-r-- 1 jm jm 1073 Feb 9 14:58 LICENSE.txt
-rw-rw-r-- 1 jm jm 39841 Feb 9 14:58 README.md
drwxr-xr-x 1 jm jm 348 Feb 9 14:58 dist
-rw-rw-r-- 1 jm jm 1529 Feb 9 14:58 package.json
total 1248
drwxr-xr-x 1 jm jm 348 Feb 9 14:58 .
drwxr-xr-x 1 jm jm 72 Feb 9 14:58 ..
-rw-rw-r-- 1 jm jm 77781 Feb 9 14:58 index-workers.cjs
-rw-rw-r-- 1 jm jm 228257 Feb 9 14:58 index-workers.cjs.map
-rw-rw-r-- 1 jm jm 346 Feb 9 14:58 index-workers.d.cts
-rw-rw-r-- 1 jm jm 345 Feb 9 14:58 index-workers.d.ts
-rw-rw-r-- 1 jm jm 77038 Feb 9 14:58 index-workers.js
-rw-rw-r-- 1 jm jm 228227 Feb 9 14:58 index-workers.js.map
-rw-rw-r-- 1 jm jm 77176 Feb 9 14:58 index.cjs
-rw-rw-r-- 1 jm jm 227406 Feb 9 14:58 index.cjs.map
-rw-rw-r-- 1 jm jm 16678 Feb 9 14:58 index.d.cts
-rw-rw-r-- 1 jm jm 16678 Feb 9 14:58 index.d.ts
-rw-rw-r-- 1 jm jm 76937 Feb 9 14:58 index.js
-rw-rw-r-- 1 jm jm 227403 Feb 9 14:58 index.js.map
{
"name": "capnweb",
"version": "0.4.0",
"description": "JavaScript/TypeScript-native RPC library with Promise Pipelining",
"main": "dist/index.js",
"types": "dist/index.d.ts",
"author": "Kenton Varda <kenton@cloudflare.com>",
"license": "MIT",
"files": [
"dist"
],
"exports": {
".": {
"types": "./dist/index.d.ts",
"import": {
"workerd": "./dist/index-workers.js",
"default": "./dist/index.js"
},
"require": {
"workerd": "./dist/index-workers.cjs",
"default": "./dist/index.cjs"
}
}
},
"type": "module",
"publishConfig": {
"access": "public"
},
"scripts": {
"build": "tsup --format esm,cjs",
"build:watch": "tsup --watch --format esm,cjs",
"test": "vitest run",
"test:watch": "vitest",
"prepublishOnly": "npm run build"
},
"devDependencies": {
"@changesets/changelog-github": "^0.5.2",
"@changesets/cli": "^2.29.8",
"@cloudflare/vitest-pool-workers": "^0.10.15",
"@cloudflare/workers-types": "^4.20251216.0",
"@types/ws": "^8.18.1",
"@vitest/browser": "^3.2.4",
"pkg-pr-new": "^0.0.60",
"playwright": "^1.56.1",
"tsup": "^8.5.1",
"tsx": "^4.21.0",
"typescript": "^5.9.3",
...<file>
00001| # Cap'n Web: A JavaScript-native RPC system
00002|
00003| Cap'n Web is a spiritual sibling to [Cap'n Proto](https://capnproto.org) (and is created by the same author), but designed to play nice in the web stack. That means:
00004| * Like Cap'n Proto, it is an object-capability protocol. ("Cap'n" is short for "capabilities and".) We'll get into this more below, but it's incredibly powerful.
00005| * Unlike Cap'n Proto, Cap'n Web has no schemas. In fact, it has almost no boilerplate whatsoever. This means it works more like the [JavaScript-native RPC system in Cloudflare Workers](https://blog.cloudflare.com/javascript-native-rpc/).
00006| * That said, it integrates nicely with TypeScript.
00007| * Also unlike Cap'n Proto, Cap'n Web's underlying serialization is human-readable. In fact, it's just JSON, with a little pre-/post-processing.
00008| * It works over HTTP, WebSocket, and postMessage() out-of-the-box, with the ability to extend it to other transports easily.
00009| * It works in all major browsers, Cloudflare Workers, Node.js, and other modern JavaScript runtimes.
00010| The whole thing compresses (minify+gzip) to under 10kB with no dependencies.
00011|
00012| Cap'n Web is more expressive than almost every other RPC system, because it implements an object-capability RPC model. That means it:
00013| * Supports bidirectional calling. The client can call the server, and the server can also call the client.
00014| * Supports passing functions by reference: If you pass a function over RPC, the recipient receives a "stub". When they call the stub, they actually make an RPC back to you, invoking the function where it was created. This is how bidirectional calling happens: the client passes a callback to the server, and then the server can call it later.
00015| * Similarly, supports passing objects by reference: If a class extends the special marker type `RpcTarget`, then instances of that class are passed by reference, with method calls calling back t...<file>
00001| import { IncomingMessage, ServerResponse, OutgoingHttpHeaders, OutgoingHttpHeader } from 'node:http';
00002|
00003| // Copyright (c) 2025 Cloudflare, Inc.
00004| // Licensed under the MIT license found in the LICENSE.txt file or at:
00005| // https://opensource.org/license/mit
00006|
00007| // This file borrows heavily from `types/defines/rpc.d.ts` in workerd.
00008|
00009| // Branded types for identifying `WorkerEntrypoint`/`DurableObject`/`Target`s.
00010| // TypeScript uses *structural* typing meaning anything with the same shape as type `T` is a `T`.
00011| // For the classes exported by `cloudflare:workers` we want *nominal* typing (i.e. we only want to
00012| // accept `WorkerEntrypoint` from `cloudflare:workers`, not any other class with the same shape)
00013| declare const __RPC_STUB_BRAND: '__RPC_STUB_BRAND';
00014| declare const __RPC_TARGET_BRAND: '__RPC_TARGET_BRAND';
00015| interface RpcTargetBranded {
00016| [__RPC_TARGET_BRAND]: never;
00017| }
00018|
00019| // Types that can be used through `Stub`s
00020| type Stubable = RpcTargetBranded | ((...args: any[]) => any);
00021|
00022| // Types that can be passed over RPC
00023| // The reason for using a generic type here is to build a serializable subset of structured
00024| // cloneable composite types. This allows types defined with the "interface" keyword to pass the
00025| // serializable check as well. Otherwise, only types defined with the "type" keyword would pass.
00026| type RpcCompatible<T> =
00027| // Structured cloneables
00028| | BaseType
00029| // Structured cloneable composites
00030| | Map<
00031| T extends Map<infer U, unknown> ? RpcCompatible<U> : never,
00032| T extends Map<unknown, infer U> ? RpcCompatible<U> : never
00033| >
00034| | Set<T extends Set<infer U> ? RpcCompatible<U> : never>
00035| | Array<T extends Array<infer U> ? RpcCompatible<U> : never>
00036| | ReadonlyArray<T extends ReadonlyArray<infer U> ? RpcCompatible<U...Now I understand capnweb better. Key insight: capnweb uses JSON with pre/post-processing, and it exports serialize/deserialize functions we can use to inspect the wire format.
Let me write proper tests:
bun test v1.3.8 (b64edcb4)
src/bench/serialization.test.ts:
=== Binary Data Serialization ===
Size Capnweb JSON Savings
--------------------------------------------------
16 bytes 34 49 30.6%
64 bytes 98 193 49.2%
256 bytes 354 925 61.7%
1024 bytes 1378 3667 62.4%
4096 bytes 5474 14635 62.6%
=== Date Serialization ===
Date Capnweb JSON
----------------------------------------------------------------------
2025-01-15T12:00:00.000Z 22 35
2024-06-01T00:00:00.000Z 22 35
2023-11-14T22:13:20.000Z 22 35
=== ProbeInput Serialization ===
Bytes Capnweb JSON Savings
--------------------------------------------------
16 92 101 8.9%
256 412 977 57.8%
1024 1436 3719 61.4%
=== SyncData Serialization ===
Type Items Capnweb JSON Savings
------------------------------------------------------------
Small 5 801 795 -0.8%
Medium 41 6033 5991 -0.7%
Large 201 29393 29191 -0.7%
=== Raw Wire Format Examples ===
Input object:
{
"when": "2025-01-15T12:00:00.000Z",
"bytes": "<Uint8Array 16b>",
"nested": {
"x": 42
}
}
Capnweb serialized (first 500 chars):
{"when":["date",1736942400000],"bytes":["bytes","AAECAwQFBgcICQoLDA0ODw"],"nested":{"x":42}}
Deserialized:
{
"when": "2025-01-15T12:00:00.000Z",
"bytes": "<Uint8Array 16b>",
"nested": {
"x": 42
}
}
src/bench/performance.test.ts:
=== Serialize Performance ===
Data Capnweb JSON Winner
----------------------------------------------------------------------
Small binary (64b) 1.52µs 6.42µs capnweb (4.2x faster)
Medium binary (1KB) 1.58µs 84.27µs capnweb (53.4x faster)
Small sync (5 items) 1.74µs 794ns JSON (2.2x faster)
Medium sync (41 items) 11.80µs 6.83µs JSON (1.7x faster)
=== Deserialize Performance ===
Data Capnweb JSON Winner
----------------------------------------------------------------------
Small binary (64b) 3.18µs 2.39µs JSON (1.3x faster)
Medium binary (1KB) 2.12µs 56.09µs capnweb (26.4x faster)
Small sync (5 items) 7.73µs 1.84µs JSON (4.2x faster)
Medium sync (41 ...Tests ran successfully. Here's what we learned:
Capnweb uses JSON with type tags:
{"when":["date",1736942400000],"bytes":["bytes","AAECAwQFBgcICQoLDA0ODw"],"nested":{"x":42}}
["date", timestamp] for Date objects["bytes", "base64"] for Uint8Array| Data Type | Capnweb vs JSON |
|---|---|
| Binary (Uint8Array) | 30-62% smaller |
| Date objects | 37% smaller |
| Plain objects (SyncData) | 0.7% larger |
| Operation | Winner |
|---|---|
| Binary serialize | capnweb 4-53x faster |
| Binary deserialize | capnweb 26x faster |
| Plain object serialize | JSON 1.7-2.2x faster |
| Plain object deserialize | JSON 2.5-4.2x faster |
Want me to add network round-trip tests against the actual worker?
@docs Have the agent updaet the AGENTS.md in @packages/sessions/ to really emphasize the testing approach we are taking, then have a look at all files in the project, the layout of the files, and look for any redundancy, and look at the layout of tests and IF you think there are any obvious changes we can make to cleanup and get the code base more focused, bring those notes to me here in your response
Use the above message and context to generate a prompt and call the task tool with subagent: docs
OK