@typecad/hal 1.0.0-alpha.14 → 1.0.0-alpha.16

package/dist/http.js

@@ -1,65 +1,59 @@
-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;
+// ---------------------------------------------------------------------------
+// Request — the thin HTTP/S client
+//
+// The request is CONSTRUCTION facts: method, URL, and the policy opts
+// (timeout, body, TLS mode) ride the constructor; headers attach with the
+// header() chain; send() lowers the facts into the shim and performs the
+// request; the response is read from this request afterwards (the shim
+// holds the response until the next request).
+//
+//   const req = new Request(Request.POST, url, {
+//     timeoutMs: 10_000,
+//     body: '{"v":1}', json: true,
+//     caCert: PEM,            // pin a CA (verified TLS)
+//   });
+//   req.header('X-Custom', 'v');
+//   if (req.send()) { console.log(req.status()); }
+//
+// Method tokens: Request.GET / POST / PUT / DELETE / HEAD / PATCH (plain
+// 'GET' strings also accepted). `insecure: true` skips TLS certificate
+// verification (development only). Awaiting send() inside async functions
+// still splits into a background request + done-poll (the async machinery
+// intercepts the send op; the facts were already lowered at send()).
+// ----------------------------------------------------------------------------
+import { httpBegin, httpSetHeader, httpSetTimeout, httpSetBody, httpSetInsecure, httpSetCaCert, httpSend, httpStatus, httpOk, httpBody, httpContentLength, httpResponseHeader, } from './emit.js';
+export class Request {
+    constructor(method, url, opts = {}) {
+        this._method = method.toUpperCase();
         this._url = url;
+        this._timeoutMs = opts.timeoutMs ?? 10_000;
+        this._body = opts.body ?? '';
+        this._json = opts.json === true;
+        this._insecure = opts.insecure === true;
+        this._caCert = opts.caCert ?? '';
     }
+    /** Attach a request header. Chainable — one per header. */
     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 the request (blocking). The construction facts lower into the
+     *  shim first (timeout/body/TLS mode), then the request performs.
+     *  Awaitable inside async functions — the async machinery splits the
+     *  send into a background request + done-poll. */
     send() {
+        httpSetTimeout(this._timeoutMs);
+        httpSetBody(this._body, this._json);
+        httpSetInsecure(this._insecure);
+        httpSetCaCert(this._caCert);
         httpBegin(this._method, this._url);
-        httpSend();
-        return Promise.resolve(false);
+        return httpSend();
     }
+    /** Response status code (0 before a completed send). */
     status() {
         return httpStatus();
     }
+    /** True when the response status is 2xx. */
     ok() {
         return httpOk();
     }
@@ -67,38 +61,19 @@ export class HttpRequest {
     text() {
         return httpBody();
     }
+    /** Response Content-Length (0 when absent). */
     contentLength() {
         return httpContentLength();
     }
+    /** One response header value ("" when absent; valid until the next
+     *  request). */
     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();
+Request.GET = 'GET';
+Request.POST = 'POST';
+Request.PUT = 'PUT';
+Request.DELETE = 'DELETE';
+Request.HEAD = 'HEAD';
+Request.PATCH = 'PATCH';

package/dist/i2c-target.d.ts

@@ -0,0 +1,28 @@
+export declare class I2CTarget {
+    private readonly _bus;
+    private readonly _address;
+    private readonly _hz;
+    /** Construct a device handle. `bus` is the bus instance (I2C0, I2C1, …);
+     *  `address` is the 7-bit I2C address; `hz` optionally sets the bus speed
+     *  once at first use (100k/400k/1M map to Zephyr's I2C_SPEED_* tiers). */
+    constructor(bus: string, address: number, opts?: {
+        hz?: number;
+    });
+    /** Write one register byte (i2c_reg_write_byte). */
+    writeReg(reg: number, value: number): void;
+    /** Read one register byte (i2c_reg_read_byte). */
+    readReg(reg: number): number;
+    /** Read-modify-write one register field (i2c_reg_update_byte): the bits in
+     *  `mask` are replaced by `value`. Atomic on the wire — no read-back race. */
+    updateReg(reg: number, mask: number, value: number): void;
+    /** Write raw bytes (i2c_write) — commands and data with no register
+     *  convention. */
+    write(data: number[] | Uint8Array): void;
+    /** The 7-bit I2C address this target addresses. Exposed so I2CTarget
+     *  structurally satisfies the @typecad/simulator II2CDeviceAccessor
+     *  contract (`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;
+}

package/dist/i2c-target.js

@@ -0,0 +1,52 @@
+// ---------------------------------------------------------------------------
+// I2CTarget — the thin Zephyr-shaped I2C device
+//
+// One address on a bus, Zephyr's register verbs verbatim: writeReg/readReg
+// are i2c_reg_write_byte / i2c_reg_read_byte, updateReg is the native
+// read-modify-write (i2c_reg_update_byte — mask and all, no read-back race),
+// and write() is i2c_write. No begin/end transaction dance, no Wire
+// vocabulary — the controller device handle and the per-call address are all
+// Zephyr needs.
+//
+// `bus` is the board's bus instance export (I2C0/I2C1); the address is the
+// 7-bit form (0x44). The optional bus `hz` applies once (i2c_configure,
+// guarded) — Zephyr's own I2C_SPEED_SET mapping.
+// ----------------------------------------------------------------------------
+import { i2cRegWrite, i2cRegRead, i2cRegUpdate, i2cDevWrite } from './emit.js';
+export class I2CTarget {
+    /** Construct a device handle. `bus` is the bus instance (I2C0, I2C1, …);
+     *  `address` is the 7-bit I2C address; `hz` optionally sets the bus speed
+     *  once at first use (100k/400k/1M map to Zephyr's I2C_SPEED_* tiers). */
+    constructor(bus, address, opts) {
+        this._bus = bus;
+        this._address = address;
+        this._hz = opts?.hz ?? 0;
+    }
+    /** Write one register byte (i2c_reg_write_byte). */
+    writeReg(reg, value) {
+        i2cRegWrite(this._bus, this._address, this._hz, reg, value);
+    }
+    /** Read one register byte (i2c_reg_read_byte). */
+    readReg(reg) {
+        return i2cRegRead(this._bus, this._address, this._hz, reg);
+    }
+    /** Read-modify-write one register field (i2c_reg_update_byte): the bits in
+     *  `mask` are replaced by `value`. Atomic on the wire — no read-back race. */
+    updateReg(reg, mask, value) {
+        i2cRegUpdate(this._bus, this._address, this._hz, reg, mask, value);
+    }
+    /** Write raw bytes (i2c_write) — commands and data with no register
+     *  convention. */
+    write(data) {
+        i2cDevWrite(this._bus, this._address, this._hz, data);
+    }
+    /** The 7-bit I2C address this target addresses. Exposed so I2CTarget
+     *  structurally satisfies the @typecad/simulator II2CDeviceAccessor
+     *  contract (`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;
+    }
+}

package/dist/i2c.d.ts

@@ -1,47 +1,9 @@
-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;
-    readBytes(register: number, count: number): Uint8Array;
-}
+import { I2CTarget } from './i2c-target.js';
 export declare class I2CBus {
-    static readonly __includes: string[];
     private _bus;
     constructor(bus: string);
-    device(address: number): I2CDevice;
-    begin(): this;
-    beginSlave(address: number): void;
-    end(): void;
-    setClock(hz: number): void;
-    /** Recover a locked I2C bus by clocking SCL until the stuck slave releases SDA.
-     *
-     *  NOTE: This references the board-defined `SCL` pin macro. All current MCU
-     *  packages (atmega328p, esp32, esp32c3, esp32c6, esp32s3) export SCL, so
-     *  this works in practice. A fully portable version would resolve the SCL
-     *  pin number via a board constant (e.g. peripherals.i2c.0.sclPin), but that
-     *  requires adding resolved numeric pin fields to the board-constants
-     *  pipeline — deferred for now. */
-    recover(): void;
-    take(): this | null;
-    release(): void;
-    writeByte(address: number, register: number, value: number): void;
-    readByte(address: number, register: number): number;
-    beginTransmission(address: number): void;
-    write(data: number | number[] | Uint8Array): void;
-    endTransmission(stop?: boolean): number;
-    requestFrom(address: number, quantity: number, stop?: boolean): number;
-    available(): number;
-    read(): number;
+    /** The functional device target at `address` on this controller —
+     *  register verbs callable directly, and the fact-carrier `new Sensor(...)`
+     *  accepts. Equivalent to `new I2CTarget(this, address)`. */
+    device(address: number): I2CTarget;
 }
-/** Map TypeCAD I2C instance number to Arduino C++ object name. I2C0→Wire, I2C1→Wire1 */
-export declare function i2cName(instance: number): string;

package/dist/i2c.js

@@ -1,137 +1,24 @@
-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);
-        i2cWrite(this._bus, register);
-        i2cWrite(this._bus, value);
-        i2cEndTx(this._bus, true);
-    }
-    readByte(register) {
-        include("<Wire.h>");
-        i2cBeginTx(this._bus, this._address);
-        i2cWrite(this._bus, register);
-        i2cEndTx(this._bus, false);
-        i2cRequestFrom(this._bus, this._address, 1);
-        return i2cRead(this._bus);
-    }
-    writeBytes(register, data) {
-        include("<Wire.h>");
-        i2cBeginTx(this._bus, this._address);
-        i2cWrite(this._bus, register);
-        i2cWriteBuffer(this._bus, data);
-        i2cEndTx(this._bus, true);
-    }
-    readBytes(register, count) {
-        include("<Wire.h>");
-        i2cBeginTx(this._bus, this._address);
-        i2cWrite(this._bus, register);
-        i2cEndTx(this._bus, false);
-        i2cRequestFrom(this._bus, this._address, count, true);
-        // 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);
-    }
-}
+// ---------------------------------------------------------------------------
+// I2C — controller selector (legacy Wire API removed)
+//
+// The bus singletons (I2C0/I2C1…) are CONTROLLER SELECTORS; device(address)
+// hands back the FUNCTIONAL I2CTarget directly — register verbs callable with
+// no further construction (`I2C0.device(0x44).writeReg(...)`) and the same
+// fact-carrier `new Sensor(SENSOR.x, I2C0.device(0x44))` consumes. Explicit
+// construction `new I2CTarget(I2C0, 0x44)` is equivalent. The former
+// begin/endTransmission/requestFrom Wire reconstruction was removed with the
+// legacy Arduino surface; the standalone I2CDevice fact-carrier was absorbed
+// by I2CTarget (same facts, plus the verbs).
+// ----------------------------------------------------------------------------
+import { I2CTarget } from './i2c-target.js';
 export class I2CBus {
     constructor(bus) {
         this._bus = bus;
     }
+    /** The functional device target at `address` on this controller —
+     *  register verbs callable directly, and the fact-carrier `new Sensor(...)`
+     *  accepts. Equivalent to `new I2CTarget(this, address)`. */
     device(address) {
-        return new I2CDevice(this._bus, address);
-    }
-    begin() {
-        include("<Wire.h>");
-        i2cBegin(this._bus);
-        return this;
-    }
-    beginSlave(address) {
-        i2cBegin(this._bus, address);
-    }
-    end() {
-        i2cEnd(this._bus);
-    }
-    setClock(hz) {
-        i2cSetClock(this._bus, hz);
+        return new I2CTarget(this._bus, address);
     }
-    /** Recover a locked I2C bus by clocking SCL until the stuck slave releases SDA.
-     *
-     *  NOTE: This references the board-defined `SCL` pin macro. All current MCU
-     *  packages (atmega328p, esp32, esp32c3, esp32c6, esp32s3) export SCL, so
-     *  this works in practice. A fully portable version would resolve the SCL
-     *  pin number via a board constant (e.g. peripherals.i2c.0.sclPin), but that
-     *  requires adding resolved numeric pin fields to the board-constants
-     *  pipeline — deferred for now. */
-    recover() {
-        include("<Wire.h>");
-        rawCpp(`pinMode(SCL, OUTPUT);`);
-        rawCpp(`for (int i = 0; i < 16; i++) {`);
-        rawCpp(`  digitalWrite(SCL, LOW);`);
-        rawCpp(`  delayMicroseconds(10);`);
-        rawCpp(`  digitalWrite(SCL, HIGH);`);
-        rawCpp(`  delayMicroseconds(10);`);
-        rawCpp(`}`);
-        rawCpp(`${this._bus}.begin();`);
-    }
-    take() {
-        include("<Wire.h>");
-        return this;
-    }
-    release() {
-        // No-op for standard Arduino.
-    }
-    writeByte(address, register, value) {
-        i2cBeginTx(this._bus, address);
-        i2cWrite(this._bus, register);
-        i2cWrite(this._bus, value);
-        i2cEndTx(this._bus, true);
-    }
-    readByte(address, register) {
-        i2cBeginTx(this._bus, address);
-        i2cWrite(this._bus, register);
-        i2cEndTx(this._bus, false);
-        i2cRequestFrom(this._bus, address, 1);
-        return i2cRead(this._bus);
-    }
-    // Low-level Wire API pass-through methods
-    beginTransmission(address) {
-        i2cBeginTx(this._bus, address);
-    }
-    write(data) {
-        i2cWrite(this._bus, data);
-    }
-    endTransmission(stop) {
-        return i2cEndTx(this._bus, stop ?? true);
-    }
-    requestFrom(address, quantity, stop) {
-        return i2cRequestFrom(this._bus, address, quantity, stop ?? true);
-    }
-    available() {
-        return i2cAvailable(this._bus);
-    }
-    read() {
-        return i2cRead(this._bus);
-    }
-}
-I2CBus.__includes = ["<Wire.h>"];
-/** Map TypeCAD I2C instance number to Arduino C++ object name. I2C0→Wire, I2C1→Wire1 */
-export function i2cName(instance) {
-    return instance === 0 ? "Wire" : `Wire${instance}`;
 }

