tesla-fleet-api 0.3.0 → 0.5.0

package/dist/bluetooth/homey.cjs

@@ -0,0 +1,155 @@
+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/homey.ts
+/**
+* Bytes per write. Homey hides the MTU, so this is the ATT minimum, the one size
+* sure to work. BLE-00 step 6: if a whole 114-byte frame gets a reply, this can
+* become `null`. Otherwise step 7 keeps it, or the MTU estimate less 3 if larger.
+*/
+const HOMEY_MAX_WRITE_SIZE = 20;
+/**
+* For `connect_timeout_ms` and `max_connect_attempts`, not applied by this
+* adapter: `discover()` caches for 30 s, so a fast retry sees old data, and
+* these fit Homey's 9 s action window. BLE-00 step 11 sets both, against its
+* target of a connect under 4 s in 9 of 10. A flow with no such window should
+* keep the library's defaults until then, as a link slower than this never lands.
+*/
+const HOMEY_VEHICLE_OPTIONS = {
+	connect_timeout_ms: 4e3,
+	max_connect_attempts: 1
+};
+/**
+* Bound on discovery and subscribing once a link is up. Homey has no timeout of
+* its own, and if these hang, nothing else could release the vehicle's slot.
+* BLE-00 steps 3 and 4 show what a slow link takes.
+*/
+const HOMEY_SETUP_TIMEOUT_MS = require_constants.DEFAULT_CONNECT_TIMEOUT_MS;
+/** Bound on unsubscribing, which must not keep `disconnect` from running on a dead link. BLE-00 step 10. */
+const HOMEY_UNSUBSCRIBE_TIMEOUT_MS = 1e3;
+function find(characteristics, uuid) {
+	return characteristics.find((characteristic) => require_shared.compactUuid(characteristic.uuid) === require_shared.compactUuid(uuid));
+}
+var HomeyConnection = class {
+	id;
+	handlers;
+	maxWriteSize;
+	claims;
+	lost = false;
+	closed = false;
+	closing;
+	peripheral;
+	characteristics = [];
+	genericAccess;
+	subscribed = false;
+	onDisconnect = () => {
+		this.lost = true;
+		if (!this.closed) this.handlers.onDisconnect();
+	};
+	constructor(id, handlers, maxWriteSize, claims) {
+		this.id = id;
+		this.handlers = handlers;
+		this.maxWriteSize = maxWriteSize;
+		this.claims = claims;
+	}
+	/** Stale after a silent drop. The library's timeouts are what find a dead link. */
+	get isConnected() {
+		return !this.lost && !this.closed && this.peripheral?.isConnected === true;
+	}
+	/** Discover, then subscribe: the link is live only once this resolves. */
+	async attach(peripheral) {
+		this.peripheral = peripheral;
+		this.assertCurrent();
+		peripheral.once("disconnect", this.onDisconnect);
+		const characteristics = await (await peripheral.getService(require_shared.compactUuid(require_constants.SERVICE_UUID))).discoverCharacteristics();
+		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;
+		await notify.subscribeToNotifications((data) => this.handlers.onNotify(data));
+		this.subscribed = true;
+	}
+	/**
+	* Homey hands every attempt the same link, and one subscription per
+	* characteristic. A superseded attempt stops here, before it changes either.
+	*/
+	assertCurrent() {
+		if (this.claims.superseded(this.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.write(Buffer.from(data));
+	}
+	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.read();
+	}
+	/**
+	* Homey's stack may hide this service, which BLE-00 step 8 settles. A failed
+	* lookup leaves a characteristic unresolved on a healthy link, so it must not
+	* read as a lost one.
+	*/
+	discoverGenericAccess() {
+		const { peripheral } = this;
+		if (!peripheral) return Promise.reject(new require_transport.BleNotSubmittedError("The link is down."));
+		this.genericAccess ??= peripheral.getService(require_shared.compactUuid(require_constants.GENERIC_ACCESS_UUID)).then((service) => service.discoverCharacteristics()).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, id } = this;
+			peripheral?.removeListener("disconnect", this.onDisconnect);
+			const superseded = claims.superseded(id, this);
+			claims.release(id, this);
+			if (superseded || !peripheral) return;
+			if (this.subscribed) await require_shared.quietly(() => require_async.withTimeout(() => find(this.characteristics, require_constants.VEHICLE_NOTIFY_UUID).unsubscribeFromNotifications(), HOMEY_UNSUBSCRIBE_TIMEOUT_MS));
+			await require_shared.quietly(() => peripheral.disconnect());
+		})();
+		return this.closing;
+	}
+};
+var HomeyBleTransport = class {
+	ble;
+	maxWriteSize;
+	claims = new require_shared.LinkClaims();
+	/** @param ble `this.homey.ble`. The app needs the `homey:wireless:ble` permission. */
+	constructor(ble, options = {}) {
+		this.ble = ble;
+		this.maxWriteSize = options.maxWriteSize === void 0 ? 20 : options.maxWriteSize;
+	}
+	/** Takes Homey's fixed window, whatever `timeoutMs` says. Never pass `discover` a filter. */
+	async scan({ matches }) {
+		return (await this.ble.discover()).filter((advertisement) => !matches || advertisement.localName !== void 0 && matches(advertisement.localName)).map((advertisement) => ({
+			id: advertisement.uuid,
+			name: advertisement.localName,
+			rssi: advertisement.rssi,
+			connectable: advertisement.connectable
+		}));
+	}
+	async connect(device, handlers) {
+		const connection = new HomeyConnection(device.id, handlers, this.maxWriteSize, this.claims);
+		this.claims.claim(device.id, connection);
+		try {
+			const peripheral = await (await this.ble.find(device.id)).connect();
+			await require_async.withTimeout(() => connection.attach(peripheral), HOMEY_SETUP_TIMEOUT_MS);
+		} catch (error) {
+			await connection.disconnect();
+			throw error;
+		}
+		return connection;
+	}
+};
+exports.HOMEY_MAX_WRITE_SIZE = HOMEY_MAX_WRITE_SIZE;
+exports.HOMEY_SETUP_TIMEOUT_MS = HOMEY_SETUP_TIMEOUT_MS;
+exports.HOMEY_UNSUBSCRIBE_TIMEOUT_MS = HOMEY_UNSUBSCRIBE_TIMEOUT_MS;
+exports.HOMEY_VEHICLE_OPTIONS = HOMEY_VEHICLE_OPTIONS;
+exports.HomeyBleTransport = HomeyBleTransport;

