devflare 0.0.0 → 1.0.0-next.1

package/dist/index-pf5s73n9.js

@@ -0,0 +1,1413 @@
+import {
+  normalizeDOBinding
+} from "./index-hcex3rgh.js";
+import {
+  __require
+} from "./index-37x76zdn.js";
+
+// 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) {
+      body = { type: "http", transferId: crypto.randomUUID() };
+    } 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;
+      case "http":
+        throw new Error("HTTP transfer body must be handled externally");
+    }
+  }
+  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) {
+      body = { type: "http", transferId: crypto.randomUUID() };
+    } 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;
+      case "http":
+        throw new Error("HTTP transfer body must be handled externally");
+    }
+  }
+  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 (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 (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 deserializeR2Object(obj) {
+  const serialized = obj;
+  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) {
+      if (serialized.httpMetadata?.contentType) {
+        headers.set("Content-Type", serialized.httpMetadata.contentType);
+      }
+      if (serialized.httpMetadata?.contentLanguage) {
+        headers.set("Content-Language", serialized.httpMetadata.contentLanguage);
+      }
+      if (serialized.httpMetadata?.contentDisposition) {
+        headers.set("Content-Disposition", serialized.httpMetadata.contentDisposition);
+      }
+      if (serialized.httpMetadata?.contentEncoding) {
+        headers.set("Content-Encoding", serialized.httpMetadata.contentEncoding);
+      }
+      if (serialized.httpMetadata?.cacheControl) {
+        headers.set("Cache-Control", serialized.httpMetadata.cacheControl);
+      }
+      if (serialized.httpMetadata?.cacheExpiry) {
+        headers.set("Expires", new Date(serialized.httpMetadata.cacheExpiry).toUTCString());
+      }
+    }
+  };
+}
+function deserializeR2ObjectBody(obj) {
+  const serialized = obj;
+  const bodyBytes = serialized.bodyData ? base64Decode(serialized.bodyData) : new Uint8Array(0);
+  const r2ObjectBody = {
+    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,
+    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 });
+    },
+    writeHttpMetadata(headers) {
+      if (serialized.httpMetadata?.contentType) {
+        headers.set("Content-Type", serialized.httpMetadata.contentType);
+      }
+      if (serialized.httpMetadata?.contentLanguage) {
+        headers.set("Content-Language", serialized.httpMetadata.contentLanguage);
+      }
+      if (serialized.httpMetadata?.contentDisposition) {
+        headers.set("Content-Disposition", serialized.httpMetadata.contentDisposition);
+      }
+      if (serialized.httpMetadata?.contentEncoding) {
+        headers.set("Content-Encoding", serialized.httpMetadata.contentEncoding);
+      }
+      if (serialized.httpMetadata?.cacheControl) {
+        headers.set("Cache-Control", serialized.httpMetadata.cacheControl);
+      }
+      if (serialized.httpMetadata?.cacheExpiry) {
+        headers.set("Expires", new Date(serialized.httpMetadata.cacheExpiry).toUTCString());
+      }
+    }
+  };
+  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;
+  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;
+    for (const [id, pending] of this.pendingCalls) {
+      clearTimeout(pending.timeout);
+      pending.reject(new Error("Bridge disconnected"));
+    }
+    this.pendingCalls.clear();
+  }
+  get connected() {
+    return this.isConnected;
+  }
+  handleDisconnect() {
+    this.isConnected = false;
+    this.ws = null;
+    for (const [_id, pending] of this.pendingCalls) {
+      clearTimeout(pending.timeout);
+      pending.reject(new Error("Bridge disconnected"));
+    }
+    this.pendingCalls.clear();
+    for (const [_sid, stream] of this.activeStreams) {
+      stream.controller.error(new Error("Bridge disconnected"));
+    }
+    this.activeStreams.clear();
+    if (this.autoReconnect) {
+      setTimeout(() => {
+        this.connect().catch(() => {});
+      }, this.reconnectDelay);
+    }
+  }
+  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 msg = {
+      t: "ws.open",
+      wid,
+      target: { binding, id, url, headers }
+    };
+    this.send(msg);
+    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
+        });
+      },
+      pull: async (controller) => {
+        const stream = this.activeStreams.get(sid);
+        if (!stream)
+          return;
+        const pullMsg = {
+          t: "stream.pull",
+          sid,
+          creditBytes: DEFAULT_CHUNK_SIZE * 4
+        };
+        this.send(pullMsg);
+        await new Promise((resolve) => {
+          const checkBuffer = () => {
+            const s = this.activeStreams.get(sid);
+            if (!s)
+              return resolve();
+            if (s.buffer.length > 0) {
+              const chunk = s.buffer.shift();
+              controller.enqueue(chunk);
+              resolve();
+            } else {
+              setTimeout(checkBuffer, 10);
+            }
+          };
+          checkBuffer();
+        });
+      },
+      cancel: () => {
+        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":
+          break;
+        case "ws.close":
+          this.handleWsClose(msg);
+          break;
+      }
+    } catch (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)
+      return;
+    stream.buffer.push(decoded.payload);
+  }
+  handleStreamEnd(msg) {
+    const stream = this.activeStreams.get(msg.sid);
+    if (!stream)
+      return;
+    for (const chunk of stream.buffer) {
+      stream.controller.enqueue(chunk);
+    }
+    stream.controller.close();
+    this.activeStreams.delete(msg.sid);
+  }
+  handleStreamAbort(msg) {
+    const stream = this.activeStreams.get(msg.sid);
+    if (!stream)
+      return;
+    stream.controller.error(new Error(msg.error ?? "Stream aborted"));
+    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);
+  }
+  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}`);
+        }
+        return response.json();
+      }
+      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 value.length;
+  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;
+      }
+      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]);
+    }
+  };
+}
+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 "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;
+  return {
+    then(resolve, reject) {
+      if (fetched) {
+        resolve(cachedValue);
+        return;
+      }
+      client.call(`${bindingName}.value`, []).then((value) => {
+        cachedValue = value;
+        fetched = true;
+        resolve(value);
+      }).catch(reject);
+    },
+    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;
+}
+
+// src/bridge/miniflare.ts
+function generateGatewayScript() {
+  return `
+// Gateway Worker — Provides RPC access to all bindings
+export default {
+	async fetch(request, env, ctx) {
+		const url = new URL(request.url)
+		
+		// Health check
+		if (url.pathname === '/_devflare/health') {
+			return new Response(JSON.stringify({ status: 'ok', bindings: Object.keys(env) }), {
+				headers: { 'Content-Type': 'application/json' }
+			})
+		}
+		
+		// RPC endpoint
+		if (url.pathname === '/_devflare/rpc' && request.method === 'POST') {
+			try {
+				const { method, params } = await request.json()
+				const result = await executeRpc(env, method, params)
+				return new Response(JSON.stringify({ ok: true, result }), {
+					headers: { 'Content-Type': 'application/json' }
+				})
+			} catch (error) {
+				return new Response(JSON.stringify({
+					ok: false,
+					error: { code: 'RPC_ERROR', message: error.message }
+				}), {
+					status: 500,
+					headers: { 'Content-Type': 'application/json' }
+				})
+			}
+		}
+		
+		return new Response('Devflare Gateway', { status: 200 })
+	}
+}
+
+async function executeRpc(env, method, params) {
+	const [bindingName, ...methodPath] = method.split('.')
+	const binding = env[bindingName]
+	
+	if (!binding) {
+		throw new Error(\`Binding "\${bindingName}" not found\`)
+	}
+	
+	const methodName = methodPath.join('.')
+	
+	// KV operations
+	if (methodName === 'get') return binding.get(params[0], params[1])
+	if (methodName === 'put') return binding.put(params[0], params[1], params[2])
+	if (methodName === 'delete') return binding.delete(params[0])
+	if (methodName === 'list') return binding.list(params[0])
+	if (methodName === 'getWithMetadata') return binding.getWithMetadata(params[0], params[1])
+	
+	// R2 operations
+	if (methodName === 'head') return binding.head(params[0])
+	if (methodName === 'r2.get') return serializeR2Object(await binding.get(params[0], params[1]))
+	if (methodName === 'r2.put') return serializeR2Object(await binding.put(params[0], params[1], params[2]))
+	if (methodName === 'r2.delete') return binding.delete(params[0])
+	if (methodName === 'r2.list') return serializeR2Objects(await binding.list(params[0]))
+	
+	// D1 operations
+	if (methodName === 'exec') return binding.exec(params[0])
+	if (methodName === 'batch') {
+		const statements = params[0].map(s => binding.prepare(s.sql).bind(...(s.bindings || [])))
+		return binding.batch(statements)
+	}
+	if (methodName.startsWith('stmt.')) {
+		const [, stmtMethod] = methodName.split('.')
+		const [sql, ...bindings] = params
+		const stmt = binding.prepare(sql).bind(...bindings.slice(0, -1))
+		
+		if (stmtMethod === 'first') return stmt.first(bindings[bindings.length - 1])
+		if (stmtMethod === 'all') return stmt.all()
+		if (stmtMethod === 'run') return stmt.run()
+		if (stmtMethod === 'raw') return stmt.raw(bindings[bindings.length - 1])
+	}
+	
+	// DO operations
+	if (methodName === 'idFromName') {
+		const id = binding.idFromName(params[0])
+		return { __type: 'DOId', hex: id.toString() }
+	}
+	if (methodName === 'idFromString') {
+		const id = binding.idFromString(params[0])
+		return { __type: 'DOId', hex: id.toString() }
+	}
+	if (methodName === 'newUniqueId') {
+		const id = binding.newUniqueId(params[0])
+		return { __type: 'DOId', hex: id.toString() }
+	}
+	if (methodName === 'stub.fetch') {
+		const [, doId, serializedReq] = params
+		const id = binding.idFromString(doId.hex)
+		const stub = binding.get(id)
+		const response = await stub.fetch(new Request(serializedReq.url, {
+			method: serializedReq.method,
+			headers: serializedReq.headers,
+			body: serializedReq.body?.type === 'bytes' ? atob(serializedReq.body.data) : undefined
+		}))
+		return serializeResponse(response)
+	}
+	if (methodName === 'stub.rpc') {
+		// DO RPC: Call a method on the DO instance
+		const [, doId, rpcMethod, rpcParams] = params
+		const id = binding.idFromString(doId.hex)
+		const stub = binding.get(id)
+		
+		// Use fetch to call the RPC endpoint
+		const response = await stub.fetch(new Request('http://do/_rpc', {
+			method: 'POST',
+			headers: { 'Content-Type': 'application/json' },
+			body: JSON.stringify({ method: rpcMethod, params: rpcParams })
+		}))
+		
+		const result = await response.json()
+		if (!result.ok) throw new Error(result.error?.message || 'RPC failed')
+		return result.result
+	}
+	
+	// Queue operations
+	if (methodName === 'send') return binding.send(params[0], params[1])
+	if (methodName === 'sendBatch') return binding.sendBatch(params[0], params[1])
+	
+	// Generic fallback
+	if (typeof binding[methodName] === 'function') {
+		return binding[methodName](...params)
+	}
+	
+	throw new Error(\`Unknown method: \${method}\`)
+}
+
+function serializeResponse(response) {
+	return {
+		status: response.status,
+		statusText: response.statusText,
+		headers: [...response.headers.entries()],
+		body: null // Will be streamed separately for large bodies
+	}
+}
+
+function serializeR2Object(obj) {
+	if (!obj) return null
+	return {
+		key: obj.key,
+		version: obj.version,
+		size: obj.size,
+		etag: obj.etag,
+		httpEtag: obj.httpEtag,
+		uploaded: obj.uploaded?.toISOString(),
+		httpMetadata: obj.httpMetadata,
+		customMetadata: obj.customMetadata
+	}
+}
+
+function serializeR2Objects(result) {
+	if (!result) return null
+	return {
+		objects: result.objects.map(serializeR2Object),
+		truncated: result.truncated,
+		cursor: result.cursor,
+		delimitedPrefixes: result.delimitedPrefixes
+	}
+}
+`;
+}
+async function startMiniflare(options = {}) {
+  const { Miniflare, Log, LogLevel } = await import("miniflare");
+  const port = options.port ?? 8787;
+  const persistPath = options.persistPath ?? ".devflare/data";
+  const mfConfig = {
+    modules: true,
+    script: generateGatewayScript(),
+    port,
+    host: "127.0.0.1",
+    log: options.verbose ? new Log(LogLevel.DEBUG) : new Log(LogLevel.WARN),
+    compatibilityDate: options.compatibilityDate ?? "2024-01-01",
+    compatibilityFlags: options.compatibilityFlags ?? []
+  };
+  const hasBindings = (val) => {
+    if (!val)
+      return false;
+    if (Array.isArray(val))
+      return val.length > 0;
+    return Object.keys(val).length > 0;
+  };
+  if (hasBindings(options.kvNamespaces)) {
+    mfConfig.kvNamespaces = options.kvNamespaces;
+    if (options.persist) {
+      mfConfig.kvPersist = `${persistPath}/kv`;
+    }
+  }
+  if (hasBindings(options.r2Buckets)) {
+    mfConfig.r2Buckets = options.r2Buckets;
+    if (options.persist) {
+      mfConfig.r2Persist = `${persistPath}/r2`;
+    }
+  }
+  if (hasBindings(options.d1Databases)) {
+    mfConfig.d1Databases = options.d1Databases;
+    if (options.persist) {
+      mfConfig.d1Persist = `${persistPath}/d1`;
+    }
+  }
+  if (options.durableObjects) {
+    mfConfig.durableObjects = options.durableObjects;
+    if (options.persist) {
+      mfConfig.durableObjectsPersist = `${persistPath}/do`;
+    }
+  }
+  if (options.bindings) {
+    mfConfig.bindings = options.bindings;
+  }
+  if (options.queues?.length) {
+    mfConfig.queueProducers = Object.fromEntries(options.queues.map((q) => [q, { queueName: q }]));
+  }
+  const mf = new Miniflare(mfConfig);
+  await mf.ready;
+  return {
+    ready: Promise.resolve(),
+    async dispose() {
+      await mf.dispose();
+    },
+    async getBindings() {
+      return mf.getBindings();
+    },
+    getKVNamespace: mf.getKVNamespace.bind(mf),
+    getR2Bucket: mf.getR2Bucket.bind(mf),
+    getD1Database: mf.getD1Database.bind(mf),
+    getDurableObjectNamespace: mf.getDurableObjectNamespace.bind(mf),
+    dispatchFetch: mf.dispatchFetch.bind(mf),
+    _mf: mf
+  };
+}
+async function startMiniflareFromConfig(config, options = {}) {
+  const bindings = config.bindings ?? {};
+  const mfOptions = {
+    ...options,
+    compatibilityDate: config.compatibilityDate,
+    compatibilityFlags: config.compatibilityFlags,
+    kvNamespaces: bindings.kv ? bindings.kv : undefined,
+    r2Buckets: bindings.r2 ? bindings.r2 : undefined,
+    d1Databases: bindings.d1 ? bindings.d1 : undefined,
+    queues: bindings.queues?.consumers?.map((c) => c.queue),
+    bindings: config.vars,
+    durableObjects: bindings.durableObjects ? Object.fromEntries(Object.entries(bindings.durableObjects).map(([bindingName, doConfig]) => {
+      const normalized = normalizeDOBinding(doConfig);
+      return [
+        bindingName,
+        {
+          className: normalized.className,
+          scriptPath: normalized.scriptName
+        }
+      ];
+    })) : undefined
+  };
+  return startMiniflare(mfOptions);
+}
+var globalMiniflare = null;
+async function getMiniflare(options) {
+  if (!globalMiniflare) {
+    globalMiniflare = await startMiniflare(options);
+  }
+  return globalMiniflare;
+}
+async function stopMiniflare() {
+  if (globalMiniflare) {
+    await globalMiniflare.dispose();
+    globalMiniflare = null;
+  }
+}
+
+export { BinaryKind, BinaryFlags, encodeBinaryFrame, decodeBinaryFrame, parseJsonMsg, stringifyJsonMsg, serializeValue, deserializeValue, base64Encode, base64Decode, BridgeClient, getClient, createEnvProxy, bridgeEnv, initEnv, setBindingHints, startMiniflare, startMiniflareFromConfig, getMiniflare, stopMiniflare };