@corewire/core 0.0.0 → 1.0.0-next.2

package/dist/encoding.d.mts

@@ -0,0 +1,411 @@
+declare namespace daap_d_exports {
+  export { ContentCode, ContentCodeKey, DecodedTag, PlaybackStatus, TagType, TrackMetadata, decode$4 as decode, decodeTag, decodeToObject, decodeTrackMetadata, encodeContainer, encodePlaybackStatus, encodeTag, encodeTagWithSize, encodeTrackMetadata };
+}
+/**
+* Maps four-character DAAP tag codes to their DMAP/DAAP content code names.
+*/
+declare const ContentCode: {
+  readonly mlit: "dmap.listingitem";
+  readonly mlcl: "dmap.listing";
+  readonly msrv: "dmap.serverinforesponse";
+  readonly mcon: "dmap.container";
+  readonly miid: "dmap.itemid";
+  readonly minm: "dmap.itemname";
+  readonly mikd: "dmap.itemkind";
+  readonly mper: "dmap.persistentid";
+  readonly asal: "daap.songalbum";
+  readonly asar: "daap.songartist";
+  readonly asaa: "daap.songalbumartist";
+  readonly ascp: "daap.songcomposer";
+  readonly asgn: "daap.songgenre";
+  readonly astm: "daap.songtime";
+  readonly astn: "daap.songtracknumber";
+  readonly asdc: "daap.songdisccount";
+  readonly asdn: "daap.songdiscnumber";
+  readonly astc: "daap.songtrackcount";
+  readonly asyr: "daap.songyear";
+  readonly asbr: "daap.songbitrate";
+  readonly assr: "daap.songsamplerate";
+  readonly assz: "daap.songsize";
+  readonly caps: "daap.songplaystatus";
+  readonly cash: "daap.songshufflestate";
+  readonly carp: "daap.songrepeatstate";
+  readonly cavs: "daap.songvisiblestate";
+  readonly aePP: "com.apple.itunes.photo-properties";
+};
+/**
+* Maps four-character DAAP tag codes to the type the decoder reads their value as.
+*
+* Type values: 1=byte, 2=unsigned byte, 3=short, 4=unsigned short,
+* 5=int, 6=unsigned int, 7=long, 8=unsigned long,
+* 9=string, 10=date, 11=version, 12=container.
+*/
+declare const TagType: {
+  readonly mlit: 12;
+  readonly mlcl: 12;
+  readonly mcon: 12;
+  readonly msrv: 12;
+  readonly miid: 5;
+  readonly minm: 9;
+  readonly mikd: 1;
+  readonly mper: 7;
+  readonly asal: 9;
+  readonly asar: 9;
+  readonly asaa: 9;
+  readonly ascp: 9;
+  readonly asgn: 9;
+  readonly astm: 5;
+  readonly astn: 3;
+  readonly asdc: 3;
+  readonly asdn: 3;
+  readonly astc: 3;
+  readonly asyr: 3;
+  readonly asbr: 3;
+  readonly assr: 5;
+  readonly assz: 5;
+  readonly caps: 1;
+  readonly cash: 1;
+  readonly carp: 1;
+  readonly cavs: 1;
+  readonly aePP: 9;
+};
+/**
+* Encodes a single DAAP tag. A number takes the smallest big-endian size that fits.
+*
+* @param tag - Four-character ASCII tag code, such as `minm`.
+* @param value - A string is written as UTF-8, a bigint as 8 bytes and a Buffer as is.
+* @throws Error if the tag is not exactly 4 characters.
+*/
+declare function encodeTag(tag: string, value: Buffer | string | number | bigint): Buffer;
+/**
+* Encodes a DAAP container tag around tags that are already encoded.
+*
+* @param tag - Four-character ASCII container tag code, such as `mlit`.
+* @throws Error if the tag is not exactly 4 characters.
+*/
+declare function encodeContainer(tag: string, content: Buffer): Buffer;
+/**
+* Encodes the playback status into DAAP tags, one tag per defined field.
+*/
+declare function encodePlaybackStatus(status: PlaybackStatus): Buffer;
+/**
+* Encodes a numeric DAAP tag with a fixed value size, for tags whose size the protocol fixes.
+*
+* @param tag - Four-character ASCII tag code.
+* @param byteSize - Size of the big-endian value in bytes.
+* @throws Error if the tag is not exactly 4 characters.
+*/
+declare function encodeTagWithSize(tag: string, value: number, byteSize: 1 | 2 | 4 | 8): Buffer;
+/**
+* Encodes track metadata into a DAAP listing item (`mlit`), one tag per defined field.
+* The duration goes from seconds to the milliseconds of `astm`.
+*/
+declare function encodeTrackMetadata(metadata: TrackMetadata): Buffer;
+/**
+* Decodes the DAAP tags in a buffer, up to its end or the first incomplete tag.
+*/
+declare function decode$4(buffer: Buffer): DecodedTag[];
+/**
+* Decodes the DAAP tag at the start of a buffer.
+*
+* @returns The tag and the rest of the buffer, or null when the buffer holds no complete tag.
+*/
+declare function decodeTag(buffer: Buffer): [DecodedTag, Buffer] | null;
+/**
+* Decodes a DAAP buffer into an object keyed by tag code, with values read as {@link TagType} says.
+* Containers decode recursively; a tag of unknown type keeps its raw buffer.
+*/
+declare function decodeToObject(buffer: Buffer): Record<string, unknown>;
+/**
+* Decodes track metadata from a bare tag list or an `mlit` container.
+* The duration goes from the milliseconds of `astm` back to seconds.
+*/
+declare function decodeTrackMetadata(buffer: Buffer): TrackMetadata;
+/** A four-character DAAP content code from {@link ContentCode}. */
+type ContentCodeKey = keyof typeof ContentCode;
+/** A decoded DAAP tag with its raw value bytes. */
+type DecodedTag = {
+  readonly tag: string; /** The length of the value in bytes. */
+  readonly length: number;
+  readonly value: Buffer;
+};
+/** The playback state that DAAP sends as `caps`, `cash` and `carp`. */
+type PlaybackStatus = {
+  readonly playing?: boolean;
+  readonly shuffle?: boolean;
+  readonly repeat?: "off" | "one" | "all";
+};
+/** The metadata of a track, with the DAAP tag that carries each field. */
+type TrackMetadata = {
+  /** The title, sent as `minm`. */readonly title?: string; /** The artist, sent as `asar`. */
+  readonly artist?: string; /** The album artist, sent as `asaa`. */
+  readonly albumArtist?: string; /** The album name, sent as `asal`. */
+  readonly album?: string; /** The composer, sent as `ascp`. */
+  readonly composer?: string; /** The genre, sent as `asgn`. */
+  readonly genre?: string; /** The duration in seconds, sent as milliseconds in `astm`. */
+  readonly duration?: number; /** The track number on the album, sent as `astn`. */
+  readonly trackNumber?: number; /** The number of tracks on the album, sent as `astc`. */
+  readonly trackCount?: number; /** The disc number in the set, sent as `asdn`. */
+  readonly discNumber?: number; /** The number of discs in the set, sent as `asdc`. */
+  readonly discCount?: number; /** The release year, sent as `asyr`. */
+  readonly year?: number; /** The bitrate in kbps, sent as `asbr`. */
+  readonly bitrate?: number; /** The sample rate in Hz, sent as `assr`. */
+  readonly sampleRate?: number; /** The file size in bytes, sent as `assz`. */
+  readonly size?: number;
+};
+declare namespace nskeyedarchiver_d_exports {
+  export { decode$3 as decode, decodeAsArray };
+}
+/**
+* Decodes an NSKeyedArchiver plist into plain objects. It resolves `CF$UID` references, turns
+* NSArray and NSDictionary into arrays and objects, and drops the class metadata.
+*
+* @param archive - The parsed plist, with `$objects` and `$top`.
+* @returns The root object, or null when the archive lacks `$objects` or `$top`.
+*/
+declare function decode$3(archive: any): unknown;
+/** Like {@link decode}, but wraps a root that is not an array in a single-element array. */
+declare function decodeAsArray(archive: any): unknown[];
+declare namespace ntp_d_exports {
+  export { PacketFields, decode$2 as decode, encode$2 as encode, now, parts };
+}
+/**
+* Returns the wall-clock time as a 64-bit NTP timestamp: whole seconds since 1900 in the upper
+* 32 bits, the fraction in the lower 32 bits.
+*
+* It reads `Date.now()` instead of a monotonic clock, because Apple devices expect NTP
+* timestamps anchored to real time.
+*/
+declare function now(): bigint;
+/** Splits a 64-bit NTP timestamp into `[seconds, fraction]`, both 32-bit unsigned integers. */
+declare function parts(ntp: bigint): [number, number];
+/**
+* Decodes an NTP timing packet. The send timestamp (bytes 24 to 31) reads as 0 when the packet
+* stops before it.
+*
+* @throws {RangeError} When the packet is shorter than 24 bytes.
+*/
+declare function decode$2(buffer: Buffer): PacketFields;
+/** Encodes a 32-byte NTP timing packet. */
+declare function encode$2(fields: PacketFields): Buffer;
+/**
+* The fields of an AirPlay NTP timing packet. Each timestamp is split into whole seconds since
+* 1900 (`_sec`) and a 32-bit fraction (`_frac`).
+*/
+type PacketFields = {
+  readonly proto: number;
+  readonly type: number;
+  readonly seqno: number;
+  readonly padding: number;
+  readonly reftime_sec: number;
+  readonly reftime_frac: number;
+  readonly recvtime_sec: number;
+  readonly recvtime_frac: number;
+  readonly sendtime_sec: number;
+  readonly sendtime_frac: number;
+};
+declare namespace opack_d_exports {
+  export { decode$1 as decode, encode$1 as encode, float, int, sizedInteger };
+}
+/**
+* A number that OPack encodes as FLOAT64. A plain number with an integer value
+* would encode as an OPack integer.
+*/
+declare class Float {
+  #private;
+  get value(): number;
+  constructor(value: number);
+}
+/**
+* A number that OPack encodes as an integer in the smallest width that holds it.
+*/
+declare class Integer {
+  #private;
+  get value(): number | bigint;
+  constructor(value: number | bigint);
+}
+/**
+* A signed integer with a fixed width on the wire. The decoder returns one for every sized
+* integer, so encoding it again writes the same width.
+*/
+declare class SizedInteger {
+  #private;
+  /** The width of the integer on the wire in bytes: 1, 2, 4, 8 or 16. */
+  get size(): number;
+  /** The value; a bigint when it lies outside the safe integer range of a number. */
+  get value(): number | bigint;
+  constructor(value: number | bigint, size: number);
+  /**
+  * Returns the value, so the integer works in arithmetic and comparisons.
+  */
+  valueOf(): number | bigint;
+}
+/**
+* Wraps a number so OPack encodes it as FLOAT64, also when it is a whole number.
+*/
+declare function float(value: number): Float;
+/**
+* Wraps an integer so OPack encodes it as an integer in the smallest width that holds it.
+*
+* @throws RangeError if the value is not an integer.
+*/
+declare function int(value: number | bigint): Integer;
+/**
+* Wraps an integer so OPack encodes it with a fixed width.
+*
+* @param size - The width in bytes: 1, 2, 4, 8 or 16. The value must fit as a signed integer.
+* @throws RangeError if the width is not one of these or the value does not fit in it.
+*/
+declare function sizedInteger(value: number | bigint, size: number): SizedInteger;
+/**
+* Decodes OPack bytes into a value. Inline integers come back as numbers, sized integers as
+* {@link sizedInteger} values, dates as `Date`, UUIDs and byte strings as `Uint8Array`.
+*
+* @throws TypeError if the buffer ends early, nests deeper than 32 containers, refers to a
+* value that does not exist or holds a tag OPack does not define.
+*/
+declare function decode$1(data: Uint8Array): any;
+/**
+* Encodes a value as OPack. It takes null, booleans, numbers, bigints, strings, bytes, dates,
+* arrays, plain objects and the wrappers {@link float}, {@link int} and {@link sizedInteger}.
+* A repeated string, byte string of two bytes or more, number outside -1 to 39 or date becomes
+* a reference to its first occurrence; arrays and objects are always written in full.
+*
+* @throws TypeError if the value has an unsupported type or nests deeper than 32 containers.
+* @throws RangeError if an integer does not fit in 128 bits or a date is invalid.
+*/
+declare function encode$1(data: any): Uint8Array;
+//#endregion
+//#region ../../node_modules/.bun/@plist+common@1.1.0/node_modules/@plist/common/lib/cjs/types.d.ts
+declare type Value$1 = null | string | number | bigint | boolean | ArrayBuffer | Date | Dictionary | Value$1[];
+declare type Dictionary = {
+  [key: string]: Value$1;
+};
+//#endregion
+//#region ../../node_modules/.bun/@plist+binary.serialize@1.1.0/node_modules/@plist/binary.serialize/lib/cjs/index.d.ts
+declare const serialize: (value: Value$1) => ArrayBufferLike;
+declare namespace plist_d_exports {
+  export { PlistDictionary, PlistValue, parse, serialize };
+}
+type PlistValue = null | string | number | bigint | boolean | ArrayBuffer | Date | PlistDictionary | PlistValue[];
+type PlistDictionary = {
+  [key: string]: PlistValue;
+};
+/**
+* Parses a binary plist.
+*
+* Integers of 1, 2 and 4 bytes are unsigned; only 8-byte integers carry a sign. A signed
+* read turns 200 into -56 and 44100 into -21436. An 8-byte integer comes back as a `bigint`.
+*
+* @throws Error when the buffer is not a well-formed binary plist.
+*/
+declare function parse(buffer: ArrayBuffer): PlistValue;
+declare namespace tlv8_d_exports {
+  export { ErrorCode, Flags, Method, State, Value, bail, decode, decodeEntries, encode };
+}
+/**
+* TLV8 pairing flags used during HAP pair-setup and pair-verify.
+* Sent as part of the TLV8 Flags (0x13) value.
+*/
+declare const Flags: {
+  readonly TransientPairing: 0x10;
+};
+/**
+* TLV8 error codes returned by the accessory during pairing.
+* Included in the Error (0x07) TLV value.
+*/
+declare const ErrorCode: {
+  readonly Unknown: 0x01;
+  readonly Authentication: 0x02;
+  readonly BackOff: 0x03;
+  readonly MaxPeers: 0x04;
+  readonly MaxTries: 0x05;
+  readonly Unavailable: 0x06;
+  readonly Busy: 0x07;
+};
+/**
+* HAP pairing method identifiers. Sent in the Method (0x00) TLV value
+* to indicate which pairing operation is being performed.
+*/
+declare const Method: {
+  readonly PairSetup: 0x00;
+  readonly PairSetupWithAuth: 0x01;
+  readonly PairVerify: 0x02;
+  readonly AddPairing: 0x03;
+  readonly RemovePairing: 0x04;
+  readonly ListPairing: 0x05;
+};
+/**
+* HAP pairing state machine steps (M1 through M6).
+* Each state corresponds to a message in the SRP pair-setup or pair-verify flow.
+*/
+declare const State: {
+  readonly M1: 0x01;
+  readonly M2: 0x02;
+  readonly M3: 0x03;
+  readonly M4: 0x04;
+  readonly M5: 0x05;
+  readonly M6: 0x06;
+};
+/**
+* TLV8 type identifiers for the fields exchanged during HAP pairing.
+* Each value is the type byte that precedes the length and data in a TLV8 entry.
+*/
+declare const Value: {
+  readonly Method: 0x00;
+  readonly Identifier: 0x01;
+  readonly Salt: 0x02;
+  readonly PublicKey: 0x03;
+  readonly Proof: 0x04;
+  readonly EncryptedData: 0x05;
+  readonly State: 0x06;
+  readonly Error: 0x07;
+  readonly BackOff: 0x08;
+  readonly Certificate: 0x09;
+  readonly Signature: 0x0A;
+  readonly Permissions: 0x0B;
+  readonly FragmentData: 0x0C;
+  readonly FragmentLast: 0x0D;
+  readonly Name: 0x11;
+  readonly Flags: 0x13;
+};
+/** Throws the {@link TLV8PairingError} for the error or back-off in a decoded pairing response. */
+declare function bail(data: Map<number, Buffer>): never;
+/**
+* Encodes `[type, value]` entries; a number value is a single byte. A value longer than 255 bytes
+* becomes consecutive fragments of the same type, as TLV8 requires.
+*/
+declare function encode(entries: [number, number | Buffer | Uint8Array][]): Buffer;
+/**
+* Decodes a TLV8 buffer into a map from type to value, for messages that hold each type once,
+* such as pairing messages. Adjacent entries of the same type are concatenated, which reassembles
+* fragmented values. When a type appears again after another type, the first value wins.
+*
+* @throws {RangeError} When an entry is truncated.
+*/
+declare function decode(buf: Buffer): Map<number, Buffer>;
+/**
+* Decodes a TLV8 buffer into its `[type, value]` entries in order, for lists in which a type
+* repeats. Adjacent entries of the same type are concatenated into one value, which reassembles
+* fragmented values; a separator entry between two items keeps them apart.
+*
+* @throws {RangeError} When an entry is truncated.
+*/
+declare function decodeEntries(buf: Buffer): [number, Buffer][];
+declare namespace rti_d_exports {
+  export { TextInputSession, decodeSession, encodeOperation };
+}
+type TextInputSession = {
+  readonly uuid: Uint8Array;
+  readonly documentText: string;
+  readonly isSecure: boolean;
+  readonly keyboardType: number;
+  readonly autocorrection: boolean;
+  readonly autocapitalization: boolean;
+};
+/** Reads RTIKeyedArchiver roots without exposing bytes outside the supplied view. */
+declare function decodeSession(data: Uint8Array | ArrayBuffer): TextInputSession;
+/** Encodes an RTITextOperations archive that inserts `text`, or clears the field when `clear` is set. */
+declare function encodeOperation(sessionUUID: Uint8Array, text: string, clear: boolean): ArrayBuffer;
+//#endregion
+export { daap_d_exports as DAAP, nskeyedarchiver_d_exports as NSKeyedArchiver, ntp_d_exports as NTP, opack_d_exports as OPack, plist_d_exports as Plist, rti_d_exports as RTI, tlv8_d_exports as TLV8 };

