devflare 1.0.0-next.2 → 1.0.0-next.20

package/dist/{index-pf5s73n9.js → index-vdewcg1r.js}

@@ -1,10 +1,3 @@
-import {
-  normalizeDOBinding
-} from "./index-hcex3rgh.js";
-import {
-  __require
-} from "./index-37x76zdn.js";
-
 // src/bridge/protocol.ts
 var BinaryKind = {
   StreamChunk: 1,
@@ -76,7 +69,7 @@ async function serializeRequest(request, options) {
   if (request.body) {
     const bytes = await request.arrayBuffer();
     if (bytes.byteLength > threshold) {
-      body = { type: "http", transferId: crypto.randomUUID() };
+      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)) };
     }
@@ -104,8 +97,6 @@ function deserializeRequest(serialized, 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, {
@@ -126,7 +117,7 @@ async function serializeResponse(response, options) {
   if (response.body) {
     const bytes = await response.arrayBuffer();
     if (bytes.byteLength > threshold) {
-      body = { type: "http", transferId: crypto.randomUUID() };
+      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)) };
     }
@@ -153,8 +144,6 @@ function deserializeResponse(serialized, getStream) {
           body = getStream(serialized.body.sid) ?? null;
         }
         break;
-      case "http":
-        throw new Error("HTTP transfer body must be handled externally");
     }
   }
   return new Response(body, {
@@ -193,6 +182,39 @@ async function serializeValueInternal(value, streams) {
   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)));
   }
@@ -211,6 +233,38 @@ function deserializeValue(value, getStream) {
   }
   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);
     }
@@ -244,8 +298,27 @@ function deserializeValue(value, getStream) {
   }
   return value;
 }
-function deserializeR2Object(obj) {
-  const serialized = obj;
+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,
@@ -259,42 +332,21 @@ function deserializeR2Object(obj) {
     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());
-      }
+      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 = {
-    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,
+    ...createSerializedR2Metadata(serialized),
     body: new ReadableStream({
       start(controller) {
         controller.enqueue(bodyBytes);
@@ -318,26 +370,6 @@ function deserializeR2ObjectBody(obj) {
       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;
@@ -374,6 +406,7 @@ class BridgeClient {
   pendingCalls = new Map;
   activeStreams = new Map;
   wsProxies = new Map;
+  pendingWsOpens = new Map;
   outgoingStreams = new Map;
   connectPromise = null;
   isConnected = false;
@@ -432,11 +465,10 @@ class BridgeClient {
     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();
+    this.cleanupPending(new Error("Bridge disconnected"));
+  }
+  close() {
+    this.disconnect();
   }
   get connected() {
     return this.isConnected;
@@ -444,20 +476,41 @@ class BridgeClient {
   handleDisconnect() {
     this.isConnected = false;
     this.ws = null;
-    for (const [_id, pending] of this.pendingCalls) {
+    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(new Error("Bridge disconnected"));
+      pending.reject(error);
     }
     this.pendingCalls.clear();
-    for (const [_sid, stream] of this.activeStreams) {
-      stream.controller.error(new Error("Bridge disconnected"));
+    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();
-    if (this.autoReconnect) {
-      setTimeout(() => {
-        this.connect().catch(() => {});
-      }, this.reconnectDelay);
+    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();
@@ -490,12 +543,21 @@ class BridgeClient {
       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) => {
@@ -523,36 +585,57 @@ class BridgeClient {
         this.activeStreams.set(sid, {
           controller,
           buffer: [],
-          creditRemaining: 0
+          creditRemaining: 0,
+          pendingPull: null,
+          ended: false,
+          closed: false
         });
       },
       pull: async (controller) => {
         const stream = this.activeStreams.get(sid);
-        if (!stream)
+        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) => {
-          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();
+        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);
       }
     });
@@ -587,12 +670,15 @@ class BridgeClient {
           this.handleStreamAbort(msg);
           break;
         case "ws.opened":
+          this.handleWsOpened(msg);
           break;
         case "ws.close":
           this.handleWsClose(msg);
           break;
       }
-    } catch (error) {}
+    } catch (error) {
+      console.error("[devflare bridge client] parse error:", data, error);
+    }
   }
   handleBinaryMessage(frame) {
     try {
@@ -665,25 +751,40 @@ class BridgeClient {
   }
   handleStreamChunk(decoded) {
     const stream = this.activeStreams.get(decoded.id);
-    if (!stream)
+    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;
-    for (const chunk of stream.buffer) {
-      stream.controller.enqueue(chunk);
+    stream.ended = true;
+    if (stream.pendingPull) {
+      const pending = stream.pendingPull;
+      stream.pendingPull = null;
+      pending.resolve();
     }
-    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"));
+    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) {
@@ -701,6 +802,13 @@ class BridgeClient {
     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();
@@ -766,7 +874,8 @@ function createR2Proxy(client, bindingName) {
           const error = await response.text();
           throw new Error(`HTTP transfer failed: ${error}`);
         }
-        return response.json();
+        const serialized = await response.json();
+        return deserializeValue(serialized);
       }
       return client.call(`${bindingName}.r2.put`, [key, value, options]);
     },
@@ -792,7 +901,7 @@ function getValueSize(value) {
   if (value instanceof Uint8Array)
     return value.byteLength;
   if (typeof value === "string")
-    return value.length;
+    return new TextEncoder().encode(value).byteLength;
   if (value instanceof ReadableStream)
     return Infinity;
   return 0;
@@ -983,6 +1092,9 @@ function createDOStubProxy(client, bindingName, idInfo, proxyOptions = {}) {
       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`, [
@@ -1016,6 +1128,13 @@ function createAIProxy(client, bindingName) {
     }
   };
 }
+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();
@@ -1050,6 +1169,9 @@ function createEnvProxy(options = {}) {
         case "ai":
           proxy = createAIProxy(client, prop);
           break;
+        case "sendEmail":
+          proxy = createSendEmailProxy(client, prop);
+          break;
         case "secret":
         case "var":
           proxy = createSimpleBindingProxy(client, prop);
@@ -1100,17 +1222,26 @@ function createGenericBindingProxy(client, bindingName) {
 function createSimpleBindingProxy(client, bindingName) {
   let cachedValue;
   let fetched = false;
-  return {
-    then(resolve, reject) {
-      if (fetched) {
-        resolve(cachedValue);
-        return;
-      }
-      client.call(`${bindingName}.value`, []).then((value) => {
+  let pendingValue = null;
+  const loadValue = () => {
+    if (fetched) {
+      return Promise.resolve(cachedValue);
+    }
+    if (!pendingValue) {
+      pendingValue = client.call(`${bindingName}.value`, []).then((value) => {
         cachedValue = value;
         fetched = true;
-        resolve(value);
-      }).catch(reject);
+        return value;
+      }).catch((error) => {
+        pendingValue = null;
+        throw error;
+      });
+    }
+    return pendingValue;
+  };
+  return {
+    then(resolve, reject) {
+      return loadValue().then(resolve ?? undefined, reject ?? undefined);
     },
     toString() {
       if (!fetched)
@@ -1137,277 +1268,4 @@ function setBindingHints(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 };
+export { BridgeClient, getClient, createEnvProxy, bridgeEnv, initEnv, setBindingHints };