wire-mesh-core 3.1.0 → 3.2.0

package/dist/adapters/byte-stream-connection.cjs

@@ -0,0 +1,79 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_generated_protocol = require("../generated/protocol.cjs");
+let cbor2 = require("cbor2");
+//#region src/adapters/byte-stream-connection.ts
+const LENGTH_PREFIX_BYTES = 4;
+const BYTES_PER_KIBIBYTE = 1024;
+/** The largest frame body a peer may announce in a length prefix, matching the 100 MiB the `ws` package applies to one message on the same hub, so a WebSocket peer and a byte-stream peer are bounded alike. Without a bound a peer-controlled 4 GiB prefix makes the reader buffer until memory runs out. */
+const MAX_FRAME_BYTES = 100 * (BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE);
+/** A frame with an empty body, which carries nothing and is skipped by the reader. A QUIC stream is invisible to the peer until a byte crosses it, so the side that opens a stream writes one of these to make it visible before it has a real frame to send. */
+const STREAM_OPEN_MARKER = new Uint8Array(LENGTH_PREFIX_BYTES);
+/** The bytes that carry one frame on a byte stream: a 4-byte big-endian length, then the frame's CBOR body, the same framing the TCP adapter uses. */
+function encodeLengthPrefixedFrame(frame) {
+	const body = (0, cbor2.encode)(frame, cbor2.cdeEncodeOptions);
+	const message = new Uint8Array(LENGTH_PREFIX_BYTES + body.length);
+	new DataView(message.buffer).setUint32(0, body.length);
+	message.set(body, LENGTH_PREFIX_BYTES);
+	return message;
+}
+function concat(first, second) {
+	const joined = new Uint8Array(first.length + second.length);
+	joined.set(first);
+	joined.set(second, first.length);
+	return joined;
+}
+/**
+* Frames arriving on a byte stream, in order, until it ends. An empty body (STREAM_OPEN_MARKER) is skipped. A body that does not decode as CBOR, or a length prefix above MAX_FRAME_BYTES, rejects the iteration (a connection-level failure); a body that decodes but fails frame validation is dropped and the stream continues, since an unrecognised frame from a newer peer is what version negotiation exists to tolerate.
+*/
+async function* readFrames(reader) {
+	let buffered = /* @__PURE__ */ new Uint8Array(0);
+	try {
+		for (;;) {
+			const chunk = await reader.read();
+			if (chunk.done) return;
+			buffered = concat(buffered, chunk.value);
+			while (buffered.length >= LENGTH_PREFIX_BYTES) {
+				const bodyLength = new DataView(buffered.buffer, buffered.byteOffset).getUint32(0);
+				if (bodyLength > 104857600) throw new Error(`frame of ${String(bodyLength)} bytes exceeds the ${String(MAX_FRAME_BYTES)}-byte limit`);
+				if (buffered.length < LENGTH_PREFIX_BYTES + bodyLength) break;
+				if (bodyLength === 0) {
+					buffered = buffered.slice(LENGTH_PREFIX_BYTES);
+					continue;
+				}
+				const body = buffered.slice(LENGTH_PREFIX_BYTES, LENGTH_PREFIX_BYTES + bodyLength);
+				buffered = buffered.slice(LENGTH_PREFIX_BYTES + bodyLength);
+				const result = require_generated_protocol.frameSchema.safeParse((0, cbor2.decode)(body, cbor2.cdeDecodeOptions));
+				if (result.success) yield result.data;
+			}
+		}
+	} catch (error) {
+		await reader.cancel(error);
+		throw error;
+	}
+}
+/**
+* A Connection over an ordered, reliable byte stream, one frame per length-prefixed CBOR body. Pass `opened: true` on the side that opened the stream: it writes a STREAM_OPEN_MARKER first, so the peer sees the stream before the first real frame. Pass `opened: true` on the side that opened the stream, which writes a STREAM_OPEN_MARKER first so the peer sees the stream before the first real frame. `close` ends the writable side and cancels the readable side, so the peer sees the stream finish and this side's `receive()` ends.
+*/
+function connectionFromByteStream(stream, options = { opened: false }) {
+	const writer = stream.writable.getWriter();
+	const reader = stream.readable.getReader();
+	const frames = readFrames(reader);
+	const marked = options.opened ? writer.write(STREAM_OPEN_MARKER) : Promise.resolve();
+	marked.catch(() => void 0);
+	return {
+		send: async (frame) => {
+			await marked;
+			await writer.write(encodeLengthPrefixedFrame(frame));
+		},
+		receive: () => frames,
+		close: async () => {
+			await writer.close();
+			await reader.cancel();
+		}
+	};
+}
+//#endregion
+exports.MAX_FRAME_BYTES = MAX_FRAME_BYTES;
+exports.STREAM_OPEN_MARKER = STREAM_OPEN_MARKER;
+exports.connectionFromByteStream = connectionFromByteStream;
+exports.encodeLengthPrefixedFrame = encodeLengthPrefixedFrame;

