tesla-fleet-api 0.4.0 → 0.6.0

package/dist/bluetooth/noble.mjs

@@ -0,0 +1,177 @@
+import { AsyncLock, withTimeout } from "./async.mjs";
+import { APPEARANCE_UUID, DEFAULT_CONNECT_TIMEOUT_MS, 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/noble.ts
+function find(characteristics, uuid) {
+	return characteristics.find((characteristic) => compactUuid(characteristic.uuid) === compactUuid(uuid));
+}
+async function loadNoble(bindings) {
+	const specifier = "@stoprocent/noble/lib/resolve-bindings.js";
+	let module;
+	try {
+		module = await import(specifier);
+	} catch (cause) {
+		throw new Error("NobleBleTransport needs @stoprocent/noble, or a `noble` option.", { cause });
+	}
+	return module.default(bindings);
+}
+var NobleConnection = class {
+	peripheral;
+	handlers;
+	claims;
+	lost = false;
+	closed = false;
+	closing;
+	genericAccess;
+	characteristics = [];
+	onData = (data, isNotification) => {
+		if (isNotification !== false) this.handlers.onNotify(data);
+	};
+	onDisconnect = () => {
+		this.lost = true;
+		if (!this.closed) this.handlers.onDisconnect();
+	};
+	constructor(peripheral, handlers, claims) {
+		this.peripheral = peripheral;
+		this.handlers = handlers;
+		this.claims = claims;
+	}
+	get isConnected() {
+		return !this.lost && !this.closed && this.peripheral.state === "connected";
+	}
+	/** Read each time: noble can report a larger MTU after the link is up. */
+	get maxWriteSize() {
+		const { mtu } = this.peripheral;
+		return mtu && mtu > 3 ? mtu - 3 : 20;
+	}
+	/** Resolve the characteristics and turn notifications on. */
+	async subscribe() {
+		const { peripheral } = this;
+		const { characteristics } = await peripheral.discoverSomeServicesAndCharacteristicsAsync([compactUuid(SERVICE_UUID)], [
+			VEHICLE_WRITE_UUID,
+			VEHICLE_NOTIFY_UUID,
+			VERSION_UUID
+		].map(compactUuid));
+		const notify = find(characteristics, VEHICLE_NOTIFY_UUID);
+		if (!notify || !find(characteristics, "00000212-b2d1-43f0-9b88-960cebf8b91e")) throw new Error("The vehicle's write or notify characteristic was not found.");
+		this.assertCurrent();
+		this.characteristics = characteristics;
+		notify.on("data", this.onData);
+		await notify.subscribeAsync();
+	}
+	/** A superseded attempt stops here, before it changes a link another attempt owns. */
+	assertCurrent() {
+		if (this.claims.superseded(this.peripheral.id, this)) throw new Error("A newer connect attempt took over this link.");
+	}
+	async write(data) {
+		const characteristic = find(this.characteristics, VEHICLE_WRITE_UUID);
+		if (!characteristic) throw new BleNotSubmittedError("The vehicle write characteristic was not found.");
+		if (!this.isConnected) throw new BleNotSubmittedError("The link is down.");
+		await characteristic.writeAsync(Buffer.from(data), false);
+	}
+	async read(characteristic) {
+		const target = characteristic === "version" ? find(this.characteristics, VERSION_UUID) : find(await this.discoverGenericAccess(), characteristic === "deviceName" ? NAME_UUID : APPEARANCE_UUID);
+		if (!target) throw new BleNotSubmittedError(`The ${characteristic} characteristic was not found.`);
+		return target.readAsync();
+	}
+	/**
+	* BlueZ and CoreBluetooth can hide this service. A failed lookup leaves a
+	* characteristic unresolved on a healthy link, so it must not read as a lost one.
+	*/
+	discoverGenericAccess() {
+		this.genericAccess ??= this.peripheral.discoverSomeServicesAndCharacteristicsAsync([compactUuid(GENERIC_ACCESS_UUID)], [compactUuid(NAME_UUID), compactUuid(APPEARANCE_UUID)]).then(({ characteristics }) => characteristics).catch((cause) => {
+			this.genericAccess = void 0;
+			throw new BleNotSubmittedError("Generic Access could not be resolved.", { cause });
+		});
+		return this.genericAccess;
+	}
+	disconnect() {
+		this.closing ??= (async () => {
+			this.closed = true;
+			const { peripheral, claims } = this;
+			peripheral.removeListener("disconnect", this.onDisconnect);
+			find(this.characteristics, VEHICLE_NOTIFY_UUID)?.removeListener("data", this.onData);
+			const superseded = claims.superseded(peripheral.id, this);
+			claims.release(peripheral.id, this);
+			if (!superseded && peripheral.state !== "disconnected") await quietly(() => peripheral.disconnectAsync());
+		})();
+		return this.closing;
+	}
+};
+var NobleBleTransport = class {
+	options;
+	backend;
+	scans = new AsyncLock();
+	peripherals = /* @__PURE__ */ new Map();
+	claims = new LinkClaims();
+	constructor(options = {}) {
+		this.options = options;
+	}
+	noble() {
+		if (this.options.noble) return Promise.resolve(this.options.noble);
+		const fallback = process.platform === "linux" ? "dbus" : "default";
+		const loading = this.backend ??= loadNoble(this.options.bindings ?? fallback);
+		loading.catch(() => {
+			this.backend = void 0;
+		});
+		return loading;
+	}
+	async scan({ timeoutMs, matches }) {
+		const noble = await this.noble();
+		return this.listen(noble, timeoutMs, (device) => device.name !== void 0 && matches?.(device.name) === true);
+	}
+	/** Scan with no service filter until `done` accepts a device or the window ends. */
+	listen(noble, timeoutMs, done) {
+		return this.scans.run(async () => {
+			await noble.waitForPoweredOnAsync(timeoutMs);
+			const seen = /* @__PURE__ */ new Map();
+			let finish;
+			const finished = new Promise((resolve) => {
+				finish = resolve;
+			});
+			const onDiscover = (peripheral) => {
+				this.peripherals.set(peripheral.id, peripheral);
+				const device = {
+					id: peripheral.id,
+					name: peripheral.advertisement.localName ?? seen.get(peripheral.id)?.name,
+					rssi: peripheral.rssi,
+					connectable: peripheral.connectable
+				};
+				seen.set(peripheral.id, device);
+				if (done(device)) finish();
+			};
+			noble.on("discover", onDiscover);
+			const timer = setTimeout(finish, Math.max(0, timeoutMs - 250));
+			try {
+				await noble.startScanningAsync([], true);
+				await finished;
+			} finally {
+				clearTimeout(timer);
+				noble.removeListener("discover", onDiscover);
+				await quietly(() => noble.stopScanningAsync());
+			}
+			return [...seen.values()];
+		});
+	}
+	async connect(device, handlers) {
+		const noble = await this.noble();
+		if (!this.peripherals.has(device.id)) await this.listen(noble, DEFAULT_SCAN_TIMEOUT_MS, ({ id }) => id === device.id);
+		const peripheral = this.peripherals.get(device.id);
+		if (!peripheral) throw new Error("The device was not seen in a scan.");
+		await quietly(() => noble.stopScanningAsync());
+		const connection = new NobleConnection(peripheral, handlers, this.claims);
+		this.claims.claim(device.id, connection);
+		peripheral.once("disconnect", connection.onDisconnect);
+		try {
+			await peripheral.connectAsync();
+			connection.assertCurrent();
+			await withTimeout(() => connection.subscribe(), DEFAULT_CONNECT_TIMEOUT_MS);
+		} catch (error) {
+			await connection.disconnect();
+			throw error;
+		}
+		return connection;
+	}
+};
+export { NobleBleTransport };

package/dist/bluetooth/streamglue.cjs

@@ -0,0 +1,157 @@
+const require_funnel = require("../funnel.cjs");
+let _teslemetry_tesla_protocol_command_vcsec = require("@teslemetry/tesla-protocol/command/vcsec");
+// src/bluetooth/streamglue.ts
+const GEAR_STATES = /* @__PURE__ */ new Map([
+	[_teslemetry_tesla_protocol_command_vcsec.GearE.GEAR_PARK, "ShiftStateP"],
+	[_teslemetry_tesla_protocol_command_vcsec.GearE.GEAR_DRIVE, "ShiftStateD"],
+	[_teslemetry_tesla_protocol_command_vcsec.GearE.GEAR_REVERSE, "ShiftStateR"],
+	[_teslemetry_tesla_protocol_command_vcsec.GearE.GEAR_NEUTRAL, "ShiftStateN"]
+]);
+const TONNEAU_POSITION_STATES = /* @__PURE__ */ new Map([
+	[_teslemetry_tesla_protocol_command_vcsec.ClosureStateE.CLOSURESTATE_CLOSED, "TonneauPositionStateClosed"],
+	[_teslemetry_tesla_protocol_command_vcsec.ClosureStateE.CLOSURESTATE_OPEN, "TonneauPositionStateFullyOpen"],
+	[_teslemetry_tesla_protocol_command_vcsec.ClosureStateE.CLOSURESTATE_AJAR, "TonneauPositionStatePartiallyOpen"]
+]);
+/** A closure state's name, or the bare number for one this build has no name for. */
+function closureName(state) {
+	const name = (0, _teslemetry_tesla_protocol_command_vcsec.closureStateEToJSON)(state);
+	return name === "UNRECOGNIZED" ? String(state) : name;
+}
+/**
+* Feeds a vehicle's broadcasts into a stream-shaped sink, so a Bluetooth reading
+* reaches the listeners a native stream event does. There is no source ranking:
+* every call reaches them in arrival order.
+*/
+var BleBroadcastStreamGlue = class {
+	#sink;
+	#unsubscribes;
+	constructor(vehicle, sink) {
+		this.#sink = sink;
+		this.#unsubscribes = [
+			vehicle.listen_vehicle_lock_state((state) => this.#onLockState(state)),
+			vehicle.listen_charge_port((state) => this.#onChargePort(state)),
+			vehicle.listen_closure_statuses((closures) => this.#onClosures(closures)),
+			vehicle.listen_gear((gear) => this.#onGear(gear)),
+			vehicle.listen_tonneau((state) => this.#onTonneau(state)),
+			vehicle.listen_tonneau_percent_open((percent) => this.#sink.ingest({ TonneauOpenPercent: percent }, { source: "bluetooth" }))
+		];
+	}
+	/** Stop listening. Safe to call twice. */
+	stop() {
+		for (const unsubscribe of this.#unsubscribes) unsubscribe();
+		this.#unsubscribes = [];
+	}
+	#onLockState(state) {
+		const locked = require_funnel.LOCK_STATES.get(state);
+		if (locked !== void 0) this.#sink.ingest({ Locked: locked }, {
+			source: "bluetooth",
+			raw: (0, _teslemetry_tesla_protocol_command_vcsec.vehicleLockStateEToJSON)(state)
+		});
+	}
+	#onChargePort(state) {
+		const open = require_funnel.CLOSURE_STATES.get(state);
+		if (open !== void 0) this.#sink.ingest({ ChargePortDoorOpen: open }, {
+			source: "bluetooth",
+			raw: (0, _teslemetry_tesla_protocol_command_vcsec.closureStateEToJSON)(state)
+		});
+	}
+	/**
+	* Every door listener fires on any `DoorState` event and reads its own key, so
+	* a leaf sent alone would reach the other five as missing. All six go in one
+	* event, as a native event's do, with a leaf in an unmapped state left out.
+	*/
+	#onClosures(closures) {
+		const raw = {
+			DriverFront: closures.frontDriverDoor,
+			PassengerFront: closures.frontPassengerDoor,
+			DriverRear: closures.rearDriverDoor,
+			PassengerRear: closures.rearPassengerDoor,
+			TrunkFront: closures.frontTrunk,
+			TrunkRear: closures.rearTrunk
+		};
+		const leaves = Object.entries(raw);
+		const doorState = leaves.flatMap(([key, state]) => {
+			const open = require_funnel.CLOSURE_STATES.get(state);
+			return open === void 0 ? [] : [[key, open]];
+		});
+		if (doorState.length > 0) this.#sink.ingest({ DoorState: Object.fromEntries(doorState) }, {
+			source: "bluetooth",
+			raw: Object.fromEntries(leaves.map(([key, state]) => [key, closureName(state)]))
+		});
+	}
+	#onGear(gear) {
+		const state = GEAR_STATES.get(gear);
+		if (state !== void 0) this.#sink.ingest({ Gear: state }, {
+			source: "bluetooth",
+			raw: (0, _teslemetry_tesla_protocol_command_vcsec.gearEToJSON)(gear)
+		});
+	}
+	#onTonneau(state) {
+		const position = TONNEAU_POSITION_STATES.get(state);
+		if (position !== void 0) this.#sink.ingest({ TonneauPosition: position }, {
+			source: "bluetooth",
+			raw: (0, _teslemetry_tesla_protocol_command_vcsec.closureStateEToJSON)(state)
+		});
+	}
+};
+/** The map and listener behind each field a broadcast carries. */
+const BROADCAST_FIELDS = /* @__PURE__ */ new Map([
+	[require_funnel.FieldPath.LOCKED, {
+		states: require_funnel.LOCK_STATES,
+		listen: (vehicle, callback) => vehicle.listen_vehicle_lock_state(callback)
+	}],
+	[require_funnel.FieldPath.CHARGE_PORT_DOOR_OPEN, {
+		states: require_funnel.CLOSURE_STATES,
+		listen: (vehicle, callback) => vehicle.listen_charge_port(callback)
+	}],
+	[require_funnel.FieldPath.DOOR_STATE_TRUNK_FRONT, {
+		states: require_funnel.CLOSURE_STATES,
+		listen: (vehicle, callback) => vehicle.listen_front_trunk(callback)
+	}]
+]);
+/**
+* Publishes VCSEC status broadcasts to an `ObservationFunnel`. Registration only:
+* a dropped session ends the broadcasts and says nothing about the fields, so it
+* publishes nothing.
+*/
+var BleBroadcastPublisher = class {
+	paths = new Set(BROADCAST_FIELDS.keys());
+	#vehicle;
+	#clock;
+	#subscriptions = /* @__PURE__ */ new Map();
+	#sink = null;
+	constructor(vehicle, options = {}) {
+		this.#vehicle = vehicle;
+		this.#clock = options.clock ?? (() => performance.now() / 1e3);
+	}
+	attach(sink) {
+		this.#sink = sink;
+		return () => {
+			this.release(new Set(this.#subscriptions.keys()));
+			this.#sink = null;
+		};
+	}
+	request(paths) {
+		for (const path of paths) {
+			const field = BROADCAST_FIELDS.get(path);
+			if (field && !this.#subscriptions.has(path)) this.#subscriptions.set(path, field.listen(this.#vehicle, (state) => {
+				const value = field.states.get(state);
+				if (value !== void 0) this.#sink?.publish({
+					path,
+					value,
+					observed_at: this.#clock()
+				});
+			}));
+		}
+	}
+	release(paths) {
+		for (const path of paths) {
+			this.#subscriptions.get(path)?.();
+			this.#subscriptions.delete(path);
+		}
+	}
+};
+exports.BleBroadcastPublisher = BleBroadcastPublisher;
+exports.BleBroadcastStreamGlue = BleBroadcastStreamGlue;
+exports.GEAR_STATES = GEAR_STATES;
+exports.TONNEAU_POSITION_STATES = TONNEAU_POSITION_STATES;