package/dist/bluetooth/homey.d.cts

@@ -0,0 +1,75 @@
+import { BleConnection, BleDeviceRef, BleLinkHandlers, BleScanOptions, BleTransport } from "./transport.cjs";
+/**
+ * Bytes per write. Homey hides the MTU, so this is the ATT minimum, the one size
+ * sure to work. BLE-00 step 6: if a whole 114-byte frame gets a reply, this can
+ * become `null`. Otherwise step 7 keeps it, or the MTU estimate less 3 if larger.
+ */
+export declare const HOMEY_MAX_WRITE_SIZE = 20;
+/**
+ * For `connect_timeout_ms` and `max_connect_attempts`, not applied by this
+ * adapter: `discover()` caches for 30 s, so a fast retry sees old data, and
+ * these fit Homey's 9 s action window. BLE-00 step 11 sets both, against its
+ * target of a connect under 4 s in 9 of 10. A flow with no such window should
+ * keep the library's defaults until then, as a link slower than this never lands.
+ */
+export declare const HOMEY_VEHICLE_OPTIONS: {
+  readonly connect_timeout_ms: 4000;
+  readonly max_connect_attempts: 1;
+};
+/**
+ * Bound on discovery and subscribing once a link is up. Homey has no timeout of
+ * its own, and if these hang, nothing else could release the vehicle's slot.
+ * BLE-00 steps 3 and 4 show what a slow link takes.
+ */
+export declare const HOMEY_SETUP_TIMEOUT_MS = 20000;
+/** Bound on unsubscribing, which must not keep `disconnect` from running on a dead link. BLE-00 step 10. */
+export declare const HOMEY_UNSUBSCRIBE_TIMEOUT_MS = 1000;
+export interface HomeyCharacteristicLike {
+  uuid: string;
+  read(): Promise<Buffer>;
+  /** Always a write with response: the only kind Homey offers. */
+  write(data: Buffer): Promise<unknown>;
+  subscribeToNotifications(callback: (data: Buffer) => void): Promise<void>;
+  unsubscribeFromNotifications(): Promise<void>;
+}
+export interface HomeyServiceLike {
+  discoverCharacteristics(): Promise<HomeyCharacteristicLike[]>;
+}
+export interface HomeyPeripheralLike {
+  /** Can stay true after a silent drop, so it is only ever a faster signal. BLE-00 step 9 measures it. */
+  readonly isConnected: boolean;
+  getService(uuid: string): Promise<HomeyServiceLike>;
+  disconnect(): Promise<void>;
+  /** Not guaranteed on every drop, but if it fires, the link is gone. BLE-00 step 9 measures it. */
+  once(event: "disconnect", listener: () => void): unknown;
+  removeListener(event: "disconnect", listener: () => void): unknown;
+}
+export interface HomeyAdvertisementLike {
+  uuid: string;
+  /** Typed as a string, but Homey's guide says it is optional. BLE-00 step 2 measures how often it is there. */
+  localName?: string;
+  rssi?: number;
+  connectable?: boolean;
+  /** If already connected, returns the existing connection. It has no timeout: the library bounds it. */
+  connect(): Promise<HomeyPeripheralLike>;
+}
+/** What this adapter needs of `this.homey.ble`. */
+export interface HomeyBleManagerLike {
+  /** About 5 s, fixed. Called with no filter, because the vehicle advertises no service. */
+  discover(): Promise<HomeyAdvertisementLike[]>;
+  find(uuid: string): Promise<HomeyAdvertisementLike>;
+}
+export interface HomeyBleTransportOptions {
+  /** Bytes per write, or `null` for a whole frame in one write. Defaults to `HOMEY_MAX_WRITE_SIZE`. */
+  maxWriteSize?: number | null;
+}
+export declare class HomeyBleTransport implements BleTransport {
+  private readonly ble;
+  private readonly maxWriteSize;
+  private readonly claims;
+  /** @param ble `this.homey.ble`. The app needs the `homey:wireless:ble` permission. */
+  constructor(ble: HomeyBleManagerLike, options?: HomeyBleTransportOptions);
+  /** Takes Homey's fixed window, whatever `timeoutMs` says. Never pass `discover` a filter. */
+  scan({ matches }: BleScanOptions): Promise<BleDeviceRef[]>;
+  connect(device: BleDeviceRef, handlers: BleLinkHandlers): Promise<BleConnection>;
+}

