pinomad 0.3.0 → 0.5.0

package/dist/chunk-kmbh44dt.js

@@ -0,0 +1,704 @@
+// packages/protocol/src/relay.ts
+import { ed25519 } from "@noble/curves/ed25519.js";
+
+// packages/protocol/src/noise.ts
+import { chacha20poly1305 } from "@noble/ciphers/chacha.js";
+import { x25519 } from "@noble/curves/ed25519.js";
+import { blake2s } from "@noble/hashes/blake2.js";
+import { hmac } from "@noble/hashes/hmac.js";
+var PROTOCOL_NAME = new TextEncoder().encode("Noise_IK_25519_ChaChaPoly_BLAKE2s");
+var KEY_LENGTH = 32;
+var TAG_LENGTH = 16;
+var MAX_MESSAGE = 65535;
+var MAX_NONCE = 2n ** 64n - 1n;
+var hash = (data) => blake2s(data, { dkLen: KEY_LENGTH });
+var concat = (...parts) => {
+  const out = new Uint8Array(parts.reduce((sum, part) => sum + part.length, 0));
+  let offset = 0;
+  for (const part of parts) {
+    out.set(part, offset);
+    offset += part.length;
+  }
+  return out;
+};
+function hkdf(chainingKey, ikm, outputs) {
+  const tempKey = hmac(blake2s, chainingKey, ikm);
+  const out1 = hmac(blake2s, tempKey, new Uint8Array([1]));
+  const out2 = hmac(blake2s, tempKey, concat(out1, new Uint8Array([2])));
+  return [out1, out2];
+}
+function generateKeyPair() {
+  return keyPairFromPrivate(x25519.utils.randomSecretKey());
+}
+function keyPairFromPrivate(privateKey) {
+  if (privateKey.length !== KEY_LENGTH)
+    throw new Error(`X25519 private key must be ${KEY_LENGTH} bytes`);
+  return { publicKey: x25519.getPublicKey(privateKey), privateKey };
+}
+var dh = (pair, remotePublic) => x25519.getSharedSecret(pair.privateKey, remotePublic);
+
+class NoiseCipherState {
+  #key;
+  #nonce = 0n;
+  setKey(key) {
+    this.#key = key;
+    this.#nonce = 0n;
+  }
+  encrypt(plaintext, ad = new Uint8Array(0)) {
+    const key = this.#key;
+    if (key === undefined)
+      return plaintext;
+    return chacha20poly1305(key, this.#takeNonce(), ad).encrypt(plaintext);
+  }
+  decrypt(ciphertext, ad = new Uint8Array(0)) {
+    const key = this.#key;
+    if (key === undefined)
+      return ciphertext;
+    return chacha20poly1305(key, this.#takeNonce(), ad).decrypt(ciphertext);
+  }
+  #takeNonce() {
+    if (this.#nonce === MAX_NONCE)
+      throw new Error("nonce exhausted");
+    const nonce = new Uint8Array(12);
+    new DataView(nonce.buffer).setBigUint64(4, this.#nonce, true);
+    this.#nonce += 1n;
+    return nonce;
+  }
+}
+
+class SymmetricState {
+  #ck;
+  #h;
+  cipher = new NoiseCipherState;
+  constructor() {
+    const name = PROTOCOL_NAME;
+    this.#h = name.length <= KEY_LENGTH ? concat(name, new Uint8Array(KEY_LENGTH - name.length)) : hash(name);
+    this.#ck = this.#h.slice();
+  }
+  mixKey(ikm) {
+    const [ck, tempKey] = hkdf(this.#ck, ikm, 2);
+    this.#ck = ck;
+    this.cipher.setKey(tempKey.subarray(0, KEY_LENGTH));
+  }
+  mixHash(data) {
+    this.#h = hash(concat(this.#h, data));
+  }
+  encryptAndHash(plaintext) {
+    const ciphertext = this.cipher.encrypt(plaintext, this.#h);
+    this.mixHash(ciphertext);
+    return ciphertext;
+  }
+  decryptAndHash(ciphertext) {
+    const plaintext = this.cipher.decrypt(ciphertext, this.#h);
+    this.mixHash(ciphertext);
+    return plaintext;
+  }
+  get handshakeHash() {
+    return this.#h;
+  }
+  split() {
+    const [key1, key2] = hkdf(this.#ck, new Uint8Array(0), 2);
+    const first = new NoiseCipherState;
+    first.setKey(key1.subarray(0, KEY_LENGTH));
+    const second = new NoiseCipherState;
+    second.setKey(key2.subarray(0, KEY_LENGTH));
+    return [first, second];
+  }
+}
+function take(message, size) {
+  if (message.offset + size > message.buffer.length)
+    throw new Error("malformed Noise message");
+  const slice = message.buffer.subarray(message.offset, message.offset + size);
+  message.offset += size;
+  return slice;
+}
+function readMessage1(state, message, own) {
+  const remoteEphemeral = take(message, KEY_LENGTH).slice();
+  state.mixHash(remoteEphemeral);
+  state.mixKey(dh(own.static, remoteEphemeral));
+  const remoteStatic = state.decryptAndHash(take(message, KEY_LENGTH + TAG_LENGTH)).slice();
+  if (remoteStatic.length !== KEY_LENGTH)
+    throw new Error("bad remote static key");
+  state.mixKey(dh(own.static, remoteStatic));
+  return { remoteEphemeral, remoteStatic };
+}
+function writeMessage2(state, buffer, own, remoteEphemeral, remoteStatic) {
+  buffer.push(own.ephemeral.publicKey);
+  state.mixHash(own.ephemeral.publicKey);
+  state.mixKey(dh(own.ephemeral, remoteEphemeral));
+  state.mixKey(dh(own.ephemeral, remoteStatic));
+}
+var checkLength = (message, what) => {
+  if (message.length > MAX_MESSAGE)
+    throw new Error(`${what} exceeds ${MAX_MESSAGE} bytes`);
+};
+function initialize(prologue, responderStatic) {
+  const state = new SymmetricState;
+  state.mixHash(prologue);
+  state.mixHash(responderStatic);
+  return state;
+}
+function respondIK(options) {
+  const ephemeral = options.ephemeral ?? generateKeyPair();
+  const state = initialize(options.prologue, options.static.publicKey);
+  let remoteEphemeral;
+  let remoteStatic;
+  return {
+    readMessage1(message) {
+      checkLength(message, "handshake message");
+      const reader = { buffer: message, offset: 0 };
+      const remote = readMessage1(state, reader, { static: options.static });
+      remoteEphemeral = remote.remoteEphemeral;
+      remoteStatic = remote.remoteStatic;
+      const payload = state.decryptAndHash(take(reader, message.length - reader.offset));
+      return { payload, remoteStatic };
+    },
+    writeMessage2(payload) {
+      if (remoteEphemeral === undefined || remoteStatic === undefined)
+        throw new Error("message 2 before message 1");
+      const buffer = [];
+      writeMessage2(state, buffer, { ephemeral }, remoteEphemeral, remoteStatic);
+      buffer.push(state.encryptAndHash(payload));
+      const message = concat(...buffer);
+      checkLength(message, "handshake message");
+      const [receive, send] = state.split();
+      return { message, result: { send, receive, handshakeHash: state.handshakeHash } };
+    }
+  };
+}
+
+// packages/protocol/src/secure-channel.ts
+var SECURE_PROLOGUE = new TextEncoder().encode("pinomad/1");
+var utf8 = new TextEncoder;
+var utf8Decode = new TextDecoder("utf-8", { fatal: true });
+var encodeHostHello = (hello) => utf8.encode(JSON.stringify(hello));
+function decodeJson(bytes) {
+  try {
+    return JSON.parse(utf8Decode.decode(bytes));
+  } catch {
+    throw new Error("handshake payload is not JSON");
+  }
+}
+var isString = (value) => typeof value === "string";
+function decodeClientHello(bytes) {
+  const value = decodeJson(bytes);
+  if (value?.v !== 1)
+    throw new Error("unsupported client hello");
+  const pair = value.pair;
+  if (pair === undefined)
+    return { v: 1 };
+  const secret = pair.secret;
+  const name = pair.name;
+  if (!isString(secret) || !isString(name))
+    throw new Error("malformed pair");
+  return { v: 1, pair: { secret, name } };
+}
+var B64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+function toBase64Url(bytes) {
+  let out = "";
+  for (let index = 0;index < bytes.length; index += 3) {
+    const a = bytes[index];
+    const b = bytes[index + 1];
+    const c = bytes[index + 2];
+    out += B64_ALPHABET[a >> 2] + B64_ALPHABET[(a & 3) << 4 | (b ?? 0) >> 4];
+    if (b !== undefined)
+      out += B64_ALPHABET[(b & 15) << 2 | (c ?? 0) >> 6];
+    if (c !== undefined)
+      out += B64_ALPHABET[c & 63];
+  }
+  return out;
+}
+function fromBase64Url(text) {
+  if (text.length % 4 === 1)
+    throw new Error("invalid base64url");
+  const lookup = new Map(Array.from(B64_ALPHABET, (char, index) => [char, index]));
+  const bytes = [];
+  for (let index = 0;index < text.length; index += 4) {
+    const quad = text.slice(index, index + 4);
+    const values = [...quad].map((char) => {
+      const value = lookup.get(char);
+      if (value === undefined)
+        throw new Error("invalid base64url");
+      return value;
+    });
+    const packed = values.reduce((bits, value, index2) => bits | value << 18 - index2 * 6, 0);
+    bytes.push(packed >> 16 & 255);
+    if (values.length > 2)
+      bytes.push(packed >> 8 & 255);
+    if (values.length > 3)
+      bytes.push(packed & 255);
+  }
+  return new Uint8Array(bytes);
+}
+var MAX_BODY = 65535 - 16 - 1;
+
+class SecureSession {
+  #send;
+  #receive;
+  #pending = [];
+  constructor(result) {
+    this.#send = result.send;
+    this.#receive = result.receive;
+  }
+  seal(text) {
+    const body = utf8.encode(text);
+    const chunks = [];
+    for (let offset = 0;offset <= body.length; offset += MAX_BODY) {
+      const last = offset + MAX_BODY >= body.length;
+      const record = new Uint8Array(1 + Math.min(MAX_BODY, body.length - offset));
+      record[0] = last ? 0 : 1;
+      record.set(body.subarray(offset, offset + MAX_BODY), 1);
+      chunks.push(this.#send.encrypt(record));
+      if (last)
+        break;
+    }
+    return chunks;
+  }
+  open(chunk) {
+    const record = this.#receive.decrypt(chunk);
+    const flag = record[0];
+    if (flag !== 0 && flag !== 1)
+      throw new Error("bad record flag");
+    this.#pending.push(record.subarray(1));
+    if (flag === 1)
+      return;
+    const whole = concatParts(this.#pending);
+    this.#pending = [];
+    return utf8Decode.decode(whole);
+  }
+}
+function concatParts(parts) {
+  const out = new Uint8Array(parts.reduce((sum, part) => sum + part.length, 0));
+  let offset = 0;
+  for (const part of parts) {
+    out.set(part, offset);
+    offset += part.length;
+  }
+  return out;
+}
+
+// packages/protocol/src/relay.ts
+var RELAY_CLOSE = {
+  badSignature: 4601,
+  hostNotAllowed: 4603,
+  hostOffline: 4604,
+  unknownConnection: 4605,
+  replaced: 4609,
+  acceptTimeout: 4610
+};
+function encodeRelayFrame(frame) {
+  return JSON.stringify(frame);
+}
+var isString2 = (value) => typeof value === "string";
+var isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var isBoundedString = (value, max = 64) => isString2(value) && value.length > 0 && value.length <= max;
+function decodeJson2(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new Error("relay frame is not JSON");
+  }
+}
+function decodeRelayToHost(text) {
+  const value = decodeJson2(text);
+  switch (value?.t) {
+    case "challenge":
+      if (!isString2(value.nonce))
+        throw new Error("malformed challenge");
+      return { t: "challenge", nonce: value.nonce };
+    case "registered":
+      return decodeRegistered(value);
+    case "incoming":
+      if (!isString2(value.connId))
+        throw new Error("malformed incoming");
+      return { t: "incoming", connId: value.connId };
+    case "pairing-request":
+      if (!isBoundedString(value.requestId))
+        throw new Error("malformed pairing-request");
+      return { t: "pairing-request", requestId: value.requestId };
+    case "push-result":
+      return decodePushResult(value);
+    case "joined":
+      if (!isString2(value.username))
+        throw new Error("malformed joined");
+      return { t: "joined", username: value.username };
+    case "left":
+      return { t: "left" };
+    case "refused":
+      if (!isString2(value.reason))
+        throw new Error("malformed refused");
+      return { t: "refused", reason: value.reason };
+    default:
+      throw new Error("unknown relay frame");
+  }
+}
+function decodeRegistered(value) {
+  if (value.push === undefined)
+    return { t: "registered" };
+  if (!Array.isArray(value.push) || value.push.length > 8 || !value.push.every(isString2)) {
+    throw new Error("malformed registered");
+  }
+  const push = value.push.filter((entry) => entry === "production" || entry === "development");
+  return { t: "registered", push };
+}
+function decodePushResult(value) {
+  if (!isBoundedString(value.requestId) || !isBoundedString(value.reason, 256) || value.result !== "accepted" && value.result !== "unregistered" && value.result !== "retry" && value.result !== "rejected" && value.result !== "unavailable") {
+    throw new Error("malformed push-result");
+  }
+  if (value.result === "unregistered") {
+    if (typeof value.unregisteredAt !== "number" || !Number.isFinite(value.unregisteredAt)) {
+      throw new Error("malformed push-result");
+    }
+    return {
+      t: "push-result",
+      requestId: value.requestId,
+      result: "unregistered",
+      reason: value.reason,
+      unregisteredAt: value.unregisteredAt
+    };
+  }
+  if (value.result === "retry") {
+    if (value.retryAfterMs !== undefined && (typeof value.retryAfterMs !== "number" || !Number.isFinite(value.retryAfterMs))) {
+      throw new Error("malformed push-result");
+    }
+    return {
+      t: "push-result",
+      requestId: value.requestId,
+      result: "retry",
+      reason: value.reason,
+      ...value.retryAfterMs === undefined ? {} : { retryAfterMs: value.retryAfterMs }
+    };
+  }
+  return { t: "push-result", requestId: value.requestId, result: value.result, reason: value.reason };
+}
+function decodeHostToRelay(text) {
+  const value = decodeJson2(text);
+  switch (value?.t) {
+    case "register":
+      return decodeRegister(value);
+    case "push":
+      return decodePush(value);
+    case "pairing":
+      if (!isBoundedString(value.requestId) || !isBoundedString(value.secret) || typeof value.expiresAt !== "number" || !Number.isFinite(value.expiresAt)) {
+        throw new Error("malformed pairing");
+      }
+      return { t: "pairing", requestId: value.requestId, secret: value.secret, expiresAt: value.expiresAt };
+    case "pairing-refused":
+      if (!isBoundedString(value.requestId) || !isBoundedString(value.reason)) {
+        throw new Error("malformed pairing-refused");
+      }
+      return { t: "pairing-refused", requestId: value.requestId, reason: value.reason };
+    default:
+      throw new Error("unknown host frame");
+  }
+}
+function decodePush(value) {
+  const n = value.notification;
+  if (!isBoundedString(value.requestId) || !isBoundedString(value.token, 256) || value.environment !== "production" && value.environment !== "development" || !isRecord(n) || !isBoundedString(n.title, 512) || !isBoundedString(n.body, 256) || !isBoundedString(n.collapseId, 64) || !isBoundedString(n.hostKey, 64) || typeof n.conversationId !== "number" || !Number.isSafeInteger(n.conversationId) || n.conversationId < 1) {
+    throw new Error("malformed push");
+  }
+  return {
+    t: "push",
+    requestId: value.requestId,
+    token: value.token,
+    environment: value.environment,
+    notification: {
+      title: n.title,
+      body: n.body,
+      collapseId: n.collapseId,
+      hostKey: n.hostKey,
+      conversationId: n.conversationId
+    }
+  };
+}
+function decodeRegister(value) {
+  if (value.t !== "register" || !isString2(value.hostId) || !isString2(value.signature)) {
+    throw new Error("malformed register");
+  }
+  if (value.op !== undefined && value.op !== "join" && value.op !== "leave")
+    throw new Error("malformed register");
+  if (value.signatureV2 !== undefined && !isString2(value.signatureV2))
+    throw new Error("malformed register");
+  if (value.noisePublicKey !== undefined && !isString2(value.noisePublicKey))
+    throw new Error("malformed register");
+  if (value.joinToken !== undefined && !isString2(value.joinToken))
+    throw new Error("malformed register");
+  if (value.name !== undefined && !isString2(value.name))
+    throw new Error("malformed register");
+  if (value.features !== undefined && (!Array.isArray(value.features) || value.features.length > 16 || !value.features.every((feature) => isString2(feature) && feature.length <= 64))) {
+    throw new Error("malformed register");
+  }
+  return {
+    t: "register",
+    hostId: value.hostId,
+    signature: value.signature,
+    ...value.signatureV2 === undefined ? {} : { signatureV2: value.signatureV2 },
+    ...value.noisePublicKey === undefined ? {} : { noisePublicKey: value.noisePublicKey },
+    ...value.op === undefined ? {} : { op: value.op },
+    ...value.joinToken === undefined ? {} : { joinToken: value.joinToken },
+    ...value.name === undefined ? {} : { name: value.name },
+    ...value.features === undefined ? {} : { features: value.features }
+  };
+}
+function relayHostId(publicKey) {
+  if (publicKey.length !== 32)
+    throw new Error("Ed25519 public key must be 32 bytes");
+  return toBase64Url(publicKey);
+}
+var utf82 = new TextEncoder;
+function relayChallengeMessage(args) {
+  return utf82.encode(`pinomad-relay/1
+${args.relayOrigin}
+${args.hostId}
+${args.nonce}`);
+}
+function signRelayChallenge(secretKey, args) {
+  return toBase64Url(ed25519.sign(relayChallengeMessage(args), secretKey));
+}
+function verifyRelayChallenge(signature, args) {
+  try {
+    return ed25519.verify(fromBase64Url(signature), relayChallengeMessage(args), fromBase64Url(args.hostId));
+  } catch {
+    return false;
+  }
+}
+function relayChallengeMessageV2(args) {
+  return utf82.encode(`pinomad-relay/2
+${args.relayOrigin}
+${args.hostId}
+${args.nonce}
+${args.noisePublicKey}`);
+}
+function signRelayChallengeV2(secretKey, args) {
+  return toBase64Url(ed25519.sign(relayChallengeMessageV2(args), secretKey));
+}
+function verifyRelayChallengeV2(signature, args) {
+  try {
+    return ed25519.verify(fromBase64Url(signature), relayChallengeMessageV2(args), fromBase64Url(args.hostId));
+  } catch {
+    return false;
+  }
+}
+
+// apps/host/src/relay-link.ts
+import { randomBytes } from "node:crypto";
+import { WebSocket as WebSocket2 } from "ws";
+function relayWsBase(origin) {
+  const normalized = origin.replace(/\/+$/, "");
+  if (normalized.startsWith("https://"))
+    return `wss://${normalized.slice("https://".length)}`;
+  if (normalized.startsWith("http://"))
+    return `ws://${normalized.slice("http://".length)}`;
+  throw new Error(`relay origin must be an http(s) URL: ${origin}`);
+}
+var REJECTION_REASONS = {
+  [RELAY_CLOSE.badSignature]: () => `the relay rejected this host's registration signature — a version mismatch?`,
+  [RELAY_CLOSE.hostNotAllowed]: (hostId) => `the server does not allow this host (${hostId}); join it to an account with \`pinomad join\``,
+  [RELAY_CLOSE.replaced]: () => `the relay replaced this control connection — another process registered the same hostId`
+};
+var PUSH_TIMEOUT_MS = 1e4;
+function startRelayLink(options) {
+  const origin = options.origin.replace(/\/+$/, "");
+  const wsBase = relayWsBase(origin);
+  const hostId = relayHostId(options.signingKey.publicKey);
+  const minDelay = options.reconnectDelayMs?.min ?? 1000;
+  const maxDelay = options.reconnectDelayMs?.max ?? 30000;
+  const maxPendingAccepts = options.maxPendingAccepts ?? 16;
+  let state = { status: "connecting" };
+  let stopped = false;
+  let control;
+  let delay = minDelay;
+  let retryTimer;
+  let pendingAccepts = 0;
+  let pushEnvironments;
+  const pushes = new Map;
+  function setState(next) {
+    const changed = state.status !== next.status || state.status === "rejected" && next.status === "rejected" && state.reason !== next.reason;
+    state = next;
+    if (changed)
+      options.onStateChange?.(next);
+  }
+  const watched = new Set;
+  const ponged = new WeakMap;
+  const pingIntervalMs = options.pingIntervalMs ?? 30000;
+  const pingTimer = setInterval(() => {
+    for (const socket of watched) {
+      if (socket.readyState !== WebSocket2.OPEN)
+        continue;
+      if (ponged.get(socket) === true) {
+        ponged.set(socket, false);
+        socket.ping();
+      } else {
+        socket.terminate();
+      }
+    }
+  }, pingIntervalMs);
+  function watch(socket) {
+    watched.add(socket);
+    ponged.set(socket, true);
+    socket.on("pong", () => ponged.set(socket, true));
+    socket.once("close", () => watched.delete(socket));
+    socket.on("error", () => socket.terminate());
+  }
+  function connectControl() {
+    if (stopped)
+      return;
+    const socket = new WebSocket2(`${wsBase}/host`, { handshakeTimeout: pingIntervalMs });
+    control = socket;
+    pushEnvironments = undefined;
+    watch(socket);
+    socket.on("message", (data, isBinary) => onControlMessage(socket, data, isBinary));
+    socket.once("close", (code) => onControlClosed(socket, code));
+  }
+  function reconnect(at) {
+    if (stopped || retryTimer !== undefined)
+      return;
+    retryTimer = setTimeout(() => {
+      retryTimer = undefined;
+      connectControl();
+    }, at);
+  }
+  function onControlMessage(socket, data, isBinary) {
+    let frame;
+    try {
+      if (isBinary)
+        throw new Error("binary control frame");
+      frame = decodeRelayToHost(data.toString());
+    } catch {
+      socket.close();
+      return;
+    }
+    switch (frame.t) {
+      case "challenge": {
+        const noisePublicKey = toBase64Url(options.noisePublicKey);
+        const challenge = { relayOrigin: origin, hostId, nonce: frame.nonce };
+        socket.send(encodeRelayFrame({
+          t: "register",
+          hostId,
+          signature: signRelayChallenge(options.signingKey.secretKey, challenge),
+          signatureV2: signRelayChallengeV2(options.signingKey.secretKey, { ...challenge, noisePublicKey }),
+          noisePublicKey,
+          ...options.accountOffer === undefined ? {} : { features: ["pairing"] }
+        }));
+        break;
+      }
+      case "registered":
+        delay = minDelay;
+        pushEnvironments = frame.push;
+        setState({ status: "registered", ...frame.push === undefined ? {} : { push: frame.push } });
+        break;
+      case "push-result": {
+        const request = pushes.get(frame.requestId);
+        if (request === undefined || request.socket !== socket)
+          break;
+        pushes.delete(frame.requestId);
+        const { t: _t, requestId: _id, ...verdict } = frame;
+        request.settle(verdict);
+        break;
+      }
+      case "pairing-request": {
+        const accountOffer = options.accountOffer;
+        const refused = (reason) => {
+          socket.send(encodeRelayFrame({ t: "pairing-refused", requestId: frame.requestId, reason }));
+        };
+        if (accountOffer === undefined) {
+          refused("unavailable");
+          break;
+        }
+        accountOffer().then((result) => {
+          if (socket !== control || socket.readyState !== WebSocket2.OPEN)
+            return;
+          socket.send(encodeRelayFrame(result.ok ? { t: "pairing", requestId: frame.requestId, secret: result.secret, expiresAt: result.expiresAt } : { t: "pairing-refused", requestId: frame.requestId, reason: result.reason }));
+        }, () => {
+          if (socket === control && socket.readyState === WebSocket2.OPEN)
+            refused("error");
+        });
+        break;
+      }
+      case "incoming": {
+        if (pendingAccepts >= maxPendingAccepts)
+          break;
+        pendingAccepts += 1;
+        const data2 = new WebSocket2(`${wsBase}/accept/${frame.connId}`, { handshakeTimeout: pingIntervalMs });
+        watch(data2);
+        const release = () => {
+          pendingAccepts -= 1;
+          clearTimeout(ageOut);
+          data2.off("close", release);
+        };
+        const ageOut = setTimeout(release, 1e4);
+        data2.once("close", release);
+        options.accept(data2);
+        break;
+      }
+    }
+  }
+  function onControlClosed(socket, code) {
+    control = undefined;
+    pushEnvironments = undefined;
+    for (const [requestId, request] of pushes) {
+      if (request.socket === socket) {
+        pushes.delete(requestId);
+        request.settle({ result: "retry", reason: "control closed" });
+      }
+    }
+    if (stopped)
+      return;
+    const rejection = REJECTION_REASONS[code];
+    if (rejection !== undefined) {
+      const reason = `relay ${origin}: ${rejection(hostId)} (${code})`;
+      setState({ status: "rejected", reason });
+      delay = maxDelay;
+      reconnect(maxDelay);
+      return;
+    }
+    setState({ status: "connecting" });
+    reconnect(delay);
+    delay = Math.min(maxDelay, delay * 2);
+  }
+  connectControl();
+  return {
+    hostId,
+    origin,
+    state: () => state,
+    sendPush(request) {
+      const socket = control;
+      if (stopped || socket === undefined || socket.readyState !== WebSocket2.OPEN || state.status !== "registered") {
+        return Promise.resolve({ result: "retry", reason: "control disconnected" });
+      }
+      const envs = pushEnvironments;
+      if (envs === undefined) {
+        return Promise.resolve({ result: "unavailable", reason: "server does not declare push" });
+      }
+      if (!envs.includes(request.environment)) {
+        return Promise.resolve({ result: "unavailable", reason: `environment ${request.environment} not declared` });
+      }
+      return new Promise((resolve) => {
+        const requestId = randomBytes(16).toString("base64url");
+        const timer = setTimeout(() => {
+          if (pushes.delete(requestId))
+            resolve({ result: "retry", reason: "timeout" });
+        }, PUSH_TIMEOUT_MS);
+        pushes.set(requestId, {
+          socket,
+          settle: (verdict) => {
+            clearTimeout(timer);
+            resolve(verdict);
+          }
+        });
+        socket.send(encodeRelayFrame({ t: "push", requestId, ...request }));
+      });
+    },
+    close() {
+      stopped = true;
+      if (retryTimer !== undefined)
+        clearTimeout(retryTimer);
+      clearInterval(pingTimer);
+      for (const socket of watched)
+        socket.terminate();
+      return Promise.resolve();
+    }
+  };
+}
+
+export { generateKeyPair, keyPairFromPrivate, respondIK, SECURE_PROLOGUE, encodeHostHello, decodeClientHello, toBase64Url, fromBase64Url, SecureSession, RELAY_CLOSE, encodeRelayFrame, decodeRelayToHost, decodeHostToRelay, relayHostId, signRelayChallenge, verifyRelayChallenge, signRelayChallengeV2, verifyRelayChallengeV2, relayWsBase, startRelayLink };