package/dist/adapters/byte-stream-connection.d.cts

@@ -0,0 +1,21 @@
+import { N as Frame } from "../protocol-DCDae3z4.cjs";
+import { t as Connection } from "../transport-CfW7fsGK.cjs";
+//#region src/adapters/byte-stream-connection.d.ts
+/** The largest frame body a peer may announce in a length prefix, matching the 100 MiB the `ws` package applies to one message on the same hub, so a WebSocket peer and a byte-stream peer are bounded alike. Without a bound a peer-controlled 4 GiB prefix makes the reader buffer until memory runs out. */
+export declare const MAX_FRAME_BYTES: number;
+/** A frame with an empty body, which carries nothing and is skipped by the reader. A QUIC stream is invisible to the peer until a byte crosses it, so the side that opens a stream writes one of these to make it visible before it has a real frame to send. */
+export declare const STREAM_OPEN_MARKER: Uint8Array;
+/** The two halves of an ordered, reliable byte stream, as the Web Streams API models them: a WebTransport bidirectional stream is one, and so is any other stream a runtime exposes in that shape. */
+export interface ByteStream {
+  readonly readable: ReadableStream<Uint8Array>;
+  readonly writable: WritableStream<Uint8Array>;
+}
+/** The bytes that carry one frame on a byte stream: a 4-byte big-endian length, then the frame's CBOR body, the same framing the TCP adapter uses. */
+export declare function encodeLengthPrefixedFrame(frame: Frame): Uint8Array;
+/**
+ * A Connection over an ordered, reliable byte stream, one frame per length-prefixed CBOR body. Pass `opened: true` on the side that opened the stream: it writes a STREAM_OPEN_MARKER first, so the peer sees the stream before the first real frame. Pass `opened: true` on the side that opened the stream, which writes a STREAM_OPEN_MARKER first so the peer sees the stream before the first real frame. `close` ends the writable side and cancels the readable side, so the peer sees the stream finish and this side's `receive()` ends.
+ */
+export declare function connectionFromByteStream(stream: Readonly<ByteStream>, options?: Readonly<{
+  opened: boolean;
+}>): Connection;
+//#endregion

package/dist/adapters/byte-stream-connection.d.mts

@@ -0,0 +1,21 @@
+import { N as Frame } from "../protocol-DCDae3z4.mjs";
+import { t as Connection } from "../transport-iLBxIkRS.mjs";
+//#region src/adapters/byte-stream-connection.d.ts
+/** The largest frame body a peer may announce in a length prefix, matching the 100 MiB the `ws` package applies to one message on the same hub, so a WebSocket peer and a byte-stream peer are bounded alike. Without a bound a peer-controlled 4 GiB prefix makes the reader buffer until memory runs out. */
+export declare const MAX_FRAME_BYTES: number;
+/** A frame with an empty body, which carries nothing and is skipped by the reader. A QUIC stream is invisible to the peer until a byte crosses it, so the side that opens a stream writes one of these to make it visible before it has a real frame to send. */
+export declare const STREAM_OPEN_MARKER: Uint8Array;
+/** The two halves of an ordered, reliable byte stream, as the Web Streams API models them: a WebTransport bidirectional stream is one, and so is any other stream a runtime exposes in that shape. */
+export interface ByteStream {
+  readonly readable: ReadableStream<Uint8Array>;
+  readonly writable: WritableStream<Uint8Array>;
+}
+/** The bytes that carry one frame on a byte stream: a 4-byte big-endian length, then the frame's CBOR body, the same framing the TCP adapter uses. */
+export declare function encodeLengthPrefixedFrame(frame: Frame): Uint8Array;
+/**
+ * A Connection over an ordered, reliable byte stream, one frame per length-prefixed CBOR body. Pass `opened: true` on the side that opened the stream: it writes a STREAM_OPEN_MARKER first, so the peer sees the stream before the first real frame. Pass `opened: true` on the side that opened the stream, which writes a STREAM_OPEN_MARKER first so the peer sees the stream before the first real frame. `close` ends the writable side and cancels the readable side, so the peer sees the stream finish and this side's `receive()` ends.
+ */
+export declare function connectionFromByteStream(stream: Readonly<ByteStream>, options?: Readonly<{
+  opened: boolean;
+}>): Connection;
+//#endregion

