tesla-fleet-api 0.3.0 → 0.5.0

package/dist/bluetooth/esphome.mjs

@@ -0,0 +1,291 @@
+import { AsyncLock, withTimeout } from "./async.mjs";
+import { APPEARANCE_UUID, CCCD_UUID, DEFAULT_SCAN_TIMEOUT_MS, GENERIC_ACCESS_UUID, NAME_UUID, SERVICE_UUID, VEHICLE_NOTIFY_UUID, VEHICLE_WRITE_UUID, VERSION_UUID } from "./constants.mjs";
+import { BleNotSubmittedError } from "./transport.mjs";
+import { LinkClaims, compactUuid, quietly } from "./adapters/shared.mjs";
+// src/bluetooth/adapters/esphome.ts
+/** The bytes that turn notifications on in a CCCD. */
+const CCCD_ENABLE_NOTIFICATIONS = Buffer.from([1, 0]);
+/** How long a proxy takes to answer a connect. The package's own wait is the same. */
+const DEVICE_CONNECT_WAIT_MS = 1e4;
+/** How long the API connection to the proxy may take. */
+const API_CONNECT_TIMEOUT_MS = 1e4;
+const ADVERTISEMENT = "message.BluetoothLEAdvertisementResponse";
+const CONNECTION_STATE = "message.BluetoothDeviceConnectionResponse";
+const NOTIFY_DATA = "message.BluetoothGATTNotifyDataResponse";
+/** One queue per proxy, however many transports or links share it. */
+const proxyQueues = /* @__PURE__ */ new WeakMap();
+function queueFor(proxy) {
+	let queue = proxyQueues.get(proxy);
+	if (!queue) {
+		queue = new AsyncLock();
+		proxyQueues.set(proxy, queue);
+	}
+	return queue;
+}
+/** A proxy's 48-bit address as a MAC, the form a caller would recognize. */
+function formatAddress(address) {
+	return address.toString(16).padStart(12, "0").replace(/(..)(?=.)/g, "$1:").toUpperCase();
+}
+function parseAddress(id) {
+	const hex = id.replace(/:/g, "");
+	if (!/^[0-9a-fA-F]{12}$/.test(hex)) throw new Error("An ESPHome device id must be a 48-bit address.");
+	return Number.parseInt(hex, 16);
+}
+function sameUuid(entry, uuid) {
+	return entry.uuid ? compactUuid(entry.uuid) === compactUuid(uuid) : (entry.shortUuid ?? 0).toString(16).padStart(4, "0") === compactUuid(uuid);
+}
+/** A late reply to an abandoned call can land on the next call of its type. */
+function assertReplyFor(reply, address, handle) {
+	if (reply.address !== address || reply.handle !== handle) throw new Error("The proxy's reply was for another request.");
+}
+var EsphomeConnection = class {
+	proxy;
+	address;
+	id;
+	handlers;
+	claims;
+	lost = false;
+	closed = false;
+	closing;
+	handles = /* @__PURE__ */ new Map();
+	mtu = 0;
+	onLost = () => {
+		if (this.lost) return;
+		this.lost = true;
+		this.stopListening();
+		if (!this.closed) this.handlers.onDisconnect();
+	};
+	onState = (state) => {
+		if (state.address === this.address && !state.connected) this.onLost();
+	};
+	notifyHandle;
+	onNotifyData = (message) => {
+		if (message.address === this.address && message.handle === this.notifyHandle) this.handlers.onNotify(Buffer.from(message.data, "base64"));
+	};
+	constructor(proxy, address, id, handlers, claims) {
+		this.proxy = proxy;
+		this.address = address;
+		this.id = id;
+		this.handlers = handlers;
+		this.claims = claims;
+	}
+	get queue() {
+		return queueFor(this.proxy);
+	}
+	get isConnected() {
+		return !this.lost && !this.closed && this.proxy.connected && this.proxy.authorized;
+	}
+	get maxWriteSize() {
+		return this.mtu > 3 ? this.mtu - 3 : 20;
+	}
+	/** Ask the proxy to connect. The reply is matched here, as a link dropping elsewhere sends the same message type. */
+	requestLink(addressType) {
+		const { proxy, address } = this;
+		return this.queue.run(async () => {
+			let onReply;
+			const reply = new Promise((resolve) => {
+				onReply = (state) => {
+					if (state.address === address) resolve(state);
+				};
+			});
+			proxy.on(CONNECTION_STATE, onReply);
+			try {
+				return await withTimeout(() => Promise.race([reply, proxy.connectBluetoothDeviceService(address, addressType, false).then(() => reply)]), DEVICE_CONNECT_WAIT_MS);
+			} finally {
+				proxy.off(CONNECTION_STATE, onReply);
+			}
+		});
+	}
+	/** Connect, map the handles, and subscribe. Resolves once the CCCD write is done. */
+	async open(addressType) {
+		const state = await this.requestLink(addressType);
+		if (!state.connected || state.error) {
+			this.lost = true;
+			throw new Error(`The proxy could not connect: error ${state.error}.`);
+		}
+		this.assertCurrent();
+		this.mtu = state.mtu;
+		const { proxy, address } = this;
+		proxy.on(CONNECTION_STATE, this.onState);
+		proxy.on("disconnected", this.onLost);
+		proxy.on("unauthorized", this.onLost);
+		const { servicesList } = await this.queue.run(() => proxy.listBluetoothGATTServicesService(address));
+		const service = servicesList.find((candidate) => sameUuid(candidate, SERVICE_UUID));
+		const characteristic = (uuid) => service?.characteristicsList.find((candidate) => sameUuid(candidate, uuid));
+		const write = characteristic(VEHICLE_WRITE_UUID);
+		const notify = characteristic(VEHICLE_NOTIFY_UUID);
+		const cccd = notify?.descriptorsList.find((descriptor) => sameUuid(descriptor, CCCD_UUID));
+		if (!write || !notify || !cccd) throw new Error("The vehicle's write or notify characteristic, or its CCCD, was not found.");
+		this.handles.set("write", write.handle);
+		const version = characteristic(VERSION_UUID);
+		if (version) this.handles.set("version", version.handle);
+		const genericAccess = servicesList.find((candidate) => sameUuid(candidate, GENERIC_ACCESS_UUID));
+		for (const [name, uuid] of [["deviceName", NAME_UUID], ["appearance", APPEARANCE_UUID]]) {
+			const entry = genericAccess?.characteristicsList.find((candidate) => sameUuid(candidate, uuid));
+			if (entry) this.handles.set(name, entry.handle);
+		}
+		this.assertCurrent();
+		this.notifyHandle = notify.handle;
+		proxy.on(NOTIFY_DATA, this.onNotifyData);
+		await this.queue.run(() => proxy.notifyBluetoothGATTCharacteristicService(address, notify.handle));
+		await this.queue.run(() => proxy.writeBluetoothGATTDescriptorService(address, cccd.handle, CCCD_ENABLE_NOTIFICATIONS));
+	}
+	/** A superseded attempt stops here, before it changes a link another attempt owns. */
+	assertCurrent() {
+		if (this.claims.superseded(this.id, this)) throw new Error("A newer connect attempt took over this link.");
+	}
+	async write(data) {
+		const { proxy, address } = this;
+		const handle = this.handles.get("write");
+		if (handle === void 0) throw new BleNotSubmittedError("The vehicle write characteristic was not found.");
+		const queuedAt = performance.now();
+		await this.queue.run(async () => {
+			if (!this.isConnected) throw new BleNotSubmittedError("The link is down.");
+			if (performance.now() - queuedAt >= 5e3) throw new BleNotSubmittedError("The write outlasted its timeout in the proxy queue.");
+			assertReplyFor(await proxy.writeBluetoothGATTCharacteristicService(address, handle, Buffer.from(data), true), address, handle);
+		});
+	}
+	async read(characteristic) {
+		const { proxy, address } = this;
+		const handle = this.handles.get(characteristic);
+		if (handle === void 0) throw new BleNotSubmittedError(`The ${characteristic} characteristic was not found.`);
+		const reply = await this.queue.run(() => {
+			if (!this.isConnected) throw new BleNotSubmittedError("The link is down.");
+			return proxy.readBluetoothGATTCharacteristicService(address, handle);
+		});
+		assertReplyFor(reply, address, handle);
+		return Buffer.from(reply.data, "base64");
+	}
+	stopListening() {
+		const { proxy } = this;
+		proxy.off(CONNECTION_STATE, this.onState);
+		proxy.off("disconnected", this.onLost);
+		proxy.off("unauthorized", this.onLost);
+		proxy.off(NOTIFY_DATA, this.onNotifyData);
+	}
+	disconnect() {
+		this.closing ??= (async () => {
+			this.closed = true;
+			this.stopListening();
+			const { claims, id, proxy, address } = this;
+			const superseded = claims.superseded(id, this);
+			claims.release(id, this);
+			if (!superseded && !this.lost && proxy.authorized) await quietly(() => this.queue.run(() => proxy.disconnectBluetoothDeviceService(address)));
+		})();
+		return this.closing;
+	}
+};
+var EsphomeBleTransport = class {
+	options;
+	proxy;
+	ownsProxy;
+	scans = new AsyncLock();
+	claims = new LinkClaims();
+	/** A proxy refuses a connect with no address type, and only an advertisement carries it. */
+	addressTypes = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.options = options;
+		this.ownsProxy = !("connection" in options);
+		if ("connection" in options) this.proxy = options.connection;
+	}
+	/** The API connection, up and authorized. */
+	async ready() {
+		const proxy = this.proxy ??= await this.buildProxy();
+		if (proxy.authorized) return proxy;
+		if (this.ownsProxy && !proxy.connected) proxy.connect();
+		let onAuthorized;
+		let onError;
+		try {
+			await withTimeout(() => new Promise((resolve, reject) => {
+				onAuthorized = resolve;
+				onError = reject;
+				proxy.on("authorized", onAuthorized);
+				proxy.on("error", onError);
+			}), API_CONNECT_TIMEOUT_MS);
+		} finally {
+			proxy.off("authorized", onAuthorized);
+			proxy.off("error", onError);
+		}
+		return proxy;
+	}
+	async buildProxy() {
+		if ("connection" in this.options) return this.options.connection;
+		const specifier = "@2colors/esphome-native-api";
+		let module;
+		try {
+			module = await import(specifier);
+		} catch (cause) {
+			throw new Error("EsphomeBleTransport needs @2colors/esphome-native-api, or a `connection` option.", { cause });
+		}
+		const Connection = module.Connection ?? module.default?.Connection;
+		if (!Connection) throw new Error("@2colors/esphome-native-api has no Connection.");
+		const { host, port, encryptionKey, password } = this.options;
+		const proxy = new Connection({
+			host,
+			port,
+			encryptionKey,
+			password
+		});
+		proxy.on("error", () => void 0);
+		return proxy;
+	}
+	async scan({ timeoutMs, matches }) {
+		const proxy = await this.ready();
+		return this.listen(proxy, timeoutMs, (device) => device.name !== void 0 && matches?.(device.name) === true);
+	}
+	/** Listen to advertisements until `done` accepts a device or the window ends. A proxy filters nothing. */
+	listen(proxy, timeoutMs, done) {
+		return this.scans.run(async () => {
+			const seen = /* @__PURE__ */ new Map();
+			let finish;
+			const finished = new Promise((resolve) => {
+				finish = resolve;
+			});
+			const onAdvertisement = (advertisement) => {
+				const id = formatAddress(advertisement.address);
+				this.addressTypes.set(id, advertisement.addressType ?? this.addressTypes.get(id));
+				const device = {
+					id,
+					name: advertisement.name || seen.get(id)?.name,
+					rssi: advertisement.rssi
+				};
+				seen.set(id, device);
+				if (done(device)) finish();
+			};
+			proxy.on(ADVERTISEMENT, onAdvertisement);
+			const timer = setTimeout(finish, Math.max(0, timeoutMs - 250));
+			try {
+				proxy.subscribeBluetoothAdvertisementService();
+				await finished;
+			} finally {
+				clearTimeout(timer);
+				proxy.off(ADVERTISEMENT, onAdvertisement);
+				await quietly(() => proxy.unsubscribeBluetoothAdvertisementService());
+			}
+			return [...seen.values()];
+		});
+	}
+	async connect(device, handlers) {
+		const address = parseAddress(device.id);
+		const id = formatAddress(address);
+		const proxy = await this.ready();
+		if (this.addressTypes.get(id) === void 0) await this.listen(proxy, DEFAULT_SCAN_TIMEOUT_MS, (seen) => seen.id === id && this.addressTypes.get(id) !== void 0);
+		const connection = new EsphomeConnection(proxy, address, id, handlers, this.claims);
+		this.claims.claim(id, connection);
+		try {
+			await connection.open(this.addressTypes.get(id));
+		} catch (error) {
+			await connection.disconnect();
+			throw error;
+		}
+		return connection;
+	}
+	/** Close the API connection, if this transport opened it. */
+	close() {
+		if (this.ownsProxy) {
+			this.proxy?.disconnect();
+			this.proxy = void 0;
+		}
+	}
+};
+export { EsphomeBleTransport };

