@typecad/hal 1.0.0-alpha.6 → 1.0.0-alpha.7

package/dist/http.js

@@ -0,0 +1,104 @@
+import { httpBegin, httpReset, httpSetHeader, httpSetTimeout, httpSetMaxBody, httpSetBody, httpSetInsecure, httpSetCaCert, httpSend, httpStatus, httpOk, httpBody, httpContentLength, httpResponseHeader, } from './emit.js';
+export var HttpMethod;
+(function (HttpMethod) {
+    HttpMethod[HttpMethod["GET"] = 0] = "GET";
+    HttpMethod[HttpMethod["POST"] = 1] = "POST";
+    HttpMethod[HttpMethod["PUT"] = 2] = "PUT";
+    HttpMethod[HttpMethod["DELETE"] = 3] = "DELETE";
+    HttpMethod[HttpMethod["HEAD"] = 4] = "HEAD";
+    HttpMethod[HttpMethod["PATCH"] = 5] = "PATCH";
+})(HttpMethod || (HttpMethod = {}));
+/**
+ * Fluent HTTP/S request builder, lowered to native ESP-IDF
+ * `esp_http_client` by framework-esp32 (TLS via esp-tls / mbedTLS bundle).
+ * Response fields are read from this object after send() — mirrors
+ * `await WiFi.connect(); WiFi.localIP()`.
+ *
+ * No `include()` calls here — ESP-IDF headers are framework-owned and added
+ * via forcedIncludes when the program uses http.* ops.
+ */
+export class HttpRequest {
+    constructor(method, url) {
+        this._method = method;
+        this._url = url;
+    }
+    header(name, value) {
+        httpSetHeader(name, value);
+        return this;
+    }
+    timeout(ms) {
+        httpSetTimeout(ms);
+        return this;
+    }
+    maxBody(bytes) {
+        httpSetMaxBody(bytes);
+        return this;
+    }
+    body(data) {
+        httpSetBody(data, false);
+        return this;
+    }
+    jsonBody(json) {
+        httpSetBody(json, true);
+        return this;
+    }
+    /** Skip TLS certificate verification (development only). */
+    insecure() {
+        httpSetInsecure();
+        return this;
+    }
+    caCert(pem) {
+        httpSetCaCert(pem);
+        return this;
+    }
+    /** Blocking at top level; cooperatively awaitable inside async functions. */
+    send() {
+        httpBegin(this._method, this._url);
+        httpSend();
+        return Promise.resolve(false);
+    }
+    status() {
+        return httpStatus();
+    }
+    ok() {
+        return httpOk();
+    }
+    /** Response body as a C string (valid until the next request). */
+    text() {
+        return httpBody();
+    }
+    contentLength() {
+        return httpContentLength();
+    }
+    responseHeader(name) {
+        return httpResponseHeader(name);
+    }
+}
+export class HttpClass {
+    get(url) {
+        httpReset();
+        return new HttpRequest("GET", url);
+    }
+    post(url) {
+        httpReset();
+        return new HttpRequest("POST", url);
+    }
+    put(url) {
+        httpReset();
+        return new HttpRequest("PUT", url);
+    }
+    del(url) {
+        httpReset();
+        return new HttpRequest("DELETE", url);
+    }
+    head(url) {
+        httpReset();
+        return new HttpRequest("HEAD", url);
+    }
+    patch(url) {
+        httpReset();
+        return new HttpRequest("PATCH", url);
+    }
+}
+HttpClass.__instance_name = "Http";
+export const Http = new HttpClass();

package/dist/index.d.ts

@@ -9,7 +9,7 @@ export type { SPIBitOrder, SPIMode, SPISettings } from './types.js';
 export { include } from './include.js';
 export { board } from './board.js';
 export { callback } from './callback.js';