package/dist/bluetooth/homey.d.mts

@@ -0,0 +1,75 @@
+import { BleConnection, BleDeviceRef, BleLinkHandlers, BleScanOptions, BleTransport } from "./transport.mjs";
+/**
+ * Bytes per write. Homey hides the MTU, so this is the ATT minimum, the one size
+ * sure to work. BLE-00 step 6: if a whole 114-byte frame gets a reply, this can
+ * become `null`. Otherwise step 7 keeps it, or the MTU estimate less 3 if larger.
+ */
+export declare const HOMEY_MAX_WRITE_SIZE = 20;
+/**
+ * For `connect_timeout_ms` and `max_connect_attempts`, not applied by this
+ * adapter: `discover()` caches for 30 s, so a fast retry sees old data, and
+ * these fit Homey's 9 s action window. BLE-00 step 11 sets both, against its
+ * target of a connect under 4 s in 9 of 10. A flow with no such window should
+ * keep the library's defaults until then, as a link slower than this never lands.
+ */
+export declare const HOMEY_VEHICLE_OPTIONS: {
+  readonly connect_timeout_ms: 4000;
+  readonly max_connect_attempts: 1;
+};
+/**
+ * Bound on discovery and subscribing once a link is up. Homey has no timeout of
+ * its own, and if these hang, nothing else could release the vehicle's slot.
+ * BLE-00 steps 3 and 4 show what a slow link takes.
+ */
+export declare const HOMEY_SETUP_TIMEOUT_MS = 20000;
+/** Bound on unsubscribing, which must not keep `disconnect` from running on a dead link. BLE-00 step 10. */
+export declare const HOMEY_UNSUBSCRIBE_TIMEOUT_MS = 1000;
+export interface HomeyCharacteristicLike {
+  uuid: string;
+  read(): Promise<Buffer>;
+  /** Always a write with response: the only kind Homey offers. */
+  write(data: Buffer): Promise<unknown>;
+  subscribeToNotifications(callback: (data: Buffer) => void): Promise<void>;
+  unsubscribeFromNotifications(): Promise<void>;
+}
+export interface HomeyServiceLike {
+  discoverCharacteristics(): Promise<HomeyCharacteristicLike[]>;
+}
+export interface HomeyPeripheralLike {
+  /** Can stay true after a silent drop, so it is only ever a faster signal. BLE-00 step 9 measures it. */
+  readonly isConnected: boolean;
+  getService(uuid: string): Promise<HomeyServiceLike>;
+  disconnect(): Promise<void>;
+  /** Not guaranteed on every drop, but if it fires, the link is gone. BLE-00 step 9 measures it. */
+  once(event: "disconnect", listener: () => void): unknown;
+  removeListener(event: "disconnect", listener: () => void): unknown;
+}
+export interface HomeyAdvertisementLike {
+  uuid: string;
+  /** Typed as a string, but Homey's guide says it is optional. BLE-00 step 2 measures how often it is there. */
+  localName?: string;
+  rssi?: number;
+  connectable?: boolean;
+  /** If already connected, returns the existing connection. It has no timeout: the library bounds it. */
+  connect(): Promise<HomeyPeripheralLike>;
+}
+/** What this adapter needs of `this.homey.ble`. */
+export interface HomeyBleManagerLike {
+  /** About 5 s, fixed. Called with no filter, because the vehicle advertises no service. */
+  discover(): Promise<HomeyAdvertisementLike[]>;
+  find(uuid: string): Promise<HomeyAdvertisementLike>;
+}
+export interface HomeyBleTransportOptions {
+  /** Bytes per write, or `null` for a whole frame in one write. Defaults to `HOMEY_MAX_WRITE_SIZE`. */
+  maxWriteSize?: number | null;
+}
+export declare class HomeyBleTransport implements BleTransport {
+  private readonly ble;
+  private readonly maxWriteSize;
+  private readonly claims;
+  /** @param ble `this.homey.ble`. The app needs the `homey:wireless:ble` permission. */
+  constructor(ble: HomeyBleManagerLike, options?: HomeyBleTransportOptions);
+  /** Takes Homey's fixed window, whatever `timeoutMs` says. Never pass `discover` a filter. */
+  scan({ matches }: BleScanOptions): Promise<BleDeviceRef[]>;
+  connect(device: BleDeviceRef, handlers: BleLinkHandlers): Promise<BleConnection>;
+}