package/dist/bluetooth/framing.cjs

@@ -0,0 +1,125 @@
+require("./constants.cjs");
+let _teslemetry_tesla_protocol_command_universal_message = require("@teslemetry/tesla-protocol/command/universal_message");
+let _teslemetry_tesla_protocol_command_vcsec = require("@teslemetry/tesla-protocol/command/vcsec");
+// src/bluetooth/framing.ts
+/** Prefix a payload with its big-endian 2-byte length, which counts the payload only. */
+function prependLength(message) {
+	const header = Buffer.alloc(2);
+	header.writeUInt16BE(message.length);
+	return Buffer.concat([header, message]);
+}
+/**
+* Cut a frame into the writes that carry it.
+* @param maxWriteSize Largest bytes per write. `null` means the backend accepts a full frame, as Python's do.
+*/
+function splitFrame(frame, maxWriteSize) {
+	if (maxWriteSize === null) return [frame];
+	if (!Number.isInteger(maxWriteSize) || maxWriteSize <= 0) throw new RangeError(`maxWriteSize must be a positive integer, got ${maxWriteSize}.`);
+	const chunks = [];
+	for (let start = 0; start < frame.length; start += maxWriteSize) chunks.push(frame.subarray(start, start + maxWriteSize));
+	return chunks;
+}
+/** Whether a decoded `RoutableMessage` holds nothing: ts-proto's shape for "no known field". */
+function hasNoKnownField(message) {
+	return message.toDestination === void 0 && message.fromDestination === void 0 && message.protobufMessageAsBytes === void 0 && message.sessionInfoRequest === void 0 && message.sessionInfo === void 0 && message.signatureData === void 0 && message.signedMessageStatus === void 0 && message.messageFrame === void 0 && message.requestUuid.length === 0 && message.uuid.length === 0 && message.flags === 0;
+}
+/**
+* Parse one reassembled frame, wrapping a bare VCSEC message.
+*
+* On a fresh link the car sends `FromVCSECMessage` frames, such as a repeating
+* `authenticationRequest`, with no `RoutableMessage` around them. None of its
+* field numbers exist on `RoutableMessage`, so one parses as a message with no
+* known field. It is wrapped as an unaddressed VCSEC message, so it reaches the
+* broadcast listeners as a wrapped one would.
+* @throws When the frame is not a `RoutableMessage`.
+*/
+function parseFrame(payload) {
+	const message = _teslemetry_tesla_protocol_command_universal_message.RoutableMessage.decode(payload);
+	if (payload.length === 0 || !hasNoKnownField(message)) return message;
+	let vcsec;
+	try {
+		vcsec = _teslemetry_tesla_protocol_command_vcsec.FromVCSECMessage.decode(payload);
+	} catch {
+		return message;
+	}
+	if (!Object.values(vcsec).some((field) => field !== void 0)) return message;
+	return _teslemetry_tesla_protocol_command_universal_message.RoutableMessage.create({
+		fromDestination: { domain: _teslemetry_tesla_protocol_command_universal_message.Domain.DOMAIN_VEHICLE_SECURITY },
+		protobufMessageAsBytes: payload
+	});
+}
+/**
+* Reassembles BLE notifications into length-prefixed messages.
+*
+* One notification can hold part of a message, one message, or several. A
+* message that cannot be decoded drops the current notification and resyncs at
+* the next one. A partial message is also dropped if its next chunk does not
+* arrive within `STALE_CHUNK_TIMEOUT_MS`.
+*/
+var ReassemblingBuffer = class {
+	callback;
+	buffer = Buffer.alloc(0);
+	expectedLength = null;
+	/** Where each notification still in `buffer` starts: the only places a resync can land. */
+	packetStarts = [];
+	lastChunkAt = null;
+	now;
+	/**
+	* @param callback Called with each parsed message. Its errors are not caught.
+	* @param now The monotonic clock, in milliseconds. Injectable for tests.
+	*/
+	constructor(callback, now = () => performance.now()) {
+		this.callback = callback;
+		this.now = now;
+	}
+	/** Take one notification and emit every message it completes. Malformed bytes never throw. */
+	receive(chunk) {
+		const now = this.now();
+		if (this.buffer.length > 0 && this.lastChunkAt !== null && now - this.lastChunkAt > 1e3) {
+			this.buffer = Buffer.alloc(0);
+			this.expectedLength = null;
+			this.packetStarts = [];
+		}
+		this.lastChunkAt = now;
+		this.packetStarts.push(this.buffer.length);
+		this.buffer = Buffer.concat([this.buffer, chunk]);
+		for (;;) {
+			if (this.expectedLength === null && this.buffer.length >= 2) this.expectedLength = this.buffer.readUInt16BE(0) + 2;
+			if (this.expectedLength === null) return;
+			if (this.expectedLength > 1024) {
+				this.discardPacket();
+				continue;
+			}
+			if (this.buffer.length < this.expectedLength) return;
+			let message;
+			try {
+				message = parseFrame(this.buffer.subarray(2, this.expectedLength));
+			} catch {
+				this.discardPacket();
+				continue;
+			}
+			const consumed = this.expectedLength;
+			this.buffer = this.buffer.subarray(consumed);
+			this.packetStarts = this.packetStarts.filter((start) => start >= consumed).map((start) => start - consumed);
+			this.expectedLength = null;
+			this.callback(message);
+		}
+	}
+	/** Drop the current notification and resync at the next, if there is one. */
+	discardPacket() {
+		this.packetStarts.shift();
+		const next = this.packetStarts[0];
+		if (next === void 0) {
+			this.buffer = Buffer.alloc(0);
+			this.packetStarts = [];
+		} else {
+			this.buffer = this.buffer.subarray(next);
+			this.packetStarts = this.packetStarts.map((start) => start - next);
+		}
+		this.expectedLength = null;
+	}
+};
+exports.ReassemblingBuffer = ReassemblingBuffer;
+exports.parseFrame = parseFrame;
+exports.prependLength = prependLength;
+exports.splitFrame = splitFrame;