package/dist/adapters/byte-stream-connection.mjs

@@ -0,0 +1,75 @@
+import { frameSchema } from "../generated/protocol.mjs";
+import { cdeDecodeOptions, cdeEncodeOptions, decode, encode } from "cbor2";
+//#region src/adapters/byte-stream-connection.ts
+const LENGTH_PREFIX_BYTES = 4;
+const BYTES_PER_KIBIBYTE = 1024;
+/** The largest frame body a peer may announce in a length prefix, matching the 100 MiB the `ws` package applies to one message on the same hub, so a WebSocket peer and a byte-stream peer are bounded alike. Without a bound a peer-controlled 4 GiB prefix makes the reader buffer until memory runs out. */
+const MAX_FRAME_BYTES = 100 * (BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE);
+/** A frame with an empty body, which carries nothing and is skipped by the reader. A QUIC stream is invisible to the peer until a byte crosses it, so the side that opens a stream writes one of these to make it visible before it has a real frame to send. */
+const STREAM_OPEN_MARKER = new Uint8Array(LENGTH_PREFIX_BYTES);
+/** The bytes that carry one frame on a byte stream: a 4-byte big-endian length, then the frame's CBOR body, the same framing the TCP adapter uses. */
+function encodeLengthPrefixedFrame(frame) {
+	const body = encode(frame, cdeEncodeOptions);
+	const message = new Uint8Array(LENGTH_PREFIX_BYTES + body.length);
+	new DataView(message.buffer).setUint32(0, body.length);
+	message.set(body, LENGTH_PREFIX_BYTES);
+	return message;
+}
+function concat(first, second) {
+	const joined = new Uint8Array(first.length + second.length);
+	joined.set(first);
+	joined.set(second, first.length);
+	return joined;
+}
+/**
+* Frames arriving on a byte stream, in order, until it ends. An empty body (STREAM_OPEN_MARKER) is skipped. A body that does not decode as CBOR, or a length prefix above MAX_FRAME_BYTES, rejects the iteration (a connection-level failure); a body that decodes but fails frame validation is dropped and the stream continues, since an unrecognised frame from a newer peer is what version negotiation exists to tolerate.
+*/
+async function* readFrames(reader) {
+	let buffered = /* @__PURE__ */ new Uint8Array(0);
+	try {
+		for (;;) {
+			const chunk = await reader.read();
+			if (chunk.done) return;
+			buffered = concat(buffered, chunk.value);
+			while (buffered.length >= LENGTH_PREFIX_BYTES) {
+				const bodyLength = new DataView(buffered.buffer, buffered.byteOffset).getUint32(0);
+				if (bodyLength > 104857600) throw new Error(`frame of ${String(bodyLength)} bytes exceeds the ${String(MAX_FRAME_BYTES)}-byte limit`);
+				if (buffered.length < LENGTH_PREFIX_BYTES + bodyLength) break;
+				if (bodyLength === 0) {
+					buffered = buffered.slice(LENGTH_PREFIX_BYTES);
+					continue;
+				}
+				const body = buffered.slice(LENGTH_PREFIX_BYTES, LENGTH_PREFIX_BYTES + bodyLength);
+				buffered = buffered.slice(LENGTH_PREFIX_BYTES + bodyLength);
+				const result = frameSchema.safeParse(decode(body, cdeDecodeOptions));
+				if (result.success) yield result.data;
+			}
+		}
+	} catch (error) {
+		await reader.cancel(error);
+		throw error;
+	}
+}
+/**
+* A Connection over an ordered, reliable byte stream, one frame per length-prefixed CBOR body. Pass `opened: true` on the side that opened the stream: it writes a STREAM_OPEN_MARKER first, so the peer sees the stream before the first real frame. Pass `opened: true` on the side that opened the stream, which writes a STREAM_OPEN_MARKER first so the peer sees the stream before the first real frame. `close` ends the writable side and cancels the readable side, so the peer sees the stream finish and this side's `receive()` ends.
+*/
+function connectionFromByteStream(stream, options = { opened: false }) {
+	const writer = stream.writable.getWriter();
+	const reader = stream.readable.getReader();
+	const frames = readFrames(reader);
+	const marked = options.opened ? writer.write(STREAM_OPEN_MARKER) : Promise.resolve();
+	marked.catch(() => void 0);
+	return {
+		send: async (frame) => {
+			await marked;
+			await writer.write(encodeLengthPrefixedFrame(frame));
+		},
+		receive: () => frames,
+		close: async () => {
+			await writer.close();
+			await reader.cancel();
+		}
+	};
+}
+//#endregion
+export { MAX_FRAME_BYTES, STREAM_OPEN_MARKER, connectionFromByteStream, encodeLengthPrefixedFrame };

