@dxos/edge-client 0.6.11 → 0.6.12-main.5a87ad5

package/dist/lib/node/testing/index.cjs

@@ -0,0 +1,152 @@
+"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 testing_exports = {};
+__export(testing_exports, {
+  DEFAULT_PORT: () => DEFAULT_PORT,
+  createTestEdgeWsServer: () => createTestEdgeWsServer
+});
+module.exports = __toCommonJS(testing_exports);
+var import_chunk_ANV2HBEH = require("../chunk-ANV2HBEH.cjs");
+var import_isomorphic_ws = __toESM(require("isomorphic-ws"));
+var import_async = require("@dxos/async");
+var import_log = require("@dxos/log");
+var import_buf = require("@dxos/protocols/buf");
+var import_messenger_pb = require("@dxos/protocols/buf/dxos/edge/messenger_pb");
+var __dxlog_file = "/home/runner/work/dxos/dxos/packages/core/mesh/edge-client/src/testing/test-utils.ts";
+var DEFAULT_PORT = 8080;
+var createTestEdgeWsServer = async (port = DEFAULT_PORT, params) => {
+  const server = new import_isomorphic_ws.default.Server({
+    port,
+    verifyClient: createConnectionDelayHandler(params)
+  });
+  let connection;
+  const messageSink = [];
+  const closeTrigger = new import_async.Trigger();
+  const sendResponseMessage = createResponseSender(() => connection);
+  server.on("connection", (ws) => {
+    connection = ws;
+    ws.on("error", (err) => import_log.log.catch(err, void 0, {
+      F: __dxlog_file,
+      L: 34,
+      S: void 0,
+      C: (f, a) => f(...a)
+    }));
+    ws.on("message", async (data) => {
+      if (String(data) === "__ping__") {
+        ws.send("__pong__");
+        return;
+      }
+      const { request, requestPayload } = await decodeRequest(params, data);
+      if (params?.messageHandler) {
+        const responsePayload = await params.messageHandler(requestPayload);
+        if (responsePayload && connection) {
+          sendResponseMessage(request, responsePayload);
+        }
+      }
+      (0, import_log.log)("message", {
+        payload: requestPayload
+      }, {
+        F: __dxlog_file,
+        L: 47,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+      messageSink.push(requestPayload);
+    });
+    ws.on("close", () => {
+      connection = void 0;
+      closeTrigger.wake();
+    });
+  });
+  return {
+    server,
+    messageSink,
+    endpoint: `ws://localhost:${port}`,
+    cleanup: () => server.close(),
+    currentConnection: () => connection,
+    sendResponseMessage,
+    closeConnection: () => {
+      closeTrigger.reset();
+      connection.close(1011);
+      return closeTrigger.wait();
+    }
+  };
+};
+var createConnectionDelayHandler = (params) => {
+  return (_, callback) => {
+    if (params?.admitConnection) {
+      (0, import_log.log)("delaying edge connection admission", void 0, {
+        F: __dxlog_file,
+        L: 75,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+      void params.admitConnection.wait().then(() => {
+        callback(true);
+        (0, import_log.log)("edge connection admitted", void 0, {
+          F: __dxlog_file,
+          L: 78,
+          S: void 0,
+          C: (f, a) => f(...a)
+        });
+      });
+    } else {
+      callback(true);
+    }
+  };
+};
+var createResponseSender = (connection) => {
+  return (request, responsePayload) => {
+    const recipient = request.source;
+    connection().send(import_buf.buf.toBinary(import_messenger_pb.MessageSchema, import_buf.buf.create(import_messenger_pb.MessageSchema, {
+      source: {
+        identityKey: recipient.identityKey,
+        peerKey: recipient.peerKey
+      },
+      serviceId: request.serviceId,
+      payload: {
+        value: responsePayload
+      }
+    })));
+  };
+};
+var decodeRequest = async (params, data) => {
+  const request = import_buf.buf.fromBinary(import_messenger_pb.MessageSchema, await (0, import_chunk_ANV2HBEH.toUint8Array)(data));
+  const requestPayload = params?.payloadDecoder ? params.payloadDecoder(request.payload.value) : import_chunk_ANV2HBEH.protocol.getPayload(request, import_messenger_pb.TextMessageSchema);
+  return {
+    request,
+    requestPayload
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_PORT,
+  createTestEdgeWsServer
+});
+//# sourceMappingURL=index.cjs.map

package/dist/lib/node/testing/index.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/testing/test-utils.ts"],
+  "sourcesContent": ["//\n// Copyright 2024 DXOS.org\n//\n\nimport WebSocket from 'isomorphic-ws';\n\nimport { Trigger } from '@dxos/async';\nimport { log } from '@dxos/log';\nimport { buf } from '@dxos/protocols/buf';\nimport { MessageSchema, TextMessageSchema, type Message } from '@dxos/protocols/buf/dxos/edge/messenger_pb';\n\nimport { protocol } from '../defs';\nimport { toUint8Array } from '../protocol';\n\nexport const DEFAULT_PORT = 8080;\n\ntype TestEdgeWsServerParams = {\n  admitConnection?: Trigger;\n  payloadDecoder?: (payload: Uint8Array) => any;\n  messageHandler?: (payload: any) => Promise<Uint8Array | undefined>;\n};\n\nexport const createTestEdgeWsServer = async (port = DEFAULT_PORT, params?: TestEdgeWsServerParams) => {\n  const server = new WebSocket.Server({ port, verifyClient: createConnectionDelayHandler(params) });\n\n  let connection: WebSocket | undefined;\n\n  const messageSink: any[] = [];\n  const closeTrigger = new Trigger();\n  const sendResponseMessage = createResponseSender(() => connection!);\n\n  server.on('connection', (ws) => {\n    connection = ws;\n    ws.on('error', (err) => log.catch(err));\n    ws.on('message', async (data) => {\n      if (String(data) === '__ping__') {\n        ws.send('__pong__');\n        return;\n      }\n      const { request, requestPayload } = await decodeRequest(params, data);\n      if (params?.messageHandler) {\n        const responsePayload = await params.messageHandler(requestPayload);\n        if (responsePayload && connection) {\n          sendResponseMessage(request, responsePayload);\n        }\n      }\n      log('message', { payload: requestPayload });\n      messageSink.push(requestPayload);\n    });\n\n    ws.on('close', () => {\n      connection = undefined;\n      closeTrigger.wake();\n    });\n  });\n\n  return {\n    server,\n    messageSink,\n    endpoint: `ws://localhost:${port}`,\n    cleanup: () => server.close(),\n    currentConnection: () => connection,\n    sendResponseMessage,\n    closeConnection: () => {\n      closeTrigger.reset();\n      connection!.close(1011);\n      return closeTrigger.wait();\n    },\n  };\n};\n\nconst createConnectionDelayHandler = (params: TestEdgeWsServerParams | undefined) => {\n  return (_: any, callback: (admit: boolean) => void) => {\n    if (params?.admitConnection) {\n      log('delaying edge connection admission');\n      void params.admitConnection.wait().then(() => {\n        callback(true);\n        log('edge connection admitted');\n      });\n    } else {\n      callback(true);\n    }\n  };\n};\n\nconst createResponseSender = (connection: () => WebSocket) => {\n  return (request: Message, responsePayload: Uint8Array) => {\n    const recipient = request.source!;\n    connection().send(\n      buf.toBinary(\n        MessageSchema,\n        buf.create(MessageSchema, {\n          source: {\n            identityKey: recipient.identityKey,\n            peerKey: recipient.peerKey,\n          },\n          serviceId: request.serviceId!,\n          payload: { value: responsePayload },\n        }),\n      ),\n    );\n  };\n};\n\nconst decodeRequest = async (params: TestEdgeWsServerParams | undefined, data: any) => {\n  const request = buf.fromBinary(MessageSchema, await toUint8Array(data));\n  const requestPayload = params?.payloadDecoder\n    ? params.payloadDecoder(request.payload!.value!)\n    : protocol.getPayload(request, TextMessageSchema);\n  return { request, requestPayload };\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIA,2BAAsB;AAEtB,mBAAwB;AACxB,iBAAoB;AACpB,iBAAoB;AACpB,0BAA+D;;AAKxD,IAAMA,eAAe;AAQrB,IAAMC,yBAAyB,OAAOC,OAAOF,cAAcG,WAAAA;AAChE,QAAMC,SAAS,IAAIC,qBAAAA,QAAUC,OAAO;IAAEJ;IAAMK,cAAcC,6BAA6BL,MAAAA;EAAQ,CAAA;AAE/F,MAAIM;AAEJ,QAAMC,cAAqB,CAAA;AAC3B,QAAMC,eAAe,IAAIC,qBAAAA;AACzB,QAAMC,sBAAsBC,qBAAqB,MAAML,UAAAA;AAEvDL,SAAOW,GAAG,cAAc,CAACC,OAAAA;AACvBP,iBAAaO;AACbA,OAAGD,GAAG,SAAS,CAACE,QAAQC,eAAIC,MAAMF,KAAAA,QAAAA;;;;;;AAClCD,OAAGD,GAAG,WAAW,OAAOK,SAAAA;AACtB,UAAIC,OAAOD,IAAAA,MAAU,YAAY;AAC/BJ,WAAGM,KAAK,UAAA;AACR;MACF;AACA,YAAM,EAAEC,SAASC,eAAc,IAAK,MAAMC,cAActB,QAAQiB,IAAAA;AAChE,UAAIjB,QAAQuB,gBAAgB;AAC1B,cAAMC,kBAAkB,MAAMxB,OAAOuB,eAAeF,cAAAA;AACpD,YAAIG,mBAAmBlB,YAAY;AACjCI,8BAAoBU,SAASI,eAAAA;QAC/B;MACF;AACAT,0BAAI,WAAW;QAAEU,SAASJ;MAAe,GAAA;;;;;;AACzCd,kBAAYmB,KAAKL,cAAAA;IACnB,CAAA;AAEAR,OAAGD,GAAG,SAAS,MAAA;AACbN,mBAAaqB;AACbnB,mBAAaoB,KAAI;IACnB,CAAA;EACF,CAAA;AAEA,SAAO;IACL3B;IACAM;IACAsB,UAAU,kBAAkB9B,IAAAA;IAC5B+B,SAAS,MAAM7B,OAAO8B,MAAK;IAC3BC,mBAAmB,MAAM1B;IACzBI;IACAuB,iBAAiB,MAAA;AACfzB,mBAAa0B,MAAK;AAClB5B,iBAAYyB,MAAM,IAAA;AAClB,aAAOvB,aAAa2B,KAAI;IAC1B;EACF;AACF;AAEA,IAAM9B,+BAA+B,CAACL,WAAAA;AACpC,SAAO,CAACoC,GAAQC,aAAAA;AACd,QAAIrC,QAAQsC,iBAAiB;AAC3BvB,0BAAI,sCAAA,QAAA;;;;;;AACJ,WAAKf,OAAOsC,gBAAgBH,KAAI,EAAGI,KAAK,MAAA;AACtCF,iBAAS,IAAA;AACTtB,4BAAI,4BAAA,QAAA;;;;;;MACN,CAAA;IACF,OAAO;AACLsB,eAAS,IAAA;IACX;EACF;AACF;AAEA,IAAM1B,uBAAuB,CAACL,eAAAA;AAC5B,SAAO,CAACc,SAAkBI,oBAAAA;AACxB,UAAMgB,YAAYpB,QAAQqB;AAC1BnC,eAAAA,EAAaa,KACXuB,eAAIC,SACFC,mCACAF,eAAIG,OAAOD,mCAAe;MACxBH,QAAQ;QACNK,aAAaN,UAAUM;QACvBC,SAASP,UAAUO;MACrB;MACAC,WAAW5B,QAAQ4B;MACnBvB,SAAS;QAAEwB,OAAOzB;MAAgB;IACpC,CAAA,CAAA,CAAA;EAGN;AACF;AAEA,IAAMF,gBAAgB,OAAOtB,QAA4CiB,SAAAA;AACvE,QAAMG,UAAUsB,eAAIQ,WAAWN,mCAAe,UAAMO,oCAAalC,IAAAA,CAAAA;AACjE,QAAMI,iBAAiBrB,QAAQoD,iBAC3BpD,OAAOoD,eAAehC,QAAQK,QAASwB,KAAK,IAC5CI,+BAASC,WAAWlC,SAASmC,qCAAAA;AACjC,SAAO;IAAEnC;IAASC;EAAe;AACnC;",
+  "names": ["DEFAULT_PORT", "createTestEdgeWsServer", "port", "params", "server", "WebSocket", "Server", "verifyClient", "createConnectionDelayHandler", "connection", "messageSink", "closeTrigger", "Trigger", "sendResponseMessage", "createResponseSender", "on", "ws", "err", "log", "catch", "data", "String", "send", "request", "requestPayload", "decodeRequest", "messageHandler", "responsePayload", "payload", "push", "undefined", "wake", "endpoint", "cleanup", "close", "currentConnection", "closeConnection", "reset", "wait", "_", "callback", "admitConnection", "then", "recipient", "source", "buf", "toBinary", "MessageSchema", "create", "identityKey", "peerKey", "serviceId", "value", "fromBinary", "toUint8Array", "payloadDecoder", "protocol", "getPayload", "TextMessageSchema"]
+}

package/dist/lib/node-esm/chunk-HNVT57AU.mjs

@@ -0,0 +1,115 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+
+// packages/core/mesh/edge-client/src/protocol.ts
+import { invariant } from "@dxos/invariant";
+import { buf, bufWkt } from "@dxos/protocols/buf";
+import { MessageSchema } from "@dxos/protocols/buf/dxos/edge/messenger_pb";
+import { bufferToArray } from "@dxos/util";
+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 = buf.createRegistry(...types);
+  }
+  get typeRegistry() {
+    return this._typeRegistry;
+  }
+  toJson(message) {
+    try {
+      return buf.toJson(MessageSchema, message, {
+        registry: this.typeRegistry
+      });
+    } catch (err) {
+      return {
+        type: this.getPayloadType(message)
+      };
+    }
+  }
+  /**
+  * Return the payload with the given type.
+  */
+  getPayload(message, type) {
+    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}`);
+    }
+    invariant(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 = bufWkt.anyUnpack(message.payload, this.typeRegistry);
+    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 buf.create(MessageSchema, {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      source,
+      target,
+      serviceId,
+      payload: payload ? bufWkt.anyPack(type, buf.create(type, payload)) : void 0
+    });
+  }
+};
+var toUint8Array = async (data) => {
+  if (data instanceof Buffer) {
+    return bufferToArray(data);
+  }
+  if (data instanceof Blob) {
+    return new Uint8Array(await data.arrayBuffer());
+  }
+  throw new Error(`Unexpected datatype: ${data}`);
+};
+
+// packages/core/mesh/edge-client/src/defs.ts
+import { bufWkt as bufWkt2 } from "@dxos/protocols/buf";
+import { SwarmRequestSchema, SwarmResponseSchema, TextMessageSchema } from "@dxos/protocols/buf/dxos/edge/messenger_pb";
+var protocol = new Protocol([
+  SwarmRequestSchema,
+  SwarmResponseSchema,
+  TextMessageSchema,
+  bufWkt2.AnySchema
+]);
+
+export {
+  getTypename,
+  Protocol,
+  toUint8Array,
+  protocol
+};
+//# sourceMappingURL=chunk-HNVT57AU.mjs.map

package/dist/lib/node-esm/chunk-HNVT57AU.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/protocol.ts", "../../../src/defs.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"],
+  "mappings": ";;;AAIA,SAASA,iBAAiB;AAC1B,SAASC,KAAKC,cAAc;AAC5B,SAAuBC,qBAAsC;AAC7D,SAASC,qBAAqB;;AAIvB,IAAMC,cAAc,CAACC,aAAqB,uBAAuBA,QAAAA;AAKjE,IAAMC,WAAN,MAAMA;EAGXC,YAAYC,OAA0B;AACpC,SAAKC,gBAAgBT,IAAIU,eAAc,GAAIF,KAAAA;EAC7C;EAEA,IAAIG,eAA6B;AAC/B,WAAO,KAAKF;EACd;EAEAG,OAAOC,SAAuB;AAC5B,QAAI;AACF,aAAOb,IAAIY,OAAOV,eAAeW,SAAS;QAAEC,UAAU,KAAKH;MAAa,CAAA;IAC1E,SAASI,KAAK;AACZ,aAAO;QAAEC,MAAM,KAAKC,eAAeJ,OAAAA;MAAS;IAC9C;EACF;;;;EAKAK,WAAyCL,SAAkBG,MAAoC;AAC7FjB,cAAUc,QAAQM,SAAO,QAAA;;;;;;;;;AACzB,UAAMC,kBAAkB,KAAKH,eAAeJ,OAAAA;AAC5C,QAAIG,QAAQA,KAAKX,aAAae,iBAAiB;AAC7C,YAAM,IAAIC,MAAM,4BAA4BD,eAAAA,cAA6BJ,KAAKX,QAAQ,EAAE;IAC1F;AAEAN,cAAUE,OAAOqB,MAAMT,QAAQM,SAASH,IAAAA,GAAO,4BAA4BI,eAAAA,KAAkB;;;;;;;;;AAC7F,UAAMD,UAAUlB,OAAOsB,UAAUV,QAAQM,SAAS,KAAKR,YAAY;AACnEZ,cAAUoB,SAAS,kBAAkBC,eAAAA,KAAkB;;;;;;;;;AACvD,WAAOD;EACT;;;;EAKAF,eAAeJ,SAAsC;AACnD,QAAI,CAACA,QAAQM,SAAS;AACpB,aAAOK;IACT;AAEA,UAAM,CAAA,EAAGR,IAAAA,IAAQH,QAAQM,QAAQM,QAAQC,MAAM,GAAA;AAC/C,WAAOV;EACT;;;;EAKAW,cACEX,MACA,EACEY,QACAC,QACAV,SACAW,UAAS,GAOX;AACA,WAAO9B,IAAI+B,OAAO7B,eAAe;MAC/B8B,YAAW,oBAAIC,KAAAA,GAAOC,YAAW;MACjCN;MACAC;MACAC;MACAX,SAASA,UAAUlB,OAAOkC,QAAQnB,MAAMhB,IAAI+B,OAAOf,MAAMG,OAAAA,CAAAA,IAAYK;IACvE,CAAA;EACF;AACF;AAKO,IAAMY,eAAe,OAAOC,SAAAA;AAEjC,MAAIA,gBAAgBC,QAAQ;AAC1B,WAAOnC,cAAckC,IAAAA;EACvB;AAGA,MAAIA,gBAAgBE,MAAM;AACxB,WAAO,IAAIC,WAAW,MAAOH,KAAcI,YAAW,CAAA;EACxD;AAEA,QAAM,IAAIpB,MAAM,wBAAwBgB,IAAAA,EAAM;AAChD;;;ACrGA,SAASK,UAAAA,eAAc;AACvB,SAASC,oBAAoBC,qBAAqBC,yBAAyB;AAIpE,IAAMC,WAAW,IAAIC,SAAS;EAACC;EAAoBC;EAAqBC;EAAmBC,QAAOC;CAAU;",
+  "names": ["invariant", "buf", "bufWkt", "MessageSchema", "bufferToArray", "getTypename", "typeName", "Protocol", "constructor", "types", "_typeRegistry", "createRegistry", "typeRegistry", "toJson", "message", "registry", "err", "type", "getPayloadType", "getPayload", "payload", "payloadTypename", "Error", "anyIs", "anyUnpack", "undefined", "typeUrl", "split", "createMessage", "source", "target", "serviceId", "create", "timestamp", "Date", "toISOString", "anyPack", "toUint8Array", "data", "Buffer", "Blob", "Uint8Array", "arrayBuffer", "bufWkt", "SwarmRequestSchema", "SwarmResponseSchema", "TextMessageSchema", "protocol", "Protocol", "SwarmRequestSchema", "SwarmResponseSchema", "TextMessageSchema", "bufWkt", "AnySchema"]
+}

package/dist/lib/node-esm/index.mjs

@@ -0,0 +1,378 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  Protocol,
+  getTypename,
+  protocol,
+  toUint8Array
+} from "./chunk-HNVT57AU.mjs";
+
+// packages/core/mesh/edge-client/src/index.ts
+export * from "@dxos/protocols/buf/dxos/edge/messenger_pb";
+
+// packages/core/mesh/edge-client/src/edge-client.ts
+import WebSocket from "isomorphic-ws";
+import { Trigger, Event, scheduleTaskInterval, scheduleTask, TriggerState } from "@dxos/async";
+import { Context, LifecycleState as LifecycleState2, Resource as Resource2 } from "@dxos/context";
+import { log as log2 } from "@dxos/log";
+import { buf } from "@dxos/protocols/buf";
+import { MessageSchema } from "@dxos/protocols/buf/dxos/edge/messenger_pb";
+
+// packages/core/mesh/edge-client/src/errors.ts
+var EdgeConnectionClosedError = class extends Error {
+  constructor() {
+    super("Edge connection closed.");
+  }
+};
+var EdgeIdentityChangedError = class extends Error {
+  constructor() {
+    super("Edge identity changed.");
+  }
+};
+
+// packages/core/mesh/edge-client/src/persistent-lifecycle.ts
+import { DeferredTask, sleep, synchronized } from "@dxos/async";
+import { cancelWithContext, LifecycleState, Resource } from "@dxos/context";
+import { warnAfterTimeout } from "@dxos/debug";
+import { log } from "@dxos/log";
+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_file = "/home/runner/work/dxos/dxos/packages/core/mesh/edge-client/src/persistent-lifecycle.ts";
+var INIT_RESTART_DELAY = 100;
+var DEFAULT_MAX_RESTART_DELAY = 5e3;
+var PersistentLifecycle = class extends Resource {
+  constructor({ start, stop, onRestart, maxRestartDelay = DEFAULT_MAX_RESTART_DELAY }) {
+    super();
+    this._restartTask = void 0;
+    this._restartAfter = 0;
+    this._start = start;
+    this._stop = stop;
+    this._onRestart = onRestart;
+    this._maxRestartDelay = maxRestartDelay;
+  }
+  async _open() {
+    this._restartTask = new DeferredTask(this._ctx, async () => {
+      try {
+        await this._restart();
+      } catch (err) {
+        log.warn("Restart failed", {
+          err
+        }, {
+          F: __dxlog_file,
+          L: 64,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        this._restartTask?.schedule();
+      }
+    });
+    await this._start().catch((err) => {
+      log.warn("Start failed", {
+        err
+      }, {
+        F: __dxlog_file,
+        L: 69,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      this._restartTask?.schedule();
+    });
+  }
+  async _close() {
+    await this._restartTask?.join();
+    await this._stop();
+    this._restartTask = void 0;
+  }
+  async _restart() {
+    log(`restarting in ${this._restartAfter}ms`, {
+      state: this._lifecycleState
+    }, {
+      F: __dxlog_file,
+      L: 81,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    await this._stop();
+    if (this._lifecycleState !== LifecycleState.OPEN) {
+      return;
+    }
+    await cancelWithContext(this._ctx, sleep(this._restartAfter));
+    this._restartAfter = Math.min(Math.max(this._restartAfter * 2, INIT_RESTART_DELAY), this._maxRestartDelay);
+    await warnAfterTimeout(5e3, "Connection establishment takes too long", () => this._start());
+    this._restartAfter = 0;
+    await this._onRestart?.();
+  }
+  /**
+  * Scheduling restart should be done from outside.
+  */
+  scheduleRestart() {
+    if (this._lifecycleState !== LifecycleState.OPEN) {
+      return;
+    }
+    this._restartTask.schedule();
+  }
+};
+_ts_decorate([
+  synchronized
+], PersistentLifecycle.prototype, "_open", null);
+_ts_decorate([
+  synchronized
+], PersistentLifecycle.prototype, "scheduleRestart", null);
+
+// packages/core/mesh/edge-client/src/edge-client.ts
+var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/core/mesh/edge-client/src/edge-client.ts";
+var DEFAULT_TIMEOUT = 1e4;
+var SIGNAL_KEEPALIVE_INTERVAL = 5e3;
+var EdgeClient = class extends Resource2 {
+  constructor(_identityKey, _peerKey, _config) {
+    super();
+    this._identityKey = _identityKey;
+    this._peerKey = _peerKey;
+    this._config = _config;
+    this.reconnect = new Event();
+    this.connected = new Event();
+    this._persistentLifecycle = new PersistentLifecycle({
+      start: async () => this._openWebSocket(),
+      stop: async () => this._closeWebSocket(),
+      onRestart: async () => this.reconnect.emit()
+    });
+    this._listeners = /* @__PURE__ */ new Set();
+    this._ready = new Trigger();
+    this._ws = void 0;
+    this._keepaliveCtx = void 0;
+    this._heartBeatContext = void 0;
+  }
+  // TODO(burdon): Attach logging.
+  get info() {
+    return {
+      open: this.isOpen,
+      identity: this._identityKey,
+      device: this._peerKey
+    };
+  }
+  get identityKey() {
+    return this._identityKey;
+  }
+  get peerKey() {
+    return this._peerKey;
+  }
+  setIdentity({ peerKey, identityKey }) {
+    this._peerKey = peerKey;
+    this._identityKey = identityKey;
+    this._persistentLifecycle.scheduleRestart();
+  }
+  addListener(listener) {
+    this._listeners.add(listener);
+    return () => this._listeners.delete(listener);
+  }
+  /**
+  * Open connection to messaging service.
+  */
+  async _open() {
+    log2("opening...", {
+      info: this.info
+    }, {
+      F: __dxlog_file2,
+      L: 100,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    this._persistentLifecycle.open().catch((err) => {
+      log2.warn("Error while opening connection", {
+        err
+      }, {
+        F: __dxlog_file2,
+        L: 102,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    });
+  }
+  /**
+  * Close connection and free resources.
+  */
+  async _close() {
+    log2("closing...", {
+      peerKey: this._peerKey
+    }, {
+      F: __dxlog_file2,
+      L: 110,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    await this._persistentLifecycle.close();
+  }
+  async _openWebSocket() {
+    const url = new URL(`/ws/${this._identityKey}/${this._peerKey}`, this._config.socketEndpoint);
+    this._ws = new WebSocket(url);
+    this._ws.onopen = () => {
+      log2("opened", this.info, {
+        F: __dxlog_file2,
+        L: 119,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      this._ready.wake();
+      this.connected.emit();
+    };
+    this._ws.onclose = () => {
+      log2("closed", this.info, {
+        F: __dxlog_file2,
+        L: 124,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      this._persistentLifecycle.scheduleRestart();
+    };
+    this._ws.onerror = (event) => {
+      log2.warn("EdgeClient socket error", {
+        error: event.error,
+        info: event.message
+      }, {
+        F: __dxlog_file2,
+        L: 128,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      this._persistentLifecycle.scheduleRestart();
+    };
+    this._ws.onmessage = async (event) => {
+      if (event.data === "__pong__") {
+        this._onHeartbeat();
+        return;
+      }
+      const data = await toUint8Array(event.data);
+      const message = buf.fromBinary(MessageSchema, data);
+      log2("received", {
+        peerKey: this._peerKey,
+        payload: protocol.getPayloadType(message)
+      }, {
+        F: __dxlog_file2,
+        L: 141,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      if (message) {
+        for (const listener of this._listeners) {
+          try {
+            await listener(message);
+          } catch (err) {
+            log2.error("processing", {
+              err,
+              payload: protocol.getPayloadType(message)
+            }, {
+              F: __dxlog_file2,
+              L: 147,
+              S: this,
+              C: (f, a) => f(...a)
+            });
+          }
+        }
+      }
+    };
+    await this._ready.wait({
+      timeout: this._config.timeout ?? DEFAULT_TIMEOUT
+    });
+    this._keepaliveCtx = new Context(void 0, {
+      F: __dxlog_file2,
+      L: 154
+    });
+    scheduleTaskInterval(this._keepaliveCtx, async () => {
+      this._ws?.send("__ping__");
+    }, SIGNAL_KEEPALIVE_INTERVAL);
+    this._ws.send("__ping__");
+    this._onHeartbeat();
+  }
+  async _closeWebSocket() {
+    if (!this._ws) {
+      return;
+    }
+    try {
+      this._ready.throw(this.isOpen ? new EdgeIdentityChangedError() : new EdgeConnectionClosedError());
+      this._ready.reset();
+      void this._keepaliveCtx?.dispose();
+      this._keepaliveCtx = void 0;
+      void this._heartBeatContext?.dispose();
+      this._heartBeatContext = void 0;
+      this._ws.onopen = () => {
+      };
+      this._ws.onclose = () => {
+      };
+      this._ws.onerror = () => {
+      };
+      this._ws.close();
+      this._ws = void 0;
+    } catch (err) {
+      if (err instanceof Error && err.message.includes("WebSocket is closed before the connection is established.")) {
+        return;
+      }
+      log2.warn("Error closing websocket", {
+        err
+      }, {
+        F: __dxlog_file2,
+        L: 190,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    }
+  }
+  /**
+  * Send message.
+  * NOTE: The message is guaranteed to be delivered but the service must respond with a message to confirm processing.
+  */
+  async send(message) {
+    if (this._ready.state !== TriggerState.RESOLVED) {
+      log2("waiting for websocket to become ready", void 0, {
+        F: __dxlog_file2,
+        L: 200,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      await this._ready.wait({
+        timeout: this._config.timeout ?? DEFAULT_TIMEOUT
+      });
+    }
+    if (!this._ws) {
+      throw new EdgeConnectionClosedError();
+    }
+    if (message.source && (message.source.peerKey !== this._peerKey || message.source.identityKey !== this.identityKey)) {
+      throw new EdgeIdentityChangedError();
+    }
+    log2("sending...", {
+      peerKey: this._peerKey,
+      payload: protocol.getPayloadType(message)
+    }, {
+      F: __dxlog_file2,
+      L: 213,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    this._ws.send(buf.toBinary(MessageSchema, message));
+  }
+  _onHeartbeat() {
+    if (this._lifecycleState !== LifecycleState2.OPEN) {
+      return;
+    }
+    void this._heartBeatContext?.dispose();
+    this._heartBeatContext = new Context(void 0, {
+      F: __dxlog_file2,
+      L: 222
+    });
+    scheduleTask(this._heartBeatContext, () => {
+      this._persistentLifecycle.scheduleRestart();
+    }, 2 * SIGNAL_KEEPALIVE_INTERVAL);
+  }
+};
+export {
+  EdgeClient,
+  EdgeConnectionClosedError,
+  EdgeIdentityChangedError,
+  Protocol,
+  getTypename,
+  protocol,
+  toUint8Array
+};
+//# sourceMappingURL=index.mjs.map