package/dist/bluetooth/framing.d.cts

@@ -0,0 +1,45 @@
+import { RoutableMessage } from "@teslemetry/tesla-protocol/command/universal_message";
+/** Prefix a payload with its big-endian 2-byte length, which counts the payload only. */
+export declare function prependLength(message: Uint8Array): Buffer;
+/**
+ * Cut a frame into the writes that carry it.
+ * @param maxWriteSize Largest bytes per write. `null` means the backend accepts a full frame, as Python's do.
+ */
+export declare function splitFrame(frame: Uint8Array, maxWriteSize: number | null): Uint8Array[];
+/**
+ * Parse one reassembled frame, wrapping a bare VCSEC message.
+ *
+ * On a fresh link the car sends `FromVCSECMessage` frames, such as a repeating
+ * `authenticationRequest`, with no `RoutableMessage` around them. None of its
+ * field numbers exist on `RoutableMessage`, so one parses as a message with no
+ * known field. It is wrapped as an unaddressed VCSEC message, so it reaches the
+ * broadcast listeners as a wrapped one would.
+ * @throws When the frame is not a `RoutableMessage`.
+ */
+export declare function parseFrame(payload: Uint8Array): RoutableMessage;
+/**
+ * Reassembles BLE notifications into length-prefixed messages.
+ *
+ * One notification can hold part of a message, one message, or several. A
+ * message that cannot be decoded drops the current notification and resyncs at
+ * the next one. A partial message is also dropped if its next chunk does not
+ * arrive within `STALE_CHUNK_TIMEOUT_MS`.
+ */
+export declare class ReassemblingBuffer {
+  private readonly callback;
+  private buffer;
+  private expectedLength;
+  /** Where each notification still in `buffer` starts: the only places a resync can land. */
+  private packetStarts;
+  private lastChunkAt;
+  private readonly now;
+  /**
+   * @param callback Called with each parsed message. Its errors are not caught.
+   * @param now The monotonic clock, in milliseconds. Injectable for tests.
+   */
+  constructor(callback: (message: RoutableMessage) => void, now?: () => number);
+  /** Take one notification and emit every message it completes. Malformed bytes never throw. */
+  receive(chunk: Uint8Array): void;
+  /** Drop the current notification and resync at the next, if there is one. */
+  private discardPacket;
+}