package/dist/domain/bulk.d.cts

@@ -1,6 +1,6 @@
 import { D as DeviceId, N as Frame, V as ManageCommand, f as CapabilityScope, p as CapabilityToken } from "../protocol-DCDae3z4.cjs";
-import { t as KeyValueStorage } from "../storage-B403CRyu.cjs";
 import { t as Connection } from "../transport-CfW7fsGK.cjs";
+import { t as KeyValueStorage } from "../storage-B403CRyu.cjs";
 import { IncomingManageRequest, MeshSession } from "./mesh-session.cjs";
 //#region src/domain/bulk.d.ts
 /** The two capabilities matching the direction each manage-command actually flows (spec/bulk.cddl): the sender proves write authority to open a transfer, the receiver proves read authority to ask for one to continue. */

package/dist/domain/bulk.d.mts

@@ -1,6 +1,6 @@
 import { D as DeviceId, N as Frame, V as ManageCommand, f as CapabilityScope, p as CapabilityToken } from "../protocol-DCDae3z4.mjs";
-import { t as KeyValueStorage } from "../storage-B403CRyu.mjs";
 import { t as Connection } from "../transport-iLBxIkRS.mjs";
+import { t as KeyValueStorage } from "../storage-B403CRyu.mjs";
 import { IncomingManageRequest, MeshSession } from "./mesh-session.mjs";
 //#region src/domain/bulk.d.ts
 /** The two capabilities matching the direction each manage-command actually flows (spec/bulk.cddl): the sender proves write authority to open a transfer, the receiver proves read authority to ask for one to continue. */

package/dist/domain/mesh-session.d.cts

@@ -1,7 +1,7 @@
 import { D as DeviceId, E as DataRequestFrame, N as Frame, T as DataHaveFrame, U as ManageError, V as ManageCommand, W as ManageOk, bt as RevocationEntry, et as PeerAdvert, f as CapabilityScope, lt as ProtocolVersion, nn as TopologyPeers, p as CapabilityToken, w as DataEntriesFrame } from "../protocol-DCDae3z4.cjs";
+import { r as Transport, t as Connection } from "../transport-CfW7fsGK.cjs";
 import { t as IdentityPort } from "../identity-DVCNuFLG.cjs";
 import { t as Clock } from "../clock-DiSx-WKM.cjs";
-import { r as Transport, t as Connection } from "../transport-CfW7fsGK.cjs";
 //#region src/domain/mesh-session.d.ts
 /** How long to wait for the node's handshake before calling it unanswered. A relay-only node never sends one; that is a state to display, not an error. */
 export declare const HANDSHAKE_TIMEOUT_MS = 3000;

package/dist/domain/mesh-session.d.mts

@@ -1,7 +1,7 @@
 import { D as DeviceId, E as DataRequestFrame, N as Frame, T as DataHaveFrame, U as ManageError, V as ManageCommand, W as ManageOk, bt as RevocationEntry, et as PeerAdvert, f as CapabilityScope, lt as ProtocolVersion, nn as TopologyPeers, p as CapabilityToken, w as DataEntriesFrame } from "../protocol-DCDae3z4.mjs";
