lemon-model 1.1.0 → 1.2.0

package/dist/socket/socket.js

@@ -0,0 +1,844 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSocketFactory = exports.SocketFactory = exports.createPeer = exports.Peer = exports.createNetwork = exports.Network = exports.noopSocketLogger = exports.defaultPeerNetworkFactory = exports.nextMessageId = exports.defaultPeerIdentityProvider = void 0;
+const transport_1 = require("./transport");
+let peerNo = 0;
+let clientNo = 0;
+let messageNo = 0;
+let networkNo = 0;
+exports.defaultPeerIdentityProvider = {
+    nextPeerId: () => `peer-${++peerNo}`,
+    nextClientId: () => `client-${++clientNo}`,
+    nextMessageId: () => `message-${++messageNo}`,
+    nextNetworkId: (fromPeerId, toPeerId) => fromPeerId && toPeerId ? `${fromPeerId}->${toPeerId}` : `network-${++networkNo}`,
+};
+const nextMessageId = () => exports.defaultPeerIdentityProvider.nextMessageId();
+exports.nextMessageId = nextMessageId;
+const defaultPeerNetworkFactory = context => (0, exports.createNetwork)(Object.assign({ id: context.id, fromPeerId: context.fromPeerId, toPeerId: context.toPeerId, logger: context.logger }, context.options));
+exports.defaultPeerNetworkFactory = defaultPeerNetworkFactory;
+exports.noopSocketLogger = { log: () => undefined };
+const delay = (ms) => (ms > 0 ? new Promise(resolve => setTimeout(resolve, ms)) : undefined);
+const DEFAULT_MAX_PACKET_BYTES = 64 * 1024;
+const DEFAULT_JITTER_MS = 1;
+/**
+ * one-shot in-memory network transport.
+ * - public transport surface is intentionally limited to send(string) and close().
+ */
+class Network {
+    constructor(options) {
+        var _a, _b;
+        this.state = 'open';
+        this.messageListeners = new Set();
+        this.used = false;
+        this.deliveryNo = 0;
+        this.errorListeners = new Set();
+        this.id = (_a = options === null || options === void 0 ? void 0 : options.id) !== null && _a !== void 0 ? _a : exports.defaultPeerIdentityProvider.nextNetworkId();
+        this.fromPeerId = options === null || options === void 0 ? void 0 : options.fromPeerId;
+        this.toPeerId = options === null || options === void 0 ? void 0 : options.toPeerId;
+        this.logger = (_b = options === null || options === void 0 ? void 0 : options.logger) !== null && _b !== void 0 ? _b : exports.noopSocketLogger;
+        this.options = asNetworkOptions(options);
+        this.log('debug', 'network created', 'network.constructor', { data: { options: this.options } });
+    }
+    /** network state */
+    get readyState() {
+        return this.state;
+    }
+    /** wait until this in-memory network is ready */
+    ready() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.ensureOpen('network.ready');
+            this.log('debug', 'network ready', 'network.ready');
+        });
+    }
+    /** attach this network to exactly one receiver */
+    attach(receiver) {
+        if (this.used)
+            throw new Error(`@network[${this.id}] is already used - network.attach(${this.id})`);
+        this.ensureOpen('network.attach');
+        this.used = true;
+        this.messageListeners.add(receiver);
+        this.log('debug', 'network receiver attached', 'network.attach');
+    }
+    /** send raw string data over the network */
+    send(data) {
+        this.ensureOpen('network.send');
+        if (this.messageListeners.size <= 0) {
+            throw new Error(`@network[${this.id}] is not connected - network.send(${this.id})`);
+        }
+        if (typeof data !== 'string')
+            throw new Error(`@data (string) is required - network.send(${this.id})`);
+        const bytes = byteLength(data);
+        if (bytes > this.options.maxPacketBytes)
+            throw new Error(`1009: message too big`);
+        const listeners = [...this.messageListeners];
+        this.log('debug', 'network packet queued', 'network.send', {
+            data: { bytes, listeners: listeners.length },
+        });
+        const _deliver = () => __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield delay(this.nextDeliveryDelayMs());
+                if (this.state !== 'open')
+                    return;
+                for (const listener of listeners)
+                    listener(data);
+                this.log('debug', 'network packet delivered', 'network.deliver', {
+                    data: { bytes, listeners: listeners.length },
+                });
+            }
+            catch (e) {
+                this.log('error', 'network delivery failed', 'network.deliver', { error: e });
+                this.emitError(e, { scope: 'network.deliver', network: this });
+            }
+        });
+        _deliver();
+    }
+    /** subscribe to raw string data delivered from the network */
+    onMessage(handler) {
+        this.ensureOpen('network.onMessage');
+        this.messageListeners.add(handler);
+        this.log('debug', 'network message listener added', 'network.onMessage', {
+            data: { listeners: this.messageListeners.size },
+        });
+        return () => {
+            this.messageListeners.delete(handler);
+            this.log('debug', 'network message listener removed', 'network.onMessage.unsubscribe', {
+                data: { listeners: this.messageListeners.size },
+            });
+        };
+    }
+    /** update network conditions */
+    configure(options) {
+        this.options = Object.assign(Object.assign({}, this.options), options);
+        this.log('info', 'network configured', 'network.configure', { data: { options: this.options } });
+    }
+    /** observe asynchronous network delivery errors */
+    onError(handler) {
+        this.errorListeners.add(handler);
+        return () => {
+            this.errorListeners.delete(handler);
+        };
+    }
+    /** close this network forever */
+    close() {
+        if (this.state === 'closed')
+            return;
+        this.state = 'closed';
+        this.messageListeners.clear();
+        this.log('info', 'network closed', 'network.close');
+    }
+    ensureOpen(scope) {
+        if (this.state !== 'open')
+            throw new Error(`@network[${this.id}] connection error: ${this.state} - ${scope}`);
+    }
+    nextDeliveryDelayMs() {
+        const baseMs = this.options.latencyMs;
+        if (!this.options.unordered)
+            return baseMs;
+        const jitterMs = this.deliveryNo++ % 2 === 0 ? this.options.jitterMs : 0;
+        return baseMs + jitterMs;
+    }
+    emitError(error, context) {
+        for (const listener of [...this.errorListeners]) {
+            listener(error, context);
+        }
+    }
+    log(level, message, location, entry) {
+        try {
+            this.logger.log(Object.assign(Object.assign({ time: Date.now(), level,
+                message,
+                location, networkId: this.id, peerId: this.fromPeerId, remotePeerId: this.toPeerId }, entry), { error: (entry === null || entry === void 0 ? void 0 : entry.error) == null ? undefined : normalizeError(entry.error) }));
+        }
+        catch (_a) {
+            // Logging must never break simulated network behavior.
+        }
+    }
+}
+exports.Network = Network;
+/** create a one-shot network */
+const createNetwork = (options) => new Network(options);
+exports.createNetwork = createNetwork;
+/**
+ * in-memory peer that can act as a server, a client, or both.
+ */
+class Peer {
+    constructor(options) {
+        var _a, _b, _c, _d;
+        this.state = 'open';
+        this.clients = new Map();
+        this.listeners = new Set();
+        this.errorListeners = new Set();
+        this.pending = new Map();
+        this.identityProvider = (_a = options === null || options === void 0 ? void 0 : options.identityProvider) !== null && _a !== void 0 ? _a : exports.defaultPeerIdentityProvider;
+        this.networkFactory = (_b = options === null || options === void 0 ? void 0 : options.networkFactory) !== null && _b !== void 0 ? _b : exports.defaultPeerNetworkFactory;
+        this.logger = (_c = options === null || options === void 0 ? void 0 : options.logger) !== null && _c !== void 0 ? _c : exports.noopSocketLogger;
+        this.id = (_d = options === null || options === void 0 ? void 0 : options.id) !== null && _d !== void 0 ? _d : this.identityProvider.nextPeerId();
+        this.networkOptions = asNetworkOptions(options);
+        this.jsonTransportOptions = asJSONTransportOptions(options === null || options === void 0 ? void 0 : options.jsonTransport, this.networkOptions.maxPacketBytes);
+        this.log('debug', 'peer created', 'peer.constructor');
+    }
+    /** assigned client id when this peer is connected to another peer */
+    get clientId() {
+        return this.assignedClientId;
+    }
+    /** endpoint state */
+    get readyState() {
+        return this.state;
+    }
+    /** upstream network when this peer is connected as a client */
+    get network() {
+        var _a;
+        return (_a = this.server) === null || _a === void 0 ? void 0 : _a.network;
+    }
+    /** wait until this peer's upstream network is ready */
+    ready() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            this.ensureOpen('peer.ready');
+            const network = (_a = this.server) === null || _a === void 0 ? void 0 : _a.network;
+            if (!(network === null || network === void 0 ? void 0 : network.ready)) {
+                this.log('debug', 'peer ready without upstream network wait', 'peer.ready', {
+                    networkId: getNetworkId(network),
+                });
+                return;
+            }
+            this.log('debug', 'waiting for upstream network ready', 'peer.ready.wait', {
+                networkId: getNetworkId(network),
+            });
+            try {
+                yield network.ready();
+                this.log('debug', 'upstream network ready', 'peer.ready.ok', {
+                    networkId: getNetworkId(network),
+                });
+            }
+            catch (e) {
+                this.log('error', 'upstream network ready failed', 'peer.ready.error', {
+                    networkId: getNetworkId(network),
+                    error: e,
+                });
+                throw e;
+            }
+        });
+    }
+    /** update network conditions for this peer and connected networks */
+    configureNetwork(options) {
+        var _a, _b, _c, _d, _e;
+        this.networkOptions = Object.assign(Object.assign({}, this.networkOptions), options);
+        (_c = (_a = this.server) === null || _a === void 0 ? void 0 : (_b = _a.network).configure) === null || _c === void 0 ? void 0 : _c.call(_b, this.networkOptions);
+        for (const link of this.clients.values()) {
+            (_e = (_d = link.network).configure) === null || _e === void 0 ? void 0 : _e.call(_d, this.networkOptions);
+        }
+        this.log('info', 'network options configured', 'peer.configureNetwork', {
+            data: { options: this.networkOptions },
+        });
+    }
+    /** connect this peer as a client to a server peer */
+    connect(peer) {
+        this.ensureOpen('peer.connect');
+        const server = peer;
+        server.ensureOpen('peer.accept');
+        this.log('info', 'connecting peer', 'peer.connect', { remotePeerId: server.id });
+        const { uplink, downlink } = Peer.createNetworkPair(this, server, 'peer.connect');
+        const serverTransportOptions = server.jsonTransportOptions;
+        const clientTransportOptions = this.jsonTransportOptions;
+        const clientId = server.accept(this, downlink, serverTransportOptions);
+        server.attachClientReceiverTransport(clientId, Peer.attachReceiver(uplink, server, this, clientId, clientTransportOptions));
+        const serverReceiverTransport = Peer.attachReceiver(downlink, this, server, undefined, serverTransportOptions);
+        this.server = {
+            peer: server,
+            clientId,
+            network: uplink,
+            transportOptions: clientTransportOptions,
+            receiverTransport: serverReceiverTransport,
+        };
+        this.assignedClientId = clientId;
+        this.log('info', 'peer connected', 'peer.connect', {
+            remotePeerId: server.id,
+            clientId,
+            networkId: getNetworkId(uplink),
+        });
+        server.log('info', 'client accepted', 'peer.accept', {
+            remotePeerId: this.id,
+            clientId,
+            networkId: getNetworkId(downlink),
+        });
+        return clientId;
+    }
+    /** replace connected network instances while keeping the peer relationship */
+    reconnect(options) {
+        var _a;
+        this.ensureOpen('peer.reconnect');
+        if (options === null || options === void 0 ? void 0 : options.clientId) {
+            const link = this.clients.get(options.clientId);
+            if (!link)
+                throw new Error(`@clientId[${options.clientId}] is not connected - peer.reconnect(${this.id})`);
+            Peer.reconnectPair(link.peer, this, options.clientId);
+            this.log('info', 'peer network reconnected', 'peer.reconnect', {
+                remotePeerId: link.peer.id,
+                clientId: options.clientId,
+            });
+            return options.clientId;
+        }
+        if ((_a = this.server) === null || _a === void 0 ? void 0 : _a.clientId) {
+            Peer.reconnectPair(this, this.server.peer, this.server.clientId);
+            this.log('info', 'peer network reconnected', 'peer.reconnect', {
+                remotePeerId: this.server.peer.id,
+                clientId: this.server.clientId,
+            });
+            return this.server.clientId;
+        }
+        if (this.clients.size === 1) {
+            const [clientId, link] = [...this.clients.entries()][0];
+            Peer.reconnectPair(link.peer, this, clientId);
+            this.log('info', 'peer network reconnected', 'peer.reconnect', {
+                remotePeerId: link.peer.id,
+                clientId,
+            });
+            return clientId;
+        }
+        if (this.clients.size > 1)
+            throw new Error(`@clientId (string) is required - peer.reconnect(${this.id})`);
+        throw new Error(`@peer is not connected - peer.reconnect(${this.id})`);
+    }
+    /** find a client peer connected to this peer by client id */
+    findPeer(clientId) {
+        var _a;
+        return (_a = this.clients.get(clientId)) === null || _a === void 0 ? void 0 : _a.peer;
+    }
+    /** post a typed message without waiting for a result */
+    post(message, options) {
+        this.publish(message, options);
+    }
+    /** send a typed message and wait for a result message with the same mid */
+    send(message, options) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const mid = (_a = message.mid) !== null && _a !== void 0 ? _a : this.identityProvider.nextMessageId();
+            const envelope = Object.assign(Object.assign({}, message), { mid });
+            return new Promise((resolve, reject) => {
+                this.pending.set(mid, { resolve, reject });
+                try {
+                    this.publish(envelope, options);
+                }
+                catch (e) {
+                    this.pending.delete(mid);
+                    reject(e);
+                }
+            });
+        });
+    }
+    /** subscribe to incoming messages */
+    onMessage(handler) {
+        this.ensureOpen('peer.onMessage');
+        const listener = handler;
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    /** observe fire-and-forget transport errors */
+    onError(handler) {
+        this.errorListeners.add(handler);
+        return () => {
+            this.errorListeners.delete(handler);
+        };
+    }
+    /** close this peer */
+    close() {
+        var _a;
+        if (this.state === 'closed')
+            return;
+        this.log('info', 'peer closing', 'peer.close');
+        this.state = 'closed';
+        const server = this.server;
+        this.server = undefined;
+        if (server) {
+            this.closeLink(server);
+            server.peer.detachClient(server.clientId);
+        }
+        for (const [clientId, link] of this.clients) {
+            this.closeLink(link);
+            if (((_a = link.peer.server) === null || _a === void 0 ? void 0 : _a.peer) === this) {
+                link.peer.closeLink(link.peer.server);
+                link.peer.server = undefined;
+                link.peer.assignedClientId = undefined;
+            }
+            this.clients.delete(clientId);
+        }
+        this.clients.clear();
+        this.listeners.clear();
+        for (const [mid, pending] of this.pending) {
+            pending.reject(new Error(`@peer[${this.id}] is closed - peer.close(${mid})`));
+        }
+        this.pending.clear();
+        this.log('info', 'peer closed', 'peer.close');
+    }
+    accept(client, network, transportOptions) {
+        const clientId = this.identityProvider.nextClientId();
+        this.clients.set(clientId, { peer: client, network, transportOptions });
+        return clientId;
+    }
+    attachClientReceiverTransport(clientId, transport) {
+        const link = this.clients.get(clientId);
+        if (link)
+            link.receiverTransport = transport;
+    }
+    detachClient(clientId) {
+        if (!clientId)
+            return;
+        const link = this.clients.get(clientId);
+        if (!link)
+            return;
+        this.log('info', 'client detached', 'peer.detachClient', {
+            remotePeerId: link.peer.id,
+            clientId,
+            networkId: getNetworkId(link.network),
+        });
+        this.closeLink(link);
+        this.clients.delete(clientId);
+    }
+    closeLink(link) {
+        var _a, _b;
+        this.log('debug', 'closing peer link', 'peer.closeLink', {
+            remotePeerId: link.peer.id,
+            clientId: link.clientId,
+            networkId: getNetworkId(link.network),
+        });
+        (_b = (_a = link.receiverTransport) === null || _a === void 0 ? void 0 : _a.detach) === null || _b === void 0 ? void 0 : _b.call(_a);
+        link.receiverTransport = undefined;
+        link.network.close();
+    }
+    static reconnectPair(client, server, clientId) {
+        client.ensureOpen('peer.reconnect');
+        server.ensureOpen('peer.reconnect');
+        const clientLink = client.server;
+        const serverLink = server.clients.get(clientId);
+        if (!clientLink || clientLink.peer !== server || !serverLink || serverLink.peer !== client) {
+            throw new Error(`@clientId[${clientId}] link mismatch - peer.reconnect(${server.id})`);
+        }
+        const { uplink, downlink } = Peer.createNetworkPair(client, server, 'peer.reconnect');
+        client.closeLink(clientLink);
+        server.closeLink(serverLink);
+        clientLink.network = uplink;
+        clientLink.transportOptions = client.jsonTransportOptions;
+        clientLink.receiverTransport = Peer.attachReceiver(downlink, client, server, undefined, server.jsonTransportOptions);
+        serverLink.network = downlink;
+        serverLink.transportOptions = server.jsonTransportOptions;
+        serverLink.receiverTransport = Peer.attachReceiver(uplink, server, client, clientId, client.jsonTransportOptions);
+        client.assignedClientId = clientId;
+        client.log('info', 'peer link networks replaced', 'peer.reconnectPair', {
+            remotePeerId: server.id,
+            clientId,
+            networkId: getNetworkId(uplink),
+        });
+        server.log('info', 'peer link networks replaced', 'peer.reconnectPair', {
+            remotePeerId: client.id,
+            clientId,
+            networkId: getNetworkId(downlink),
+        });
+    }
+    static attachReceiver(network, receiver, sender, clientId, transportOptions) {
+        var _a;
+        if (transportOptions) {
+            const transport = (0, transport_1.createJSONTransport)(network, Object.assign(Object.assign({}, transportOptions), { logger: (_a = transportOptions.logger) !== null && _a !== void 0 ? _a : receiver.logger }));
+            transport.onMessage(message => receiver.dispatch(message, sender, clientId).catch(e => receiver.rejectPending(message === null || message === void 0 ? void 0 : message.mid, e)));
+            transport.onError((error, context) => {
+                receiver.log('error', 'peer transport error', 'peer.transport', {
+                    remotePeerId: sender.id,
+                    clientId,
+                    networkId: getNetworkId(network),
+                    error,
+                    data: { scope: context.scope },
+                });
+                receiver.emitError(error, Object.assign(Object.assign({}, context), { scope: `peer.transport.${context.scope}`, peer: receiver }));
+            });
+            return transport;
+        }
+        network.onMessage(data => receiver.receiveNetworkData(data, sender, clientId));
+        return undefined;
+    }
+    createPeerNetwork(toPeer) {
+        var _a;
+        const context = {
+            id: this.identityProvider.nextNetworkId(this.id, toPeer.id),
+            fromPeerId: this.id,
+            toPeerId: toPeer.id,
+            options: Object.assign({}, this.networkOptions),
+            logger: this.logger,
+        };
+        let network;
+        try {
+            network = this.networkFactory(context);
+        }
+        catch (e) {
+            const { logger: _logger } = context, logContext = __rest(context, ["logger"]);
+            this.log('error', 'peer network creation failed', 'peer.createPeerNetwork', {
+                remotePeerId: toPeer.id,
+                networkId: context.id,
+                error: e,
+                data: { context: logContext },
+            });
+            throw e;
+        }
+        const { logger: _logger } = context, logContext = __rest(context, ["logger"]);
+        this.log('debug', 'peer network created', 'peer.createPeerNetwork', {
+            remotePeerId: toPeer.id,
+            networkId: (_a = getNetworkId(network)) !== null && _a !== void 0 ? _a : context.id,
+            data: { context: logContext },
+        });
+        return network;
+    }
+    static createNetworkPair(client, server, location) {
+        let uplink;
+        try {
+            uplink = client.createPeerNetwork(server);
+            const downlink = server.createPeerNetwork(client);
+            return { uplink, downlink };
+        }
+        catch (e) {
+            uplink === null || uplink === void 0 ? void 0 : uplink.close();
+            client.log('error', 'peer network pair creation failed', location, {
+                remotePeerId: server.id,
+                error: e,
+            });
+            server.log('error', 'peer network pair creation failed', location, {
+                remotePeerId: client.id,
+                error: e,
+            });
+            throw e;
+        }
+    }
+    publish(message, options) {
+        this.ensureOpen('peer.post');
+        if (!(message === null || message === void 0 ? void 0 : message.type))
+            throw new Error(`@message.type (string) is required - peer.post(${this.id})`);
+        if (!(message === null || message === void 0 ? void 0 : message.mid))
+            throw new Error(`@message.mid (string) is required - peer.post(${this.id})`);
+        const target = this.resolveTarget(options);
+        this.log('debug', 'publishing peer message', 'peer.publish', {
+            remotePeerId: target.peer.id,
+            clientId: target.clientId,
+            mid: message.mid,
+            type: message.type,
+            networkId: getNetworkId(target.network),
+        });
+        const _deliver = () => __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.sendToLink(target, message);
+            }
+            catch (e) {
+                this.log('error', 'peer publish failed', 'peer.publish', {
+                    remotePeerId: target.peer.id,
+                    clientId: target.clientId,
+                    mid: message.mid,
+                    type: message.type,
+                    networkId: getNetworkId(target.network),
+                    error: e,
+                });
+                const pending = this.pending.get(message.mid);
+                if (pending) {
+                    this.pending.delete(message.mid);
+                    pending.reject(e);
+                }
+                else {
+                    this.emitError(e, {
+                        scope: 'peer.post',
+                        mid: message.mid,
+                        peer: this,
+                        network: target.network,
+                        message,
+                    });
+                }
+            }
+        });
+        _deliver();
+    }
+    resolveTarget(options) {
+        const clientId = options === null || options === void 0 ? void 0 : options.clientId;
+        if (clientId) {
+            const link = this.clients.get(clientId);
+            if (!link)
+                throw new Error(`@clientId[${clientId}] is not connected - peer.post(${this.id})`);
+            return link;
+        }
+        if (this.server)
+            return this.server;
+        if (this.clients.size === 1)
+            return [...this.clients.values()][0];
+        if (this.clients.size > 1)
+            throw new Error(`@clientId (string) is required - peer.post(${this.id})`);
+        throw new Error(`@peer is not connected - peer.post(${this.id})`);
+    }
+    receiveNetworkData(data, sender, clientId) {
+        try {
+            const message = JSON.parse(data);
+            this.dispatch(message, sender, clientId).catch(e => {
+                this.rejectPending(message === null || message === void 0 ? void 0 : message.mid, e);
+            });
+        }
+        catch (e) {
+            this.log('error', 'peer network data parse failed', 'peer.receiveNetworkData', {
+                remotePeerId: sender === null || sender === void 0 ? void 0 : sender.id,
+                clientId,
+                error: e,
+            });
+            this.rejectPending(undefined, e);
+        }
+    }
+    dispatch(message, sender, clientId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.ensureOpen('peer.dispatch');
+            this.log('debug', 'dispatching peer message', 'peer.dispatch', {
+                remotePeerId: sender === null || sender === void 0 ? void 0 : sender.id,
+                clientId,
+                mid: message === null || message === void 0 ? void 0 : message.mid,
+                type: message === null || message === void 0 ? void 0 : message.type,
+            });
+            if (message.type === 'result' || message.type === 'pong') {
+                const pending = this.pending.get(message.mid);
+                if (pending) {
+                    this.pending.delete(message.mid);
+                    this.log('debug', 'pending peer message resolved', 'peer.dispatch.result', {
+                        remotePeerId: sender === null || sender === void 0 ? void 0 : sender.id,
+                        clientId,
+                        mid: message.mid,
+                        type: message.type,
+                    });
+                    pending.resolve(message.data);
+                    return;
+                }
+            }
+            if (message.type === 'error') {
+                const pending = this.pending.get(message.mid);
+                if (pending) {
+                    this.pending.delete(message.mid);
+                    this.log('warn', 'pending peer message rejected', 'peer.dispatch.error', {
+                        remotePeerId: sender === null || sender === void 0 ? void 0 : sender.id,
+                        clientId,
+                        mid: message.mid,
+                        type: message.type,
+                        data: { errorData: message.data },
+                    });
+                    pending.reject(message.data);
+                    return;
+                }
+            }
+            if (message.type === 'ping') {
+                this.log('debug', 'replying pong to ping', 'peer.dispatch.ping', {
+                    remotePeerId: sender === null || sender === void 0 ? void 0 : sender.id,
+                    clientId,
+                    mid: message.mid,
+                    type: message.type,
+                });
+                this.reply(sender, message.mid, 'pong', { clientId });
+                return;
+            }
+            const context = {
+                mid: message.mid,
+                type: message.type,
+                peer: this,
+                sender,
+                clientId,
+                receivedAt: Date.now(),
+                reply: (data) => this.reply(sender, message.mid, 'result', data),
+            };
+            const listeners = [...this.listeners];
+            const results = [];
+            for (const listener of listeners) {
+                results.push(yield listener(message, context));
+            }
+            if (results.length > 0)
+                context.reply(results.length <= 1 ? results[0] : results);
+        });
+    }
+    reply(target, mid, type, data) {
+        if (!target)
+            return;
+        const _deliver = () => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const link = this.findLinkTo(target);
+                if (link) {
+                    this.log('debug', 'replying peer message', 'peer.reply', {
+                        remotePeerId: target.id,
+                        clientId: link.clientId,
+                        mid,
+                        type,
+                        networkId: getNetworkId(link.network),
+                    });
+                    this.sendToLink(link, { type, data, mid });
+                }
+            }
+            catch (e) {
+                this.log('error', 'peer reply failed', 'peer.reply', {
+                    remotePeerId: target.id,
+                    mid,
+                    type,
+                    error: e,
+                });
+                target.rejectPending(mid, e);
+            }
+        });
+        _deliver();
+    }
+    sendToLink(link, message) {
+        if (link.transportOptions) {
+            (0, transport_1.splitJSON)(message, link.transportOptions).send(link.network);
+        }
+        else {
+            link.network.send(JSON.stringify(message));
+        }
+    }
+    findLinkTo(target) {
+        var _a;
+        if (((_a = this.server) === null || _a === void 0 ? void 0 : _a.peer) === target)
+            return this.server;
+        for (const link of this.clients.values()) {
+            if (link.peer === target)
+                return link;
+        }
+        return undefined;
+    }
+    rejectPending(mid, error) {
+        if (!mid)
+            return;
+        const pending = this.pending.get(mid);
+        if (!pending)
+            return;
+        this.pending.delete(mid);
+        pending.reject(error);
+    }
+    emitError(error, context) {
+        var _a;
+        this.log('error', 'peer error emitted', 'peer.emitError', {
+            mid: context.mid,
+            type: (_a = context.message) === null || _a === void 0 ? void 0 : _a.type,
+            networkId: getNetworkId(context.network),
+            error,
+            data: { scope: context.scope },
+        });
+        for (const listener of [...this.errorListeners]) {
+            listener(error, context);
+        }
+    }
+    ensureOpen(scope) {
+        if (this.state !== 'open')
+            throw new Error(`@peer[${this.id}] is ${this.state} - ${scope}(${this.id})`);
+    }
+    log(level, message, location, entry) {
+        try {
+            this.logger.log(Object.assign(Object.assign({ time: Date.now(), level,
+                message,
+                location, peerId: this.id }, entry), { error: (entry === null || entry === void 0 ? void 0 : entry.error) == null ? undefined : normalizeError(entry.error) }));
+        }
+        catch (_a) {
+            // Logging must never break simulated socket behavior.
+        }
+    }
+}
+exports.Peer = Peer;
+/** create a peer */
+const createPeer = (options) => new Peer(options);
+exports.createPeer = createPeer;
+/**
+ * factory for creating peers and keeping a small registry for tests.
+ */
+class SocketFactory {
+    constructor(options) {
+        this.options = options;
+        this.no = 0;
+        this.peers = new Map();
+    }
+    /** create and register a peer */
+    peer(options) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
+        const peer = (0, exports.createPeer)({
+            latencyMs: (_a = options === null || options === void 0 ? void 0 : options.latencyMs) !== null && _a !== void 0 ? _a : (_b = this.options) === null || _b === void 0 ? void 0 : _b.latencyMs,
+            jitterMs: (_c = options === null || options === void 0 ? void 0 : options.jitterMs) !== null && _c !== void 0 ? _c : (_d = this.options) === null || _d === void 0 ? void 0 : _d.jitterMs,
+            unordered: (_e = options === null || options === void 0 ? void 0 : options.unordered) !== null && _e !== void 0 ? _e : (_f = this.options) === null || _f === void 0 ? void 0 : _f.unordered,
+            maxPacketBytes: (_g = options === null || options === void 0 ? void 0 : options.maxPacketBytes) !== null && _g !== void 0 ? _g : (_h = this.options) === null || _h === void 0 ? void 0 : _h.maxPacketBytes,
+            identityProvider: (_j = options === null || options === void 0 ? void 0 : options.identityProvider) !== null && _j !== void 0 ? _j : (_k = this.options) === null || _k === void 0 ? void 0 : _k.identityProvider,
+            networkFactory: (_l = options === null || options === void 0 ? void 0 : options.networkFactory) !== null && _l !== void 0 ? _l : (_m = this.options) === null || _m === void 0 ? void 0 : _m.networkFactory,
+            logger: (_o = options === null || options === void 0 ? void 0 : options.logger) !== null && _o !== void 0 ? _o : (_p = this.options) === null || _p === void 0 ? void 0 : _p.logger,
+            jsonTransport: (_q = options === null || options === void 0 ? void 0 : options.jsonTransport) !== null && _q !== void 0 ? _q : (_r = this.options) === null || _r === void 0 ? void 0 : _r.jsonTransport,
+            id: (_s = options === null || options === void 0 ? void 0 : options.id) !== null && _s !== void 0 ? _s : this.nextFactoryPeerId(options),
+        });
+        this.peers.set(peer.id, peer);
+        return peer;
+    }
+    /** find a registered peer by peer id */
+    find(id) {
+        return this.peers.get(id);
+    }
+    /** connect client to server and return the assigned client id */
+    connect(client, server) {
+        return client.connect(server);
+    }
+    /** find a client peer connected to a server peer by client id */
+    findPeer(server, clientId) {
+        return server.findPeer(clientId);
+    }
+    nextFactoryPeerId(options) {
+        var _a, _b, _c, _d;
+        if (((options === null || options === void 0 ? void 0 : options.identityProvider) || ((_a = this.options) === null || _a === void 0 ? void 0 : _a.identityProvider)) && !((_b = this.options) === null || _b === void 0 ? void 0 : _b.idPrefix))
+            return undefined;
+        return `${(_d = (_c = this.options) === null || _c === void 0 ? void 0 : _c.idPrefix) !== null && _d !== void 0 ? _d : 'peer'}-${++this.no}`;
+    }
+}
+exports.SocketFactory = SocketFactory;
+/** create a socket factory */
+const createSocketFactory = (options) => new SocketFactory(options);
+exports.createSocketFactory = createSocketFactory;
+const asNetworkOptions = (options) => {
+    var _a, _b, _c, _d;
+    return ({
+        latencyMs: (_a = options === null || options === void 0 ? void 0 : options.latencyMs) !== null && _a !== void 0 ? _a : 0,
+        jitterMs: (_b = options === null || options === void 0 ? void 0 : options.jitterMs) !== null && _b !== void 0 ? _b : DEFAULT_JITTER_MS,
+        unordered: (_c = options === null || options === void 0 ? void 0 : options.unordered) !== null && _c !== void 0 ? _c : true,
+        maxPacketBytes: (_d = options === null || options === void 0 ? void 0 : options.maxPacketBytes) !== null && _d !== void 0 ? _d : DEFAULT_MAX_PACKET_BYTES,
+    });
+};
+const asJSONTransportOptions = (options, peerMaxPacketBytes) => {
+    if (!options)
+        return undefined;
+    const transportOptions = options === true ? {} : options;
+    if (transportOptions.chunkBytes || !peerMaxPacketBytes)
+        return transportOptions;
+    return Object.assign(Object.assign({}, transportOptions), { chunkBytes: (0, transport_1.calculateJSONTransportChunkBytes)(peerMaxPacketBytes, transportOptions.envelopeReserveBytes) });
+};
+const getNetworkId = (network) => {
+    const id = network === null || network === void 0 ? void 0 : network.id;
+    return typeof id === 'string' ? id : undefined;
+};
+const normalizeError = (error) => {
+    if (error instanceof Error)
+        return error.message;
+    if (typeof error === 'string')
+        return error;
+    try {
+        return JSON.stringify(error);
+    }
+    catch (_a) {
+        return String(error);
+    }
+};
+const byteLength = (value) => new TextEncoder().encode(value).length;
+//# sourceMappingURL=socket.js.map