package/dist/encoding.mjs

@@ -0,0 +1,3 @@
+import { f as opack_exports, h as daap_exports, l as tlv8_exports, m as nskeyedarchiver_exports, p as ntp_exports, t as rti_exports, u as plist_exports } from "./encoding-BaLbwFQ0.mjs";
+
+export { daap_exports as DAAP, nskeyedarchiver_exports as NSKeyedArchiver, ntp_exports as NTP, opack_exports as OPack, plist_exports as Plist, rti_exports as RTI, tlv8_exports as TLV8 };

package/dist/errors-DVv1n4fL.mjs

@@ -0,0 +1,125 @@
+//#region src/errors.ts
+/** Base class of the CoreWire errors, so one `instanceof` check catches all of them. */
+var AppleProtocolError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "AppleProtocolError";
+	}
+};
+/** Thrown when a TCP connection fails to open or breaks. */
+var ConnectionError = class extends AppleProtocolError {
+	constructor(message) {
+		super(message);
+		this.name = "ConnectionError";
+	}
+};
+/** Thrown when a TCP connection attempt exceeds the configured socket timeout. */
+var ConnectionTimeoutError = class extends ConnectionError {
+	constructor(message = "Connection timed out.") {
+		super(message);
+		this.name = "ConnectionTimeoutError";
+	}
+};
+/** Thrown when a connection or session closes before an operation finishes, or when an operation runs on a closed one. */
+var ConnectionClosedError = class extends ConnectionError {
+	constructor(message = "Connection closed unexpectedly.") {
+		super(message);
+		this.name = "ConnectionClosedError";
+	}
+};
+/** Thrown when a HAP pair-setup or pair-verify fails. */
+var PairingError = class extends AppleProtocolError {
+	constructor(message) {
+		super(message);
+		this.name = "PairingError";
+	}
+};
+/**
+* Thrown when the accessory's identity verification fails, such as an invalid
+* Ed25519 signature or mismatched accessory identifier during pair-verify.
+*/
+var AuthenticationError = class extends PairingError {
+	constructor(message) {
+		super(message);
+		this.name = "AuthenticationError";
+	}
+};
+/**
+* Thrown when stored credentials are invalid, missing, or incompatible
+* with the accessory (e.g. after a factory reset).
+*/
+var CredentialsError = class extends PairingError {
+	constructor(message) {
+		super(message);
+		this.name = "CredentialsError";
+	}
+};
+/** Thrown when a protocol command fails to execute on the target device. */
+var CommandError = class extends AppleProtocolError {
+	constructor(message) {
+		super(message);
+		this.name = "CommandError";
+	}
+};
+/** Thrown when a protocol setup step fails (e.g. an RTSP SETUP). */
+var SetupError = class extends AppleProtocolError {
+	constructor(message) {
+		super(message);
+		this.name = "SetupError";
+	}
+};
+/** Thrown when mDNS device discovery fails or a device cannot be found after retries. */
+var DiscoveryError = class extends AppleProtocolError {
+	constructor(message) {
+		super(message);
+		this.name = "DiscoveryError";
+	}
+};
+/** Thrown when encrypting or decrypting a message fails. */
+var EncryptionError = class extends AppleProtocolError {
+	constructor(message) {
+		super(message);
+		this.name = "EncryptionError";
+	}
+};
+/** Thrown when a response from the accessory is malformed or has an unexpected format. */
+var InvalidResponseError = class extends AppleProtocolError {
+	constructor(message) {
+		super(message);
+		this.name = "InvalidResponseError";
+	}
+};
+/** Thrown when a protocol operation exceeds its expected time limit. */
+var TimeoutError = class extends AppleProtocolError {
+	constructor(message) {
+		super(message);
+		this.name = "TimeoutError";
+	}
+};
+/** Thrown when a media playback operation fails on the target device. */
+var PlaybackError = class extends AppleProtocolError {
+	constructor(message) {
+		super(message);
+		this.name = "PlaybackError";
+	}
+};
+/** Thrown when the authentication tag of a ChaCha20-Poly1305 message does not match, because the ciphertext changed or the key or nonce is wrong. */
+var DecryptionError = class extends EncryptionError {
+	constructor(message = "Decryption failed: authentication tag mismatch") {
+		super(message);
+		this.name = "DecryptionError";
+	}
+};
+/** Thrown when the accessory answers a pairing message with a TLV8 error or back-off. */
+var TLV8PairingError = class extends PairingError {
+	/** The TLV8 error code of the accessory; undefined when it sent none. */
+	code;
+	constructor(message, code) {
+		super(message);
+		this.name = "TLV8PairingError";
+		this.code = code;
+	}
+};
+
+//#endregion
+export { ConnectionError as a, DecryptionError as c, InvalidResponseError as d, PairingError as f, TimeoutError as g, TLV8PairingError as h, ConnectionClosedError as i, DiscoveryError as l, SetupError as m, AuthenticationError as n, ConnectionTimeoutError as o, PlaybackError as p, CommandError as r, CredentialsError as s, AppleProtocolError as t, EncryptionError as u };