+import { r as Transport, t as Connection } from "../transport-iLBxIkRS.mjs";
 import { t as IdentityPort } from "../identity-DcaYgjXT.mjs";
 import { t as Clock } from "../clock-DiSx-WKM.mjs";
-import { r as Transport, t as Connection } from "../transport-iLBxIkRS.mjs";
 //#region src/domain/mesh-session.d.ts
 /** How long to wait for the node's handshake before calling it unanswered. A relay-only node never sends one; that is a state to display, not an error. */
 export declare const HANDSHAKE_TIMEOUT_MS = 3000;

package/dist/domain/pinned-address.cjs

@@ -0,0 +1,39 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/domain/pinned-address.ts
+const PIN_FRAGMENT = "#sha256=";
+const SHA256_HEX_PATTERN = /^[0-9a-f]{64}$/;
+function hexToBytes(hex) {
+	const bytes = new Uint8Array(hex.length / 2);
+	for (let index = 0; index < bytes.length; index++) bytes[index] = Number.parseInt(hex.slice(index * 2, index * 2 + 2), 16);
+	return bytes;
+}
+/**
+* The address a node advertises for WebTransport: `https://host:port#sha256=<hex>`, the address and the hash of the certificate it serves. A client that pins the hash needs nothing else from the network to trust the node, so the pair travels together in one string, which `wire-candidate.address` already permits.
+*/
+function formatPinnedAddress(hostPort, sha256Hex) {
+	return `https://${hostPort}${PIN_FRAGMENT}${sha256Hex}`;
+}
+/**
+* Whether an address carries a certificate pin, and so is dialled over WebTransport rather than WebSocket.
+*/
+function isPinnedAddress(address) {
+	return address.startsWith("https://") && address.includes(PIN_FRAGMENT);
+}
+/**
+* Splits an address of the form `https://host:port#sha256=<hex>`.
+* @throws Error when the address is not `https://` or carries no valid 64-digit lowercase hex hash.
+*/
+function parsePinnedAddress(address) {
+	const url = new URL(address);
+	const hex = url.hash.startsWith(PIN_FRAGMENT) ? url.hash.slice(8) : "";
+	if (url.protocol !== "https:" || !SHA256_HEX_PATTERN.test(hex)) throw new Error(`expected "https://host:port${PIN_FRAGMENT}<64 hex digits>", got "${address}"`);
+	url.hash = "";
+	return {
+		url: url.toString(),
+		sha256: hexToBytes(hex)
+	};
+}
+//#endregion
+exports.formatPinnedAddress = formatPinnedAddress;
+exports.isPinnedAddress = isPinnedAddress;
+exports.parsePinnedAddress = parsePinnedAddress;

package/dist/domain/pinned-address.d.cts

@@ -0,0 +1,22 @@
+//#region src/domain/pinned-address.d.ts
+/** A WebTransport address and the SHA-256 hash of the certificate it is expected to serve. */
+export interface PinnedAddress {
+  /** `https://host:port/`, the URL to open. */
+  readonly url: string;
+  /** The certificate's SHA-256 hash, as bytes. */
+  readonly sha256: Uint8Array<ArrayBuffer>;
+}
+/**
+ * The address a node advertises for WebTransport: `https://host:port#sha256=<hex>`, the address and the hash of the certificate it serves. A client that pins the hash needs nothing else from the network to trust the node, so the pair travels together in one string, which `wire-candidate.address` already permits.
+ */
+export declare function formatPinnedAddress(hostPort: string, sha256Hex: string): string;
+/**
+ * Whether an address carries a certificate pin, and so is dialled over WebTransport rather than WebSocket.
+ */
+export declare function isPinnedAddress(address: string): boolean;
+/**
+ * Splits an address of the form `https://host:port#sha256=<hex>`.
+ * @throws Error when the address is not `https://` or carries no valid 64-digit lowercase hex hash.
+ */
+export declare function parsePinnedAddress(address: string): PinnedAddress;
+//#endregion

package/dist/domain/pinned-address.d.mts

