@typecad/hal 0.1.0-alpha.2 → 1.0.0-alpha.10

package/dist/emit.js

@@ -5,6 +5,11 @@
 // resolver.  The framework strategy translates each operation into
 // framework-specific C++ at code generation time.
 //
+// EMIT BOUNDARY: This file is a canonical entry point of the HAL lowering
+// surface (A) — its C++ output lands in user sketches. The emitted bytes are
+// covered by the TypeCAD Runtime Exception (see RUNTIME_EXCEPTION.md at the
+// repository root) and are not subject to the license of this tool source.
+//
 // Pin parameters accept both `number` (legacy framework pin number) and
 // `string` (MCU port name like "PB5"). The transpiler resolves port names
 // to framework pin numbers via the MCU package's pin mapping.
@@ -25,6 +30,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
 // ---------------------------------------------------------------------------
@@ -85,6 +113,15 @@ export function i2cRequestFrom(bus, address, quantity, stop) { return 0; }
 export function i2cAvailable(bus) { return 0; }
 /** Read a byte from I2C. */
 export function i2cRead(bus) { return 0; }
+/**
+ * Drain `count` bytes requested from the I2C bus into a caller-provided buffer.
+ * Semantic primitive: lowers to the `i2c.read_buffer` HAL op. The `buffer`
+ * argument is emitted as a placeholder (`__HAL_READ_BUF__`) that the var-init
+ * transformer rewrites to the caller's own buffer variable, so bytes land in
+ * the `uint8_t data[N]` declared in user scope — NOT an internal temp that
+ * decays to a pointer on return. Keeps `data.length` / `data[i]` valid.
+ */
+export function i2cReadBuffer(bus, count, buffer) { }
 // ---------------------------------------------------------------------------
 // SPI — serial peripheral interface
 // ---------------------------------------------------------------------------
@@ -102,6 +139,14 @@ export function spiEndTx(bus) { }
 export function spiCsLow(pin) { }
 /** Set SPI chip-select pin HIGH. */
 export function spiCsHigh(pin) { }
+/**
+ * Read `count` bytes from the SPI bus into a caller-provided buffer by clocking
+ * dummy (0x00) transfers. Semantic primitive: lowers to the `spi.read_buffer`
+ * HAL op (per-byte `bus.transfer(0)` read loop). The `buffer` placeholder is
+ * rewritten to the caller's variable. Mirrors i2cReadBuffer. The caller is
+ * responsible for asserting/de-asserting chip-select around it.
+ */
+export function spiReadBuffer(bus, count, buffer) { }
 /** Set SPI data mode. */
 export function spiSetMode(bus, mode) { }
 /** Set SPI bit order. */
@@ -170,8 +215,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/fs.d.ts

@@ -1,13 +1,33 @@
 /**
  * FSClass provides a high-level abstraction for filesystem operations.
- * Maps to SD.h or LittleFS depending on the board configuration.
+ *
+ * Lowered to native filesystem HAL ops (fs.*): ESP-IDF mounts an SD card via
+ * esp_vfs_fat_sdmmc_mount (FAT on SDMMC/SDSPI); Arduino uses SD.h / LittleFS.
+ * The per-framework runtime shim owns the open/read/write/close dance and
+ * returns heap strings for readText.
+ *
+ * The semantic primitives (fsBegin / fsReadText / ...) are resolved to fs.*
+ * HAL ops by the transpiler's hal-plugins switch; this class is the
+ * ergonomic, type-checking surface.
  */
 export declare class FSClass {
     static readonly __instance_name = "FS";
+    /** Mount the filesystem. Returns true on success. */
     begin(): boolean;
+    /** Read a UTF-8 text file into a string. Returns "" if the file is missing
+     *  or unreadable. The returned buffer is caller-owned. */
     readText(path: string): string;
+    /** Write a string to a file (overwrites). Silently no-ops if the file
+     *  cannot be opened for writing. */
     writeText(path: string, content: string): void;
+    /** True if a file exists at the path. */
     exists(path: string): boolean;
+    /** Delete a file. Returns true if deleted. */
     remove(path: string): boolean;
 }
 export declare const FS: FSClass;
+export declare function fsBegin(): void;
+export declare function fsReadText(path: string): string;
+export declare function fsWriteText(path: string, content: string): void;
+export declare function fsExists(path: string): boolean;
+export declare function fsRemove(path: string): boolean;

package/dist/fs.js