package/dist/index.d.ts

@@ -1,54 +1,42 @@
 export type { DigitalValue, AnalogValue } from './types.js';
-export { PinMode, InterruptMode } from './types.js';
-export type { IPinGroup, PinGroupMember } from './types.js';
-export { createPinGroup } from './types.js';
+export { PinMode } from './types.js';
 export type { InterruptHandler } from './types.js';
 export type { ArchitectureIdentifier } from './types.js';
-export type { I2CAddress } from './types.js';
-export type { SPIBitOrder, SPIMode, SPISettings } from './types.js';
+export type { SerialValue } from './types.js';
 export { include } from './include.js';
 export { board } from './board.js';
 export { callback } from './callback.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';
-export { abs, min, max, NumClass, Num, MapChain, ConstrainChain } from './math.js';
-export { Pulse, pulseIn, pulseInLong } from './pulse.js';
-export { Shift, shiftIn, shiftOut } from './shift.js';
+export { TimeClass, Time } from './time.js';
+export { abs, min, max, NumClass, Num } from './math.js';
 export { Random } from './random.js';
-export { randomSeed, random } from './random.js';
-export { noInterrupts, interrupts, attachInterrupt, detachInterrupt } from './interrupts.js';
-export { Pin, OutputPin, InputPin, ToneChain } from './gpio.js';
-export { I2CBus, I2CDevice, i2cName } from './i2c.js';
-export { SPIBus, SPIDevice, spiName } from './spi.js';
-export { SerialPort, serialName } from './uart.js';
-export { createHALInstances } from './utils.js';
+export { Pin } from './gpio.js';
+export { GPIO } from './gpio-pin.js';
+export { shiftOut, shiftIn } from './shift-pin.js';
+export { PWM } from './pwm-pin.js';
+export { ADC } from './adc-pin.js';
+export { DAC } from './dac-pin.js';
+export { Watchdog } from './watchdog.js';
+export { Counter } from './counter.js';
+export { I2CTarget } from './i2c-target.js';
+export { SPITarget } from './spi-target.js';
+export { UART } from './uart-port.js';
+export { Thread } from './thread.js';
+export { I2CBus } from './i2c.js';
+export { Sensor } from './sensor.js';
+export { SENSOR, CHAN, SENSOR_PART_INFO } from './sensor-catalog.generated.js';
+export { ZEPHYR_ADC_GAINS, ZEPHYR_ADC_REFERENCES, ZEPHYR_GPIO_FLAGS, ZEPHYR_GPIO_INTS } from './zephyr-tokens.generated.js';
+export type { SensorToken, SensorChannelName, SensorPartInfo } from './sensor-catalog.generated.js';
+export { SPIBus } from './spi.js';
+export { USBConsole } from './usb.js';
 export type { Bit, Bits } from './register.js';
 export { register, bits } from './register.js';
