tesla-fleet-api 0.3.0 → 0.5.0

package/dist/bluetooth/broadcast.cjs

@@ -0,0 +1,153 @@
+const require_commands = require("../commands.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/broadcast.ts
+/**
+* Local callbacks, not tied to a connection, so they live as long as the
+* vehicle and survive reconnects. A callback that throws is logged, and neither
+* later callbacks nor message routing see it.
+*/
+var ListenerRegistry = class {
+	log;
+	entries = [];
+	constructor(log) {
+		this.log = log;
+	}
+	get size() {
+		return this.entries.length;
+	}
+	add(callback) {
+		const entry = { callback };
+		this.entries.push(entry);
+		return () => {
+			this.entries = this.entries.filter((other) => other !== entry);
+		};
+	}
+	emit(value) {
+		for (const { callback } of this.entries) try {
+			callback(value);
+		} catch (error) {
+			this.log(`BLE listener failed: ${error instanceof Error ? `${error.name}: ${error.message}` : String(error)}`);
+		}
+	}
+};
+/**
+* A broadcast's VCSEC status, if it carries one. Broadcasts are unsigned, so
+* they need no session and prove nothing about who sent them.
+*/
+function decodeVcsecStatus(message) {
+	if (message.protobufMessageAsBytes === void 0) return null;
+	try {
+		return _teslemetry_tesla_protocol_command_vcsec.FromVCSECMessage.decode(message.protobufMessageAsBytes).vehicleStatus ?? null;
+	} catch {
+		return null;
+	}
+}
+/**
+* Persistent listeners for unsolicited broadcasts, which arrive on the same
+* notifications as command replies. Each `VehicleStatus` leaf has a typed
+* `listen_*`, and `listen_broadcast` takes every raw broadcast on a domain,
+* including payloads with no typed listener.
+*
+* The scalar listeners fire on every status broadcast with whatever value it
+* holds, because proto3 has no presence on them, so a lock-only broadcast also
+* reports `GEAR_UNKNOWN`. The closure listeners fire only when the broadcast
+* carries the block they read.
+*/
+var BroadcastListeners = class extends require_commands.default {
+	statusListeners = new ListenerRegistry((message) => this.log(message));
+	domainListeners = /* @__PURE__ */ new Map();
+	log(message) {
+		this.parent.parent._log(message);
+	}
+	/** Hand one unaddressed message to everything listening. */
+	dispatchBroadcast(domain, message) {
+		this.domainListeners.get(domain)?.emit(message);
+		if (domain === _teslemetry_tesla_protocol_command_universal_message.Domain.DOMAIN_VEHICLE_SECURITY && this.statusListeners.size > 0) {
+			const status = decodeVcsecStatus(message);
+			if (status) this.statusListeners.emit(status);
+		}
+	}
+	listenClosure(callback) {
+		return this.statusListeners.add((status) => {
+			if (status.closureStatuses) callback(status.closureStatuses);
+		});
+	}
+	/** Listen for every unsolicited broadcast on `domain`, including `VehicleStatus`. */
+	listen_broadcast(domain, callback) {
+		let registry = this.domainListeners.get(domain);
+		if (!registry) {
+			registry = new ListenerRegistry((message) => this.log(message));
+			this.domainListeners.set(domain, registry);
+		}
+		return registry.add(callback);
+	}
+	/** Listen for the vehicle's overall lock state. */
+	listen_vehicle_lock_state(callback) {
+		return this.statusListeners.add((status) => callback(status.vehicleLockState));
+	}
+	/** Listen for the vehicle's sleep status. */
+	listen_vehicle_sleep_status(callback) {
+		return this.statusListeners.add((status) => callback(status.vehicleSleepStatus));
+	}
+	/** Listen for driver presence. */
+	listen_user_presence(callback) {
+		return this.statusListeners.add((status) => callback(status.userPresence));
+	}
+	/** Listen for the gear selection. */
+	listen_gear(callback) {
+		return this.statusListeners.add((status) => callback(status.gear));
+	}
+	/** Listen for the UI desire state. */
+	listen_ui_desire(callback) {
+		return this.statusListeners.add((status) => callback(status.UIDesire));
+	}
+	/** Listen for the tonneau's open percentage, on broadcasts that carry it. */
+	listen_tonneau_percent_open(callback) {
+		return this.statusListeners.add((status) => {
+			if (status.detailedClosureStatus) callback(status.detailedClosureStatus.tonneauPercentOpen);
+		});
+	}
+	/**
+	* Listen for a broadcast's whole closure block in one call. The listeners
+	* below each fire separately for the same broadcast.
+	*/
+	listen_closure_statuses(callback) {
+		return this.listenClosure(callback);
+	}
+	/** Listen for the front driver door. */
+	listen_front_driver_door(callback) {
+		return this.listenClosure((closures) => callback(closures.frontDriverDoor));
+	}
+	/** Listen for the front passenger door. */
+	listen_front_passenger_door(callback) {
+		return this.listenClosure((closures) => callback(closures.frontPassengerDoor));
+	}
+	/** Listen for the rear driver door. */
+	listen_rear_driver_door(callback) {
+		return this.listenClosure((closures) => callback(closures.rearDriverDoor));
+	}
+	/** Listen for the rear passenger door. */
+	listen_rear_passenger_door(callback) {
+		return this.listenClosure((closures) => callback(closures.rearPassengerDoor));
+	}
+	/** Listen for the front trunk. */
+	listen_front_trunk(callback) {
+		return this.listenClosure((closures) => callback(closures.frontTrunk));
+	}
+	/** Listen for the rear trunk. */
+	listen_rear_trunk(callback) {
+		return this.listenClosure((closures) => callback(closures.rearTrunk));
+	}
+	/** Listen for the charge port. */
+	listen_charge_port(callback) {
+		return this.listenClosure((closures) => callback(closures.chargePort));
+	}
+	/** Listen for the tonneau. */
+	listen_tonneau(callback) {
+		return this.listenClosure((closures) => callback(closures.tonneau));
+	}
+};
+exports.BroadcastListeners = BroadcastListeners;
+exports.ListenerRegistry = ListenerRegistry;
+exports.decodeVcsecStatus = decodeVcsecStatus;

package/dist/bluetooth/broadcast.d.cts

@@ -0,0 +1,59 @@
+import Commands from "../commands.cjs";
+import { Domain, RoutableMessage } from "@teslemetry/tesla-protocol/command/universal_message";
+import { ClosureStateE, ClosureStatuses, GearE, UIDesireE, UserPresenceE, VehicleLockStateE, VehicleSleepStatusE, VehicleStatus } from "@teslemetry/tesla-protocol/command/vcsec";
+/** Removes a listener. Safe to call twice. */
+export type Unsubscribe = () => void;
+/**
+ * Persistent listeners for unsolicited broadcasts, which arrive on the same
+ * notifications as command replies. Each `VehicleStatus` leaf has a typed
+ * `listen_*`, and `listen_broadcast` takes every raw broadcast on a domain,
+ * including payloads with no typed listener.
+ *
+ * The scalar listeners fire on every status broadcast with whatever value it
+ * holds, because proto3 has no presence on them, so a lock-only broadcast also
+ * reports `GEAR_UNKNOWN`. The closure listeners fire only when the broadcast
+ * carries the block they read.
+ */
+export declare abstract class BroadcastListeners extends Commands {
+  private readonly statusListeners;
+  private readonly domainListeners;
+  protected log(message: string): void;
+  /** Hand one unaddressed message to everything listening. */
+  protected dispatchBroadcast(domain: Domain, message: RoutableMessage): void;
+  private listenClosure;
+  /** Listen for every unsolicited broadcast on `domain`, including `VehicleStatus`. */
+  listen_broadcast(domain: Domain, callback: (message: RoutableMessage) => void): Unsubscribe;
+  /** Listen for the vehicle's overall lock state. */
+  listen_vehicle_lock_state(callback: (state: VehicleLockStateE) => void): Unsubscribe;
+  /** Listen for the vehicle's sleep status. */
+  listen_vehicle_sleep_status(callback: (status: VehicleSleepStatusE) => void): Unsubscribe;
+  /** Listen for driver presence. */
+  listen_user_presence(callback: (presence: UserPresenceE) => void): Unsubscribe;
+  /** Listen for the gear selection. */
+  listen_gear(callback: (gear: GearE) => void): Unsubscribe;
+  /** Listen for the UI desire state. */
+  listen_ui_desire(callback: (desire: UIDesireE) => void): Unsubscribe;
+  /** Listen for the tonneau's open percentage, on broadcasts that carry it. */
+  listen_tonneau_percent_open(callback: (percent: number) => void): Unsubscribe;
+  /**
+   * Listen for a broadcast's whole closure block in one call. The listeners
+   * below each fire separately for the same broadcast.
+   */
+  listen_closure_statuses(callback: (closures: ClosureStatuses) => void): Unsubscribe;
+  /** Listen for the front driver door. */
+  listen_front_driver_door(callback: (state: ClosureStateE) => void): Unsubscribe;
+  /** Listen for the front passenger door. */
+  listen_front_passenger_door(callback: (state: ClosureStateE) => void): Unsubscribe;
+  /** Listen for the rear driver door. */
+  listen_rear_driver_door(callback: (state: ClosureStateE) => void): Unsubscribe;
+  /** Listen for the rear passenger door. */
+  listen_rear_passenger_door(callback: (state: ClosureStateE) => void): Unsubscribe;
+  /** Listen for the front trunk. */
+  listen_front_trunk(callback: (state: ClosureStateE) => void): Unsubscribe;
+  /** Listen for the rear trunk. */
+  listen_rear_trunk(callback: (state: ClosureStateE) => void): Unsubscribe;
+  /** Listen for the charge port. */
+  listen_charge_port(callback: (state: ClosureStateE) => void): Unsubscribe;
+  /** Listen for the tonneau. */
+  listen_tonneau(callback: (state: ClosureStateE) => void): Unsubscribe;
+}

package/dist/bluetooth/broadcast.d.mts

@@ -0,0 +1,59 @@
+import Commands from "../commands.mjs";
+import { Domain, RoutableMessage } from "@teslemetry/tesla-protocol/command/universal_message";
+import { ClosureStateE, ClosureStatuses, GearE, UIDesireE, UserPresenceE, VehicleLockStateE, VehicleSleepStatusE, VehicleStatus } from "@teslemetry/tesla-protocol/command/vcsec";
+/** Removes a listener. Safe to call twice. */
+export type Unsubscribe = () => void;
+/**
+ * Persistent listeners for unsolicited broadcasts, which arrive on the same
+ * notifications as command replies. Each `VehicleStatus` leaf has a typed
+ * `listen_*`, and `listen_broadcast` takes every raw broadcast on a domain,
+ * including payloads with no typed listener.
+ *
+ * The scalar listeners fire on every status broadcast with whatever value it
+ * holds, because proto3 has no presence on them, so a lock-only broadcast also
+ * reports `GEAR_UNKNOWN`. The closure listeners fire only when the broadcast
+ * carries the block they read.
+ */
+export declare abstract class BroadcastListeners extends Commands {
+  private readonly statusListeners;
+  private readonly domainListeners;
+  protected log(message: string): void;
+  /** Hand one unaddressed message to everything listening. */
+  protected dispatchBroadcast(domain: Domain, message: RoutableMessage): void;
+  private listenClosure;
+  /** Listen for every unsolicited broadcast on `domain`, including `VehicleStatus`. */
+  listen_broadcast(domain: Domain, callback: (message: RoutableMessage) => void): Unsubscribe;
+  /** Listen for the vehicle's overall lock state. */
+  listen_vehicle_lock_state(callback: (state: VehicleLockStateE) => void): Unsubscribe;
+  /** Listen for the vehicle's sleep status. */
+  listen_vehicle_sleep_status(callback: (status: VehicleSleepStatusE) => void): Unsubscribe;
+  /** Listen for driver presence. */
+  listen_user_presence(callback: (presence: UserPresenceE) => void): Unsubscribe;
+  /** Listen for the gear selection. */
+  listen_gear(callback: (gear: GearE) => void): Unsubscribe;
+  /** Listen for the UI desire state. */
+  listen_ui_desire(callback: (desire: UIDesireE) => void): Unsubscribe;
+  /** Listen for the tonneau's open percentage, on broadcasts that carry it. */
+  listen_tonneau_percent_open(callback: (percent: number) => void): Unsubscribe;
+  /**
+   * Listen for a broadcast's whole closure block in one call. The listeners
+   * below each fire separately for the same broadcast.
+   */
+  listen_closure_statuses(callback: (closures: ClosureStatuses) => void): Unsubscribe;
+  /** Listen for the front driver door. */
+  listen_front_driver_door(callback: (state: ClosureStateE) => void): Unsubscribe;
+  /** Listen for the front passenger door. */
+  listen_front_passenger_door(callback: (state: ClosureStateE) => void): Unsubscribe;
+  /** Listen for the rear driver door. */
+  listen_rear_driver_door(callback: (state: ClosureStateE) => void): Unsubscribe;
+  /** Listen for the rear passenger door. */
+  listen_rear_passenger_door(callback: (state: ClosureStateE) => void): Unsubscribe;
+  /** Listen for the front trunk. */
+  listen_front_trunk(callback: (state: ClosureStateE) => void): Unsubscribe;
+  /** Listen for the rear trunk. */
+  listen_rear_trunk(callback: (state: ClosureStateE) => void): Unsubscribe;
+  /** Listen for the charge port. */
+  listen_charge_port(callback: (state: ClosureStateE) => void): Unsubscribe;
+  /** Listen for the tonneau. */
+  listen_tonneau(callback: (state: ClosureStateE) => void): Unsubscribe;
+}

package/dist/bluetooth/broadcast.mjs

@@ -0,0 +1,151 @@
+import Commands from "../commands.mjs";
+import { Domain } from "@teslemetry/tesla-protocol/command/universal_message";
+import { FromVCSECMessage } from "@teslemetry/tesla-protocol/command/vcsec";
+// src/bluetooth/broadcast.ts
+/**
+* Local callbacks, not tied to a connection, so they live as long as the
+* vehicle and survive reconnects. A callback that throws is logged, and neither
+* later callbacks nor message routing see it.
+*/
+var ListenerRegistry = class {
+	log;
+	entries = [];
+	constructor(log) {
+		this.log = log;
+	}
+	get size() {
+		return this.entries.length;
+	}
+	add(callback) {
+		const entry = { callback };
+		this.entries.push(entry);
+		return () => {
+			this.entries = this.entries.filter((other) => other !== entry);
+		};
+	}
+	emit(value) {
+		for (const { callback } of this.entries) try {
+			callback(value);
+		} catch (error) {
+			this.log(`BLE listener failed: ${error instanceof Error ? `${error.name}: ${error.message}` : String(error)}`);
+		}
+	}
+};
+/**
+* A broadcast's VCSEC status, if it carries one. Broadcasts are unsigned, so
+* they need no session and prove nothing about who sent them.
+*/
+function decodeVcsecStatus(message) {
+	if (message.protobufMessageAsBytes === void 0) return null;
+	try {
+		return FromVCSECMessage.decode(message.protobufMessageAsBytes).vehicleStatus ?? null;
+	} catch {
+		return null;
+	}
+}
+/**
+* Persistent listeners for unsolicited broadcasts, which arrive on the same
+* notifications as command replies. Each `VehicleStatus` leaf has a typed
+* `listen_*`, and `listen_broadcast` takes every raw broadcast on a domain,
+* including payloads with no typed listener.
+*
+* The scalar listeners fire on every status broadcast with whatever value it
+* holds, because proto3 has no presence on them, so a lock-only broadcast also
+* reports `GEAR_UNKNOWN`. The closure listeners fire only when the broadcast
+* carries the block they read.
+*/
+var BroadcastListeners = class extends Commands {
+	statusListeners = new ListenerRegistry((message) => this.log(message));
+	domainListeners = /* @__PURE__ */ new Map();
+	log(message) {
+		this.parent.parent._log(message);
+	}
+	/** Hand one unaddressed message to everything listening. */
+	dispatchBroadcast(domain, message) {
+		this.domainListeners.get(domain)?.emit(message);
+		if (domain === Domain.DOMAIN_VEHICLE_SECURITY && this.statusListeners.size > 0) {
+			const status = decodeVcsecStatus(message);
+			if (status) this.statusListeners.emit(status);
+		}
+	}
+	listenClosure(callback) {
+		return this.statusListeners.add((status) => {
+			if (status.closureStatuses) callback(status.closureStatuses);
+		});
+	}
+	/** Listen for every unsolicited broadcast on `domain`, including `VehicleStatus`. */
+	listen_broadcast(domain, callback) {
+		let registry = this.domainListeners.get(domain);
+		if (!registry) {
+			registry = new ListenerRegistry((message) => this.log(message));
+			this.domainListeners.set(domain, registry);
+		}
+		return registry.add(callback);
+	}
+	/** Listen for the vehicle's overall lock state. */
+	listen_vehicle_lock_state(callback) {
+		return this.statusListeners.add((status) => callback(status.vehicleLockState));
+	}
+	/** Listen for the vehicle's sleep status. */
+	listen_vehicle_sleep_status(callback) {
+		return this.statusListeners.add((status) => callback(status.vehicleSleepStatus));
+	}
+	/** Listen for driver presence. */
+	listen_user_presence(callback) {
+		return this.statusListeners.add((status) => callback(status.userPresence));
+	}
+	/** Listen for the gear selection. */
+	listen_gear(callback) {
+		return this.statusListeners.add((status) => callback(status.gear));
+	}
+	/** Listen for the UI desire state. */
+	listen_ui_desire(callback) {
+		return this.statusListeners.add((status) => callback(status.UIDesire));
+	}
+	/** Listen for the tonneau's open percentage, on broadcasts that carry it. */
+	listen_tonneau_percent_open(callback) {
+		return this.statusListeners.add((status) => {
+			if (status.detailedClosureStatus) callback(status.detailedClosureStatus.tonneauPercentOpen);
+		});
+	}
+	/**
+	* Listen for a broadcast's whole closure block in one call. The listeners
+	* below each fire separately for the same broadcast.
+	*/
+	listen_closure_statuses(callback) {
+		return this.listenClosure(callback);
+	}
+	/** Listen for the front driver door. */
+	listen_front_driver_door(callback) {
+		return this.listenClosure((closures) => callback(closures.frontDriverDoor));
+	}
+	/** Listen for the front passenger door. */
+	listen_front_passenger_door(callback) {
+		return this.listenClosure((closures) => callback(closures.frontPassengerDoor));
+	}
+	/** Listen for the rear driver door. */
+	listen_rear_driver_door(callback) {
+		return this.listenClosure((closures) => callback(closures.rearDriverDoor));
+	}
+	/** Listen for the rear passenger door. */
+	listen_rear_passenger_door(callback) {
+		return this.listenClosure((closures) => callback(closures.rearPassengerDoor));
+	}
+	/** Listen for the front trunk. */
+	listen_front_trunk(callback) {
+		return this.listenClosure((closures) => callback(closures.frontTrunk));
+	}
+	/** Listen for the rear trunk. */
+	listen_rear_trunk(callback) {
+		return this.listenClosure((closures) => callback(closures.rearTrunk));
+	}
+	/** Listen for the charge port. */
+	listen_charge_port(callback) {
+		return this.listenClosure((closures) => callback(closures.chargePort));
+	}
+	/** Listen for the tonneau. */
+	listen_tonneau(callback) {
+		return this.listenClosure((closures) => callback(closures.tonneau));
+	}
+};
+export { BroadcastListeners, ListenerRegistry, decodeVcsecStatus };

package/dist/bluetooth/constants.cjs

@@ -0,0 +1,99 @@
+// src/bluetooth/constants.ts
+/** The vehicle's GATT service. It is never advertised, so never scan for it. */
+const SERVICE_UUID = "00000211-b2d1-43f0-9b88-960cebf8b91e";
+/** Client to car. Tesla's Go SDK names the two by the opposite view, hence these names. */
+const VEHICLE_WRITE_UUID = "00000212-b2d1-43f0-9b88-960cebf8b91e";
+/** Car to client. */
+const VEHICLE_NOTIFY_UUID = "00000213-b2d1-43f0-9b88-960cebf8b91e";
+/** Python's name for `VEHICLE_WRITE_UUID`. */
+const WRITE_UUID = VEHICLE_WRITE_UUID;
+/** Python's name for `VEHICLE_NOTIFY_UUID`. */
+const READ_UUID = VEHICLE_NOTIFY_UUID;
+/** The keepalive read target. */
+const VERSION_UUID = "00000214-b2d1-43f0-9b88-960cebf8b91e";
+/** GATT Device Name. */
+const NAME_UUID = "00002a00-0000-1000-8000-00805f9b34fb";
+/** GATT Appearance. */
+const APPEARANCE_UUID = "00002a01-0000-1000-8000-00805f9b34fb";
+/** Generic Access, for a backend that needs a service UUID to reach the two above. */
+const GENERIC_ACCESS_UUID = "00001800-0000-1000-8000-00805f9b34fb";
+/** Client Characteristic Configuration. Only an ESPHome proxy needs it written by hand. */
+const CCCD_UUID = "00002902-0000-1000-8000-00805f9b34fb";
+/** Largest frame accepted, length prefix included. Tesla's Go SDK allows 2 more bytes. */
+const MAX_FRAME_SIZE = 1024;
+/**
+* Bytes per write when a connection does not say: the ATT default MTU of 23,
+* less 3 of header. Safe on any link, and all Homey offers, as it hides the MTU.
+*/
+const DEFAULT_MAX_WRITE_SIZE = 20;
+/** A chunk after this much silence means the partial frame before it was abandoned. */
+const STALE_CHUNK_TIMEOUT_MS = 1e3;
+/** An idle held link drops at about 42 s on average; a read this often keeps it about 10 times longer. */
+const DEFAULT_KEEPALIVE_INTERVAL_MS = 2e4;
+/** Infotainment answers a handshake 4 to 16 s after an RKE wake. */
+const DEFAULT_WAKE_TIMEOUT_MS = 3e4;
+/**
+* One infotainment readiness probe. A ready infotainment answers in 0.26 to 0.39 s.
+* The window opens once the request is fully written, so a slow 20-byte link
+* spends none of it writing. Raise it with `wake_probe_timeout_ms` if a link's
+* replies are slower than this, as a probe that keeps timing out never proves
+* the car is ready.
+*/
+const DEFAULT_WAKE_PROBE_TIMEOUT_MS = 1e3;
+/** How often a wake is resent while infotainment stays silent: a first wake can be missed after a long sleep. */
+const WAKE_RESEND_INTERVAL_MS = 3e3;
+/** How long an awake car's infotainment may take to finish booting. */
+const INFOTAINMENT_BOOT_TIMEOUT_MS = 2e4;
+/** How long a charge-port opening has to show in charge state. It took about 1.4 s in live trials. */
+const CHARGE_PORT_VERIFY_TIMEOUT_MS = 5e3;
+/** Between charge-state polls, while waiting for readiness or for the latch. */
+const CHARGE_PORT_VERIFY_INTERVAL_MS = 250;
+/** How long `pair` waits for someone to tap a key card. */
+const DEFAULT_PAIR_TIMEOUT_MS = 3e5;
+/** Between `pair`'s checks of whether the key was accepted. */
+const DEFAULT_PAIR_POLL_INTERVAL_MS = 5e3;
+/** Connect attempts. Each is bounded by `DEFAULT_CONNECT_TIMEOUT_MS`. */
+const DEFAULT_CONNECT_ATTEMPTS = 3;
+/** One connect attempt. Python takes the same figure from `bleak-retry-connector`. */
+const DEFAULT_CONNECT_TIMEOUT_MS = 2e4;
+/** One scan. It must outlast the backend's window, which Homey fixes at about 5 s. */
+const DEFAULT_SCAN_TIMEOUT_MS = 1e4;
+/** Bound on tearing down a link: the failure behind it is what gets reported. */
+const LINK_TEARDOWN_TIMEOUT_MS = 5e3;
+/**
+* One write call. Not in Python, whose backends bound their own writes. Homey's
+* have no timeout and its link state can be stale, so a hung write must end
+* here. A design choice. BLE-00 step 10 measures how long a failing write takes
+* on Homey, which sets it.
+*/
+const GATT_WRITE_TIMEOUT_MS = 5e3;
+/** One read call, other than a keepalive's. */
+const GATT_READ_TIMEOUT_MS = 5e3;
+exports.APPEARANCE_UUID = APPEARANCE_UUID;
+exports.CCCD_UUID = CCCD_UUID;
+exports.CHARGE_PORT_VERIFY_INTERVAL_MS = CHARGE_PORT_VERIFY_INTERVAL_MS;
+exports.CHARGE_PORT_VERIFY_TIMEOUT_MS = CHARGE_PORT_VERIFY_TIMEOUT_MS;
+exports.DEFAULT_CONNECT_ATTEMPTS = DEFAULT_CONNECT_ATTEMPTS;
+exports.DEFAULT_CONNECT_TIMEOUT_MS = DEFAULT_CONNECT_TIMEOUT_MS;
+exports.DEFAULT_KEEPALIVE_INTERVAL_MS = DEFAULT_KEEPALIVE_INTERVAL_MS;
+exports.DEFAULT_MAX_WRITE_SIZE = DEFAULT_MAX_WRITE_SIZE;
+exports.DEFAULT_PAIR_POLL_INTERVAL_MS = DEFAULT_PAIR_POLL_INTERVAL_MS;
+exports.DEFAULT_PAIR_TIMEOUT_MS = DEFAULT_PAIR_TIMEOUT_MS;
+exports.DEFAULT_SCAN_TIMEOUT_MS = DEFAULT_SCAN_TIMEOUT_MS;
+exports.DEFAULT_WAKE_PROBE_TIMEOUT_MS = DEFAULT_WAKE_PROBE_TIMEOUT_MS;
+exports.DEFAULT_WAKE_TIMEOUT_MS = DEFAULT_WAKE_TIMEOUT_MS;
+exports.GATT_READ_TIMEOUT_MS = GATT_READ_TIMEOUT_MS;
+exports.GATT_WRITE_TIMEOUT_MS = GATT_WRITE_TIMEOUT_MS;
+exports.GENERIC_ACCESS_UUID = GENERIC_ACCESS_UUID;
+exports.INFOTAINMENT_BOOT_TIMEOUT_MS = INFOTAINMENT_BOOT_TIMEOUT_MS;
+exports.LINK_TEARDOWN_TIMEOUT_MS = LINK_TEARDOWN_TIMEOUT_MS;
+exports.MAX_FRAME_SIZE = MAX_FRAME_SIZE;
+exports.NAME_UUID = NAME_UUID;
+exports.READ_UUID = READ_UUID;
+exports.SERVICE_UUID = SERVICE_UUID;
+exports.STALE_CHUNK_TIMEOUT_MS = STALE_CHUNK_TIMEOUT_MS;
+exports.VEHICLE_NOTIFY_UUID = VEHICLE_NOTIFY_UUID;
+exports.VEHICLE_WRITE_UUID = VEHICLE_WRITE_UUID;
+exports.VERSION_UUID = VERSION_UUID;
+exports.WAKE_RESEND_INTERVAL_MS = WAKE_RESEND_INTERVAL_MS;
+exports.WRITE_UUID = WRITE_UUID;

package/dist/bluetooth/constants.d.cts

@@ -0,0 +1,70 @@
+/** The vehicle's GATT service. It is never advertised, so never scan for it. */
+export declare const SERVICE_UUID = "00000211-b2d1-43f0-9b88-960cebf8b91e";
+/** Client to car. Tesla's Go SDK names the two by the opposite view, hence these names. */
+export declare const VEHICLE_WRITE_UUID = "00000212-b2d1-43f0-9b88-960cebf8b91e";
+/** Car to client. */
+export declare const VEHICLE_NOTIFY_UUID = "00000213-b2d1-43f0-9b88-960cebf8b91e";
+/** Python's name for `VEHICLE_WRITE_UUID`. */
+export declare const WRITE_UUID = "00000212-b2d1-43f0-9b88-960cebf8b91e";
+/** Python's name for `VEHICLE_NOTIFY_UUID`. */
+export declare const READ_UUID = "00000213-b2d1-43f0-9b88-960cebf8b91e";
+/** The keepalive read target. */
+export declare const VERSION_UUID = "00000214-b2d1-43f0-9b88-960cebf8b91e";
+/** GATT Device Name. */
+export declare const NAME_UUID = "00002a00-0000-1000-8000-00805f9b34fb";
+/** GATT Appearance. */
+export declare const APPEARANCE_UUID = "00002a01-0000-1000-8000-00805f9b34fb";
+/** Generic Access, for a backend that needs a service UUID to reach the two above. */
+export declare const GENERIC_ACCESS_UUID = "00001800-0000-1000-8000-00805f9b34fb";
+/** Client Characteristic Configuration. Only an ESPHome proxy needs it written by hand. */
+export declare const CCCD_UUID = "00002902-0000-1000-8000-00805f9b34fb";
+/** Largest frame accepted, length prefix included. Tesla's Go SDK allows 2 more bytes. */
+export declare const MAX_FRAME_SIZE = 1024;
+/**
+ * Bytes per write when a connection does not say: the ATT default MTU of 23,
+ * less 3 of header. Safe on any link, and all Homey offers, as it hides the MTU.
+ */
+export declare const DEFAULT_MAX_WRITE_SIZE = 20;
+/** A chunk after this much silence means the partial frame before it was abandoned. */
+export declare const STALE_CHUNK_TIMEOUT_MS = 1000;
+/** An idle held link drops at about 42 s on average; a read this often keeps it about 10 times longer. */
+export declare const DEFAULT_KEEPALIVE_INTERVAL_MS = 20000;
+/** Infotainment answers a handshake 4 to 16 s after an RKE wake. */
+export declare const DEFAULT_WAKE_TIMEOUT_MS = 30000;
+/**
+ * One infotainment readiness probe. A ready infotainment answers in 0.26 to 0.39 s.
+ * The window opens once the request is fully written, so a slow 20-byte link
+ * spends none of it writing. Raise it with `wake_probe_timeout_ms` if a link's
+ * replies are slower than this, as a probe that keeps timing out never proves
+ * the car is ready.
+ */
+export declare const DEFAULT_WAKE_PROBE_TIMEOUT_MS = 1000;
+/** How often a wake is resent while infotainment stays silent: a first wake can be missed after a long sleep. */
+export declare const WAKE_RESEND_INTERVAL_MS = 3000;
+/** How long an awake car's infotainment may take to finish booting. */
+export declare const INFOTAINMENT_BOOT_TIMEOUT_MS = 20000;
+/** How long a charge-port opening has to show in charge state. It took about 1.4 s in live trials. */
+export declare const CHARGE_PORT_VERIFY_TIMEOUT_MS = 5000;
+/** Between charge-state polls, while waiting for readiness or for the latch. */
+export declare const CHARGE_PORT_VERIFY_INTERVAL_MS = 250;
+/** How long `pair` waits for someone to tap a key card. */
+export declare const DEFAULT_PAIR_TIMEOUT_MS = 300000;
+/** Between `pair`'s checks of whether the key was accepted. */
+export declare const DEFAULT_PAIR_POLL_INTERVAL_MS = 5000;
+/** Connect attempts. Each is bounded by `DEFAULT_CONNECT_TIMEOUT_MS`. */
+export declare const DEFAULT_CONNECT_ATTEMPTS = 3;
+/** One connect attempt. Python takes the same figure from `bleak-retry-connector`. */
+export declare const DEFAULT_CONNECT_TIMEOUT_MS = 20000;
+/** One scan. It must outlast the backend's window, which Homey fixes at about 5 s. */
+export declare const DEFAULT_SCAN_TIMEOUT_MS = 10000;
+/** Bound on tearing down a link: the failure behind it is what gets reported. */
+export declare const LINK_TEARDOWN_TIMEOUT_MS = 5000;
+/**
+ * One write call. Not in Python, whose backends bound their own writes. Homey's
+ * have no timeout and its link state can be stale, so a hung write must end
+ * here. A design choice. BLE-00 step 10 measures how long a failing write takes
+ * on Homey, which sets it.
+ */
+export declare const GATT_WRITE_TIMEOUT_MS = 5000;
+/** One read call, other than a keepalive's. */
+export declare const GATT_READ_TIMEOUT_MS = 5000;

package/dist/bluetooth/constants.d.mts

@@ -0,0 +1,70 @@
+/** The vehicle's GATT service. It is never advertised, so never scan for it. */
+export declare const SERVICE_UUID = "00000211-b2d1-43f0-9b88-960cebf8b91e";
+/** Client to car. Tesla's Go SDK names the two by the opposite view, hence these names. */
+export declare const VEHICLE_WRITE_UUID = "00000212-b2d1-43f0-9b88-960cebf8b91e";
+/** Car to client. */
+export declare const VEHICLE_NOTIFY_UUID = "00000213-b2d1-43f0-9b88-960cebf8b91e";
+/** Python's name for `VEHICLE_WRITE_UUID`. */
+export declare const WRITE_UUID = "00000212-b2d1-43f0-9b88-960cebf8b91e";
+/** Python's name for `VEHICLE_NOTIFY_UUID`. */
+export declare const READ_UUID = "00000213-b2d1-43f0-9b88-960cebf8b91e";
+/** The keepalive read target. */
+export declare const VERSION_UUID = "00000214-b2d1-43f0-9b88-960cebf8b91e";
+/** GATT Device Name. */
+export declare const NAME_UUID = "00002a00-0000-1000-8000-00805f9b34fb";
+/** GATT Appearance. */
+export declare const APPEARANCE_UUID = "00002a01-0000-1000-8000-00805f9b34fb";
+/** Generic Access, for a backend that needs a service UUID to reach the two above. */
+export declare const GENERIC_ACCESS_UUID = "00001800-0000-1000-8000-00805f9b34fb";
+/** Client Characteristic Configuration. Only an ESPHome proxy needs it written by hand. */
+export declare const CCCD_UUID = "00002902-0000-1000-8000-00805f9b34fb";
+/** Largest frame accepted, length prefix included. Tesla's Go SDK allows 2 more bytes. */
+export declare const MAX_FRAME_SIZE = 1024;
+/**
+ * Bytes per write when a connection does not say: the ATT default MTU of 23,
+ * less 3 of header. Safe on any link, and all Homey offers, as it hides the MTU.
+ */
+export declare const DEFAULT_MAX_WRITE_SIZE = 20;
+/** A chunk after this much silence means the partial frame before it was abandoned. */
+export declare const STALE_CHUNK_TIMEOUT_MS = 1000;
+/** An idle held link drops at about 42 s on average; a read this often keeps it about 10 times longer. */
+export declare const DEFAULT_KEEPALIVE_INTERVAL_MS = 20000;
+/** Infotainment answers a handshake 4 to 16 s after an RKE wake. */
+export declare const DEFAULT_WAKE_TIMEOUT_MS = 30000;
+/**
+ * One infotainment readiness probe. A ready infotainment answers in 0.26 to 0.39 s.
+ * The window opens once the request is fully written, so a slow 20-byte link
+ * spends none of it writing. Raise it with `wake_probe_timeout_ms` if a link's
+ * replies are slower than this, as a probe that keeps timing out never proves
+ * the car is ready.
+ */
+export declare const DEFAULT_WAKE_PROBE_TIMEOUT_MS = 1000;
+/** How often a wake is resent while infotainment stays silent: a first wake can be missed after a long sleep. */
+export declare const WAKE_RESEND_INTERVAL_MS = 3000;
+/** How long an awake car's infotainment may take to finish booting. */
+export declare const INFOTAINMENT_BOOT_TIMEOUT_MS = 20000;
+/** How long a charge-port opening has to show in charge state. It took about 1.4 s in live trials. */
+export declare const CHARGE_PORT_VERIFY_TIMEOUT_MS = 5000;
+/** Between charge-state polls, while waiting for readiness or for the latch. */
+export declare const CHARGE_PORT_VERIFY_INTERVAL_MS = 250;
+/** How long `pair` waits for someone to tap a key card. */
+export declare const DEFAULT_PAIR_TIMEOUT_MS = 300000;
+/** Between `pair`'s checks of whether the key was accepted. */
+export declare const DEFAULT_PAIR_POLL_INTERVAL_MS = 5000;
+/** Connect attempts. Each is bounded by `DEFAULT_CONNECT_TIMEOUT_MS`. */
+export declare const DEFAULT_CONNECT_ATTEMPTS = 3;
+/** One connect attempt. Python takes the same figure from `bleak-retry-connector`. */
+export declare const DEFAULT_CONNECT_TIMEOUT_MS = 20000;
+/** One scan. It must outlast the backend's window, which Homey fixes at about 5 s. */
+export declare const DEFAULT_SCAN_TIMEOUT_MS = 10000;
+/** Bound on tearing down a link: the failure behind it is what gets reported. */
+export declare const LINK_TEARDOWN_TIMEOUT_MS = 5000;
+/**
+ * One write call. Not in Python, whose backends bound their own writes. Homey's
+ * have no timeout and its link state can be stale, so a hung write must end
+ * here. A design choice. BLE-00 step 10 measures how long a failing write takes
+ * on Homey, which sets it.
+ */
+export declare const GATT_WRITE_TIMEOUT_MS = 5000;
+/** One read call, other than a keepalive's. */
+export declare const GATT_READ_TIMEOUT_MS = 5000;