package/dist/bluetooth/framing.d.mts

@@ -0,0 +1,45 @@
+import { RoutableMessage } from "@teslemetry/tesla-protocol/command/universal_message";
+/** Prefix a payload with its big-endian 2-byte length, which counts the payload only. */
+export declare function prependLength(message: Uint8Array): Buffer;
+/**
+ * Cut a frame into the writes that carry it.
+ * @param maxWriteSize Largest bytes per write. `null` means the backend accepts a full frame, as Python's do.
+ */
+export declare function splitFrame(frame: Uint8Array, maxWriteSize: number | null): Uint8Array[];
+/**
+ * Parse one reassembled frame, wrapping a bare VCSEC message.
+ *
+ * On a fresh link the car sends `FromVCSECMessage` frames, such as a repeating
+ * `authenticationRequest`, with no `RoutableMessage` around them. None of its
+ * field numbers exist on `RoutableMessage`, so one parses as a message with no
+ * known field. It is wrapped as an unaddressed VCSEC message, so it reaches the
+ * broadcast listeners as a wrapped one would.
+ * @throws When the frame is not a `RoutableMessage`.
+ */
+export declare function parseFrame(payload: Uint8Array): RoutableMessage;
+/**
+ * Reassembles BLE notifications into length-prefixed messages.
+ *
+ * One notification can hold part of a message, one message, or several. A
+ * message that cannot be decoded drops the current notification and resyncs at
+ * the next one. A partial message is also dropped if its next chunk does not
+ * arrive within `STALE_CHUNK_TIMEOUT_MS`.
+ */
+export declare class ReassemblingBuffer {
+  private readonly callback;
+  private buffer;
+  private expectedLength;
+  /** Where each notification still in `buffer` starts: the only places a resync can land. */
+  private packetStarts;
+  private lastChunkAt;
+  private readonly now;
+  /**
+   * @param callback Called with each parsed message. Its errors are not caught.
+   * @param now The monotonic clock, in milliseconds. Injectable for tests.
+   */
+  constructor(callback: (message: RoutableMessage) => void, now?: () => number);
+  /** Take one notification and emit every message it completes. Malformed bytes never throw. */
+  receive(chunk: Uint8Array): void;
+  /** Drop the current notification and resync at the next, if there is one. */
+  private discardPacket;
+}

