tesla-fleet-api 0.3.0 → 0.5.0

package/dist/bluetooth/noble.cjs

@@ -0,0 +1,178 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_async = require("./async.cjs");
+const require_constants = require("./constants.cjs");
+const require_transport = require("./transport.cjs");
+const require_shared = require("./adapters/shared.cjs");
+// src/bluetooth/adapters/noble.ts
+function find(characteristics, uuid) {
+	return characteristics.find((characteristic) => require_shared.compactUuid(characteristic.uuid) === require_shared.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([require_shared.compactUuid(require_constants.SERVICE_UUID)], [
+			require_constants.VEHICLE_WRITE_UUID,
+			require_constants.VEHICLE_NOTIFY_UUID,
+			require_constants.VERSION_UUID
+		].map(require_shared.compactUuid));
+		const notify = find(characteristics, require_constants.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, require_constants.VEHICLE_WRITE_UUID);
+		if (!characteristic) throw new require_transport.BleNotSubmittedError("The vehicle write characteristic was not found.");
+		if (!this.isConnected) throw new require_transport.BleNotSubmittedError("The link is down.");
+		await characteristic.writeAsync(Buffer.from(data), false);
+	}
+	async read(characteristic) {
+		const target = characteristic === "version" ? find(this.characteristics, require_constants.VERSION_UUID) : find(await this.discoverGenericAccess(), characteristic === "deviceName" ? require_constants.NAME_UUID : require_constants.APPEARANCE_UUID);
+		if (!target) throw new require_transport.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([require_shared.compactUuid(require_constants.GENERIC_ACCESS_UUID)], [require_shared.compactUuid(require_constants.NAME_UUID), require_shared.compactUuid(require_constants.APPEARANCE_UUID)]).then(({ characteristics }) => characteristics).catch((cause) => {
+			this.genericAccess = void 0;
+			throw new require_transport.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, require_constants.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 require_shared.quietly(() => peripheral.disconnectAsync());
+		})();
+		return this.closing;
+	}
+};
+var NobleBleTransport = class {
+	options;
+	backend;
+	scans = new require_async.AsyncLock();
+	peripherals = /* @__PURE__ */ new Map();
+	claims = new require_shared.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 require_shared.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, require_constants.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 require_shared.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 require_async.withTimeout(() => connection.subscribe(), require_constants.DEFAULT_CONNECT_TIMEOUT_MS);
+		} catch (error) {
+			await connection.disconnect();
+			throw error;
+		}
+		return connection;
+	}
+};
+exports.NobleBleTransport = NobleBleTransport;

package/dist/bluetooth/noble.d.cts

@@ -0,0 +1,58 @@
+import { BleConnection, BleDeviceRef, BleLinkHandlers, BleScanOptions, BleTransport } from "./transport.cjs";
+export interface NobleCharacteristicLike {
+  uuid: string;
+  on(event: "data", listener: (data: Buffer, isNotification?: boolean) => void): unknown;
+  removeListener(event: "data", listener: (data: Buffer, isNotification?: boolean) => void): unknown;
+  subscribeAsync(): Promise<void>;
+  /** `withoutResponse: false` is a write with response. */
+  writeAsync(data: Buffer, withoutResponse: boolean): Promise<void>;
+  readAsync(): Promise<Buffer>;
+}
+export interface NoblePeripheralLike {
+  id: string;
+  state: string;
+  mtu: number | null;
+  rssi?: number;
+  connectable?: boolean;
+  advertisement: {
+    localName?: string;
+  };
+  connectAsync(): Promise<void>;
+  disconnectAsync(): Promise<void>;
+  discoverSomeServicesAndCharacteristicsAsync(serviceUUIDs: string[], characteristicUUIDs: string[]): Promise<{
+    characteristics: NobleCharacteristicLike[];
+  }>;
+  once(event: "disconnect", listener: () => void): unknown;
+  removeListener(event: "disconnect", listener: () => void): unknown;
+}
+export interface NobleLike {
+  waitForPoweredOnAsync(timeout?: number): Promise<void>;
+  startScanningAsync(serviceUUIDs?: string[], allowDuplicates?: boolean): Promise<void>;
+  stopScanningAsync(): Promise<void>;
+  on(event: "discover", listener: (peripheral: NoblePeripheralLike) => void): unknown;
+  removeListener(event: "discover", listener: (peripheral: NoblePeripheralLike) => void): unknown;
+}
+export interface NobleBleTransportOptions {
+  /** A noble you built, such as `withBindings("dbus")`. Without it, `@stoprocent/noble` loads on first use. */
+  noble?: NobleLike;
+  /**
+   * Which bindings to load. Defaults to `"dbus"` on Linux, which shares the
+   * adapter with BlueZ and needs no root but does need `dbus-next`, and to
+   * `"default"` elsewhere. `"hci"` needs `sudo setcap cap_net_raw+eip` on the
+   * Node binary.
+   */
+  bindings?: "default" | "dbus" | "hci" | "mac" | "win";
+}
+export declare class NobleBleTransport implements BleTransport {
+  private readonly options;
+  private backend;
+  private readonly scans;
+  private readonly peripherals;
+  private readonly claims;
+  constructor(options?: NobleBleTransportOptions);
+  private noble;
+  scan({ timeoutMs, matches }: BleScanOptions): Promise<BleDeviceRef[]>;
+  /** Scan with no service filter until `done` accepts a device or the window ends. */
+  private listen;
+  connect(device: BleDeviceRef, handlers: BleLinkHandlers): Promise<BleConnection>;
+}

