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

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

@@ -20,7 +20,11 @@
  * @param includeWaitForPinEdge Whether to include the `waitForPinEdge` stub
  *   (used by Arduino targets).
  */
-export function generatePromiseRuntime(queueCapacity, includeWaitForPinEdge = false) {
+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
+    // behavior when no strategy is supplied.
+    const now = strategy?.currentTimeMillis?.() ?? "millis()";
     const waitForPinEdge = includeWaitForPinEdge ? `
   // HAL-level wait for pin edge — polling-based implementation.
   // Detects an actual transition (idle→target), not just the current level.
@@ -31,18 +35,18 @@ export function generatePromiseRuntime(queueCapacity, includeWaitForPinEdge = fa
     return Promise<void>([pin, mode, timeout](std::function<void(const void*)> resolve, std::function<void(const std::string&)> reject) {
       int targetState = (mode == RISING) ? HIGH : LOW;
       int idleState = (mode == RISING) ? LOW : HIGH;
-      unsigned long start = millis();
+      unsigned long start = ${now};
       // Phase 2 poller: waits for the pin to reach the target state (the edge).
       auto pollTarget = [pin, targetState, timeout, start, resolve]() {
-        if (digitalRead(pin) == targetState) {
+        if (${strategy?.readDigitalPin?.("pin") ?? "digitalRead(pin)"} == targetState) {
           resolve(nullptr);
-        } else if (timeout >= 0 && (millis() - start >= (unsigned long)timeout)) {
+        } else if (timeout >= 0 && (${now} - start >= static_cast<unsigned long>(timeout))) {
           resolve(nullptr);
         } else {
           enqueueMicrotask([pin, targetState, timeout, start, resolve]() {
-            if (digitalRead(pin) == targetState) {
+            if (${strategy?.readDigitalPin?.("pin") ?? "digitalRead(pin)"} == targetState) {
               resolve(nullptr);
-            } else if (timeout >= 0 && (millis() - start >= (unsigned long)timeout)) {
+            } else if (timeout >= 0 && (${now} - start >= static_cast<unsigned long>(timeout))) {
               resolve(nullptr);
             } else {
               enqueueMicrotask([pin, targetState, timeout, start, resolve]() {});
@@ -52,9 +56,9 @@ export function generatePromiseRuntime(queueCapacity, includeWaitForPinEdge = fa
       };
       // Phase 1: wait for idle state before watching for the edge.
       enqueueMicrotask([pin, idleState, timeout, start, resolve, pollTarget]() {
-        if (digitalRead(pin) == idleState) {
+        if (${strategy?.readDigitalPin?.("pin") ?? "digitalRead(pin)"} == idleState) {
           pollTarget();
-        } else if (timeout >= 0 && (millis() - start >= (unsigned long)timeout)) {
+        } else if (timeout >= 0 && (${now} - start >= static_cast<unsigned long>(timeout))) {
           resolve(nullptr);
         } else {
           enqueueMicrotask([pin, idleState, timeout, start, resolve, pollTarget]() {});
@@ -181,17 +185,95 @@ namespace typecad_async {
     std::vector<std::function<void(const std::string&)>> _onRejected;
   };
 
+  // Promise<void> — T=_value/const T& is illegal for void. Helpers below pass
+  // resolve as std::function<void(const void*)> (pointer, not reference).
+  template <>
+  class Promise<void> {
+  public:
+    enum class State { Pending, Fulfilled, Rejected };
+
+    using ResolveFn = std::function<void(const void*)>;
+    using RejectFn = std::function<void(const std::string&)>;
+    using Executor = std::function<void(ResolveFn, RejectFn)>;
+
+    Promise() : _state(State::Pending), _error{} {}
+
+    explicit Promise(Executor executor)
+      : _state(State::Pending), _error{} {
+      executor(
+        [this](const void*) { this->resolve(nullptr); },
+        [this](const std::string& error) { this->reject(error); }
+      );
+    }
+
+    static Promise<void> resolveValue() {
+      Promise<void> promise;
+      promise.resolve(nullptr);
+      return promise;
+    }
+
+    static Promise<void> rejectValue(const std::string& error) {
+      Promise<void> promise;
+      promise.reject(error);
+      return promise;
+    }
+
+    void resolve(const void* = nullptr) {
+      if (_state != State::Pending) return;
+      _state = State::Fulfilled;
+      auto callbacks = _onFulfilled;
+      enqueueMicrotask([callbacks]() mutable {
+        for (auto& callback : callbacks) { callback(nullptr); }
+      });
+    }
+
+    void reject(const std::string& error) {
+      if (_state != State::Pending) return;
+      _state = State::Rejected;
+      _error = error;
+      auto callbacks = _onRejected;
+      enqueueMicrotask([callbacks, error]() mutable {
+        for (auto& callback : callbacks) { callback(error); }
+      });
+    }
+
+    Promise<void>& then(std::function<void(const void*)> onFulfilled) {
+      if (_state == State::Fulfilled) {
+        enqueueMicrotask([onFulfilled]() mutable { onFulfilled(nullptr); });
+      } else if (_state == State::Pending) {
+        _onFulfilled.push_back(std::move(onFulfilled));
+      }
+      return *this;
+    }
+
+    Promise<void>& catchError(std::function<void(const std::string&)> onRejected) {
+      if (_state == State::Rejected) {
+        const std::string error = _error;
+        enqueueMicrotask([onRejected, error]() mutable { onRejected(error); });
+      } else if (_state == State::Pending) {
+        _onRejected.push_back(std::move(onRejected));
+      }
+      return *this;
+    }
+
+  private:
+    State _state;
+    std::string _error;
+    std::vector<std::function<void(const void*)>> _onFulfilled;
+    std::vector<std::function<void(const std::string&)>> _onRejected;
+  };
+
   // ── HAL-level implementations (inside namespace so they see Promise<T> and enqueueMicrotask) ──
 
   // Async.sleep() — cooperative delay using millis polling
   inline Promise<void> __cuttlefish_async_sleep(unsigned long ms) {
     return Promise<void>([ms](std::function<void(const void*)> resolve, std::function<void(const std::string&)> reject) {
-      unsigned long start = millis();
-      if (millis() - start >= ms) {
+      unsigned long start = ${now};
+      if (${now} - start >= ms) {
         resolve(nullptr);
       } else {
         enqueueMicrotask([ms, start, resolve]() {
-          if (millis() - start >= ms) {
+          if (${now} - start >= ms) {
             resolve(nullptr);
           } else {
             enqueueMicrotask([ms, start, resolve]() { /* will be re-checked next cycle */ });
@@ -211,9 +293,9 @@ namespace typecad_async {
   // Async.sleepUntil() — poll condition every interval ms
   inline Promise<void> __cuttlefish_async_sleep_until(unsigned long pollIntervalMs) {
     return Promise<void>([pollIntervalMs](std::function<void(const void*)> resolve, std::function<void(const std::string&)> reject) {
-      unsigned long start = millis();
+      unsigned long start = ${now};
       enqueueMicrotask([pollIntervalMs, start, resolve]() {
-        if (millis() - start >= pollIntervalMs) {
+        if (${now} - start >= pollIntervalMs) {
           resolve(nullptr);  // caller re-checks condition
         } else {
           enqueueMicrotask([pollIntervalMs, start, resolve]() { /* re-check next cycle */ });

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

@@ -31,11 +31,28 @@ export interface ToolchainOptions {
     optimize?: string;
     extraFlags?: string[];
     defines?: Record<string, string>;
+    /** ESP32 PSRAM type ('opi' | 'quad') when the target board has PSRAM. */
+    psram?: 'opi' | 'quad';
     /**
      * Framework-specific config from `cuttlefish.config.ts`.
      * Each framework casts this to its own typed interface.
      */
     frameworkConfig?: Record<string, unknown>;
+    /**
+     * Zephyr-specific config from `cuttlefish.config.ts` (the `zephyr` section).
+     */
+    zephyrConfig?: Record<string, unknown>;
+    /**
+     * Display config from `cuttlefish.config.ts` (the `display` section).
+     * Frameworks use cs/dc/rst/spiFrequency to generate devicetree wiring.
+     */
+    display?: Record<string, unknown>;
+    /**
+     * True when `--debug` is active. Frameworks read this to generate debug
+     * artifacts (e.g. VS Code launch configs, debug Kconfig symbols) and to
+     * select their debug mode (gdb vs printf) via PlatformDebugStrategy.
+     */
+    debug?: boolean;
 }
 /**
  * Generic compile result. All frameworks return this shape.

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

@@ -26,6 +26,14 @@ export interface Diagnostic {
     column?: number;
     code?: string;
     source?: string;
+    /**
+     * Path (or basename) of the source file the diagnostic refers to. When set,
+     * it is rendered in the diagnostic header so the location is not just
+     * `(line,col)` but `path/to/file.ts (line,col)`. Emitters should prefer the
+     * real file path from the originating node's sourceSpan, falling back to a
+     * basename when the full path is unavailable.
+     */
+    filePath?: string;
     /** Text of the source line for display context. */
     sourceLine?: string;
 }

package/dist/api/shared/validate-framework-manifest.d.ts

@@ -0,0 +1,28 @@
+import type { PlatformStrategy } from './platform-strategy.js';
+import type { FrameworkToolchain } from '../../framework-registry.js';
+import type { FrameworkManifest } from './framework-manifest.js';
+export interface ManifestValidationContext {
+    strategy: PlatformStrategy;
+    toolchain?: FrameworkToolchain;
+    moduleExports: Record<string, unknown>;
+    packageRoot: string;
+    repoTestsDir: string;
+}
+export interface ManifestValidationError {
+    code: string;
+    path: string;
+    message: string;
+    subject?: string;
+}
+export interface ManifestValidationWarning {
+    code: string;
+    path: string;
+    message: string;
+    subject?: string;
+}
+export interface ManifestValidationResult {
+    valid: boolean;
+    errors: ManifestValidationError[];
+    warnings: ManifestValidationWarning[];
+}
+export declare function validateFrameworkManifest(manifest: FrameworkManifest, ctx: ManifestValidationContext): ManifestValidationResult;