-export { EEPROMClass, EEPROM } from './eeprom.js';
-export { WDTClass, WDT } from './wdt.js';
-export { ADCClass, ADC } from './adc.js';
-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 { Store } from './preferences.js';
+export { File } from './fs.js';
+export { Mqtt } from './mqtt.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 { WiFi, Scan, WiFiAP } from './wifi.js';
+export { Request } from './http.js';
+export type { RequestOpts } from './http.js';
+export { BLE, BleChain, BleValueType, BlePerm, GATT } from './ble.js';
 export type { GattCharacteristicDef, CharValue } from './ble.js';
-export { RmtChannel } from './rmt.js';

package/dist/index.js

@@ -1,46 +1,34 @@
-export { PinMode, InterruptMode } from './types.js';
-export { createPinGroup } from './types.js';
+export { PinMode } from './types.js';
 export { include } from './include.js';
 export { board } from './board.js';
 export { callback } from './callback.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';
-export { abs, min, max, NumClass, Num, MapChain, ConstrainChain } from './math.js';
-export { Pulse, pulseIn, pulseInLong } from './pulse.js';
-export { Shift, shiftIn, shiftOut } from './shift.js';
+export { TimeClass, Time } from './time.js';
+export { abs, min, max, NumClass, Num } from './math.js';
 export { Random } from './random.js';
