@typecad/hal 1.0.0-alpha.13 → 1.0.0-alpha.15

package/dist/math.js

@@ -1,14 +1,12 @@
-export class MapChain {
-    constructor(value) { }
-    from(low, high) { return this; }
-    to(low, high) { return 0; }
-    toPercent() { return 0; }
-    toByte() { return 0; }
-}
-export class ConstrainChain {
-    constructor(value) { }
-    between(low, high) { return 0; }
-}
+// ---------------------------------------------------------------------------
+// Num — numeric conveniences over the strategy polyfill.
+//
+// The fluent map/constrain chains (Num.map(x).from(a,b).to(c,d)) were dropped
+// with the free map()/constrain() functions in the Zephyr-first cleanup —
+// the remap/clamp arithmetic is a three-line helper in user code, and no
+// backend honors it natively. abs/min/max stay (bare-call polyfills exist on
+// every framework).
+// ---------------------------------------------------------------------------
 export class NumClass {
     // No __instance_name — Num methods must NOT be intercepted by the HAL
     // resolver. They pass through as bare C++ calls (Num.abs(-7)), which the
@@ -19,8 +17,6 @@ export class NumClass {
     abs(x) { return 0; }
     min(a, b) { return 0; }
     max(a, b) { return 0; }
-    constrain(value) { return new ConstrainChain(value); }
-    map(value) { return new MapChain(value); }
 }
 export const Num = new NumClass();
 export function abs(x) { return 0; }

package/dist/mqtt.d.ts

@@ -1,33 +1,23 @@
-/**
- * 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). */
+export declare class Mqtt {
+    private readonly _uri;
+    private readonly _clientId;
+    /** Construct the client for a broker ("mqtt://broker.local" or
+     *  "mqtts://..." for TLS). */
+    constructor(uri: string, opts: {
+        clientId: string;
+    });
+    /** Connect to the broker. Requires a network connection (WiFi) first.
+     *  The Zephyr client completes the session in its poll thread — poll
+     *  linked() afterwards. */
+    connect(): void;
+    /** Handler invoked for every received PUBLISH on a subscribed topic. */
     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;
+    /** True while the broker session is up. */
+    linked(): 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;

package/dist/mqtt.js

@@ -1,22 +1,35 @@
+// ---------------------------------------------------------------------------
+// Mqtt — the thin pub/sub client
+//
+// The broker URI and client id are CONSTRUCTION facts; the verbs map onto
+// the Zephyr MQTT client (mqtt_connect / mqtt_publish / mqtt_subscribe,
+// with a poll thread feeding mqtt_input/mqtt_live):
+//
+//   connect()     → establish the broker session (poll linked() after —
+//                   the Zephyr client connects in its poll thread)
+//   onMessage(cb) → handler for every received PUBLISH on a subscribed
+//                   topic — receives (topic, payload)
+//   subscribe(t)  → subscribe to a topic filter ("sensors/#")
+//   publish(t, s) → publish a message
+//   linked()      → the broker session is up
+//   disconnect()  → disconnect and free the client
+// ----------------------------------------------------------------------------
 import { callback } from './callback.js';
-/**
- * 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 class MqttClass {
-    /** Connect to a broker URI (e.g. "mqtt://broker.local" or "mqtts://..."). */
-    connect(brokerUri, clientId) {
-        mqttConnect(brokerUri, clientId);
-        return true;
+import { mqttConnect, mqttOnMessage, mqttSubscribe, mqttPublish, mqttConnected, mqttDisconnect, } from './emit.js';
+export class Mqtt {
+    /** Construct the client for a broker ("mqtt://broker.local" or
+     *  "mqtts://..." for TLS). */
+    constructor(uri, opts) {
+        this._uri = uri;
+        this._clientId = opts.clientId;
     }
-    /** Set a handler invoked for every received PUBLISH on a subscribed topic.
-     *  The handler receives (topic, payload). */
+    /** Connect to the broker. Requires a network connection (WiFi) first.
+     *  The Zephyr client completes the session in its poll thread — poll
+     *  linked() afterwards. */
+    connect() {
+        mqttConnect(this._uri, this._clientId);
+    }
+    /** Handler invoked for every received PUBLISH on a subscribed topic. */
     onMessage(handler) {
         mqttOnMessage(callback(handler));
     }
@@ -28,8 +41,8 @@ export class MqttClass {
     publish(topic, data) {
         mqttPublish(topic, data);
     }
-    /** True if the client is currently connected to the broker. */
-    connected() {
+    /** True while the broker session is up. */
+    linked() {
         return mqttConnected();
     }
     /** Disconnect from the broker and free the client. */
@@ -37,12 +50,3 @@ export class MqttClass {
         mqttDisconnect();
     }
 }
-MqttClass.__instance_name = "MQTT";
-export const MQTT = new MqttClass();
-// ── Semantic primitives (resolved to mqtt.* HAL ops by the transpiler) ──
-export function mqttConnect(brokerUri, clientId) { }
-export function mqttOnMessage(handler) { }
-export function mqttSubscribe(topic) { }
-export function mqttPublish(topic, data) { }
-export function mqttConnected() { return false; }
-export function mqttDisconnect() { }

package/dist/power.d.ts

@@ -1,21 +1,13 @@
-/**
- * PowerClass provides control over MCU power states and clock frequencies.
- *
- * The arch guard (ESP32 family vs AVR) lives in the strategy, not here — it
- * relies on the FQBN-derived architecture which is always available at
- * transpile time, unlike `board("architecture")` which needs a board package.
- */
-export declare class PowerClass {
-    static readonly __instance_name = "Power";
+export declare class Power {
+    /** Enter deep sleep for `ms`. Wakeup resets the chip — this call never
+     *  returns. */
     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;
+     *  Lowers to ext0 wakeup (Xtensa ESP32/S3, RTC pins only) or the
+     *  gpio-wakeup variant (RISC-V C3/C6) depending on the target. Wakeup
+     *  resets the chip — this call never returns. */
+    deepSleepUntil(pin: number, level: 0 | 1): void;
+    /** Enter light sleep until any wake source (GPIO/timer). */
     lightSleep(): void;
-    setCpuFrequency(mhz: number): void;
 }
-export declare const Power: PowerClass;
+export declare const PowerDefault: Power;

package/dist/power.js

@@ -1,30 +1,32 @@
-import { powerDeepSleep, powerLightSleep, powerSetCpuFrequency, powerDeepSleepPin } from './emit.js';
-/**
- * PowerClass provides control over MCU power states and clock frequencies.
- *
- * The arch guard (ESP32 family vs AVR) lives in the strategy, not here — it
- * relies on the FQBN-derived architecture which is always available at
- * transpile time, unlike `board("architecture")` which needs a board package.
- */
-export class PowerClass {
+// ---------------------------------------------------------------------------
+// Power — the thin power-management verbs
+//
+// Power is stateless on Zephyr (sleep entry goes through the power-management
+// policy / sys_pm), so the surface is bare verbs with no construction facts:
+//
+//   deepSleep(ms)        → deep sleep for ms (wake resets the chip)
+//   deepSleepUntil(pin, level) → deep sleep until the pin reaches level
+//                          (RTC-capable pins only; the framework flags
+//                          non-RTC pins at compile time; never returns)
+//   lightSleep()         → light sleep until any wake source
+// ----------------------------------------------------------------------------
+import { powerDeepSleep, powerLightSleep, powerDeepSleepPin } from './emit.js';
+export class Power {
+    /** Enter deep sleep for `ms`. Wakeup resets the chip — this call never
+     *  returns. */
     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) {
+     *  Lowers to ext0 wakeup (Xtensa ESP32/S3, RTC pins only) or the
+     *  gpio-wakeup variant (RISC-V C3/C6) depending on the target. Wakeup
+     *  resets the chip — this call never returns. */
+    deepSleepUntil(pin, level) {
         powerDeepSleepPin(pin, level);
     }
+    /** Enter light sleep until any wake source (GPIO/timer). */
     lightSleep() {
         powerLightSleep();
     }
-    setCpuFrequency(mhz) {
-        powerSetCpuFrequency(mhz);
-    }
 }
-PowerClass.__instance_name = "Power";
-export const Power = new PowerClass();
+export const PowerDefault = new Power();

package/dist/preferences.d.ts

@@ -1,27 +1,19 @@
-/**
- * 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;
-    end(): void;
-    clear(): void;
+export declare class Store {
+    private readonly _ns;
+    /** Construct the store for a namespace ('app' → settings subtree tc/app/). */
+    constructor(ns: string);
+    setInt(key: string, value: number): void;
+    getInt(key: string, defaultValue: number): number;
+    setFloat(key: string, value: number): void;
+    getFloat(key: string, defaultValue: number): number;
+    setBool(key: string, value: boolean): void;
+    getBool(key: string, defaultValue: boolean): boolean;
+    setString(key: string, value: string): void;
+    /** Read a string back. The value lands in the shim's ring buffer — copy
+     *  what you need before the next get on the same key. */
+    getString(key: string, defaultValue: string): string;
+    /** Delete one key (flash + cache). No-op when absent. */
     remove(key: string): void;
-    putInt(key: string, value: number): void;
-    getInt(key: string, defaultValue?: number): number;
-    putUInt(key: string, value: number): void;
-    getUInt(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;
+    /** Delete every key under this store's namespace. */
+    clear(): void;
 }
-export declare const Preferences: PreferencesClass;

package/dist/preferences.js

@@ -1,56 +1,58 @@
-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 {
-    begin(name, readOnly = false) {
-        preferencesBegin(name, readOnly);
-    }
-    end() {
-        preferencesEnd();
-    }
-    clear() {
-        preferencesClear();
-    }
+// ---------------------------------------------------------------------------
+// Store — the thin persistent key/value store
+//
+// The namespace is the CONSTRUCTION fact: `new Store('app')` rides every op
+// as the settings subtree prefix (tc/app/<key> on Zephyr's settings/ZMS
+// backend). There is no session to open or close — the backend loads once at
+// boot and every verb maps 1:1 onto a settings write/read/delete:
+//
+//   setInt/getInt, setFloat/getFloat, setBool/getBool,
+//   setString/getString  — typed pairs; get takes a REQUIRED default (no
+//                          hidden = 0 magic value)
+//   remove(key)          → settings_delete
+//   clear()              → delete every tc/<ns>/* key this app wrote
+//
+// Values survive re-flashing the application: they live in the board's
+// storage partition, not the app image.
+// ----------------------------------------------------------------------------
+import { preferencesPutInt, preferencesGetInt, preferencesPutFloat, preferencesGetFloat, preferencesPutBool, preferencesGetBool, preferencesPutString, preferencesGetString, preferencesRemove, preferencesClear, } from './emit.js';
+export class Store {
+    /** Construct the store for a namespace ('app' → settings subtree tc/app/). */
+    constructor(ns) {
+        this._ns = ns;
+    }
+    setInt(key, value) {
+        preferencesPutInt(this._ns, key, value);
+    }
+    getInt(key, defaultValue) {
+        return preferencesGetInt(this._ns, key, defaultValue);
+    }
+    setFloat(key, value) {
+        preferencesPutFloat(this._ns, key, value);
+    }
+    getFloat(key, defaultValue) {
+        return preferencesGetFloat(this._ns, key, defaultValue);
+    }
+    setBool(key, value) {
+        preferencesPutBool(this._ns, key, value);
+    }
+    getBool(key, defaultValue) {
+        return preferencesGetBool(this._ns, key, defaultValue);
+    }
+    setString(key, value) {
+        preferencesPutString(this._ns, key, value);
+    }
+    /** Read a string back. The value lands in the shim's ring buffer — copy
+     *  what you need before the next get on the same key. */
+    getString(key, defaultValue) {
+        return preferencesGetString(this._ns, key, defaultValue);
+    }
+    /** Delete one key (flash + cache). No-op when absent. */
     remove(key) {
-        preferencesRemove(key);
-    }
-    putInt(key, value) {
-        preferencesPutInt(key, value);
-    }
-    getInt(key, defaultValue = 0) {
-        return preferencesGetInt(key, defaultValue);
-    }
-    putUInt(key, value) {
-        preferencesPutUInt(key, value);
-    }
-    getUInt(key, defaultValue = 0) {
-        return preferencesGetUInt(key, defaultValue);
+        preferencesRemove(this._ns, key);
     }
-    putBool(key, value) {
-        preferencesPutBool(key, value);
-    }
-    getBool(key, defaultValue = false) {
-        return preferencesGetBool(key, defaultValue);
-    }
-    putFloat(key, value) {
-        preferencesPutFloat(key, value);
-    }
-    getFloat(key, defaultValue = 0) {
-        return preferencesGetFloat(key, defaultValue);
-    }
-    putString(key, value) {
-        preferencesPutString(key, value);
-    }
-    getString(key, defaultValue = "") {
-        return preferencesGetString(key, defaultValue);
+    /** Delete every key under this store's namespace. */
+    clear() {
+        preferencesClear(this._ns);
     }
 }
-PreferencesClass.__instance_name = "Preferences";
-export const Preferences = new PreferencesClass();

package/dist/pulse.d.ts

@@ -1,4 +1,4 @@
-import type { Pin, InputPin } from './gpio.js';
+import type { Pin } from './gpio.js';
 export declare function pulseIn(pin: number, value: number, timeout?: number): number;
 export declare function pulseInLong(pin: number, value: number, timeout?: number): number;
 export declare class Pulse {
@@ -6,14 +6,14 @@ export declare class Pulse {
      * Functional entrypoint for measuring pulses.
      * @example Pulse.on(D7).high()
      */
-    static on(pin: Pin | InputPin): PulseMeasurement;
+    static on(pin: Pin | number): PulseMeasurement;
     /** Measure long pulses using high-precision 64-bit timers. */
-    static long(pin: Pin | InputPin, value: number): number;
+    static long(pin: Pin | number, value: number): number;
 }
 declare class PulseMeasurement {
     private _pin;
     private _timeout;
-    constructor(pin: Pin | InputPin);
+    constructor(pin: Pin | number);
     /** Set the maximum wait time for a pulse (in microseconds). */
     timeout(us: number): this;
     /** Measures the next HIGH pulse duration in microseconds. */

package/dist/pulse.js

@@ -1,4 +1,8 @@
 import { rawCpp } from './emit.js';
+/** Pin-or-number to the resolver's identifier form (type-level only). */
+function pinNum(pin) {
+    return (typeof pin === 'number' ? pin : pin.number);
+}
 export function pulseIn(pin, value, timeout) {
     if (timeout !== undefined) {
         rawCpp(`return pulseIn(${pin}, ${value}, ${timeout});`);
@@ -27,13 +31,13 @@ export class Pulse {
     }
     /** Measure long pulses using high-precision 64-bit timers. */
     static long(pin, value) {
-        rawCpp(`return pulseInLong(${pin.number}, ${value});`);
+        rawCpp(`return pulseInLong(${pinNum(pin)}, ${value});`);
         return 0;
     }
 }
 class PulseMeasurement {
     constructor(pin) {
-        this._pin = pin.number;
+        this._pin = pinNum(pin);
     }
     /** Set the maximum wait time for a pulse (in microseconds). */
     timeout(us) {

package/dist/pwm-pin.d.ts

@@ -0,0 +1,24 @@
+import type { Pin } from './gpio.js';
+export declare class PWM {
+    private readonly _pin;
+    private readonly _periodNs;
+    private readonly _controller;
+    private readonly _channel;
+    /** Construct a PWM channel. `periodNs` is required — the channel's period
+     *  in nanoseconds (50 Hz servo = 20_000_000; 1 kHz LED dimming = 1_000_000).
+     *  `controller`/`channel` override the routing when the board's facts do
+     *  not map this pin. */
+    constructor(pin: number | Pin, opts: {
+        periodNs: number;
+        controller?: string;
+        channel?: number;
+    });
+    /** Set the pulse width in nanoseconds (pwm_set_pulse_dt). */
+    setPulse(pulseNs: number): void;
+    /** Set the duty cycle as a fraction 0.0–1.0. Sugar: lowers to one
+     *  pwm_set_pulse_dt with pulse = duty × the constructed period. */
+    setDuty(duty: number): void;
+    /** Change the period at runtime (pwm_set_dt). Zephyr 4.4 has no period-only
+     *  setter, so the pulse resets to idle — follow with setPulse/setDuty. */
+    setPeriod(periodNs: number): void;
+}

package/dist/pwm-pin.js

@@ -0,0 +1,38 @@
+// ---------------------------------------------------------------------------
+// PWM — the thin Zephyr-shaped PWM channel
+//
+// The period is a CONSTRUCTION fact (Zephyr's model — the period lives with
+// the channel, not with each write): `new PWM(PA5, { periodNs: 20_000_000 })`.
+// The first use applies the construction period (pwm_set_dt with an idle
+// pulse — Zephyr 4.4 has no period-only setter), then setPulse lowers to
+// pwm_set_pulse_dt verbatim. setDuty(0.0–1.0) is sugar that lowers to
+// exactly one pwm_set_pulse_dt against the known period — no 0–255 scaling
+// anywhere. Nanoseconds throughout.
+// ----------------------------------------------------------------------------
+import { pwmSetPulse, pwmSetDuty, pwmSetPeriod } from './emit.js';
+export class PWM {
+    /** Construct a PWM channel. `periodNs` is required — the channel's period
+     *  in nanoseconds (50 Hz servo = 20_000_000; 1 kHz LED dimming = 1_000_000).
+     *  `controller`/`channel` override the routing when the board's facts do
+     *  not map this pin. */
+    constructor(pin, opts) {
+        this._pin = typeof pin === 'number' ? pin : pin.number;
+        this._periodNs = opts.periodNs;
+        this._controller = opts?.controller ?? '';
+        this._channel = opts?.channel ?? -1;
+    }
+    /** Set the pulse width in nanoseconds (pwm_set_pulse_dt). */
+    setPulse(pulseNs) {
+        pwmSetPulse(this._pin, this._periodNs, pulseNs, this._controller, this._channel);
+    }
+    /** Set the duty cycle as a fraction 0.0–1.0. Sugar: lowers to one
+     *  pwm_set_pulse_dt with pulse = duty × the constructed period. */
+    setDuty(duty) {
+        pwmSetDuty(this._pin, this._periodNs, duty, this._controller, this._channel);
+    }
+    /** Change the period at runtime (pwm_set_dt). Zephyr 4.4 has no period-only
+     *  setter, so the pulse resets to idle — follow with setPulse/setDuty. */
+    setPeriod(periodNs) {
+        pwmSetPeriod(this._pin, periodNs, this._controller, this._channel);
+    }
+}

package/dist/random.d.ts

@@ -1,5 +1,3 @@
-export declare function randomSeed(seed: number): void;
-export declare function random(minOrMax: number, max?: number): number;
 export declare class Random {
     /** Seeds the PRNG with a starting value. */
     static seed(val: number): void;

package/dist/random.js

@@ -1,26 +1,20 @@
-import { rawCpp } from './emit.js';
-export function randomSeed(seed) { }
-export function random(minOrMax, max) { return 0; }
+// ---------------------------------------------------------------------------
+// Random — the thin PRNG surface
+//
+// The Random namespace methods (seed/upTo/between/int) are intercepted by the
+// transpiler's namespace-method resolver and lowered to the random.* HAL op
+// family (random.seed / random.range / random.int), which each framework lowers
+// to its platform PRNG (Zephyr: a userspace xorshift32 seeded from
+// sys_rand_get). The bodies below are inert runtime stubs for host-side
+// type-checking only — never emitted.
+// ---------------------------------------------------------------------------
 export class Random {
     /** Seeds the PRNG with a starting value. */
-    static seed(val) {
-        rawCpp(`randomSeed(${val});`);
-    }
+    static seed(val) { }
     /** Returns a random number in range [0, max-1]. */
-    static upTo(max) {
-        rawCpp(`return random(${max});`);
-        return 0;
-    }
+    static upTo(max) { return 0; }
     /** Returns a random number in range [min, max-1]. */
-    static between(min, max) {
-        rawCpp(`return random(${min}, ${max});`);
-        return 0;
-    }
+    static between(min, max) { return 0; }
     /** Returns a random non-negative 31-bit integer [0, 2147483646]. */
-    static int() {
-        // Arduino random(max) returns [0, max-1]; 2147483647 = INT_MAX gives a
-        // non-negative 31-bit range (sign bit always 0).
-        rawCpp(`return random(2147483647);`);
-        return 0;
-    }
+    static int() { return 0; }
 }