@typecad/framework-zephyr 1.0.0-alpha.16 → 1.0.0-alpha.19

package/dist/sdk/board-catalog-sync.d.ts

@@ -2,7 +2,7 @@ import * as catalog from '@typecad/cuttlefish/board-catalog';
 export type BoardCatalogSyncReport = catalog.BoardCatalogSyncReport;
 export type BoardCatalogEnsureResult = catalog.BoardCatalogEnsureResult;
 export type BoardCatalogOverlay = catalog.BoardCatalogOverlay;
-export declare const GENERATOR_REV: number, isZephyrBase: typeof catalog.isZephyrBase, locateZephyrBaseCheap: typeof catalog.locateZephyrBaseCheap, overlayPathFor: typeof catalog.overlayPathFor, readBoardCatalogOverlayFile: typeof catalog.readBoardCatalogOverlayFile, loadBoardCatalogOverlay: typeof catalog.loadBoardCatalogOverlay, resetBoardCatalogOverlayCache: typeof catalog.resetBoardCatalogOverlayCache, isOverlayStale: typeof catalog.isOverlayStale, diffBoardCatalogs: typeof catalog.diffBoardCatalogs, boardRecordFingerprint: typeof catalog.boardRecordFingerprint, findBoardInCatalog: typeof catalog.findBoardInCatalog, activeBoardCatalog: typeof catalog.activeBoardCatalog, resetActiveBoardCatalog: typeof catalog.resetActiveBoardCatalog;
+export declare const loadBoardCatalogOverlay: typeof catalog.loadBoardCatalogOverlay, resetBoardCatalogOverlayCache: typeof catalog.resetBoardCatalogOverlayCache;
 /** Sync with the full west discovery cascade behind it (the CLI's path):
  * falls back through spawn-based discovery when the cheap fs probes find
  * nothing. */