-export { randomSeed, random } from './random.js';
-export { noInterrupts, interrupts, attachInterrupt, detachInterrupt } from './interrupts.js';
-export { Pin, OutputPin, InputPin, ToneChain } from './gpio.js';
-export { I2CBus, I2CDevice, i2cName } from './i2c.js';
-export { SPIBus, SPIDevice, spiName } from './spi.js';
-export { SerialPort, serialName } from './uart.js';
-export { createHALInstances } from './utils.js';
+export { Pin } from './gpio.js';
+export { GPIO } from './gpio-pin.js';
+export { shiftOut, shiftIn } from './shift-pin.js';
+export { PWM } from './pwm-pin.js';
+export { ADC } from './adc-pin.js';
+export { DAC } from './dac-pin.js';
+export { Watchdog } from './watchdog.js';
+export { Counter } from './counter.js';
+export { I2CTarget } from './i2c-target.js';
+export { SPITarget } from './spi-target.js';
+export { UART } from './uart-port.js';
+export { Thread } from './thread.js';
+export { I2CBus } from './i2c.js';
+export { Sensor } from './sensor.js';
+export { SENSOR, CHAN, SENSOR_PART_INFO } from './sensor-catalog.generated.js';
+export { ZEPHYR_ADC_GAINS, ZEPHYR_ADC_REFERENCES, ZEPHYR_GPIO_FLAGS, ZEPHYR_GPIO_INTS } from './zephyr-tokens.generated.js';
+export { SPIBus } from './spi.js';
+export { USBConsole } from './usb.js';
 export { register, bits } from './register.js';
-export { EEPROMClass, EEPROM } from './eeprom.js';
-export { WDTClass, WDT } from './wdt.js';
-export { ADCClass, ADC } from './adc.js';
-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 { Store } from './preferences.js';
+export { File } from './fs.js';
+export { Mqtt } from './mqtt.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';
+export { WiFi, Scan, WiFiAP } from './wifi.js';
+export { Request } from './http.js';
+export { BLE, BleChain, BleValueType, BlePerm, GATT } from './ble.js';

package/dist/math.d.ts

@@ -1,20 +1,7 @@
-export declare class MapChain {
-    constructor(value: number);
-    from(low: number, high: number): MapChain;
-    to(low: number, high: number): number;
-    toPercent(): number;
-    toByte(): number;
-}
-export declare class ConstrainChain {
-    constructor(value: number);
-    between(low: number, high: number): number;
-}
 export declare class NumClass {
     abs(x: number): number;
     min(a: number, b: number): number;
     max(a: number, b: number): number;
-    constrain(value: number): ConstrainChain;
-    map(value: number): MapChain;
 }
 export declare const Num: NumClass;
 export declare function abs(x: number): number;