package/dist/bluetooth/streamglue.d.cts

@@ -0,0 +1,37 @@
+import { Clock, FieldPath, ObservationSink, Publisher, Unsubscribe } from "../funnel.cjs";
+import { BroadcastListeners } from "./broadcast.cjs";
+/**
+ * What the glue feeds. Structurally a Teslemetry stream's `ingest`: no stream
+ * package is imported here, so a sink can be anything with this method.
+ */
+export interface StreamSink {
+  ingest(data: Record<string, unknown>, metadata?: Record<string, unknown>): unknown;
+}
+export declare const GEAR_STATES: ReadonlyMap<number, string>;
+export declare const TONNEAU_POSITION_STATES: ReadonlyMap<number, string>;
+/**
+ * Feeds a vehicle's broadcasts into a stream-shaped sink, so a Bluetooth reading
+ * reaches the listeners a native stream event does. There is no source ranking:
+ * every call reaches them in arrival order.
+ */
+export declare class BleBroadcastStreamGlue {
+  #private;
+  constructor(vehicle: BroadcastListeners, sink: StreamSink);
+  /** Stop listening. Safe to call twice. */
+  stop(): void;
+}
+/**
+ * Publishes VCSEC status broadcasts to an `ObservationFunnel`. Registration only:
+ * a dropped session ends the broadcasts and says nothing about the fields, so it
+ * publishes nothing.
+ */
+export declare class BleBroadcastPublisher implements Publisher {
+  #private;
+  readonly paths: ReadonlySet<FieldPath>;
+  constructor(vehicle: BroadcastListeners, options?: {
+    clock?: Clock;
+  });
+  attach(sink: ObservationSink): Unsubscribe;
+  request(paths: ReadonlySet<FieldPath>): void;
+  release(paths: ReadonlySet<FieldPath>): void;
+}