package/dist/bluetooth/noble.d.mts

@@ -0,0 +1,58 @@
+import { BleConnection, BleDeviceRef, BleLinkHandlers, BleScanOptions, BleTransport } from "./transport.mjs";
+export interface NobleCharacteristicLike {
+  uuid: string;
+  on(event: "data", listener: (data: Buffer, isNotification?: boolean) => void): unknown;
+  removeListener(event: "data", listener: (data: Buffer, isNotification?: boolean) => void): unknown;
+  subscribeAsync(): Promise<void>;
+  /** `withoutResponse: false` is a write with response. */
+  writeAsync(data: Buffer, withoutResponse: boolean): Promise<void>;
+  readAsync(): Promise<Buffer>;
+}
+export interface NoblePeripheralLike {
+  id: string;
+  state: string;
+  mtu: number | null;
+  rssi?: number;
+  connectable?: boolean;
+  advertisement: {
+    localName?: string;
+  };
+  connectAsync(): Promise<void>;
+  disconnectAsync(): Promise<void>;
+  discoverSomeServicesAndCharacteristicsAsync(serviceUUIDs: string[], characteristicUUIDs: string[]): Promise<{
+    characteristics: NobleCharacteristicLike[];
+  }>;
+  once(event: "disconnect", listener: () => void): unknown;
+  removeListener(event: "disconnect", listener: () => void): unknown;
+}
+export interface NobleLike {
+  waitForPoweredOnAsync(timeout?: number): Promise<void>;
+  startScanningAsync(serviceUUIDs?: string[], allowDuplicates?: boolean): Promise<void>;
+  stopScanningAsync(): Promise<void>;
+  on(event: "discover", listener: (peripheral: NoblePeripheralLike) => void): unknown;
+  removeListener(event: "discover", listener: (peripheral: NoblePeripheralLike) => void): unknown;
+}
+export interface NobleBleTransportOptions {
+  /** A noble you built, such as `withBindings("dbus")`. Without it, `@stoprocent/noble` loads on first use. */
+  noble?: NobleLike;
+  /**
+   * Which bindings to load. Defaults to `"dbus"` on Linux, which shares the
+   * adapter with BlueZ and needs no root but does need `dbus-next`, and to
+   * `"default"` elsewhere. `"hci"` needs `sudo setcap cap_net_raw+eip` on the
+   * Node binary.
+   */
+  bindings?: "default" | "dbus" | "hci" | "mac" | "win";
+}
+export declare class NobleBleTransport implements BleTransport {
+  private readonly options;
+  private backend;
+  private readonly scans;
+  private readonly peripherals;
+  private readonly claims;
+  constructor(options?: NobleBleTransportOptions);
+  private noble;
+  scan({ timeoutMs, matches }: BleScanOptions): Promise<BleDeviceRef[]>;
+  /** Scan with no service filter until `done` accepts a device or the window ends. */
+  private listen;
+  connect(device: BleDeviceRef, handlers: BleLinkHandlers): Promise<BleConnection>;
+}

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;
+}