@@ -1,39 +1,47 @@
-import { rawCpp } from './emit.js';
-import { include } from './include.js';
 /**
  * FSClass provides a high-level abstraction for filesystem operations.
- * Maps to SD.h or LittleFS depending on the board configuration.
+ *
+ * Lowered to native filesystem HAL ops (fs.*): ESP-IDF mounts an SD card via
+ * esp_vfs_fat_sdmmc_mount (FAT on SDMMC/SDSPI); Arduino uses SD.h / LittleFS.
+ * The per-framework runtime shim owns the open/read/write/close dance and
+ * returns heap strings for readText.
+ *
+ * The semantic primitives (fsBegin / fsReadText / ...) are resolved to fs.*
+ * HAL ops by the transpiler's hal-plugins switch; this class is the
+ * ergonomic, type-checking surface.
  */
 export class FSClass {
+    /** Mount the filesystem. Returns true on success. */
     begin() {
-        include("<FS.h>");
-        rawCpp(`return FS.begin();`);
+        fsBegin();
         return true;
     }
+    /** Read a UTF-8 text file into a string. Returns "" if the file is missing
+     *  or unreadable. The returned buffer is caller-owned. */
     readText(path) {
-        include("<FS.h>");
-        rawCpp(`File f = FS.open(${path}.c_str(), "r");`);
-        rawCpp(`if (!f) return "";`);
-        rawCpp(`String s = f.readString();`);
-        rawCpp(`f.close();`);
-        rawCpp(`return s.c_str();`);
-        return "";
+        return fsReadText(path);
     }
+    /** Write a string to a file (overwrites). Silently no-ops if the file
+     *  cannot be opened for writing. */
     writeText(path, content) {
-        include("<FS.h>");
-        rawCpp(`File f = FS.open(${path}.c_str(), "w");`);
-        rawCpp(`if (f) { f.print(${content}.c_str()); f.close(); }`);
+        fsWriteText(path, content);
     }
+    /** True if a file exists at the path. */
     exists(path) {
-        include("<FS.h>");
-        rawCpp(`return FS.exists(${path}.c_str());`);
-        return false;
+        return fsExists(path);
     }
+    /** Delete a file. Returns true if deleted. */
     remove(path) {
-        include("<FS.h>");
-        rawCpp(`return FS.remove(${path}.c_str());`);
-        return false;
+        return fsRemove(path);
     }
 }
 FSClass.__instance_name = "FS";
 export const FS = new FSClass();
+// ── Semantic primitives (resolved to fs.* HAL ops by the transpiler) ──
+// These are inert at runtime (tests, type-checking); the cuttlefish transpiler
+// intercepts calls by name and lowers them to typed HAL op IR.
+export function fsBegin() { }
+export function fsReadText(path) { return ""; }
+export function fsWriteText(path, content) { }
+export function fsExists(path) { return false; }
+export function fsRemove(path) { return false; }

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;

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/i2c.d.ts