package/dist/bluetooth/streamglue.d.mts

@@ -0,0 +1,37 @@
+import { Clock, FieldPath, ObservationSink, Publisher, Unsubscribe } from "../funnel.mjs";
+import { BroadcastListeners } from "./broadcast.mjs";
+/**
+ * What the glue feeds. Structurally a Teslemetry stream's `ingest`: no stream
+ * package is imported here, so a sink can be anything with this method.
+ */
+export interface StreamSink {
+  ingest(data: Record<string, unknown>, metadata?: Record<string, unknown>): unknown;
+}
+export declare const GEAR_STATES: ReadonlyMap<number, string>;
+export declare const TONNEAU_POSITION_STATES: ReadonlyMap<number, string>;
+/**
+ * Feeds a vehicle's broadcasts into a stream-shaped sink, so a Bluetooth reading
+ * reaches the listeners a native stream event does. There is no source ranking:
+ * every call reaches them in arrival order.
+ */
+export declare class BleBroadcastStreamGlue {
+  #private;
+  constructor(vehicle: BroadcastListeners, sink: StreamSink);
+  /** Stop listening. Safe to call twice. */
+  stop(): void;
+}
+/**
+ * Publishes VCSEC status broadcasts to an `ObservationFunnel`. Registration only:
+ * a dropped session ends the broadcasts and says nothing about the fields, so it
+ * publishes nothing.
+ */
+export declare class BleBroadcastPublisher implements Publisher {
+  #private;
+  readonly paths: ReadonlySet<FieldPath>;
+  constructor(vehicle: BroadcastListeners, options?: {
+    clock?: Clock;
+  });
+  attach(sink: ObservationSink): Unsubscribe;
+  request(paths: ReadonlySet<FieldPath>): void;
+  release(paths: ReadonlySet<FieldPath>): void;
+}

