@stim-cli/core 1.20.2 → 1.21.0

package/dist/noise-session.d.mts

@@ -0,0 +1,164 @@
+import { f as NoiseTransport, l as NoiseKeyPair, s as NoiseDh } from "./noise-DYIbymAJ.mjs";
+import { EventEmitter } from "node:events";
+//#region noise-session.d.ts
+/** The protocol version byte that opens every protocol 2 connection. */
+declare const STIM_PROTOCOL_VERSION = 2;
+/** A client the server already has a record for: `Noise_XX`, nothing after the mode byte. */
+declare const MODE_RETURNING = 0;
+/** A client spending a pairing token or setup ticket: `Noise_XXpsk2`, with the secret's `lookup` after the mode byte. */
+declare const MODE_FIRST_CONTACT = 1;
+type HandshakeMode = typeof MODE_RETURNING | typeof MODE_FIRST_CONTACT;
+declare const SECRET_BYTES = 32;
+declare const LOOKUP_BYTES = 16;
+/** Largest message, plaintext without its type byte, a server accepts from a client. */
+declare const MAX_CLIENT_MESSAGE_BYTES: number;
+/** Largest message, plaintext without its type byte, a server sends. */
+declare const MAX_SERVER_MESSAGE_BYTES: number;
+/** What a transport message adds to its plaintext on the wire: the type byte and the ChaCha20-Poly1305 tag. */
+declare const TRANSPORT_OVERHEAD_BYTES = 17;
+/** The largest first WebSocket message: the cleartext prefix and Noise message 1. */
+declare const MAX_FIRST_MESSAGE_BYTES: number;
+/** The close code a server or client uses for an authentication refusal; the close reason is the error code. */
+declare const CLOSE_REFUSED = 4401;
+/** The close code for a message this side cannot use, such as a protocol 1 hello; the reason is the error code. */
+declare const CLOSE_BAD_REQUEST = 4400;
+/** A pairing token or setup ticket as people and commands carry it: 43 base64url characters of 32 random bytes. */
+declare function newSecret(): string;
+/** The 32 bytes of a pairing token or setup ticket, or null when `text` is not one. */
+declare function decodeSecret(text: string): Buffer | null;
+interface SecretValues {
+  /** The Noise PSK: `SHA-256("stim noise psk v1" || t)`. */
+  psk: Buffer;
+  /** Names the secret in the cleartext prefix: `SHA-256("stim noise lookup v1" || t)[0..16]`. */
+  lookup: Buffer;
+  /** The setup journal's file name and URL path, lowercase hex of `SHA-256("stim setup journal v1" || t)`. */
+  journal: string;
+}
+/** The values both sides derive from a secret's 32 bytes. None reveals `psk` or the secret. */
+declare function secretValues(secret: Uint8Array): SecretValues;
+/** A server key's fingerprint, as the pairing QR code carries it: base64url of the key's SHA-256. */
+declare function keyFingerprint(publicKey: Uint8Array): string;
+/** The cleartext prefix of the first WebSocket message. */
+declare function handshakePrefix(mode: HandshakeMode, lookup?: Uint8Array): Buffer;
+type ParsedFirstMessage = {
+  mode: typeof MODE_RETURNING;
+  prefix: Buffer;
+  message: Buffer;
+} | {
+  mode: typeof MODE_FIRST_CONTACT;
+  prefix: Buffer;
+  lookup: Buffer;
+  message: Buffer;
+} | {
+  error: "protocol-unsupported" | "handshake-failed";
+};
+/** Splits the first WebSocket message into its prefix and Noise message 1. */
+declare function parseFirstMessage(data: Uint8Array): ParsedFirstMessage;
+/** `"stim noise v1" || prefix`, so the handshake authenticates the version, mode and lookup. */
+declare function handshakePrologue(prefix: Uint8Array): Buffer;
+/**
+ * The long-term X25519 key in `file`, created with mode 0600 the first time. A file that exists but does not hold a
+ * 32-byte key throws instead of being replaced, because a new key makes every pinned peer refuse this side.
+ */
+declare function readOrCreateKeyFile(file: string): NoiseKeyPair;
+/** The subset of a `ws` WebSocket that a Noise session runs on. */
+interface RawSocket {
+  readonly readyState: number;
+  readonly bufferedAmount: number;
+  /** Bytes go as a binary message and a string as a text message, as `ws` sends them. */
+  send(data: Buffer | string, callback?: (error?: Error) => void): void;
+  close(code?: number, reason?: string): void;
+  terminate(): void;
+  ping?(): void;
+  on(event: "message", listener: (data: unknown, isBinary: boolean) => void): unknown;
+  on(event: "close", listener: (code: number, reason: Buffer) => void): unknown;
+  on(event: "error", listener: (error: Error) => void): unknown;
+  on(event: "pong", listener: () => void): unknown;
+  off(event: "message", listener: (data: unknown, isBinary: boolean) => void): unknown;
+  off(event: "close", listener: (code: number, reason: Buffer) => void): unknown;
+  off(event: "error", listener: (error: Error) => void): unknown;
+}
+/** Why a handshake did not complete. `code` is the server's close reason when it refused this client. */
+declare class HandshakeRefusal extends Error {
+  override name: string;
+  readonly code: string;
+  constructor(code: string, message: string);
+}
+/**
+ * One authenticated, encrypted connection over a WebSocket, with the subset of `ws`'s WebSocket API Stim uses.
+ * `send` takes a string for a text message and bytes for a binary one; `message` listeners get the plaintext as a
+ * Buffer and whether it was binary. A message that fails to decrypt closes the connection. A socket error is emitted
+ * only to `error` listeners; without one it is dropped, since the socket also closes and `close` reports that.
+ */
+declare class NoiseSocket extends EventEmitter {
+  #private;
+  readonly CONNECTING = 0;
+  readonly OPEN = 1;
+  readonly CLOSING = 2;
+  readonly CLOSED = 3;
+  /** The authenticated static public key of the other side. */
+  readonly remoteKey: Buffer;
+  constructor(raw: RawSocket, transport: NoiseTransport, remoteKey: Buffer);
+  get readyState(): number;
+  get bufferedAmount(): number;
+  /**
+   * Sends a string as a text message or bytes as a binary message. A message over this side's limit closes the
+   * connection with 1009, as a WebSocket peer does for an oversized frame.
+   */
+  send(data: string | Uint8Array, options?: {
+    binary?: boolean;
+  } | ((error?: Error) => void), callback?: (error?: Error) => void): void;
+  close(code?: number, reason?: string): void;
+  terminate(): void;
+  ping(): void;
+}
+interface InitiateOptions {
+  keyPair: NoiseKeyPair;
+  /** The server key pinned at pairing; the handshake fails unless the server proves it holds this key. */
+  serverKey?: Uint8Array;
+  /** A pairing token or setup ticket's 32 bytes, for first contact. Without it, the client must pin `serverKey`. */
+  secret?: Uint8Array;
+  /** The device name first contact records; sent encrypted in message 3. */
+  name?: string;
+  /** Accepts a server key on first contact, such as one matching a QR code's fingerprint. */
+  acceptServerKey?: (key: Buffer) => boolean;
+  timeoutMs: number;
+  /** Largest message this client sends and receives; defaults to the client side of the spec's limits. */
+  maxSendBytes?: number;
+  maxReceiveBytes?: number;
+}
+/**
+ * Runs the client side of the protocol 2 handshake on an open WebSocket. It rejects with {@link HandshakeRefusal} and
+ * closes the socket when the server refuses or the handshake fails; the server's close reason names why.
+ */
+declare function initiateNoise(raw: RawSocket, options: InitiateOptions): Promise<NoiseSocket>;
+/** What the server learned from a completed handshake, before it decides whether to keep the connection. */
+interface AcceptedHandshake {
+  socket: NoiseSocket;
+  mode: HandshakeMode;
+  /** The first-contact secret's lookup, as hex. */
+  lookup?: string;
+  clientKey: Buffer;
+  /** Message 3's payload: the first-contact JSON `{ "name": ... }`, or empty. */
+  payload: Buffer;
+}
+interface AcceptOptions {
+  keyPair: NoiseKeyPair;
+  /** The PSK of the secret `lookup` (hex) names, or null when no valid secret matches. */
+  psk: (lookup: string) => Buffer | null;
+  timeoutMs: number;
+  /** X25519 in place of node:crypto's, as `HandshakeOptions.dh` takes it. */
+  dh?: NoiseDh;
+  maxSendBytes?: number;
+  maxReceiveBytes?: number;
+}
+/** The message a protocol 1 client gets: in cleartext, since it cannot decrypt, then the socket closes. */
+declare const PROTOCOL_UNSUPPORTED_MESSAGE: string;
+/**
+ * Runs the server side of the handshake on the first message a client sent. It closes the socket and rejects with
+ * {@link HandshakeRefusal} when the client speaks another protocol, names no valid secret (`unknown-secret`), or fails
+ * the handshake. A text first message, a protocol 1 hello, gets a cleartext `protocol-unsupported` reply.
+ */
+declare function acceptNoise(raw: RawSocket, first: unknown, isBinary: boolean, options: AcceptOptions): Promise<AcceptedHandshake>;
+//#endregion
+export { AcceptOptions, AcceptedHandshake, CLOSE_BAD_REQUEST, CLOSE_REFUSED, HandshakeMode, HandshakeRefusal, InitiateOptions, LOOKUP_BYTES, MAX_CLIENT_MESSAGE_BYTES, MAX_FIRST_MESSAGE_BYTES, MAX_SERVER_MESSAGE_BYTES, MODE_FIRST_CONTACT, MODE_RETURNING, NoiseSocket, PROTOCOL_UNSUPPORTED_MESSAGE, ParsedFirstMessage, RawSocket, SECRET_BYTES, STIM_PROTOCOL_VERSION, SecretValues, TRANSPORT_OVERHEAD_BYTES, acceptNoise, decodeSecret, handshakePrefix, handshakePrologue, initiateNoise, keyFingerprint, newSecret, parseFirstMessage, readOrCreateKeyFile, secretValues };