@@ -2,6 +2,13 @@ export declare class I2CDevice {
     private _bus;
     private _address;
     constructor(bus: string, address: number);
+    /** The 7-bit I2C address this accessor targets. Exposed so I2CDevice
+     *  structurally satisfies the @typecad/simulator II2CDeviceAccessor contract
+     *  (which declares `readonly address`), letting the same driver function be
+     *  typed against the contract and accept either a real board device or a
+     *  simulated one. The transpiler strips HAL class bodies to IR, so this
+     *  getter carries no runtime cost in the generated C++. */
+    get address(): number;
     writeByte(register: number, value: number): void;
     readByte(register: number): number;
     writeBytes(register: number, data: number[] | Uint8Array): void;

package/dist/i2c.js

@@ -1,10 +1,19 @@
-import { i2cBegin, i2cEnd, i2cSetClock, i2cBeginTx, i2cWrite, i2cWriteBuffer, i2cEndTx, i2cRequestFrom, i2cAvailable, i2cRead, rawCpp } from './emit.js';
+import { i2cBegin, i2cEnd, i2cSetClock, i2cBeginTx, i2cWrite, i2cWriteBuffer, i2cEndTx, i2cRequestFrom, i2cAvailable, i2cRead, i2cReadBuffer, rawCpp } from './emit.js';
 import { include } from './include.js';
 export class I2CDevice {
     constructor(bus, address) {
         this._bus = bus;
         this._address = address;
     }
+    /** The 7-bit I2C address this accessor targets. Exposed so I2CDevice
+     *  structurally satisfies the @typecad/simulator II2CDeviceAccessor contract
+     *  (which declares `readonly address`), letting the same driver function be
+     *  typed against the contract and accept either a real board device or a
+     *  simulated one. The transpiler strips HAL class bodies to IR, so this
+     *  getter carries no runtime cost in the generated C++. */
+    get address() {
+        return this._address;
+    }
     writeByte(register, value) {
         include("<Wire.h>");
         i2cBeginTx(this._bus, this._address);
@@ -33,9 +42,11 @@ export class I2CDevice {
         i2cWrite(this._bus, register);
         i2cEndTx(this._bus, false);
         i2cRequestFrom(this._bus, this._address, count, true);
-        rawCpp(`static uint8_t __buf[${count}];`);
-        rawCpp(`for (int __i = 0; __i < ${count}; __i++) __buf[__i] = ${this._bus}.read();`);
-        rawCpp(`return __buf;`);
+        // Drain the requested bytes into the caller's buffer (declared by the
+        // Uint8Array return marker as `uint8_t data[count]`). Using the semantic
+        // primitive — NOT rawCpp — keeps the buffer in user scope so it survives
+        // the return (no decayed pointer) and `data.length` / `data[i]` work.
+        i2cReadBuffer(this._bus, count, new Uint8Array(count));
         return new Uint8Array(count);
     }
 }

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';
@@ -33,5 +33,22 @@ export { DACClass, DAC } from './dac.js';
 export { PreferencesClass, Preferences } from './preferences.js';
 export { HardwareTimer, Timer0, Timer1, Timer2 } from './timer.js';
 export { FSClass, FS } from './fs.js';
+export { fsBegin, fsReadText, fsWriteText, fsExists, fsRemove } from './fs.js';
+export { MdnsClass, MDNS } from './mdns.js';
+export { mdnsStart, mdnsSetHostname, mdnsAddService, mdnsAnnounce, mdnsStop } from './mdns.js';
+export { MqttClass, MQTT } from './mqtt.js';
+export { mqttConnect, mqttOnMessage, mqttSubscribe, mqttPublish, mqttConnected, mqttDisconnect } from './mqtt.js';
+export { OtaClass, OTA } from './ota.js';
+export { otaFromUrl, otaBegin, otaWrite, otaApply } from './ota.js';
+export { TemperatureClass, Temperature } from './temperature.js';
+export { tempRead } from './temperature.js';
+export { hwtimerSetFrequency, hwtimerOnOverflow, hwtimerStart, hwtimerStop } from './timer.js';
+export { CapacitiveClass, Capacitive } from './capacitive.js';
+export { capacitiveRead } from './capacitive.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';
@@ -26,5 +26,21 @@ export { DACClass, DAC } from './dac.js';
 export { PreferencesClass, Preferences } from './preferences.js';
 export { HardwareTimer, Timer0, Timer1, Timer2 } from './timer.js';
 export { FSClass, FS } from './fs.js';
+export { fsBegin, fsReadText, fsWriteText, fsExists, fsRemove } from './fs.js';
+export { MdnsClass, MDNS } from './mdns.js';
+export { mdnsStart, mdnsSetHostname, mdnsAddService, mdnsAnnounce, mdnsStop } from './mdns.js';
+export { MqttClass, MQTT } from './mqtt.js';
+export { mqttConnect, mqttOnMessage, mqttSubscribe, mqttPublish, mqttConnected, mqttDisconnect } from './mqtt.js';
+export { OtaClass, OTA } from './ota.js';
+export { otaFromUrl, otaBegin, otaWrite, otaApply } from './ota.js';
+export { TemperatureClass, Temperature } from './temperature.js';
+export { tempRead } from './temperature.js';
+export { hwtimerSetFrequency, hwtimerOnOverflow, hwtimerStart, hwtimerStop } from './timer.js';
+export { CapacitiveClass, Capacitive } from './capacitive.js';
+export { capacitiveRead } from './capacitive.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/mdns.d.ts

@@ -0,0 +1,31 @@
+/**
+ * MdnsClass — mDNS service discovery (ESP-IDF esp_mdns).
+ *
+ * Lowered to native mDNS HAL ops (mdns.*): ESP-IDF's esp_mdns component
+ * advertises the device on the local network as `<hostname>.local` and
+ * publishes services (e.g. `_http._tcp`) for discovery by Bonjour/Avahi.
+ *
+ * The semantic primitives (mdnsStart / mdnsAddService / ...) are resolved to
+ * mdns.* HAL ops by the transpiler; this class is the ergonomic surface.
+ *
+ * Requires WiFi to be connected (mDNS rides on the station interface).
+ */
+export declare class MdnsClass {
+    static readonly __instance_name = "MDNS";
+    /** Initialize mDNS and set the host name (advertised as <name>.local). */
+    start(hostname: string): boolean;
+    /** Set/override the host name after start(). */
+    setHostname(name: string): void;
+    /** Publish a service instance. proto is "_tcp" or "_udp". */
+    addService(instance: string, proto: string, port: number): void;
+    /** Advertise that the device is reachable (sends a probe/announce). */
+    announce(): void;
+    /** Tear down the mDNS responder. */
+    stop(): void;
+}
+export declare const MDNS: MdnsClass;
+export declare function mdnsStart(hostname: string): void;
+export declare function mdnsSetHostname(name: string): void;
+export declare function mdnsAddService(instance: string, proto: string, port: number): void;
+export declare function mdnsAnnounce(): void;
+export declare function mdnsStop(): void;

package/dist/mdns.js

@@ -0,0 +1,43 @@
+/**
+ * MdnsClass — mDNS service discovery (ESP-IDF esp_mdns).
+ *
+ * Lowered to native mDNS HAL ops (mdns.*): ESP-IDF's esp_mdns component
+ * advertises the device on the local network as `<hostname>.local` and
+ * publishes services (e.g. `_http._tcp`) for discovery by Bonjour/Avahi.
+ *
+ * The semantic primitives (mdnsStart / mdnsAddService / ...) are resolved to
+ * mdns.* HAL ops by the transpiler; this class is the ergonomic surface.
+ *
+ * Requires WiFi to be connected (mDNS rides on the station interface).
+ */
+export class MdnsClass {
+    /** Initialize mDNS and set the host name (advertised as <name>.local). */
+    start(hostname) {
+        mdnsStart(hostname);
+        return true;
+    }
+    /** Set/override the host name after start(). */
+    setHostname(name) {
+        mdnsSetHostname(name);
+    }
+    /** Publish a service instance. proto is "_tcp" or "_udp". */
+    addService(instance, proto, port) {
+        mdnsAddService(instance, proto, port);
+    }
+    /** Advertise that the device is reachable (sends a probe/announce). */
+    announce() {
+        mdnsAnnounce();
+    }
+    /** Tear down the mDNS responder. */
+    stop() {
+        mdnsStop();
+    }
+}
+MdnsClass.__instance_name = "MDNS";
+export const MDNS = new MdnsClass();
+// ── Semantic primitives (resolved to mdns.* HAL ops by the transpiler) ──
+export function mdnsStart(hostname) { }
+export function mdnsSetHostname(name) { }
+export function mdnsAddService(instance, proto, port) { }
+export function mdnsAnnounce() { }
+export function mdnsStop() { }

package/dist/mqtt.d.ts

@@ -0,0 +1,33 @@
+/**
+ * MqttClass — MQTT 3.1.1 pub/sub client (ESP-IDF esp_mqtt).
+ *
+ * Lowered to native MQTT HAL ops (mqtt.*): ESP-IDF's esp_mqtt_client_* API.
+ * Covers the common IoT pub/sub path: connect to a broker, publish, subscribe
+ * with an onMessage callback, and disconnect. The runtime shim owns the event
+ * loop translation (ESP-IDF's MQTT event handler → the user's TS callback).
+ *
+ * Requires a network connection (WiFi) before connect().
+ */
+export declare class MqttClass {
+    static readonly __instance_name = "MQTT";
+    /** Connect to a broker URI (e.g. "mqtt://broker.local" or "mqtts://..."). */
+    connect(brokerUri: string, clientId: string): boolean;
+    /** Set a handler invoked for every received PUBLISH on a subscribed topic.
+     *  The handler receives (topic, payload). */
+    onMessage(handler: (topic: string, payload: string) => void): void;
+    /** Subscribe to a topic filter (e.g. "sensors/#"). */
+    subscribe(topic: string): void;
+    /** Publish a message to a topic. */
+    publish(topic: string, data: string): void;
+    /** True if the client is currently connected to the broker. */
+    connected(): boolean;
+    /** Disconnect from the broker and free the client. */
+    disconnect(): void;
+}
+export declare const MQTT: MqttClass;
+export declare function mqttConnect(brokerUri: string, clientId: string): void;
+export declare function mqttOnMessage(handler: string): void;
+export declare function mqttSubscribe(topic: string): void;
+export declare function mqttPublish(topic: string, data: string): void;
+export declare function mqttConnected(): boolean;
+export declare function mqttDisconnect(): void;