package/dist/bluetooth/streamglue.mjs

@@ -0,0 +1,154 @@
+import { CLOSURE_STATES, FieldPath, LOCK_STATES } from "../funnel.mjs";
+import { ClosureStateE, GearE, closureStateEToJSON, gearEToJSON, vehicleLockStateEToJSON } from "@teslemetry/tesla-protocol/command/vcsec";
+// src/bluetooth/streamglue.ts
+const GEAR_STATES = /* @__PURE__ */ new Map([
+	[GearE.GEAR_PARK, "ShiftStateP"],
+	[GearE.GEAR_DRIVE, "ShiftStateD"],
+	[GearE.GEAR_REVERSE, "ShiftStateR"],
+	[GearE.GEAR_NEUTRAL, "ShiftStateN"]
+]);
+const TONNEAU_POSITION_STATES = /* @__PURE__ */ new Map([
+	[ClosureStateE.CLOSURESTATE_CLOSED, "TonneauPositionStateClosed"],
+	[ClosureStateE.CLOSURESTATE_OPEN, "TonneauPositionStateFullyOpen"],
+	[ClosureStateE.CLOSURESTATE_AJAR, "TonneauPositionStatePartiallyOpen"]
+]);
+/** A closure state's name, or the bare number for one this build has no name for. */
+function closureName(state) {
+	const name = closureStateEToJSON(state);
+	return name === "UNRECOGNIZED" ? String(state) : name;
+}
+/**
+* Feeds a vehicle's broadcasts into a stream-shaped sink, so a Bluetooth reading
+* reaches the listeners a native stream event does. There is no source ranking:
+* every call reaches them in arrival order.
+*/
+var BleBroadcastStreamGlue = class {
+	#sink;
+	#unsubscribes;
+	constructor(vehicle, sink) {
+		this.#sink = sink;
+		this.#unsubscribes = [
+			vehicle.listen_vehicle_lock_state((state) => this.#onLockState(state)),
+			vehicle.listen_charge_port((state) => this.#onChargePort(state)),
+			vehicle.listen_closure_statuses((closures) => this.#onClosures(closures)),
+			vehicle.listen_gear((gear) => this.#onGear(gear)),
+			vehicle.listen_tonneau((state) => this.#onTonneau(state)),
+			vehicle.listen_tonneau_percent_open((percent) => this.#sink.ingest({ TonneauOpenPercent: percent }, { source: "bluetooth" }))
+		];
+	}
+	/** Stop listening. Safe to call twice. */
+	stop() {
+		for (const unsubscribe of this.#unsubscribes) unsubscribe();
+		this.#unsubscribes = [];
+	}
+	#onLockState(state) {
+		const locked = LOCK_STATES.get(state);
+		if (locked !== void 0) this.#sink.ingest({ Locked: locked }, {
+			source: "bluetooth",
+			raw: vehicleLockStateEToJSON(state)
+		});
+	}
+	#onChargePort(state) {
+		const open = CLOSURE_STATES.get(state);
+		if (open !== void 0) this.#sink.ingest({ ChargePortDoorOpen: open }, {
+			source: "bluetooth",
+			raw: closureStateEToJSON(state)
+		});
+	}
+	/**
+	* Every door listener fires on any `DoorState` event and reads its own key, so
+	* a leaf sent alone would reach the other five as missing. All six go in one
+	* event, as a native event's do, with a leaf in an unmapped state left out.
+	*/
+	#onClosures(closures) {
+		const raw = {
+			DriverFront: closures.frontDriverDoor,
+			PassengerFront: closures.frontPassengerDoor,
+			DriverRear: closures.rearDriverDoor,
+			PassengerRear: closures.rearPassengerDoor,
+			TrunkFront: closures.frontTrunk,
+			TrunkRear: closures.rearTrunk
+		};
+		const leaves = Object.entries(raw);
+		const doorState = leaves.flatMap(([key, state]) => {
+			const open = CLOSURE_STATES.get(state);
+			return open === void 0 ? [] : [[key, open]];
+		});
+		if (doorState.length > 0) this.#sink.ingest({ DoorState: Object.fromEntries(doorState) }, {
+			source: "bluetooth",
+			raw: Object.fromEntries(leaves.map(([key, state]) => [key, closureName(state)]))
+		});
+	}
+	#onGear(gear) {
+		const state = GEAR_STATES.get(gear);
+		if (state !== void 0) this.#sink.ingest({ Gear: state }, {
+			source: "bluetooth",
+			raw: gearEToJSON(gear)
+		});
+	}
+	#onTonneau(state) {
+		const position = TONNEAU_POSITION_STATES.get(state);
+		if (position !== void 0) this.#sink.ingest({ TonneauPosition: position }, {
+			source: "bluetooth",
+			raw: closureStateEToJSON(state)
+		});
+	}
+};
+/** The map and listener behind each field a broadcast carries. */
+const BROADCAST_FIELDS = /* @__PURE__ */ new Map([
+	[FieldPath.LOCKED, {
+		states: LOCK_STATES,
+		listen: (vehicle, callback) => vehicle.listen_vehicle_lock_state(callback)
+	}],
+	[FieldPath.CHARGE_PORT_DOOR_OPEN, {
+		states: CLOSURE_STATES,
+		listen: (vehicle, callback) => vehicle.listen_charge_port(callback)
+	}],
+	[FieldPath.DOOR_STATE_TRUNK_FRONT, {
+		states: CLOSURE_STATES,
+		listen: (vehicle, callback) => vehicle.listen_front_trunk(callback)
+	}]
+]);
+/**
+* Publishes VCSEC status broadcasts to an `ObservationFunnel`. Registration only:
+* a dropped session ends the broadcasts and says nothing about the fields, so it
+* publishes nothing.
+*/
+var BleBroadcastPublisher = class {
+	paths = new Set(BROADCAST_FIELDS.keys());
+	#vehicle;
+	#clock;
+	#subscriptions = /* @__PURE__ */ new Map();
+	#sink = null;
+	constructor(vehicle, options = {}) {
+		this.#vehicle = vehicle;
+		this.#clock = options.clock ?? (() => performance.now() / 1e3);
+	}
+	attach(sink) {
+		this.#sink = sink;
+		return () => {
+			this.release(new Set(this.#subscriptions.keys()));
+			this.#sink = null;
+		};
+	}
+	request(paths) {
+		for (const path of paths) {
+			const field = BROADCAST_FIELDS.get(path);
+			if (field && !this.#subscriptions.has(path)) this.#subscriptions.set(path, field.listen(this.#vehicle, (state) => {
+				const value = field.states.get(state);
+				if (value !== void 0) this.#sink?.publish({
+					path,
+					value,
+					observed_at: this.#clock()
+				});
+			}));
+		}
+	}
+	release(paths) {
+		for (const path of paths) {
+			this.#subscriptions.get(path)?.();
+			this.#subscriptions.delete(path);
+		}
+	}
+};
+export { BleBroadcastPublisher, BleBroadcastStreamGlue, GEAR_STATES, TONNEAU_POSITION_STATES };