-export { rawCpp, boardResolve } from './emit.js';
+export { rawCpp, rawCppExpr, boardResolve } from './emit.js';
 export { HIGH, LOW, OUTPUT, INPUT, INPUT_PULLUP, INPUT_PULLDOWN, OUTPUT_OPEN_DRAIN, ANALOG, LED_BUILTIN, LSBFIRST, MSBFIRST, WDTO_15MS, WDTO_30MS, WDTO_60MS, WDTO_120MS, WDTO_250MS, WDTO_500MS, WDTO_1S, WDTO_2S, WDTO_4S, WDTO_8S } from './constants.js';
 export { delay, millis, micros, delayMicroseconds, map, constrain, TimingClass, Timing } from './timing.js';
 export { freeHeap, setInterval, setTimeout, clearInterval, clearTimeout } from './timing.js';
@@ -35,3 +35,8 @@ export { HardwareTimer, Timer0, Timer1, Timer2 } from './timer.js';
 export { FSClass, FS } from './fs.js';
 export { PowerClass, Power } from './power.js';
 export { AsyncClass, Async } from './async.js';
+export { WiFiClass, WiFi, WiFiStatus, WiFiEncryption } from './wifi.js';
+export { HttpClass, Http, HttpRequest, HttpMethod } from './http.js';
+export { BleClass, Ble, BleServer, BleValueType, BlePerm, BleStatus, BleAdvertisingMode, GATT, } from './ble.js';
+export type { GattCharacteristicDef, CharValue } from './ble.js';
+export { RmtChannel } from './rmt.js';

package/dist/index.js

@@ -3,7 +3,7 @@ export { createPinGroup } from './types.js';
 export { include } from './include.js';
 export { board } from './board.js';
 export { callback } from './callback.js';
-export { rawCpp, boardResolve } from './emit.js';
+export { rawCpp, rawCppExpr, boardResolve } from './emit.js';
 export { HIGH, LOW, OUTPUT, INPUT, INPUT_PULLUP, INPUT_PULLDOWN, OUTPUT_OPEN_DRAIN, ANALOG, LED_BUILTIN, LSBFIRST, MSBFIRST, WDTO_15MS, WDTO_30MS, WDTO_60MS, WDTO_120MS, WDTO_250MS, WDTO_500MS, WDTO_1S, WDTO_2S, WDTO_4S, WDTO_8S } from './constants.js';
 export { delay, millis, micros, delayMicroseconds, map, constrain, TimingClass, Timing } from './timing.js';
 export { freeHeap, setInterval, setTimeout, clearInterval, clearTimeout } from './timing.js';
@@ -28,3 +28,7 @@ export { HardwareTimer, Timer0, Timer1, Timer2 } from './timer.js';
 export { FSClass, FS } from './fs.js';
 export { PowerClass, Power } from './power.js';
 export { AsyncClass, Async } from './async.js';
+export { WiFiClass, WiFi, WiFiStatus, WiFiEncryption } from './wifi.js';
+export { HttpClass, Http, HttpRequest, HttpMethod } from './http.js';
+export { BleClass, Ble, BleServer, BleValueType, BlePerm, BleStatus, BleAdvertisingMode, GATT, } from './ble.js';
+export { RmtChannel } from './rmt.js';

package/dist/power.d.ts

@@ -8,6 +8,13 @@
 export declare class PowerClass {
     static readonly __instance_name = "Power";
     deepSleep(ms: number): void;
+    /** Enter deep sleep until `pin` reaches `level` (0 = low, 1 = high).
+     *
+     *  Lowers to ext0 wakeup (Xtensa ESP32/S3, RTC pins only) or the gpio-wakeup
+     *  variant (RISC-V C3/C6) depending on the target. `pin` must be RTC-capable;
+     *  the framework flags non-RTC pins at compile time. Wakeup resets the chip,
+     *  so this call never returns. */
+    deepSleepPin(pin: number, level: 0 | 1): void;
     lightSleep(): void;
     setCpuFrequency(mhz: number): void;
 }