package/dist/bluetooth/framing.mjs

@@ -0,0 +1,122 @@
+import "./constants.mjs";
+import { Domain, RoutableMessage } from "@teslemetry/tesla-protocol/command/universal_message";
+import { FromVCSECMessage } from "@teslemetry/tesla-protocol/command/vcsec";
+// src/bluetooth/framing.ts
+/** Prefix a payload with its big-endian 2-byte length, which counts the payload only. */
+function prependLength(message) {
+	const header = Buffer.alloc(2);
+	header.writeUInt16BE(message.length);
+	return Buffer.concat([header, message]);
+}
+/**
+* Cut a frame into the writes that carry it.
+* @param maxWriteSize Largest bytes per write. `null` means the backend accepts a full frame, as Python's do.
+*/
+function splitFrame(frame, maxWriteSize) {
+	if (maxWriteSize === null) return [frame];
+	if (!Number.isInteger(maxWriteSize) || maxWriteSize <= 0) throw new RangeError(`maxWriteSize must be a positive integer, got ${maxWriteSize}.`);
+	const chunks = [];
+	for (let start = 0; start < frame.length; start += maxWriteSize) chunks.push(frame.subarray(start, start + maxWriteSize));
+	return chunks;
+}
+/** Whether a decoded `RoutableMessage` holds nothing: ts-proto's shape for "no known field". */
+function hasNoKnownField(message) {
+	return message.toDestination === void 0 && message.fromDestination === void 0 && message.protobufMessageAsBytes === void 0 && message.sessionInfoRequest === void 0 && message.sessionInfo === void 0 && message.signatureData === void 0 && message.signedMessageStatus === void 0 && message.messageFrame === void 0 && message.requestUuid.length === 0 && message.uuid.length === 0 && message.flags === 0;
+}
+/**
+* Parse one reassembled frame, wrapping a bare VCSEC message.
+*
+* On a fresh link the car sends `FromVCSECMessage` frames, such as a repeating
+* `authenticationRequest`, with no `RoutableMessage` around them. None of its
+* field numbers exist on `RoutableMessage`, so one parses as a message with no
+* known field. It is wrapped as an unaddressed VCSEC message, so it reaches the
+* broadcast listeners as a wrapped one would.
+* @throws When the frame is not a `RoutableMessage`.
+*/
+function parseFrame(payload) {
+	const message = RoutableMessage.decode(payload);
+	if (payload.length === 0 || !hasNoKnownField(message)) return message;
+	let vcsec;
+	try {
+		vcsec = FromVCSECMessage.decode(payload);
+	} catch {
+		return message;
+	}
+	if (!Object.values(vcsec).some((field) => field !== void 0)) return message;
+	return RoutableMessage.create({
+		fromDestination: { domain: Domain.DOMAIN_VEHICLE_SECURITY },
+		protobufMessageAsBytes: payload
+	});
+}
+/**
+* Reassembles BLE notifications into length-prefixed messages.
+*
+* One notification can hold part of a message, one message, or several. A
+* message that cannot be decoded drops the current notification and resyncs at
+* the next one. A partial message is also dropped if its next chunk does not
+* arrive within `STALE_CHUNK_TIMEOUT_MS`.
+*/
+var ReassemblingBuffer = class {
+	callback;
+	buffer = Buffer.alloc(0);
+	expectedLength = null;
+	/** Where each notification still in `buffer` starts: the only places a resync can land. */
+	packetStarts = [];
+	lastChunkAt = null;
+	now;
+	/**
+	* @param callback Called with each parsed message. Its errors are not caught.
+	* @param now The monotonic clock, in milliseconds. Injectable for tests.
+	*/
+	constructor(callback, now = () => performance.now()) {
+		this.callback = callback;
+		this.now = now;
+	}
+	/** Take one notification and emit every message it completes. Malformed bytes never throw. */
+	receive(chunk) {
+		const now = this.now();
+		if (this.buffer.length > 0 && this.lastChunkAt !== null && now - this.lastChunkAt > 1e3) {
+			this.buffer = Buffer.alloc(0);
+			this.expectedLength = null;
+			this.packetStarts = [];
+		}
+		this.lastChunkAt = now;
+		this.packetStarts.push(this.buffer.length);
+		this.buffer = Buffer.concat([this.buffer, chunk]);
+		for (;;) {
+			if (this.expectedLength === null && this.buffer.length >= 2) this.expectedLength = this.buffer.readUInt16BE(0) + 2;
+			if (this.expectedLength === null) return;
+			if (this.expectedLength > 1024) {
+				this.discardPacket();
+				continue;
+			}
+			if (this.buffer.length < this.expectedLength) return;
+			let message;
+			try {
+				message = parseFrame(this.buffer.subarray(2, this.expectedLength));
+			} catch {
+				this.discardPacket();
+				continue;
+			}
+			const consumed = this.expectedLength;
+			this.buffer = this.buffer.subarray(consumed);
+			this.packetStarts = this.packetStarts.filter((start) => start >= consumed).map((start) => start - consumed);
+			this.expectedLength = null;
+			this.callback(message);
+		}
+	}
+	/** Drop the current notification and resync at the next, if there is one. */
+	discardPacket() {
+		this.packetStarts.shift();
+		const next = this.packetStarts[0];
+		if (next === void 0) {
+			this.buffer = Buffer.alloc(0);
+			this.packetStarts = [];
+		} else {
+			this.buffer = this.buffer.subarray(next);
+			this.packetStarts = this.packetStarts.map((start) => start - next);
+		}
+		this.expectedLength = null;
+	}
+};
+export { ReassemblingBuffer, parseFrame, prependLength, splitFrame };