devflare 1.0.0-next.16 → 1.0.0-next.17

package/dist/{index-9ba1etyz.js → index-vdewcg1r.js}

@@ -69,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)) };
     }
@@ -97,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, {
@@ -119,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)) };
     }
@@ -146,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, {
@@ -186,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)));
   }
@@ -204,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);
     }
@@ -345,6 +406,7 @@ class BridgeClient {
   pendingCalls = new Map;
   activeStreams = new Map;
   wsProxies = new Map;
+  pendingWsOpens = new Map;
   outgoingStreams = new Map;
   connectPromise = null;
   isConnected = false;
@@ -403,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;
@@ -415,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();
@@ -461,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) => {
@@ -494,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);
       }
     });
@@ -558,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 {
@@ -636,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) {
@@ -672,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();
@@ -737,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]);
     },
@@ -763,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;
@@ -954,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`, [
@@ -1081,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)
@@ -1118,4 +1268,4 @@ function setBindingHints(hints) {
   globalEnvProxy = null;
 }
 
-export { BinaryKind, BinaryFlags, encodeBinaryFrame, decodeBinaryFrame, parseJsonMsg, stringifyJsonMsg, serializeValue, deserializeValue, base64Encode, base64Decode, BridgeClient, getClient, createEnvProxy, bridgeEnv, initEnv, setBindingHints };
+export { BridgeClient, getClient, createEnvProxy, bridgeEnv, initEnv, setBindingHints };