@@ -12,5 +12,3 @@ export declare function syncBoardCatalog(opts?: {
 /** The build-path pre-step: refresh a stale overlay before a regen
  * (fs-only discovery — no spawns during builds). */
 export declare function ensureFreshBoardCatalog(): catalog.BoardCatalogEnsureResult;
-/** Locate a Zephyr tree by any means (spawn cascade included). */
-export declare function locateZephyrBaseFull(): string | undefined;

package/dist/sdk/board-catalog-sync.js

@@ -5,13 +5,14 @@
 // @typecad/cuttlefish/board-catalog — the create flow needs it before any
 // framework is installed. This module adds the one thing the framework owns
 // — the full spawn-based west discovery cascade for an explicit
-// `cuttlefish board sync` — and re-exports the store for the strategy's
-// import surface.
+// `typecad-hal board sync`. Consumers pull the rest of the store's surface
+// from @typecad/cuttlefish/board-catalog directly.
 // ----------------------------------------------------------------------------
 import path from 'node:path';
 import * as catalog from '@typecad/cuttlefish/board-catalog';
 import { discoverWest } from '../toolchain/west-discover.js';
-export const { GENERATOR_REV, isZephyrBase, locateZephyrBaseCheap, overlayPathFor, readBoardCatalogOverlayFile, loadBoardCatalogOverlay, resetBoardCatalogOverlayCache, isOverlayStale, diffBoardCatalogs, boardRecordFingerprint, findBoardInCatalog, activeBoardCatalog, resetActiveBoardCatalog, } = catalog;
+// Re-exported for the package index's board-sync surface.
+export const { loadBoardCatalogOverlay, resetBoardCatalogOverlayCache } = catalog;
 /** Sync with the full west discovery cascade behind it (the CLI's path):
  * falls back through spawn-based discovery when the cheap fs probes find
  * nothing. */
@@ -32,10 +33,3 @@ export function syncBoardCatalog(opts = {}) {
 export function ensureFreshBoardCatalog() {
     return catalog.ensureFreshBoardCatalog();
 }
-/** Locate a Zephyr tree by any means (spawn cascade included). */
-export function locateZephyrBaseFull() {
-    const install = discoverWest();
-    return install?.zephyrBase && catalog.isZephyrBase(install.zephyrBase)
-        ? path.resolve(install.zephyrBase)
-        : undefined;
-}

package/dist/strategy.d.ts

@@ -15,6 +15,55 @@ export declare function collectSensors(program: ProgramIR | undefined): Map<stri
     spiHz: number | string;
     spiMode: number | string;
     alertPin: number | string;
+    resolution: number | string;
+}> | undefined;
+/**
+ * The I2S construction facts the program's ops carry (the shim's slab and
+ * init helpers size from these) — first-seen wins, keyed by instance.
+ */
+export declare function collectI2s(program: ProgramIR | undefined): Map<number, {
+    hz: number;
+    channels: number;
+    bits: number;
+    blockFrames: number;
+}> | undefined;
+/**
+ * Which can / i2s / clock verbs the program's ops actually use — the init
+ * blocks emit only the state those verbs reference (Zephyr's -Werror turns
+ * an unreferenced static function/variable into a build failure: a
+ * send-only CAN program must not carry the rx trampoline, a now()-only
+ * Clock program must not carry the set() conversion helper). Returns
+ * undefined when there is no program to scan (probe flows) — callers then
+ * fall back to emitting every controller with the full state set.
+ */
+export declare function collectVerbUsage(program: ProgramIR | undefined): {
+    can: Map<number, {
+        begin: boolean;
+        send: boolean;
+        onReceive: boolean;
+    }>;
+    i2s: Map<number, {
+        write: boolean;
+        read: boolean;
+        readAt: boolean;
+    }>;
+    clock: {
+        set: boolean;
+        now: boolean;
+    };
+} | undefined;
+/**
+ * Collect the distinct I2C responders the program's ops reference
+ * (i2c.resp_*), keyed `${bus}|${address}` — one target-mode address per
+ * constructed responder. Mirrors collectSpiTargets: the construction facts
+ * (rx/tx sizes) ride every op, so the first seen wins and the state block
+ * cannot drift from the call sites.
+ */
+export declare function collectI2cResponders(program: ProgramIR | undefined): Map<string, {
+    bus: string;
+    address: number;
+    rx: number;
+    tx: number;
 }> | undefined;
 /**
  * Collect the distinct thin SPI targets the program's ops reference
@@ -88,15 +137,6 @@ export declare class ZephyrStrategy implements PlatformStrategy {
         boardJson: string;
     };
     private resolveChip;
-    /**
-     * Resolve the debug mode for the active target from the platform context.
-     * Mirrors resolveChip's target extraction so shimLines/forcedIncludes can
-     * gate the printf halt shim + console UART include to printf builds only
-     * (gdb builds use VS Code native breakpoints + #line markers, so the
-     * __tc_debug_wait_for_continue shim and its <zephyr/drivers/uart.h> include
-     * are dead code there).
-     */
-    private resolveDebugMode;
     forcedIncludes(_program?: ProgramIR, ctx?: PlatformContext): string[];
     symbolAliases(): Record<string, string>;
     /**
@@ -110,15 +150,27 @@ export declare class ZephyrStrategy implements PlatformStrategy {
      */
     private programUsesAsyncRuntime;
     /** Pins referenced by gpio.* hal-ops in the program IR. lowerGpio routes a
-     *  pin to its devicetree spec by pin NUMBER, so the structured hal-op pins
-     *  are the authoritative signal for which __tc_dt_* specs are needed —
-     *  regardless of when the final call text is rendered. */
+     * pin to its devicetree spec by pin NUMBER, so the structured hal-op pins
+     * are the authoritative signal for which __tc_dt_* specs are needed —
+     * regardless of when the final call text is rendered.
+     *
+     * A gpio op interpolated into another HAL call's template literal
+     * (`USB0.writeLine(\`led: ${led.get()}\`)`) never becomes an IR node —
+     * resolveHALExprToText lowers it to C++ text while building the IR and bakes
+     * it into an __EMIT__ snprintf prelude, so the walk cannot see its pin. The
+     * spec NAME it references is still in that text; collectRawMatches finds it
+     * there, or the spec goes undeclared and the build fails on `__tc_dt_led0
+     * was not declared in this scope`. */
     private collectGpioPinUsage;
     /** Run `re` (global) against every raw string in the IR — raw expression
-     *  values plus raw hal-op codes — returning capture group 1 of each match
-     *  (the full match when the regex has no group). This is how references the
-     *  text scanners must see but that never appear as IR call nodes (e.g. a
-     *  rawCpp() escape hatch naming `__tc_dt_sw0` directly) are discovered. */
+     * values plus raw hal-op codes — returning capture group 1 of each match
+     * (the full match when the regex has no group). This is how references the
+     * text scanners must see but that never appear as IR call nodes are
+     * discovered: a rawCpp() escape hatch naming `__tc_dt_sw0` directly, and —
+     * the reason every string LEAF is scanned, not just raw nodes — the
+     * pre-lowered C++ text of a HAL call inlined into another HAL call's
+     * template literal, which the IR builder bakes into plain `string` payloads
+     * (__EMIT__ snprintf preludes, op data fields) rather than raw nodes. */
     private collectRawMatches;
     /** Whether the wiring-compat GPIO read surface (__tc_gpio_read definition,
      *  __tc_gpio_dev dispatcher, and the wiring_compat polyfill's digitalRead /
@@ -210,14 +262,14 @@ export declare class ZephyrStrategy implements PlatformStrategy {
     } | undefined;
     /**
      * Regenerate the board catalog overlay from the user's own Zephyr tree —
-     * `cuttlefish board sync`. After a `west update`, this is how new/changed/
+     * `typecad-hal board sync`. After a `west update`, this is how new/changed/
      * removed boards reach projects without a cuttlefish release. See
      * src/sdk/board-catalog-sync.ts.
      */
     syncBoardCatalog(zephyrBase?: string): BoardCatalogSyncReport;
     /**
      * Refresh the overlay only when it is stale (provenance no longer matches
-     * the tree) — the pre-step `cuttlefish board regen` runs so a regen after
+     * the tree) — the pre-step `typecad-hal board regen` runs so a regen after
      * `west update` picks up the tree's boards automatically. Tree walk only
      * happens when there is actual refreshing to do.
      */
@@ -241,6 +293,13 @@ export declare class ZephyrStrategy implements PlatformStrategy {
         preIteration: string;
         postIteration: string;
     } | null;
+    /**
+     * Per-frame wall-time feed for the trace heartbeat's UI stats. The helper
+     * is emitted unconditionally for UI programs (compiles to a no-op unless
+     * zephyr.trace defined CUTTLEFISH_TRACE_UI), so this call is safe with
+     * tracing on or off.
+     */
+    uiFrameTimingLines(deltaMsExpr: string): string[] | null;
     shouldSkipTypeAlias(): boolean;
     emitDiagnostics(): Diagnostic[];
     currentTimeMillis(): string;
@@ -262,7 +321,7 @@ export declare class ZephyrStrategy implements PlatformStrategy {
     readDigitalPin(pin: string): string;
     readAnalogPin(pin: string): string;
     writeDigitalPin(pin: string, val: string): string;
-    setPinMode(_pin: string, _mode: string): string;
+    setPinMode(pin: string, _mode: string): string;
     delayMs(ms: string): string;
     delayMicroseconds(us: string): string;
     halCallNames(): ReadonlySet<string>;
@@ -280,32 +339,9 @@ export declare class ZephyrStrategy implements PlatformStrategy {
     providesTouchAdapter(): boolean;
     resolveTouchAdapter(touch: TouchProfile): TouchAdapterCodegen | undefined;
     getProfileRegistry(): Map<string, DisplayProfile>;
-    colorFormat(): 'rgb565' | 'rgb666' | 'rgb888' | 'mono';
+    colorFormat(): 'rgb565' | 'rgb666' | 'rgb888' | 'mono' | 'gray8';
+    colorFormatForDriver(driver: string): 'rgb565' | 'rgb666' | 'rgb888' | 'mono' | 'gray8' | undefined;
+    displayClassForDriver(driver: string): 'eink' | 'oled' | undefined;
     graphicsCapacity(): GraphicsCapacity;
-    debugMode(target?: string): 'gdb' | 'printf';
-    generateDebugInitCode(): string[];
-    generateDebugBreakpointCode(params: {
-        fileName: string;
-        lineNum: number;
-        originalLine: string;
-        variables: Array<{
-            name: string;
-            isFunction?: boolean;
-            cppType?: 'bool' | 'int' | 'long' | 'float' | 'string' | 'unknown';
-        }>;
-        normalizedCondition?: string;
-        breakpointId?: number;
-    }): string[];
-    generateDebugLogpointCode(params: {
-        fileName: string;
-        lineNum: number;
-        parts: Array<{
-            type: 'text' | 'variable';
-            value: string;
-        }>;
-        variables: Array<{
-            name: string;
-            isFunction?: boolean;
-        }>;
-    }): string[];
+    debugMode(target?: string): 'gdb' | 'none';
 }