package/dist/bluetooth/homey.mjs

@@ -0,0 +1,150 @@
+import { withTimeout } from "./async.mjs";
+import { APPEARANCE_UUID, DEFAULT_CONNECT_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/homey.ts
+/**
+* Bytes per write. Homey hides the MTU, so this is the ATT minimum, the one size
+* sure to work. BLE-00 step 6: if a whole 114-byte frame gets a reply, this can
+* become `null`. Otherwise step 7 keeps it, or the MTU estimate less 3 if larger.
+*/
+const HOMEY_MAX_WRITE_SIZE = 20;
+/**
+* For `connect_timeout_ms` and `max_connect_attempts`, not applied by this
+* adapter: `discover()` caches for 30 s, so a fast retry sees old data, and
+* these fit Homey's 9 s action window. BLE-00 step 11 sets both, against its
+* target of a connect under 4 s in 9 of 10. A flow with no such window should
+* keep the library's defaults until then, as a link slower than this never lands.
+*/
+const HOMEY_VEHICLE_OPTIONS = {
+	connect_timeout_ms: 4e3,
+	max_connect_attempts: 1
+};
+/**
+* Bound on discovery and subscribing once a link is up. Homey has no timeout of
+* its own, and if these hang, nothing else could release the vehicle's slot.
+* BLE-00 steps 3 and 4 show what a slow link takes.
+*/
+const HOMEY_SETUP_TIMEOUT_MS = DEFAULT_CONNECT_TIMEOUT_MS;
+/** Bound on unsubscribing, which must not keep `disconnect` from running on a dead link. BLE-00 step 10. */
+const HOMEY_UNSUBSCRIBE_TIMEOUT_MS = 1e3;
+function find(characteristics, uuid) {
+	return characteristics.find((characteristic) => compactUuid(characteristic.uuid) === compactUuid(uuid));
+}
+var HomeyConnection = class {
+	id;
+	handlers;
+	maxWriteSize;
+	claims;
+	lost = false;
+	closed = false;
+	closing;
+	peripheral;
+	characteristics = [];
+	genericAccess;
+	subscribed = false;
+	onDisconnect = () => {
+		this.lost = true;
+		if (!this.closed) this.handlers.onDisconnect();
+	};
+	constructor(id, handlers, maxWriteSize, claims) {
+		this.id = id;
+		this.handlers = handlers;
+		this.maxWriteSize = maxWriteSize;
+		this.claims = claims;
+	}
+	/** Stale after a silent drop. The library's timeouts are what find a dead link. */
+	get isConnected() {
+		return !this.lost && !this.closed && this.peripheral?.isConnected === true;
+	}
+	/** Discover, then subscribe: the link is live only once this resolves. */
+	async attach(peripheral) {
+		this.peripheral = peripheral;
+		this.assertCurrent();
+		peripheral.once("disconnect", this.onDisconnect);
+		const characteristics = await (await peripheral.getService(compactUuid(SERVICE_UUID))).discoverCharacteristics();
+		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;
+		await notify.subscribeToNotifications((data) => this.handlers.onNotify(data));
+		this.subscribed = true;
+	}
+	/**
+	* Homey hands every attempt the same link, and one subscription per
+	* characteristic. A superseded attempt stops here, before it changes either.
+	*/
+	assertCurrent() {
+		if (this.claims.superseded(this.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.write(Buffer.from(data));
+	}
+	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.read();
+	}
+	/**
+	* Homey's stack may hide this service, which BLE-00 step 8 settles. A failed
+	* lookup leaves a characteristic unresolved on a healthy link, so it must not
+	* read as a lost one.
+	*/
+	discoverGenericAccess() {
+		const { peripheral } = this;
+		if (!peripheral) return Promise.reject(new BleNotSubmittedError("The link is down."));
+		this.genericAccess ??= peripheral.getService(compactUuid(GENERIC_ACCESS_UUID)).then((service) => service.discoverCharacteristics()).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, id } = this;
+			peripheral?.removeListener("disconnect", this.onDisconnect);
+			const superseded = claims.superseded(id, this);
+			claims.release(id, this);
+			if (superseded || !peripheral) return;
+			if (this.subscribed) await quietly(() => withTimeout(() => find(this.characteristics, VEHICLE_NOTIFY_UUID).unsubscribeFromNotifications(), HOMEY_UNSUBSCRIBE_TIMEOUT_MS));
+			await quietly(() => peripheral.disconnect());
+		})();
+		return this.closing;
+	}
+};
+var HomeyBleTransport = class {
+	ble;
+	maxWriteSize;
+	claims = new LinkClaims();
+	/** @param ble `this.homey.ble`. The app needs the `homey:wireless:ble` permission. */
+	constructor(ble, options = {}) {
+		this.ble = ble;
+		this.maxWriteSize = options.maxWriteSize === void 0 ? 20 : options.maxWriteSize;
+	}
+	/** Takes Homey's fixed window, whatever `timeoutMs` says. Never pass `discover` a filter. */
+	async scan({ matches }) {
+		return (await this.ble.discover()).filter((advertisement) => !matches || advertisement.localName !== void 0 && matches(advertisement.localName)).map((advertisement) => ({
+			id: advertisement.uuid,
+			name: advertisement.localName,
+			rssi: advertisement.rssi,
+			connectable: advertisement.connectable
+		}));
+	}
+	async connect(device, handlers) {
+		const connection = new HomeyConnection(device.id, handlers, this.maxWriteSize, this.claims);
+		this.claims.claim(device.id, connection);
+		try {
+			const peripheral = await (await this.ble.find(device.id)).connect();
+			await withTimeout(() => connection.attach(peripheral), HOMEY_SETUP_TIMEOUT_MS);
+		} catch (error) {
+			await connection.disconnect();
+			throw error;
+		}
+		return connection;
+	}
+};
+export { HOMEY_MAX_WRITE_SIZE, HOMEY_SETUP_TIMEOUT_MS, HOMEY_UNSUBSCRIBE_TIMEOUT_MS, HOMEY_VEHICLE_OPTIONS, HomeyBleTransport };