package/dist/bluetooth/teslabluetooth.cjs

@@ -0,0 +1,67 @@
+const require_exceptions = require("../exceptions.cjs");
+const require_teslafleetapi = require("../teslafleetapi.cjs");
+const require_vehicle = require("../vehicle.cjs");
+const require_names = require("./names.cjs");
+const require_vehiclebluetooth = require("./vehiclebluetooth.cjs");
+// src/bluetooth/teslabluetooth.ts
+/**
+* The vehicles of a `TeslaBluetooth`. `createBluetooth` lives here, not on the
+* root `Vehicle`, so the root entry never loads Bluetooth code.
+*/
+var VehiclesBluetooth = class extends require_vehicle.default {
+	/** Class `createBluetooth` instantiates; a subclass overrides it to supply its own vehicle type. */
+	static Bluetooth = require_vehiclebluetooth.default;
+	/** Same as `createBluetooth`, under Python's other name. */
+	create(vin, options) {
+		return this.createBluetooth(vin, options);
+	}
+	/** Creates a vehicle reached over Bluetooth through `options.transport`. */
+	createBluetooth(vin, options) {
+		const vehicle = new this.constructor.Bluetooth(this, vin, options);
+		this.byVin.set(vin, vehicle);
+		return vehicle;
+	}
+};
+/**
+* A client with no cloud behind it, for vehicles reached only over Bluetooth.
+* Every REST path raises `BluetoothCloudUnavailableError` before any I/O, so a
+* REST method a vehicle inherits fails clearly, sends nothing, and is safe for
+* a router to fail over on. A cloud client that wants the same key on both
+* paths uses `new VehicleBluetooth(client.vehicles, vin, options)` instead.
+*/
+var TeslaBluetooth = class extends require_teslafleetapi.default {
+	static Vehicles = VehiclesBluetooth;
+	_transport_name = "bluetooth";
+	constructor(options = {}) {
+		super({
+			server: "bluetooth://local",
+			chargingScope: false,
+			energyScope: false,
+			partnerScope: false,
+			userScope: false,
+			debug: options.debug,
+			logger: options.logger
+		});
+		this.private_key = options.privateKey ?? null;
+	}
+	async _request() {
+		throw new require_exceptions.BluetoothCloudUnavailableError();
+	}
+	async _fetch() {
+		throw new require_exceptions.BluetoothCloudUnavailableError();
+	}
+	/** Whether a BLE device name is a valid Tesla vehicle's. */
+	valid_name(name) {
+		return require_names.valid_name(name);
+	}
+	/** The BLE device name of a vehicle. */
+	get_name(vin) {
+		return require_names.get_name(vin);
+	}
+	/** Whether an advertised name belongs to this VIN, with any valid suffix. */
+	name_matches_vin(advertised, vin) {
+		return require_names.name_matches_vin(advertised, vin);
+	}
+};
+exports.VehiclesBluetooth = VehiclesBluetooth;
+exports.default = TeslaBluetooth;

