devflare 1.0.0-next.31 → 1.0.0-next.33

package/dist/{index-6sj0v0dk.js → index-1trss579.js}

@@ -1,1228 +1,839 @@
 import {
   wrapEnvSendEmailBindings
-} from "./index-hpwa6vsw.js";
+} from "./index-n4xkaymm.js";
 
-// src/runtime/validation.ts
-class ContextAccessError extends Error {
-  contextName;
-  propertyName;
-  constructor(contextName, propertyName, message) {
-    super(message ?? `Cannot access ${contextName}.${propertyName} outside of an active Devflare handler trail.
-
-` + `This typically happens when:
-` + `  1. Accessing ${contextName} at module top-level (during import)
-` + `  2. Accessing ${contextName} in a callback that runs after the handler ends
-` + `  3. Accessing ${contextName} in a setTimeout/setInterval callback
-
-` + `Move the access inside your handler function or middleware.`);
-    this.name = "ContextAccessError";
-    this.contextName = contextName;
-    this.propertyName = propertyName;
-  }
-  static contextUnavailable(message) {
-    return new ContextAccessError("context", "<unavailable>", message ?? `Context not available. Devflare uses AsyncLocalStorage to carry the active event through fetch, queue, scheduled, email, tail, and Durable Object handler call chains.
-
-` + `This usually means one of:
-
-` + `1. Accessing context at module top-level (runs at cold start, not per-request)
-` + `2. Accessing context in setTimeout/setInterval callbacks
-` + `3. Missing 'nodejs_compat' compatibility flag in your worker config
-
-` + `Fix: Move the access inside your handler, middleware, or a helper called from that handler trail.
-` + `Learn more: https://devflare.dev/docs/context-errors`);
-  }
-}
-function createContextProxy(getter, name, options = {}) {
-  const mutable = options.mutable ?? true;
-  return new Proxy({}, {
-    get(_target, prop) {
-      const ctx = getter();
-      if (ctx === undefined || ctx === null) {
-        throw new ContextAccessError(name, String(prop));
-      }
-      return ctx[prop];
-    },
-    set(_target, prop, value) {
-      if (!mutable) {
-        throw new TypeError(`Cannot assign to '${String(prop)}' on '${name}' because it is read-only.
-` + `Use 'locals' for mutable request-scoped data.`);
-      }
-      const ctx = getter();
-      if (ctx === undefined || ctx === null) {
-        throw new ContextAccessError(name, String(prop));
-      }
-      ctx[prop] = value;
-      return true;
-    },
-    deleteProperty(_target, prop) {
-      if (!mutable) {
-        throw new TypeError(`Cannot delete property '${String(prop)}' from '${name}' because it is read-only.`);
-      }
-      const ctx = getter();
-      if (ctx === undefined || ctx === null) {
-        return true;
-      }
-      return Reflect.deleteProperty(ctx, prop);
-    },
-    has(_target, prop) {
-      const ctx = getter();
-      if (ctx === undefined || ctx === null) {
-        return false;
-      }
-      return prop in ctx;
-    },
-    ownKeys(_target) {
-      const ctx = getter();
-      if (ctx === undefined || ctx === null) {
-        return [];
-      }
-      return Reflect.ownKeys(ctx);
-    },
-    getOwnPropertyDescriptor(_target, prop) {
-      const ctx = getter();
-      if (ctx === undefined || ctx === null) {
-        return;
-      }
-      const descriptor = Reflect.getOwnPropertyDescriptor(ctx, prop);
-      if (!descriptor) {
-        return;
-      }
-      if (!mutable) {
-        return { ...descriptor, writable: false };
-      }
-      return descriptor;
-    }
-  });
-}
-
-// src/runtime/context-events.ts
-function createLocals(locals) {
-  return locals ?? {};
-}
-function prepareEventShell(env, options = {}) {
-  return {
-    env: wrapEnvSendEmailBindings(env),
-    locals: createLocals(options.locals)
-  };
-}
-function createAugmentedTarget(target, extra) {
-  return new Proxy(target, {
-    get(target2, prop) {
-      if (prop in extra) {
-        return extra[prop];
-      }
-      const value = Reflect.get(target2, prop, target2);
-      return typeof value === "function" ? value.bind(target2) : value;
-    },
-    has(target2, prop) {
-      return prop in extra || prop in target2;
-    },
-    ownKeys(target2) {
-      return Array.from(new Set([
-        ...Reflect.ownKeys(target2),
-        ...Reflect.ownKeys(extra)
-      ]));
-    },
-    getOwnPropertyDescriptor(target2, prop) {
-      if (prop in extra) {
-        return {
-          configurable: true,
-          enumerable: true,
-          writable: false,
-          value: extra[prop]
-        };
-      }
-      return Reflect.getOwnPropertyDescriptor(target2, prop);
-    }
-  });
-}
-function createBaseEvent(type, env, ctx, options = {}) {
-  const shell = prepareEventShell(env, { locals: options.locals });
-  return {
-    type,
-    ctx,
-    ...shell,
-    request: options.request ?? null,
-    params: options.params
-  };
-}
-function createFetchEvent(request, env, ctx, options = {}) {
-  const shell = prepareEventShell(env, { locals: options.locals });
-  return createAugmentedTarget(request, {
-    type: "fetch",
-    ctx,
-    ...shell,
-    url: new URL(request.url),
-    request,
-    params: options.params ?? {}
-  });
-}
-function createQueueEvent(batch, env, ctx, options = {}) {
-  const shell = prepareEventShell(env, { locals: options.locals });
-  return createAugmentedTarget(batch, {
-    type: "queue",
-    ctx,
-    ...shell,
-    batch
-  });
-}
-function createScheduledEvent(controller, env, ctx, options = {}) {
-  const shell = prepareEventShell(env, { locals: options.locals });
-  return createAugmentedTarget(controller, {
-    type: "scheduled",
-    ctx,
-    ...shell,
-    controller
-  });
-}
-function createEmailEvent(message, env, ctx, options = {}) {
-  const shell = prepareEventShell(env, { locals: options.locals });
-  return createAugmentedTarget(message, {
-    type: "email",
-    ctx,
-    ...shell,
-    message
-  });
-}
-function createTailEvent(events, env, ctx, options = {}) {
-  const shell = prepareEventShell(env, { locals: options.locals });
-  return createAugmentedTarget(events, {
-    type: "tail",
-    ctx,
-    ...shell,
-    events
-  });
-}
-function createDurableObjectFetchEvent(request, env, state, options = {}) {
-  const shell = prepareEventShell(env, { locals: options.locals });
-  return createAugmentedTarget(request, {
-    type: "durable-object-fetch",
-    ctx: state,
-    state,
-    ...shell,
-    request
-  });
-}
-function createDurableObjectAlarmEvent(env, state, options = {}) {
-  const shell = prepareEventShell(env, { locals: options.locals });
-  return {
-    type: "durable-object-alarm",
-    ctx: state,
-    state,
-    ...shell
-  };
-}
-function createDurableObjectWebSocketMessageEvent(ws, message, env, state, options = {}) {
-  const shell = prepareEventShell(env, { locals: options.locals });
-  return createAugmentedTarget(ws, {
-    type: "durable-object-websocket-message",
-    ctx: state,
-    state,
-    ...shell,
-    ws,
-    message
-  });
-}
-function createDurableObjectWebSocketCloseEvent(ws, code, reason, wasClean, env, state, options = {}) {
-  const shell = prepareEventShell(env, { locals: options.locals });
-  return createAugmentedTarget(ws, {
-    type: "durable-object-websocket-close",
-    ctx: state,
-    state,
-    ...shell,
-    ws,
-    code,
-    reason,
-    wasClean
-  });
-}
-function createDurableObjectWebSocketErrorEvent(ws, error, env, state, options = {}) {
-  const shell = prepareEventShell(env, { locals: options.locals });
-  return createAugmentedTarget(ws, {
-    type: "durable-object-websocket-error",
-    ctx: state,
-    state,
-    ...shell,
-    ws,
-    error
-  });
-}
-function createDefaultEvent(env, ctx, request, type, locals) {
-  switch (type) {
-    case "fetch": {
-      if (request && ctx) {
-        return createFetchEvent(request, env, ctx, { locals });
-      }
-      return createBaseEvent(type, env, ctx, { locals, request });
-    }
-    case "durable-object-fetch": {
-      if (request && ctx) {
-        return createDurableObjectFetchEvent(request, env, ctx, { locals });
-      }
-      return createBaseEvent(type, env, ctx, { locals, request });
-    }
-    case "durable-object-alarm": {
-      if (ctx) {
-        return createDurableObjectAlarmEvent(env, ctx, { locals });
-      }
-      return createBaseEvent(type, env, ctx, { locals });
-    }
-    case "queue":
-    case "scheduled":
-    case "email":
-    case "tail":
-    case "durable-object-websocket-message":
-    case "durable-object-websocket-close":
-    case "durable-object-websocket-error":
-      return createBaseEvent(type, env, ctx, { locals, request });
-    default: {
-      const exhaustive = type;
-      throw new Error(`createDefaultEvent: unknown event type ${String(exhaustive)}`);
-    }
-  }
-}
-
-// src/runtime/context.ts
-import { AsyncLocalStorage } from "node:async_hooks";
-var storage = new AsyncLocalStorage;
-function createLocals2() {
-  return {};
-}
-function runWithContext(env, ctx, request, fn, type = "fetch") {
-  const locals = createLocals2();
-  const event = createDefaultEvent(env, ctx, request, type, locals);
-  return runWithEventContext(event, fn);
-}
-function runWithEventContext(event, fn) {
-  const context = {
-    env: event.env,
-    ctx: event.ctx,
-    request: event.request ?? null,
-    locals: event.locals,
-    type: event.type,
-    event
-  };
-  return storage.run(context, fn);
-}
-function getContext() {
-  const context = storage.getStore();
-  if (!context) {
-    throw ContextAccessError.contextUnavailable();
-  }
-  return context;
-}
-function getContextOrNull() {
-  const context = storage.getStore();
-  return context ?? null;
-}
-function getEventContext() {
-  return getContext().event;
-}
-function getEventContextOrNull() {
-  return getContextOrNull()?.event ?? null;
-}
-function hasContext() {
-  return storage.getStore() !== undefined;
-}
-function createEventAccessor(name, matcher) {
-  const accessor = () => {
-    const currentEvent = getEventContextOrNull();
-    if (!currentEvent) {
-      throw ContextAccessError.contextUnavailable();
-    }
-    if (!matcher(currentEvent)) {
-      throw ContextAccessError.contextUnavailable(`${name} is not available in the current '${currentEvent.type}' context.
-
-Devflare stores event objects in AsyncLocalStorage so helpers called within a handler can reach the active event.
-Use ${name}.safe() to return null instead of throwing, or call the getter that matches the active surface.`);
-    }
-    return currentEvent;
-  };
-  accessor.safe = () => {
-    const currentEvent = getEventContextOrNull();
-    return currentEvent && matcher(currentEvent) ? currentEvent : null;
-  };
-  return accessor;
-}
-function isFetchEvent(event) {
-  return event.type === "fetch" && event.request instanceof Request;
-}
-function isQueueEvent(event) {
-  return event.type === "queue" && "batch" in event;
-}
-function isScheduledEvent(event) {
-  return event.type === "scheduled" && "controller" in event;
-}
-function isEmailEvent(event) {
-  return event.type === "email" && "message" in event;
-}
-function isTailEvent(event) {
-  return event.type === "tail" && Array.isArray(event) && "events" in event;
-}
-function isDurableObjectEvent(event) {
-  return event.type.startsWith("durable-object-") && "state" in event;
-}
-function isDurableObjectFetchEvent(event) {
-  return event.type === "durable-object-fetch" && event.request instanceof Request;
-}
-function isDurableObjectAlarmEvent(event) {
-  return event.type === "durable-object-alarm" && "state" in event;
-}
-function isDurableObjectWebSocketMessageEvent(event) {
-  return event.type === "durable-object-websocket-message" && "ws" in event && "message" in event;
-}
-function isDurableObjectWebSocketCloseEvent(event) {
-  return event.type === "durable-object-websocket-close" && "ws" in event && "code" in event;
-}
-function isDurableObjectWebSocketErrorEvent(event) {
-  return event.type === "durable-object-websocket-error" && "ws" in event && "error" in event;
-}
-var getFetchEvent = createEventAccessor("getFetchEvent()", isFetchEvent);
-var getQueueEvent = createEventAccessor("getQueueEvent()", isQueueEvent);
-var getScheduledEvent = createEventAccessor("getScheduledEvent()", isScheduledEvent);
-var getEmailEvent = createEventAccessor("getEmailEvent()", isEmailEvent);
-var getTailEvent = createEventAccessor("getTailEvent()", isTailEvent);
-var getDurableObjectEvent = createEventAccessor("getDurableObjectEvent()", isDurableObjectEvent);
-var getDurableObjectFetchEvent = createEventAccessor("getDurableObjectFetchEvent()", isDurableObjectFetchEvent);
-var getDurableObjectAlarmEvent = createEventAccessor("getDurableObjectAlarmEvent()", isDurableObjectAlarmEvent);
-var getDurableObjectWebSocketMessageEvent = createEventAccessor("getDurableObjectWebSocketMessageEvent()", isDurableObjectWebSocketMessageEvent);
-var getDurableObjectWebSocketCloseEvent = createEventAccessor("getDurableObjectWebSocketCloseEvent()", isDurableObjectWebSocketCloseEvent);
-var getDurableObjectWebSocketErrorEvent = createEventAccessor("getDurableObjectWebSocketErrorEvent()", isDurableObjectWebSocketErrorEvent);
+// src/bridge/log.ts
+var isDebugEnabled = () => {
+  try {
+    const env = globalThis.process?.env;
+    return Boolean(env?.DEVFLARE_DEBUG_BRIDGE);
+  } catch {
+    return false;
+  }
+};
+var bridgeLog = {
+  warn(message, error) {
+    if (!isDebugEnabled())
+      return;
+    console.warn(`[devflare:bridge] ${message}`, error);
+  },
+  debug(message, error) {
+    if (!isDebugEnabled())
+      return;
+    console.debug(`[devflare:bridge] ${message}`, error);
+  }
+};
 