package/dist/bluetooth/names.cjs

@@ -0,0 +1,24 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+let crypto = require("crypto");
+crypto = require_runtime.__toESM(crypto, 1);
+// src/bluetooth/names.ts
+const VALID_NAME = /^S[a-f0-9]{16}[CDRP]$/;
+/** Whether a BLE device name is a valid Tesla vehicle's. */
+function valid_name(name) {
+	return VALID_NAME.test(name);
+}
+/** The BLE device name of a vehicle. */
+function get_name(vin) {
+	return `S${crypto.default.createHash("sha1").update(vin, "utf8").digest("hex").slice(0, 16)}C`;
+}
+/**
+* Whether an advertised name belongs to this VIN. The hash matches, with any of
+* the four suffixes `valid_name` allows, which is wider than Python's exact
+* match on `C`.
+*/
+function name_matches_vin(advertised, vin) {
+	return valid_name(advertised) && advertised.slice(0, 17) === get_name(vin).slice(0, 17);
+}
+exports.get_name = get_name;
+exports.name_matches_vin = name_matches_vin;
+exports.valid_name = valid_name;

package/dist/bluetooth/names.d.cts

@@ -0,0 +1,10 @@
+/** Whether a BLE device name is a valid Tesla vehicle's. */
+export declare function valid_name(name: string): boolean;
+/** The BLE device name of a vehicle. */
+export declare function get_name(vin: string): string;
+/**
+ * Whether an advertised name belongs to this VIN. The hash matches, with any of
+ * the four suffixes `valid_name` allows, which is wider than Python's exact
+ * match on `C`.
+ */
+export declare function name_matches_vin(advertised: string, vin: string): boolean;

