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

package/README.md

@@ -1,8 +1,8 @@
 # `@typecad/hal`
 
 Hardware abstraction layer for [TypeCAD](https://cuttlefish.typecad.net) —
-GPIO, I2C, SPI, UART, timers, ADC/DAC, EEPROM, and more, written as regular
-TypeScript.
+GPIO, I2C, SPI, UART, timers, ADC/DAC, EEPROM, WiFi/HTTP, and more, written as
+regular TypeScript.
 
 `@typecad/hal` is what firmware code imports to talk to hardware. You write
 normal TypeScript (`pin.high()`, `i2c.write(...)`, `Serial0.print(...)`); the
@@ -41,6 +41,7 @@ add new HAL features.
 | **I2C** | `I2CBus`, `II2CBus`, `I2CStatus`, `i2cName` |
 | **SPI** | `SPIBus`, `ISPIBus`, `SPIStatus`, `SPISettings`, `spiName` |
 | **UART / Serial** | `SerialPort`, `IUARTBus`, `UARTStatus`, `serialName` |
+| **Networking** | `WiFi`, `WiFiClass`, `WiFiStatus`, `WiFiEncryption`, `Http`, `HttpClass`, `HttpRequest`, `HttpMethod` |
 | **Timing** | `delay`, `millis`, `micros`, `delayMicroseconds`, `Timing`, `map`, `constrain` |
 | **Pulse / Shift** | `pulseIn`, `shiftIn`, `shiftOut` |
 | **Interrupts** | `attachInterrupt`, `detachInterrupt`, `noInterrupts`, `interrupts`, `InterruptMode` |

package/dist/ble.d.ts

@@ -0,0 +1,160 @@
+/** Characteristic value encoding — drives both TS callback types and C++ marshalling. */
+export declare enum BleValueType {
+    Uint8 = "uint8",
+    Uint16 = "uint16",
+    Uint32 = "uint32",
+    Int8 = "int8",
+    Int16 = "int16",
+    Int32 = "int32",
+    Float32 = "float32",
+    Utf8 = "utf8",
+    Boolean = "boolean",
+    Bytes = "bytes"
+}
+/** GATT characteristic permission flags. Combine with `|`. */
+export declare enum BlePerm {
+    Read = 1,
+    Write = 2,
+    Notify = 4
+}
+/** BLE peripheral status (mirrored by the runtime shim). */
+export declare enum BleStatus {
+    Idle = 0,
+    Initializing = 1,
+    Advertising = 2,
+    Connected = 3,
+    Error = 4
+}
+export declare enum BleAdvertisingMode {
+    Connectable = "connectable",
+    NonConnectable = "non_connectable"
+}
+/** A well-known GATT characteristic entry in the catalog. */
+export interface GattCharacteristicDef {
+    readonly uuid: string;
+    readonly type: BleValueType;
+    readonly read?: boolean;
+    readonly write?: boolean;
+    readonly notify?: boolean;
+}
+/**
+ * Standard GATT services/characteristics. Autocomplete walks the hierarchy:
+ *   GATT.ENVIRONMENTAL. -> TEMPERATURE, HUMIDITY, ...
+ * Pass the .uuid, .type, and computed perms to BleServer.characteristic().
+ */
+export declare const GATT: {
+    readonly DEVICE_INFO: {
+        readonly MANUFACTURER_NAME: {
+            readonly uuid: "2A29";
+            readonly type: BleValueType.Utf8;
+            readonly read: true;
+        };
+        readonly MODEL_NUMBER: {
+            readonly uuid: "2A24";
+            readonly type: BleValueType.Utf8;
+            readonly read: true;
+        };
+        readonly FIRMWARE_REVISION: {
+            readonly uuid: "2A26";
+            readonly type: BleValueType.Utf8;
+            readonly read: true;
+        };
+    };
+    readonly ENVIRONMENTAL: {
+        readonly TEMPERATURE: {
+            readonly uuid: "2A6E";
+            readonly type: BleValueType.Int16;
+            readonly read: true;
+            readonly notify: true;
+        };
+        readonly HUMIDITY: {
+            readonly uuid: "2A6F";
+            readonly type: BleValueType.Uint16;
+            readonly read: true;
+            readonly notify: true;
+        };
+        readonly PRESSURE: {
+            readonly uuid: "2A6D";
+            readonly type: BleValueType.Uint32;
+            readonly read: true;
+            readonly notify: true;
+        };
+    };
+    readonly BATTERY: {
+        readonly LEVEL: {
+            readonly uuid: "2A19";
+            readonly type: BleValueType.Uint8;
+            readonly read: true;
+            readonly notify: true;
+        };
+    };
+};
+/** The value passed to/from callbacks — narrowed per characteristic by type. */
+export type CharValue = number | string | boolean | Uint8Array;
+/**
+ * BLE GATT peripheral control, lowered to native ESP-IDF NimBLE
+ * (`nimble_host` / `ble_gap` / `ble_gatts`) by framework-esp32.
+ *
+ * No `include()` calls here — NimBLE headers are framework-owned and added via
+ * forcedIncludes when the program uses ble.* ops.
+ *
+ * Transpiler note: method bodies pass parameters directly into semantic calls
+ * (no local consts / module counters) so the resolver can statically track every
+ * argument. The characteristic index is carried through the chain via
+ * `this._charCount` fieldValues, mirroring how HttpRequest carries _method/_url.
+ */
+export declare class BleClass {
+    static readonly __instance_name = "Ble";
+    /** Begin building a GATT server with the given advertised device name. */
+    server(name: string): BleServer;
+    /** Initialize NimBLE, register services, and start advertising. */
+    begin(): void;
+    advertise(): void;
+    stopAdvertising(): void;
+    /** Blocking at top level; cooperatively awaitable inside async functions. */
+    untilConnected(timeoutMs?: number): Promise<boolean>;
+    untilConnectedStart(): void;
+    isConnected(): boolean;
+    status(): BleStatus;
+    clientCount(): number;
+    txPower(dbm: number): this;
+    notify(index: number, value: number): void;
+}
+/**
+ * Fluent GATT server builder. Returned by `Ble.server()`.
+ *
+ * Single-class fluent chain (like HttpRequest): characteristic() returns `this`,
+ * so onRead/onWrite/onSubscribe chain directly. The _charCount field tracks
+ * which characteristic slot the callbacks attach to.
+ *
+ * Field tracking (read by the transpiler resolver via ctor field assignment):
+ *   _name      — advertised device name
+ *   _charCount — current characteristic index (the last characteristic() target)
+ *   _svcCount  — current service index
+ */
+export declare class BleServer {
+    private _name;
+    private _charCount;
+    private _lastChar;
+    private _svcCount;
+    constructor(name: string, charCount: number, svcCount: number);
+    /** Add a characteristic by UUID, value type, and permissions.
+     *  Combine permissions with `|`: `BlePerm.Read | BlePerm.Notify`.
+     *  Returns this for chaining. */
+    characteristic(uuid: string, type: BleValueType, perms: number): this;
+    /** Begin a new service grouping. Subsequent characteristics attach to it. */
+    service(uuid: string): this;
+    /** Register a read handler for the most recently added characteristic. */
+    onRead(handler: () => CharValue): this;
+    /** Register a write handler for the most recently added characteristic. */
+    onWrite(handler: (value: number) => void): this;
+    /** Register a connect handler (called when a central connects). */
+    onConnect(handler: () => void): this;
+    /** Register a disconnect handler (called when a central disconnects). */
+    onDisconnect(handler: () => void): this;
+    /** Push a new value to subscribed clients on the most recently added characteristic. */
+    notify(value: number): void;
+    /** Initialize NimBLE, register services, and start advertising. */
+    begin(): void;
+}
+export declare const Ble: BleClass;

package/dist/ble.js

@@ -0,0 +1,157 @@
+import { bleServerBegin, bleAdvertiseStart, bleAdvertiseStop, bleAddService, bleAddChar, bleOnRead, bleOnWrite, bleOnConnect, bleOnDisconnect, bleNotify, bleIsConnected, bleClientCount, bleSetName, bleUntilConnected, bleUntilConnectedStart, bleSetTxPower, bleStatus, } from './emit.js';
+import { callback } from './callback.js';
+/** Characteristic value encoding — drives both TS callback types and C++ marshalling. */
+export var BleValueType;
+(function (BleValueType) {
+    BleValueType["Uint8"] = "uint8";
+    BleValueType["Uint16"] = "uint16";
+    BleValueType["Uint32"] = "uint32";
+    BleValueType["Int8"] = "int8";
+    BleValueType["Int16"] = "int16";
+    BleValueType["Int32"] = "int32";
+    BleValueType["Float32"] = "float32";
+    BleValueType["Utf8"] = "utf8";
+    BleValueType["Boolean"] = "boolean";
+    BleValueType["Bytes"] = "bytes";
+})(BleValueType || (BleValueType = {}));
+/** GATT characteristic permission flags. Combine with `|`. */
+export var BlePerm;
+(function (BlePerm) {
+    BlePerm[BlePerm["Read"] = 1] = "Read";
+    BlePerm[BlePerm["Write"] = 2] = "Write";
+    BlePerm[BlePerm["Notify"] = 4] = "Notify";
+})(BlePerm || (BlePerm = {}));
+/** BLE peripheral status (mirrored by the runtime shim). */
+export var BleStatus;
+(function (BleStatus) {
+    BleStatus[BleStatus["Idle"] = 0] = "Idle";
+    BleStatus[BleStatus["Initializing"] = 1] = "Initializing";
+    BleStatus[BleStatus["Advertising"] = 2] = "Advertising";
+    BleStatus[BleStatus["Connected"] = 3] = "Connected";
+    BleStatus[BleStatus["Error"] = 4] = "Error";
+})(BleStatus || (BleStatus = {}));
+export var BleAdvertisingMode;
+(function (BleAdvertisingMode) {
+    BleAdvertisingMode["Connectable"] = "connectable";
+    BleAdvertisingMode["NonConnectable"] = "non_connectable";
+})(BleAdvertisingMode || (BleAdvertisingMode = {}));
+/**
+ * Standard GATT services/characteristics. Autocomplete walks the hierarchy:
+ *   GATT.ENVIRONMENTAL. -> TEMPERATURE, HUMIDITY, ...
+ * Pass the .uuid, .type, and computed perms to BleServer.characteristic().
+ */
+export const GATT = {
+    DEVICE_INFO: {
+        MANUFACTURER_NAME: { uuid: '2A29', type: BleValueType.Utf8, read: true },
+        MODEL_NUMBER: { uuid: '2A24', type: BleValueType.Utf8, read: true },
+        FIRMWARE_REVISION: { uuid: '2A26', type: BleValueType.Utf8, read: true },
+    },
+    ENVIRONMENTAL: {
+        TEMPERATURE: { uuid: '2A6E', type: BleValueType.Int16, read: true, notify: true },
+        HUMIDITY: { uuid: '2A6F', type: BleValueType.Uint16, read: true, notify: true },
+        PRESSURE: { uuid: '2A6D', type: BleValueType.Uint32, read: true, notify: true },
+    },
+    BATTERY: {
+        LEVEL: { uuid: '2A19', type: BleValueType.Uint8, read: true, notify: true },
+    },
+};
+/**
+ * BLE GATT peripheral control, lowered to native ESP-IDF NimBLE
+ * (`nimble_host` / `ble_gap` / `ble_gatts`) by framework-esp32.
+ *
+ * No `include()` calls here — NimBLE headers are framework-owned and added via
+ * forcedIncludes when the program uses ble.* ops.
+ *
+ * Transpiler note: method bodies pass parameters directly into semantic calls
+ * (no local consts / module counters) so the resolver can statically track every
+ * argument. The characteristic index is carried through the chain via
+ * `this._charCount` fieldValues, mirroring how HttpRequest carries _method/_url.
+ */
+export class BleClass {
+    /** Begin building a GATT server with the given advertised device name. */
+    server(name) {
+        bleSetName(name);
+        return new BleServer(name, 0, 1);
+    }
+    /** Initialize NimBLE, register services, and start advertising. */
+    begin() {
+        bleServerBegin("TypeCAD");
+        bleAdvertiseStart();
+    }
+    advertise() { bleAdvertiseStart(); }
+    stopAdvertising() { bleAdvertiseStop(); }
+    /** Blocking at top level; cooperatively awaitable inside async functions. */
+    untilConnected(timeoutMs = 0) {
+        bleUntilConnected(timeoutMs);
+        return Promise.resolve(false);
+    }
+    untilConnectedStart() { bleUntilConnectedStart(); }
+    isConnected() { return bleIsConnected(); }
+    status() { return bleStatus(); }
+    clientCount() { return bleClientCount(); }
+    txPower(dbm) { bleSetTxPower(dbm); return this; }
+    notify(index, value) { bleNotify(index, value); }
+}
+BleClass.__instance_name = "Ble";
+/**
+ * Fluent GATT server builder. Returned by `Ble.server()`.
+ *
+ * Single-class fluent chain (like HttpRequest): characteristic() returns `this`,
+ * so onRead/onWrite/onSubscribe chain directly. The _charCount field tracks
+ * which characteristic slot the callbacks attach to.
+ *
+ * Field tracking (read by the transpiler resolver via ctor field assignment):
+ *   _name      — advertised device name
+ *   _charCount — current characteristic index (the last characteristic() target)
+ *   _svcCount  — current service index
+ */
+export class BleServer {
+    constructor(name, charCount, svcCount) {
+        this._name = name;
+        this._charCount = charCount;
+        this._lastChar = charCount;
+        this._svcCount = svcCount;
+    }
+    /** Add a characteristic by UUID, value type, and permissions.
+     *  Combine permissions with `|`: `BlePerm.Read | BlePerm.Notify`.
+     *  Returns this for chaining. */
+    characteristic(uuid, type, perms) {
+        bleAddChar(this._charCount, uuid, type, perms, this._svcCount);
+        return this;
+    }
+    /** Begin a new service grouping. Subsequent characteristics attach to it. */
+    service(uuid) {
+        bleAddService(uuid);
+        return this;
+    }
+    /** Register a read handler for the most recently added characteristic. */
+    onRead(handler) {
+        bleOnRead(this._lastChar, callback(handler));
+        return this;
+    }
+    /** Register a write handler for the most recently added characteristic. */
+    onWrite(handler) {
+        bleOnWrite(this._lastChar, callback(handler));
+        return this;
+    }
+    /** Register a connect handler (called when a central connects). */
+    onConnect(handler) {
+        bleOnConnect(callback(handler));
+        return this;
+    }
+    /** Register a disconnect handler (called when a central disconnects). */
+    onDisconnect(handler) {
+        bleOnDisconnect(callback(handler));
+        return this;
+    }
+    /** Push a new value to subscribed clients on the most recently added characteristic. */
+    notify(value) {
+        bleNotify(this._lastChar, value);
+    }
+    /** Initialize NimBLE, register services, and start advertising. */
+    begin() {
+        bleServerBegin(this._name);
+        bleAdvertiseStart();
+    }
+}
+export const Ble = new BleClass();

package/dist/emit.d.ts

@@ -8,6 +8,31 @@ export declare function gpioToggle(pin: number | string): void;
 export declare function gpioSetMode(pin: number | string, mode: string): void;
 /** Write PWM duty cycle to a pin. */
 export declare function pwmWrite(pin: number | string, duty: number): void;
+import type { Pin } from './gpio.js';
+type RmtPin = Pin | number | string;
+/** Positional semantic primitive. Args: pin, resolutionHz, bit0Hi, bit0Lo,
+ *  bit1Hi, bit1Lo, msbFirst, queueDepth. Use rmtTxInit() from hal/rmt.ts. */
+export declare function rmtTxInit(pin: RmtPin, 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 init). */
+export declare function rmtTxWriteBytes(pin: RmtPin, bytes: number[] | Uint8Array): void;
+/** Write raw RMT symbols — arbitrary [hiTicks, loTicks] pairs. */
+export declare function rmtTxWriteSymbols(pin: RmtPin, symbols: [number, number][]): void;
+/** Block until the queued TX completes. */
+export declare function rmtTxWaitDone(pin: RmtPin, timeoutMs?: number): void;
+/** Tear down the TX channel and release its slot. */
+export declare function rmtTxDeinit(pin: RmtPin): void;
+/** Positional semantic primitive — use rmtRxInit() from hal/rmt.ts. */
+export declare function rmtRxInit(pin: RmtPin, resolutionHz: number): void;
+/** Register a callback-by-name invoked when an RX burst completes. */
+export declare function rmtRxOnReceived(pin: RmtPin, handler: string): void;
+/** Start receiving. */
+export declare function rmtRxStart(pin: RmtPin): void;
+/** Stop receiving. */
+export declare function rmtRxStop(pin: RmtPin): void;
+/** Blocking read — returns flattened symbols [d0,l0,d1,l1,…] in ticks. */
+export declare function rmtRxRead(pin: RmtPin, maxCount: number): number[];
+/** Tear down the RX channel and release its slot. */
+export declare function rmtRxDeinit(pin: RmtPin): void;
 /** Read analog value from a pin. */
 export declare function adcRead(pin: number | string): number;
 /** Read analog voltage from a pin (ADC value converted to voltage). */
@@ -134,5 +159,102 @@ export declare function powerDeepSleep(ms: number): void;
 export declare function powerLightSleep(): void;
 /** Set the CPU frequency (MHz). */
 export declare function powerSetCpuFrequency(mhz: number): void;
+/** Enter deep sleep until `pin` reaches `level` (pin wakeup). Architecture-aware:
+ *  ext0 on Xtensa (RTC pins), gpio-wakeup on RISC-V. */
+export declare function powerDeepSleepPin(pin: number, level: number): void;
+export declare function preferencesBegin(namespace: string, readOnly: boolean): void;
+export declare function preferencesEnd(): void;
+export declare function preferencesClear(): void;
+export declare function preferencesRemove(key: string): void;
+export declare function preferencesPutInt(key: string, value: number): void;
+export declare function preferencesGetInt(key: string, defaultValue: number): number;
+export declare function preferencesPutUInt(key: string, value: number): void;
+export declare function preferencesGetUInt(key: string, defaultValue: number): number;
+export declare function preferencesPutBool(key: string, value: boolean): void;
+export declare function preferencesGetBool(key: string, defaultValue: boolean): boolean;
+export declare function preferencesPutFloat(key: string, value: number): void;
+export declare function preferencesGetFloat(key: string, defaultValue: number): number;
+export declare function preferencesPutString(key: string, value: string): void;
+export declare function preferencesGetString(key: string, defaultValue: string): string;
+export declare function wifiConnect(ssid: string, password?: string, timeoutMs?: number): boolean;
+export declare function wifiConnectStart(ssid: string, password?: string): void;
+export declare function wifiDisconnect(): void;
+export declare function wifiStatus(): number;
+export declare function wifiIsConnected(): boolean;
+export declare function wifiLocalIp(): string;
+export declare function wifiRssi(): number;
+export declare function wifiMac(): string;
+export declare function wifiSetHostname(name: string): void;
+export declare function wifiSetStaticIp(ip: string, gateway: string, subnet: string, dns?: string): void;
+export declare function wifiSetAutoReconnect(enabled: boolean): void;
+export declare function wifiSetPowerSave(mode: string): void;
+export declare function wifiSetTxPower(dbm: number): void;
+export declare function wifiOnEvent(event: string, handler: string): void;
+export declare function wifiApStart(ssid: string, password?: string, channel?: number, hidden?: boolean, maxClients?: number): boolean;
+export declare function wifiApStop(): void;
+export declare function wifiApClientCount(): number;
+export declare function wifiApIp(): string;
+export declare function wifiApSetChannel(channel: number): void;
+export declare function wifiApSetHidden(hidden: boolean): void;
+export declare function wifiApSetMaxClients(maxClients: number): void;
+export declare function wifiScan(): number;
+export declare function wifiScanStart(): void;
+export declare function wifiScanCount(): number;
+export declare function wifiScanSsid(index: number): string;
+export declare function wifiScanRssi(index: number): number;
+export declare function wifiScanEncryption(index: number): number;
+export declare function wifiScanChannel(index: number): number;
+export declare function wifiSaveCredentials(ssid: string, password: string): void;
+export declare function wifiConnectSaved(timeoutMs?: number): boolean;
+export declare function wifiClearCredentials(): void;
+export declare function wifiWaitConnected(timeoutMs?: number): boolean;
+export declare function wifiWaitDisconnected(): void;
+export declare function httpBegin(method: string, url: string): void;
+export declare function httpReset(): void;
+export declare function httpSetHeader(name: string, value: string): void;
+export declare function httpSetTimeout(ms: number): void;
+export declare function httpSetMaxBody(bytes: number): void;
+export declare function httpSetBody(data: string, json?: boolean): void;
+export declare function httpSetInsecure(): void;
+export declare function httpSetCaCert(pem: string): void;
+export declare function httpSend(): boolean;
+export declare function httpSendStart(): void;
+export declare function httpStatus(): number;
+export declare function httpOk(): boolean;
+export declare function httpBody(): string;
+export declare function httpContentLength(): number;
+export declare function httpResponseHeader(name: string): string;
+export declare function bleServerBegin(name: string): void;
+export declare function bleAdvertiseStart(): void;
+export declare function bleAdvertiseStop(): void;
+export declare function bleAddService(uuid: string): void;
+export declare function bleAddChar(index: number, uuid: string, type: string, perms: number, svcIndex: number): void;
+export declare function bleOnRead(index: number, handler: string): void;
+export declare function bleOnWrite(index: number, handler: string): void;
+export declare function bleOnConnect(handler: string): void;
+export declare function bleOnDisconnect(handler: string): void;
+export declare function bleNotify(index: number, value: number | string): void;
+export declare function bleIsConnected(): boolean;
+export declare function bleClientCount(): number;
+export declare function bleSetName(name: string): void;
+export declare function bleUntilConnected(timeoutMs?: number): boolean;
+export declare function bleUntilConnectedStart(): void;
+export declare function bleSetTxPower(dbm: number): void;
+export declare function bleStatus(): number;
 /** Emit raw C++ code (escape hatch for unsupported operations). */
 export declare function rawCpp(code: string): void;
+/**
+ * Emit raw C++ in expression context. Use when an IDF macro or constructor
+ * must produce a value (e.g. `WIFI_INIT_CONFIG_DEFAULT()` expands to a struct
+ * initializer; there's no TS-side way to construct it). The type parameter
+ * is purely a TS hint — the transpiler doesn't check it; it just emits the
+ * raw text in expression position.
+ *
+ *   const cfg = rawCpp<wifi_init_config_t>('WIFI_INIT_CONFIG_DEFAULT()');
+ *
+ * lowers to:
+ *
+ *   wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
+ */
+export declare function rawCppExpr<T>(code: string): T;
+export {};

package/dist/emit.js

@@ -25,6 +25,29 @@ export function gpioSetMode(pin, mode) { }
 // ---------------------------------------------------------------------------
 /** Write PWM duty cycle to a pin. */
 export function pwmWrite(pin, duty) { }
+/** Positional semantic primitive. Args: pin, resolutionHz, bit0Hi, bit0Lo,
+ *  bit1Hi, bit1Lo, msbFirst, queueDepth. Use rmtTxInit() from hal/rmt.ts. */
+export function rmtTxInit(pin, resolutionHz, bit0Hi, bit0Lo, bit1Hi, bit1Lo, msbFirst, queueDepth) { }
+/** Write bytes via the channel's bytes-encoder (timings fixed at init). */
+export function rmtTxWriteBytes(pin, bytes) { }
+/** Write raw RMT symbols — arbitrary [hiTicks, loTicks] pairs. */
+export function rmtTxWriteSymbols(pin, symbols) { }
+/** Block until the queued TX completes. */
+export function rmtTxWaitDone(pin, timeoutMs) { }
+/** Tear down the TX channel and release its slot. */
+export function rmtTxDeinit(pin) { }
+/** Positional semantic primitive — use rmtRxInit() from hal/rmt.ts. */
+export function rmtRxInit(pin, resolutionHz) { }
+/** Register a callback-by-name invoked when an RX burst completes. */
+export function rmtRxOnReceived(pin, handler) { }
+/** Start receiving. */
+export function rmtRxStart(pin) { }
+/** Stop receiving. */
+export function rmtRxStop(pin) { }
+/** Blocking read — returns flattened symbols [d0,l0,d1,l1,…] in ticks. */
+export function rmtRxRead(pin, maxCount) { return []; }
+/** Tear down the RX channel and release its slot. */
+export function rmtRxDeinit(pin) { }
 // ---------------------------------------------------------------------------
 // ADC — analog-to-digital conversion
 // ---------------------------------------------------------------------------
@@ -187,8 +210,115 @@ export function powerDeepSleep(ms) { }
 export function powerLightSleep() { }
 /** Set the CPU frequency (MHz). */
 export function powerSetCpuFrequency(mhz) { }
+/** Enter deep sleep until `pin` reaches `level` (pin wakeup). Architecture-aware:
+ *  ext0 on Xtensa (RTC pins), gpio-wakeup on RISC-V. */
+export function powerDeepSleepPin(pin, level) { }
+// ---------------------------------------------------------------------------
+// Preferences (NVS-backed key/value store)
+// ---------------------------------------------------------------------------
+export function preferencesBegin(namespace, readOnly) { }
+export function preferencesEnd() { }
+export function preferencesClear() { }
+export function preferencesRemove(key) { }
+export function preferencesPutInt(key, value) { }
+export function preferencesGetInt(key, defaultValue) { return 0; }
+export function preferencesPutUInt(key, value) { }
+export function preferencesGetUInt(key, defaultValue) { return 0; }
+export function preferencesPutBool(key, value) { }
+export function preferencesGetBool(key, defaultValue) { return false; }
+export function preferencesPutFloat(key, value) { }
+export function preferencesGetFloat(key, defaultValue) { return 0; }
+export function preferencesPutString(key, value) { }
+export function preferencesGetString(key, defaultValue) { return ""; }
+export function wifiConnect(ssid, password, timeoutMs) { return false; }
+export function wifiConnectStart(ssid, password) { }
+export function wifiDisconnect() { }
+export function wifiStatus() { return 0; }
+export function wifiIsConnected() { return false; }
+export function wifiLocalIp() { return ""; }
+export function wifiRssi() { return 0; }
+export function wifiMac() { return ""; }
+export function wifiSetHostname(name) { }
+export function wifiSetStaticIp(ip, gateway, subnet, dns) { }
+export function wifiSetAutoReconnect(enabled) { }
+export function wifiSetPowerSave(mode) { }
+export function wifiSetTxPower(dbm) { }
+export function wifiOnEvent(event, handler) { }
+export function wifiApStart(ssid, password, channel, hidden, maxClients) { return false; }
+export function wifiApStop() { }
+export function wifiApClientCount() { return 0; }
+export function wifiApIp() { return ""; }
+export function wifiApSetChannel(channel) { }
+export function wifiApSetHidden(hidden) { }
+export function wifiApSetMaxClients(maxClients) { }
+export function wifiScan() { return 0; }
+export function wifiScanStart() { }
+export function wifiScanCount() { return 0; }
+export function wifiScanSsid(index) { return ""; }
+export function wifiScanRssi(index) { return 0; }
+export function wifiScanEncryption(index) { return 0; }
+export function wifiScanChannel(index) { return 0; }
+export function wifiSaveCredentials(ssid, password) { }
+export function wifiConnectSaved(timeoutMs) { return false; }
+export function wifiClearCredentials() { }
+export function wifiWaitConnected(timeoutMs) { return false; }
+export function wifiWaitDisconnected() { }
+// ---------------------------------------------------------------------------
+// HTTP client
+// ---------------------------------------------------------------------------
+export function httpBegin(method, url) { }
+export function httpReset() { }
+export function httpSetHeader(name, value) { }
+export function httpSetTimeout(ms) { }
+export function httpSetMaxBody(bytes) { }
+export function httpSetBody(data, json) { }
+export function httpSetInsecure() { }
+export function httpSetCaCert(pem) { }
+export function httpSend() { return false; }
+export function httpSendStart() { }
+export function httpStatus() { return 0; }
+export function httpOk() { return false; }
+export function httpBody() { return ""; }
+export function httpContentLength() { return 0; }
+export function httpResponseHeader(name) { return ""; }
+// ---------------------------------------------------------------------------
+// BLE (NimBLE GATT peripheral)
+// ---------------------------------------------------------------------------
+export function bleServerBegin(name) { }
+export function bleAdvertiseStart() { }
+export function bleAdvertiseStop() { }
+export function bleAddService(uuid) { }
+export function bleAddChar(index, uuid, type, perms, svcIndex) { }
+export function bleOnRead(index, handler) { }
+export function bleOnWrite(index, handler) { }
+export function bleOnConnect(handler) { }
+export function bleOnDisconnect(handler) { }
+export function bleNotify(index, value) { }
+export function bleIsConnected() { return false; }
+export function bleClientCount() { return 0; }
+export function bleSetName(name) { }
+export function bleUntilConnected(timeoutMs) { return false; }
+export function bleUntilConnectedStart() { }
+export function bleSetTxPower(dbm) { }
+export function bleStatus() { return 0; }
 // ---------------------------------------------------------------------------
 // Raw C++ escape hatch
 // ---------------------------------------------------------------------------
 /** Emit raw C++ code (escape hatch for unsupported operations). */
 export function rawCpp(code) { }
+/**
+ * Emit raw C++ in expression context. Use when an IDF macro or constructor
+ * must produce a value (e.g. `WIFI_INIT_CONFIG_DEFAULT()` expands to a struct
+ * initializer; there's no TS-side way to construct it). The type parameter
+ * is purely a TS hint — the transpiler doesn't check it; it just emits the
+ * raw text in expression position.
+ *
+ *   const cfg = rawCpp<wifi_init_config_t>('WIFI_INIT_CONFIG_DEFAULT()');
+ *
+ * lowers to:
+ *
+ *   wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
+ */
+export function rawCppExpr(code) {
+    return undefined;
+}

package/dist/http.d.ts

@@ -0,0 +1,48 @@
+export declare enum HttpMethod {
+    GET = 0,
+    POST = 1,
+    PUT = 2,
+    DELETE = 3,
+    HEAD = 4,
+    PATCH = 5
+}
+/**
+ * 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 declare class HttpRequest {
+    private _method;
+    private _url;
+    constructor(method: string, url: string);
+    header(name: string, value: string): this;
+    timeout(ms: number): this;
+    maxBody(bytes: number): this;
+    body(data: string): this;
+    jsonBody(json: string): this;
+    /** Skip TLS certificate verification (development only). */
+    insecure(): this;
+    caCert(pem: string): this;
+    /** Blocking at top level; cooperatively awaitable inside async functions. */
+    send(): Promise<boolean>;
+    status(): number;
+    ok(): boolean;
+    /** Response body as a C string (valid until the next request). */
+    text(): string;
+    contentLength(): number;
+    responseHeader(name: string): string;
+}
+export declare class HttpClass {
+    static readonly __instance_name = "Http";
+    get(url: string): HttpRequest;
+    post(url: string): HttpRequest;
+    put(url: string): HttpRequest;
+    del(url: string): HttpRequest;
+    head(url: string): HttpRequest;
+    patch(url: string): HttpRequest;
+}
+export declare const Http: HttpClass;