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

package/dist/api/shared/hal-op-ir.js

@@ -6,7 +6,7 @@
 // framework-specific C++.
 //
 // The transpiler produces these nodes when resolving HAL method calls.
-// Framework strategies (ArduinoStrategy, NativeAVRStrategy, etc.) implement
+// Framework strategies (ZephyrStrategy, NativeStrategy, etc.) implement
 // resolveHALOperation() to map each operation to concrete C++ code.
 //
 // Pin-carrying operations include an optional `port` field for the MCU
@@ -27,116 +27,82 @@
  */
 export const HAL_OPERATION_KINDS = [
     // GPIO
-    'gpio.write', 'gpio.read', 'gpio.toggle', 'gpio.set_mode',
+    'gpio.write', 'gpio.read', 'gpio.toggle',
     // PWM
-    'pwm.write', 'pwm.get_frequency', 'pwm.get_resolution',
     // RMT
-    'rmt.tx_init', 'rmt.tx_write_bytes', 'rmt.tx_write_symbols',
-    'rmt.tx_wait_done', 'rmt.tx_deinit',
-    'rmt.rx_init', 'rmt.rx_on_received', 'rmt.rx_start',
-    'rmt.rx_stop', 'rmt.rx_read', 'rmt.rx_deinit',
     // ADC
-    'adc.read', 'adc.get_resolution', 'adc.set_reference',
-    'adc.get_reference', 'adc.read_voltage',
     // DAC
-    'dac.write',
     // Interrupts
-    'interrupt.attach', 'interrupt.detach',
-    // Tone
-    'tone.play', 'tone.stop',
-    // Timing
-    'timing.delay', 'timing.delay_microseconds', 'timing.millis',
-    'timing.micros', 'timing.free_heap', 'timing.set_interval',
-    'timing.set_timeout', 'timing.clear_interval', 'timing.clear_timeout',
-    // Power
-    'power.deep_sleep', 'power.light_sleep', 'power.set_cpu_frequency', 'power.deep_sleep_pin',
-    // I2C
-    'i2c.begin', 'i2c.end', 'i2c.set_clock', 'i2c.begin_transmission',
-    'i2c.write', 'i2c.write_bytes', 'i2c.write_buffer', 'i2c.read_buffer',
-    'i2c.end_transmission', 'i2c.request_from', 'i2c.available', 'i2c.read',
-    'i2c.recover',
-    // SPI
-    'spi.begin', 'spi.end', 'spi.transfer', 'spi.begin_transaction',
-    'spi.end_transaction', 'spi.set_mode', 'spi.set_bit_order',
-    'spi.cs_low', 'spi.cs_high', 'spi.read_buffer',
-    // UART
-    'uart.begin', 'uart.end', 'uart.print', 'uart.println', 'uart.printf',
-    'uart.write', 'uart.read', 'uart.peek', 'uart.available', 'uart.flush',
+    'interrupt.attach_flags', 'interrupt.detach',
+    // Timing (legacy Arduino-named ops removed; timers keep JS names)
+    'timing.sleep', 'timing.now', 'timing.now_us', 'timing.busy_wait_us',
+    // Thin Zephyr-shaped peripherals
+    'gpio.configure', 'gpio.read_cfg', 'gpio.shift_out', 'gpio.shift_in',
+    'pwm.set_pulse', 'pwm.set_duty', 'pwm.set_period',
+    'adc.read_raw', 'adc.read_mv',
+    'dac.write_value',
+    'wdt.setup', 'wdt.feed',
+    'counter.on_alarm', 'counter.start', 'counter.stop',
+    // Tier-2 thin buses
+    'i2c.reg_write', 'i2c.reg_read', 'i2c.reg_update', 'i2c.dev_write',
+    'spi.transceive', 'spi.dev_write', 'spi.reg_read',
+    'uart.poll_write', 'uart.rx_arm', 'uart.rx_available', 'uart.rx_peek', 'uart.rx_read',
+    'thread.start', 'thread.join',
     // Pulse
-    'pulse.in', 'pulse.in_long',
     // Shift
-    'shift.out', 'shift.in',
     // Board
     'board.resolve',
     // Watchdog timer
-    'wdt.enable', 'wdt.reset', 'wdt.disable',
+    'wdt.disable',
     // Snprintf
     'snprintf.emit',
     // WiFi
-    'wifi.connect', 'wifi.connect_start', 'wifi.disconnect', 'wifi.status',
+    'wifi.join', 'wifi.connect_start', 'wifi.disconnect',
     'wifi.is_connected', 'wifi.local_ip', 'wifi.rssi', 'wifi.mac',
-    'wifi.set_hostname', 'wifi.set_static_ip', 'wifi.set_auto_reconnect',
-    'wifi.set_power_save', 'wifi.set_tx_power', 'wifi.on_event',
-    'wifi.ap_start', 'wifi.ap_stop', 'wifi.ap_client_count', 'wifi.ap_ip',
-    'wifi.ap_set_channel', 'wifi.ap_set_hidden', 'wifi.ap_set_max_clients',
+    'wifi.on_event',
+    'wifi.ap_start', 'wifi.ap_stop',
     'wifi.scan', 'wifi.scan_start', 'wifi.scan_done', 'wifi.scan_count',
     'wifi.scan_ssid', 'wifi.scan_rssi', 'wifi.scan_encryption',
-    'wifi.scan_channel', 'wifi.save_credentials', 'wifi.connect_saved',
-    'wifi.clear_credentials', 'wifi.wait_connected', 'wifi.wait_disconnected',
+    'wifi.scan_channel',
     // HTTP
-    'http.begin', 'http.reset', 'http.set_header', 'http.set_timeout',
+    'http.begin', 'http.set_header', 'http.set_timeout',
     'http.set_max_body', 'http.set_body', 'http.set_insecure',
     'http.set_ca_cert', 'http.send', 'http.send_start', 'http.done',
     'http.status', 'http.ok', 'http.body', 'http.content_length',
     'http.response_header',
-    // Worker offload (generalized request-in / poll-out over a worker pool)
-    'worker.submit', 'worker.done',
     // BLE (NimBLE GATT peripheral)
     'ble.server_begin', 'ble.advertise_start', 'ble.advertise_stop',
     'ble.add_service', 'ble.add_char',
     'ble.on_read', 'ble.on_write', 'ble.on_connect', 'ble.on_disconnect', 'ble.notify',
-    'ble.is_connected', 'ble.client_count', 'ble.set_name',
-    'ble.until_connected', 'ble.until_connected_start',
-    'ble.set_tx_power', 'ble.status',
+    'ble.is_connected', 'ble.client_count',
     // Preferences (NVS)
-    'preferences.begin', 'preferences.end', 'preferences.clear', 'preferences.remove',
+    'preferences.clear', 'preferences.remove',
     'preferences.put_int', 'preferences.get_int',
-    'preferences.put_uint', 'preferences.get_uint',
     'preferences.put_bool', 'preferences.get_bool',
     'preferences.put_float', 'preferences.get_float',
     'preferences.put_string', 'preferences.get_string',
     // Random
     'random.int', 'random.range', 'random.seed',
     // FS (filesystem)
-    'fs.begin', 'fs.read_text', 'fs.write_text', 'fs.exists', 'fs.remove',
-    // mDNS
-    'mdns.start', 'mdns.set_hostname', 'mdns.add_service', 'mdns.announce', 'mdns.stop',
+    'fs.read_text', 'fs.write_text', 'fs.exists', 'fs.remove',
     // MQTT
     'mqtt.connect', 'mqtt.on_message', 'mqtt.subscribe', 'mqtt.publish', 'mqtt.connected', 'mqtt.disconnect',
-    // OTA
-    'ota.from_url', 'ota.begin', 'ota.write', 'ota.apply',
-    // Temperature
-    'temp.read',
+    'sensor.fetch',
+    'sensor.get',
     // Hardware timer
-    'hwtimer.set_frequency', 'hwtimer.on_overflow', 'hwtimer.start', 'hwtimer.stop',
-    // Capacitive touch pins
-    'capacitive.read',
     // I2S / digital audio (unimplemented — declared unsupported by all frameworks)
     'i2s.init', 'i2s.write', 'i2s.read',
     // TWAI / CAN (unimplemented)
     'twai.init', 'twai.send', 'twai.receive',
-    // USB OTG / USB-Serial-JTAG (unimplemented)
-    'usb.init', 'usb.write', 'usb.read',
+    // USB CDC-ACM serial port
+    'usb.begin', 'usb.wait_ready', 'usb.end', 'usb.print', 'usb.println',
+    'usb.read', 'usb.available', 'usb.connected',
     // Ethernet MAC (unimplemented)
     'eth.init', 'eth.start', 'eth.is_linked',
     // ESPNOW (unimplemented)
-    'espnow.init', 'espnow.add_peer', 'espnow.send', 'espnow.on_receive',
     // Hardware crypto (unimplemented)
-    'crypto.aes_encrypt', 'crypto.sha256', 'crypto.hmac',
     // Pulse counter (unimplemented)
-    'pcnt.init', 'pcnt.count', 'pcnt.clear',
     // Motor control PWM (unimplemented)
-    'mcpwm.init', 'mcpwm.set_duty', 'mcpwm.start',
     // Raw passthrough
     'raw',
 ];

