@dxos/edge-client 0.8.2-main.5885341 → 0.8.2-main.85fa0e5

package/dist/lib/node/chunk-FQM4JFRT.cjs

@@ -0,0 +1,586 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var chunk_FQM4JFRT_exports = {};
+__export(chunk_FQM4JFRT_exports, {
+  CLOUDFLARE_MESSAGE_MAX_BYTES: () => CLOUDFLARE_MESSAGE_MAX_BYTES,
+  CLOUDFLARE_RPC_MAX_BYTES: () => CLOUDFLARE_RPC_MAX_BYTES,
+  EDGE_WEBSOCKET_PROTOCOL_V0: () => EDGE_WEBSOCKET_PROTOCOL_V0,
+  EDGE_WEBSOCKET_PROTOCOL_V1: () => EDGE_WEBSOCKET_PROTOCOL_V1,
+  EdgeWsConnection: () => EdgeWsConnection,
+  Protocol: () => Protocol,
+  WebSocketMuxer: () => WebSocketMuxer,
+  getTypename: () => getTypename,
+  protocol: () => protocol,
+  toUint8Array: () => toUint8Array
+});
+module.exports = __toCommonJS(chunk_FQM4JFRT_exports);
+var import_invariant = require("@dxos/invariant");
+var import_buf = require("@dxos/protocols/buf");
+var import_messenger_pb = require("@dxos/protocols/buf/dxos/edge/messenger_pb");
+var import_util = require("@dxos/util");
+var import_buf2 = require("@dxos/protocols/buf");
+var import_messenger_pb2 = require("@dxos/protocols/buf/dxos/edge/messenger_pb");
+var import_async = require("@dxos/async");
+var import_log = require("@dxos/log");
+var import_buf3 = require("@dxos/protocols/buf");
+var import_messenger_pb3 = require("@dxos/protocols/buf/dxos/edge/messenger_pb");
+var import_isomorphic_ws = __toESM(require("isomorphic-ws"));
+var import_async2 = require("@dxos/async");
+var import_context = require("@dxos/context");
+var import_invariant2 = require("@dxos/invariant");
+var import_log2 = require("@dxos/log");
+var import_buf4 = require("@dxos/protocols/buf");
+var import_messenger_pb4 = require("@dxos/protocols/buf/dxos/edge/messenger_pb");
+var __dxlog_file = "/home/runner/work/dxos/dxos/packages/core/mesh/edge-client/src/protocol.ts";
+var getTypename = (typeName) => `type.googleapis.com/${typeName}`;
+var Protocol = class {
+  constructor(types) {
+    this._typeRegistry = import_buf.buf.createRegistry(...types);
+  }
+  get typeRegistry() {
+    return this._typeRegistry;
+  }
+  toJson(message) {
+    try {
+      return import_buf.buf.toJson(import_messenger_pb.MessageSchema, message, {
+        registry: this.typeRegistry
+      });
+    } catch (err) {
+      return {
+        type: this.getPayloadType(message)
+      };
+    }
+  }
+  /**
+  * Return the payload with the given type.
+  */
+  getPayload(message, type) {
+    (0, import_invariant.invariant)(message.payload, void 0, {
+      F: __dxlog_file,
+      L: 40,
+      S: this,
+      A: [
+        "message.payload",
+        ""
+      ]
+    });
+    const payloadTypename = this.getPayloadType(message);
+    if (type && type.typeName !== payloadTypename) {
+      throw new Error(`Unexpected payload type: ${payloadTypename}; expected ${type.typeName}`);
+    }
+    (0, import_invariant.invariant)(import_buf.bufWkt.anyIs(message.payload, type), `Unexpected payload type: ${payloadTypename}}`, {
+      F: __dxlog_file,
+      L: 46,
+      S: this,
+      A: [
+        "bufWkt.anyIs(message.payload, type)",
+        "`Unexpected payload type: ${payloadTypename}}`"
+      ]
+    });
+    const payload = import_buf.bufWkt.anyUnpack(message.payload, this.typeRegistry);
+    (0, import_invariant.invariant)(payload, `Empty payload: ${payloadTypename}}`, {
+      F: __dxlog_file,
+      L: 48,
+      S: this,
+      A: [
+        "payload",
+        "`Empty payload: ${payloadTypename}}`"
+      ]
+    });
+    return payload;
+  }
+  /**
+  * Get the payload type.
+  */
+  getPayloadType(message) {
+    if (!message.payload) {
+      return void 0;
+    }
+    const [, type] = message.payload.typeUrl.split("/");
+    return type;
+  }
+  /**
+  * Create a packed message.
+  */
+  createMessage(type, { source, target, payload, serviceId }) {
+    return import_buf.buf.create(import_messenger_pb.MessageSchema, {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      source,
+      target,
+      serviceId,
+      payload: payload ? import_buf.bufWkt.anyPack(type, import_buf.buf.create(type, payload)) : void 0
+    });
+  }
+};
+var toUint8Array = async (data) => {
+  if (data instanceof Buffer) {
+    return (0, import_util.bufferToArray)(data);
+  }
+  if (data instanceof Blob) {
+    return new Uint8Array(await data.arrayBuffer());
+  }
+  throw new Error(`Unexpected datatype: ${data}`);
+};
+var protocol = new Protocol([
+  import_messenger_pb2.SwarmRequestSchema,
+  import_messenger_pb2.SwarmResponseSchema,
+  import_messenger_pb2.TextMessageSchema,
+  import_buf2.bufWkt.AnySchema
+]);
+var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/core/mesh/edge-client/src/edge-ws-muxer.ts";
+var FLAG_SEGMENT_SEQ = 1;
+var FLAG_SEGMENT_SEQ_TERMINATED = 1 << 1;
+var CLOUDFLARE_MESSAGE_MAX_BYTES = 1e3 * 1e3;
+var CLOUDFLARE_RPC_MAX_BYTES = 32 * 1e3 * 1e3;
+var MAX_CHUNK_LENGTH = 16384;
+var MAX_BUFFERED_AMOUNT = CLOUDFLARE_MESSAGE_MAX_BYTES;
+var BUFFER_FULL_BACKOFF_TIMEOUT = 100;
+var WebSocketMuxer = class {
+  constructor(_ws) {
+    this._ws = _ws;
+    this._inMessageAccumulator = /* @__PURE__ */ new Map();
+    this._outMessageChunks = /* @__PURE__ */ new Map();
+    this._outMessageChannelByService = /* @__PURE__ */ new Map();
+  }
+  /**
+  * Resolves when all the message chunks get enqueued for sending.
+  */
+  async send(message) {
+    const binary = import_buf3.buf.toBinary(import_messenger_pb3.MessageSchema, message);
+    const channelId = this._resolveChannel(message);
+    if (channelId == null && binary.byteLength > CLOUDFLARE_MESSAGE_MAX_BYTES || binary.byteLength > CLOUDFLARE_RPC_MAX_BYTES) {
+      import_log.log.error("Large message dropped", {
+        byteLength: binary.byteLength,
+        serviceId: message.serviceId,
+        payload: protocol.getPayloadType(message),
+        channelId
+      }, {
+        F: __dxlog_file2,
+        L: 55,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      return;
+    }
+    if (channelId == null || binary.length < MAX_CHUNK_LENGTH) {
+      const flags = Buffer.from([
+        0
+      ]);
+      this._ws.send(Buffer.concat([
+        flags,
+        binary
+      ]));
+      return;
+    }
+    const terminatorSentTrigger = new import_async.Trigger();
+    const messageChunks = [];
+    for (let i = 0; i < binary.length; i += MAX_CHUNK_LENGTH) {
+      const chunk = binary.slice(i, i + MAX_CHUNK_LENGTH);
+      const isLastChunk = i + MAX_CHUNK_LENGTH < binary.length;
+      if (isLastChunk) {
+        const flags = Buffer.from([
+          FLAG_SEGMENT_SEQ | FLAG_SEGMENT_SEQ_TERMINATED,
+          channelId
+        ]);
+        messageChunks.push({
+          payload: Buffer.concat([
+            flags,
+            chunk
+          ]),
+          trigger: terminatorSentTrigger
+        });
+      } else {
+        const flags = Buffer.from([
+          FLAG_SEGMENT_SEQ
+        ]);
+        messageChunks.push({
+          payload: Buffer.concat([
+            flags,
+            chunk
+          ])
+        });
+      }
+    }
+    const queuedMessages = this._outMessageChunks.get(channelId);
+    if (queuedMessages) {
+      queuedMessages.push(...messageChunks);
+    } else {
+      this._outMessageChunks.set(channelId, messageChunks);
+    }
+    this._sendChunkedMessages();
+    return terminatorSentTrigger.wait();
+  }
+  receiveData(data) {
+    if ((data[0] & FLAG_SEGMENT_SEQ) === 0) {
+      return import_buf3.buf.fromBinary(import_messenger_pb3.MessageSchema, data.slice(1));
+    }
+    const [flags, channelId, ...payload] = data;
+    let chunkAccumulator = this._inMessageAccumulator.get(channelId);
+    if (chunkAccumulator) {
+      chunkAccumulator.push(Buffer.from(payload));
+    } else {
+      chunkAccumulator = [
+        Buffer.from(payload)
+      ];
+      this._inMessageAccumulator.set(channelId, chunkAccumulator);
+    }
+    if ((flags & FLAG_SEGMENT_SEQ_TERMINATED) === 0) {
+      return void 0;
+    }
+    const message = import_buf3.buf.fromBinary(import_messenger_pb3.MessageSchema, Buffer.concat(chunkAccumulator));
+    this._inMessageAccumulator.delete(channelId);
+    return message;
+  }
+  destroy() {
+    if (this._sendTimeout) {
+      clearTimeout(this._sendTimeout);
+      this._sendTimeout = void 0;
+    }
+    for (const channelChunks of this._outMessageChunks.values()) {
+      channelChunks.forEach((chunk) => chunk.trigger?.wake());
+    }
+    this._outMessageChunks.clear();
+    this._inMessageAccumulator.clear();
+    this._outMessageChannelByService.clear();
+  }
+  _sendChunkedMessages() {
+    if (this._sendTimeout) {
+      return;
+    }
+    const send = () => {
+      if (this._ws.readyState === WebSocket.CLOSING || this._ws.readyState === WebSocket.CLOSED) {
+        import_log.log.warn("send called for closed websocket", void 0, {
+          F: __dxlog_file2,
+          L: 139,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        this._sendTimeout = void 0;
+        return;
+      }
+      let timeout = 0;
+      const emptyChannels = [];
+      for (const [channelId, messages] of this._outMessageChunks.entries()) {
+        if (this._ws.bufferedAmount != null) {
+          if (this._ws.bufferedAmount + MAX_CHUNK_LENGTH > MAX_BUFFERED_AMOUNT) {
+            timeout = BUFFER_FULL_BACKOFF_TIMEOUT;
+            break;
+          }
+        }
+        const nextMessage = messages.shift();
+        if (nextMessage) {
+          this._ws.send(nextMessage.payload);
+          nextMessage.trigger?.wake();
+        } else {
+          emptyChannels.push(channelId);
+        }
+      }
+      emptyChannels.forEach((channelId) => this._outMessageChunks.delete(channelId));
+      if (this._outMessageChunks.size > 0) {
+        this._sendTimeout = setTimeout(send, timeout);
+      } else {
+        this._sendTimeout = void 0;
+      }
+    };
+    this._sendTimeout = setTimeout(send);
+  }
+  _resolveChannel(message) {
+    if (!message.serviceId) {
+      return void 0;
+    }
+    let id = this._outMessageChannelByService.get(message.serviceId);
+    if (!id) {
+      id = this._outMessageChannelByService.size + 1;
+      this._outMessageChannelByService.set(message.serviceId, id);
+    }
+    return id;
+  }
+};
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/core/mesh/edge-client/src/edge-ws-connection.ts";
+var SIGNAL_KEEPALIVE_INTERVAL = 4e3;
+var SIGNAL_KEEPALIVE_TIMEOUT = 12e3;
+var EDGE_WEBSOCKET_PROTOCOL_V0 = "edge-ws-v0";
+var EDGE_WEBSOCKET_PROTOCOL_V1 = "edge-ws-v1";
+var EdgeWsConnection = class extends import_context.Resource {
+  constructor(_identity, _connectionInfo, _callbacks) {
+    super();
+    this._identity = _identity;
+    this._connectionInfo = _connectionInfo;
+    this._callbacks = _callbacks;
+  }
+  get info() {
+    return {
+      open: this.isOpen,
+      identity: this._identity.identityKey,
+      device: this._identity.peerKey
+    };
+  }
+  send(message) {
+    (0, import_invariant2.invariant)(this._ws, void 0, {
+      F: __dxlog_file3,
+      L: 57,
+      S: this,
+      A: [
+        "this._ws",
+        ""
+      ]
+    });
+    (0, import_invariant2.invariant)(this._wsMuxer, void 0, {
+      F: __dxlog_file3,
+      L: 58,
+      S: this,
+      A: [
+        "this._wsMuxer",
+        ""
+      ]
+    });
+    (0, import_log2.log)("sending...", {
+      peerKey: this._identity.peerKey,
+      payload: protocol.getPayloadType(message)
+    }, {
+      F: __dxlog_file3,
+      L: 59,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    if (this._ws?.protocol.includes(EDGE_WEBSOCKET_PROTOCOL_V0)) {
+      const binary = import_buf4.buf.toBinary(import_messenger_pb4.MessageSchema, message);
+      if (binary.length > CLOUDFLARE_MESSAGE_MAX_BYTES) {
+        import_log2.log.error("Message dropped because it was too large (>1MB).", {
+          byteLength: binary.byteLength,
+          serviceId: message.serviceId,
+          payload: protocol.getPayloadType(message)
+        }, {
+          F: __dxlog_file3,
+          L: 63,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        return;
+      }
+      this._ws.send(binary);
+    } else {
+      this._wsMuxer.send(message).catch((e) => import_log2.log.catch(e, void 0, {
+        F: __dxlog_file3,
+        L: 72,
+        S: this,
+        C: (f, a) => f(...a)
+      }));
+    }
+  }
+  async _open() {
+    const baseProtocols = [
+      EDGE_WEBSOCKET_PROTOCOL_V0,
+      EDGE_WEBSOCKET_PROTOCOL_V1
+    ];
+    this._ws = new import_isomorphic_ws.default(this._connectionInfo.url.toString(), this._connectionInfo.protocolHeader ? [
+      ...baseProtocols,
+      this._connectionInfo.protocolHeader
+    ] : [
+      ...baseProtocols
+    ]);
+    const muxer = new WebSocketMuxer(this._ws);
+    this._wsMuxer = muxer;
+    this._ws.onopen = () => {
+      if (this.isOpen) {
+        (0, import_log2.log)("connected", void 0, {
+          F: __dxlog_file3,
+          L: 89,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        this._callbacks.onConnected();
+        this._scheduleHeartbeats();
+      } else {
+        import_log2.log.verbose("connected after becoming inactive", {
+          currentIdentity: this._identity
+        }, {
+          F: __dxlog_file3,
+          L: 93,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+      }
+    };
+    this._ws.onclose = (event) => {
+      if (this.isOpen) {
+        import_log2.log.warn("disconnected while being open", {
+          code: event.code,
+          reason: event.reason
+        }, {
+          F: __dxlog_file3,
+          L: 98,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        this._callbacks.onRestartRequired();
+        muxer.destroy();
+      }
+    };
+    this._ws.onerror = (event) => {
+      if (this.isOpen) {
+        import_log2.log.warn("edge connection socket error", {
+          error: event.error,
+          info: event.message
+        }, {
+          F: __dxlog_file3,
+          L: 105,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        this._callbacks.onRestartRequired();
+      } else {
+        import_log2.log.verbose("error ignored on closed connection", {
+          error: event.error
+        }, {
+          F: __dxlog_file3,
+          L: 108,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+      }
+    };
+    this._ws.onmessage = async (event) => {
+      if (!this.isOpen) {
+        import_log2.log.verbose("message ignored on closed connection", {
+          event: event.type
+        }, {
+          F: __dxlog_file3,
+          L: 116,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        return;
+      }
+      if (event.data === "__pong__") {
+        this._rescheduleHeartbeatTimeout();
+        return;
+      }
+      const bytes = await toUint8Array(event.data);
+      if (!this.isOpen) {
+        return;
+      }
+      const message = this._ws?.protocol?.includes(EDGE_WEBSOCKET_PROTOCOL_V0) ? import_buf4.buf.fromBinary(import_messenger_pb4.MessageSchema, bytes) : muxer.receiveData(bytes);
+      if (message) {
+        (0, import_log2.log)("received", {
+          from: message.source,
+          payload: protocol.getPayloadType(message)
+        }, {
+          F: __dxlog_file3,
+          L: 133,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        this._callbacks.onMessage(message);
+      }
+    };
+  }
+  async _close() {
+    void this._inactivityTimeoutCtx?.dispose().catch(() => {
+    });
+    try {
+      this._ws?.close();
+      this._ws = void 0;
+      this._wsMuxer?.destroy();
+      this._wsMuxer = void 0;
+    } catch (err) {
+      if (err instanceof Error && err.message.includes("WebSocket is closed before the connection is established.")) {
+        return;
+      }
+      import_log2.log.warn("Error closing websocket", {
+        err
+      }, {
+        F: __dxlog_file3,
+        L: 151,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    }
+  }
+  _scheduleHeartbeats() {
+    (0, import_invariant2.invariant)(this._ws, void 0, {
+      F: __dxlog_file3,
+      L: 156,
+      S: this,
+      A: [
+        "this._ws",
+        ""
+      ]
+    });
+    (0, import_async2.scheduleTaskInterval)(this._ctx, async () => {
+      this._ws?.send("__ping__");
+    }, SIGNAL_KEEPALIVE_INTERVAL);
+    this._ws.send("__ping__");
+    this._rescheduleHeartbeatTimeout();
+  }
+  _rescheduleHeartbeatTimeout() {
+    if (!this.isOpen) {
+      return;
+    }
+    void this._inactivityTimeoutCtx?.dispose();
+    this._inactivityTimeoutCtx = new import_context.Context(void 0, {
+      F: __dxlog_file3,
+      L: 175
+    });
+    (0, import_async2.scheduleTask)(this._inactivityTimeoutCtx, () => {
+      if (this.isOpen) {
+        import_log2.log.warn("restart due to inactivity timeout", void 0, {
+          F: __dxlog_file3,
+          L: 180,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        this._callbacks.onRestartRequired();
+      }
+    }, SIGNAL_KEEPALIVE_TIMEOUT);
+  }
+};
+_ts_decorate([
+  import_log2.logInfo
+], EdgeWsConnection.prototype, "info", null);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CLOUDFLARE_MESSAGE_MAX_BYTES,
+  CLOUDFLARE_RPC_MAX_BYTES,
+  EDGE_WEBSOCKET_PROTOCOL_V0,
+  EDGE_WEBSOCKET_PROTOCOL_V1,
+  EdgeWsConnection,
+  Protocol,
+  WebSocketMuxer,
+  getTypename,
+  protocol,
+  toUint8Array
+});
+//# sourceMappingURL=chunk-FQM4JFRT.cjs.map

package/dist/lib/node/chunk-FQM4JFRT.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/protocol.ts", "../../../src/defs.ts", "../../../src/edge-ws-muxer.ts", "../../../src/edge-ws-connection.ts"],
+  "sourcesContent": ["//\n// Copyright 2024 DXOS.org\n//\n\nimport { invariant } from '@dxos/invariant';\nimport { buf, bufWkt } from '@dxos/protocols/buf';\nimport { type Message, MessageSchema, type PeerSchema } from '@dxos/protocols/buf/dxos/edge/messenger_pb';\nimport { bufferToArray } from '@dxos/util';\n\nexport type PeerData = buf.MessageInitShape<typeof PeerSchema>;\n\nexport const getTypename = (typeName: string) => `type.googleapis.com/${typeName}`;\n\n/**\n * NOTE: The type registry should be extended with all message types.\n */\nexport class Protocol {\n  private readonly _typeRegistry: buf.Registry;\n\n  constructor(types: buf.DescMessage[]) {\n    this._typeRegistry = buf.createRegistry(...types);\n  }\n\n  get typeRegistry(): buf.Registry {\n    return this._typeRegistry;\n  }\n\n  toJson(message: Message): any {\n    try {\n      return buf.toJson(MessageSchema, message, { registry: this.typeRegistry });\n    } catch (err) {\n      return { type: this.getPayloadType(message) };\n    }\n  }\n\n  /**\n   * Return the payload with the given type.\n   */\n  getPayload<Desc extends buf.DescMessage>(message: Message, type: Desc): buf.MessageShape<Desc> {\n    invariant(message.payload);\n    const payloadTypename = this.getPayloadType(message);\n    if (type && type.typeName !== payloadTypename) {\n      throw new Error(`Unexpected payload type: ${payloadTypename}; expected ${type.typeName}`);\n    }\n\n    invariant(bufWkt.anyIs(message.payload, type), `Unexpected payload type: ${payloadTypename}}`);\n    const payload = bufWkt.anyUnpack(message.payload, this.typeRegistry) as buf.MessageShape<Desc>;\n    invariant(payload, `Empty payload: ${payloadTypename}}`);\n    return payload;\n  }\n\n  /**\n   * Get the payload type.\n   */\n  getPayloadType(message: Message): string | undefined {\n    if (!message.payload) {\n      return undefined;\n    }\n\n    const [, type] = message.payload.typeUrl.split('/');\n    return type;\n  }\n\n  /**\n   * Create a packed message.\n   */\n  createMessage<Desc extends buf.DescMessage>(\n    type: Desc,\n    {\n      source,\n      target,\n      payload,\n      serviceId,\n    }: {\n      source?: PeerData;\n      target?: PeerData[];\n      payload?: buf.MessageInitShape<Desc>;\n      serviceId?: string;\n    },\n  ) {\n    return buf.create(MessageSchema, {\n      timestamp: new Date().toISOString(),\n      source,\n      target,\n      serviceId,\n      payload: payload ? bufWkt.anyPack(type, buf.create(type, payload)) : undefined,\n    });\n  }\n}\n\n/**\n * Convert websocket data to Uint8Array.\n */\nexport const toUint8Array = async (data: any): Promise<Uint8Array> => {\n  // Node.\n  if (data instanceof Buffer) {\n    return bufferToArray(data);\n  }\n\n  // Browser.\n  if (data instanceof Blob) {\n    return new Uint8Array(await (data as Blob).arrayBuffer());\n  }\n\n  throw new Error(`Unexpected datatype: ${data}`);\n};\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport { bufWkt } from '@dxos/protocols/buf';\nimport { SwarmRequestSchema, SwarmResponseSchema, TextMessageSchema } from '@dxos/protocols/buf/dxos/edge/messenger_pb';\n\nimport { Protocol } from './protocol';\n\nexport const protocol = new Protocol([SwarmRequestSchema, SwarmResponseSchema, TextMessageSchema, bufWkt.AnySchema]);\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport { Trigger } from '@dxos/async';\nimport { log } from '@dxos/log';\nimport { buf } from '@dxos/protocols/buf';\nimport { MessageSchema, type Message } from '@dxos/protocols/buf/dxos/edge/messenger_pb';\n\nimport { protocol } from './defs';\n\n/**\n * 0000 0001 - message contains a part of segmented message chunk sequence.\n * The next byte defines a channel id and the rest of the message contains a part of Message proto binary.\n * Messages from different channels might interleave.\n * When the flag is NOT set the rest of the message should be interpreted as the valid Message proto binary.\n */\nconst FLAG_SEGMENT_SEQ = 1;\n/**\n * 0000 0010 - message terminates a segmented message chunk sequence.\n * All the chunks accumulated for the channel specified by the second byte can be concatenated\n * and interpreted as a valid Message proto binary.\n */\nconst FLAG_SEGMENT_SEQ_TERMINATED = 1 << 1;\n\n/**\n * https://developers.cloudflare.com/durable-objects/platform/limits/\n */\nexport const CLOUDFLARE_MESSAGE_MAX_BYTES = 1000 * 1000; // 1MB\nexport const CLOUDFLARE_RPC_MAX_BYTES = 32 * 1000 * 1000; // 32MB\n\nconst MAX_CHUNK_LENGTH = 16384;\nconst MAX_BUFFERED_AMOUNT = CLOUDFLARE_MESSAGE_MAX_BYTES;\nconst BUFFER_FULL_BACKOFF_TIMEOUT = 100;\n\nexport class WebSocketMuxer {\n  private readonly _inMessageAccumulator = new Map<number, Buffer[]>();\n  private readonly _outMessageChunks = new Map<number, MessageChunk[]>();\n  private readonly _outMessageChannelByService = new Map<string, number>();\n\n  private _sendTimeout: any | undefined;\n\n  constructor(private readonly _ws: WebSocketCompat) {}\n\n  /**\n   * Resolves when all the message chunks get enqueued for sending.\n   */\n  public async send(message: Message): Promise<void> {\n    const binary = buf.toBinary(MessageSchema, message);\n    const channelId = this._resolveChannel(message);\n    if (\n      (channelId == null && binary.byteLength > CLOUDFLARE_MESSAGE_MAX_BYTES) ||\n      binary.byteLength > CLOUDFLARE_RPC_MAX_BYTES\n    ) {\n      log.error('Large message dropped', {\n        byteLength: binary.byteLength,\n        serviceId: message.serviceId,\n        payload: protocol.getPayloadType(message),\n        channelId,\n      });\n      return;\n    }\n\n    if (channelId == null || binary.length < MAX_CHUNK_LENGTH) {\n      const flags = Buffer.from([0]);\n      this._ws.send(Buffer.concat([flags, binary]));\n      return;\n    }\n\n    const terminatorSentTrigger = new Trigger();\n    const messageChunks: MessageChunk[] = [];\n    for (let i = 0; i < binary.length; i += MAX_CHUNK_LENGTH) {\n      const chunk = binary.slice(i, i + MAX_CHUNK_LENGTH);\n      const isLastChunk = i + MAX_CHUNK_LENGTH < binary.length;\n      if (isLastChunk) {\n        const flags = Buffer.from([FLAG_SEGMENT_SEQ | FLAG_SEGMENT_SEQ_TERMINATED, channelId]);\n        messageChunks.push({ payload: Buffer.concat([flags, chunk]), trigger: terminatorSentTrigger });\n      } else {\n        const flags = Buffer.from([FLAG_SEGMENT_SEQ]);\n        messageChunks.push({ payload: Buffer.concat([flags, chunk]) });\n      }\n    }\n\n    const queuedMessages = this._outMessageChunks.get(channelId);\n    if (queuedMessages) {\n      queuedMessages.push(...messageChunks);\n    } else {\n      this._outMessageChunks.set(channelId, messageChunks);\n    }\n\n    this._sendChunkedMessages();\n\n    return terminatorSentTrigger.wait();\n  }\n\n  public receiveData(data: Uint8Array): Message | undefined {\n    if ((data[0] & FLAG_SEGMENT_SEQ) === 0) {\n      return buf.fromBinary(MessageSchema, data.slice(1));\n    }\n\n    const [flags, channelId, ...payload] = data;\n    let chunkAccumulator = this._inMessageAccumulator.get(channelId);\n    if (chunkAccumulator) {\n      chunkAccumulator.push(Buffer.from(payload));\n    } else {\n      chunkAccumulator = [Buffer.from(payload)];\n      this._inMessageAccumulator.set(channelId, chunkAccumulator);\n    }\n\n    if ((flags & FLAG_SEGMENT_SEQ_TERMINATED) === 0) {\n      return undefined;\n    }\n\n    const message = buf.fromBinary(MessageSchema, Buffer.concat(chunkAccumulator));\n    this._inMessageAccumulator.delete(channelId);\n    return message;\n  }\n\n  public destroy() {\n    if (this._sendTimeout) {\n      clearTimeout(this._sendTimeout);\n      this._sendTimeout = undefined;\n    }\n    for (const channelChunks of this._outMessageChunks.values()) {\n      channelChunks.forEach((chunk) => chunk.trigger?.wake());\n    }\n    this._outMessageChunks.clear();\n    this._inMessageAccumulator.clear();\n    this._outMessageChannelByService.clear();\n  }\n\n  private _sendChunkedMessages() {\n    if (this._sendTimeout) {\n      return;\n    }\n\n    const send = () => {\n      if (this._ws.readyState === WebSocket.CLOSING || this._ws.readyState === WebSocket.CLOSED) {\n        log.warn('send called for closed websocket');\n        this._sendTimeout = undefined;\n        return;\n      }\n\n      let timeout = 0;\n      const emptyChannels: number[] = [];\n      for (const [channelId, messages] of this._outMessageChunks.entries()) {\n        if (this._ws.bufferedAmount != null) {\n          if (this._ws.bufferedAmount + MAX_CHUNK_LENGTH > MAX_BUFFERED_AMOUNT) {\n            timeout = BUFFER_FULL_BACKOFF_TIMEOUT;\n            break;\n          }\n        }\n\n        const nextMessage = messages.shift();\n        if (nextMessage) {\n          this._ws.send(nextMessage.payload);\n          nextMessage.trigger?.wake();\n        } else {\n          emptyChannels.push(channelId);\n        }\n      }\n\n      emptyChannels.forEach((channelId) => this._outMessageChunks.delete(channelId));\n\n      if (this._outMessageChunks.size > 0) {\n        this._sendTimeout = setTimeout(send, timeout);\n      } else {\n        this._sendTimeout = undefined;\n      }\n    };\n    this._sendTimeout = setTimeout(send);\n  }\n\n  private _resolveChannel(message: Message): number | undefined {\n    if (!message.serviceId) {\n      return undefined;\n    }\n    let id = this._outMessageChannelByService.get(message.serviceId);\n    if (!id) {\n      id = this._outMessageChannelByService.size + 1;\n      this._outMessageChannelByService.set(message.serviceId, id);\n    }\n    return id;\n  }\n}\n\ntype WebSocketCompat = {\n  readonly readyState: number;\n  /**\n   * Not available in workerd.\n   */\n  bufferedAmount?: number;\n  send(message: (ArrayBuffer | ArrayBufferView) | string): void;\n};\n\ntype MessageChunk = {\n  payload: Buffer;\n  /**\n   * Wakes when the payload is enqueued by WebSocket.\n   */\n  trigger?: Trigger;\n};\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport WebSocket from 'isomorphic-ws';\n\nimport { scheduleTask, scheduleTaskInterval } from '@dxos/async';\nimport { Context, Resource } from '@dxos/context';\nimport { invariant } from '@dxos/invariant';\nimport { log, logInfo } from '@dxos/log';\nimport { buf } from '@dxos/protocols/buf';\nimport { MessageSchema, type Message } from '@dxos/protocols/buf/dxos/edge/messenger_pb';\n\nimport { protocol } from './defs';\nimport { type EdgeIdentity } from './edge-identity';\nimport { CLOUDFLARE_MESSAGE_MAX_BYTES, WebSocketMuxer } from './edge-ws-muxer';\nimport { toUint8Array } from './protocol';\n\nconst SIGNAL_KEEPALIVE_INTERVAL = 4_000;\nconst SIGNAL_KEEPALIVE_TIMEOUT = 12_000;\n\nexport const EDGE_WEBSOCKET_PROTOCOL_V0 = 'edge-ws-v0';\n/**\n * Supports message segmentation and muxing.\n */\nexport const EDGE_WEBSOCKET_PROTOCOL_V1 = 'edge-ws-v1';\n\nexport type EdgeWsConnectionCallbacks = {\n  onConnected: () => void;\n  onMessage: (message: Message) => void;\n  onRestartRequired: () => void;\n};\n\nexport class EdgeWsConnection extends Resource {\n  private _inactivityTimeoutCtx: Context | undefined;\n  private _ws: WebSocket | undefined;\n  private _wsMuxer: WebSocketMuxer | undefined;\n\n  constructor(\n    private readonly _identity: EdgeIdentity,\n    private readonly _connectionInfo: { url: URL; protocolHeader?: string },\n    private readonly _callbacks: EdgeWsConnectionCallbacks,\n  ) {\n    super();\n  }\n\n  @logInfo\n  public get info() {\n    return {\n      open: this.isOpen,\n      identity: this._identity.identityKey,\n      device: this._identity.peerKey,\n    };\n  }\n\n  public send(message: Message) {\n    invariant(this._ws);\n    invariant(this._wsMuxer);\n    log('sending...', { peerKey: this._identity.peerKey, payload: protocol.getPayloadType(message) });\n    if (this._ws?.protocol.includes(EDGE_WEBSOCKET_PROTOCOL_V0)) {\n      const binary = buf.toBinary(MessageSchema, message);\n      if (binary.length > CLOUDFLARE_MESSAGE_MAX_BYTES) {\n        log.error('Message dropped because it was too large (>1MB).', {\n          byteLength: binary.byteLength,\n          serviceId: message.serviceId,\n          payload: protocol.getPayloadType(message),\n        });\n        return;\n      }\n      this._ws.send(binary);\n    } else {\n      this._wsMuxer.send(message).catch((e) => log.catch(e));\n    }\n  }\n\n  protected override async _open() {\n    const baseProtocols = [EDGE_WEBSOCKET_PROTOCOL_V0, EDGE_WEBSOCKET_PROTOCOL_V1];\n    this._ws = new WebSocket(\n      this._connectionInfo.url.toString(),\n      this._connectionInfo.protocolHeader\n        ? [...baseProtocols, this._connectionInfo.protocolHeader]\n        : [...baseProtocols],\n    );\n    const muxer = new WebSocketMuxer(this._ws);\n    this._wsMuxer = muxer;\n\n    this._ws.onopen = () => {\n      if (this.isOpen) {\n        log('connected');\n        this._callbacks.onConnected();\n        this._scheduleHeartbeats();\n      } else {\n        log.verbose('connected after becoming inactive', { currentIdentity: this._identity });\n      }\n    };\n    this._ws.onclose = (event) => {\n      if (this.isOpen) {\n        log.warn('disconnected while being open', { code: event.code, reason: event.reason });\n        this._callbacks.onRestartRequired();\n        muxer.destroy();\n      }\n    };\n    this._ws.onerror = (event) => {\n      if (this.isOpen) {\n        log.warn('edge connection socket error', { error: event.error, info: event.message });\n        this._callbacks.onRestartRequired();\n      } else {\n        log.verbose('error ignored on closed connection', { error: event.error });\n      }\n    };\n    /**\n     * https://developer.mozilla.org/en-US/docs/Web/API/MessageEvent/data\n     */\n    this._ws.onmessage = async (event) => {\n      if (!this.isOpen) {\n        log.verbose('message ignored on closed connection', { event: event.type });\n        return;\n      }\n      if (event.data === '__pong__') {\n        this._rescheduleHeartbeatTimeout();\n        return;\n      }\n      const bytes = await toUint8Array(event.data);\n      if (!this.isOpen) {\n        return;\n      }\n\n      const message = this._ws?.protocol?.includes(EDGE_WEBSOCKET_PROTOCOL_V0)\n        ? buf.fromBinary(MessageSchema, bytes)\n        : muxer.receiveData(bytes);\n\n      if (message) {\n        log('received', { from: message.source, payload: protocol.getPayloadType(message) });\n        this._callbacks.onMessage(message);\n      }\n    };\n  }\n\n  protected override async _close() {\n    void this._inactivityTimeoutCtx?.dispose().catch(() => {});\n\n    try {\n      this._ws?.close();\n      this._ws = undefined;\n      this._wsMuxer?.destroy();\n      this._wsMuxer = undefined;\n    } catch (err) {\n      if (err instanceof Error && err.message.includes('WebSocket is closed before the connection is established.')) {\n        return;\n      }\n      log.warn('Error closing websocket', { err });\n    }\n  }\n\n  private _scheduleHeartbeats() {\n    invariant(this._ws);\n    scheduleTaskInterval(\n      this._ctx,\n      async () => {\n        // TODO(mykola): use RFC6455 ping/pong once implemented in the browser?\n        // Cloudflare's worker responds to this `without interrupting hibernation`. https://developers.cloudflare.com/durable-objects/api/websockets/#setwebsocketautoresponse\n        this._ws?.send('__ping__');\n      },\n      SIGNAL_KEEPALIVE_INTERVAL,\n    );\n    this._ws.send('__ping__');\n    this._rescheduleHeartbeatTimeout();\n  }\n\n  private _rescheduleHeartbeatTimeout() {\n    if (!this.isOpen) {\n      return;\n    }\n    void this._inactivityTimeoutCtx?.dispose();\n    this._inactivityTimeoutCtx = new Context();\n    scheduleTask(\n      this._inactivityTimeoutCtx,\n      () => {\n        if (this.isOpen) {\n          log.warn('restart due to inactivity timeout');\n          this._callbacks.onRestartRequired();\n        }\n      },\n      SIGNAL_KEEPALIVE_TIMEOUT,\n    );\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["import_buf", "import_messenger_pb", "import_async", "import_invariant", "import_log", "getTypename", "typeName", "Protocol", "constructor", "types", "_typeRegistry", "buf", "createRegistry", "typeRegistry", "toJson", "message", "MessageSchema", "registry", "err", "type", "getPayloadType", "getPayload", "invariant", "payload", "payloadTypename", "Error", "bufWkt", "anyIs", "anyUnpack", "undefined", "typeUrl", "split", "createMessage", "source", "target", "serviceId", "create", "timestamp", "Date", "toISOString", "anyPack", "toUint8Array", "data", "Buffer", "bufferToArray", "Blob", "Uint8Array", "arrayBuffer", "protocol", "SwarmRequestSchema", "SwarmResponseSchema", "TextMessageSchema", "AnySchema", "FLAG_SEGMENT_SEQ", "FLAG_SEGMENT_SEQ_TERMINATED", "CLOUDFLARE_MESSAGE_MAX_BYTES", "CLOUDFLARE_RPC_MAX_BYTES", "MAX_CHUNK_LENGTH", "MAX_BUFFERED_AMOUNT", "BUFFER_FULL_BACKOFF_TIMEOUT", "WebSocketMuxer", "_ws", "_inMessageAccumulator", "Map", "_outMessageChunks", "_outMessageChannelByService", "send", "binary", "toBinary", "channelId", "_resolveChannel", "byteLength", "log", "error", "length", "flags", "from", "concat", "terminatorSentTrigger", "Trigger", "messageChunks", "i", "chunk", "slice", "isLastChunk", "push", "trigger", "queuedMessages", "get", "set", "_sendChunkedMessages", "wait", "receiveData", "fromBinary", "chunkAccumulator", "delete", "destroy", "_sendTimeout", "clearTimeout", "channelChunks", "values", "forEach", "wake", "clear", "readyState", "WebSocket", "CLOSING", "CLOSED", "warn", "timeout", "emptyChannels", "messages", "entries", "bufferedAmount", "nextMessage", "shift", "size", "setTimeout", "id", "SIGNAL_KEEPALIVE_INTERVAL", "SIGNAL_KEEPALIVE_TIMEOUT", "EDGE_WEBSOCKET_PROTOCOL_V0", "EDGE_WEBSOCKET_PROTOCOL_V1", "EdgeWsConnection", "Resource", "_identity", "_connectionInfo", "_callbacks", "info", "open", "isOpen", "identity", "identityKey", "device", "peerKey", "_wsMuxer", "includes", "catch", "e", "_open", "baseProtocols", "url", "toString", "protocolHeader", "muxer", "onopen", "onConnected", "_scheduleHeartbeats", "verbose", "currentIdentity", "onclose", "event", "code", "reason", "onRestartRequired", "onerror", "onmessage", "_rescheduleHeartbeatTimeout", "bytes", "onMessage", "_close", "_inactivityTimeoutCtx", "dispose", "close", "scheduleTaskInterval", "_ctx", "Context", "scheduleTask", "logInfo"]
+}