@dxos/network-manager 0.10.0 → 0.11.1

package/dist/lib/chunk-wire-protocol.mjs

@@ -0,0 +1,3554 @@
+import { DeferredTask, Event, Mutex, SubscriptionList, Trigger, scheduleTask, scheduleTaskInterval, sleep, synchronized } from "@dxos/async";
+import { ErrorStream, raise } from "@dxos/debug";
+import { PublicKey } from "@dxos/keys";
+import { ComplexMap, arrayToBuffer, isNonNullable } from "@dxos/util";
+import { Context, ContextDisposedError, Resource, cancelWithContext } from "@dxos/context";
+import { assertArgument, invariant } from "@dxos/invariant";
+import { log, logInfo } from "@dxos/log";
+import { CancelledError, ConnectionResetError, ConnectivityError, ProtocolError, SystemError, TimeoutError } from "@dxos/protocols";
+import { Messenger, PeerInfoHash } from "@dxos/messaging";
+import { schema } from "@dxos/protocols/proto";
+import * as EffectContext from "effect/Context";
+import { ConnectionState } from "@dxos/protocols/proto/dxos/client/services";
+import { Duplex, Transform, Writable } from "@dxos/node-std/stream";
+import { ConnectionState as ConnectionState$1 } from "@dxos/protocols/proto/dxos/mesh/bridge";
+import { Stream } from "@dxos/codec-protobuf/stream";
+import { Teleport } from "@dxos/teleport";
+//#region \0@oxc-project+runtime@0.139.0/helpers/esm/decorate.js
+function __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;
+}
+//#endregion
+//#region src/swarm/connection.ts
+var __dxlog_file$12 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/swarm/connection.ts";
+/**
+* How long to wait before sending the signal in case we receive another signal.
+* This value is increased exponentially.
+*/
+var STARTING_SIGNALLING_DELAY = 10;
+/**
+* How long to wait for the transport to establish connectivity, i.e. for the connection to move between CONNECTING and CONNECTED.
+*/
+var TRANSPORT_CONNECTION_TIMEOUT = 1e4;
+var TRANSPORT_STATS_INTERVAL = 5e3;
+/**
+* Maximum delay between signal batches.
+*/
+var MAX_SIGNALLING_DELAY = 300;
+/**
+* State machine for each connection.
+*/
+var ConnectionState$2 = /* @__PURE__ */ function(ConnectionState) {
+	/**
+	*  Connection is created, but not yet passed through the connection limiter.
+	*/
+	ConnectionState["CREATED"] = "CREATED";
+	/**
+	* Initial state. Connection is registered but no attempt to connect to the remote peer has been performed.
+	* Might mean that we are waiting for the answer signal from the remote peer.
+	*/
+	ConnectionState["INITIAL"] = "INITIAL";
+	/**
+	* Trying to establish connection.
+	*/
+	ConnectionState["CONNECTING"] = "CONNECTING";
+	/**
+	* Connection is established.
+	*/
+	ConnectionState["CONNECTED"] = "CONNECTED";
+	/**
+	* Connection is being closed.
+	*/
+	ConnectionState["CLOSING"] = "CLOSING";
+	/**
+	* Connection closed.
+	*/
+	ConnectionState["CLOSED"] = "CLOSED";
+	ConnectionState["ABORTING"] = "ABORTING";
+	ConnectionState["ABORTED"] = "ABORTED";
+	return ConnectionState;
+}({});
+/**
+* Represents a connection to a remote peer.
+* Owns a transport paired together with a wire-protocol.
+*/
+var Connection = class {
+	topic;
+	localInfo;
+	remoteInfo;
+	sessionId;
+	initiator;
+	_signalMessaging;
+	_protocol;
+	_transportFactory;
+	_callbacks;
+	_ctx = new Context(void 0, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$12,
+		L: 93
+	});
+	connectedTimeoutContext = new Context(void 0, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$12,
+		L: 94
+	});
+	_protocolClosed = new Trigger();
+	_transportClosed = new Trigger();
+	_state = "CREATED";
+	_transport;
+	closeReason;
+	_incomingSignalBuffer = [];
+	_outgoingSignalBuffer = [];
+	stateChanged = new Event();
+	errors = new ErrorStream();
+	transportStats = new Event();
+	_signalSendTask = new DeferredTask(this._ctx, async () => {
+		await this._flushSignalBuffer(this._ctx);
+	});
+	_signallingDelay = STARTING_SIGNALLING_DELAY;
+	constructor(topic, localInfo, remoteInfo, sessionId, initiator, _signalMessaging, _protocol, _transportFactory, _callbacks) {
+		this.topic = topic;
+		this.localInfo = localInfo;
+		this.remoteInfo = remoteInfo;
+		this.sessionId = sessionId;
+		this.initiator = initiator;
+		this._signalMessaging = _signalMessaging;
+		this._protocol = _protocol;
+		this._transportFactory = _transportFactory;
+		this._callbacks = _callbacks;
+		log.trace("dxos.mesh.connection.construct", {
+			sessionId: this.sessionId,
+			topic: this.topic,
+			localPeer: this.localInfo,
+			remotePeer: this.remoteInfo,
+			initiator: this.initiator
+		}, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$12,
+			L: 128,
+			S: this
+		});
+	}
+	get sessionIdString() {
+		return this.sessionId.truncate();
+	}
+	get state() {
+		return this._state;
+	}
+	get transport() {
+		return this._transport;
+	}
+	get protocol() {
+		return this._protocol;
+	}
+	/**
+	* Create an underlying transport and prepares it for the connection.
+	*/
+	async openConnection() {
+		invariant(this._state === "INITIAL", "Invalid state.", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$12,
+			L: 158,
+			S: this,
+			A: ["this._state === ConnectionState.INITIAL", "'Invalid state.'"]
+		});
+		log("opening connection", void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$12,
+			L: 159,
+			S: this
+		});
+		log.trace("dxos.mesh.connection.open", {
+			sessionId: this.sessionId,
+			topic: this.topic,
+			localPeerId: this.localInfo,
+			remotePeerId: this.remoteInfo,
+			initiator: this.initiator
+		}, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$12,
+			L: 160,
+			S: this
+		});
+		this._changeState("CONNECTING");
+		this._protocol.open(this.sessionId).catch((err) => {
+			this.errors.raise(err);
+		});
+		this._protocol.stream.on("close", () => {
+			log("protocol stream closed", void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$12,
+				L: 177,
+				S: this
+			});
+			this._protocolClosed.wake();
+			this.close({ error: new ProtocolError({ message: "protocol stream closed" }) }).catch((err) => this.errors.raise(err));
+		});
+		scheduleTask(this.connectedTimeoutContext, async () => {
+			log.info(`timeout waiting ${TRANSPORT_CONNECTION_TIMEOUT / 1e3}s for transport to connect, aborting`, void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$12,
+				L: 187,
+				S: this
+			});
+			await this.abort(new TimeoutError({ message: `${TRANSPORT_CONNECTION_TIMEOUT / 1e3}s for transport to connect` })).catch((err) => this.errors.raise(err));
+		}, TRANSPORT_CONNECTION_TIMEOUT);
+		invariant(!this._transport, void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$12,
+			L: 195,
+			S: this,
+			A: ["!this._transport", ""]
+		});
+		this._transport = this._transportFactory.createTransport({
+			ownPeerKey: this.localInfo.peerKey,
+			remotePeerKey: this.remoteInfo.peerKey,
+			topic: this.topic.toHex(),
+			initiator: this.initiator,
+			stream: this._protocol.stream,
+			sendSignal: async (signal) => this._sendSignal(signal),
+			sessionId: this.sessionId
+		});
+		this._transport.connected.once(async () => {
+			this._changeState("CONNECTED");
+			await this.connectedTimeoutContext.dispose();
+			this._callbacks?.onConnected?.();
+			scheduleTaskInterval(this._ctx, async () => this._emitTransportStats(), TRANSPORT_STATS_INTERVAL);
+		});
+		this._transport.closed.once(() => {
+			this._transport = void 0;
+			this._transportClosed.wake();
+			log("abort triggered by transport close", void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$12,
+				L: 217,
+				S: this
+			});
+			this.abort().catch((err) => this.errors.raise(err));
+		});
+		this._transport.errors.handle(async (err) => {
+			log("transport error:", { err }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$12,
+				L: 222,
+				S: this
+			});
+			if (!this.closeReason) this.closeReason = err?.message;
+			if (err instanceof ConnectionResetError) {
+				log.info("aborting due to transport ConnectionResetError", void 0, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$12,
+					L: 229,
+					S: this
+				});
+				this.abort(err).catch((err) => this.errors.raise(err));
+			} else if (err instanceof ConnectivityError) {
+				log.info("aborting due to transport ConnectivityError", void 0, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$12,
+					L: 232,
+					S: this
+				});
+				this.abort(err).catch((err) => this.errors.raise(err));
+			}
+			if (this._state !== "CLOSED" && this._state !== "CLOSING") {
+				await this.connectedTimeoutContext.dispose();
+				this.errors.raise(err);
+			}
+		});
+		await this._transport.open();
+		for (const signal of this._incomingSignalBuffer) this._transport.onSignal(signal);
+		this._incomingSignalBuffer = [];
+		log("opened connection", void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$12,
+			L: 251,
+			S: this
+		});
+	}
+	async abort(err) {
+		log("abort", { err }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$12,
+			L: 258,
+			S: this
+		});
+		if (this._state === "CLOSED" || this._state === "ABORTED") {
+			log(`abort ignored: already ${this._state}`, this.closeReason, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$12,
+				L: 260,
+				S: this
+			});
+			return;
+		}
+		await this.connectedTimeoutContext.dispose();
+		this._changeState("ABORTING");
+		if (!this.closeReason) this.closeReason = err?.message;
+		await this._ctx.dispose();
+		log("aborting...", {
+			peerId: this.localInfo,
+			err
+		}, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$12,
+			L: 272,
+			S: this
+		});
+		try {
+			await this._closeProtocol({ abort: true });
+		} catch (err) {
+			log.catch(err, void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$12,
+				L: 278,
+				S: this
+			});
+		}
+		try {
+			await this._closeTransport();
+		} catch (err) {
+			log.catch(err, void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$12,
+				L: 285,
+				S: this
+			});
+		}
+		try {
+			this._callbacks?.onClosed?.(err);
+		} catch (err) {
+			log.catch(err, void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$12,
+				L: 291,
+				S: this
+			});
+		}
+		this._changeState("ABORTED");
+	}
+	async close({ error, reason } = {}) {
+		log("close", { error }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$12,
+			L: 298,
+			S: this
+		});
+		if (!this.closeReason) this.closeReason = reason ?? error?.message;
+		else this.closeReason += `; ${reason ?? error?.message}`;
+		if (this._state === "CLOSED" || this._state === "ABORTING" || this._state === "ABORTED") {
+			log("close ignored: already in progress", {
+				state: this._state,
+				error
+			}, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$12,
+				L: 309,
+				S: this
+			});
+			return;
+		}
+		const lastState = this._state;
+		this._changeState("CLOSING");
+		await this.connectedTimeoutContext.dispose();
+		await this._ctx.dispose();
+		let abortProtocol = false;
+		if (lastState !== "CONNECTED" || error != null) {
+			log(`graceful close requested when we were in ${lastState} state? aborting`, void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$12,
+				L: 320,
+				S: this
+			});
+			abortProtocol = true;
+		}
+		log("closing...", {
+			peerId: this.localInfo,
+			abortProtocol,
+			error
+		}, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$12,
+			L: 324,
+			S: this
+		});
+		try {
+			await this._closeProtocol({ abort: abortProtocol });
+		} catch (err) {
+			log.catch(err, void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$12,
+				L: 329,
+				S: this
+			});
+		}
+		try {
+			await this._closeTransport();
+		} catch (err) {
+			log.catch(err, void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$12,
+				L: 335,
+				S: this
+			});
+		}
+		log("closed", { peerId: this.localInfo }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$12,
+			L: 338,
+			S: this
+		});
+		this._changeState("CLOSED");
+		this._callbacks?.onClosed?.(error);
+	}
+	async _closeProtocol(options) {
+		log("closing protocol", options, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$12,
+			L: 344,
+			S: this
+		});
+		await Promise.race([options?.abort ? this._protocol.abort() : this._protocol.close(), this._protocolClosed.wait()]);
+		log("protocol closed", options, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$12,
+			L: 346,
+			S: this
+		});
+	}
+	async _closeTransport() {
+		log("closing transport", void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$12,
+			L: 350,
+			S: this
+		});
+		await Promise.race([this._transport?.close(), this._transportClosed.wait()]);
+		log("transport closed", void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$12,
+			L: 352,
+			S: this
+		});
+	}
+	_sendSignal(signal) {
+		this._outgoingSignalBuffer.push(signal);
+		this._signalSendTask.schedule();
+	}
+	async _flushSignalBuffer(ctx) {
+		if (this._outgoingSignalBuffer.length === 0) return;
+		try {
+			if (process.env.NODE_ENV !== "test") {
+				await cancelWithContext(ctx, sleep(this._signallingDelay));
+				this._signallingDelay = Math.min(this._signallingDelay * 2, MAX_SIGNALLING_DELAY);
+			}
+			const signals = [...this._outgoingSignalBuffer];
+			this._outgoingSignalBuffer.length = 0;
+			await this._signalMessaging.signal(ctx, {
+				author: this.localInfo,
+				recipient: this.remoteInfo,
+				sessionId: this.sessionId,
+				topic: this.topic,
+				data: { signalBatch: { signals } }
+			});
+		} catch (err) {
+			if (err instanceof CancelledError || err instanceof ContextDisposedError || err instanceof Error && err.message?.includes("CANCELLED")) return;
+			log.info("signal message failed to deliver", { err }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$12,
+				L: 392,
+				S: this
+			});
+			await this.close({ error: new ConnectivityError({
+				message: "signal message failed to deliver",
+				cause: err
+			}) });
+		}
+	}
+	/**
+	* Receive a signal from the remote peer.
+	*/
+	async signal(_ctx, msg) {
+		invariant(msg.sessionId, void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$12,
+			L: 401,
+			S: this,
+			A: ["msg.sessionId", ""]
+		});
+		if (!msg.sessionId.equals(this.sessionId)) {
+			log("dropping signal for incorrect session id", void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$12,
+				L: 403,
+				S: this
+			});
+			return;
+		}
+		invariant(msg.data.signal || msg.data.signalBatch, void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$12,
+			L: 406,
+			S: this,
+			A: ["msg.data.signal || msg.data.signalBatch", ""]
+		});
+		invariant(msg.author.peerKey === this.remoteInfo.peerKey, void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$12,
+			L: 407,
+			S: this,
+			A: ["msg.author.peerKey === this.remoteInfo.peerKey", ""]
+		});
+		invariant(msg.recipient.peerKey === this.localInfo.peerKey, void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$12,
+			L: 408,
+			S: this,
+			A: ["msg.recipient.peerKey === this.localInfo.peerKey", ""]
+		});
+		const signals = msg.data.signalBatch ? msg.data.signalBatch.signals ?? [] : [msg.data.signal];
+		for (const signal of signals) {
+			if (!signal) continue;
+			if (["CREATED", "INITIAL"].includes(this.state)) {
+				log("buffered signal", {
+					peerId: this.localInfo,
+					remoteId: this.remoteInfo,
+					msg: msg.data
+				}, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$12,
+					L: 417,
+					S: this
+				});
+				this._incomingSignalBuffer.push(signal);
+			} else {
+				invariant(this._transport, "Connection not ready to accept signals.", {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$12,
+					L: 420,
+					S: this,
+					A: ["this._transport", "'Connection not ready to accept signals.'"]
+				});
+				log("received signal", {
+					peerId: this.localInfo,
+					remoteId: this.remoteInfo,
+					msg: msg.data
+				}, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$12,
+					L: 421,
+					S: this
+				});
+				await this._transport.onSignal(signal);
+			}
+		}
+	}
+	initiate() {
+		this._changeState("INITIAL");
+	}
+	_changeState(state) {
+		log("stateChanged", {
+			from: this._state,
+			to: state,
+			peerId: this.localInfo
+		}, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$12,
+			L: 432,
+			S: this
+		});
+		invariant(state !== this._state, "Already in this state.", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$12,
+			L: 433,
+			S: this,
+			A: ["state !== this._state", "'Already in this state.'"]
+		});
+		this._state = state;
+		this.stateChanged.emit(state);
+	}
+	async _emitTransportStats() {
+		const stats = await this.transport?.getStats();
+		if (stats) this.transportStats.emit(stats);
+	}
+};
+__decorate([logInfo], Connection.prototype, "sessionIdString", null);
+__decorate([synchronized], Connection.prototype, "abort", null);
+__decorate([synchronized], Connection.prototype, "close", null);
+//#endregion
+//#region src/signal/swarm-messenger.ts
+var __dxlog_file$11 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/signal/swarm-messenger.ts";
+var SwarmMessage = schema.getCodecForType("dxos.mesh.swarm.SwarmMessage");
+/**
+* Adds offer/answer and signal interfaces.
+*/
+var SwarmMessenger = class {
+	_sendMessage;
+	_onSignal;
+	_onOffer;
+	_topic;
+	_offerRecords = new ComplexMap((key) => key.toHex());
+	constructor({ sendMessage, onSignal, onOffer, topic }) {
+		this._sendMessage = sendMessage;
+		this._onSignal = onSignal;
+		this._onOffer = onOffer;
+		this._topic = topic;
+	}
+	async receiveMessage(ctx, { author, recipient, payload }) {
+		if (payload.type_url !== "dxos.mesh.swarm.SwarmMessage") return;
+		invariant(recipient, "Recipient is required", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$11,
+			L: 54,
+			S: this,
+			A: ["recipient", "'Recipient is required'"]
+		});
+		const message = SwarmMessage.decode(payload.value);
+		if (!this._topic.equals(message.topic)) return;
+		log("received", {
+			from: author,
+			to: recipient,
+			msg: message
+		}, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$11,
+			L: 62,
+			S: this
+		});
+		if (message.data?.offer) await this._handleOffer(ctx, {
+			author,
+			recipient,
+			message
+		});
+		else if (message.data?.answer) await this._resolveAnswers(message);
+		else if (message.data?.signal) await this._handleSignal(ctx, {
+			author,
+			recipient,
+			message
+		});
+		else if (message.data?.signalBatch) await this._handleSignal(ctx, {
+			author,
+			recipient,
+			message
+		});
+		else log.warn("unknown message", { message }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$11,
+			L: 73,
+			S: this
+		});
+	}
+	async signal(ctx, message) {
+		invariant(message.data?.signal || message.data?.signalBatch, "Invalid message", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$11,
+			L: 78,
+			S: this,
+			A: ["message.data?.signal || message.data?.signalBatch", "'Invalid message'"]
+		});
+		await this._sendReliableMessage(ctx, {
+			author: message.author,
+			recipient: message.recipient,
+			message
+		});
+	}
+	async offer(ctx, message) {
+		const networkMessage = {
+			...message,
+			messageId: PublicKey.random()
+		};
+		return new Promise((resolve, reject) => {
+			this._offerRecords.set(networkMessage.messageId, { resolve });
+			this._sendReliableMessage(ctx, {
+				author: message.author,
+				recipient: message.recipient,
+				message: networkMessage
+			}).catch((err) => reject(err));
+		});
+	}
+	async _sendReliableMessage(ctx, { author, recipient, message }) {
+		const networkMessage = {
+			...message,
+			messageId: message.messageId ?? PublicKey.random()
+		};
+		log("sending", {
+			from: author,
+			to: recipient,
+			msg: networkMessage
+		}, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$11,
+			L: 119,
+			S: this
+		});
+		await this._sendMessage(ctx, {
+			author,
+			recipient,
+			payload: {
+				type_url: "dxos.mesh.swarm.SwarmMessage",
+				value: SwarmMessage.encode(networkMessage)
+			}
+		});
+	}
+	async _resolveAnswers(message) {
+		invariant(message.data?.answer?.offerMessageId, "No offerMessageId", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$11,
+			L: 131,
+			S: this,
+			A: ["message.data?.answer?.offerMessageId", "'No offerMessageId'"]
+		});
+		const offerRecord = this._offerRecords.get(message.data.answer.offerMessageId);
+		if (offerRecord) {
+			this._offerRecords.delete(message.data.answer.offerMessageId);
+			invariant(message.data?.answer, "No answer", {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$11,
+				L: 135,
+				S: this,
+				A: ["message.data?.answer", "'No answer'"]
+			});
+			log("resolving", { answer: message.data.answer }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$11,
+				L: 136,
+				S: this
+			});
+			offerRecord.resolve(message.data.answer);
+		}
+	}
+	async _handleOffer(ctx, { author, recipient, message }) {
+		invariant(message.data.offer, "No offer", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$11,
+			L: 153,
+			S: this,
+			A: ["message.data.offer", "'No offer'"]
+		});
+		const offerMessage = {
+			author,
+			recipient,
+			...message,
+			data: { offer: message.data.offer }
+		};
+		const answer = await this._onOffer(ctx, offerMessage);
+		answer.offerMessageId = message.messageId;
+		try {
+			await this._sendReliableMessage(ctx, {
+				author: recipient,
+				recipient: author,
+				message: {
+					topic: message.topic,
+					sessionId: message.sessionId,
+					data: { answer }
+				}
+			});
+		} catch (err) {
+			if (err instanceof TimeoutError) log.info("timeout sending answer to offer", { err }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$11,
+				L: 174,
+				S: this
+			});
+			else log.info("error sending answer to offer", { err }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$11,
+				L: 176,
+				S: this
+			});
+		}
+	}
+	async _handleSignal(ctx, { author, recipient, message }) {
+		invariant(message.messageId, void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$11,
+			L: 193,
+			S: this,
+			A: ["message.messageId", ""]
+		});
+		invariant(message.data.signal || message.data.signalBatch, "Invalid message", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$11,
+			L: 194,
+			S: this,
+			A: ["message.data.signal || message.data.signalBatch", "'Invalid message'"]
+		});
+		const signalMessage = {
+			author,
+			recipient,
+			...message,
+			data: {
+				signal: message.data.signal,
+				signalBatch: message.data.signalBatch
+			}
+		};
+		await this._onSignal(ctx, signalMessage);
+	}
+};
+//#endregion
+//#region src/swarm/peer.ts
+var __dxlog_file$10 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/swarm/peer.ts";
+var ConnectionDisplacedError = class extends SystemError {
+	constructor() {
+		super({ message: "Connection displaced by remote initiator." });
+	}
+};
+/**
+* Minimum time the connection needs to be open to not incur a cool-down timer for this peer after the connection closes.
+*/
+var CONNECTION_COUNTS_STABLE_AFTER = 5e3;
+/**
+* State of remote peer during the lifetime of a swarm connection.
+* Can open and close multiple connections to the remote peer.
+*/
+var Peer = class {
+	remoteInfo;
+	topic;
+	localInfo;
+	_signalMessaging;
+	_protocolProvider;
+	_transportFactory;
+	_connectionLimiter;
+	_callbacks;
+	/**
+	* Will be available to connect after this time.
+	*/
+	_availableAfter = 0;
+	availableToConnect = true;
+	_lastConnectionTime;
+	_ctx = new Context(void 0, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$10,
+		L: 80
+	});
+	_connectionCtx;
+	connection;
+	/**
+	* Whether the peer is currently advertizing itself on the signal-network.
+	*/
+	advertizing = false;
+	initiating = false;
+	connectionDisplaced = new Event();
+	constructor(remoteInfo, topic, localInfo, _signalMessaging, _protocolProvider, _transportFactory, _connectionLimiter, _callbacks) {
+		this.remoteInfo = remoteInfo;
+		this.topic = topic;
+		this.localInfo = localInfo;
+		this._signalMessaging = _signalMessaging;
+		this._protocolProvider = _protocolProvider;
+		this._transportFactory = _transportFactory;
+		this._connectionLimiter = _connectionLimiter;
+		this._callbacks = _callbacks;
+	}
+	/**
+	* Respond to remote offer.
+	*/
+	async onOffer(_ctx, message) {
+		const remote = message.author;
+		if (this.connection && ![
+			ConnectionState$2.CREATED,
+			ConnectionState$2.INITIAL,
+			ConnectionState$2.CONNECTING
+		].includes(this.connection.state)) {
+			log.info(`received offer when connection already in ${this.connection.state} state`, void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$10,
+				L: 115,
+				S: this
+			});
+			return { accept: false };
+		}
+		if (this.connection || this.initiating) if (remote.peerKey < this.localInfo.peerKey) {
+			log("close local connection", {
+				localPeer: this.localInfo,
+				topic: this.topic,
+				remotePeer: this.remoteInfo,
+				sessionId: this.connection?.sessionId
+			}, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$10,
+				L: 124,
+				S: this
+			});
+			if (this.connection) await this.closeConnection(new ConnectionDisplacedError());
+		} else return { accept: false };
+		if (await this._callbacks.onOffer(remote)) {
+			if (!this.connection) {
+				invariant(message.sessionId, void 0, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$10,
+					L: 144,
+					S: this,
+					A: ["message.sessionId", ""]
+				});
+				const connection = this._createConnection(false, message.sessionId);
+				try {
+					await this._connectionLimiter.connecting(message.sessionId);
+					connection.initiate();
+					await connection.openConnection();
+				} catch (err) {
+					if (!(err instanceof CancelledError)) log.info("connection error", {
+						topic: this.topic,
+						peerId: this.localInfo,
+						remoteId: this.remoteInfo,
+						err
+					}, {
+						"~LogMeta": "~LogMeta",
+						F: __dxlog_file$10,
+						L: 154,
+						S: this
+					});
+					await this.closeConnection(err);
+				}
+				return { accept: true };
+			}
+		}
+		return { accept: false };
+	}
+	/**
+	* Initiate a connection to the remote peer.
+	*/
+	async initiateConnection(ctx) {
+		invariant(!this.initiating, "Initiation in progress.", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$10,
+			L: 172,
+			S: this,
+			A: ["!this.initiating", "'Initiation in progress.'"]
+		});
+		invariant(!this.connection, "Already connected.", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$10,
+			L: 173,
+			S: this,
+			A: ["!this.connection", "'Already connected.'"]
+		});
+		const sessionId = PublicKey.random();
+		log("initiating...", {
+			local: this.localInfo,
+			topic: this.topic,
+			remote: this.remoteInfo,
+			sessionId
+		}, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$10,
+			L: 175,
+			S: this
+		});
+		const connection = this._createConnection(true, sessionId);
+		this.initiating = true;
+		let answer;
+		try {
+			await this._connectionLimiter.connecting(sessionId);
+			connection.initiate();
+			answer = await this._signalMessaging.offer(ctx, {
+				author: this.localInfo,
+				recipient: this.remoteInfo,
+				sessionId,
+				topic: this.topic,
+				data: { offer: {} }
+			});
+			log("received", {
+				answer,
+				topic: this.topic,
+				local: this.localInfo,
+				remote: this.remoteInfo
+			}, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$10,
+				L: 192,
+				S: this
+			});
+			if (connection.state !== ConnectionState$2.INITIAL) {
+				log("ignoring response", void 0, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$10,
+					L: 194,
+					S: this
+				});
+				return;
+			}
+		} catch (err) {
+			log("initiation error: send offer", {
+				err,
+				topic: this.topic,
+				local: this.localInfo,
+				remote: this.remoteInfo
+			}, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$10,
+				L: 198,
+				S: this
+			});
+			await connection.abort(err);
+			throw err;
+		} finally {
+			this.initiating = false;
+		}
+		try {
+			if (!answer.accept) {
+				this._callbacks.onRejected();
+				return;
+			}
+		} catch (err) {
+			log("initiation error: accept answer", {
+				err,
+				topic: this.topic,
+				local: this.localInfo,
+				remote: this.remoteInfo
+			}, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$10,
+				L: 211,
+				S: this
+			});
+			await connection.abort(err);
+			throw err;
+		} finally {
+			this.initiating = false;
+		}
+		try {
+			log("opening connection as initiator", void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$10,
+				L: 224,
+				S: this
+			});
+			await connection.openConnection();
+			this._callbacks.onAccepted();
+		} catch (err) {
+			log("initiation error: open connection", {
+				err,
+				topic: this.topic,
+				local: this.localInfo,
+				remote: this.remoteInfo
+			}, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$10,
+				L: 228,
+				S: this
+			});
+			log.warn("closing connection due to unhandled error on openConnection", { err }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$10,
+				L: 235,
+				S: this
+			});
+			await this.closeConnection(err);
+			throw err;
+		} finally {
+			this.initiating = false;
+		}
+	}
+	/**
+	* Create new connection.
+	* Either we're initiating a connection or creating one in response to an offer from the other peer.
+	*/
+	_createConnection(initiator, sessionId) {
+		log("creating connection", {
+			topic: this.topic,
+			peerId: this.localInfo,
+			remoteId: this.remoteInfo,
+			initiator,
+			sessionId
+		}, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$10,
+			L: 249,
+			S: this
+		});
+		invariant(!this.connection, "Already connected.", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$10,
+			L: 256,
+			S: this,
+			A: ["!this.connection", "'Already connected.'"]
+		});
+		const connection = new Connection(this.topic, this.localInfo, this.remoteInfo, sessionId, initiator, this._signalMessaging, this._protocolProvider({
+			initiator,
+			localPeerId: PublicKey.from(this.localInfo.peerKey),
+			remotePeerId: PublicKey.from(this.remoteInfo.peerKey),
+			topic: this.topic
+		}), this._transportFactory, {
+			onConnected: () => {
+				this.availableToConnect = true;
+				this._lastConnectionTime = Date.now();
+				this._callbacks.onConnected();
+				this._connectionLimiter.doneConnecting(sessionId);
+				log.trace("dxos.mesh.connection.connected", {
+					topic: this.topic,
+					localPeerId: this.localInfo,
+					remotePeerId: this.remoteInfo,
+					sessionId,
+					initiator
+				}, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$10,
+					L: 280,
+					S: this
+				});
+			},
+			onClosed: (err) => {
+				const logMeta = {
+					topic: this.topic,
+					peerId: this.localInfo,
+					remoteId: this.remoteInfo,
+					initiator
+				};
+				log("connection closed", logMeta, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$10,
+					L: 290,
+					S: this
+				});
+				this._connectionLimiter.doneConnecting(sessionId);
+				invariant(this.connection === connection, "Connection mismatch (race condition).", {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$10,
+					L: 295,
+					S: this,
+					A: ["this.connection === connection", "'Connection mismatch (race condition).'"]
+				});
+				log.trace("dxos.mesh.connection.closed", {
+					topic: this.topic,
+					localPeerId: this.localInfo,
+					remotePeerId: this.remoteInfo,
+					sessionId,
+					initiator
+				}, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$10,
+					L: 297,
+					S: this
+				});
+				if (err instanceof ConnectionDisplacedError) this.connectionDisplaced.emit(this.connection);
+				else {
+					if (this._lastConnectionTime && this._lastConnectionTime + CONNECTION_COUNTS_STABLE_AFTER < Date.now()) this._availableAfter = 0;
+					else {
+						this.availableToConnect = false;
+						this._availableAfter = increaseInterval(this._availableAfter);
+					}
+					this._callbacks.onDisconnected();
+					scheduleTask(this._connectionCtx, () => {
+						log("peer became available", logMeta, {
+							"~LogMeta": "~LogMeta",
+							F: __dxlog_file$10,
+							L: 321,
+							S: this
+						});
+						this.availableToConnect = true;
+						this._callbacks.onPeerAvailable();
+					}, this._availableAfter);
+				}
+				this.connection = void 0;
+			}
+		});
+		this._callbacks.onInitiated(connection);
+		this._connectionCtx?.dispose();
+		this._connectionCtx = this._ctx.derive();
+		connection.errors.handle((err) => {
+			log.info("connection error, closing", {
+				topic: this.topic,
+				peerId: this.localInfo,
+				remoteId: this.remoteInfo,
+				initiator,
+				err
+			}, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$10,
+				L: 339,
+				S: this
+			});
+			log.trace("dxos.mesh.connection.error", {
+				topic: this.topic,
+				localPeerId: this.localInfo,
+				remotePeerId: this.remoteInfo,
+				sessionId,
+				initiator,
+				err
+			}, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$10,
+				L: 346,
+				S: this
+			});
+			this.closeConnection(err);
+		});
+		this.connection = connection;
+		return connection;
+	}
+	async closeConnection(err) {
+		if (!this.connection) return;
+		const connection = this.connection;
+		log("closing...", {
+			peerId: this.remoteInfo,
+			sessionId: connection.sessionId
+		}, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$10,
+			L: 371,
+			S: this
+		});
+		await connection.close({ error: err });
+		log("closed", {
+			peerId: this.remoteInfo,
+			sessionId: connection.sessionId
+		}, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$10,
+			L: 377,
+			S: this
+		});
+	}
+	async onSignal(ctx, message) {
+		if (!this.connection) {
+			log("dropping signal message for non-existent connection", { message }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$10,
+				L: 382,
+				S: this
+			});
+			return;
+		}
+		await this.connection.signal(ctx, message);
+	}
+	async safeDestroy(reason) {
+		await this._ctx.dispose();
+		log("Destroying peer", {
+			peerId: this.remoteInfo,
+			topic: this.topic
+		}, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$10,
+			L: 392,
+			S: this
+		});
+		await this?.connection?.close({ reason });
+	}
+};
+__decorate([synchronized], Peer.prototype, "safeDestroy", null);
+var increaseInterval = (interval) => {
+	if (interval === 0) return 50;
+	else if (interval < 500) return 500;
+	else if (interval < 1e3) return 1e3;
+	else if (interval < 5e3) return 5e3;
+	return 1e4;
+};
+//#endregion
+//#region src/swarm/swarm.ts
+var __dxlog_file$9 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/swarm/swarm.ts";
+var INITIATION_DELAY = 100;
+var getClassName = (obj) => Object.getPrototypeOf(obj).constructor.name;
+/**
+* A single peer's view of the swarm.
+* Manages a set of peers subscribed on the same topic.
+* Routes signal events and maintains swarm topology.
+*/
+var Swarm = class {
+	_topic;
+	_ownPeer;
+	_topology;
+	_protocolProvider;
+	_messenger;
+	_transportFactory;
+	_label;
+	_connectionLimiter;
+	_initiationDelay;
+	_swarmMessenger;
+	_ctx = new Context(void 0, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$9,
+		L: 37
+	});
+	_listeningHandle = void 0;
+	/**
+	* PeerInfo -> Peer.
+	* @internal
+	*/
+	_peers = new ComplexMap(PeerInfoHash);
+	/**
+	* Unique id of the swarm, local to the current peer, generated when swarm is joined.
+	*/
+	_instanceId = PublicKey.random().toHex();
+	/**
+	* New connection to a peer is started.
+	* @internal
+	*/
+	connectionAdded = new Event();
+	/**
+	* Connection to a peer is dropped.
+	* @internal
+	*/
+	disconnected = new Event();
+	/**
+	* Connection is established to a new peer.
+	* @internal
+	*/
+	connected = new Event();
+	errors = new ErrorStream();
+	constructor(_topic, _ownPeer, _topology, _protocolProvider, _messenger, _transportFactory, _label, _connectionLimiter, _initiationDelay = INITIATION_DELAY) {
+		this._topic = _topic;
+		this._ownPeer = _ownPeer;
+		this._topology = _topology;
+		this._protocolProvider = _protocolProvider;
+		this._messenger = _messenger;
+		this._transportFactory = _transportFactory;
+		this._label = _label;
+		this._connectionLimiter = _connectionLimiter;
+		this._initiationDelay = _initiationDelay;
+		log("creating swarm", {
+			topic: this._topic.toHex(),
+			peer: this._ownPeer
+		}, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$9,
+			L: 87,
+			S: this
+		});
+		_topology.init(this._getSwarmController());
+		this._swarmMessenger = new SwarmMessenger({
+			sendMessage: async (ctx, msg) => await this._messenger.sendMessage(ctx, msg),
+			onSignal: async (ctx, msg) => await this.onSignal(ctx, msg),
+			onOffer: async (ctx, msg) => await this.onOffer(ctx, msg),
+			topic: this._topic
+		});
+	}
+	get connections() {
+		return Array.from(this._peers.values()).map((peer) => peer.connection).filter(isNonNullable);
+	}
+	get ownPeerId() {
+		return PublicKey.from(this._ownPeer.peerKey);
+	}
+	get ownPeer() {
+		return this._ownPeer;
+	}
+	/**
+	* Custom label assigned to this swarm. Used in devtools to display human-readable names for swarms.
+	*/
+	get label() {
+		return this._label;
+	}
+	get topic() {
+		return this._topic;
+	}
+	async open() {
+		invariant(!this._listeningHandle, void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$9,
+			L: 126,
+			S: this,
+			A: ["!this._listeningHandle", ""]
+		});
+		this._listeningHandle = await this._messenger.listen({
+			peer: this._ownPeer,
+			payloadType: "dxos.mesh.swarm.SwarmMessage",
+			onMessage: async (message) => {
+				await this._swarmMessenger.receiveMessage(this._ctx, message).catch((err) => log.info("Error while receiving message", { err }, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$9,
+					L: 134,
+					S: this
+				}));
+			}
+		});
+	}
+	async destroy() {
+		log("destroying...", void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$9,
+			L: 140,
+			S: this
+		});
+		await this._listeningHandle?.unsubscribe();
+		this._listeningHandle = void 0;
+		await this._ctx.dispose();
+		await this._topology.destroy();
+		await Promise.all(Array.from(this._peers.keys()).map((key) => this._destroyPeer(key, "swarm destroyed")));
+		log("destroyed", void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$9,
+			L: 147,
+			S: this
+		});
+	}
+	async setTopology(topology) {
+		invariant(!this._ctx.disposed, "Swarm is offline", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$9,
+			L: 151,
+			S: this,
+			A: ["!this._ctx.disposed", "'Swarm is offline'"]
+		});
+		if (topology === this._topology) return;
+		log("setting topology", {
+			previous: getClassName(this._topology),
+			topology: getClassName(topology)
+		}, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$9,
+			L: 155,
+			S: this
+		});
+		await this._topology.destroy();
+		this._topology = topology;
+		this._topology.init(this._getSwarmController());
+		this._topology.update();
+	}
+	async onSwarmEvent(swarmEvent) {
+		log("swarm event", { swarmEvent }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$9,
+			L: 168,
+			S: this
+		});
+		if (this._ctx.disposed) {
+			log("swarm event ignored for disposed swarm", void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$9,
+				L: 171,
+				S: this
+			});
+			return;
+		}
+		if (swarmEvent.peerAvailable) {
+			const peerId = swarmEvent.peerAvailable.peer.peerKey;
+			if (peerId !== this._ownPeer.peerKey) {
+				log("new peer", { peerId }, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$9,
+					L: 178,
+					S: this
+				});
+				const peer = this._getOrCreatePeer(swarmEvent.peerAvailable.peer);
+				peer.advertizing = true;
+			}
+		} else if (swarmEvent.peerLeft) {
+			const peer = this._peers.get(swarmEvent.peerLeft.peer);
+			if (peer) {
+				peer.advertizing = false;
+				if (this._isConnectionEstablishmentInProgress(peer)) {
+					log(`destroying peer, state: ${peer.connection?.state}`, void 0, {
+						"~LogMeta": "~LogMeta",
+						F: __dxlog_file$9,
+						L: 189,
+						S: this
+					});
+					this._destroyPeer(swarmEvent.peerLeft.peer, "peer left").catch((err) => log.catch(err, void 0, {
+						"~LogMeta": "~LogMeta",
+						F: __dxlog_file$9,
+						L: 190,
+						S: this
+					}));
+				}
+			} else log("received peerLeft but no peer found", { peer: swarmEvent.peerLeft.peer.peerKey }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$9,
+				L: 193,
+				S: this
+			});
+		}
+		this._topology.update();
+	}
+	async onOffer(ctx, message) {
+		log("offer", { message }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$9,
+			L: 202,
+			S: this
+		});
+		if (this._ctx.disposed) {
+			log("ignored for disposed swarm", void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$9,
+				L: 204,
+				S: this
+			});
+			return { accept: false };
+		}
+		invariant(message.author, void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$9,
+			L: 209,
+			S: this,
+			A: ["message.author", ""]
+		});
+		if (message.recipient.peerKey !== this._ownPeer.peerKey) {
+			log("rejecting offer with incorrect peerId", { message }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$9,
+				L: 211,
+				S: this
+			});
+			return { accept: false };
+		}
+		if (!message.topic?.equals(this._topic)) {
+			log("rejecting offer with incorrect topic", { message }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$9,
+				L: 215,
+				S: this
+			});
+			return { accept: false };
+		}
+		const answer = await this._getOfferSenderPeer(message.author).onOffer(ctx, message);
+		this._topology.update();
+		return answer;
+	}
+	_getOfferSenderPeer(senderInfo) {
+		const peer = this._getOrCreatePeer(senderInfo);
+		const connectionState = peer.connection?.state;
+		if (connectionState === ConnectionState$2.CLOSING || connectionState === ConnectionState$2.ABORTING) {
+			this._peers.delete(peer.remoteInfo);
+			this.disconnected.emit(peer.remoteInfo);
+			return this._getOrCreatePeer(peer.remoteInfo);
+		}
+		return peer;
+	}
+	async onSignal(ctx, message) {
+		log("signal", { message }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$9,
+			L: 240,
+			S: this
+		});
+		if (this._ctx.disposed) {
+			log.info("ignored for offline swarm", void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$9,
+				L: 242,
+				S: this
+			});
+			return;
+		}
+		invariant(message.recipient.peerKey === this._ownPeer.peerKey, `Invalid signal peer id expected=${this.ownPeerId}, actual=${message.recipient}`, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$9,
+			L: 245,
+			S: this,
+			A: ["message.recipient.peerKey === this._ownPeer.peerKey", "`Invalid signal peer id expected=${this.ownPeerId}, actual=${message.recipient}`"]
+		});
+		invariant(message.topic?.equals(this._topic), void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$9,
+			L: 249,
+			S: this,
+			A: ["message.topic?.equals(this._topic)", ""]
+		});
+		invariant(message.author, void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$9,
+			L: 250,
+			S: this,
+			A: ["message.author", ""]
+		});
+		await this._getOrCreatePeer(message.author).onSignal(ctx, message);
+	}
+	async goOffline() {
+		await this._ctx.dispose();
+		await Promise.all([...this._peers.keys()].map((peerId) => this._destroyPeer(peerId, "goOffline")));
+	}
+	async goOnline() {
+		this._ctx = new Context(void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$9,
+			L: 266
+		});
+	}
+	_getOrCreatePeer(peerInfo) {
+		invariant(peerInfo.peerKey, "PeerInfo.peerKey is required", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$9,
+			L: 270,
+			S: this,
+			A: ["peerInfo.peerKey", "'PeerInfo.peerKey is required'"]
+		});
+		let peer = this._peers.get(peerInfo);
+		if (!peer) {
+			peer = new Peer(peerInfo, this._topic, this._ownPeer, this._swarmMessenger, this._protocolProvider, this._transportFactory, this._connectionLimiter, {
+				onInitiated: (connection) => {
+					this.connectionAdded.emit(connection);
+				},
+				onConnected: () => {
+					this.connected.emit(peerInfo);
+				},
+				onDisconnected: async () => {
+					if (this._isUnregistered(peer)) {
+						log.verbose("ignored onDisconnected for unregistered peer", void 0, {
+							"~LogMeta": "~LogMeta",
+							F: __dxlog_file$9,
+							L: 290,
+							S: this
+						});
+						return;
+					}
+					if (!peer.advertizing) await this._destroyPeer(peerInfo, "peer disconnected");
+					this.disconnected.emit(peerInfo);
+					this._topology.update();
+				},
+				onRejected: () => {
+					if (!this._isUnregistered(peer)) {
+						log("peer rejected connection", { peerInfo }, {
+							"~LogMeta": "~LogMeta",
+							F: __dxlog_file$9,
+							L: 304,
+							S: this
+						});
+						this._destroyPeer(peerInfo, "peer rejected connection");
+					}
+				},
+				onAccepted: () => {
+					this._topology.update();
+				},
+				onOffer: (remoteId) => {
+					return this._topology.onOffer(PublicKey.from(remoteId.peerKey));
+				},
+				onPeerAvailable: () => {
+					this._topology.update();
+				}
+			});
+			this._peers.set(peerInfo, peer);
+		}
+		return peer;
+	}
+	async _destroyPeer(peerInfo, reason) {
+		log("destroy peer", {
+			peerKey: peerInfo.peerKey,
+			reason
+		}, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$9,
+			L: 326,
+			S: this
+		});
+		const peer = this._peers.get(peerInfo);
+		invariant(peer, void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$9,
+			L: 328,
+			S: this,
+			A: ["peer", ""]
+		});
+		this._peers.delete(peerInfo);
+		await peer.safeDestroy(reason);
+	}
+	_getSwarmController() {
+		return {
+			getState: () => ({
+				ownPeerId: PublicKey.from(this._ownPeer.peerKey),
+				connected: Array.from(this._peers.entries()).filter(([_, peer]) => peer.connection).map(([info]) => PublicKey.from(info.peerKey)),
+				candidates: Array.from(this._peers.entries()).filter(([_, peer]) => !peer.connection && peer.advertizing && peer.availableToConnect).map(([info]) => PublicKey.from(info.peerKey)),
+				allPeers: Array.from(this._peers.keys()).map((info) => PublicKey.from(info.peerKey))
+			}),
+			connect: (peer) => {
+				if (this._ctx.disposed) return;
+				scheduleTask(this._ctx, async () => {
+					try {
+						await this._initiateConnection({ peerKey: peer.toHex() });
+					} catch (err) {
+						log("initiation error", err, {
+							"~LogMeta": "~LogMeta",
+							F: __dxlog_file$9,
+							L: 355,
+							S: this
+						});
+					}
+				});
+			},
+			disconnect: async (peer) => {
+				if (this._ctx.disposed) return;
+				scheduleTask(this._ctx, async () => {
+					await this._closeConnection({ peerKey: peer.toHex() });
+					this._topology.update();
+				});
+			}
+		};
+	}
+	/**
+	* Creates a connection then sends message over signal network.
+	*/
+	async _initiateConnection(remotePeer) {
+		const ctx = this._ctx;
+		const peer = this._getOrCreatePeer(remotePeer);
+		if (remotePeer.peerKey < this._ownPeer.peerKey) {
+			log("initiation delay", { remotePeer }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$9,
+				L: 383,
+				S: this
+			});
+			await sleep(this._initiationDelay);
+		}
+		if (ctx.disposed) return;
+		if (this._isUnregistered(peer)) throw new Error("Peer left during initiation delay");
+		if (peer.connection) return;
+		log("initiating connection...", { remotePeer }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$9,
+			L: 399,
+			S: this
+		});
+		await peer.initiateConnection(ctx);
+		this._topology.update();
+		log("initiated", { remotePeer }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$9,
+			L: 402,
+			S: this
+		});
+	}
+	async _closeConnection(peerInfo) {
+		const peer = this._peers.get(peerInfo);
+		if (!peer) return;
+		await peer.closeConnection();
+	}
+	_isConnectionEstablishmentInProgress(peer) {
+		if (!peer.connection) return true;
+		return [
+			ConnectionState$2.INITIAL,
+			ConnectionState$2.CREATED,
+			ConnectionState$2.CONNECTING
+		].includes(peer.connection.state);
+	}
+	_isUnregistered(peer) {
+		return !peer || this._peers.get(peer.remoteInfo) !== peer;
+	}
+};
+__decorate([logInfo], Swarm.prototype, "_instanceId", void 0);
+__decorate([logInfo], Swarm.prototype, "ownPeer", null);
+__decorate([logInfo], Swarm.prototype, "topic", null);
+__decorate([synchronized], Swarm.prototype, "onSwarmEvent", null);
+__decorate([synchronized], Swarm.prototype, "onOffer", null);
+__decorate([synchronized], Swarm.prototype, "goOffline", null);
+__decorate([synchronized], Swarm.prototype, "goOnline", null);
+//#endregion
+//#region src/swarm/swarm-mapper.ts
+var __dxlog_file$8 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/swarm/swarm-mapper.ts";
+var SwarmMapper = class {
+	_swarm;
+	_subscriptions = new SubscriptionList();
+	_connectionSubscriptions = new ComplexMap(PeerInfoHash);
+	_peers = new ComplexMap(PeerInfoHash);
+	mapUpdated = new Event();
+	get peers() {
+		return Array.from(this._peers.values());
+	}
+	constructor(_swarm) {
+		this._swarm = _swarm;
+		this._subscriptions.add(_swarm.connectionAdded.on((connection) => {
+			this._update();
+			this._connectionSubscriptions.set(connection.remoteInfo, connection.stateChanged.on(() => {
+				this._update();
+			}));
+		}));
+		this._subscriptions.add(_swarm.disconnected.on((peerId) => {
+			this._connectionSubscriptions.get(peerId)?.();
+			this._connectionSubscriptions.delete(peerId);
+			this._update();
+		}));
+		this._update();
+	}
+	_update() {
+		log("updating swarm", void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$8,
+			L: 71,
+			S: this
+		});
+		this._peers.clear();
+		this._peers.set(this._swarm.ownPeer, {
+			id: this._swarm.ownPeerId,
+			state: "ME",
+			connections: []
+		});
+		for (const connection of this._swarm.connections) this._peers.set(connection.remoteInfo, {
+			id: PublicKey.from(connection.remoteInfo.peerKey),
+			state: connection.state,
+			connections: [this._swarm.ownPeerId]
+		});
+		log("graph changed", {
+			directConnections: this._swarm.connections.length,
+			totalPeersInSwarm: this._peers.size
+		}, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$8,
+			L: 112,
+			S: this
+		});
+		this.mapUpdated.emit(Array.from(this._peers.values()));
+	}
+	destroy() {
+		Array.from(this._connectionSubscriptions.values()).forEach((cb) => cb());
+		this._connectionSubscriptions.clear();
+		this._subscriptions.clear();
+	}
+};
+//#endregion
+//#region src/swarm/connection-limiter.ts
+var __dxlog_file$7 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/swarm/connection-limiter.ts";
+var MAX_CONCURRENT_INITIATING_CONNECTIONS = 50;
+/**
+* Limits the amount of concurrent connections with 'CONNECTING' state.
+*/
+var ConnectionLimiter = class {
+	_ctx = new Context(void 0, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$7,
+		L: 23
+	});
+	_maxConcurrentInitConnections;
+	/**
+	* Queue of promises to resolve when initiating connections amount is below the limit.
+	*/
+	_waitingPromises = new ComplexMap(PublicKey.hash);
+	resolveWaitingPromises = new DeferredTask(this._ctx, async () => {
+		Array.from(this._waitingPromises.values()).slice(0, this._maxConcurrentInitConnections).forEach(({ resolve }) => {
+			resolve();
+		});
+	});
+	constructor({ maxConcurrentInitConnections = 50 } = {}) {
+		this._maxConcurrentInitConnections = maxConcurrentInitConnections;
+	}
+	/**
+	* @returns Promise that resolves in queue when connections amount with 'CONNECTING' state is below the limit.
+	*/
+	async connecting(sessionId) {
+		invariant(!this._waitingPromises.has(sessionId), "Peer is already waiting for connection", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$7,
+			L: 48,
+			S: this,
+			A: ["!this._waitingPromises.has(sessionId)", "'Peer is already waiting for connection'"]
+		});
+		log("waiting", { sessionId }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$7,
+			L: 49,
+			S: this
+		});
+		await new Promise((resolve, reject) => {
+			this._waitingPromises.set(sessionId, {
+				resolve,
+				reject
+			});
+			this.resolveWaitingPromises.schedule();
+		});
+		log("allow", { sessionId }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$7,
+			L: 57,
+			S: this
+		});
+	}
+	/**
+	* Rejects promise returned by `connecting` method.
+	*/
+	doneConnecting(sessionId) {
+		log("done", { sessionId }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$7,
+			L: 64,
+			S: this
+		});
+		if (!this._waitingPromises.has(sessionId)) return;
+		this._waitingPromises.get(sessionId).reject(new CancelledError());
+		this._waitingPromises.delete(sessionId);
+		this.resolveWaitingPromises.schedule();
+	}
+};
+//#endregion
+//#region src/connection-log.ts
+var CONNECTION_GC_THRESHOLD = 1e3 * 60 * 15;
+var EventType = /* @__PURE__ */ function(EventType) {
+	EventType["CONNECTION_STATE_CHANGED"] = "CONNECTION_STATE_CHANGED";
+	EventType["PROTOCOL_ERROR"] = "PROTOCOL_ERROR";
+	EventType["PROTOCOL_EXTENSIONS_INITIALIZED"] = "PROTOCOL_EXTENSIONS_INITIALIZED";
+	EventType["PROTOCOL_EXTENSIONS_HANDSHAKE"] = "PROTOCOL_EXTENSIONS_HANDSHAKE";
+	EventType["PROTOCOL_HANDSHAKE"] = "PROTOCOL_HANDSHAKE";
+	return EventType;
+}({});
+var ConnectionLog = class {
+	/**
+	* SwarmId => info
+	*/
+	_swarms = new ComplexMap(PublicKey.hash);
+	update = new Event();
+	getSwarmInfo(swarmId) {
+		return this._swarms.get(swarmId) ?? raise(/* @__PURE__ */ new Error(`Swarm not found: ${swarmId}`));
+	}
+	get swarms() {
+		return Array.from(this._swarms.values());
+	}
+	joinedSwarm(swarm) {
+		const info = {
+			id: PublicKey.from(swarm._instanceId),
+			topic: swarm.topic,
+			isActive: true,
+			label: swarm.label,
+			connections: []
+		};
+		this._swarms.set(PublicKey.from(swarm._instanceId), info);
+		this.update.emit();
+		swarm.connectionAdded.on((connection) => {
+			const connectionInfo = {
+				state: ConnectionState$2.CREATED,
+				closeReason: connection.closeReason,
+				remotePeerId: PublicKey.from(connection.remoteInfo.peerKey),
+				sessionId: connection.sessionId,
+				transport: connection.transport && Object.getPrototypeOf(connection.transport).constructor.name,
+				protocolExtensions: [],
+				events: [],
+				lastUpdate: /* @__PURE__ */ new Date()
+			};
+			info.connections.push(connectionInfo);
+			this.update.emit();
+			connection.stateChanged.on(async (state) => {
+				connectionInfo.state = state;
+				connectionInfo.closeReason = connection.closeReason;
+				connectionInfo.lastUpdate = /* @__PURE__ */ new Date();
+				connectionInfo.events.push({
+					type: "CONNECTION_STATE_CHANGED",
+					newState: state
+				});
+				if (state === ConnectionState$2.CONNECTED) {
+					const details = await connection.transport?.getDetails();
+					connectionInfo.transportDetails = details;
+				}
+				this.update.emit();
+			});
+			connection.protocol?.stats?.on((stats) => {
+				connectionInfo.readBufferSize = stats.readBufferSize;
+				connectionInfo.writeBufferSize = stats.writeBufferSize;
+				connectionInfo.streams = stats.channels;
+				connectionInfo.lastUpdate = /* @__PURE__ */ new Date();
+				this.update.emit();
+			});
+			connection.transportStats?.on((stats) => {
+				connectionInfo.transportBytesSent = stats.bytesSent;
+				connectionInfo.transportBytesReceived = stats.bytesReceived;
+				connectionInfo.transportPacketsSent = stats.packetsSent;
+				connectionInfo.transportPacketsReceived = stats.packetsReceived;
+			});
+			gcSwarm(info);
+		});
+	}
+	leftSwarm(swarm) {
+		this.getSwarmInfo(PublicKey.from(swarm._instanceId)).isActive = false;
+		this.update.emit();
+	}
+};
+var gcSwarm = (swarm) => {
+	swarm.connections = swarm.connections?.filter((connection) => {
+		return connection.lastUpdate ? Date.now() - connection.lastUpdate.getTime() < CONNECTION_GC_THRESHOLD : true;
+	});
+};
+//#endregion
+//#region src/network-manager.ts
+var __dxlog_file$6 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/network-manager.ts";
+/**
+* Effect service tag for {@link SwarmNetworkManager}.
+*/
+var SwarmNetworkManagerService = class extends EffectContext.Tag("@dxos/network-manager/SwarmNetworkManager")() {};
+/**
+* Manages p2p connection to the swarm.
+*/
+var SwarmNetworkManager = class {
+	/**
+	* @internal
+	*/
+	_swarms = new ComplexMap(PublicKey.hash);
+	_mappers = new ComplexMap(PublicKey.hash);
+	_transportFactory;
+	_signalManager;
+	_messenger;
+	_signalConnection;
+	_connectionLimiter;
+	_connectionLog;
+	_peerInfo = void 0;
+	_connectionState = ConnectionState.ONLINE;
+	connectionStateChanged = new Event();
+	topicsUpdated = new Event();
+	constructor({ transportFactory, signalManager, enableDevtoolsLogging, peerInfo }) {
+		this._transportFactory = transportFactory;
+		this._signalManager = signalManager;
+		this._signalManager.swarmEvent.on((event) => this._swarms.get(event.topic)?.onSwarmEvent(event));
+		this._messenger = new Messenger({ signalManager: this._signalManager });
+		this._signalConnection = {
+			join: (ctx, opts) => this._signalManager.join(ctx, opts),
+			leave: (ctx, opts) => this._signalManager.leave(ctx, opts)
+		};
+		this._peerInfo = peerInfo;
+		this._connectionLimiter = new ConnectionLimiter();
+		if (enableDevtoolsLogging) this._connectionLog = new ConnectionLog();
+	}
+	get connectionLog() {
+		return this._connectionLog;
+	}
+	get connectionState() {
+		return this._connectionState;
+	}
+	get topics() {
+		return Array.from(this._swarms.keys());
+	}
+	getSwarmMap(topic) {
+		return this._mappers.get(topic);
+	}
+	getSwarm(topic) {
+		return this._swarms.get(topic);
+	}
+	setPeerInfo(peerInfo) {
+		this._peerInfo = peerInfo;
+	}
+	getPeerInfo() {
+		return this._peerInfo;
+	}
+	async open() {
+		log("opening network manager", void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$6,
+			L: 146,
+			S: this
+		});
+		await this._messenger.open();
+		await this._signalManager.open();
+		log("opened network manager", void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$6,
+			L: 149,
+			S: this
+		});
+	}
+	async close(ctx) {
+		for (const topic of this._swarms.keys()) await this.leaveSwarm(ctx, topic).catch((err) => {
+			log(err, void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$6,
+				L: 155,
+				S: this
+			});
+		});
+		await this._messenger.close();
+		await this._signalManager.close();
+	}
+	/**
+	* Join the swarm.
+	*/
+	async joinSwarm(ctx, { topic, topology, protocolProvider: protocol, label }) {
+		assertArgument(PublicKey.isPublicKey(topic), "topic");
+		invariant(topology, void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$6,
+			L: 177,
+			S: this,
+			A: ["topology", ""]
+		});
+		invariant(this._peerInfo, void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$6,
+			L: 178,
+			S: this,
+			A: ["this._peerInfo", ""]
+		});
+		assertArgument(typeof protocol === "function", "protocolProvider");
+		if (this._swarms.has(topic)) throw new Error(`Already connected to swarm: ${PublicKey.from(topic)}`);
+		log("joining", {
+			topic: PublicKey.from(topic),
+			peerInfo: this._peerInfo,
+			topology: topology.toString()
+		}, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$6,
+			L: 184,
+			S: this
+		});
+		const swarm = new Swarm(topic, this._peerInfo, topology, protocol, this._messenger, this._transportFactory, label, this._connectionLimiter);
+		swarm.errors.handle((error) => {
+			log("swarm error", { error }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$6,
+				L: 197,
+				S: this
+			});
+		});
+		this._swarms.set(topic, swarm);
+		this._mappers.set(topic, new SwarmMapper(swarm));
+		await swarm.open();
+		this._signalConnection.join(ctx, {
+			topic,
+			peer: this._peerInfo
+		}).catch((error) => log.catch(error, void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$6,
+			L: 206,
+			S: this
+		}));
+		this.topicsUpdated.emit();
+		this._connectionLog?.joinedSwarm(swarm);
+		log("joined", {
+			topic: PublicKey.from(topic),
+			count: this._swarms.size
+		}, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$6,
+			L: 210,
+			S: this
+		});
+		return { close: (ctx) => this.leaveSwarm(ctx, topic) };
+	}
+	/**
+	* Close the connection.
+	*/
+	async leaveSwarm(ctx, topic) {
+		if (!this._swarms.has(topic)) return;
+		log("leaving", { topic: PublicKey.from(topic) }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$6,
+			L: 227,
+			S: this
+		});
+		const swarm = this._swarms.get(topic);
+		await this._signalConnection.leave(ctx, {
+			topic,
+			peer: swarm.ownPeer
+		});
+		this._mappers.get(topic).destroy();
+		this._mappers.delete(topic);
+		this._connectionLog?.leftSwarm(swarm);
+		await swarm.destroy();
+		this._swarms.delete(topic);
+		this.topicsUpdated.emit();
+		log("left", {
+			topic: PublicKey.from(topic),
+			count: this._swarms.size
+		}, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$6,
+			L: 241,
+			S: this
+		});
+	}
+	async setConnectionState(state) {
+		if (state === this._connectionState) return;
+		switch (state) {
+			case ConnectionState.OFFLINE:
+				this._connectionState = state;
+				await Promise.all([...this._swarms.values()].map((swarm) => swarm.goOffline()));
+				await this._signalManager.close();
+				break;
+			case ConnectionState.ONLINE:
+				this._connectionState = state;
+				await Promise.all([...this._swarms.values()].map((swarm) => swarm.goOnline()));
+				await this._signalManager.open();
+				break;
+		}
+		this.connectionStateChanged.emit(this._connectionState);
+	}
+};
+__decorate([synchronized], SwarmNetworkManager.prototype, "joinSwarm", null);
+__decorate([synchronized], SwarmNetworkManager.prototype, "leaveSwarm", null);
+//#endregion
+//#region src/topology/fully-connected-topology.ts
+var __dxlog_file$5 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/topology/fully-connected-topology.ts";
+var FullyConnectedTopology = class {
+	_controller;
+	toString() {
+		return "FullyConnectedTopology";
+	}
+	init(controller) {
+		invariant(!this._controller, "Already initialized", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$5,
+			L: 18,
+			S: this,
+			A: ["!this._controller", "'Already initialized'"]
+		});
+		this._controller = controller;
+	}
+	update() {
+		invariant(this._controller, "Not initialized", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$5,
+			L: 23,
+			S: this,
+			A: ["this._controller", "'Not initialized'"]
+		});
+		const { candidates: discovered } = this._controller.getState();
+		for (const peer of discovered) this._controller.connect(peer);
+	}
+	async onOffer(peer) {
+		return true;
+	}
+	async destroy() {}
+};
+//#endregion
+//#region src/transport/memory-transport.ts
+var __dxlog_file$4 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/transport/memory-transport.ts";
+var MEMORY_TRANSPORT_DELAY = 1;
+/**
+* Creates a binary stream that delays data being sent through the stream by the specified amount of time.
+*/
+var createStreamDelay = (delay) => {
+	return new Transform({
+		objectMode: true,
+		transform: (chunk, _, cb) => {
+			setTimeout(() => cb(null, chunk), delay);
+		}
+	});
+};
+var MemoryTransportFactory = { createTransport: (options) => new MemoryTransport(options) };
+/**
+* Fake transport.
+*/
+var MemoryTransport = class MemoryTransport {
+	_options;
+	static _connections = new ComplexMap(PublicKey.hash);
+	_instanceId = PublicKey.random();
+	_remote = new Trigger();
+	_outgoingDelay = createStreamDelay(MEMORY_TRANSPORT_DELAY);
+	_incomingDelay = createStreamDelay(MEMORY_TRANSPORT_DELAY);
+	_closed = false;
+	_remoteInstanceId;
+	_remoteConnection;
+	closed = new Event();
+	connected = new Event();
+	errors = new ErrorStream();
+	constructor(_options) {
+		this._options = _options;
+		invariant(!MemoryTransport._connections.has(this._instanceId), "Duplicate memory connection", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$4,
+			L: 64,
+			S: this,
+			A: ["!MemoryTransport._connections.has(this._instanceId)", "'Duplicate memory connection'"]
+		});
+		MemoryTransport._connections.set(this._instanceId, this);
+	}
+	get isOpen() {
+		return !this._closed;
+	}
+	async open() {
+		log("opening...", void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$4,
+			L: 74,
+			S: this
+		});
+		if (this._options.initiator) {
+			log("sending signal", void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$4,
+				L: 78,
+				S: this
+			});
+			try {
+				await this._options.sendSignal({ payload: { transportId: this._instanceId.toHex() } });
+			} catch (err) {
+				if (!this._closed) this.errors.raise(toError(err));
+			}
+		} else this._remote.wait({ timeout: this._options.timeout ?? 1e3 }).then((remoteId) => {
+			if (this._closed) return;
+			this._remoteInstanceId = remoteId;
+			this._remoteConnection = MemoryTransport._connections.get(this._remoteInstanceId);
+			if (!this._remoteConnection) {
+				this._closed = true;
+				this.closed.emit();
+				return;
+			}
+			invariant(!this._remoteConnection._remoteConnection, `Remote already connected: ${this._remoteInstanceId}`, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$4,
+				L: 104,
+				S: this,
+				A: ["!this._remoteConnection._remoteConnection", "`Remote already connected: ${this._remoteInstanceId}`"]
+			});
+			this._remoteConnection._remoteConnection = this;
+			this._remoteConnection._remoteInstanceId = this._instanceId;
+			log("connected", void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$4,
+				L: 108,
+				S: this
+			});
+			this._options.stream.pipe(this._outgoingDelay).pipe(this._remoteConnection._options.stream).pipe(this._incomingDelay).pipe(this._options.stream);
+			this.connected.emit();
+			this._remoteConnection.connected.emit();
+		}).catch((err) => {
+			if (this._closed) return;
+			this.errors.raise(err);
+		});
+		return this;
+	}
+	async close() {
+		log("closing...", void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$4,
+			L: 130,
+			S: this
+		});
+		this._closed = true;
+		MemoryTransport._connections.delete(this._instanceId);
+		if (this._remoteConnection) {
+			this._remoteConnection._closed = true;
+			MemoryTransport._connections.delete(this._remoteInstanceId);
+			this._options.stream.unpipe(this._incomingDelay);
+			this._incomingDelay.unpipe(this._remoteConnection._options.stream);
+			this._remoteConnection._options.stream.unpipe(this._outgoingDelay);
+			this._outgoingDelay.unpipe(this._options.stream);
+			this._options.stream.unpipe(this._outgoingDelay);
+			this._remoteConnection.closed.emit();
+			this._remoteConnection._remoteConnection = void 0;
+			this._remoteConnection = void 0;
+		}
+		this.closed.emit();
+		log("closed", void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$4,
+			L: 158,
+			S: this
+		});
+		return this;
+	}
+	async onSignal({ payload }) {
+		log("received signal", { payload }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$4,
+			L: 163,
+			S: this
+		});
+		if (!payload?.transportId) return;
+		const transportId = payload.transportId;
+		if (transportId) {
+			const remoteId = PublicKey.fromHex(transportId);
+			this._remote.wake(remoteId);
+		}
+	}
+	async getDetails() {
+		return this._instanceId.toHex();
+	}
+	async getStats() {
+		return {
+			bytesSent: 0,
+			bytesReceived: 0,
+			packetsSent: 0,
+			packetsReceived: 0
+		};
+	}
+};
+__decorate([logInfo], MemoryTransport.prototype, "_instanceId", void 0);
+__decorate([logInfo], MemoryTransport.prototype, "_remoteInstanceId", void 0);
+var toError = (err) => err instanceof Error ? err : new Error(String(err));
+//#endregion
+//#region src/transport/transport.ts
+var TransportKind = /* @__PURE__ */ function(TransportKind) {
+	TransportKind["WEB_RTC"] = "WEB-RTC";
+	TransportKind["WEB_RTC_PROXY"] = "WEB-RTC_PROXY";
+	TransportKind["MEMORY"] = "MEMORY";
+	TransportKind["TCP"] = "TCP";
+	return TransportKind;
+}({});
+//#endregion
+//#region src/transport/webrtc/rtc-connection-factory.ts
+/**
+* Use built-in browser RTCPeerConnection.
+*/
+var BrowserRtcConnectionFactory = class {
+	async initialize() {}
+	async onConnectionDestroyed() {}
+	async createConnection(config) {
+		return new RTCPeerConnection(config);
+	}
+	async initConnection(connection, info) {}
+};
+/**
+* Use `node-datachannel` polyfill.
+* https://github.com/paullouisageneau/libdatachannel
+*/
+var NodeRtcConnectionFactory = class NodeRtcConnectionFactory {
+	static _createdConnections = 0;
+	static _cleanupMutex = new Mutex();
+	async initialize() {}
+	async onConnectionDestroyed() {
+		return NodeRtcConnectionFactory._cleanupMutex.executeSynchronized(async () => {
+			if (--NodeRtcConnectionFactory._createdConnections === 0) (await import("#node-datachannel")).cleanup();
+		});
+	}
+	async createConnection(config) {
+		return NodeRtcConnectionFactory._cleanupMutex.executeSynchronized(async () => {
+			const { RTCPeerConnection } = await import("#node-datachannel/polyfill");
+			NodeRtcConnectionFactory._createdConnections++;
+			return new RTCPeerConnection(config);
+		});
+	}
+	async initConnection(connection, info) {
+		if (info.initiator) connection.onnegotiationneeded?.(null);
+	}
+};
+/**
+* Create platform-specific connection factory.
+*/
+var getRtcConnectionFactory = () => {
+	return typeof globalThis.RTCPeerConnection === "undefined" ? new NodeRtcConnectionFactory() : new BrowserRtcConnectionFactory();
+};
+//#endregion
+//#region src/transport/webrtc/rtc-transport-stats.ts
+var describeSelectedRemoteCandidate = async (connection) => {
+	const rc = (connection && await getRtcConnectionStats(connection))?.remoteCandidate;
+	if (!rc) return "unavailable";
+	if (rc.candidateType === "relay") return `${rc.ip}:${rc.port} relay for ${rc.relatedAddress}:${rc.relatedPort}`;
+	return `${rc.ip}:${rc.port} ${rc.candidateType}`;
+};
+var createRtcTransportStats = async (connection, topic) => {
+	const stats = connection && await getRtcConnectionStats(connection, topic);
+	if (!stats) return {
+		bytesSent: 0,
+		bytesReceived: 0,
+		packetsSent: 0,
+		packetsReceived: 0,
+		rawStats: {}
+	};
+	return {
+		bytesSent: stats.dataChannel?.bytesSent,
+		bytesReceived: stats.dataChannel?.bytesReceived,
+		packetsSent: 0,
+		packetsReceived: 0,
+		rawStats: stats.raw
+	};
+};
+var getRtcConnectionStats = async (connection, channelTopic) => {
+	const stats = await connection.getStats();
+	const statsEntries = Array.from(stats.entries());
+	const transport = statsEntries.find(([_, entry]) => entry.type === "transport")?.[1];
+	const selectedCandidatePair = transport && statsEntries.find(([entryId]) => entryId === transport.selectedCandidatePairId)?.[1];
+	const remoteCandidate = selectedCandidatePair && statsEntries.find(([entryId]) => entryId === selectedCandidatePair.remoteCandidateId)?.[1];
+	return {
+		transport,
+		selectedCandidatePair,
+		dataChannel: channelTopic && statsEntries.find(([_, entry]) => entry.type === "data-channel" && entry.label === channelTopic)?.[1],
+		remoteCandidate,
+		raw: Object.fromEntries(stats)
+	};
+};
+//#endregion
+//#region src/transport/webrtc/rtc-transport-channel.ts
+var __dxlog_file$3 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/transport/webrtc/rtc-transport-channel.ts";
+var MAX_MESSAGE_SIZE = 64 * 1024;
+var MAX_BUFFERED_AMOUNT = 64 * 1024;
+/**
+* A WebRTC connection data channel.
+* Manages a WebRTC connection to a remote peer using an abstract signalling mechanism.
+*/
+var RtcTransportChannel = class extends Resource {
+	_connection;
+	_options;
+	closed = new Event();
+	connected = new Event();
+	errors = new ErrorStream();
+	_channel;
+	_stream;
+	_streamDataFlushedCallback = null;
+	_isChannelCreationInProgress = false;
+	constructor(_connection, _options) {
+		super();
+		this._connection = _connection;
+		this._options = _options;
+	}
+	get isRtcChannelCreationInProgress() {
+		return this._isChannelCreationInProgress;
+	}
+	onConnectionError(error) {
+		if (this.isOpen) this.errors.raise(error);
+	}
+	async _open() {
+		invariant(!this._isChannelCreationInProgress, void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$3,
+			L: 56,
+			S: this,
+			A: ["!this._isChannelCreationInProgress", ""]
+		});
+		this._isChannelCreationInProgress = true;
+		this._connection.createDataChannel(this._options.topic).then((channel) => {
+			if (this.isOpen) {
+				this._channel = channel;
+				this._initChannel(this._channel);
+			} else this._safeCloseChannel(channel);
+		}).catch((err) => {
+			if (this.isOpen) {
+				const error = err instanceof Error ? err : new ConnectivityError({ message: `Failed to create a channel: ${JSON.stringify(err?.message)}` });
+				this.errors.raise(error);
+			} else log.verbose("connection establishment failed after transport was closed", { err }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$3,
+				L: 76,
+				S: this
+			});
+		}).finally(() => {
+			this._isChannelCreationInProgress = false;
+		});
+	}
+	async _close() {
+		if (this._channel) {
+			this._safeCloseChannel(this._channel);
+			this._channel = void 0;
+			this._stream = void 0;
+		}
+		this.closed.emit();
+		log("closed", void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$3,
+			L: 92,
+			S: this
+		});
+	}
+	_initChannel(channel) {
+		Object.assign(channel, {
+			onopen: () => {
+				if (!this.isOpen) {
+					log.warn("channel opened in a closed transport", { topic: this._options.topic }, {
+						"~LogMeta": "~LogMeta",
+						F: __dxlog_file$3,
+						L: 99,
+						S: this
+					});
+					this._safeCloseChannel(channel);
+					return;
+				}
+				log("onopen", void 0, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$3,
+					L: 104,
+					S: this
+				});
+				const duplex = new Duplex({
+					read: () => {},
+					write: (chunk, encoding, callback) => {
+						return this._handleChannelWrite(chunk, callback);
+					}
+				});
+				duplex.pipe(this._options.stream).pipe(duplex);
+				this._stream = duplex;
+				this.connected.emit();
+			},
+			onclose: async () => {
+				log("onclose", void 0, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$3,
+					L: 117,
+					S: this
+				});
+				await this.close();
+			},
+			onmessage: async (event) => {
+				if (!this._stream) {
+					log.warn("ignoring message on a closed channel", void 0, {
+						"~LogMeta": "~LogMeta",
+						F: __dxlog_file$3,
+						L: 123,
+						S: this
+					});
+					return;
+				}
+				let data = event.data;
+				if (data instanceof ArrayBuffer) data = Buffer.from(data);
+				else if (data instanceof Blob) data = Buffer.from(await data.arrayBuffer());
+				this._stream.push(data);
+			},
+			onerror: (event) => {
+				if (this.isOpen) {
+					const err = event.error instanceof Error ? event.error : /* @__PURE__ */ new Error(`Datachannel error: ${event.type}.`);
+					this.errors.raise(err);
+				}
+			},
+			onbufferedamountlow: () => {
+				const cb = this._streamDataFlushedCallback;
+				this._streamDataFlushedCallback = null;
+				cb?.();
+			}
+		});
+	}
+	async _handleChannelWrite(chunk, callback) {
+		if (!this._channel) {
+			log.warn("writing to a channel after a connection was closed", void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$3,
+				L: 153,
+				S: this
+			});
+			return;
+		}
+		if (chunk.length > MAX_MESSAGE_SIZE) {
+			const error = /* @__PURE__ */ new Error(`Message too large: ${chunk.length} > ${MAX_MESSAGE_SIZE}.`);
+			this.errors.raise(error);
+			callback();
+			return;
+		}
+		try {
+			this._channel.send(chunk);
+		} catch (err) {
+			this.errors.raise(err);
+			callback();
+			return;
+		}
+		if (this._channel.bufferedAmount > MAX_BUFFERED_AMOUNT) {
+			if (this._streamDataFlushedCallback !== null) log.error("consumer trying to write before we are ready for more data", void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$3,
+				L: 174,
+				S: this
+			});
+			this._streamDataFlushedCallback = callback;
+		} else callback();
+	}
+	_safeCloseChannel(channel) {
+		try {
+			channel.close();
+		} catch (error) {
+			log.catch(error, void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$3,
+				L: 186,
+				S: this
+			});
+		}
+	}
+	onSignal(signal) {
+		return this._connection.onSignal(signal);
+	}
+	async getDetails() {
+		return describeSelectedRemoteCandidate(this._connection.currentConnection);
+	}
+	async getStats() {
+		return createRtcTransportStats(this._connection.currentConnection, this._options.topic);
+	}
+};
+//#endregion
+//#region src/transport/webrtc/utils.ts
+var chooseInitiatorPeer = (peer1Key, peer2Key) => peer1Key < peer2Key ? peer1Key : peer2Key;
+var areSdpEqual = (sdp1, sdp2) => {
+	const sdp1Lines = deduplicatedSdpLines(sdp1);
+	const sdp2Lines = deduplicatedSdpLines(sdp2);
+	if (sdp1Lines.length !== sdp2Lines.length) return false;
+	return sdp1Lines.every((line, idx) => line === sdp2Lines[idx]);
+};
+/**
+* For some reason libdatachannel duplicates some attributes after an sdp is set.
+* So the following test might fail:
+* conn.setRemoteDescription(sdp);
+* expect(conn.remoteDescription.sdp).toEqual(sdp);
+*/
+var deduplicatedSdpLines = (sdp) => {
+	const deduplicatedLines = [];
+	const seenLines = [];
+	for (const line of sdp.split("\r\n")) {
+		if (line.startsWith("m")) seenLines.length = 0;
+		if (seenLines.includes(line)) continue;
+		seenLines.push(line);
+		deduplicatedLines.push(line);
+	}
+	return deduplicatedLines;
+};
+//#endregion
+//#region src/transport/webrtc/rtc-peer-connection.ts
+var __dxlog_file$2 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/transport/webrtc/rtc-peer-connection.ts";
+/**
+* A factory for rtc Transport implementations for a particular peer.
+* Contains WebRTC connection establishment logic.
+* When the first Transport is opened a connection is established and kept until all the transports are closed.
+*/
+var RtcPeerConnection = class {
+	_factory;
+	_options;
+	_channelCreatedCallbacks = /* @__PURE__ */ new Map();
+	_transportChannels = /* @__PURE__ */ new Map();
+	_dataChannels = /* @__PURE__ */ new Map();
+	_readyForCandidates = new Trigger();
+	_offerProcessingMutex = new Mutex();
+	/**
+	* Can't use peer.connection.initiator, because if two connections to the same peer are created in
+	* different swarms, we might be the initiator of the first one, but not of the other one.
+	* Use a stable peer keypair property (key ordering) to decide who's acting as the initiator of
+	* transport connection establishment and data channel creation.
+	*/
+	_initiator;
+	_connection;
+	constructor(_factory, _options) {
+		this._factory = _factory;
+		this._options = _options;
+		this._initiator = chooseInitiatorPeer(_options.ownPeerKey, _options.remotePeerKey) === _options.ownPeerKey;
+	}
+	get transportChannelCount() {
+		return this._transportChannels.size;
+	}
+	get currentConnection() {
+		return this._connection;
+	}
+	async createDataChannel(topic) {
+		const connection = await this._openConnection();
+		if (!this._transportChannels.has(topic)) {
+			if (!this._transportChannels.size) this._lockAndCloseConnection();
+			throw new Error("Transport closed while connection was being open");
+		}
+		if (this._initiator) {
+			const channel = connection.createDataChannel(topic);
+			this._dataChannels.set(topic, channel);
+			return channel;
+		} else {
+			const existingChannel = this._dataChannels.get(topic);
+			if (existingChannel) return existingChannel;
+			log("waiting for initiator-peer to open a data channel", void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$2,
+				L: 93,
+				S: this
+			});
+			return new Promise((resolve, reject) => {
+				this._channelCreatedCallbacks.set(topic, {
+					resolve,
+					reject
+				});
+			});
+		}
+	}
+	createTransportChannel(options) {
+		const channel = new RtcTransportChannel(this, options);
+		this._transportChannels.set(options.topic, channel);
+		channel.closed.on(() => {
+			this._transportChannels.delete(options.topic);
+			if (this._transportChannels.size === 0) this._lockAndCloseConnection();
+		});
+		return channel;
+	}
+	async _openConnection() {
+		if (this._connection) return this._connection;
+		log("initializing connection...", () => ({ remotePeer: this._options.remotePeerKey }), {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$2,
+			L: 118,
+			S: this
+		});
+		const config = await this._loadConnectionConfig();
+		const connection = await this._factory.createConnection(config);
+		const iceCandidateErrors = [];
+		Object.assign(connection, {
+			onnegotiationneeded: async () => {
+				invariant(this._initiator, void 0, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$2,
+					L: 133,
+					S: this,
+					A: ["this._initiator", ""]
+				});
+				if (connection !== this._connection) {
+					this._onConnectionCallbackAfterClose("onnegotiationneeded", connection);
+					return;
+				}
+				log("onnegotiationneeded", void 0, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$2,
+					L: 140,
+					S: this
+				});
+				try {
+					const offer = await connection.createOffer();
+					await connection.setLocalDescription(offer);
+					await this._sendDescription(connection, offer);
+				} catch (err) {
+					this._lockAndAbort(connection, err);
+				}
+			},
+			onicecandidate: async (event) => {
+				if (connection !== this._connection) {
+					this._onConnectionCallbackAfterClose("onicecandidate", connection);
+					return;
+				}
+				if (event.candidate) {
+					log("onicecandidate", { candidate: event.candidate.candidate }, {
+						"~LogMeta": "~LogMeta",
+						F: __dxlog_file$2,
+						L: 159,
+						S: this
+					});
+					await this._sendIceCandidate(event.candidate);
+				} else log("onicecandidate gathering complete", void 0, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$2,
+					L: 162,
+					S: this
+				});
+			},
+			onicecandidateerror: (event) => {
+				const { url, errorCode, errorText } = event;
+				iceCandidateErrors.push({
+					url,
+					errorCode,
+					errorText
+				});
+			},
+			oniceconnectionstatechange: () => {
+				if (connection !== this._connection) {
+					this._onConnectionCallbackAfterClose("oniceconnectionstatechange", connection);
+					return;
+				}
+				log("oniceconnectionstatechange", { state: connection.iceConnectionState }, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$2,
+					L: 182,
+					S: this
+				});
+				if (connection.iceConnectionState === "failed") this._lockAndAbort(connection, createIceFailureError(iceCandidateErrors));
+			},
+			onconnectionstatechange: () => {
+				if (connection !== this._connection) {
+					if (connection.connectionState !== "closed" && connection.connectionState !== "failed") this._onConnectionCallbackAfterClose("onconnectionstatechange", connection);
+					return;
+				}
+				log("onconnectionstatechange", { state: connection.connectionState }, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$2,
+					L: 199,
+					S: this
+				});
+				if (connection.connectionState === "failed") this._lockAndAbort(connection, /* @__PURE__ */ new Error("Connection failed."));
+			},
+			onsignalingstatechange: () => {
+				log("onsignalingstatechange", { state: connection.signalingState }, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$2,
+					L: 206,
+					S: this
+				});
+			},
+			ondatachannel: (event) => {
+				invariant(!this._initiator, "Initiator is expected to create data channels.", {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$2,
+					L: 212,
+					S: this,
+					A: ["!this._initiator", "'Initiator is expected to create data channels.'"]
+				});
+				if (connection !== this._connection) {
+					this._onConnectionCallbackAfterClose("ondatachannel", connection);
+					return;
+				}
+				log("ondatachannel", { label: event.channel.label }, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$2,
+					L: 219,
+					S: this
+				});
+				this._dataChannels.set(event.channel.label, event.channel);
+				const pendingCallback = this._channelCreatedCallbacks.get(event.channel.label);
+				if (pendingCallback) {
+					this._channelCreatedCallbacks.delete(event.channel.label);
+					pendingCallback.resolve(event.channel);
+				}
+			}
+		});
+		this._connection = connection;
+		this._readyForCandidates.reset();
+		await this._factory.initConnection(connection, { initiator: this._initiator });
+		return this._connection;
+	}
+	async _lockAndAbort(connection, error) {
+		this._abortConnection(connection, error);
+	}
+	_abortConnection(connection, error) {
+		if (connection !== this._connection) {
+			log.error("attempted to abort an inactive connection", { error }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$2,
+				L: 244,
+				S: this
+			});
+			this._safeCloseConnection(connection);
+			return;
+		}
+		for (const [topic, pendingCallback] of this._channelCreatedCallbacks.entries()) {
+			pendingCallback.reject(error);
+			this._transportChannels.delete(topic);
+		}
+		this._channelCreatedCallbacks.clear();
+		for (const channel of this._transportChannels.values()) channel.onConnectionError(error);
+		this._transportChannels.clear();
+		this._safeCloseConnection();
+		log("connection aborted", { reason: error.message }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$2,
+			L: 258,
+			S: this
+		});
+	}
+	async _lockAndCloseConnection() {
+		invariant(this._transportChannels.size === 0, void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$2,
+			L: 263,
+			S: this,
+			A: ["this._transportChannels.size === 0", ""]
+		});
+		if (this._connection) {
+			this._safeCloseConnection();
+			log("connection closed", void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$2,
+				L: 266,
+				S: this
+			});
+		}
+	}
+	async onSignal(signal) {
+		const connection = this._connection;
+		if (!connection) {
+			log.warn("a signal ignored because the connection was closed", { type: signal.payload.data.type }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$2,
+				L: 274,
+				S: this
+			});
+			return;
+		}
+		const data = signal.payload.data;
+		switch (data.type) {
+			case "offer":
+				await this._offerProcessingMutex.executeSynchronized(async () => {
+					if (isRemoteDescriptionSet(connection, data)) return;
+					if (connection.connectionState !== "new") {
+						this._abortConnection(connection, /* @__PURE__ */ new Error(`Received an offer in ${connection.connectionState}.`));
+						return;
+					}
+					try {
+						await connection.setRemoteDescription({
+							type: data.type,
+							sdp: data.sdp
+						});
+						const answer = await connection.createAnswer();
+						await connection.setLocalDescription(answer);
+						await this._sendDescription(connection, answer);
+						this._onSessionNegotiated(connection);
+					} catch (err) {
+						this._abortConnection(connection, new Error("Error handling a remote offer.", { cause: err }));
+					}
+				});
+				break;
+			case "answer":
+				await this._offerProcessingMutex.executeSynchronized(async () => {
+					try {
+						if (isRemoteDescriptionSet(connection, data)) return;
+						if (connection.signalingState !== "have-local-offer") {
+							this._abortConnection(connection, /* @__PURE__ */ new Error(`Unexpected answer from remote peer, signalingState was ${connection.signalingState}.`));
+							return;
+						}
+						await connection.setRemoteDescription({
+							type: data.type,
+							sdp: data.sdp
+						});
+						this._onSessionNegotiated(connection);
+					} catch (err) {
+						this._abortConnection(connection, new Error("Error handling a remote answer.", { cause: err }));
+					}
+				});
+				break;
+			case "candidate":
+				this._processIceCandidate(connection, data.candidate);
+				break;
+			default:
+				this._abortConnection(connection, /* @__PURE__ */ new Error(`Unknown signal type ${data.type}.`));
+				break;
+		}
+		log("signal processed", { type: data.type }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$2,
+			L: 333,
+			S: this
+		});
+	}
+	async _processIceCandidate(connection, candidate) {
+		try {
+			await this._readyForCandidates.wait();
+			if (connection === this._connection) {
+				log("adding ice candidate", { candidate }, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$2,
+					L: 341,
+					S: this
+				});
+				await connection.addIceCandidate(candidate);
+			}
+		} catch (err) {
+			log.catch(err, void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$2,
+				L: 345,
+				S: this
+			});
+		}
+	}
+	_onSessionNegotiated(connection) {
+		if (connection === this._connection) {
+			log("ready to process ice candidates", void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$2,
+				L: 351,
+				S: this
+			});
+			this._readyForCandidates.wake();
+		} else log.warn("session was negotiated after connection became inactive", void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$2,
+			L: 354,
+			S: this
+		});
+	}
+	_onConnectionCallbackAfterClose(callback, connection) {
+		log.warn("callback invoked after a connection was destroyed, this is probably a bug", {
+			callback,
+			state: connection.connectionState
+		}, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$2,
+			L: 359,
+			S: this
+		});
+		this._safeCloseConnection(connection);
+	}
+	_safeCloseConnection(connection = this._connection) {
+		const resetFields = this._connection && connection === this._connection;
+		try {
+			connection?.close();
+		} catch (err) {
+			log.catch(err, void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$2,
+				L: 371,
+				S: this
+			});
+		}
+		if (resetFields) {
+			this._connection = void 0;
+			this._dataChannels.clear();
+			this._readyForCandidates.wake();
+			this._factory.onConnectionDestroyed().catch((err) => log.catch(err, void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$2,
+				L: 377,
+				S: this
+			}));
+			for (const [_, pendingCallback] of this._channelCreatedCallbacks.entries()) pendingCallback.reject("Connection closed.");
+			this._channelCreatedCallbacks.clear();
+		}
+	}
+	async _loadConnectionConfig() {
+		const config = { ...this._options.webrtcConfig };
+		try {
+			const providedIceServers = await this._options.iceProvider?.getIceServers() ?? [];
+			if (providedIceServers.length > 0) config.iceServers = [...config.iceServers ?? [], ...providedIceServers];
+		} catch (error) {
+			log.catch(error, void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$2,
+				L: 393,
+				S: this
+			});
+		}
+		return config;
+	}
+	async _sendIceCandidate(candidate) {
+		try {
+			await this._options.sendSignal({ payload: { data: {
+				type: "candidate",
+				candidate: {
+					candidate: candidate.candidate,
+					sdpMLineIndex: candidate.sdpMLineIndex ?? "0",
+					sdpMid: candidate.sdpMid ?? "0"
+				}
+			} } });
+		} catch (err) {
+			log.warn("signaling error", { err }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$2,
+				L: 414,
+				S: this
+			});
+		}
+	}
+	async _sendDescription(connection, description) {
+		if (connection !== this._connection) return;
+		const data = {
+			type: description.type,
+			sdp: description.sdp
+		};
+		await this._options.sendSignal({ payload: { data } });
+	}
+	get _connectionInfo() {
+		return {
+			...this._connection && {
+				connectionState: this._connection.connectionState,
+				iceConnectionState: this._connection.iceConnectionState,
+				iceGatheringState: this._connection.iceGatheringState,
+				signalingState: this._connection.signalingState,
+				remoteDescription: this._connection.remoteDescription,
+				localDescription: this._connection.localDescription
+			},
+			ts: Date.now(),
+			remotePeerKey: this._options.remotePeerKey,
+			channels: [...this._transportChannels.keys()].map((topic) => topic),
+			config: this._connection?.getConfiguration()
+		};
+	}
+	get _loggerContext() {
+		return {
+			ownPeerKey: this._options.ownPeerKey,
+			remotePeerKey: this._options.remotePeerKey,
+			initiator: this._initiator,
+			channels: this._transportChannels.size
+		};
+	}
+};
+__decorate([synchronized], RtcPeerConnection.prototype, "_openConnection", null);
+__decorate([synchronized], RtcPeerConnection.prototype, "_lockAndAbort", null);
+__decorate([synchronized], RtcPeerConnection.prototype, "_lockAndCloseConnection", null);
+__decorate([synchronized], RtcPeerConnection.prototype, "onSignal", null);
+__decorate([logInfo], RtcPeerConnection.prototype, "_loggerContext", null);
+var isRemoteDescriptionSet = (connection, data) => {
+	if (!connection.remoteDescription?.type || connection.remoteDescription?.type !== data.type) return false;
+	return areSdpEqual(connection.remoteDescription.sdp, data.sdp);
+};
+var createIceFailureError = (details) => {
+	return new ConnectivityError({ message: `ICE failed:\n${details.map(({ url, errorCode, errorText }) => `${errorCode} ${url}: ${errorText}`).join("\n")}` });
+};
+//#endregion
+//#region src/transport/webrtc/rtc-transport-factory.ts
+var createRtcTransportFactory = (webrtcConfig, iceProvider) => {
+	const connectionFactory = getRtcConnectionFactory();
+	return { createTransport: (options) => {
+		return new RtcPeerConnection(connectionFactory, {
+			ownPeerKey: options.ownPeerKey,
+			remotePeerKey: options.remotePeerKey,
+			sendSignal: options.sendSignal,
+			legacyInitiator: options.initiator,
+			webrtcConfig,
+			iceProvider
+		}).createTransportChannel(options);
+	} };
+};
+//#endregion
+//#region src/transport/webrtc/rtc-transport-proxy.ts
+var __dxlog_file$1 = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/transport/webrtc/rtc-transport-proxy.ts";
+var RPC_TIMEOUT = 1e4;
+var CLOSE_RPC_TIMEOUT = 3e3;
+var RESP_MIN_THRESHOLD = 500;
+var RtcTransportProxy = class extends Resource {
+	_options;
+	_proxyId = PublicKey.random();
+	closed = new Event();
+	connected = new Event();
+	errors = new ErrorStream();
+	_serviceStream;
+	constructor(_options) {
+		super();
+		this._options = _options;
+	}
+	async _open() {
+		let stream;
+		try {
+			stream = this._options.bridgeService.open({
+				proxyId: this._proxyId,
+				remotePeerKey: this._options.remotePeerKey,
+				ownPeerKey: this._options.ownPeerKey,
+				topic: this._options.topic,
+				initiator: this._options.initiator ?? false
+			}, { timeout: RPC_TIMEOUT });
+		} catch (error) {
+			this.errors.raise(error);
+			return;
+		}
+		this._serviceStream = stream;
+		stream.waitUntilReady().then(() => {
+			stream.subscribe(async (event) => {
+				log("rtc transport proxy event", event, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$1,
+					L: 66,
+					S: this
+				});
+				if (event.connection) await this._handleConnection(event.connection);
+				else if (event.data) this._handleData(event.data);
+				else if (event.signal) await this._handleSignal(event.signal);
+			}, (err) => {
+				log("rtc bridge stream closed", { err }, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$1,
+					L: 76,
+					S: this
+				});
+				if (err) this._raiseIfOpen(err);
+				else this.close();
+			});
+			const connectorStream = new Writable({ write: (chunk, _, callback) => {
+				const sendStartMs = Date.now();
+				this._options.bridgeService.sendData({
+					proxyId: this._proxyId,
+					payload: chunk
+				}, { timeout: RPC_TIMEOUT }).then(() => {
+					if (Date.now() - sendStartMs > RESP_MIN_THRESHOLD) {
+						log("slow response, delaying callback", void 0, {
+							"~LogMeta": "~LogMeta",
+							F: __dxlog_file$1,
+							L: 93,
+							S: this
+						});
+						scheduleTask(this._ctx, () => callback(), RESP_MIN_THRESHOLD);
+					} else callback();
+				}, (err) => {
+					callback();
+					this._raiseIfOpen(err);
+				});
+			} });
+			connectorStream.on("error", (err) => {
+				this._raiseIfOpen(err);
+			});
+			this._options.stream.pipe(connectorStream);
+		}, (error) => {
+			if (error) this._raiseIfOpen(error);
+			else this.close();
+		});
+	}
+	async _close() {
+		try {
+			await this._serviceStream?.close();
+			this._serviceStream = void 0;
+		} catch (err) {
+			log.catch(err, void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 128,
+				S: this
+			});
+		}
+		try {
+			await this._options.bridgeService.close({ proxyId: this._proxyId }, { timeout: CLOSE_RPC_TIMEOUT });
+		} catch (err) {
+			log.catch(err, void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 134,
+				S: this
+			});
+		}
+		this.closed.emit();
+	}
+	async onSignal(signal) {
+		this._options.bridgeService.sendSignal({
+			proxyId: this._proxyId,
+			signal
+		}, { timeout: RPC_TIMEOUT }).catch((err) => this._raiseIfOpen(decodeError(err)));
+	}
+	async _handleConnection(connectionEvent) {
+		if (connectionEvent.error) {
+			this.errors.raise(decodeError(connectionEvent.error));
+			return;
+		}
+		switch (connectionEvent.state) {
+			case ConnectionState$1.CONNECTED:
+				this.connected.emit();
+				break;
+			case ConnectionState$1.CLOSED:
+				await this.close();
+				break;
+		}
+	}
+	_handleData(dataEvent) {
+		try {
+			this._options.stream.write(arrayToBuffer(dataEvent.payload));
+		} catch (error) {
+			this._raiseIfOpen(error);
+		}
+	}
+	async _handleSignal(signalEvent) {
+		try {
+			await this._options.sendSignal(signalEvent.payload);
+		} catch (error) {
+			const type = signalEvent.payload.payload.data?.type;
+			if (type === "offer" || type === "answer") this._raiseIfOpen(new ConnectivityError({ message: `Session establishment failed: ${type} couldn't be sent.` }));
+		}
+	}
+	async getDetails() {
+		try {
+			return (await this._options.bridgeService.getDetails({ proxyId: this._proxyId }, { timeout: RPC_TIMEOUT })).details;
+		} catch (err) {
+			return "bridge-svc unreachable";
+		}
+	}
+	async getStats() {
+		try {
+			return (await this._options.bridgeService.getStats({ proxyId: this._proxyId }, { timeout: RPC_TIMEOUT })).stats;
+		} catch (err) {
+			return {
+				bytesSent: 0,
+				bytesReceived: 0,
+				packetsSent: 0,
+				packetsReceived: 0,
+				rawStats: "bridge-svc unreachable"
+			};
+		}
+	}
+	_raiseIfOpen(error) {
+		if (this.isOpen) this.errors.raise(error);
+		else log.info("error swallowed because transport was closed", { message: error.message }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$1,
+			L: 217,
+			S: this
+		});
+	}
+	/**
+	* Called when underlying proxy service becomes unavailable.
+	*/
+	forceClose() {
+		this._serviceStream?.close();
+		this.closed.emit();
+	}
+};
+var RtcTransportProxyFactory = class {
+	_bridgeService;
+	_connections = /* @__PURE__ */ new Set();
+	/**
+	* Sets the current BridgeService to be used to open connections.
+	* Calling this method will close any existing connections.
+	*/
+	setBridgeService(bridgeService) {
+		this._bridgeService = bridgeService;
+		for (const connection of this._connections) connection.forceClose();
+		return this;
+	}
+	createTransport(options) {
+		invariant(this._bridgeService, "RtcTransportProxyFactory is not ready to open connections", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$1,
+			L: 247,
+			S: this,
+			A: ["this._bridgeService", "'RtcTransportProxyFactory is not ready to open connections'"]
+		});
+		const transport = new RtcTransportProxy({
+			...options,
+			bridgeService: this._bridgeService
+		});
+		this._connections.add(transport);
+		transport.closed.on(() => {
+			this._connections.delete(transport);
+		});
+		return transport;
+	}
+};
+var decodeError = (err) => {
+	const message = typeof err === "string" ? err : err.message;
+	if (message.includes("CONNECTION_RESET")) return new ConnectionResetError({ message });
+	else if (message.includes("TIMEOUT")) return new TimeoutError({ message });
+	else if (message.includes("CONNECTIVITY_ERROR")) return new ConnectivityError({ message });
+	else return typeof err === "string" ? new Error(err) : err;
+};
+//#endregion
+//#region src/transport/webrtc/rtc-transport-service.ts
+var __dxlog_file = "/__w/dxos/dxos/packages/core/mesh/network-manager/src/transport/webrtc/rtc-transport-service.ts";
+var RtcTransportService = class {
+	_transportFactory;
+	_openTransports = new ComplexMap(PublicKey.hash);
+	constructor(webrtcConfig, iceProvider, _transportFactory = createRtcTransportFactory(webrtcConfig, iceProvider)) {
+		this._transportFactory = _transportFactory;
+	}
+	hasOpenTransports() {
+		return this._openTransports.size > 0;
+	}
+	open(request) {
+		const existingTransport = this._openTransports.get(request.proxyId);
+		if (existingTransport) {
+			log.error("requesting a new transport bridge for an existing proxy", void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 53,
+				S: this
+			});
+			this._safeCloseTransport(existingTransport);
+			this._openTransports.delete(request.proxyId);
+		}
+		return new Stream(({ ready, next, close }) => {
+			const pushNewState = createStateUpdater(next);
+			const transportStream = new Duplex({
+				read: () => {
+					const callbacks = [...transportState.writeProcessedCallbacks];
+					transportState.writeProcessedCallbacks.length = 0;
+					callbacks.forEach((cb) => cb());
+				},
+				write: function(chunk, _, callback) {
+					next({ data: { payload: chunk } });
+					callback();
+				}
+			});
+			const transport = this._transportFactory.createTransport({
+				initiator: request.initiator,
+				topic: request.topic,
+				ownPeerKey: request.ownPeerKey,
+				remotePeerKey: request.remotePeerKey,
+				stream: transportStream,
+				sendSignal: async (signal) => {
+					next({ signal: { payload: signal } });
+				}
+			});
+			const transportState = {
+				proxyId: request.proxyId,
+				transport,
+				connectorStream: transportStream,
+				writeProcessedCallbacks: []
+			};
+			transport.connected.on(() => pushNewState(ConnectionState$1.CONNECTED));
+			transport.errors.handle(async (err) => {
+				pushNewState(ConnectionState$1.CLOSED, err);
+				this._safeCloseTransport(transportState);
+				close(err);
+			});
+			transport.closed.on(async () => {
+				pushNewState(ConnectionState$1.CLOSED);
+				this._safeCloseTransport(transportState);
+				close();
+			});
+			this._openTransports.set(request.proxyId, transportState);
+			transport.open().catch(async (err) => {
+				pushNewState(ConnectionState$1.CLOSED, err);
+				this._safeCloseTransport(transportState);
+				close(err);
+			});
+			ready();
+			log("stream ready", void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 115,
+				S: this
+			});
+			pushNewState(ConnectionState$1.CONNECTING);
+		});
+	}
+	async sendSignal({ proxyId, signal }) {
+		const transport = this._openTransports.get(proxyId);
+		invariant(transport, void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 123,
+			S: this,
+			A: ["transport", ""]
+		});
+		await transport.transport.onSignal(signal);
+	}
+	async getDetails({ proxyId }) {
+		const transport = this._openTransports.get(proxyId);
+		invariant(transport, void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 130,
+			S: this,
+			A: ["transport", ""]
+		});
+		return { details: await transport.transport.getDetails() };
+	}
+	async getStats({ proxyId }) {
+		const transport = this._openTransports.get(proxyId);
+		invariant(transport, void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 137,
+			S: this,
+			A: ["transport", ""]
+		});
+		return { stats: await transport.transport.getStats() };
+	}
+	async sendData({ proxyId, payload }) {
+		const transport = this._openTransports.get(proxyId);
+		invariant(transport, void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 144,
+			S: this,
+			A: ["transport", ""]
+		});
+		if (!transport.connectorStream.push(payload)) await new Promise((resolve) => {
+			transport.writeProcessedCallbacks.push(resolve);
+		});
+	}
+	async close({ proxyId }) {
+		const transport = this._openTransports.get(proxyId);
+		if (!transport) return;
+		this._openTransports.delete(proxyId);
+		await this._safeCloseTransport(transport);
+	}
+	async _safeCloseTransport(transport) {
+		if (this._openTransports.get(transport.proxyId) === transport) this._openTransports.delete(transport.proxyId);
+		transport.writeProcessedCallbacks.forEach((cb) => cb());
+		try {
+			await transport.transport.close();
+		} catch (error) {
+			log.warn("transport close error", { message: error?.message }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 174,
+				S: this
+			});
+		}
+		try {
+			transport.connectorStream.end();
+		} catch (error) {
+			log.warn("connectorStream close error", { message: error?.message }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 179,
+				S: this
+			});
+		}
+		log("closed", void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 181,
+			S: this
+		});
+	}
+};
+var createStateUpdater = (next) => {
+	return (state, err) => {
+		next({ connection: {
+			state,
+			...err ? { error: err.message } : void 0
+		} });
+	};
+};
+//#endregion
+//#region src/wire-protocol.ts
+/**
+* Create a wire-protocol provider backed by a teleport instance.
+* @param onConnection Called after teleport is initialized for the session. Protocol extensions could be attached here.
+* @param defaultProps Optionally provide default Teleport params that might be overridden by factory callers.
+* @returns
+*/
+var createTeleportProtocolFactory = (onConnection, defaultProps) => {
+	return (params) => {
+		const teleport = new Teleport({
+			...defaultProps,
+			...params
+		});
+		return {
+			stream: teleport.stream,
+			open: async (sessionId) => {
+				await teleport.open(sessionId);
+				await onConnection(teleport);
+			},
+			close: async () => {
+				await teleport.close();
+			},
+			abort: async () => {
+				await teleport.abort();
+			}
+		};
+	};
+};
+//#endregion
+export { Swarm as _, createRtcTransportFactory as a, ConnectionState$2 as b, MemoryTransportFactory as c, SwarmNetworkManagerService as d, ConnectionLog as f, SwarmMapper as g, MAX_CONCURRENT_INITIATING_CONNECTIONS as h, RtcTransportProxyFactory as i, FullyConnectedTopology as l, ConnectionLimiter as m, RtcTransportService as n, TransportKind as o, EventType as p, RtcTransportProxy as r, MemoryTransport as s, createTeleportProtocolFactory as t, SwarmNetworkManager as u, SwarmMessenger as v, Connection as y };
+
+//# sourceMappingURL=chunk-wire-protocol.mjs.map