package/dist/noise-session.mjs

@@ -0,0 +1,402 @@
+import { HandshakeState, MAX_HANDSHAKE_MESSAGE_BYTES, NOISE_XX, NOISE_XX_PSK2, NoiseError, NoiseTransport, generateNoiseKeyPair, noiseKeyPairFromPrivateKey } from "./noise.mjs";
+import { linkSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { createHash, randomBytes } from "node:crypto";
+import { EventEmitter } from "node:events";
+//#region noise-session.ts
+/** The protocol version byte that opens every protocol 2 connection. */
+const STIM_PROTOCOL_VERSION = 2;
+/** A client the server already has a record for: `Noise_XX`, nothing after the mode byte. */
+const MODE_RETURNING = 0;
+/** A client spending a pairing token or setup ticket: `Noise_XXpsk2`, with the secret's `lookup` after the mode byte. */
+const MODE_FIRST_CONTACT = 1;
+const SECRET_BYTES = 32;
+const LOOKUP_BYTES = 16;
+/** Largest message, plaintext without its type byte, a server accepts from a client. */
+const MAX_CLIENT_MESSAGE_BYTES = 65536;
+/** Largest message, plaintext without its type byte, a server sends. */
+const MAX_SERVER_MESSAGE_BYTES = 16777216;
+/** What a transport message adds to its plaintext on the wire: the type byte and the ChaCha20-Poly1305 tag. */
+const TRANSPORT_OVERHEAD_BYTES = 17;
+const MAX_PREFIX_BYTES = 18;
+/** The largest first WebSocket message: the cleartext prefix and Noise message 1. */
+const MAX_FIRST_MESSAGE_BYTES = MAX_PREFIX_BYTES + MAX_HANDSHAKE_MESSAGE_BYTES;
+/** How many messages a connection holds before its first `message` listener; a peer that sends more is closed. */
+const MAX_HELD_MESSAGES = 64;
+/** The close code a server or client uses for an authentication refusal; the close reason is the error code. */
+const CLOSE_REFUSED = 4401;
+/** The close code for a message this side cannot use, such as a protocol 1 hello; the reason is the error code. */
+const CLOSE_BAD_REQUEST = 4400;
+const PROLOGUE = Buffer.from("stim noise v1", "ascii");
+const SECRET_PATTERN = /^[A-Za-z0-9_-]{43}$/;
+/** A pairing token or setup ticket as people and commands carry it: 43 base64url characters of 32 random bytes. */
+function newSecret() {
+	return randomBytes(32).toString("base64url");
+}
+/** The 32 bytes of a pairing token or setup ticket, or null when `text` is not one. */
+function decodeSecret(text) {
+	if (!SECRET_PATTERN.test(text)) return null;
+	const bytes = Buffer.from(text, "base64url");
+	return bytes.length === 32 && bytes.toString("base64url") === text ? bytes : null;
+}
+const sha256 = (...parts) => {
+	const hash = createHash("sha256");
+	for (const part of parts) hash.update(part);
+	return hash.digest();
+};
+/** The values both sides derive from a secret's 32 bytes. None reveals `psk` or the secret. */
+function secretValues(secret) {
+	if (secret.length !== 32) throw new RangeError("A pairing token or setup ticket is 32 bytes");
+	return {
+		psk: sha256(Buffer.from("stim noise psk v1", "ascii"), secret),
+		lookup: sha256(Buffer.from("stim noise lookup v1", "ascii"), secret).subarray(0, 16),
+		journal: sha256(Buffer.from("stim setup journal v1", "ascii"), secret).toString("hex")
+	};
+}
+/** A server key's fingerprint, as the pairing QR code carries it: base64url of the key's SHA-256. */
+function keyFingerprint(publicKey) {
+	return sha256(publicKey).toString("base64url");
+}
+/** The cleartext prefix of the first WebSocket message. */
+function handshakePrefix(mode, lookup) {
+	if (mode === 1 !== (lookup !== void 0)) throw new TypeError("Only first contact sends lookup");
+	if (lookup && lookup.length !== 16) throw new RangeError("lookup is 16 bytes");
+	return Buffer.concat([Uint8Array.of(2, mode), lookup ?? Buffer.alloc(0)]);
+}
+/** Splits the first WebSocket message into its prefix and Noise message 1. */
+function parseFirstMessage(data) {
+	const bytes = Buffer.from(data);
+	if (bytes.length < 1 || bytes[0] !== 2) return { error: "protocol-unsupported" };
+	if (bytes.length > MAX_FIRST_MESSAGE_BYTES) return { error: "handshake-failed" };
+	if (bytes[1] === 0) return {
+		mode: 0,
+		prefix: bytes.subarray(0, 2),
+		message: bytes.subarray(2)
+	};
+	if (bytes[1] === 1 && bytes.length >= MAX_PREFIX_BYTES) return {
+		mode: 1,
+		prefix: bytes.subarray(0, MAX_PREFIX_BYTES),
+		lookup: bytes.subarray(2, MAX_PREFIX_BYTES),
+		message: bytes.subarray(MAX_PREFIX_BYTES)
+	};
+	return { error: "handshake-failed" };
+}
+/** `"stim noise v1" || prefix`, so the handshake authenticates the version, mode and lookup. */
+function handshakePrologue(prefix) {
+	return Buffer.concat([PROLOGUE, prefix]);
+}
+/**
+* The long-term X25519 key in `file`, created with mode 0600 the first time. A file that exists but does not hold a
+* 32-byte key throws instead of being replaced, because a new key makes every pinned peer refuse this side.
+*/
+function readOrCreateKeyFile(file) {
+	const read = () => {
+		const bytes = readFileSync(file);
+		if (bytes.length !== 32) throw new Error(`${file} does not hold a 32-byte X25519 key; move it away to make a new one`);
+		return noiseKeyPairFromPrivateKey(bytes);
+	};
+	try {
+		return read();
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+	}
+	mkdirSync(dirname(file), {
+		recursive: true,
+		mode: 448
+	});
+	const keyPair = generateNoiseKeyPair();
+	const temporary = `${file}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
+	writeFileSync(temporary, keyPair.privateKey, {
+		mode: 384,
+		flag: "wx"
+	});
+	try {
+		linkSync(temporary, file);
+	} catch (error) {
+		if (error.code !== "EEXIST") throw error;
+		return read();
+	} finally {
+		rmSync(temporary, { force: true });
+	}
+	return keyPair;
+}
+function bytesOf(data) {
+	if (Buffer.isBuffer(data)) return data;
+	if (Array.isArray(data)) return Buffer.concat(data);
+	if (data instanceof ArrayBuffer) return Buffer.from(data);
+	return Buffer.from(data);
+}
+/** Why a handshake did not complete. `code` is the server's close reason when it refused this client. */
+var HandshakeRefusal = class extends Error {
+	name = "HandshakeRefusal";
+	code;
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+	}
+};
+const REFUSAL_MESSAGES = {
+	"unknown-secret": "The machine does not know this pairing token or setup ticket yet, or it expired.",
+	unauthorized: "The machine does not recognize this client. Pair again.",
+	"protocol-unsupported": "The machine speaks another stim-server protocol. Update it and this client, then pair again.",
+	"handshake-failed": "The authentication handshake failed.",
+	"server-key-mismatch": "The machine answered with a different server key than the one pinned at pairing. Pair again."
+};
+/**
+* One authenticated, encrypted connection over a WebSocket, with the subset of `ws`'s WebSocket API Stim uses.
+* `send` takes a string for a text message and bytes for a binary one; `message` listeners get the plaintext as a
+* Buffer and whether it was binary. A message that fails to decrypt closes the connection. A socket error is emitted
+* only to `error` listeners; without one it is dropped, since the socket also closes and `close` reports that.
+*/
+var NoiseSocket = class extends EventEmitter {
+	CONNECTING = 0;
+	OPEN = 1;
+	CLOSING = 2;
+	CLOSED = 3;
+	/** The authenticated static public key of the other side. */
+	remoteKey;
+	#raw;
+	#transport;
+	/** Messages that arrive before the first `message` listener, such as a hello sent right after message 3. */
+	#held = [];
+	constructor(raw, transport, remoteKey) {
+		super();
+		this.#raw = raw;
+		this.#transport = transport;
+		this.remoteKey = remoteKey;
+		raw.on("message", (data, isBinary) => {
+			if (!isBinary) return void raw.close(CLOSE_BAD_REQUEST, "handshake-failed");
+			let message;
+			try {
+				message = transport.decrypt(bytesOf(data));
+			} catch {
+				raw.close(CLOSE_BAD_REQUEST, "decrypt-failed");
+				return;
+			}
+			const event = message.type === "text" ? [Buffer.from(message.data, "utf8"), false] : [message.data, true];
+			if (!this.#held) return void this.emit("message", ...event);
+			if (this.#held.length >= MAX_HELD_MESSAGES) return void raw.close(1008, "too many messages");
+			this.#held.push(event);
+		});
+		this.on("newListener", (event) => {
+			if (event !== "message" || !this.#held) return;
+			const held = this.#held;
+			this.#held = null;
+			queueMicrotask(() => {
+				for (const each of held) this.emit("message", ...each);
+			});
+		});
+		raw.on("close", (code, reason) => this.emit("close", code, reason));
+		raw.on("error", (error) => {
+			if (this.listenerCount("error")) this.emit("error", error);
+		});
+		raw.on("pong", () => this.emit("pong"));
+	}
+	get readyState() {
+		return this.#raw.readyState;
+	}
+	get bufferedAmount() {
+		return this.#raw.bufferedAmount;
+	}
+	/**
+	* Sends a string as a text message or bytes as a binary message. A message over this side's limit closes the
+	* connection with 1009, as a WebSocket peer does for an oversized frame.
+	*/
+	send(data, options, callback) {
+		const done = typeof options === "function" ? options : callback;
+		const binary = typeof options === "object" ? options.binary : void 0;
+		if (this.#raw.readyState !== this.OPEN) return void done?.(/* @__PURE__ */ new Error("The connection is not open"));
+		let frame;
+		try {
+			frame = this.#transport.encrypt(typeof data !== "string" && binary === false ? Buffer.from(data).toString() : data);
+		} catch (error) {
+			this.#raw.close(error instanceof RangeError ? 1009 : 1011, "message not sent");
+			done?.(error);
+			return;
+		}
+		this.#raw.send(frame, done);
+	}
+	close(code, reason) {
+		this.#raw.close(code, reason);
+	}
+	terminate() {
+		this.#raw.terminate();
+	}
+	ping() {
+		this.#raw.ping?.();
+	}
+};
+/**
+* Runs the client side of the protocol 2 handshake on an open WebSocket. It rejects with {@link HandshakeRefusal} and
+* closes the socket when the server refuses or the handshake fails; the server's close reason names why.
+*/
+function initiateNoise(raw, options) {
+	const first = options.secret !== void 0;
+	if (!first && !options.serverKey) throw new TypeError("A returning client pins the server key");
+	const values = first ? secretValues(options.secret) : null;
+	const prefix = values ? handshakePrefix(1, values.lookup) : handshakePrefix(0);
+	const handshake = new HandshakeState({
+		protocol: values ? NOISE_XX_PSK2 : NOISE_XX,
+		initiator: true,
+		prologue: handshakePrologue(prefix),
+		staticKeyPair: options.keyPair,
+		...values ? { psk: values.psk } : {}
+	});
+	return new Promise((resolve, reject) => {
+		const cleanup = () => {
+			clearTimeout(timer);
+			raw.off("message", onMessage);
+			raw.off("close", onClose);
+			raw.off("error", onError);
+		};
+		const fail = (code, detail) => {
+			cleanup();
+			if (raw.readyState === 1) raw.close(CLOSE_REFUSED, code);
+			reject(new HandshakeRefusal(code, detail ?? REFUSAL_MESSAGES[code] ?? `The machine refused the connection (${code}).`));
+		};
+		const onClose = (code, reason) => {
+			const text = reason.toString();
+			fail(text || "closed", text ? void 0 : `The connection closed during the handshake (${code}).`);
+		};
+		const onError = (error) => fail("closed", error.message);
+		const onMessage = (data, isBinary) => {
+			if (!isBinary) {
+				const refusal = plaintextRefusal(bytesOf(data));
+				return fail(refusal?.code ?? "handshake-failed", refusal?.message);
+			}
+			try {
+				if (handshake.readMessage(bytesOf(data)).length) return fail("handshake-failed");
+			} catch {
+				return fail("handshake-failed");
+			}
+			const serverKey = handshake.remoteStaticPublicKey;
+			if (options.serverKey ? !serverKey.equals(Buffer.from(options.serverKey)) : options.acceptServerKey?.(serverKey) === false) return fail("server-key-mismatch");
+			const payload = first ? Buffer.from(JSON.stringify({ name: options.name ?? "" }), "utf8") : void 0;
+			let message3;
+			try {
+				message3 = handshake.writeMessage(payload);
+			} catch {
+				return fail("handshake-failed");
+			}
+			cleanup();
+			raw.send(message3);
+			const { send, receive } = handshake.split();
+			resolve(new NoiseSocket(raw, new NoiseTransport({
+				send,
+				receive,
+				maxSendBytes: options.maxSendBytes ?? 65536,
+				maxReceiveBytes: options.maxReceiveBytes ?? 16777216
+			}), serverKey));
+		};
+		const timer = setTimeout(() => fail("timeout", "The machine did not finish the handshake in time."), options.timeoutMs);
+		raw.on("message", onMessage);
+		raw.on("close", onClose);
+		raw.on("error", onError);
+		try {
+			raw.send(Buffer.concat([prefix, handshake.writeMessage()]));
+		} catch {
+			fail("handshake-failed");
+		}
+	});
+}
+function plaintextRefusal(data) {
+	try {
+		const message = JSON.parse(data.toString("utf8"));
+		return typeof message.error?.code === "string" && typeof message.error.message === "string" ? {
+			code: message.error.code,
+			message: message.error.message
+		} : null;
+	} catch {
+		return null;
+	}
+}
+/** The message a protocol 1 client gets: in cleartext, since it cannot decrypt, then the socket closes. */
+const PROTOCOL_UNSUPPORTED_MESSAGE = "This stim-server speaks protocol 2, with its own authentication. Update this app or Stim, then pair again.";
+/**
+* Runs the server side of the handshake on the first message a client sent. It closes the socket and rejects with
+* {@link HandshakeRefusal} when the client speaks another protocol, names no valid secret (`unknown-secret`), or fails
+* the handshake. A text first message, a protocol 1 hello, gets a cleartext `protocol-unsupported` reply.
+*/
+function acceptNoise(raw, first, isBinary, options) {
+	return new Promise((resolve, reject) => {
+		const refuse = (code, closeCode = CLOSE_REFUSED) => {
+			clearTimeout(timer);
+			raw.off("message", onMessage);
+			raw.off("close", onClose);
+			if (raw.readyState === 1) raw.close(closeCode, code);
+			reject(new HandshakeRefusal(code, REFUSAL_MESSAGES[code] ?? code));
+		};
+		const onClose = () => refuse("closed");
+		let handshake = null;
+		let parsed;
+		const onMessage = (data, binary) => {
+			if (!binary || !handshake) return refuse("handshake-failed");
+			let payload;
+			try {
+				payload = handshake.readMessage(bytesOf(data));
+			} catch {
+				return refuse("handshake-failed");
+			}
+			clearTimeout(timer);
+			raw.off("message", onMessage);
+			raw.off("close", onClose);
+			const { send, receive } = handshake.split();
+			const clientKey = handshake.remoteStaticPublicKey;
+			resolve({
+				socket: new NoiseSocket(raw, new NoiseTransport({
+					send,
+					receive,
+					maxSendBytes: options.maxSendBytes ?? 16777216,
+					maxReceiveBytes: options.maxReceiveBytes ?? 65536
+				}), clientKey),
+				mode: parsed.mode,
+				...parsed.mode === 1 ? { lookup: parsed.lookup.toString("hex") } : {},
+				clientKey,
+				payload
+			});
+		};
+		const timer = setTimeout(() => refuse("timeout"), options.timeoutMs);
+		raw.on("close", onClose);
+		if (!isBinary) {
+			const bytes = bytesOf(first);
+			let id = null;
+			try {
+				id = JSON.parse(bytes.toString("utf8")).id ?? null;
+			} catch {
+				id = null;
+			}
+			const reply = {
+				id: typeof id === "number" || typeof id === "string" ? id : null,
+				error: {
+					code: "protocol-unsupported",
+					message: PROTOCOL_UNSUPPORTED_MESSAGE
+				}
+			};
+			if (raw.readyState === 1) raw.send(JSON.stringify(reply));
+			return refuse("protocol-unsupported", CLOSE_BAD_REQUEST);
+		}
+		const message = parseFirstMessage(bytesOf(first));
+		if ("error" in message) return refuse(message.error, message.error === "protocol-unsupported" ? CLOSE_BAD_REQUEST : CLOSE_REFUSED);
+		parsed = message;
+		const psk = message.mode === 1 ? options.psk(message.lookup.toString("hex")) : null;
+		if (message.mode === 1 && !psk) return refuse("unknown-secret");
+		try {
+			handshake = new HandshakeState({
+				protocol: psk ? NOISE_XX_PSK2 : NOISE_XX,
+				initiator: false,
+				prologue: handshakePrologue(message.prefix),
+				staticKeyPair: options.keyPair,
+				...psk ? { psk } : {},
+				...options.dh ? { dh: options.dh } : {}
+			});
+			if (handshake.readMessage(message.message).length) return refuse("handshake-failed");
+			raw.send(handshake.writeMessage());
+		} catch (error) {
+			if (!(error instanceof NoiseError)) throw error;
+			return refuse("handshake-failed");
+		}
+		raw.on("message", onMessage);
+	});
+}
+//#endregion
+export { CLOSE_BAD_REQUEST, CLOSE_REFUSED, HandshakeRefusal, LOOKUP_BYTES, MAX_CLIENT_MESSAGE_BYTES, MAX_FIRST_MESSAGE_BYTES, MAX_SERVER_MESSAGE_BYTES, MODE_FIRST_CONTACT, MODE_RETURNING, NoiseSocket, PROTOCOL_UNSUPPORTED_MESSAGE, SECRET_BYTES, STIM_PROTOCOL_VERSION, TRANSPORT_OVERHEAD_BYTES, acceptNoise, decodeSecret, handshakePrefix, handshakePrologue, initiateNoise, keyFingerprint, newSecret, parseFirstMessage, readOrCreateKeyFile, secretValues };

package/dist/noise.d.mts

@@ -0,0 +1,2 @@
+import { a as NOISE_XX, c as NoiseError, d as NoiseProtocolName, f as NoiseTransport, h as noiseKeyPairFromPrivateKey, i as MAX_HANDSHAKE_MESSAGE_BYTES, l as NoiseKeyPair, m as generateNoiseKeyPair, n as HandshakeOptions, o as NOISE_XX_PSK2, p as NoiseTransportOptions, r as HandshakeState, s as NoiseDh, t as CipherState, u as NoiseMessage } from "./noise-DYIbymAJ.mjs";
+export { CipherState, HandshakeOptions, HandshakeState, MAX_HANDSHAKE_MESSAGE_BYTES, NOISE_XX, NOISE_XX_PSK2, NoiseDh, NoiseError, NoiseKeyPair, NoiseMessage, NoiseProtocolName, NoiseTransport, NoiseTransportOptions, generateNoiseKeyPair, noiseKeyPairFromPrivateKey };