package/dist/api/shared/index.d.ts

@@ -12,7 +12,6 @@ export type { DisplayProfile, DisplayConfig, DisplaySize, TouchProfile, TouchLib
 export { effectiveDisplaySize, normalizeDisplayRotation, resolveDisplayProfile, resolveScrollConfig } from './display-profile.js';
 export { GLCDFONT_BYTES, renderGlcdfontArray } from './glcdfont.js';
 export type { DisplayAdapterCode, DisplayAdapterGenerator } from './display-adapter.js';
-export { resolveNativeDisplayOp } from './native-display-op-resolver.js';
 export type { DisplayCapabilities, DisplayFeatureFlags, NativeFormat, RefreshModel, PartialRefreshScope, } from './display-capabilities.js';
 export { defaultTftCapabilities, deriveCapabilities } from './display-capabilities.js';
 export type { BoardConstants } from './board-resolver.js';
@@ -33,9 +32,6 @@ export { generatePromiseRuntime } from './promise-runtime.js';
 export { generateStaticAsyncRuntime } from './async-runtime-static.js';
 export { generateCoopScheduler, buildCoopSchedInjection } from './coop-scheduler.js';
 export type { CoopWorkUnit, CoopSchedOptions } from './coop-scheduler.js';
-export { generateWorkerRuntime, lowerWorkerOp } from './worker-runtime.js';
-export type { WorkerRuntimeOptions, WorkerBacking } from './worker-runtime.js';
-export { buildWorkerRuntimePolyfill } from './worker-runtime-polyfill.js';
 export { FrameworkManifestSchema, defineFrameworkManifest, HAL_CATEGORIES, POLYFILL_BACKED_OPS, } from './framework-manifest.js';
 export type { FrameworkManifest, HalCategory, } from './framework-manifest.js';
 export { KNOWN_FRAMEWORK_PACKAGES, loadFrameworkManifest, } from './framework-manifest-registry.js';

package/dist/api/shared/index.js

@@ -10,10 +10,6 @@ export { effectiveDisplaySize, normalizeDisplayRotation, resolveDisplayProfile,
 // Shared 5x7 glcdfont table (Adafruit public-domain source). Consumed by
 // the SDL preview adapter and the native CuttlefishGFX runtime-header slice.
 export { GLCDFONT_BYTES, renderGlcdfontArray } from './glcdfont.js';
-// Native display-op resolver — lowers display.* HAL ops into calls against
-// the adapter surface (display_init / display_targetFillRect / etc.). Used
-// by NativeAVRStrategy and Esp32Strategy's resolveDisplayOp overrides.
-export { resolveNativeDisplayOp } from './native-display-op-resolver.js';
 export { defaultTftCapabilities, deriveCapabilities } from './display-capabilities.js';
 export { getStdLibSupport, DEFAULT_STDLIB_SUPPORT } from './polyfill-types.js';
 export { parseCompileErrors, collectCppFiles } from './toolchain-types.js';
@@ -34,9 +30,6 @@ export { generatePromiseRuntime } from './promise-runtime.js';
 export { generateStaticAsyncRuntime } from './async-runtime-static.js';
 // No-STL cooperative scheduler (priority + time-budget) — Zephyr-friendly
 export { generateCoopScheduler, buildCoopSchedInjection } from './coop-scheduler.js';
-// Worker offload runtime (generalized request-in / poll-out)
-export { generateWorkerRuntime, lowerWorkerOp } from './worker-runtime.js';
-export { buildWorkerRuntimePolyfill } from './worker-runtime-polyfill.js';
 // Framework manifest schema + helper
 export { FrameworkManifestSchema, defineFrameworkManifest, HAL_CATEGORIES, POLYFILL_BACKED_OPS, } from './framework-manifest.js';
 // Framework manifest discovery
@@ -44,3 +37,4 @@ export { KNOWN_FRAMEWORK_PACKAGES, loadFrameworkManifest, } from './framework-ma
 // Framework manifest validator
 export { validateFrameworkManifest } from './validate-framework-manifest.js';
 export { SPDX_TABLE, RISK_RANK, LICENSE_FILENAMES, normalize, identifySpdx, classifyRisk, readLicenseFileIn, readLicenseFile, readSourceHeaders, resolveLibraryLicense, riskBracket, statusMark, countByRisk, } from './spdx-licenses.js';
+// Generated Zephyr board catalog (shared with the create/scaffold flow).

package/dist/api/shared/ir-core.d.ts

@@ -160,10 +160,16 @@ export type ExpressionIR = {
 /**
  * HAL operation used as an expression (returns a value).
  * The framework strategy resolves the operation to a C++ expression string.
+ * `prefixOps` carries a method body's PRECEDING side-effect ops: expression
+ * positions historically kept only the last op, silently dropping e.g. a
+ * bus transaction prefix (i2c begin/write/end before a read) or a pin
+ * configure before a read. The renderer emits them as a GCC
+ * statement-expression `({ op; ...; value; })` so every op runs.
  */
  | {
     kind: "hal-expr";
     operation: HALOpIR;
+    prefixOps?: HALOpIR[];
 };
 export interface CallExpressionIR {
     kind: "call";

package/dist/api/shared/ir-declarations.d.ts

@@ -84,6 +84,10 @@ export interface ClassMethodIR {
     typeParameters?: string[];
     /** True when this is a generator method. */
     isGenerator?: boolean;
+    /** True when declared `async` — the body lowers to an owner-bound
+     *  cooperative state-machine task (see async-state-machine.ts), not an
+     *  ordinary method. */
+    isAsync?: boolean;
     /** Decorators applied to this method (e.g. ["asilD"]). */
     decorators?: string[];
 }

package/dist/api/shared/ir.d.ts

@@ -2,7 +2,7 @@ import type { BoardConstants } from './board-resolver.js';
 import type { Diagnostic } from './types.js';
 import type { RegisteredCallback } from '../../ir/build-ir-state.js';
 export type { CppType, ParameterIR, ExpressionIR, CallExpressionIR, SuperCallIR, VariableDeclarationIR, AssignmentIR, UpdateIR, ReturnIR, WhileIR, IfIR, ForIR, ForOfIR, ForInIR, BreakIR, ContinueIR, DoWhileIR, SwitchIR, CaseIR, TryIR, ThrowIR, LabeledIR, BlockIR, HALOpStatementIR, StatementIR, } from './ir-core.js';
-export type { HALOpIR, HALOperationKind, GpioWriteOp, GpioReadOp, GpioToggleOp, GpioSetModeOp, PwmWriteOp, PwmGetFrequencyOp, PwmGetResolutionOp, AdcReadOp, AdcGetResolutionOp, AdcSetReferenceOp, AdcGetReferenceOp, AdcReadVoltageOp, DacWriteOp, InterruptAttachOp, InterruptDetachOp, TonePlayOp, ToneStopOp, TimingDelayOp, TimingDelayMicrosecondsOp, TimingMillisOp, TimingMicrosOp, TimingFreeHeapOp, TimingSetIntervalOp, TimingSetTimeoutOp, TimingClearIntervalOp, TimingClearTimeoutOp, I2cBeginOp, I2cEndOp, I2cSetClockOp, I2cBeginTransmissionOp, I2cWriteOp, I2cEndTransmissionOp, I2cRequestFromOp, I2cAvailableOp, I2cReadOp, I2cRecoverOp, SpiBeginOp, SpiEndOp, SpiTransferOp, SpibeginTransactionOp, SpiEndTransactionOp, SpiSetModeOp, SpiSetBitOrderOp, SpiCsLowOp, SpiCsHighOp, UartBeginOp, UartEndOp, UartPrintOp, UartPrintlnOp, UartPrintfOp, UartWriteOp, UartReadOp, UartPeekOp, UartAvailableOp, UartFlushOp, PulseInOp, PulseInLongOp, ShiftOutOp, ShiftInOp, BoardResolveOp, SnprintfEmitOp, RawCppOp, } from './hal-op-ir.js';
+export type { HALOpIR, HALOperationKind, GpioWriteOp, GpioReadOp, GpioToggleOp, InterruptDetachOp, I2cReadOp, I2cRecoverOp, BoardResolveOp, SnprintfEmitOp, RawCppOp, } from './hal-op-ir.js';
 export type { FunctionIR, StructDefIR, EnumIR, ClassFieldIR, ClassConstructorIR, ClassMethodIR, ClassGetterIR, ClassSetterIR, ClassIR, InterfaceIR, TypeAliasIR, NamespaceIR, RegisterBitFieldIR, RegisterClassIR, } from './ir-declarations.js';
 export interface ImportIR {
     moduleSpecifier: string;
@@ -27,8 +27,6 @@ export interface PeripheralUsageIR {
     pwm: boolean;
     /** External interrupts are used (attachInterrupt on D2, D3) */
     externalInterrupts: boolean;
-    /** Timer0-based timing is used (millis, micros) */
-    timer0: boolean;
     /** I2C bus is used */
     i2c: boolean;
     /** SPI bus is used */

package/dist/api/shared/platform-strategy.d.ts

@@ -49,8 +49,6 @@ export interface PlatformProfileStrategy {
     mathHeader(): string;
     /** cstring header name ("<cstring>" on hosted, "<string.h>" on embedded/AVR). */
     cstringHeader(): string;
-    /** Whether the vector operator<< overload should be emitted. */
-    needsVectorOverload(): boolean;
     /** Whether a large enum needs an explicit underlying type. */
     needsLargeEnumUnderlying(): boolean;
     /** Whether to skip a type alias for this platform (e.g. std::string where unsupported). */
@@ -140,7 +138,7 @@ export interface PlatformExpressionStrategy {
     wrapStringConcat(leftRendered: string, rightRendered: string, leftIsString: boolean): string | undefined;
     /** Wrap an expression in the platform's string object type (e.g. String(...) on Arduino). */
     wrapStringObject(expr: string): string;
-    /** Platform-specific expression for current time in milliseconds (e.g. "millis()" on Arduino, "std::chrono" on hosted). */
+    /** Platform-specific expression for the monotonic runtime clock in milliseconds (e.g. "__tc_now_ms()" on Zephyr/native). */
     currentTimeMillis(): string;
     /**
      * Whether string concat / template interpolation should use snprintf()
@@ -184,18 +182,6 @@ export interface PlatformStatementStrategy {
      * Embedded targets without exception support may emit an infinite loop or halt.
      */
     renderThrow(valueExpr: string): string;
-    /**
-     * Transform console.log/error/warn calls to platform output.
-     */
-    isConsoleCall(callee: string): boolean;
-    /** Transform console.log/error/warn calls based on target platform. */
-    transformConsoleCall(method: string, renderedArgs: string, forHeader: boolean): string;
-    /**
-     * Transform console expressions that return values (e.g., console.readLine, console.readCharacter).
-     * Returns the C++ expression that evaluates to the result.
-     * Return undefined to fall back to default rendering.
-     */
-    transformConsoleExpression?(method: string, renderedArgs: string): string | undefined;
     /**
      * Fallback value for an object initializer field on this platform.
      * Some targets use "0" for nested objects; hosted targets pass through.
@@ -272,7 +258,7 @@ export interface PlatformSafetyStrategy {
     isHeapAllocationUnsafe?(architecture: string): boolean;
     /**
      * Whether C++ exceptions are disabled on the given architecture.
-     * Frameworks return true for targets compiled with -fno-exceptions (e.g. AVR-GCC).
+     * Frameworks return true for targets compiled with -fno-exceptions (e.g. Zephyr).
      */
     isExceptionSupportDisabled?(architecture: string): boolean;
     /**
@@ -384,6 +370,18 @@ export interface PlatformAsyncStrategy {
      *   - What queue capacity to use
      */
     getAsyncRuntimeConfig(): AsyncRuntimeConfig;
+    /**
+     * Generate the project-local board module for a board target — the
+     * framework owns its board data (the Zephyr framework joins its generated
+     * data pack with its curated soc descriptors). Returns the contents of
+     * `.cuttlefish/board.ts` and `.cuttlefish/board.json`; the caller writes
+     * them. Undefined = the framework has no board generation (the config's
+     * board field then requires a different resolution path).
+     */
+    generateBoardModule?(target: string): {
+        boardTs: string;
+        boardJson: string;
+    } | undefined;
     /**
      * Lines to inject into the loop/run function body to drive async tasks.
      */
@@ -405,27 +403,6 @@ export interface PlatformAsyncStrategy {
         preIteration: string;
         postIteration: string;
     } | null;
-    /**
-     * C++ statements that spawn the worker for slot `handleId`, running
-     * `fn(arg)`. Emitted as the body of __tc_worker_submit. Return undefined
-     * to declare worker offload unsupported on this framework.
-     *
-     * The shared runtime has already recorded `waiter`/set `done=false` before
-     * this runs; the hook need only spawn. `fn` and `arg` are C++ expressions
-     * (a function pointer and a void*).
-     */
-    workerSpawnLines?(handleId: number, fn: string, arg: string): string[] | undefined;
-    /**
-     * C++ expression the worker calls AFTER completing its work and writing its
-     * outputs, to signal completion to the waiter. Emitted inside the worker
-     * trampoline. Must issue a memory barrier. Return undefined if unsupported.
-     */
-    workerSignalDoneExpr?(handleId: number): string | undefined;
-    /**
-     * C++ boolean expression polled by __tc_worker_done to test completion.
-     * Must observe the signal's memory barrier. Return undefined if unsupported.
-     */
-    workerIsDoneExpr?(handleId: number): string | undefined;
 }
 /**
  * Strategy for resolving semantic HAL operations to framework-specific C++.

package/dist/api/shared/polyfill-helper-registry.js

@@ -27,11 +27,6 @@ export const POLYFILL_HELPER_MAP = {
     '.includes(': ['__tc_includes'],
     '.indexOf(': ['__tc_indexOf'],
     '.slice(': ['__tc_slice2', '__tc_slice1'],
-    // Timer methods
-    'setTimeout(': ['__tc_setTimeout'],
-    'setInterval(': ['__tc_setInterval'],
-    'clearTimeout(': ['__tc_clearTimeout'],
-    'clearInterval(': ['__tc_clearInterval'],
     // Math methods
     'Math.random(': ['__tc_random'],
     // Array methods

package/dist/api/shared/polyfill-types.js

@@ -13,15 +13,6 @@ export const DEFAULT_STDLIB_SUPPORT = {
     recommendedStringImpl: "std_string",
 };
 const STDLIB_SUPPORT = {
-    avr: {
-        hasVector: false,
-        hasString: false,
-        hasIostream: false,
-        hasExceptions: false,
-        hasRTTI: false,
-        recommendedArrayImpl: "static_array",
-        recommendedStringImpl: "static_string",
-    },
     esp32: {
         hasVector: true,
         hasString: true,
@@ -31,15 +22,6 @@ const STDLIB_SUPPORT = {
         recommendedArrayImpl: "std_vector",
         recommendedStringImpl: "std_string",
     },
-    esp8266: {
-        hasVector: true,
-        hasString: true,
-        hasIostream: true,
-        hasExceptions: true,
-        hasRTTI: true,
-        recommendedArrayImpl: "std_vector",
-        recommendedStringImpl: "std_string",
-    },
     rp2040: {
         hasVector: true,
         hasString: true,
@@ -58,15 +40,6 @@ const STDLIB_SUPPORT = {
         recommendedArrayImpl: "std_vector",
         recommendedStringImpl: "std_string",
     },
-    megaavr: {
-        hasVector: false,
-        hasString: false,
-        hasIostream: false,
-        hasExceptions: false,
-        hasRTTI: false,
-        recommendedArrayImpl: "static_array",
-        recommendedStringImpl: "static_string",
-    },
     default: DEFAULT_STDLIB_SUPPORT,
 };
 export function getStdLibSupport(architecture) {

package/dist/api/shared/promise-runtime.js

@@ -21,10 +21,10 @@
  *   (used by Arduino targets).
  */
 export function generatePromiseRuntime(queueCapacity, includeWaitForPinEdge = false, strategy) {
-    // The current-time expression (millis() on Wiring-derived frameworks,
-    // std::chrono on generic). Falling back to millis() preserves the historical
+    // The current-time expression (__tc_now_ms() — the runtime clock contract
+    // every strategy provides). Falling back to the contract symbol keeps the
     // behavior when no strategy is supplied.
-    const now = strategy?.currentTimeMillis?.() ?? "millis()";
+    const now = strategy?.currentTimeMillis?.() ?? "__tc_now_ms()";
     const waitForPinEdge = includeWaitForPinEdge ? `
   // HAL-level wait for pin edge — polling-based implementation.
   // Detects an actual transition (idle→target), not just the current level.

package/dist/api/shared/spdx-licenses.d.ts

@@ -2,8 +2,8 @@ export type CopyleftRisk = "permissive" | "weak-copyleft" | "strong-copyleft" |
 /**
  * Where a license declaration was found.
  *
- * `"library.properties"` is the Arduino library-manifest form (kept verbatim
- * for Arduino parity); `"manifest"` is the framework-neutral form for any
+ * `"library.properties"` is the Arduino-ecosystem library-manifest form (kept
+ * verbatim for packages that carry one); `"manifest"` is the framework-neutral form for any
  * other manifest reader a framework supplies (e.g. a west module.yml).
  */
 export type LicenseSource = "library.properties" | "manifest" | "license-file" | "source-header" | "none";
@@ -22,9 +22,10 @@ export interface LibraryLicenseEntry {
     source: LicenseSource;
 }
 /**
- * Neutral dependency shape every framework adapts its enumeration to. Arduino
- * maps `{ name, version, install_dir }` → `{ name, version, installDir }`;
- * Zephyr maps a west-listed project (`{ name, abspath }`) the same way.
+ * Neutral dependency shape every framework adapts its enumeration to.
+ * Package-manager listings map `{ name, version, install_dir }` →
+ * `{ name, version, installDir }`; Zephyr maps a west-listed project
+ * (`{ name, abspath }`) the same way.
  */
 export interface DiscoveredDependency {
     name: string;
@@ -113,15 +114,16 @@ export interface ResolveLicenseOptions {
     subdirs?: readonly string[];
     /**
      * Read a manifest file's text for a license field. Given the install dir and
-     * the readFile seam, return the raw license value (or undefined). Arduino
-     * wires this to read `library.properties` `license=`. Omit to skip the
-     * manifest step (e.g. a framework whose manifest carries no license field).
+     * the readFile seam, return the raw license value (or undefined). A
+     * library.properties-style adapter wires this to read its `license=` field.
+     * Omit to skip the manifest step (e.g. a framework whose manifest carries
+     * no license field).
      */
     readManifestLicense?: (installDir: string, readFile: ReadFile) => string | undefined;
     /**
      * LicenseSource label attached when the license is found via
-     * `readManifestLicense`. Defaults to `"manifest"`; Arduino passes
-     * `"library.properties"` for parity with its existing output.
+     * `readManifestLicense`. Defaults to `"manifest"`; a library.properties
+     * adapter passes `"library.properties"` for parity with its existing output.
      */
     manifestSourceLabel?: LicenseSource;
 }

package/dist/api/shared/spdx-licenses.js

@@ -6,7 +6,7 @@
 // classification) and the file-based license resolver (LICENSE file + source
 // header comments + an injected manifest reader) live here so every framework
 // package can reuse them. Each framework supplies only its own dependency
-// enumeration (arduino-cli lib list, west list, …) and a manifest reader, then
+// enumeration (package-manager listings, west list, …) and a manifest reader, then
 // calls resolveLibraryLicense.
 //
 // Nothing here imports a framework package or shells out to a toolchain: all

package/dist/api/shared/toolchain-types.d.ts

@@ -72,7 +72,7 @@ export interface UploadResult {
 /**
  * Parse compile errors from output (GCC and Clang formats)
  */
-export declare function parseCompileErrors(output: string, sketchDir?: string): CompileError[];
+export declare function parseCompileErrors(output: string, projectDir?: string): CompileError[];
 /**
  * Collect all .cpp files in a directory (non-recursive).
  */

package/dist/api/shared/toolchain-types.js

@@ -17,7 +17,7 @@ const CLANG_ERROR = /^(.*?):(\d+):(\d+):\s*(error|warning|note):\s*(.*)$/i;
 /**
  * Parse compile errors from output (GCC and Clang formats)
  */
-export function parseCompileErrors(output, sketchDir) {
+export function parseCompileErrors(output, projectDir) {
     const errors = [];
     for (const rawLine of output.split(/\r?\n/)) {
         const line = rawLine.trim();
@@ -34,9 +34,9 @@ export function parseCompileErrors(output, sketchDir) {
         const severity = severityRaw.includes("error") ? "error" : severityRaw === "warning" ? "warning" : "note";
         let filePath = match[1];
         // Normalize file paths
-        if (sketchDir) {
+        if (projectDir) {
             if (!path.isAbsolute(filePath)) {
-                const resolved = path.resolve(sketchDir, filePath);
+                const resolved = path.resolve(projectDir, filePath);
                 if (fs.existsSync(resolved)) {
                     filePath = resolved;
                 }

package/dist/api/shared/types.d.ts

@@ -47,9 +47,6 @@ export type TargetProfile = "generic" | (string & {});
  * Frameworks add their own context via the index signature.
  */
 export interface PlatformContext {
-    console?: {
-        baudRate?: number;
-    };
     /** Target architecture identifier (e.g., 'avr', 'esp32'). Populated from board config. */
     architecture?: string;
     /** Framework-specific data. Each framework reads its own key. */

package/dist/api/shared/validate-framework-manifest.js

@@ -29,18 +29,13 @@ class Accumulator {
 const CATEGORY_PREFIXES = {
     gpio: ['gpio.'],
     pwm: ['pwm.'],
-    rmt: ['rmt.'],
     adc: ['adc.'],
     dac: ['dac.'],
     interrupts: ['interrupt.'],
-    tone: ['tone.'],
     timing: ['timing.'],
-    power: ['power.'],
     i2c: ['i2c.'],
     spi: ['spi.'],
     uart: ['uart.'],
-    pulse: ['pulse.'],
-    shift: ['shift.'],
     board: ['board.'],
     wdt: ['wdt.'],
     wifi: ['wifi.'],
@@ -50,12 +45,7 @@ const CATEGORY_PREFIXES = {
     ble: ['ble.'],
     random: ['random.'],
     fs: ['fs.'],
-    mdns: ['mdns.'],
     mqtt: ['mqtt.'],
-    ota: ['ota.'],
-    temp: ['temp.'],
-    hwtimer: ['hwtimer.'],
-    capacitive: ['capacitive.'],
     // Unimplemented-but-recognized categories: each framework may declare these
     // as unsupported in its manifest so the coverage matrix records them as a
     // roadmap. The validator probes the resolver and confirms it does NOT lower
@@ -64,14 +54,8 @@ const CATEGORY_PREFIXES = {
     twai: ['twai.'],
     usb: ['usb.'],
     eth: ['eth.'],
-    espnow: ['espnow.'],
-    crypto: ['crypto.'],
-    pcnt: ['pcnt.'],
-    mcpwm: ['mcpwm.'],
-    // Worker offload + snprintf raw-escape: recognized categories. Frameworks
-    // that lower worker.* declare it supported; snprintf.emit is a raw escape
-    // hatch (declared unsupported by frameworks that don't special-case it).
-    worker: ['worker.'],
+    // snprintf raw-escape: recognized category; declared unsupported by
+    // frameworks that don't special-case it.
     snprintf: ['snprintf.'],
 };
 function opKindsForCategory(category) {
@@ -90,8 +74,12 @@ function opKindsForCategory(category) {
 const OP_PROBE_PAYLOADS = {
     // i2c.write_bytes requires bus + bytes (resolver iterates bytes).
     'i2c.write_bytes': { bus: 'i2c0', address: 0x50, bytes: [0x00, 0x01] },
-    // uart.printf requires format + args (resolver joins args).
-    'uart.printf': { port: 'Serial', format: '%d', args: ['x'] },
+    // usb.* require port (+ value/format where the resolver renders them).
+    'usb.begin': { port: 'USB0' },
+    'usb.print': { port: 'USB0', value: '"x"' },
+    'usb.println': { port: 'USB0', value: '"x"' },
+    'usb.write': { port: 'USB0', data: '"x"' },
+    'usb.printf': { port: 'USB0', format: '%d', args: ['x'] },
     // adc.read / adc.read_voltage require pin.
     'adc.read': { pin: 0 },
     'adc.read_voltage': { pin: 0 },
@@ -112,10 +100,6 @@ const OP_PROBE_PAYLOADS = {
     'fs.remove': { path: '/sdcard/x.txt' },
     // random.range requires min/max.
     'random.range': { min: 0, max: 10 },
-    // mdns.add_service requires instance/proto/port.
-    'mdns.start': { hostname: 'h' },
-    'mdns.set_hostname': { name: 'h' },
-    'mdns.add_service': { instance: 'i', proto: '_tcp', port: 80 },
     // mqtt.connect requires brokerUri/clientId; mqtt.publish requires topic/data.
     'mqtt.connect': { brokerUri: 'mqtt://b', clientId: 'c' },
     'mqtt.on_message': { handler: 'cb' },
@@ -125,16 +109,12 @@ const OP_PROBE_PAYLOADS = {
     // Without a payload the probe sends event=undefined and a 'supported'
     // declaration would false-fail as "resolver returned undefined".
     'wifi.on_event': { event: 'connect', handler: 'cb' },
-    // ota.from_url requires url; ota.write requires chunk.
-    'ota.from_url': { url: 'https://x' },
-    'ota.write': { chunk: 'buf' },
-    // hwtimer.* require an instance (and hz/handler).
-    'hwtimer.set_frequency': { instance: 0, hz: 1000 },
-    'hwtimer.on_overflow': { instance: 0, handler: 'cb' },
-    'hwtimer.start': { instance: 0 },
-    'hwtimer.stop': { instance: 0 },
     // capacitive.read requires pin.
-    'capacitive.read': { pin: 4 },
+    // sensor.* resolve their part against the generated catalog (hal's
+    // sensor-catalog.generated.ts) — sensirion_sht3xd is the stable probe part
+    // (in-tree since 2.x; the catalog regeneration checklist covers its removal).
+    'sensor.fetch': { part: 'sensirion_sht3xd', bus: 'I2C0', address: 0x44 },
+    'sensor.get': { part: 'sensirion_sht3xd', bus: 'I2C0', address: 0x44, chan: 'AMBIENT_TEMP' },
 };
 // Builds a HALOpIR probe. Uses OP_PROBE_PAYLOADS when available so resolvers
 // that destructure required fields don't throw on the probe itself.