package/dist/index-BJKNwUmq.d.mts

@@ -0,0 +1,125 @@
+import { n as LogSink, r as Logger } from "./reporter-Dn7n2TXN.mjs";
+import { t as EventMap } from "./types-qzabRJJ9.mjs";
+import { EventEmitter } from "node:events";
+
+//#region src/transport/context.d.ts
+/** The name every protocol presents for this client when the identity has none. */
+declare const DEFAULT_CLIENT_NAME = "CoreWire";
+/**
+* Overrides of the identity this client presents to Apple devices during pairing and protocol
+* negotiation. Each protocol fills what is missing with its own defaults.
+*/
+type DeviceIdentity = {
+  /** The name the device shows for this client, such as in its list of paired devices; {@link DEFAULT_CLIENT_NAME} when omitted. */readonly name?: string;
+  readonly model?: string;
+  readonly osName?: string;
+  readonly osVersion?: string;
+  readonly osBuildVersion?: string;
+  readonly sourceVersion?: string;
+  readonly applicationBundleIdentifier?: string;
+  readonly applicationBundleVersion?: string;
+};
+/**
+* Travels through every protocol layer of one device connection, so all layers log under the
+* same device id and present the same identity.
+*/
+declare class Context {
+  #private;
+  /** Identifies the target device, usually by its mDNS host name. */
+  get deviceId(): string;
+  /** The identity overrides this client presents; a protocol fills the rest with its defaults. */
+  get identity(): DeviceIdentity;
+  /** Prefixes its output with the device id. */
+  get logger(): Logger;
+  /**
+  * @param sink - Also receives every log record of this context.
+  */
+  constructor(deviceId: string, identity?: DeviceIdentity, sink?: LogSink);
+}
+//#endregion
+//#region src/transport/types.d.ts
+/** Lifecycle of a {@link Connection}. `failed` is where a connection ends after an error or a timeout. */
+type ConnectionState = "closing" | "connected" | "connecting" | "disconnected" | "failed";
+/**
+* Why a connection ended: we closed it (`local`), the device did (`remote`), the socket did not
+* open in time (`timeout`), or a socket or protocol error broke it (`error`).
+*/
+type CloseReason = "local" | "remote" | "timeout" | "error";
+//#endregion
+//#region src/transport/connection.d.ts
+type ConnectionEventMap = {
+  closed: [reason: CloseReason, error?: Error];
+  connect: [];
+  data: [data: Buffer];
+  error: [error: Error];
+};
+/**
+* One TCP socket to a device, with keep-alive and no-delay. Subclasses extend the event map with
+* protocol events.
+*
+* A connection connects once and ends once. Every way it ends, `disconnect()` and `destroy()`
+* included, emits `closed` with the reason and aborts {@link signal}. Reconnecting takes a new
+* connection, because a fresh socket carries no pairing and no encryption keys. `error` reports
+* problems that do not end the connection by themselves, such as a write after the socket closed.
+*/
+declare class Connection<TEventMap extends EventMap = {}> extends EventEmitter<ConnectionEventMap & TEventMap> {
+  #private;
+  get address(): string;
+  get context(): Context;
+  get port(): number;
+  get isConnected(): boolean;
+  /** The local IP address of the socket, or `0.0.0.0` when it is not connected. */
+  get localAddress(): string;
+  get state(): ConnectionState;
+  /** Aborts with a {@link ConnectionClosedError} when the connection ends. */
+  get signal(): AbortSignal;
+  constructor(context: Context, address: string, port: number);
+  /**
+  * Opens the socket. Returns at once when already connected.
+  *
+  * @throws {ConnectionTimeoutError} If the socket does not open within the socket timeout.
+  * @throws {ConnectionError} If the socket cannot open, or the connection is busy or has ended.
+  */
+  connect(): Promise<void>;
+  /**
+  * Ends the connection right away without a graceful shutdown. Passing an error ends it with
+  * reason `error`, for a subclass that cannot continue after a broken frame.
+  */
+  destroy(error?: Error): void;
+  /** Ends the socket gracefully and resolves once it is closed. */
+  disconnect(): Promise<void>;
+  /** Toggles hex and ASCII dumps of incoming data. */
+  debug(enabled: boolean): this;
+  /** Writes to the socket, or emits `error` when the socket is not writable. */
+  write(data: Buffer | Uint8Array): void;
+}
+//#endregion
+//#region src/transport/encryption.d.ts
+/**
+* Where the 64-bit little-endian message counter sits in the 12-byte ChaCha20 nonce. Companion
+* Link puts it at offset 0, HAP and AirPlay put it at offset 4 behind four zero bytes.
+*/
+type NonceFormat = "counter-at-0" | "counter-at-4";
+/** Builds the 12-byte ChaCha20-Poly1305 nonce for a message counter. */
+declare function buildNonce(counter: number, format: NonceFormat): Buffer;
+/**
+* Connection that can switch to ChaCha20-Poly1305 once pairing yields keys. Subclasses frame and
+* encrypt with the {@link EncryptionState}, because every protocol frames differently.
+*/
+declare class EncryptionAwareConnection<TEventMap extends EventMap> extends Connection<TEventMap> {
+  #private;
+  get isEncrypted(): boolean;
+  /** Keys and counters once {@link enableEncryption} ran; for the subclass that frames the messages. */
+  protected get encryption(): EncryptionState | undefined;
+  enableEncryption(readKey: Buffer, writeKey: Buffer): void;
+}
+/** Keys and per-direction message counters of one encrypted connection. */
+declare class EncryptionState {
+  readKey: Buffer;
+  readCount: number;
+  writeKey: Buffer;
+  writeCount: number;
+  constructor(readKey: Buffer, writeKey: Buffer);
+}
+//#endregion
+export { Connection as a, Context as c, buildNonce as i, DEFAULT_CLIENT_NAME as l, EncryptionState as n, CloseReason as o, NonceFormat as r, ConnectionState as s, EncryptionAwareConnection as t, DeviceIdentity as u };