devflare 1.0.0-next.24 → 1.0.0-next.27

package/dist/index-vdewcg1r.js

@@ -1,1271 +0,0 @@
-// src/bridge/protocol.ts
-var BinaryKind = {
-  StreamChunk: 1,
-  WsData: 2
-};
-var BinaryFlags = {
-  FIN: 1,
-  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;
-}
-function decodeBinaryFrame(frame) {
-  if (frame.byteLength < BINARY_HEADER_SIZE) {
-    throw new Error(`Invalid binary frame: too short (${frame.byteLength} bytes)`);
-  }
-  const view = new DataView(frame.buffer, frame.byteOffset, frame.byteLength);
-  return {
-    kind: view.getUint8(0),
-    id: view.getUint32(1, true),
-    seq: view.getUint32(5, true),
-    flags: view.getUint8(9),
-    payload: frame.subarray(BINARY_HEADER_SIZE)
-  };
-}
-function parseJsonMsg(data) {
-  const msg = JSON.parse(data);
-  if (typeof msg !== "object" || msg === null || !("t" in msg)) {
-    throw new Error("Invalid message: missing type field");
-  }
-  return msg;
-}
-function stringifyJsonMsg(msg) {
-  return JSON.stringify(msg);
-}
-var rpcIdCounter = 0;
-var streamIdCounter = 0;
-var wsIdCounter = 0;
-function nextRpcId() {
-  return `rpc_${++rpcIdCounter}`;
-}
-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/serialization.ts
-async function serializeRequest(request, options) {
-  const streams = [];
-  const threshold = options?.httpThreshold ?? 10 * 1024 * 1024;
-  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("http body transfer not implemented; caller should use inline or binary transfer");
-    } else if (bytes.byteLength > 0) {
-      body = { type: "bytes", data: base64Encode(new Uint8Array(bytes)) };
-    }
-  }
-  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;
-    }
-  }
-  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 ?? 10 * 1024 * 1024;
-  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) {
-      throw new Error("http body transfer not implemented; caller should use inline or binary transfer");
-    } else if (bytes.byteLength > 0) {
-      body = { type: "bytes", data: base64Encode(new Uint8Array(bytes)) };
-    }
-  }
-  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;
-    }
-  }
-  return new Response(body, {
-    status: serialized.status,
-    statusText: serialized.statusText,
-    headers: serialized.headers
-  });
-}
-async function serializeValue(value) {
-  const streams = [];
-  const result = await serializeValueInternal(value, streams);
-  return { value: result, streams };
-}
-async function serializeValueInternal(value, streams) {
-  if (value === null || value === undefined) {
-    return value;
-  }
-  if (value instanceof Request) {
-    const { serialized, streams: reqStreams } = await serializeRequest(value);
-    streams.push(...reqStreams);
-    return { __type: "Request", ...serialized };
-  }
-  if (value instanceof Response) {
-    const { serialized, streams: resStreams } = await serializeResponse(value);
-    streams.push(...resStreams);
-    return { __type: "Response", ...serialized };
-  }
-  if (value instanceof ReadableStream) {
-    const sid = nextStreamId();
-    streams.push({ sid, stream: value });
-    return { __type: "ReadableStream", sid };
-  }
-  if (value instanceof Uint8Array) {
-    return { __type: "Uint8Array", data: base64Encode(value) };
-  }
-  if (value instanceof ArrayBuffer) {
-    return { __type: "ArrayBuffer", data: base64Encode(new Uint8Array(value)) };
-  }
-  if (value instanceof Date) {
-    return { __devflare: "date", iso: value.toISOString() };
-  }
-  if (value instanceof URL) {
-    return { __devflare: "url", href: value.href };
-  }
-  if (value instanceof Error) {
-    const encoded = {
-      __devflare: "error",
-      name: value.name,
-      message: value.message
-    };
-    if (value.stack)
-      encoded.stack = value.stack;
-    return encoded;
-  }
-  if (value instanceof Map) {
-    const entries = [];
-    for (const [k, v] of value.entries()) {
-      entries.push([
-        await serializeValueInternal(k, streams),
-        await serializeValueInternal(v, streams)
-      ]);
-    }
-    return { __devflare: "map", entries };
-  }
-  if (value instanceof Set) {
-    const values = [];
-    for (const v of value.values()) {
-      values.push(await serializeValueInternal(v, streams));
-    }
-    return { __devflare: "set", values };
-  }
-  if (Array.isArray(value)) {
-    return Promise.all(value.map((v) => serializeValueInternal(v, streams)));
-  }
-  if (typeof value === "object") {
-    const result = {};
-    for (const [k, v] of Object.entries(value)) {
-      result[k] = await serializeValueInternal(v, streams);
-    }
-    return 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;
-        }
-        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;
-    }
-    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);
-  }
-  if (httpMetadata?.contentLanguage) {
-    headers.set("Content-Language", httpMetadata.contentLanguage);
-  }
-  if (httpMetadata?.contentDisposition) {
-    headers.set("Content-Disposition", httpMetadata.contentDisposition);
-  }
-  if (httpMetadata?.contentEncoding) {
-    headers.set("Content-Encoding", httpMetadata.contentEncoding);
-  }
-  if (httpMetadata?.cacheControl) {
-    headers.set("Cache-Control", httpMetadata.cacheControl);
-  }
-  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);
-    }
-  };
-}
-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 });
-    }
-  };
-  return r2ObjectBody;
-}
-function base64Encode(bytes) {
-  if (typeof Buffer !== "undefined") {
-    return Buffer.from(bytes).toString("base64");
-  }
-  let binary = "";
-  for (let i = 0;i < bytes.byteLength; i++) {
-    binary += String.fromCharCode(bytes[i]);
-  }
-  return btoa(binary);
-}
-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);
-  }
-  return bytes;
-}
-
-// src/bridge/client.ts
-class BridgeClient {
-  ws = null;
-  url;
-  autoReconnect;
-  reconnectDelay;
-  connectTimeout;
-  pendingCalls = new Map;
-  activeStreams = new Map;
-  wsProxies = new Map;
-  pendingWsOpens = new Map;
-  outgoingStreams = new Map;
-  connectPromise = null;
-  isConnected = false;
-  constructor(options = {}) {
-    this.url = options.url ?? `ws://localhost:${DEFAULT_BRIDGE_PORT}`;
-    this.autoReconnect = options.autoReconnect ?? true;
-    this.reconnectDelay = options.reconnectDelay ?? 1000;
-    this.connectTimeout = options.connectTimeout ?? 5000;
-  }
-  getUrl() {
-    return this.url;
-  }
-  getHttpUrl() {
-    return this.url.replace(/^ws:\/\//, "http://").replace(/^wss:\/\//, "https://");
-  }
-  async connect() {
-    if (this.isConnected)
-      return;
-    if (this.connectPromise)
-      return this.connectPromise;
-    this.connectPromise = new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        reject(new Error(`Connection timeout: ${this.url}`));
-        this.ws?.close();
-      }, this.connectTimeout);
-      try {
-        this.ws = new WebSocket(this.url);
-        this.ws.binaryType = "arraybuffer";
-        this.ws.onopen = () => {
-          clearTimeout(timeout);
-          this.isConnected = true;
-          this.connectPromise = null;
-          resolve();
-        };
-        this.ws.onerror = () => {
-          clearTimeout(timeout);
-          this.connectPromise = null;
-          reject(new Error("WebSocket connection failed"));
-        };
-        this.ws.onclose = () => {
-          this.handleDisconnect();
-        };
-        this.ws.onmessage = (event) => {
-          this.handleMessage(event.data);
-        };
-      } catch (error) {
-        clearTimeout(timeout);
-        this.connectPromise = null;
-        reject(error);
-      }
-    });
-    return this.connectPromise;
-  }
-  disconnect() {
-    this.autoReconnect = false;
-    this.ws?.close();
-    this.ws = null;
-    this.isConnected = false;
-    this.cleanupPending(new Error("Bridge disconnected"));
-  }
-  close() {
-    this.disconnect();
-  }
-  get connected() {
-    return this.isConnected;
-  }
-  handleDisconnect() {
-    this.isConnected = false;
-    this.ws = null;
-    this.cleanupPending(new Error("Bridge disconnected"));
-    if (this.autoReconnect) {
-      setTimeout(() => {
-        this.connect().catch(() => {});
-      }, this.reconnectDelay);
-    }
-  }
-  cleanupPending(error) {
-    for (const pending of this.pendingCalls.values()) {
-      clearTimeout(pending.timeout);
-      pending.reject(error);
-    }
-    this.pendingCalls.clear();
-    for (const pending of this.pendingWsOpens.values()) {
-      pending.reject(error);
-    }
-    this.pendingWsOpens.clear();
-    for (const stream of this.activeStreams.values()) {
-      stream.closed = true;
-      if (stream.pendingPull) {
-        stream.pendingPull.reject(error);
-        stream.pendingPull = null;
-      }
-      try {
-        stream.controller.error(error);
-      } catch {}
-    }
-    this.activeStreams.clear();
-    for (const proxy of this.wsProxies.values()) {
-      try {
-        proxy.onClose(1006, error.message);
-      } catch {}
-    }
-    this.wsProxies.clear();
-    this.outgoingStreams.clear();
-  }
-  async call(method, params, timeoutMs = 30000) {
-    await this.ensureConnected();
-    const id = nextRpcId();
-    const { value: serializedParams, streams } = await serializeValue(params);
-    for (const streamRef of streams) {
-      this.outgoingStreams.set(streamRef.sid, streamRef);
-    }
-    return new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        this.pendingCalls.delete(id);
-        reject(new Error(`RPC timeout: ${method}`));
-      }, timeoutMs);
-      this.pendingCalls.set(id, { resolve, reject, timeout });
-      const msg = {
-        t: "rpc.call",
-        id,
-        method,
-        params: serializedParams
-      };
-      this.send(msg);
-    });
-  }
-  async createWsProxy(binding, id, url, headers) {
-    await this.ensureConnected();
-    const wid = nextWsId();
-    const proxy = {
-      clientWs: null,
-      onMessage: () => {},
-      onClose: () => {}
-    };
-    this.wsProxies.set(wid, proxy);
-    const openedPromise = new Promise((resolve, reject) => {
-      this.pendingWsOpens.set(wid, { resolve, reject });
-    });
-    const msg = {
-      t: "ws.open",
-      wid,
-      target: { binding, id, url, headers }
-    };
-    this.send(msg);
-    try {
-      await openedPromise;
-    } catch (error) {
-      this.wsProxies.delete(wid);
-      throw error;
-    }
-    return {
-      wid,
-      send: (data) => {
-        const payload = typeof data === "string" ? new TextEncoder().encode(data) : data;
-        const flags = typeof data === "string" ? BinaryFlags.TEXT : 0;
-        const frame = encodeBinaryFrame(BinaryKind.WsData, wid, 0, flags, payload);
-        this.ws?.send(frame);
-      },
-      close: (code, reason) => {
-        const closeMsg = { t: "ws.close", wid, code, reason };
-        this.send(closeMsg);
-        this.wsProxies.delete(wid);
-      },
-      onMessage: (handler) => {
-        proxy.onMessage = handler;
-      },
-      onClose: (handler) => {
-        proxy.onClose = handler;
-      }
-    };
-  }
-  createReadableStream(sid) {
-    return new ReadableStream({
-      start: (controller) => {
-        this.activeStreams.set(sid, {
-          controller,
-          buffer: [],
-          creditRemaining: 0,
-          pendingPull: null,
-          ended: false,
-          closed: false
-        });
-      },
-      pull: async (controller) => {
-        const stream = this.activeStreams.get(sid);
-        if (!stream || stream.closed)
-          return;
-        if (stream.buffer.length > 0) {
-          const chunk = stream.buffer.shift();
-          controller.enqueue(chunk);
-          return;
-        }
-        if (stream.ended) {
-          controller.close();
-          this.activeStreams.delete(sid);
-          return;
-        }
-        const pullMsg = {
-          t: "stream.pull",
-          sid,
-          creditBytes: DEFAULT_CHUNK_SIZE * 4
-        };
-        this.send(pullMsg);
-        await new Promise((resolve, reject) => {
-          stream.pendingPull = { resolve, reject };
-        });
-        stream.pendingPull = null;
-        if (stream.closed)
-          return;
-        if (stream.buffer.length > 0) {
-          const chunk = stream.buffer.shift();
-          controller.enqueue(chunk);
-          return;
-        }
-        if (stream.ended) {
-          controller.close();
-          this.activeStreams.delete(sid);
-        }
-      },
-      cancel: () => {
-        const stream = this.activeStreams.get(sid);
-        if (stream) {
-          stream.closed = true;
-          if (stream.pendingPull) {
-            stream.pendingPull.reject(new Error("Stream cancelled"));
-            stream.pendingPull = null;
-          }
-        }
-        this.activeStreams.delete(sid);
-      }
-    });
-  }
-  handleMessage(data) {
-    if (typeof data === "string") {
-      this.handleJsonMessage(data);
-    } else {
-      this.handleBinaryMessage(new Uint8Array(data));
-    }
-  }
-  handleJsonMessage(data) {
-    try {
-      const msg = parseJsonMsg(data);
-      switch (msg.t) {
-        case "rpc.ok":
-          this.handleRpcOk(msg);
-          break;
-        case "rpc.err":
-          this.handleRpcErr(msg);
-          break;
-        case "event":
-          this.handleEvent(msg);
-          break;
-        case "stream.pull":
-          this.handleStreamPull(msg);
-          break;
-        case "stream.end":
-          this.handleStreamEnd(msg);
-          break;
-        case "stream.abort":
-          this.handleStreamAbort(msg);
-          break;
-        case "ws.opened":
-          this.handleWsOpened(msg);
-          break;
-        case "ws.close":
-          this.handleWsClose(msg);
-          break;
-      }
-    } catch (error) {
-      console.error("[devflare bridge client] parse error:", data, error);
-    }
-  }
-  handleBinaryMessage(frame) {
-    try {
-      const decoded = decodeBinaryFrame(frame);
-      switch (decoded.kind) {
-        case BinaryKind.StreamChunk:
-          this.handleStreamChunk(decoded);
-          break;
-        case BinaryKind.WsData:
-          this.handleWsData(decoded);
-          break;
-      }
-    } catch {}
-  }
-  handleRpcOk(msg) {
-    const pending = this.pendingCalls.get(msg.id);
-    if (!pending)
-      return;
-    clearTimeout(pending.timeout);
-    this.pendingCalls.delete(msg.id);
-    const result = deserializeValue(msg.result, (sid) => this.createReadableStream(sid));
-    pending.resolve(result);
-  }
-  handleRpcErr(msg) {
-    const pending = this.pendingCalls.get(msg.id);
-    if (!pending)
-      return;
-    clearTimeout(pending.timeout);
-    this.pendingCalls.delete(msg.id);
-    const error = new Error(msg.error.message);
-    error.code = msg.error.code;
-    error.details = msg.error.details;
-    pending.reject(error);
-  }
-  handleEvent(_msg) {}
-  handleStreamPull(msg) {
-    const streamRef = this.outgoingStreams.get(msg.sid);
-    if (!streamRef)
-      return;
-    this.pumpStream(streamRef, msg.creditBytes);
-  }
-  async pumpStream(streamRef, creditBytes) {
-    const reader = streamRef.stream.getReader();
-    let sent = 0;
-    let seq = 0;
-    try {
-      while (sent < creditBytes) {
-        const { done, value } = await reader.read();
-        if (done) {
-          this.send({ t: "stream.end", sid: streamRef.sid });
-          this.outgoingStreams.delete(streamRef.sid);
-          break;
-        }
-        if (value) {
-          const frame = encodeBinaryFrame(BinaryKind.StreamChunk, streamRef.sid, seq++, 0, value);
-          this.ws?.send(frame);
-          sent += value.byteLength;
-        }
-      }
-    } catch (error) {
-      this.send({
-        t: "stream.abort",
-        sid: streamRef.sid,
-        error: String(error)
-      });
-      this.outgoingStreams.delete(streamRef.sid);
-    } finally {
-      reader.releaseLock();
-    }
-  }
-  handleStreamChunk(decoded) {
-    const stream = this.activeStreams.get(decoded.id);
-    if (!stream || stream.closed)
-      return;
-    stream.buffer.push(decoded.payload);
-    if (stream.pendingPull) {
-      const pending = stream.pendingPull;
-      stream.pendingPull = null;
-      pending.resolve();
-    }
-  }
-  handleStreamEnd(msg) {
-    const stream = this.activeStreams.get(msg.sid);
-    if (!stream)
-      return;
-    stream.ended = true;
-    if (stream.pendingPull) {
-      const pending = stream.pendingPull;
-      stream.pendingPull = null;
-      pending.resolve();
-    }
-  }
-  handleStreamAbort(msg) {
-    const stream = this.activeStreams.get(msg.sid);
-    if (!stream)
-      return;
-    const err = new Error(msg.error ?? "Stream aborted");
-    stream.closed = true;
-    if (stream.pendingPull) {
-      const pending = stream.pendingPull;
-      stream.pendingPull = null;
-      pending.reject(err);
-    }
-    try {
-      stream.controller.error(err);
-    } catch {}
-    this.activeStreams.delete(msg.sid);
-  }
-  handleWsData(decoded) {
-    const proxy = this.wsProxies.get(decoded.id);
-    if (!proxy)
-      return;
-    const isText = (decoded.flags & BinaryFlags.TEXT) !== 0;
-    const data = isText ? new TextDecoder().decode(decoded.payload) : decoded.payload;
-    proxy.onMessage(data);
-  }
-  handleWsClose(msg) {
-    const proxy = this.wsProxies.get(msg.wid);
-    if (!proxy)
-      return;
-    proxy.onClose(msg.code, msg.reason);
-    this.wsProxies.delete(msg.wid);
-  }
-  handleWsOpened(msg) {
-    const pending = this.pendingWsOpens.get(msg.wid);
-    if (!pending)
-      return;
-    this.pendingWsOpens.delete(msg.wid);
-    pending.resolve();
-  }
-  async ensureConnected() {
-    if (!this.isConnected) {
-      await this.connect();
-    }
-  }
-  send(msg) {
-    if (!this.ws || !this.isConnected) {
-      throw new Error("Not connected to bridge");
-    }
-    this.ws.send(stringifyJsonMsg(msg));
-  }
-}
-var defaultClient = null;
-function getClient(options) {
-  if (!defaultClient) {
-    defaultClient = new BridgeClient(options);
-  }
-  return defaultClient;
-}
-
-// src/bridge/proxy.ts
-function createKVProxy(client, bindingName) {
-  return {
-    async get(key, options) {
-      return client.call(`${bindingName}.get`, [key, options]);
-    },
-    async put(key, value, options) {
-      await client.call(`${bindingName}.put`, [key, value, options]);
-    },
-    async delete(key) {
-      await client.call(`${bindingName}.delete`, [key]);
-    },
-    async list(options) {
-      return client.call(`${bindingName}.list`, [options]);
-    },
-    async getWithMetadata(key, options) {
-      return client.call(`${bindingName}.getWithMetadata`, [key, options]);
-    }
-  };
-}
-function createR2Proxy(client, bindingName) {
-  return {
-    async head(key) {
-      return client.call(`${bindingName}.head`, [key]);
-    },
-    async get(key, options) {
-      return client.call(`${bindingName}.r2.get`, [key, options]);
-    },
-    async put(key, value, options) {
-      const size = getValueSize(value);
-      if (size > HTTP_TRANSFER_THRESHOLD) {
-        const transferId = `${bindingName}:${key}`;
-        const httpUrl = client.getHttpUrl();
-        const transferUrl = httpUrl.replace(/\/$/, "") + `/_devflare/transfer/${encodeURIComponent(transferId)}`;
-        const response = await fetch(transferUrl, {
-          method: "PUT",
-          body: value,
-          headers: {
-            ...options?.httpMetadata?.contentType ? { "Content-Type": options.httpMetadata.contentType } : {}
-          }
-        });
-        if (!response.ok) {
-          const error = await response.text();
-          throw new Error(`HTTP transfer failed: ${error}`);
-        }
-        const serialized = await response.json();
-        return deserializeValue(serialized);
-      }
-      return client.call(`${bindingName}.r2.put`, [key, value, options]);
-    },
-    async delete(keys) {
-      await client.call(`${bindingName}.r2.delete`, [keys]);
-    },
-    async list(options) {
-      return client.call(`${bindingName}.r2.list`, [options]);
-    },
-    async createMultipartUpload(key, options) {
-      return client.call(`${bindingName}.createMultipartUpload`, [key, options]);
-    },
-    async resumeMultipartUpload(key, uploadId) {
-      return client.call(`${bindingName}.resumeMultipartUpload`, [key, uploadId]);
-    }
-  };
-}
-function getValueSize(value) {
-  if (value instanceof Blob)
-    return value.size;
-  if (value instanceof ArrayBuffer)
-    return value.byteLength;
-  if (value instanceof Uint8Array)
-    return value.byteLength;
-  if (typeof value === "string")
-    return new TextEncoder().encode(value).byteLength;
-  if (value instanceof ReadableStream)
-    return Infinity;
-  return 0;
-}
-function createD1Proxy(client, bindingName) {
-  return {
-    prepare(sql) {
-      return createD1StatementProxy(client, bindingName, sql, []);
-    },
-    async batch(statements) {
-      const serialized = statements.map((stmt) => {
-        const s = stmt;
-        return { sql: s._sql, bindings: s._bindings };
-      });
-      return client.call(`${bindingName}.batch`, [serialized]);
-    },
-    async exec(sql) {
-      return client.call(`${bindingName}.exec`, [sql]);
-    },
-    async dump() {
-      return client.call(`${bindingName}.dump`, []);
-    }
-  };
-}
-function createD1StatementProxy(client, bindingName, sql, bindings) {
-  const stmt = {
-    _sql: sql,
-    _bindings: bindings,
-    bind(...values) {
-      return createD1StatementProxy(client, bindingName, sql, values);
-    },
-    async first(column) {
-      return client.call(`${bindingName}.stmt.first`, [sql, ...bindings, column]);
-    },
-    async all() {
-      return client.call(`${bindingName}.stmt.all`, [sql, ...bindings]);
-    },
-    async run() {
-      return client.call(`${bindingName}.stmt.run`, [sql, ...bindings]);
-    },
-    async raw(options) {
-      return client.call(`${bindingName}.stmt.raw`, [sql, ...bindings, options]);
-    }
-  };
-  return stmt;
-}
-function createDOProxy(client, bindingName, proxyOptions = {}) {
-  return {
-    idFromName(name) {
-      return createDOIdProxy(client, bindingName, { type: "name", value: name });
-    },
-    idFromString(hexId) {
-      return createDOIdProxy(client, bindingName, { type: "hex", value: hexId });
-    },
-    newUniqueId(options) {
-      const tempId = crypto.randomUUID().replace(/-/g, "");
-      return createDOIdProxy(client, bindingName, { type: "unique", value: tempId, options });
-    },
-    get(id) {
-      const idProxy = id;
-      return createDOStubProxy(client, bindingName, idProxy._idInfo, proxyOptions);
-    },
-    getByName(name) {
-      const id = this.idFromName(name);
-      return this.get(id);
-    },
-    jurisdiction(jurisdiction) {
-      return createDOProxy(client, bindingName, proxyOptions);
-    }
-  };
-}
-function createDOIdProxy(client, bindingName, idInfo) {
-  return {
-    _idInfo: idInfo,
-    toString() {
-      if (idInfo.type === "hex")
-        return idInfo.value;
-      return `${idInfo.type}:${idInfo.value}`;
-    },
-    equals(other) {
-      return this.toString() === other.toString();
-    }
-  };
-}
-function createDOStubProxy(client, bindingName, idInfo, proxyOptions = {}) {
-  const { transformResult } = proxyOptions;
-  let resolvedId = null;
-  const resolveId = async () => {
-    if (resolvedId)
-      return resolvedId;
-    switch (idInfo.type) {
-      case "name":
-        resolvedId = await client.call(`${bindingName}.idFromName`, [idInfo.value]);
-        break;
-      case "hex":
-        resolvedId = { __type: "DOId", hex: idInfo.value };
-        break;
-      case "unique":
-        resolvedId = await client.call(`${bindingName}.newUniqueId`, [idInfo.options]);
-        break;
-    }
-    return resolvedId;
-  };
-  const stubBase = {
-    async fetch(input, init) {
-      const id = await resolveId();
-      const request = input instanceof Request ? input : new Request(input, init);
-      const { serialized } = await serializeRequest(request);
-      const result = await client.call(`${bindingName}.stub.fetch`, [bindingName, id, serialized]);
-      return deserializeResponse(result);
-    },
-    async connect(url, options) {
-      const id = await resolveId();
-      const headersList = [];
-      if (options?.headers) {
-        const headers = new Headers(options.headers);
-        headers.forEach((value, key) => {
-          headersList.push([key, value]);
-        });
-      }
-      const wsProxy = await client.createWsProxy(bindingName, id.hex, url, headersList);
-      let readController = null;
-      const readable = new ReadableStream({
-        start(controller) {
-          readController = controller;
-        },
-        cancel() {
-          wsProxy.close();
-        }
-      });
-      wsProxy.onMessage((data) => {
-        if (readController) {
-          const chunk = typeof data === "string" ? new TextEncoder().encode(data) : data;
-          readController.enqueue(chunk);
-        }
-      });
-      wsProxy.onClose((code, reason) => {
-        if (readController) {
-          readController.close();
-        }
-      });
-      const writable = new WritableStream({
-        write(chunk) {
-          wsProxy.send(chunk);
-        },
-        close() {
-          wsProxy.close(1000, "Normal closure");
-        },
-        abort(reason) {
-          wsProxy.close(1001, reason?.toString() ?? "Aborted");
-        }
-      });
-      return {
-        readable,
-        writable,
-        get opened() {
-          return Promise.resolve({
-            remoteAddress: "127.0.0.1",
-            localAddress: "127.0.0.1"
-          });
-        },
-        get closed() {
-          return new Promise((resolve) => {
-            wsProxy.onClose(() => resolve());
-          });
-        },
-        close() {
-          wsProxy.close(1000, "Normal closure");
-          return Promise.resolve();
-        },
-        startTls() {
-          throw new Error("startTls not supported on DO WebSocket proxy");
-        }
-      };
-    },
-    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}.stub.rpc`, [
-          bindingName,
-          id,
-          prop,
-          args
-        ]);
-        if (transformResult) {
-          result = transformResult(result);
-        }
-        return result;
-      };
-    }
-  });
-}
-function createQueueProxy(client, bindingName) {
-  return {
-    async send(message, options) {
-      await client.call(`${bindingName}.send`, [message, options]);
-    },
-    async sendBatch(messages, options) {
-      await client.call(`${bindingName}.sendBatch`, [messages, options]);
-    }
-  };
-}
-function createAIProxy(client, bindingName) {
-  return {
-    async run(model, inputs, options) {
-      return client.call(`${bindingName}.run`, [model, inputs, options]);
-    }
-  };
-}
-function createSendEmailProxy(client, bindingName) {
-  return {
-    async send(message) {
-      return client.call(`${bindingName}.email.send`, [message]);
-    }
-  };
-}
-var globalBindingHints = {};
-function createEnvProxy(options = {}) {
-  const client = options.client ?? getClient();
-  const bindingProxies = new Map;
-  const doProxyOptions = { transformResult: options.transformResult };
-  const hints = { ...globalBindingHints, ...options.hints };
-  return new Proxy({}, {
-    get(target, prop) {
-      if (typeof prop !== "string")
-        return;
-      if (bindingProxies.has(prop)) {
-        return bindingProxies.get(prop);
-      }
-      const hint = hints[prop];
-      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 "sendEmail":
-          proxy = createSendEmailProxy(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";
-    },
-    ownKeys() {
-      return Object.keys(hints);
-    },
-    getOwnPropertyDescriptor(target, prop) {
-      if (typeof prop === "string") {
-        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) => {
-        return client.call(`${bindingName}.${prop}`, args);
-      };
-    }
-  });
-}
-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}.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);
-    }
-  };
-}
-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;
-}
-
-export { BridgeClient, getClient, createEnvProxy, bridgeEnv, initEnv, setBindingHints };