package/dist/bluetooth/teslabluetooth.d.cts

@@ -0,0 +1,41 @@
+import { Logger } from "../log.cjs";
+import TeslaFleetApi from "../teslafleetapi.cjs";
+import Vehicle from "../vehicle.cjs";
+import VehicleBluetooth, { VehicleBluetoothOptions } from "./vehiclebluetooth.cjs";
+/**
+ * The vehicles of a `TeslaBluetooth`. `createBluetooth` lives here, not on the
+ * root `Vehicle`, so the root entry never loads Bluetooth code.
+ */
+export declare class VehiclesBluetooth extends Vehicle {
+  /** Class `createBluetooth` instantiates; a subclass overrides it to supply its own vehicle type. */
+  static Bluetooth: new (parent: Vehicle, vin: string, options: VehicleBluetoothOptions) => VehicleBluetooth;
+  /** Same as `createBluetooth`, under Python's other name. */
+  create(vin: string, options: VehicleBluetoothOptions): VehicleBluetooth;
+  /** Creates a vehicle reached over Bluetooth through `options.transport`. */
+  createBluetooth(vin: string, options: VehicleBluetoothOptions): VehicleBluetooth;
+}
+/**
+ * A client with no cloud behind it, for vehicles reached only over Bluetooth.
+ * Every REST path raises `BluetoothCloudUnavailableError` before any I/O, so a
+ * REST method a vehicle inherits fails clearly, sends nothing, and is safe for
+ * a router to fail over on. A cloud client that wants the same key on both
+ * paths uses `new VehicleBluetooth(client.vehicles, vin, options)` instead.
+ */
+export default class TeslaBluetooth extends TeslaFleetApi {
+  static Vehicles: new (parent: TeslaFleetApi) => Vehicle;
+  vehicles: VehiclesBluetooth;
+  readonly _transport_name: string;
+  constructor(options?: {
+    privateKey?: Buffer;
+    debug?: boolean;
+    logger?: Logger;
+  });
+  _request(): Promise<never>;
+  protected _fetch(): Promise<never>;
+  /** Whether a BLE device name is a valid Tesla vehicle's. */
+  valid_name(name: string): boolean;
+  /** The BLE device name of a vehicle. */
+  get_name(vin: string): string;
+  /** Whether an advertised name belongs to this VIN, with any valid suffix. */
+  name_matches_vin(advertised: string, vin: string): boolean;
+}