-// src/bridge/v2/wire.ts
-var BinaryKind = {
+// src/bridge/v2/frames.ts
+var TRANSPORT_V2_PROTOCOL_VERSION = 2;
+var TRANSPORT_V2_UNSUPPORTED_VERSION_CLOSE_CODE = 4001;
+var TransportV2BinaryKind = {
   StreamChunk: 1,
-  WsData: 2
+  WsData: 2,
+  BodyChunk: 3
 };
-var BinaryFlags = {
+var TransportV2BinaryFlags = {
   FIN: 1,
-  TEXT: 2
+  TEXT: 2,
+  ABORT: 4
 };
-var BINARY_HEADER_SIZE = 10;
-function encodeBinaryFrame(kind, id, seq, flags, payload) {
-  const frame = new Uint8Array(BINARY_HEADER_SIZE + payload.byteLength);
-  const view = new DataView(frame.buffer);
-  view.setUint8(0, kind);
-  view.setUint32(1, id, true);
-  view.setUint32(5, seq, true);
-  view.setUint8(9, flags);
-  frame.set(payload, BINARY_HEADER_SIZE);
-  return frame;
+var TRANSPORT_V2_BINARY_HEADER_SIZE = 10;
+function decodeTransportV2BinaryFrame(frame) {
+  if (frame.byteLength < TRANSPORT_V2_BINARY_HEADER_SIZE) {
+    throw new Error(`Invalid transport v2 binary frame: too short (${frame.byteLength} bytes, need at least ${TRANSPORT_V2_BINARY_HEADER_SIZE})`);
+  }
+  const view = new DataView(frame.buffer, frame.byteOffset, frame.byteLength);
+  const kind = view.getUint8(0);
+  if (kind !== TransportV2BinaryKind.StreamChunk && kind !== TransportV2BinaryKind.WsData && kind !== TransportV2BinaryKind.BodyChunk) {
+    throw new Error(`Invalid transport v2 binary frame: unknown kind ${kind}`);
+  }
+  return {
+    kind,
+    id: view.getUint32(1, true),
+    seq: view.getUint32(5, true),
+    flags: view.getUint8(9),
+    payload: frame.subarray(TRANSPORT_V2_BINARY_HEADER_SIZE)
+  };
 }
-function parseJsonMsg(data) {
+function transportV2IsFin(flags) {
+  return (flags & TransportV2BinaryFlags.FIN) !== 0;
+}
+function transportV2IsAbort(flags) {
+  return (flags & TransportV2BinaryFlags.ABORT) !== 0;
+}
+var KNOWN_V2_CONTROL_TYPES = new Set(["hello", "welcome", "body.open", "body.end", "body.abort"]);
+function parseTransportV2ControlMsg(data) {
   const msg = JSON.parse(data);
   if (typeof msg !== "object" || msg === null || !("t" in msg)) {
-    throw new Error("Invalid message: missing type field");
+    throw new Error("Invalid transport v2 control message: missing type field");
+  }
+  if (!KNOWN_V2_CONTROL_TYPES.has(msg.t)) {
+    throw new Error(`Invalid transport v2 control message: unknown type "${msg.t}"`);
+  }
+  if (msg.t === "hello" || msg.t === "welcome") {
+    if (msg.protocolVersion !== TRANSPORT_V2_PROTOCOL_VERSION) {
+      throw new Error(`Invalid transport v2 ${msg.t}: protocolVersion ${msg.protocolVersion} != ${TRANSPORT_V2_PROTOCOL_VERSION}`);
+    }
+    if (!Array.isArray(msg.capabilities)) {
+      throw new Error(`Invalid transport v2 ${msg.t}: capabilities must be an array`);
+    }
   }
   return msg;
 }
-function stringifyJsonMsg(msg) {
+function stringifyTransportV2ControlMsg(msg) {
   return JSON.stringify(msg);
 }
-var streamIdCounter = 0;
-var wsIdCounter = 0;
-function nextStreamId() {
-  return ++streamIdCounter;
-}
-function nextWsId() {
-  return ++wsIdCounter;
+function negotiateTransportV2Capabilities(supported, advertised) {
+  const supportedSet = new Set(supported);
+  const intersection = advertised.filter((cap) => supportedSet.has(cap));
+  return [...new Set(intersection)].sort();
 }
-var DEFAULT_CHUNK_SIZE = 256 * 1024;
-var HTTP_TRANSFER_THRESHOLD = 512 * 1024;
-var DEFAULT_BRIDGE_PORT = 8686;
 
-// src/bridge/v2/value-serialization.ts
-async function serializeRequest(request, options) {
-  const streams = [];
-  const threshold = options?.httpThreshold ?? HTTP_TRANSFER_THRESHOLD;
-  const headers = [];
-  request.headers.forEach((value, key) => {
-    headers.push([key, value]);
-  });
-  let body = null;
-  if (request.body) {
-    const bytes = await request.arrayBuffer();
-    if (bytes.byteLength > threshold) {
-      throw new Error("Request body exceeds the bridge inline limit (~512 KB) and large request-body streaming is not yet supported over the local bridge. " + "Send the payload in smaller chunks or via an R2 binding for now.");
-    } else if (bytes.byteLength > 0) {
-      body = { type: "bytes", data: base64Encode(new Uint8Array(bytes)) };
-    }
+// src/bridge/v2/body-streams.ts
+var TRANSPORT_V2_DEFAULT_BODY_CHUNK_SIZE = 256 * 1024;
+class TransportV2BodyReaderRegistry {
+  #streams = new Map;
+  getOrOpen(bid) {
+    const existing = this.#streams.get(bid);
+    if (existing !== undefined)
+      return existing.stream;
+    return this.open(bid);
   }
-  return {
-    serialized: {
-      url: request.url,
-      method: request.method,
-      headers,
-      body,
-      redirect: request.redirect
-    },
-    streams
-  };
-}
-function deserializeRequest(serialized, getStream) {
-  let body = null;
-  if (serialized.body) {
-    switch (serialized.body.type) {
-      case "bytes":
-        body = base64Decode(serialized.body.data);
-        break;
-      case "stream":
-        if (getStream) {
-          body = getStream(serialized.body.sid) ?? null;
-        }
-        break;
+  open(bid) {
+    if (this.#streams.has(bid)) {
+      throw new Error(`v2 body reader already registered for bid ${bid}`);
     }
+    const state = {
+      controller: null,
+      stream: null,
+      closed: false
+    };
+    state.stream = new ReadableStream({
+      start: (controller) => {
+        state.controller = controller;
+      },
+      cancel: () => {
+        state.closed = true;
+        this.#streams.delete(bid);
+      }
+    });
+    this.#streams.set(bid, state);
+    return state.stream;
   }
-  return new Request(serialized.url, {
-    method: serialized.method,
-    headers: serialized.headers,
-    body,
-    redirect: serialized.redirect
-  });
-}
-async function serializeResponse(response, options) {
-  const streams = [];
-  const threshold = options?.httpThreshold ?? HTTP_TRANSFER_THRESHOLD;
-  const headers = [];
-  response.headers.forEach((value, key) => {
-    headers.push([key, value]);
-  });
-  let body = null;
-  if (response.body) {
-    const bytes = await response.arrayBuffer();
-    if (bytes.byteLength > threshold) {
-      const sid = nextStreamId();
-      const payload = new Uint8Array(bytes);
-      const frameSize = HTTP_TRANSFER_THRESHOLD;
-      const stream = new ReadableStream({
-        start(controller) {
-          for (let offset = 0;offset < payload.byteLength; offset += frameSize) {
-            controller.enqueue(payload.slice(offset, Math.min(offset + frameSize, payload.byteLength)));
-          }
-          controller.close();
-        }
-      });
-      streams.push({ sid, stream });
-      body = { type: "stream", sid };
-    } else if (bytes.byteLength > 0) {
-      body = { type: "bytes", data: base64Encode(new Uint8Array(bytes)) };
+  pushChunk(frame) {
+    if (frame.kind !== TransportV2BinaryKind.BodyChunk) {
+      throw new Error(`v2 body reader received non-BodyChunk frame (kind=${frame.kind})`);
     }
-  }
-  return {
-    serialized: {
-      status: response.status,
-      statusText: response.statusText,
-      headers,
-      body
-    },
-    streams
-  };
-}
-function deserializeResponse(serialized, getStream) {
-  let body = null;
-  if (serialized.body) {
-    switch (serialized.body.type) {
-      case "bytes":
-        body = base64Decode(serialized.body.data);
-        break;
-      case "stream":
-        if (getStream) {
-          body = getStream(serialized.body.sid) ?? null;
-        }
-        break;
+    const state = this.#streams.get(frame.id);
+    if (state === undefined || state.closed)
+      return;
+    const isFin = transportV2IsFin(frame.flags);
+    const isAbort = transportV2IsAbort(frame.flags);
+    if (isAbort) {
+      state.closed = true;
+      state.controller?.error(new Error(`v2 body stream ${frame.id} aborted by writer`));
+      this.#streams.delete(frame.id);
+      return;
+    }
+    if (frame.payload.byteLength > 0) {
+      state.controller?.enqueue(new Uint8Array(frame.payload));
+    }
+    if (isFin) {
+      state.closed = true;
+      state.controller?.close();
+      this.#streams.delete(frame.id);
     }
   }
-  return new Response(body, {
-    status: serialized.status,
-    statusText: serialized.statusText,
-    headers: serialized.headers
-  });
-}
-async function serializeValue(value, options) {
-  const streams = [];
-  const result = await serializeValueInternal(value, streams, options);
-  return { value: result, streams };
-}
-async function serializeValueInternal(value, streams, options) {
-  if (value === null || value === undefined) {
-    return value;
+  end(bid) {
+    const state = this.#streams.get(bid);
+    if (state === undefined || state.closed)
+      return;
+    state.closed = true;
+    state.controller?.close();
+    this.#streams.delete(bid);
   }
-  if (value instanceof Request) {
-    const { serialized, streams: reqStreams } = await serializeRequest(value, options);
-    streams.push(...reqStreams);
-    return { __type: "Request", ...serialized };
+  abort(bid, reason) {
+    const state = this.#streams.get(bid);
+    if (state === undefined || state.closed)
+      return;
+    state.closed = true;
+    state.controller?.error(new Error(reason ?? `v2 body stream ${bid} aborted`));
+    this.#streams.delete(bid);
   }
-  if (value instanceof Response) {
-    const { serialized, streams: resStreams } = await serializeResponse(value, options);
-    streams.push(...resStreams);
-    return { __type: "Response", ...serialized };
+  get size() {
+    return this.#streams.size;
   }
-  if (value instanceof ReadableStream) {
-    const sid = nextStreamId();
-    streams.push({ sid, stream: value });
-    return { __type: "ReadableStream", sid };
+}
+
+// src/bridge/v2/codec.ts
+class TransportV2Codec {
+  bodyReaders = new TransportV2BodyReaderRegistry;
+  #socket;
+  #capabilities;
+  #options;
+  #handshakeResolver = null;
+  #handshakePromise;
+  #sentHello = false;
+  #receivedHello = false;
+  #receivedWelcome = false;
+  #negotiated = null;
+  #pendingRpc = new Map;
+  #nextBid = 1;
+  #nextRpcId = 1;
+  #closed = false;
+  constructor(socket, options = {}) {
+    this.#socket = socket;
+    this.#capabilities = options.capabilities ?? [];
+    this.#options = options;
+    this.#handshakePromise = new Promise((resolve, reject) => {
+      this.#handshakeResolver = { resolve, reject };
+    });
+    socket.onmessage = (event) => this.#onMessage(event);
+    socket.onclose = () => this.#onClose();
+    socket.onerror = (event) => this.#onError(event.error);
   }
-  if (value instanceof Uint8Array) {
-    return { __type: "Uint8Array", data: base64Encode(value) };
+  allocateBid() {
+    return this.#nextBid++;
   }
-  if (value instanceof ArrayBuffer) {
-    return { __type: "ArrayBuffer", data: base64Encode(new Uint8Array(value)) };
+  allocateRpcId() {
+    return `v2_rpc_${this.#nextRpcId++}`;
   }
-  if (value instanceof Date) {
-    return { __devflare: "date", iso: value.toISOString() };
+  sendHello() {
+    if (this.#sentHello)
+      return;
+    this.#sentHello = true;
+    const hello = {
+      t: "hello",
+      protocolVersion: TRANSPORT_V2_PROTOCOL_VERSION,
+      capabilities: [...this.#capabilities]
+    };
+    this.#socket.send(stringifyTransportV2ControlMsg(hello));
   }
-  if (value instanceof URL) {
-    return { __devflare: "url", href: value.href };
+  get handshake() {
+    return this.#handshakePromise;
   }
-  if (value instanceof Error) {
-    const encoded = {
-      __devflare: "error",
-      name: value.name,
-      message: value.message
-    };
-    if (value.stack)
-      encoded.stack = value.stack;
-    return encoded;
+  get negotiated() {
+    return this.#negotiated;
   }
-  if (value instanceof Map) {
-    const entries = [];
-    for (const [k, v] of value.entries()) {
-      entries.push([
-        await serializeValueInternal(k, streams, options),
-        await serializeValueInternal(v, streams, options)
-      ]);
+  sendText(message) {
+    if (this.#closed) {
+      throw new Error("cannot send on a closed v2 codec");
     }
-    return { __devflare: "map", entries };
+    this.#socket.send(message);
   }
-  if (value instanceof Set) {
-    const values = [];
-    for (const v of value.values()) {
-      values.push(await serializeValueInternal(v, streams, options));
+  sendBinary(frame) {
+    if (this.#closed) {
+      throw new Error("cannot send on a closed v2 codec");
     }
-    return { __devflare: "set", values };
+    this.#socket.send(frame);
   }
-  if (Array.isArray(value)) {
-    return Promise.all(value.map((v) => serializeValueInternal(v, streams, options)));
+  call(method, params = []) {
+    const id = this.allocateRpcId();
+    const call = { t: "rpc.call", id, method, params };
+    const promise = new Promise((resolve, reject) => {
+      this.#pendingRpc.set(id, { resolve, reject });
+    });
+    this.sendText(JSON.stringify(call));
+    return promise;
   }
-  if (typeof value === "object") {
-    const result = {};
-    for (const [k, v] of Object.entries(value)) {
-      result[k] = await serializeValueInternal(v, streams, options);
-    }
-    return result;
+  respondOk(id, result) {
+    const reply = { t: "rpc.ok", id, result };
+    this.sendText(JSON.stringify(reply));
   }
-  return value;
-}
-function deserializeValue(value, getStream) {
-  if (value === null || value === undefined) {
-    return value;
+  respondErr(id, error) {
+    const reply = { t: "rpc.err", id, error };
+    this.sendText(JSON.stringify(reply));
   }
-  if (typeof value === "object" && value !== null) {
-    const obj = value;
-    if (typeof obj.__devflare === "string") {
-      switch (obj.__devflare) {
-        case "date":
-          return new Date(obj.iso);
-        case "url":
-          return new URL(obj.href);
-        case "error": {
-          const err = new Error(obj.message);
-          if (typeof obj.name === "string")
-            err.name = obj.name;
-          if (typeof obj.stack === "string")
-            err.stack = obj.stack;
-          return err;
-        }
-        case "map": {
-          const entries = obj.entries ?? [];
-          const map = new Map;
-          for (const [k, v] of entries) {
-            map.set(deserializeValue(k, getStream), deserializeValue(v, getStream));
-          }
-          return map;
-        }
-        case "set": {
-          const values = obj.values ?? [];
-          const set = new Set;
-          for (const v of values) {
-            set.add(deserializeValue(v, getStream));
-          }
-          return set;
-        }
-      }
-    }
-    if (obj.__type === "Request") {
-      return deserializeRequest(obj, getStream);
-    }
-    if (obj.__type === "Response") {
-      return deserializeResponse(obj, getStream);
-    }
-    if (obj.__type === "ReadableStream") {
-      const sid = obj.sid;
-      return getStream?.(sid) ?? null;
-    }
-    if (obj.__type === "Uint8Array") {
-      return base64Decode(obj.data);
-    }
-    if (obj.__type === "ArrayBuffer") {
-      return base64Decode(obj.data).buffer;
+  sendWireError(err) {
+    const frame = { t: "error", ...err };
+    this.sendText(JSON.stringify(frame));
+  }
+  openBodyReader(bid) {
+    return this.bodyReaders.getOrOpen(bid);
+  }
+  setRpcCallHandler(handler) {
+    this.#options = { ...this.#options, onRpcCall: handler };
+  }
+  close(code, reason) {
+    if (this.#closed)
+      return;
+    this.#closed = true;
+    this.#failPending(new Error("v2 transport closed"));
+    this.#socket.close(code, reason);
+  }
+  get isClosed() {
+    return this.#closed;
+  }
+  #onMessage(event) {
+    const { data } = event;
+    if (typeof data === "string") {
+      this.#onText(data);
+    } else if (data instanceof Uint8Array) {
+      this.#onBinary(data);
+    } else if (data instanceof ArrayBuffer) {
+      this.#onBinary(new Uint8Array(data));
     }
-    if (obj.__type === "R2Object") {
-      return deserializeR2Object(obj);
+  }
+  #onText(data) {
+    let msg;
+    try {
+      msg = parseTransportV2ControlMsg(data);
+    } catch {
+      const rpc = tryParseRpcMsg(data);
+      if (rpc !== null) {
+        this.#onRpcMessage(rpc);
+        return;
+      }
+      const wireErr = tryParseWireError(data);
+      if (wireErr !== null) {
+        this.#options.onWireError?.(wireErr);
+        return;
+      }
+      this.#options.onUnknownControl?.(data);
+      return;
     }
-    if (obj.__type === "R2ObjectBody") {
-      return deserializeR2ObjectBody(obj);
+    switch (msg.t) {
+      case "hello":
+        this.#onHello(msg);
+        break;
+      case "welcome":
+        this.#onWelcome(msg);
+        break;
+      case "body.open":
+        this.bodyReaders.getOrOpen(msg.bid);
+        break;
+      case "body.end":
+        this.bodyReaders.end(msg.bid);
+        break;
+      case "body.abort":
+        this.bodyReaders.abort(msg.bid, msg.error);
+        break;
     }
-    if (Array.isArray(value)) {
-      return value.map((v) => deserializeValue(v, getStream));
+  }
+  #onBinary(data) {
+    let frame;
+    try {
+      frame = decodeTransportV2BinaryFrame(data);
+    } catch {
+      return;
     }
-    const result = {};
-    for (const [k, v] of Object.entries(obj)) {
-      result[k] = deserializeValue(v, getStream);
+    if (frame.kind === TransportV2BinaryKind.BodyChunk) {
+      this.bodyReaders.pushChunk(frame);
+      return;
     }
-    return result;
+    this.#options.onUnknownBinary?.(frame);
   }
-  return value;
-}
-function applySerializedHttpMetadata(headers, httpMetadata) {
-  if (httpMetadata?.contentType) {
-    headers.set("Content-Type", httpMetadata.contentType);
+  #onRpcMessage(msg) {
+    switch (msg.t) {
+      case "rpc.call":
+        this.#options.onRpcCall?.(msg);
+        break;
+      case "rpc.ok": {
+        const pending = this.#pendingRpc.get(msg.id);
+        if (pending !== undefined) {
+          this.#pendingRpc.delete(msg.id);
+          pending.resolve(msg.result);
+        }
+        break;
+      }
+      case "rpc.err": {
+        const pending = this.#pendingRpc.get(msg.id);
+        if (pending !== undefined) {
+          this.#pendingRpc.delete(msg.id);
+          const err = new Error(msg.error.message);
+          Object.assign(err, { code: msg.error.code, details: msg.error.details });
+          pending.reject(err);
+        }
+        break;
+      }
+    }
   }
-  if (httpMetadata?.contentLanguage) {
-    headers.set("Content-Language", httpMetadata.contentLanguage);
+  #onHello(msg) {
+    if (this.#receivedHello) {
+      this.close(TRANSPORT_V2_UNSUPPORTED_VERSION_CLOSE_CODE, "duplicate hello");
+      return;
+    }
+    this.#receivedHello = true;
+    const negotiated = negotiateTransportV2Capabilities(this.#capabilities, msg.capabilities);
+    const welcome = {
+      t: "welcome",
+      protocolVersion: TRANSPORT_V2_PROTOCOL_VERSION,
+      capabilities: negotiated
+    };
+    this.#socket.send(stringifyTransportV2ControlMsg(welcome));
+    this.#completeHandshake({
+      protocolVersion: TRANSPORT_V2_PROTOCOL_VERSION,
+      capabilities: negotiated
+    });
   }
-  if (httpMetadata?.contentDisposition) {
-    headers.set("Content-Disposition", httpMetadata.contentDisposition);
+  #onWelcome(msg) {
+    if (this.#receivedWelcome)
+      return;
+    this.#receivedWelcome = true;
+    this.#completeHandshake({
+      protocolVersion: TRANSPORT_V2_PROTOCOL_VERSION,
+      capabilities: msg.capabilities
+    });
   }
-  if (httpMetadata?.contentEncoding) {
-    headers.set("Content-Encoding", httpMetadata.contentEncoding);
+  #completeHandshake(result) {
+    if (this.#negotiated !== null)
+      return;
+    this.#negotiated = result;
+    this.#handshakeResolver?.resolve(result);
+    this.#handshakeResolver = null;
   }
-  if (httpMetadata?.cacheControl) {
-    headers.set("Cache-Control", httpMetadata.cacheControl);
+  #onClose() {
+    if (this.#closed) {
+      return;
+    }
+    this.#closed = true;
+    this.#failPending(new Error("v2 transport closed"));
   }
-  if (httpMetadata?.cacheExpiry) {
-    headers.set("Expires", new Date(httpMetadata.cacheExpiry).toUTCString());
+  #onError(error) {
+    const wrapped = error instanceof Error ? error : new Error(String(error));
+    this.#failPending(wrapped);
   }
-}
-function createSerializedR2Metadata(serialized) {
-  return {
-    key: serialized.key,
-    version: serialized.version,
-    size: serialized.size,
-    etag: serialized.etag,
-    httpEtag: serialized.httpEtag,
-    checksums: serialized.checksums,
-    uploaded: serialized.uploaded ? new Date(serialized.uploaded) : new Date,
-    httpMetadata: serialized.httpMetadata,
-    customMetadata: serialized.customMetadata,
-    range: serialized.range,
-    storageClass: serialized.storageClass,
-    writeHttpMetadata(headers) {
-      applySerializedHttpMetadata(headers, serialized.httpMetadata);
+  #failPending(error) {
+    const resolver = this.#handshakeResolver;
+    if (resolver !== null) {
+      this.#handshakeResolver = null;
+      resolver.reject(error);
     }
-  };
-}
-function deserializeR2Object(obj) {
-  const serialized = obj;
-  return {
-    ...createSerializedR2Metadata(serialized)
-  };
-}
-function deserializeR2ObjectBody(obj) {
-  const serialized = obj;
-  const bodyBytes = serialized.bodyData ? base64Decode(serialized.bodyData) : new Uint8Array(0);
-  const r2ObjectBody = {
-    ...createSerializedR2Metadata(serialized),
-    body: new ReadableStream({
-      start(controller) {
-        controller.enqueue(bodyBytes);
-        controller.close();
-      }
-    }),
-    bodyUsed: false,
-    async arrayBuffer() {
-      const copy = new Uint8Array(bodyBytes.byteLength);
-      copy.set(bodyBytes);
-      return copy.buffer;
-    },
-    async text() {
-      return new TextDecoder().decode(bodyBytes);
-    },
-    async json() {
-      const text = new TextDecoder().decode(bodyBytes);
-      return JSON.parse(text);
-    },
-    async blob() {
-      const contentType = serialized.httpMetadata?.contentType || "application/octet-stream";
-      const buffer = bodyBytes.buffer.slice(bodyBytes.byteOffset, bodyBytes.byteOffset + bodyBytes.byteLength);
-      return new Blob([buffer], { type: contentType });
+    for (const pending of this.#pendingRpc.values()) {
+      pending.reject(error);
     }
-  };
-  return r2ObjectBody;
+    this.#pendingRpc.clear();
+  }
 }
-function base64Encode(bytes) {
-  if (typeof Buffer !== "undefined") {
-    return Buffer.from(bytes).toString("base64");
+function tryParseRpcMsg(data) {
+  let parsed;
+  try {
+    parsed = JSON.parse(data);
+  } catch {
+    return null;
   }
-  let binary = "";
-  for (let i = 0;i < bytes.byteLength; i++) {
-    binary += String.fromCharCode(bytes[i]);
+  if (typeof parsed !== "object" || parsed === null || !("t" in parsed))
+    return null;
+  const t = parsed.t;
+  if (t === "rpc.call" || t === "rpc.ok" || t === "rpc.err") {
+    return parsed;
   }
-  return btoa(binary);
+  return null;
 }
-function base64Decode(str) {
-  if (typeof Buffer !== "undefined") {
-    return new Uint8Array(Buffer.from(str, "base64"));
-  }
-  const binary = atob(str);
-  const bytes = new Uint8Array(binary.length);
-  for (let i = 0;i < binary.length; i++) {
-    bytes[i] = binary.charCodeAt(i);
+function tryParseWireError(data) {
+  let parsed;
+  try {
+    parsed = JSON.parse(data);
+  } catch {
+    return null;
   }
-  return bytes;
+  if (typeof parsed !== "object" || parsed === null || !("t" in parsed))
+    return null;
+  const candidate = parsed;
+  if (candidate.t !== "error")
+    return null;
+  const scope = candidate.scope;
+  if (scope !== "transport" && scope !== "rpc" && scope !== "stream" && scope !== "ws")
+    return null;
+  const err = candidate.error;
+  if (!err || typeof err.code !== "string" || typeof err.message !== "string")
+    return null;
+  return parsed;
 }
 
-// src/bridge/v2/frames.ts
-var TRANSPORT_V2_PROTOCOL_VERSION = 2;
-var TRANSPORT_V2_UNSUPPORTED_VERSION_CLOSE_CODE = 4001;
-var TransportV2BinaryKind = {
+// src/bridge/v2/wire.ts
+var BinaryKind = {
   StreamChunk: 1,
-  WsData: 2,
-  BodyChunk: 3
+  WsData: 2
 };
-var TransportV2BinaryFlags = {
+var BinaryFlags = {
   FIN: 1,
-  TEXT: 2,
-  ABORT: 4
-};
-var TRANSPORT_V2_BINARY_HEADER_SIZE = 10;
-function decodeTransportV2BinaryFrame(frame) {
-  if (frame.byteLength < TRANSPORT_V2_BINARY_HEADER_SIZE) {
-    throw new Error(`Invalid transport v2 binary frame: too short (${frame.byteLength} bytes, need at least ${TRANSPORT_V2_BINARY_HEADER_SIZE})`);
-  }
-  const view = new DataView(frame.buffer, frame.byteOffset, frame.byteLength);
-  const kind = view.getUint8(0);
-  if (kind !== TransportV2BinaryKind.StreamChunk && kind !== TransportV2BinaryKind.WsData && kind !== TransportV2BinaryKind.BodyChunk) {
-    throw new Error(`Invalid transport v2 binary frame: unknown kind ${kind}`);
-  }
-  return {
-    kind,
-    id: view.getUint32(1, true),
-    seq: view.getUint32(5, true),
-    flags: view.getUint8(9),
-    payload: frame.subarray(TRANSPORT_V2_BINARY_HEADER_SIZE)
-  };
-}
-function transportV2IsFin(flags) {
-  return (flags & TransportV2BinaryFlags.FIN) !== 0;
-}
-function transportV2IsAbort(flags) {
-  return (flags & TransportV2BinaryFlags.ABORT) !== 0;
+  TEXT: 2
+};
+var BINARY_HEADER_SIZE = 10;
+function encodeBinaryFrame(kind, id, seq, flags, payload) {
+  const frame = new Uint8Array(BINARY_HEADER_SIZE + payload.byteLength);
+  const view = new DataView(frame.buffer);
+  view.setUint8(0, kind);
+  view.setUint32(1, id, true);
+  view.setUint32(5, seq, true);
+  view.setUint8(9, flags);
+  frame.set(payload, BINARY_HEADER_SIZE);
+  return frame;
 }
-var KNOWN_V2_CONTROL_TYPES = new Set([
-  "hello",
-  "welcome",
-  "body.open",
-  "body.end",
-  "body.abort"
-]);
-function parseTransportV2ControlMsg(data) {
+function parseJsonMsg(data) {
   const msg = JSON.parse(data);
   if (typeof msg !== "object" || msg === null || !("t" in msg)) {
-    throw new Error("Invalid transport v2 control message: missing type field");
-  }
-  if (!KNOWN_V2_CONTROL_TYPES.has(msg.t)) {
-    throw new Error(`Invalid transport v2 control message: unknown type "${msg.t}"`);
-  }
-  if (msg.t === "hello" || msg.t === "welcome") {
-    if (msg.protocolVersion !== TRANSPORT_V2_PROTOCOL_VERSION) {
-      throw new Error(`Invalid transport v2 ${msg.t}: protocolVersion ${msg.protocolVersion} != ${TRANSPORT_V2_PROTOCOL_VERSION}`);
-    }
-    if (!Array.isArray(msg.capabilities)) {
-      throw new Error(`Invalid transport v2 ${msg.t}: capabilities must be an array`);
-    }
+    throw new Error("Invalid message: missing type field");
   }
   return msg;
 }
-function stringifyTransportV2ControlMsg(msg) {
+function stringifyJsonMsg(msg) {
   return JSON.stringify(msg);
 }
-function negotiateTransportV2Capabilities(supported, advertised) {
-  const supportedSet = new Set(supported);
-  const intersection = advertised.filter((cap) => supportedSet.has(cap));
-  return [...new Set(intersection)].sort();
+var streamIdCounter = 0;
+var wsIdCounter = 0;
+function nextStreamId() {
+  return ++streamIdCounter;
 }
+function nextWsId() {
+  return ++wsIdCounter;
+}
+var DEFAULT_CHUNK_SIZE = 256 * 1024;
+var HTTP_TRANSFER_THRESHOLD = 512 * 1024;
+var DEFAULT_BRIDGE_PORT = 8686;
 
-// src/bridge/v2/body-streams.ts
-var TRANSPORT_V2_DEFAULT_BODY_CHUNK_SIZE = 256 * 1024;
-class TransportV2BodyReaderRegistry {
-  #streams = new Map;
-  getOrOpen(bid) {
-    const existing = this.#streams.get(bid);
-    if (existing !== undefined)
-      return existing.stream;
-    return this.open(bid);
-  }
-  open(bid) {
-    if (this.#streams.has(bid)) {
-      throw new Error(`v2 body reader already registered for bid ${bid}`);
-    }
-    const state = {
-      controller: null,
-      stream: null,
-      closed: false
-    };
-    state.stream = new ReadableStream({
-      start: (controller) => {
-        state.controller = controller;
-      },
-      cancel: () => {
-        state.closed = true;
-        this.#streams.delete(bid);
-      }
-    });
-    this.#streams.set(bid, state);
-    return state.stream;
-  }
-  pushChunk(frame) {
-    if (frame.kind !== TransportV2BinaryKind.BodyChunk) {
-      throw new Error(`v2 body reader received non-BodyChunk frame (kind=${frame.kind})`);
-    }
-    const state = this.#streams.get(frame.id);
-    if (state === undefined || state.closed)
-      return;
-    const isFin = transportV2IsFin(frame.flags);
-    const isAbort = transportV2IsAbort(frame.flags);
-    if (isAbort) {
-      state.closed = true;
-      state.controller?.error(new Error(`v2 body stream ${frame.id} aborted by writer`));
-      this.#streams.delete(frame.id);
-      return;
-    }
-    if (frame.payload.byteLength > 0) {
-      state.controller?.enqueue(new Uint8Array(frame.payload));
+// src/bridge/v2/value-serialization.ts
+async function serializeRequest(request, options) {
+  const streams = [];
+  const threshold = options?.httpThreshold ?? HTTP_TRANSFER_THRESHOLD;
+  const headers = [];
+  request.headers.forEach((value, key) => {
+    headers.push([key, value]);
+  });
+  let body = null;
+  if (request.body) {
+    const bytes = await request.arrayBuffer();
+    if (bytes.byteLength > threshold) {
+      throw new Error("Request body exceeds the bridge inline limit (~512 KB) and large request-body streaming is not yet supported over the local bridge. " + "Send the payload in smaller chunks or via an R2 binding for now.");
     }
-    if (isFin) {
-      state.closed = true;
-      state.controller?.close();
-      this.#streams.delete(frame.id);
+    if (bytes.byteLength > 0) {
+      body = { type: "bytes", data: base64Encode(new Uint8Array(bytes)) };
     }
   }
-  end(bid) {
-    const state = this.#streams.get(bid);
-    if (state === undefined || state.closed)
-      return;
-    state.closed = true;
-    state.controller?.close();
-    this.#streams.delete(bid);
-  }
-  abort(bid, reason) {
-    const state = this.#streams.get(bid);
-    if (state === undefined || state.closed)
-      return;
-    state.closed = true;
-    state.controller?.error(new Error(reason ?? `v2 body stream ${bid} aborted`));
-    this.#streams.delete(bid);
-  }
-  get size() {
-    return this.#streams.size;
-  }
+  return {
+    serialized: {
+      url: request.url,
+      method: request.method,
+      headers,
+      body,
+      redirect: request.redirect
+    },
+    streams
+  };
 }
-
-// src/bridge/v2/codec.ts
-class TransportV2Codec {
-  bodyReaders = new TransportV2BodyReaderRegistry;
-  #socket;
-  #capabilities;
-  #options;
-  #handshakeResolver = null;
-  #handshakePromise;
-  #sentHello = false;
-  #receivedHello = false;
-  #receivedWelcome = false;
-  #negotiated = null;
-  #pendingRpc = new Map;
-  #nextBid = 1;
-  #nextRpcId = 1;
-  #closed = false;
-  constructor(socket, options = {}) {
-    this.#socket = socket;
-    this.#capabilities = options.capabilities ?? [];
-    this.#options = options;
-    this.#handshakePromise = new Promise((resolve, reject) => {
-      this.#handshakeResolver = { resolve, reject };
-    });
-    socket.onmessage = (event) => this.#onMessage(event);
-    socket.onclose = () => this.#onClose();
-    socket.onerror = (event) => this.#onError(event.error);
-  }
-  allocateBid() {
-    return this.#nextBid++;
-  }
-  allocateRpcId() {
-    return `v2_rpc_${this.#nextRpcId++}`;
-  }
-  sendHello() {
-    if (this.#sentHello)
-      return;
-    this.#sentHello = true;
-    const hello = {
-      t: "hello",
-      protocolVersion: TRANSPORT_V2_PROTOCOL_VERSION,
-      capabilities: [...this.#capabilities]
-    };
-    this.#socket.send(stringifyTransportV2ControlMsg(hello));
-  }
-  get handshake() {
-    return this.#handshakePromise;
+function deserializeRequest(serialized, getStream) {
+  let body = null;
+  if (serialized.body) {
+    switch (serialized.body.type) {
+      case "bytes":
+        body = base64Decode(serialized.body.data);
+        break;
+      case "stream":
+        if (getStream) {
+          body = getStream(serialized.body.sid) ?? null;
+        }
+        break;
+    }
   }
-  get negotiated() {
-    return this.#negotiated;
+  return new Request(serialized.url, {
+    method: serialized.method,
+    headers: serialized.headers,
+    body,
+    redirect: serialized.redirect
+  });
+}
+async function serializeResponse(response, options) {
+  const streams = [];
+  const threshold = options?.httpThreshold ?? HTTP_TRANSFER_THRESHOLD;
+  const headers = [];
+  response.headers.forEach((value, key) => {
+    headers.push([key, value]);
+  });
+  let body = null;
+  if (response.body) {
+    const bytes = await response.arrayBuffer();
+    if (bytes.byteLength > threshold) {
+      const sid = nextStreamId();
+      const payload = new Uint8Array(bytes);
+      const frameSize = HTTP_TRANSFER_THRESHOLD;
+      const stream = new ReadableStream({
+        start(controller) {
+          for (let offset = 0;offset < payload.byteLength; offset += frameSize) {
+            controller.enqueue(payload.slice(offset, Math.min(offset + frameSize, payload.byteLength)));
+          }
+          controller.close();
+        }
+      });
+      streams.push({ sid, stream });
+      body = { type: "stream", sid };
+    } else if (bytes.byteLength > 0) {
+      body = { type: "bytes", data: base64Encode(new Uint8Array(bytes)) };
+    }
   }
-  sendText(message) {
-    if (this.#closed) {
-      throw new Error("cannot send on a closed v2 codec");
+  return {
+    serialized: {
+      status: response.status,
+      statusText: response.statusText,
+      headers,
+      body
+    },
+    streams
+  };
+}
+function deserializeResponse(serialized, getStream) {
+  let body = null;
+  if (serialized.body) {
+    switch (serialized.body.type) {
+      case "bytes":
+        body = base64Decode(serialized.body.data);
+        break;
+      case "stream":
+        if (getStream) {
+          body = getStream(serialized.body.sid) ?? null;
+        }
+        break;
     }
-    this.#socket.send(message);
   }
-  sendBinary(frame) {
-    if (this.#closed) {
-      throw new Error("cannot send on a closed v2 codec");
-    }
-    this.#socket.send(frame);
+  return new Response(body, {
+    status: serialized.status,
+    statusText: serialized.statusText,
+    headers: serialized.headers
+  });
+}
+async function serializeValue(value, options) {
+  const streams = [];
+  const result = await serializeValueInternal(value, streams, options);
+  return { value: result, streams };
+}
+async function serializeValueInternal(value, streams, options) {
+  if (value === null || value === undefined) {
+    return value;
   }
-  call(method, params = []) {
-    const id = this.allocateRpcId();
-    const call = { t: "rpc.call", id, method, params };
-    const promise = new Promise((resolve, reject) => {
-      this.#pendingRpc.set(id, { resolve, reject });
-    });
-    this.sendText(JSON.stringify(call));
-    return promise;
+  if (value instanceof Request) {
+    const { serialized, streams: reqStreams } = await serializeRequest(value, options);
+    streams.push(...reqStreams);
+    return { __type: "Request", ...serialized };
   }
-  respondOk(id, result) {
-    const reply = { t: "rpc.ok", id, result };
-    this.sendText(JSON.stringify(reply));
+  if (value instanceof Response) {
+    const { serialized, streams: resStreams } = await serializeResponse(value, options);
+    streams.push(...resStreams);
+    return { __type: "Response", ...serialized };
   }
-  respondErr(id, error) {
-    const reply = { t: "rpc.err", id, error };
-    this.sendText(JSON.stringify(reply));
+  if (value instanceof ReadableStream) {
+    const sid = nextStreamId();
+    streams.push({ sid, stream: value });
+    return { __type: "ReadableStream", sid };
   }
-  sendWireError(err) {
-    const frame = { t: "error", ...err };
-    this.sendText(JSON.stringify(frame));
+  if (value instanceof Uint8Array) {
+    return { __type: "Uint8Array", data: base64Encode(value) };
   }
-  openBodyReader(bid) {
-    return this.bodyReaders.getOrOpen(bid);
+  if (value instanceof ArrayBuffer) {
+    return { __type: "ArrayBuffer", data: base64Encode(new Uint8Array(value)) };
   }
-  setRpcCallHandler(handler) {
-    this.#options = { ...this.#options, onRpcCall: handler };
+  if (value instanceof Date) {
+    return { __devflare: "date", iso: value.toISOString() };
   }
-  close(code, reason) {
-    if (this.#closed)
-      return;
-    this.#closed = true;
-    this.#failPending(new Error("v2 transport closed"));
-    this.#socket.close(code, reason);
+  if (value instanceof URL) {
+    return { __devflare: "url", href: value.href };
   }
-  get isClosed() {
-    return this.#closed;
+  if (value instanceof Error) {
+    const encoded = {
+      __devflare: "error",
+      name: value.name,
+      message: value.message
+    };
+    if (value.stack)
+      encoded.stack = value.stack;
+    return encoded;
   }
-  #onMessage(event) {
-    const { data } = event;
-    if (typeof data === "string") {
-      this.#onText(data);
-    } else if (data instanceof Uint8Array) {
-      this.#onBinary(data);
-    } else if (data instanceof ArrayBuffer) {
-      this.#onBinary(new Uint8Array(data));
+  if (value instanceof Map) {
+    const entries = [];
+    for (const [k, v] of value.entries()) {
+      entries.push([
+        await serializeValueInternal(k, streams, options),
+        await serializeValueInternal(v, streams, options)
+      ]);
     }
+    return { __devflare: "map", entries };
   }
-  #onText(data) {
-    let msg;
-    try {
-      msg = parseTransportV2ControlMsg(data);
-    } catch {
-      const rpc = tryParseRpcMsg(data);
-      if (rpc !== null) {
-        this.#onRpcMessage(rpc);
-        return;
-      }
-      const wireErr = tryParseWireError(data);
-      if (wireErr !== null) {
-        this.#options.onWireError?.(wireErr);
-        return;
-      }
-      this.#options.onUnknownControl?.(data);
-      return;
-    }
-    switch (msg.t) {
-      case "hello":
-        this.#onHello(msg);
-        break;
-      case "welcome":
-        this.#onWelcome(msg);
-        break;
-      case "body.open":
-        this.bodyReaders.getOrOpen(msg.bid);
-        break;
-      case "body.end":
-        this.bodyReaders.end(msg.bid);
-        break;
-      case "body.abort":
-        this.bodyReaders.abort(msg.bid, msg.error);
-        break;
+  if (value instanceof Set) {
+    const values = [];
+    for (const v of value.values()) {
+      values.push(await serializeValueInternal(v, streams, options));
     }
+    return { __devflare: "set", values };
   }
-  #onBinary(data) {
-    let frame;
-    try {
-      frame = decodeTransportV2BinaryFrame(data);
-    } catch {
-      return;
-    }
-    if (frame.kind === TransportV2BinaryKind.BodyChunk) {
-      this.bodyReaders.pushChunk(frame);
-      return;
+  if (Array.isArray(value)) {
+    return Promise.all(value.map((v) => serializeValueInternal(v, streams, options)));
+  }
+  if (typeof value === "object") {
+    const result = {};
+    for (const [k, v] of Object.entries(value)) {
+      result[k] = await serializeValueInternal(v, streams, options);
     }
-    this.#options.onUnknownBinary?.(frame);
+    return result;
   }
-  #onRpcMessage(msg) {
-    switch (msg.t) {
-      case "rpc.call":
-        this.#options.onRpcCall?.(msg);
-        break;
-      case "rpc.ok": {
-        const pending = this.#pendingRpc.get(msg.id);
-        if (pending !== undefined) {
-          this.#pendingRpc.delete(msg.id);
-          pending.resolve(msg.result);
+  return value;
+}
+function deserializeValue(value, getStream) {
+  if (value === null || value === undefined) {
+    return value;
+  }
+  if (typeof value === "object" && value !== null) {
+    const obj = value;
+    if (typeof obj.__devflare === "string") {
+      switch (obj.__devflare) {
+        case "date":
+          return new Date(obj.iso);
+        case "url":
+          return new URL(obj.href);
+        case "error": {
+          const err = new Error(obj.message);
+          if (typeof obj.name === "string")
+            err.name = obj.name;
+          if (typeof obj.stack === "string")
+            err.stack = obj.stack;
+          return err;
         }
-        break;
-      }
-      case "rpc.err": {
-        const pending = this.#pendingRpc.get(msg.id);
-        if (pending !== undefined) {
-          this.#pendingRpc.delete(msg.id);
-          const err = new Error(msg.error.message);
-          Object.assign(err, { code: msg.error.code, details: msg.error.details });
-          pending.reject(err);
+        case "map": {
+          const entries = obj.entries ?? [];
+          const map = new Map;
+          for (const [k, v] of entries) {
+            map.set(deserializeValue(k, getStream), deserializeValue(v, getStream));
+          }
+          return map;
+        }
+        case "set": {
+          const values = obj.values ?? [];
+          const set = new Set;
+          for (const v of values) {
+            set.add(deserializeValue(v, getStream));
+          }
+          return set;
         }
-        break;
       }
     }
-  }
-  #onHello(msg) {
-    if (this.#receivedHello) {
-      this.close(TRANSPORT_V2_UNSUPPORTED_VERSION_CLOSE_CODE, "duplicate hello");
-      return;
+    if (obj.__type === "Request") {
+      return deserializeRequest(obj, getStream);
     }
-    this.#receivedHello = true;
-    const negotiated = negotiateTransportV2Capabilities(this.#capabilities, msg.capabilities);
-    const welcome = {
-      t: "welcome",
-      protocolVersion: TRANSPORT_V2_PROTOCOL_VERSION,
-      capabilities: negotiated
-    };
-    this.#socket.send(stringifyTransportV2ControlMsg(welcome));
-    this.#completeHandshake({ protocolVersion: TRANSPORT_V2_PROTOCOL_VERSION, capabilities: negotiated });
+    if (obj.__type === "Response") {
+      return deserializeResponse(obj, getStream);
+    }
+    if (obj.__type === "ReadableStream") {
+      const sid = obj.sid;
+      return getStream?.(sid) ?? null;
+    }
+    if (obj.__type === "Uint8Array") {
+      return base64Decode(obj.data);
+    }
+    if (obj.__type === "ArrayBuffer") {
+      return base64Decode(obj.data).buffer;
+    }
+    if (obj.__type === "R2Object") {
+      return deserializeR2Object(obj);
+    }
+    if (obj.__type === "R2ObjectBody") {
+      return deserializeR2ObjectBody(obj);
+    }
+    if (Array.isArray(value)) {
+      return value.map((v) => deserializeValue(v, getStream));
+    }
+    const result = {};
+    for (const [k, v] of Object.entries(obj)) {
+      result[k] = deserializeValue(v, getStream);
+    }
+    return result;
+  }
+  return value;
+}
+function applySerializedHttpMetadata(headers, httpMetadata) {
+  if (httpMetadata?.contentType) {
+    headers.set("Content-Type", httpMetadata.contentType);
   }
-  #onWelcome(msg) {
-    if (this.#receivedWelcome)
-      return;
-    this.#receivedWelcome = true;
-    this.#completeHandshake({
-      protocolVersion: TRANSPORT_V2_PROTOCOL_VERSION,
-      capabilities: msg.capabilities
-    });
+  if (httpMetadata?.contentLanguage) {
+    headers.set("Content-Language", httpMetadata.contentLanguage);
   }
-  #completeHandshake(result) {
-    if (this.#negotiated !== null)
-      return;
-    this.#negotiated = result;
-    this.#handshakeResolver?.resolve(result);
-    this.#handshakeResolver = null;
+  if (httpMetadata?.contentDisposition) {
+    headers.set("Content-Disposition", httpMetadata.contentDisposition);
   }
-  #onClose() {
-    if (this.#closed) {
-      return;
-    }
-    this.#closed = true;
-    this.#failPending(new Error("v2 transport closed"));
+  if (httpMetadata?.contentEncoding) {
+    headers.set("Content-Encoding", httpMetadata.contentEncoding);
   }
-  #onError(error) {
-    const wrapped = error instanceof Error ? error : new Error(String(error));
-    this.#failPending(wrapped);
+  if (httpMetadata?.cacheControl) {
+    headers.set("Cache-Control", httpMetadata.cacheControl);
   }
-  #failPending(error) {
-    const resolver = this.#handshakeResolver;
-    if (resolver !== null) {
-      this.#handshakeResolver = null;
-      resolver.reject(error);
+  if (httpMetadata?.cacheExpiry) {
+    headers.set("Expires", new Date(httpMetadata.cacheExpiry).toUTCString());
+  }
+}
+function createSerializedR2Metadata(serialized) {
+  return {
+    key: serialized.key,
+    version: serialized.version,
+    size: serialized.size,
+    etag: serialized.etag,
+    httpEtag: serialized.httpEtag,
+    checksums: serialized.checksums,
+    uploaded: serialized.uploaded ? new Date(serialized.uploaded) : new Date,
+    httpMetadata: serialized.httpMetadata,
+    customMetadata: serialized.customMetadata,
+    range: serialized.range,
+    storageClass: serialized.storageClass,
+    writeHttpMetadata(headers) {
+      applySerializedHttpMetadata(headers, serialized.httpMetadata);
     }
-    for (const pending of this.#pendingRpc.values()) {
-      pending.reject(error);
+  };
+}
+function deserializeR2Object(obj) {
+  const serialized = obj;
+  return {
+    ...createSerializedR2Metadata(serialized)
+  };
+}
+function deserializeR2ObjectBody(obj) {
+  const serialized = obj;
+  const bodyBytes = serialized.bodyData ? base64Decode(serialized.bodyData) : new Uint8Array(0);
+  const r2ObjectBody = {
+    ...createSerializedR2Metadata(serialized),
+    body: new ReadableStream({
+      start(controller) {
+        controller.enqueue(bodyBytes);
+        controller.close();
+      }
+    }),
+    bodyUsed: false,
+    async arrayBuffer() {
+      const copy = new Uint8Array(bodyBytes.byteLength);
+      copy.set(bodyBytes);
+      return copy.buffer;
+    },
+    async text() {
+      return new TextDecoder().decode(bodyBytes);
+    },
+    async json() {
+      const text = new TextDecoder().decode(bodyBytes);
+      return JSON.parse(text);
+    },
+    async blob() {
+      const contentType = serialized.httpMetadata?.contentType || "application/octet-stream";
+      const buffer = bodyBytes.buffer.slice(bodyBytes.byteOffset, bodyBytes.byteOffset + bodyBytes.byteLength);
+      return new Blob([buffer], { type: contentType });
     }
-    this.#pendingRpc.clear();
-  }
+  };
+  return r2ObjectBody;
 }
-function tryParseRpcMsg(data) {
-  let parsed;
-  try {
-    parsed = JSON.parse(data);
-  } catch {
-    return null;
-  }
-  if (typeof parsed !== "object" || parsed === null || !("t" in parsed))
-    return null;
-  const t = parsed.t;
-  if (t === "rpc.call" || t === "rpc.ok" || t === "rpc.err") {
-    return parsed;
+function base64Encode(bytes) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(bytes).toString("base64");
   }
-  return null;
-}
-function tryParseWireError(data) {
-  let parsed;
-  try {
-    parsed = JSON.parse(data);
-  } catch {
-    return null;
+  let binary = "";
+  for (let i = 0;i < bytes.byteLength; i++) {
+    binary += String.fromCharCode(bytes[i]);
   }
-  if (typeof parsed !== "object" || parsed === null || !("t" in parsed))
-    return null;
-  const candidate = parsed;
-  if (candidate.t !== "error")
-    return null;
-  const scope = candidate.scope;
-  if (scope !== "transport" && scope !== "rpc" && scope !== "stream" && scope !== "ws")
-    return null;
-  const err = candidate.error;
-  if (!err || typeof err.code !== "string" || typeof err.message !== "string")
-    return null;
-  return parsed;
+  return btoa(binary);
 }
-
-// src/bridge/log.ts
-var isDebugEnabled = () => {
-  try {
-    const env = globalThis.process?.env;
-    return Boolean(env?.DEVFLARE_DEBUG_BRIDGE);
-  } catch {
-    return false;
+function base64Decode(str) {
+  if (typeof Buffer !== "undefined") {
+    return new Uint8Array(Buffer.from(str, "base64"));
   }
-};
-var bridgeLog = {
-  warn(message, error) {
-    if (!isDebugEnabled())
-      return;
-    console.warn(`[devflare:bridge] ${message}`, error);
-  },
-  debug(message, error) {
-    if (!isDebugEnabled())
-      return;
-    console.debug(`[devflare:bridge] ${message}`, error);
+  const binary = atob(str);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0;i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
   }
-};
+  return bytes;
+}
 
 // src/bridge/client.ts
 class BridgeWsAdapter {
@@ -1796,10 +1407,16 @@ function createR2Proxy(client, bindingName) {
       return client.call(`${bindingName}.r2.list`, [options]);
     },
     async createMultipartUpload(key, options) {
-      return client.call(`${bindingName}.r2.createMultipartUpload`, [key, options]);
+      return client.call(`${bindingName}.r2.createMultipartUpload`, [
+        key,
+        options
+      ]);
     },
     async resumeMultipartUpload(key, uploadId) {
-      return client.call(`${bindingName}.r2.resumeMultipartUpload`, [key, uploadId]);
+      return client.call(`${bindingName}.r2.resumeMultipartUpload`, [
+        key,
+        uploadId
+      ]);
     }
   };
 }
@@ -1813,7 +1430,7 @@ function getValueSize(value) {
   if (typeof value === "string")
     return new TextEncoder().encode(value).byteLength;
   if (value instanceof ReadableStream)
-    return Infinity;
+    return Number.POSITIVE_INFINITY;
   return 0;
 }
 function createD1Proxy(client, bindingName) {
@@ -1861,14 +1478,27 @@ function createD1StatementProxy(client, bindingName, sql, bindings) {
 function createDOProxy(client, bindingName, proxyOptions = {}) {
   return {
     idFromName(name) {
-      return createDOIdProxy(client, bindingName, { type: "name", value: name, jurisdiction: proxyOptions.jurisdiction });
+      return createDOIdProxy(client, bindingName, {
+        type: "name",
+        value: name,
+        jurisdiction: proxyOptions.jurisdiction
+      });
     },
     idFromString(hexId) {
-      return createDOIdProxy(client, bindingName, { type: "hex", value: hexId, jurisdiction: proxyOptions.jurisdiction });
+      return createDOIdProxy(client, bindingName, {
+        type: "hex",
+        value: hexId,
+        jurisdiction: proxyOptions.jurisdiction
+      });
     },
     newUniqueId(options) {
       const tempId = crypto.randomUUID().replace(/-/g, "");
-      return createDOIdProxy(client, bindingName, { type: "unique", value: tempId, options, jurisdiction: proxyOptions.jurisdiction });
+      return createDOIdProxy(client, bindingName, {
+        type: "unique",
+        value: tempId,
+        options,
+        jurisdiction: proxyOptions.jurisdiction
+      });
     },
     get(id) {
       const idProxy = id;
@@ -1904,13 +1534,19 @@ function createDOStubProxy(client, bindingName, idInfo, proxyOptions = {}) {
       return resolvedId;
     switch (idInfo.type) {
       case "name":
-        resolvedId = await client.call(`${bindingName}.do.idFromName`, [idInfo.value, idInfo.jurisdiction]);
+        resolvedId = await client.call(`${bindingName}.do.idFromName`, [
+          idInfo.value,
+          idInfo.jurisdiction
+        ]);
         break;
       case "hex":
         resolvedId = { __type: "DOId", hex: idInfo.value };
         break;
       case "unique":
-        resolvedId = await client.call(`${bindingName}.do.newUniqueId`, [idInfo.options, idInfo.jurisdiction]);
+        resolvedId = await client.call(`${bindingName}.do.newUniqueId`, [
+          idInfo.options,
+          idInfo.jurisdiction
+        ]);
         break;
     }
     return resolvedId;
@@ -1987,298 +1623,677 @@ function createDOStubProxy(client, bindingName, idInfo, proxyOptions = {}) {
         }
       };
     },
-    get id() {
-      return createDOIdProxy(client, bindingName, idInfo);
+    get id() {
+      return createDOIdProxy(client, bindingName, idInfo);
+    },
+    get name() {
+      return idInfo.type === "name" ? idInfo.value : undefined;
+    }
+  };
+  return new Proxy(stubBase, {
+    get(target, prop) {
+      if (prop in target) {
+        return target[prop];
+      }
+      if (typeof prop === "symbol") {
+        return;
+      }
+      if (prop === "then" || prop === "catch" || prop === "finally") {
+        return;
+      }
+      return async (...args) => {
+        const id = await resolveId();
+        let result = await client.call(`${bindingName}.do.rpc`, [bindingName, id, prop, args]);
+        if (transformResult) {
+          result = transformResult(result);
+        }
+        return result;
+      };
+    }
+  });
+}
+function isResponseLike(value) {
+  return value instanceof Response;
+}
+function createServiceProxy(client, bindingName, proxyOptions = {}) {
+  const { transformResult } = proxyOptions;
+  const serviceBase = {
+    async fetch(input, init) {
+      const request = input instanceof Request ? input : new Request(input, init);
+      const { serialized } = await serializeRequest(request);
+      const result = await client.call(`${bindingName}.service.fetch`, [serialized]);
+      if (isResponseLike(result)) {
+        return result;
+      }
+      return deserializeResponse(result);
+    }
+  };
+  return new Proxy(serviceBase, {
+    get(target, prop) {
+      if (typeof prop !== "string") {
+        return;
+      }
+      if (prop in target) {
+        return target[prop];
+      }
+      if (prop === "then" || prop === "catch" || prop === "finally") {
+        return;
+      }
+      if (prop === "toString") {
+        return () => `[DevflareServiceBinding ${bindingName}]`;
+      }
+      return async (...args) => {
+        let result = await client.call(`${bindingName}.service.rpc`, [prop, args]);
+        if (transformResult) {
+          result = transformResult(result);
+        }
+        return result;
+      };
+    }
+  });
+}
+var EMPTY_QUEUE_METRICS = {
+  backlogCount: 0,
+  backlogBytes: 0
+};
+function createQueueResponse() {
+  return { metadata: { metrics: EMPTY_QUEUE_METRICS } };
+}
+function createQueueProxy(client, bindingName) {
+  return {
+    async metrics() {
+      return EMPTY_QUEUE_METRICS;
+    },
+    async send(message, options) {
+      await client.call(`${bindingName}.queue.send`, [message, options]);
+      return createQueueResponse();
+    },
+    async sendBatch(messages, options) {
+      await client.call(`${bindingName}.queue.sendBatch`, [messages, options]);
+      return createQueueResponse();
+    }
+  };
+}
+function createAIProxy(client, bindingName) {
+  return {
+    async run(model, inputs, options) {
+      return client.call(`${bindingName}.ai.run`, [model, inputs, options]);
+    }
+  };
+}
+function createSendEmailProxy(client, bindingName) {
+  return {
+    async send(message) {
+      return client.call(`${bindingName}.email.send`, [message]);
+    }
+  };
+}
+function createWorkflowInstanceProxy(client, bindingName, id) {
+  return {
+    id,
+    async pause() {
+      await client.call(`${bindingName}.workflow.pause`, [id]);
     },
-    get name() {
-      return idInfo.type === "name" ? idInfo.value : undefined;
+    async resume() {
+      await client.call(`${bindingName}.workflow.resume`, [id]);
+    },
+    async terminate() {
+      await client.call(`${bindingName}.workflow.terminate`, [id]);
+    },
+    async restart() {
+      await client.call(`${bindingName}.workflow.restart`, [id]);
+    },
+    async status() {
+      return client.call(`${bindingName}.workflow.status`, [id]);
+    },
+    async sendEvent(event) {
+      await client.call(`${bindingName}.workflow.sendEvent`, [id, event]);
     }
   };
-  return new Proxy(stubBase, {
+}
+function createWorkflowProxy(client, bindingName) {
+  const toInstance = (value) => {
+    const id = value?.id;
+    if (typeof id !== "string") {
+      throw new Error(`Workflow ${bindingName} returned an instance without a string id.`);
+    }
+    return createWorkflowInstanceProxy(client, bindingName, id);
+  };
+  return {
+    async create(options) {
+      return toInstance(await client.call(`${bindingName}.workflow.create`, [options]));
+    },
+    async get(id) {
+      return toInstance(await client.call(`${bindingName}.workflow.get`, [id]));
+    }
+  };
+}
+var globalBindingHints = {};
+function createEnvProxy(options = {}) {
+  const client = options.client ?? getClient();
+  const bindingProxies = new Map;
+  const doProxyOptions = { transformResult: options.transformResult };
+  const serviceProxyOptions = { transformResult: options.transformResult };
+  const strict = options.strict === true;
+  const hints = { ...globalBindingHints, ...options.hints };
+  return new Proxy({}, {
     get(target, prop) {
-      if (prop in target) {
-        return target[prop];
+      if (typeof prop !== "string")
+        return;
+      if (bindingProxies.has(prop)) {
+        return bindingProxies.get(prop);
       }
-      if (typeof prop === "symbol") {
+      const hint = hints[prop];
+      if (!hint && strict) {
         return;
       }
-      if (prop === "then" || prop === "catch" || prop === "finally") {
+      let proxy;
+      switch (hint) {
+        case "kv":
+          proxy = createKVProxy(client, prop);
+          break;
+        case "r2":
+          proxy = createR2Proxy(client, prop);
+          break;
+        case "d1":
+          proxy = createD1Proxy(client, prop);
+          break;
+        case "do":
+          proxy = createDOProxy(client, prop, doProxyOptions);
+          break;
+        case "queue":
+          proxy = createQueueProxy(client, prop);
+          break;
+        case "ai":
+          proxy = createAIProxy(client, prop);
+          break;
+        case "service":
+          proxy = createServiceProxy(client, prop, serviceProxyOptions);
+          break;
+        case "sendEmail":
+          proxy = createSendEmailProxy(client, prop);
+          break;
+        case "workflow":
+          proxy = createWorkflowProxy(client, prop);
+          break;
+        case "secret":
+        case "var":
+          proxy = createSimpleBindingProxy(client, prop);
+          break;
+        default:
+          proxy = createGenericBindingProxy(client, prop);
+      }
+      bindingProxies.set(prop, proxy);
+      return proxy;
+    },
+    has(target, prop) {
+      return typeof prop === "string" && (!strict || (prop in hints));
+    },
+    ownKeys() {
+      return Object.keys(hints);
+    },
+    getOwnPropertyDescriptor(target, prop) {
+      if (typeof prop === "string" && (!strict || (prop in hints))) {
+        return { configurable: true, enumerable: true, writable: false };
+      }
+      return;
+    }
+  });
+}
+function createGenericBindingProxy(client, bindingName) {
+  return new Proxy({}, {
+    get(target, prop) {
+      if (typeof prop !== "string")
         return;
+      if (["get", "put", "delete", "list", "getWithMetadata"].includes(prop)) {
+        return createKVProxy(client, bindingName)[prop];
+      }
+      if (["idFromName", "idFromString", "newUniqueId", "get"].includes(prop)) {
+        return createDOProxy(client, bindingName)[prop];
+      }
+      if (["prepare", "batch", "exec", "dump"].includes(prop)) {
+        return createD1Proxy(client, bindingName)[prop];
+      }
+      if (["head"].includes(prop)) {
+        return createR2Proxy(client, bindingName)[prop];
       }
       return async (...args) => {
-        const id = await resolveId();
-        let result = await client.call(`${bindingName}.do.rpc`, [
-          bindingName,
-          id,
-          prop,
-          args
-        ]);
-        if (transformResult) {
-          result = transformResult(result);
-        }
-        return result;
+        return client.call(`${bindingName}.${prop}`, args);
       };
     }
   });
 }
-function isResponseLike(value) {
-  return value instanceof Response;
+function createSimpleBindingProxy(client, bindingName) {
+  let cachedValue;
+  let fetched = false;
+  let pendingValue = null;
+  const loadValue = () => {
+    if (fetched) {
+      return Promise.resolve(cachedValue);
+    }
+    if (!pendingValue) {
+      pendingValue = client.call(`${bindingName}.var.value`, []).then((value) => {
+        cachedValue = value;
+        fetched = true;
+        return value;
+      }).catch((error) => {
+        pendingValue = null;
+        throw error;
+      });
+    }
+    return pendingValue;
+  };
+  return {
+    then(resolve, reject) {
+      return loadValue().then(resolve ?? undefined, reject ?? undefined);
+    },
+    toString() {
+      if (!fetched)
+        throw new Error(`Binding ${bindingName} not yet fetched. Use await.`);
+      return String(cachedValue);
+    }
+  };
 }
-function createServiceProxy(client, bindingName, proxyOptions = {}) {
-  const { transformResult } = proxyOptions;
-  const serviceBase = {
-    async fetch(input, init) {
-      const request = input instanceof Request ? input : new Request(input, init);
-      const { serialized } = await serializeRequest(request);
-      const result = await client.call(`${bindingName}.service.fetch`, [serialized]);
-      if (isResponseLike(result)) {
-        return result;
-      }
-      return deserializeResponse(result);
+var globalEnvProxy = null;
+var bridgeEnv = new Proxy({}, {
+  get(target, prop) {
+    if (!globalEnvProxy) {
+      globalEnvProxy = createEnvProxy({ lazy: true });
     }
+    return globalEnvProxy[prop];
+  }
+});
+function initEnv(options = {}) {
+  globalEnvProxy = createEnvProxy(options);
+  return globalEnvProxy;
+}
+function setBindingHints(hints) {
+  globalBindingHints = { ...globalBindingHints, ...hints };
+  globalEnvProxy = null;
+}
+
+// src/runtime/context-events.ts
+function createLocals(locals) {
+  return locals ?? {};
+}
+function prepareEventShell(env, options = {}) {
+  return {
+    env: wrapEnvSendEmailBindings(env),
+    locals: createLocals(options.locals)
   };
-  return new Proxy(serviceBase, {
-    get(target, prop) {
-      if (typeof prop !== "string") {
-        return;
-      }
-      if (prop in target) {
-        return target[prop];
-      }
-      if (prop === "then" || prop === "catch" || prop === "finally") {
-        return;
+}
+function createAugmentedTarget(target, extra) {
+  return new Proxy(target, {
+    get(target2, prop) {
+      if (prop in extra) {
+        return extra[prop];
       }
-      if (prop === "toString") {
-        return () => `[DevflareServiceBinding ${bindingName}]`;
+      const value = Reflect.get(target2, prop, target2);
+      return typeof value === "function" ? value.bind(target2) : value;
+    },
+    has(target2, prop) {
+      return prop in extra || prop in target2;
+    },
+    ownKeys(target2) {
+      return Array.from(new Set([...Reflect.ownKeys(target2), ...Reflect.ownKeys(extra)]));
+    },
+    getOwnPropertyDescriptor(target2, prop) {
+      if (prop in extra) {
+        return {
+          configurable: true,
+          enumerable: true,
+          writable: false,
+          value: extra[prop]
+        };
       }
-      return async (...args) => {
-        let result = await client.call(`${bindingName}.service.rpc`, [prop, args]);
-        if (transformResult) {
-          result = transformResult(result);
-        }
-        return result;
-      };
+      return Reflect.getOwnPropertyDescriptor(target2, prop);
     }
   });
 }
-var EMPTY_QUEUE_METRICS = {
-  backlogCount: 0,
-  backlogBytes: 0
-};
-function createQueueResponse() {
-  return { metadata: { metrics: EMPTY_QUEUE_METRICS } };
-}
-function createQueueProxy(client, bindingName) {
+function createBaseEvent(type, env, ctx, options = {}) {
+  const shell = prepareEventShell(env, { locals: options.locals });
   return {
-    async metrics() {
-      return EMPTY_QUEUE_METRICS;
-    },
-    async send(message, options) {
-      await client.call(`${bindingName}.queue.send`, [message, options]);
-      return createQueueResponse();
-    },
-    async sendBatch(messages, options) {
-      await client.call(`${bindingName}.queue.sendBatch`, [messages, options]);
-      return createQueueResponse();
-    }
+    type,
+    ctx,
+    ...shell,
+    request: options.request ?? null,
+    params: options.params
   };
 }
-function createAIProxy(client, bindingName) {
-  return {
-    async run(model, inputs, options) {
-      return client.call(`${bindingName}.ai.run`, [model, inputs, options]);
-    }
-  };
+function createFetchEvent(request, env, ctx, options = {}) {
+  const shell = prepareEventShell(env, { locals: options.locals });
+  return createAugmentedTarget(request, {
+    type: "fetch",
+    ctx,
+    ...shell,
+    url: new URL(request.url),
+    request,
+    params: options.params ?? {}
+  });
 }
-function createSendEmailProxy(client, bindingName) {
-  return {
-    async send(message) {
-      return client.call(`${bindingName}.email.send`, [message]);
-    }
-  };
+function createQueueEvent(batch, env, ctx, options = {}) {
+  const shell = prepareEventShell(env, { locals: options.locals });
+  return createAugmentedTarget(batch, {
+    type: "queue",
+    ctx,
+    ...shell,
+    batch
+  });
 }
-function createWorkflowInstanceProxy(client, bindingName, id) {
+function createScheduledEvent(controller, env, ctx, options = {}) {
+  const shell = prepareEventShell(env, { locals: options.locals });
+  return createAugmentedTarget(controller, {
+    type: "scheduled",
+    ctx,
+    ...shell,
+    controller
+  });
+}
+function createEmailEvent(message, env, ctx, options = {}) {
+  const shell = prepareEventShell(env, { locals: options.locals });
+  return createAugmentedTarget(message, {
+    type: "email",
+    ctx,
+    ...shell,
+    message
+  });
+}
+function createTailEvent(events, env, ctx, options = {}) {
+  const shell = prepareEventShell(env, { locals: options.locals });
+  return createAugmentedTarget(events, {
+    type: "tail",
+    ctx,
+    ...shell,
+    events
+  });
+}
+function createDurableObjectFetchEvent(request, env, state, options = {}) {
+  const shell = prepareEventShell(env, { locals: options.locals });
+  return createAugmentedTarget(request, {
+    type: "durable-object-fetch",
+    ctx: state,
+    state,
+    ...shell,
+    request
+  });
+}
+function createDurableObjectAlarmEvent(env, state, options = {}) {
+  const shell = prepareEventShell(env, { locals: options.locals });
   return {
-    id,
-    async pause() {
-      await client.call(`${bindingName}.workflow.pause`, [id]);
-    },
-    async resume() {
-      await client.call(`${bindingName}.workflow.resume`, [id]);
-    },
-    async terminate() {
-      await client.call(`${bindingName}.workflow.terminate`, [id]);
-    },
-    async restart() {
-      await client.call(`${bindingName}.workflow.restart`, [id]);
-    },
-    async status() {
-      return client.call(`${bindingName}.workflow.status`, [id]);
-    },
-    async sendEvent(event) {
-      await client.call(`${bindingName}.workflow.sendEvent`, [id, event]);
-    }
+    type: "durable-object-alarm",
+    ctx: state,
+    state,
+    ...shell
   };
 }
-function createWorkflowProxy(client, bindingName) {
-  const toInstance = (value) => {
-    const id = value?.id;
-    if (typeof id !== "string") {
-      throw new Error(`Workflow ${bindingName} returned an instance without a string id.`);
+function createDurableObjectWebSocketMessageEvent(ws, message, env, state, options = {}) {
+  const shell = prepareEventShell(env, { locals: options.locals });
+  return createAugmentedTarget(ws, {
+    type: "durable-object-websocket-message",
+    ctx: state,
+    state,
+    ...shell,
+    ws,
+    message
+  });
+}
+function createDurableObjectWebSocketCloseEvent(ws, code, reason, wasClean, env, state, options = {}) {
+  const shell = prepareEventShell(env, { locals: options.locals });
+  return createAugmentedTarget(ws, {
+    type: "durable-object-websocket-close",
+    ctx: state,
+    state,
+    ...shell,
+    ws,
+    code,
+    reason,
+    wasClean
+  });
+}
+function createDurableObjectWebSocketErrorEvent(ws, error, env, state, options = {}) {
+  const shell = prepareEventShell(env, { locals: options.locals });
+  return createAugmentedTarget(ws, {
+    type: "durable-object-websocket-error",
+    ctx: state,
+    state,
+    ...shell,
+    ws,
+    error
+  });
+}
+function createDefaultEvent(env, ctx, request, type, locals) {
+  switch (type) {
+    case "fetch": {
+      if (request && ctx) {
+        return createFetchEvent(request, env, ctx, { locals });
+      }
+      return createBaseEvent(type, env, ctx, { locals, request });
     }
-    return createWorkflowInstanceProxy(client, bindingName, id);
-  };
-  return {
-    async create(options) {
-      return toInstance(await client.call(`${bindingName}.workflow.create`, [options]));
-    },
-    async get(id) {
-      return toInstance(await client.call(`${bindingName}.workflow.get`, [id]));
+    case "durable-object-fetch": {
+      if (request && ctx) {
+        return createDurableObjectFetchEvent(request, env, ctx, { locals });
+      }
+      return createBaseEvent(type, env, ctx, { locals, request });
     }
-  };
+    case "durable-object-alarm": {
+      if (ctx) {
+        return createDurableObjectAlarmEvent(env, ctx, { locals });
+      }
+      return createBaseEvent(type, env, ctx, { locals });
+    }
+    case "queue":
+    case "scheduled":
+    case "email":
+    case "tail":
+    case "durable-object-websocket-message":
+    case "durable-object-websocket-close":
+    case "durable-object-websocket-error":
+      return createBaseEvent(type, env, ctx, { locals, request });
+    default: {
+      const exhaustive = type;
+      throw new Error(`createDefaultEvent: unknown event type ${String(exhaustive)}`);
+    }
+  }
 }
-var globalBindingHints = {};
-function createEnvProxy(options = {}) {
-  const client = options.client ?? getClient();
-  const bindingProxies = new Map;
-  const doProxyOptions = { transformResult: options.transformResult };
-  const serviceProxyOptions = { transformResult: options.transformResult };
-  const strict = options.strict === true;
-  const hints = { ...globalBindingHints, ...options.hints };
-  return new Proxy({}, {
-    get(target, prop) {
-      if (typeof prop !== "string")
-        return;
-      if (bindingProxies.has(prop)) {
-        return bindingProxies.get(prop);
+
+// src/runtime/validation.ts
+class ContextAccessError extends Error {
+  contextName;
+  propertyName;
+  constructor(contextName, propertyName, message) {
+    super(message ?? `Cannot access ${contextName}.${propertyName} outside of an active Devflare handler trail.
+
+` + `This typically happens when:
+` + `  1. Accessing ${contextName} at module top-level (during import)
+` + `  2. Accessing ${contextName} in a callback that runs after the handler ends
+` + `  3. Accessing ${contextName} in a setTimeout/setInterval callback
+
+` + `Move the access inside your handler function or middleware.`);
+    this.name = "ContextAccessError";
+    this.contextName = contextName;
+    this.propertyName = propertyName;
+  }
+  static contextUnavailable(message) {
+    return new ContextAccessError("context", "<unavailable>", message ?? `Context not available. Devflare uses AsyncLocalStorage to carry the active event through fetch, queue, scheduled, email, tail, and Durable Object handler call chains.
+
+` + `This usually means one of:
+
+` + `1. Accessing context at module top-level (runs at cold start, not per-request)
+` + `2. Accessing context in setTimeout/setInterval callbacks
+` + `3. Missing 'nodejs_compat' compatibility flag in your worker config
+
+` + `Fix: Move the access inside your handler, middleware, or a helper called from that handler trail.
+` + `Learn more: https://devflare.dev/docs/context-errors`);
+  }
+}
+function createContextProxy(getter, name, options = {}) {
+  const mutable = options.mutable ?? true;
+  return new Proxy({}, {
+    get(_target, prop) {
+      const ctx = getter();
+      if (ctx === undefined || ctx === null) {
+        throw new ContextAccessError(name, String(prop));
       }
-      const hint = hints[prop];
-      if (!hint && strict) {
-        return;
+      return ctx[prop];
+    },
+    set(_target, prop, value) {
+      if (!mutable) {
+        throw new TypeError(`Cannot assign to '${String(prop)}' on '${name}' because it is read-only.
+` + `Use 'locals' for mutable request-scoped data.`);
       }
-      let proxy;
-      switch (hint) {
-        case "kv":
-          proxy = createKVProxy(client, prop);
-          break;
-        case "r2":
-          proxy = createR2Proxy(client, prop);
-          break;
-        case "d1":
-          proxy = createD1Proxy(client, prop);
-          break;
-        case "do":
-          proxy = createDOProxy(client, prop, doProxyOptions);
-          break;
-        case "queue":
-          proxy = createQueueProxy(client, prop);
-          break;
-        case "ai":
-          proxy = createAIProxy(client, prop);
-          break;
-        case "service":
-          proxy = createServiceProxy(client, prop, serviceProxyOptions);
-          break;
-        case "sendEmail":
-          proxy = createSendEmailProxy(client, prop);
-          break;
-        case "workflow":
-          proxy = createWorkflowProxy(client, prop);
-          break;
-        case "secret":
-        case "var":
-          proxy = createSimpleBindingProxy(client, prop);
-          break;
-        default:
-          proxy = createGenericBindingProxy(client, prop);
+      const ctx = getter();
+      if (ctx === undefined || ctx === null) {
+        throw new ContextAccessError(name, String(prop));
       }
-      bindingProxies.set(prop, proxy);
-      return proxy;
+      ctx[prop] = value;
+      return true;
     },
-    has(target, prop) {
-      return typeof prop === "string" && (!strict || (prop in hints));
+    deleteProperty(_target, prop) {
+      if (!mutable) {
+        throw new TypeError(`Cannot delete property '${String(prop)}' from '${name}' because it is read-only.`);
+      }
+      const ctx = getter();
+      if (ctx === undefined || ctx === null) {
+        return true;
+      }
+      return Reflect.deleteProperty(ctx, prop);
     },
-    ownKeys() {
-      return Object.keys(hints);
+    has(_target, prop) {
+      const ctx = getter();
+      if (ctx === undefined || ctx === null) {
+        return false;
+      }
+      return prop in ctx;
     },
-    getOwnPropertyDescriptor(target, prop) {
-      if (typeof prop === "string" && (!strict || (prop in hints))) {
-        return { configurable: true, enumerable: true, writable: false };
+    ownKeys(_target) {
+      const ctx = getter();
+      if (ctx === undefined || ctx === null) {
+        return [];
       }
-      return;
-    }
-  });
-}
-function createGenericBindingProxy(client, bindingName) {
-  return new Proxy({}, {
-    get(target, prop) {
-      if (typeof prop !== "string")
+      return Reflect.ownKeys(ctx);
+    },
+    getOwnPropertyDescriptor(_target, prop) {
+      const ctx = getter();
+      if (ctx === undefined || ctx === null) {
         return;
-      if (["get", "put", "delete", "list", "getWithMetadata"].includes(prop)) {
-        return createKVProxy(client, bindingName)[prop];
-      }
-      if (["idFromName", "idFromString", "newUniqueId", "get"].includes(prop)) {
-        return createDOProxy(client, bindingName)[prop];
       }
-      if (["prepare", "batch", "exec", "dump"].includes(prop)) {
-        return createD1Proxy(client, bindingName)[prop];
+      const descriptor = Reflect.getOwnPropertyDescriptor(ctx, prop);
+      if (!descriptor) {
+        return;
       }
-      if (["head"].includes(prop)) {
-        return createR2Proxy(client, bindingName)[prop];
+      if (!mutable) {
+        return { ...descriptor, writable: false };
       }
-      return async (...args) => {
-        return client.call(`${bindingName}.${prop}`, args);
-      };
+      return descriptor;
     }
   });
 }
-function createSimpleBindingProxy(client, bindingName) {
-  let cachedValue;
-  let fetched = false;
-  let pendingValue = null;
-  const loadValue = () => {
-    if (fetched) {
-      return Promise.resolve(cachedValue);
+
+// src/runtime/context.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+var storage = new AsyncLocalStorage;
+function createLocals2() {
+  return {};
+}
+function runWithContext(env, ctx, request, fn, type = "fetch") {
+  const locals = createLocals2();
+  const event = createDefaultEvent(env, ctx, request, type, locals);
+  return runWithEventContext(event, fn);
+}
+function runWithEventContext(event, fn) {
+  const context = {
+    env: event.env,
+    ctx: event.ctx,
+    request: event.request ?? null,
+    locals: event.locals,
+    type: event.type,
+    event
+  };
+  return storage.run(context, fn);
+}
+function getContext() {
+  const context = storage.getStore();
+  if (!context) {
+    throw ContextAccessError.contextUnavailable();
+  }
+  return context;
+}
+function getContextOrNull() {
+  const context = storage.getStore();
+  return context ?? null;
+}
+function getEventContext() {
+  return getContext().event;
+}
+function getEventContextOrNull() {
+  return getContextOrNull()?.event ?? null;
+}
+function hasContext() {
+  return storage.getStore() !== undefined;
+}
+function createEventAccessor(name, matcher) {
+  const accessor = () => {
+    const currentEvent = getEventContextOrNull();
+    if (!currentEvent) {
+      throw ContextAccessError.contextUnavailable();
     }
-    if (!pendingValue) {
-      pendingValue = client.call(`${bindingName}.var.value`, []).then((value) => {
-        cachedValue = value;
-        fetched = true;
-        return value;
-      }).catch((error) => {
-        pendingValue = null;
-        throw error;
-      });
+    if (!matcher(currentEvent)) {
+      throw ContextAccessError.contextUnavailable(`${name} is not available in the current '${currentEvent.type}' context.
+
+Devflare stores event objects in AsyncLocalStorage so helpers called within a handler can reach the active event.
+Use ${name}.safe() to return null instead of throwing, or call the getter that matches the active surface.`);
     }
-    return pendingValue;
+    return currentEvent;
   };
-  return {
-    then(resolve, reject) {
-      return loadValue().then(resolve ?? undefined, reject ?? undefined);
-    },
-    toString() {
-      if (!fetched)
-        throw new Error(`Binding ${bindingName} not yet fetched. Use await.`);
-      return String(cachedValue);
-    }
+  accessor.safe = () => {
+    const currentEvent = getEventContextOrNull();
+    return currentEvent && matcher(currentEvent) ? currentEvent : null;
   };
+  return accessor;
 }
-var globalEnvProxy = null;
-var bridgeEnv = new Proxy({}, {
-  get(target, prop) {
-    if (!globalEnvProxy) {
-      globalEnvProxy = createEnvProxy({ lazy: true });
-    }
-    return globalEnvProxy[prop];
-  }
-});
-function initEnv(options = {}) {
-  globalEnvProxy = createEnvProxy(options);
-  return globalEnvProxy;
+function isFetchEvent(event) {
+  return event.type === "fetch" && event.request instanceof Request;
 }
-function setBindingHints(hints) {
-  globalBindingHints = { ...globalBindingHints, ...hints };
-  globalEnvProxy = null;
+function isQueueEvent(event) {
+  return event.type === "queue" && "batch" in event;
+}
+function isScheduledEvent(event) {
+  return event.type === "scheduled" && "controller" in event;
+}
+function isEmailEvent(event) {
+  return event.type === "email" && "message" in event;
 }
+function isTailEvent(event) {
+  return event.type === "tail" && Array.isArray(event) && "events" in event;
+}
+function isDurableObjectEvent(event) {
+  return event.type.startsWith("durable-object-") && "state" in event;
+}
+function isDurableObjectFetchEvent(event) {
+  return event.type === "durable-object-fetch" && event.request instanceof Request;
+}
+function isDurableObjectAlarmEvent(event) {
+  return event.type === "durable-object-alarm" && "state" in event;
+}
+function isDurableObjectWebSocketMessageEvent(event) {
+  return event.type === "durable-object-websocket-message" && "ws" in event && "message" in event;
+}
+function isDurableObjectWebSocketCloseEvent(event) {
+  return event.type === "durable-object-websocket-close" && "ws" in event && "code" in event;
+}
+function isDurableObjectWebSocketErrorEvent(event) {
+  return event.type === "durable-object-websocket-error" && "ws" in event && "error" in event;
+}
+var getFetchEvent = createEventAccessor("getFetchEvent()", isFetchEvent);
+var getQueueEvent = createEventAccessor("getQueueEvent()", isQueueEvent);
+var getScheduledEvent = createEventAccessor("getScheduledEvent()", isScheduledEvent);
+var getEmailEvent = createEventAccessor("getEmailEvent()", isEmailEvent);
+var getTailEvent = createEventAccessor("getTailEvent()", isTailEvent);
+var getDurableObjectEvent = createEventAccessor("getDurableObjectEvent()", isDurableObjectEvent);
+var getDurableObjectFetchEvent = createEventAccessor("getDurableObjectFetchEvent()", isDurableObjectFetchEvent);
+var getDurableObjectAlarmEvent = createEventAccessor("getDurableObjectAlarmEvent()", isDurableObjectAlarmEvent);
+var getDurableObjectWebSocketMessageEvent = createEventAccessor("getDurableObjectWebSocketMessageEvent()", isDurableObjectWebSocketMessageEvent);
+var getDurableObjectWebSocketCloseEvent = createEventAccessor("getDurableObjectWebSocketCloseEvent()", isDurableObjectWebSocketCloseEvent);
+var getDurableObjectWebSocketErrorEvent = createEventAccessor("getDurableObjectWebSocketErrorEvent()", isDurableObjectWebSocketErrorEvent);
 
-export { ContextAccessError, createContextProxy, createFetchEvent, createQueueEvent, createScheduledEvent, createEmailEvent, createTailEvent, createDurableObjectFetchEvent, createDurableObjectAlarmEvent, createDurableObjectWebSocketMessageEvent, createDurableObjectWebSocketCloseEvent, createDurableObjectWebSocketErrorEvent, runWithContext, runWithEventContext, getContext, getContextOrNull, getEventContext, getEventContextOrNull, hasContext, getFetchEvent, getQueueEvent, getScheduledEvent, getEmailEvent, getTailEvent, getDurableObjectEvent, getDurableObjectFetchEvent, getDurableObjectAlarmEvent, getDurableObjectWebSocketMessageEvent, getDurableObjectWebSocketCloseEvent, getDurableObjectWebSocketErrorEvent, BridgeClient, getClient, createEnvProxy, bridgeEnv, initEnv, setBindingHints };
+export { BridgeClient, getClient, createEnvProxy, bridgeEnv, initEnv, setBindingHints, createFetchEvent, createQueueEvent, createScheduledEvent, createEmailEvent, createTailEvent, createDurableObjectFetchEvent, createDurableObjectAlarmEvent, createDurableObjectWebSocketMessageEvent, createDurableObjectWebSocketCloseEvent, createDurableObjectWebSocketErrorEvent, ContextAccessError, createContextProxy, runWithContext, runWithEventContext, getContext, getContextOrNull, getEventContext, getEventContextOrNull, hasContext, getFetchEvent, getQueueEvent, getScheduledEvent, getEmailEvent, getTailEvent, getDurableObjectEvent, getDurableObjectFetchEvent, getDurableObjectAlarmEvent, getDurableObjectWebSocketMessageEvent, getDurableObjectWebSocketCloseEvent, getDurableObjectWebSocketErrorEvent };