package/dist/power.js

@@ -1,4 +1,4 @@
-import { powerDeepSleep, powerLightSleep, powerSetCpuFrequency } from './emit.js';
+import { powerDeepSleep, powerLightSleep, powerSetCpuFrequency, powerDeepSleepPin } from './emit.js';
 /**
  * PowerClass provides control over MCU power states and clock frequencies.
  *
@@ -10,6 +10,15 @@ export class PowerClass {
     deepSleep(ms) {
         powerDeepSleep(ms);
     }
+    /** Enter deep sleep until `pin` reaches `level` (0 = low, 1 = high).
+     *
+     *  Lowers to ext0 wakeup (Xtensa ESP32/S3, RTC pins only) or the gpio-wakeup
+     *  variant (RISC-V C3/C6) depending on the target. `pin` must be RTC-capable;
+     *  the framework flags non-RTC pins at compile time. Wakeup resets the chip,
+     *  so this call never returns. */
+    deepSleepPin(pin, level) {
+        powerDeepSleepPin(pin, level);
+    }
     lightSleep() {
         powerLightSleep();
     }

package/dist/preferences.d.ts

@@ -1,3 +1,12 @@
+/**
+ * Preferences — a persistent key/value store, lowered to native NVS
+ * (nvs_flash / nvs_open / nvs_set_* / nvs_get_*) by framework-esp32.
+ *
+ * No include() calls here — NVS headers are framework-owned and added via
+ * forcedIncludes when the program uses preferences.* ops. Method bodies pass
+ * parameters directly into semantic calls so the resolver can statically track
+ * every argument (matching the WiFi/HTTP HAL pattern).
+ */
 export declare class PreferencesClass {
     static readonly __instance_name = "Preferences";
     begin(name: string, readOnly?: boolean): void;
@@ -8,10 +17,10 @@ export declare class PreferencesClass {
     getInt(key: string, defaultValue?: number): number;
     putUInt(key: string, value: number): void;
     getUInt(key: string, defaultValue?: number): number;
-    putFloat(key: string, value: number): void;
-    getFloat(key: string, defaultValue?: number): number;
     putBool(key: string, value: boolean): void;
     getBool(key: string, defaultValue?: boolean): boolean;
+    putFloat(key: string, value: number): void;
+    getFloat(key: string, defaultValue?: number): number;
     putString(key: string, value: string): void;
     getString(key: string, defaultValue?: string): string;
 }

package/dist/preferences.js

@@ -1,54 +1,55 @@
-import { rawCpp } from './emit.js';
+import { preferencesBegin, preferencesEnd, preferencesClear, preferencesRemove, preferencesPutInt, preferencesGetInt, preferencesPutUInt, preferencesGetUInt, preferencesPutBool, preferencesGetBool, preferencesPutFloat, preferencesGetFloat, preferencesPutString, preferencesGetString, } from './emit.js';
+/**
+ * Preferences — a persistent key/value store, lowered to native NVS
+ * (nvs_flash / nvs_open / nvs_set_* / nvs_get_*) by framework-esp32.
+ *
+ * No include() calls here — NVS headers are framework-owned and added via
+ * forcedIncludes when the program uses preferences.* ops. Method bodies pass
+ * parameters directly into semantic calls so the resolver can statically track
+ * every argument (matching the WiFi/HTTP HAL pattern).
+ */
 export class PreferencesClass {
-    // NOTE: no __includes here. The transpiler emits singleton __includes on
-    // every architecture with no filtering, and <Preferences.h> is ESP32-only —
-    // adding it would break AVR builds. The class is ESP32-only by convention.
     begin(name, readOnly = false) {
-        rawCpp(`Preferences.begin(${name}.c_str(), ${readOnly});`);
+        preferencesBegin(name, readOnly);
     }
     end() {
-        rawCpp(`Preferences.end();`);
+        preferencesEnd();
     }
     clear() {
-        rawCpp(`Preferences.clear();`);
+        preferencesClear();
     }
     remove(key) {
-        rawCpp(`Preferences.remove(${key}.c_str());`);
+        preferencesRemove(key);
     }
     putInt(key, value) {
-        rawCpp(`Preferences.putInt(${key}.c_str(), ${value});`);
+        preferencesPutInt(key, value);
     }
     getInt(key, defaultValue = 0) {
-        rawCpp(`return Preferences.getInt(${key}.c_str(), ${defaultValue});`);
-        return 0;
+        return preferencesGetInt(key, defaultValue);
     }
     putUInt(key, value) {
-        rawCpp(`Preferences.putUInt(${key}.c_str(), ${value});`);
+        preferencesPutUInt(key, value);
     }
     getUInt(key, defaultValue = 0) {
-        rawCpp(`return Preferences.getUInt(${key}.c_str(), ${defaultValue});`);
-        return 0;
-    }
-    putFloat(key, value) {
-        rawCpp(`Preferences.putFloat(${key}.c_str(), ${value});`);
-    }
-    getFloat(key, defaultValue = 0) {
-        rawCpp(`return Preferences.getFloat(${key}.c_str(), ${defaultValue});`);
-        return 0;
+        return preferencesGetUInt(key, defaultValue);
     }
     putBool(key, value) {
-        rawCpp(`Preferences.putBool(${key}.c_str(), ${value});`);
+        preferencesPutBool(key, value);
     }
     getBool(key, defaultValue = false) {
-        rawCpp(`return Preferences.getBool(${key}.c_str(), ${defaultValue});`);
-        return false;
+        return preferencesGetBool(key, defaultValue);
+    }
+    putFloat(key, value) {
+        preferencesPutFloat(key, value);
+    }
+    getFloat(key, defaultValue = 0) {
+        return preferencesGetFloat(key, defaultValue);
     }
     putString(key, value) {
-        rawCpp(`Preferences.putString(${key}.c_str(), ${value}.c_str());`);
+        preferencesPutString(key, value);
     }
     getString(key, defaultValue = "") {
-        rawCpp(`return Preferences.getString(${key}.c_str(), ${defaultValue}.c_str());`);
-        return "";
+        return preferencesGetString(key, defaultValue);
     }
 }
 PreferencesClass.__instance_name = "Preferences";

package/dist/rmt.d.ts

@@ -0,0 +1,48 @@
+import type { Pin } from './gpio.js';
+/** Pin identifier accepted by RmtChannel: a Pin object, raw GPIO number, or port name. */
+type RmtPin = Pin | number | string;
+/**
+ * RMT transceiver channel bound to a GPIO pin. One channel per pin; TX and RX
+ * are independent roles on the same channel object.
+ *
+ * ```ts
+ * const led = new RmtChannel(LED);
+ * led.txInit({ resolutionHz: 10_000_000, bit0: [4, 9], bit1: [9, 4] });
+ * led.txWriteBytes([0, 16, 0]);
+ * led.txWaitDone();
+ * ```
+ */
+export declare class RmtChannel {
+    private _pin;
+    constructor(pin: RmtPin);
+    /** Initialize the channel for TX. Idempotent per pin. Bit timings are fixed
+     *  at init — ESP-IDF bakes them into the bytes-encoder and exposes no public
+     *  mutation API. Tick units are 1/resolutionHz seconds.
+     *
+     *  Args are positional scalars (not an opts object) because the transpiler's
+     *  method-body renderer folds scalar params but not property accesses on an
+     *  object param (opts.resolutionHz would render as a collapsed object + dead
+     *  property access). Mirrors how I2CBus.begin(address) takes a scalar. */
+    txInit(resolutionHz: number, bit0Hi: number, bit0Lo: number, bit1Hi: number, bit1Lo: number, msbFirst?: boolean, queueDepth?: number): void;
+    /** Write bytes via the channel's bytes-encoder (timings fixed at txInit). */
+    txWriteBytes(bytes: number[] | Uint8Array): void;
+    /** Write raw RMT symbols — arbitrary [hiTicks, loTicks] pairs. */
+    txWriteSymbols(symbols: [number, number][]): void;
+    /** Block until the queued TX completes. */
+    txWaitDone(timeoutMs?: number): void;
+    /** Tear down the TX channel and release its slot. */
+    txDeinit(): void;
+    /** Initialize the channel for RX. Idempotent per pin. */
+    rxInit(resolutionHz: number): void;
+    /** Register a callback-by-name invoked when an RX burst completes. */
+    rxOnReceived(handler: string): void;
+    /** Start receiving. */
+    rxStart(): void;
+    /** Stop receiving. */
+    rxStop(): void;
+    /** Blocking read — returns flattened symbols [d0,l0,d1,l1,…] in ticks. */
+    rxRead(maxCount: number): number[];
+    /** Tear down the RX channel and release its slot. */
+    rxDeinit(): void;
+}
+export {};

package/dist/rmt.js

@@ -0,0 +1,81 @@
+// ---------------------------------------------------------------------------
+// @typecad/hal — RMT (Remote Control Transceiver) ergonomic API
+// ---------------------------------------------------------------------------
+// Exposes RMT via a RmtChannel class, mirroring the I2CBus/I2CDevice pattern.
+// The transpiler only resolves semantic calls made inside class-method bodies
+// (free top-level calls emit verbatim), so every peripheral exposes its API
+// through a class whose methods call the positional semantic primitives in
+// emit.ts. The resolver collapses object literals, so HALOpIR fields must be
+// scalars; these methods destructure `opts` at the call site before forwarding.
+//
+// Channel identity is the GPIO pin (like pwm.ts's LEDC channel-per-pin model).
+import { rmtTxInit, rmtRxInit, rmtTxWriteBytes, rmtTxWriteSymbols, rmtTxWaitDone, rmtTxDeinit, rmtRxOnReceived, rmtRxStart, rmtRxStop, rmtRxRead, rmtRxDeinit, } from './emit.js';
+/**
+ * RMT transceiver channel bound to a GPIO pin. One channel per pin; TX and RX
+ * are independent roles on the same channel object.
+ *
+ * ```ts
+ * const led = new RmtChannel(LED);
+ * led.txInit({ resolutionHz: 10_000_000, bit0: [4, 9], bit1: [9, 4] });
+ * led.txWriteBytes([0, 16, 0]);
+ * led.txWaitDone();
+ * ```
+ */
+export class RmtChannel {
+    constructor(pin) {
+        this._pin = pin;
+    }
+    // ── TX ─────────────────────────────────────────────────────────────────────
+    /** Initialize the channel for TX. Idempotent per pin. Bit timings are fixed
+     *  at init — ESP-IDF bakes them into the bytes-encoder and exposes no public
+     *  mutation API. Tick units are 1/resolutionHz seconds.
+     *
+     *  Args are positional scalars (not an opts object) because the transpiler's
+     *  method-body renderer folds scalar params but not property accesses on an
+     *  object param (opts.resolutionHz would render as a collapsed object + dead
+     *  property access). Mirrors how I2CBus.begin(address) takes a scalar. */
+    txInit(resolutionHz, bit0Hi, bit0Lo, bit1Hi, bit1Lo, msbFirst = false, queueDepth = 4) {
+        rmtTxInit(this._pin, resolutionHz, bit0Hi, bit0Lo, bit1Hi, bit1Lo, msbFirst, queueDepth);
+    }
+    /** Write bytes via the channel's bytes-encoder (timings fixed at txInit). */
+    txWriteBytes(bytes) {
+        rmtTxWriteBytes(this._pin, bytes);
+    }
+    /** Write raw RMT symbols — arbitrary [hiTicks, loTicks] pairs. */
+    txWriteSymbols(symbols) {
+        rmtTxWriteSymbols(this._pin, symbols);
+    }
+    /** Block until the queued TX completes. */
+    txWaitDone(timeoutMs) {
+        rmtTxWaitDone(this._pin, timeoutMs);
+    }
+    /** Tear down the TX channel and release its slot. */
+    txDeinit() {
+        rmtTxDeinit(this._pin);
+    }
+    // ── RX ─────────────────────────────────────────────────────────────────────
+    /** Initialize the channel for RX. Idempotent per pin. */
+    rxInit(resolutionHz) {
+        rmtRxInit(this._pin, resolutionHz);
+    }
+    /** Register a callback-by-name invoked when an RX burst completes. */
+    rxOnReceived(handler) {
+        rmtRxOnReceived(this._pin, handler);
+    }
+    /** Start receiving. */
+    rxStart() {
+        rmtRxStart(this._pin);
+    }
+    /** Stop receiving. */
+    rxStop() {
+        rmtRxStop(this._pin);
+    }
+    /** Blocking read — returns flattened symbols [d0,l0,d1,l1,…] in ticks. */
+    rxRead(maxCount) {
+        return rmtRxRead(this._pin, maxCount);
+    }
+    /** Tear down the RX channel and release its slot. */
+    rxDeinit() {
+        rmtRxDeinit(this._pin);
+    }
+}

package/dist/wifi.d.ts

@@ -0,0 +1,68 @@
+/** Normalized WiFi link status (mapped from esp_wifi events by the runtime shim). */
+export declare enum WiFiStatus {
+    Idle = 0,
+    Connecting = 1,
+    Connected = 2,
+    ConnectFailed = 3,
+    Disconnected = 4
+}
+export declare enum WiFiEncryption {
+    Open = 0,
+    WEP = 1,
+    WPA = 2,
+    WPA2 = 3,
+    WPA3 = 4,
+    Enterprise = 5
+}
+/**
+ * WiFi radio / link control, lowered to native ESP-IDF (`esp_wifi` /
+ * `esp_netif` / `esp_event` / `nvs_flash`) by framework-esp32.
+ *
+ * No `include()` calls here — ESP-IDF headers are framework-owned and added
+ * via forcedIncludes when the program uses wifi.* ops (the Preferences
+ * lesson: HAL files must not carry platform headers). Frameworks without a
+ * wifi lowering reject these ops with a diagnostic.
+ */
+export declare class WiFiClass {
+    static readonly __instance_name = "WiFi";
+    /** Blocking at top level; cooperatively awaitable inside async functions. */
+    connect(ssid: string, password?: string, timeoutMs?: number): Promise<boolean>;
+    /** Fire-and-forget STA begin; poll status() / untilConnected(). */
+    connectAsync(ssid: string, password?: string): void;
+    untilConnected(timeoutMs?: number): Promise<boolean>;
+    untilDisconnected(): Promise<void>;
+    disconnect(): void;
+    isConnected(): boolean;
+    status(): WiFiStatus;
+    localIP(): string;
+    rssi(): number;
+    macAddress(): string;
+    hostname(name: string): this;
+    staticIP(ip: string, gateway: string, subnet: string, dns?: string): this;
+    autoReconnect(enabled: boolean): this;
+    powerSave(mode: "default" | "none"): this;
+    /** Cap TX power in dBm (roughly 2–20). Safe to call before connect() —
+     *  the value is applied after the radio starts. */
+    txPower(dbm: number): this;
+    saveCredentials(ssid: string, password: string): void;
+    connectSaved(timeoutMs?: number): boolean;
+    clearCredentials(): void;
+    onConnect(handler: () => void): void;
+    onDisconnect(handler: () => void): void;
+    onGotIP(handler: () => void): void;
+    startAP(ssid: string, password?: string): boolean;
+    apChannel(ch: number): this;
+    apHidden(hidden: boolean): this;
+    apMaxClients(n: number): this;
+    stopAP(): void;
+    apClientCount(): number;
+    apIP(): string;
+    scan(): number;
+    scanAsync(): Promise<void>;
+    scanCount(): number;
+    scanSSID(i: number): string;
+    scanRSSI(i: number): number;
+    scanEncryption(i: number): WiFiEncryption;
+    scanChannel(i: number): number;
+}
+export declare const WiFi: WiFiClass;

package/dist/wifi.js

@@ -0,0 +1,154 @@
+import { wifiConnect, wifiConnectStart, wifiDisconnect, wifiStatus, wifiIsConnected, wifiLocalIp, wifiRssi, wifiMac, wifiSetHostname, wifiSetStaticIp, wifiSetAutoReconnect, wifiSetPowerSave, wifiSetTxPower, wifiOnEvent, wifiApStart, wifiApStop, wifiApClientCount, wifiApIp, wifiApSetChannel, wifiApSetHidden, wifiApSetMaxClients, wifiScan, wifiScanStart, wifiScanCount, wifiScanSsid, wifiScanRssi, wifiScanEncryption, wifiScanChannel, wifiSaveCredentials, wifiConnectSaved, wifiClearCredentials, wifiWaitConnected, wifiWaitDisconnected, } from './emit.js';
+import { callback } from './callback.js';
+/** Normalized WiFi link status (mapped from esp_wifi events by the runtime shim). */
+export var WiFiStatus;
+(function (WiFiStatus) {
+    WiFiStatus[WiFiStatus["Idle"] = 0] = "Idle";
+    WiFiStatus[WiFiStatus["Connecting"] = 1] = "Connecting";
+    WiFiStatus[WiFiStatus["Connected"] = 2] = "Connected";
+    WiFiStatus[WiFiStatus["ConnectFailed"] = 3] = "ConnectFailed";
+    WiFiStatus[WiFiStatus["Disconnected"] = 4] = "Disconnected";
+})(WiFiStatus || (WiFiStatus = {}));
+export var WiFiEncryption;
+(function (WiFiEncryption) {
+    WiFiEncryption[WiFiEncryption["Open"] = 0] = "Open";
+    WiFiEncryption[WiFiEncryption["WEP"] = 1] = "WEP";
+    WiFiEncryption[WiFiEncryption["WPA"] = 2] = "WPA";
+    WiFiEncryption[WiFiEncryption["WPA2"] = 3] = "WPA2";
+    WiFiEncryption[WiFiEncryption["WPA3"] = 4] = "WPA3";
+    WiFiEncryption[WiFiEncryption["Enterprise"] = 5] = "Enterprise";
+})(WiFiEncryption || (WiFiEncryption = {}));
+/**
+ * WiFi radio / link control, lowered to native ESP-IDF (`esp_wifi` /
+ * `esp_netif` / `esp_event` / `nvs_flash`) by framework-esp32.
+ *
+ * No `include()` calls here — ESP-IDF headers are framework-owned and added
+ * via forcedIncludes when the program uses wifi.* ops (the Preferences
+ * lesson: HAL files must not carry platform headers). Frameworks without a
+ * wifi lowering reject these ops with a diagnostic.
+ */
+export class WiFiClass {
+    /** Blocking at top level; cooperatively awaitable inside async functions. */
+    connect(ssid, password, timeoutMs = 15000) {
+        wifiConnect(ssid, password, timeoutMs);
+        return Promise.resolve(false);
+    }
+    /** Fire-and-forget STA begin; poll status() / untilConnected(). */
+    connectAsync(ssid, password) {
+        wifiConnectStart(ssid, password);
+    }
+    untilConnected(timeoutMs = 15000) {
+        wifiWaitConnected(timeoutMs);
+        return Promise.resolve(false);
+    }
+    untilDisconnected() {
+        wifiWaitDisconnected();
+        return Promise.resolve();
+    }
+    disconnect() {
+        wifiDisconnect();
+    }
+    isConnected() {
+        return wifiIsConnected();
+    }
+    status() {
+        return wifiStatus();
+    }
+    localIP() {
+        return wifiLocalIp();
+    }
+    rssi() {
+        return wifiRssi();
+    }
+    macAddress() {
+        return wifiMac();
+    }
+    hostname(name) {
+        wifiSetHostname(name);
+        return this;
+    }
+    staticIP(ip, gateway, subnet, dns) {
+        wifiSetStaticIp(ip, gateway, subnet, dns);
+        return this;
+    }
+    autoReconnect(enabled) {
+        wifiSetAutoReconnect(enabled);
+        return this;
+    }
+    powerSave(mode) {
+        wifiSetPowerSave(mode);
+        return this;
+    }
+    /** Cap TX power in dBm (roughly 2–20). Safe to call before connect() —
+     *  the value is applied after the radio starts. */
+    txPower(dbm) {
+        wifiSetTxPower(dbm);
+        return this;
+    }
+    saveCredentials(ssid, password) {
+        wifiSaveCredentials(ssid, password);
+    }
+    connectSaved(timeoutMs = 15000) {
+        return wifiConnectSaved(timeoutMs);
+    }
+    clearCredentials() {
+        wifiClearCredentials();
+    }
+    onConnect(handler) {
+        wifiOnEvent("connect", callback(handler));
+    }
+    onDisconnect(handler) {
+        wifiOnEvent("disconnect", callback(handler));
+    }
+    onGotIP(handler) {
+        wifiOnEvent("got_ip", callback(handler));
+    }
+    startAP(ssid, password) {
+        return wifiApStart(ssid, password);
+    }
+    apChannel(ch) {
+        wifiApSetChannel(ch);
+        return this;
+    }
+    apHidden(hidden) {
+        wifiApSetHidden(hidden);
+        return this;
+    }
+    apMaxClients(n) {
+        wifiApSetMaxClients(n);
+        return this;
+    }
+    stopAP() {
+        wifiApStop();
+    }
+    apClientCount() {
+        return wifiApClientCount();
+    }
+    apIP() {
+        return wifiApIp();
+    }
+    scan() {
+        return wifiScan();
+    }
+    scanAsync() {
+        wifiScanStart();
+        return Promise.resolve();
+    }
+    scanCount() {
+        return wifiScanCount();
+    }
+    scanSSID(i) {
+        return wifiScanSsid(i);
+    }
+    scanRSSI(i) {
+        return wifiScanRssi(i);
+    }
+    scanEncryption(i) {
+        return wifiScanEncryption(i);
+    }
+    scanChannel(i) {
+        return wifiScanChannel(i);
+    }
+}
+WiFiClass.__instance_name = "WiFi";
+export const WiFi = new WiFiClass();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typecad/hal",
-  "version": "1.0.0-alpha.6",
+  "version": "1.0.0-alpha.7",
   "description": "TypeCAD hardware abstraction layer — GPIO, I2C, SPI, UART as regular TypeScript",
   "type": "module",
   "main": "./dist/index.js",
@@ -49,9 +49,9 @@
   },
   "author": "typecad0",
   "devDependencies": {
-    "@typecad/expect": "1.0.0-alpha.6",
-    "@typecad/board-arduino-uno": "1.0.0-alpha.6",
-    "@typecad/mcu-atmega328p": "1.0.0-alpha.6"
+    "@typecad/expect": "1.0.0-alpha.7",
+    "@typecad/board-arduino-uno": "1.0.0-alpha.7",
+    "@typecad/mcu-atmega328p": "1.0.0-alpha.7"
   },
   "sideEffects": false,
   "exports": {