package/dist/bluetooth/names.d.mts

@@ -0,0 +1,10 @@
+/** Whether a BLE device name is a valid Tesla vehicle's. */
+export declare function valid_name(name: string): boolean;
+/** The BLE device name of a vehicle. */
+export declare function get_name(vin: string): string;
+/**
+ * Whether an advertised name belongs to this VIN. The hash matches, with any of
+ * the four suffixes `valid_name` allows, which is wider than Python's exact
+ * match on `C`.
+ */
+export declare function name_matches_vin(advertised: string, vin: string): boolean;

package/dist/bluetooth/names.mjs

@@ -0,0 +1,20 @@
+import crypto from "crypto";
+// src/bluetooth/names.ts
+const VALID_NAME = /^S[a-f0-9]{16}[CDRP]$/;
+/** Whether a BLE device name is a valid Tesla vehicle's. */
+function valid_name(name) {
+	return VALID_NAME.test(name);
+}
+/** The BLE device name of a vehicle. */
+function get_name(vin) {
+	return `S${crypto.createHash("sha1").update(vin, "utf8").digest("hex").slice(0, 16)}C`;
+}
+/**
+* Whether an advertised name belongs to this VIN. The hash matches, with any of
+* the four suffixes `valid_name` allows, which is wider than Python's exact
+* match on `C`.
+*/
+function name_matches_vin(advertised, vin) {
+	return valid_name(advertised) && advertised.slice(0, 17) === get_name(vin).slice(0, 17);
+}
+export { get_name, name_matches_vin, valid_name };