@@ -0,0 +1,22 @@
+//#region src/domain/pinned-address.d.ts
+/** A WebTransport address and the SHA-256 hash of the certificate it is expected to serve. */
+export interface PinnedAddress {
+  /** `https://host:port/`, the URL to open. */
+  readonly url: string;
+  /** The certificate's SHA-256 hash, as bytes. */
+  readonly sha256: Uint8Array<ArrayBuffer>;
+}
+/**
+ * The address a node advertises for WebTransport: `https://host:port#sha256=<hex>`, the address and the hash of the certificate it serves. A client that pins the hash needs nothing else from the network to trust the node, so the pair travels together in one string, which `wire-candidate.address` already permits.
+ */
+export declare function formatPinnedAddress(hostPort: string, sha256Hex: string): string;
+/**
+ * Whether an address carries a certificate pin, and so is dialled over WebTransport rather than WebSocket.
+ */
+export declare function isPinnedAddress(address: string): boolean;
+/**
+ * Splits an address of the form `https://host:port#sha256=<hex>`.
+ * @throws Error when the address is not `https://` or carries no valid 64-digit lowercase hex hash.
+ */
+export declare function parsePinnedAddress(address: string): PinnedAddress;
+//#endregion

package/dist/domain/pinned-address.mjs

@@ -0,0 +1,36 @@
+//#region src/domain/pinned-address.ts
+const PIN_FRAGMENT = "#sha256=";
+const SHA256_HEX_PATTERN = /^[0-9a-f]{64}$/;
+function hexToBytes(hex) {
+	const bytes = new Uint8Array(hex.length / 2);
+	for (let index = 0; index < bytes.length; index++) bytes[index] = Number.parseInt(hex.slice(index * 2, index * 2 + 2), 16);
+	return bytes;
+}
+/**
+* The address a node advertises for WebTransport: `https://host:port#sha256=<hex>`, the address and the hash of the certificate it serves. A client that pins the hash needs nothing else from the network to trust the node, so the pair travels together in one string, which `wire-candidate.address` already permits.
+*/
+function formatPinnedAddress(hostPort, sha256Hex) {
+	return `https://${hostPort}${PIN_FRAGMENT}${sha256Hex}`;
+}
+/**
+* Whether an address carries a certificate pin, and so is dialled over WebTransport rather than WebSocket.
+*/
+function isPinnedAddress(address) {
+	return address.startsWith("https://") && address.includes(PIN_FRAGMENT);
+}
+/**
+* Splits an address of the form `https://host:port#sha256=<hex>`.
+* @throws Error when the address is not `https://` or carries no valid 64-digit lowercase hex hash.
+*/
+function parsePinnedAddress(address) {
+	const url = new URL(address);
+	const hex = url.hash.startsWith(PIN_FRAGMENT) ? url.hash.slice(8) : "";
+	if (url.protocol !== "https:" || !SHA256_HEX_PATTERN.test(hex)) throw new Error(`expected "https://host:port${PIN_FRAGMENT}<64 hex digits>", got "${address}"`);
+	url.hash = "";
+	return {
+		url: url.toString(),
+		sha256: hexToBytes(hex)
+	};
+}
+//#endregion
+export { formatPinnedAddress, isPinnedAddress, parsePinnedAddress };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wire-mesh-core",
-  "version": "3.1.0",
+  "version": "3.2.0",
   "dependencies": {
     "cbor2": "2.3.0",
     "cddl.js": "1.0.1",
@@ -26,6 +26,10 @@
     "vitest": "5.0.0"
   },
   "exports": {
+    "./adapters/byte-stream-connection": {
+      "import": "./dist/adapters/byte-stream-connection.mjs",
+      "require": "./dist/adapters/byte-stream-connection.cjs"
+    },
     "./adapters/frame-codec": {
       "import": "./dist/adapters/frame-codec.mjs",
       "require": "./dist/adapters/frame-codec.cjs"
@@ -142,6 +146,10 @@
       "import": "./dist/domain/ping-round-trips.mjs",
       "require": "./dist/domain/ping-round-trips.cjs"
     },
+    "./domain/pinned-address": {
+      "import": "./dist/domain/pinned-address.mjs",
+      "require": "./dist/domain/pinned-address.cjs"
+    },
     "./domain/relay-hub": {
       "import": "./dist/domain/relay-hub.mjs",
       "require": "./dist/domain/relay-hub.cjs"