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

package/dist/add-preset.d.ts

@@ -0,0 +1,4 @@
+import type { AddCommandOptions } from "./types.js";
+export declare function listAddPresets(): string;
+/** Run `cuttlefish add <preset>`: copy the preset into the project. */
+export declare function runAddPreset(options: AddCommandOptions): void;

package/dist/add-preset.js

@@ -0,0 +1,74 @@
+// ---------------------------------------------------------------------------
+// `cuttlefish add <preset>` — scaffold copy-and-own assets into a project.
+//
+// Presets are files shipped with the package under assets/. The command COPIES
+// them into the user's project (never injected at build time): the user owns
+// the file from day one and the build only reads what they reference. This is
+// the same philosophy as shadcn/ui — components as source you keep, not a
+// runtime dependency.
+// ---------------------------------------------------------------------------
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { loadShadcnTheme, applyShadcnTheme } from "./theme-tokens.js";
+import chalk from "chalk";
+const ASSETS_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../assets");
+const PRESETS = {
+    shadcn: {
+        source: "shadcn/shadcn.css",
+        dest: "src/styles/shadcn.css",
+        description: "shadcn-style CSS variable tokens + component class recipes (buttons, cards, badges, alerts, ...)",
+        nextSteps: [
+            `Link it from a stylesheet (sibling .ui.css file or a <style> block):`,
+            ``,
+            `    @import "./styles/shadcn.css";`,
+            ``,
+            `Then use the classes on native elements:`,
+            `    <button class="btn btn-primary">Save</button>`,
+            `    <view class="card"> ... <text class="card-title">Title</text> ... </view>`,
+            ``,
+            `Dark theme: the file defines a .dark token set — activate it with`,
+            `themeClass: 'dark' in cuttlefish.config.ts's display block.`,
+            `The file is yours: tune tokens and prune recipes freely.`,
+            ``,
+            `Themes: start from an included one with --theme <name>`,
+            `(see \`cuttlefish theme\` for the list); swap later with the same command.`,
+        ],
+    },
+};
+export function listAddPresets() {
+    return Object.entries(PRESETS).map(([id, p]) => `  ${id.padEnd(10)} ${p.description}`).join("\n");
+}
+/** Run `cuttlefish add <preset>`: copy the preset into the project. */
+export function runAddPreset(options) {
+    const preset = PRESETS[options.preset];
+    if (!preset) {
+        throw new Error(`Unknown preset "${options.preset}". Available presets:\n${listAddPresets()}`);
+    }
+    const src = path.join(ASSETS_DIR, preset.source);
+    if (!fs.existsSync(src)) {
+        throw new Error(`Preset asset missing from the cuttlefish package: ${src}`);
+    }
+    const dest = path.resolve(options.projectRoot, preset.dest);
+    if (fs.existsSync(dest) && !options.force) {
+        throw new Error(`${dest} already exists — re-run with --force to overwrite (your edits will be lost).`);
+    }
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    fs.copyFileSync(src, dest);
+    // --theme <name>: merge an included shadcn theme's tokens into the copied
+    // stylesheet (shadcn preset only; no-op for future presets without themes).
+    if (options.theme) {
+        if (options.preset !== "shadcn") {
+            throw new Error(`--theme applies to the shadcn preset only (got "${options.preset}").`);
+        }
+        const theme = loadShadcnTheme(options.theme, options.projectRoot);
+        fs.writeFileSync(dest, applyShadcnTheme(fs.readFileSync(dest, "utf-8"), theme), "utf-8");
+        console.log(chalk.green(`✓`) + ` Theme ${chalk.cyan(theme.name)} tokens merged into the copied file.`);
+    }
+    console.log(chalk.green(`✓`) + ` Added preset ${chalk.cyan(options.preset)} → ${path.relative(options.projectRoot, dest)}`);
+    console.log();
+    console.log(chalk.bold(`Next steps:`));
+    for (const line of preset.nextSteps) {
+        console.log(line ? `  ${line}` : ``);
+    }
+}

package/dist/api/config.d.ts

@@ -2,8 +2,6 @@ import type { ArchitectureIdentifier } from './board-types.js';
 import type { DisplayConfig } from './shared/display-profile.js';
 /** Build-system / framework the transpiler should target. */
 type OutputFramework = string & {};
-/** Optimization strategy. */
-type OptimizationLevel = 'none' | 'size' | 'speed' | 'balanced';
 /**
  * Output section — controls how generated C++ is laid out.
  */
@@ -14,8 +12,6 @@ interface CuttlefishOutputConfig {
      * Matches the optional Zod `output.framework` in config-schema.ts.
      */
     framework?: OutputFramework;
-    /** Optimization level. */
-    optimize?: OptimizationLevel;
     /** Directory to write generated files into (relative to project root). */
     outDir?: string;
     /** Additional compiler defines (KEY = value). */
@@ -54,8 +50,12 @@ export interface CuttlefishConfig {
     /**
      * MCU package providing silicon definitions.
      * Example: '@typecad/mcu-atmega328p'
+     *
+     * Optional for native/host targets — a desktop build has no MCU (the
+     * loader generates a boardless `@typecad/board` shim). Embedded targets
+     * should set this (or the deprecated `board`).
      */
-    mcu: string;
+    mcu?: string;
     /**
      * Board package to use. (Deprecated — use mcu + contract instead)
      */

package/dist/api/shared/display-adapters/sdl.js

@@ -323,7 +323,7 @@ export const sdlAdapter = (display) => {
             `    __tc_display.put(dx, dy, pixels[i]);`,
             `  }`,
             `}`,
-            `static inline CuttlefishCanvas16* display_createCanvas(int16_t w, int16_t h) { return new SdlGfxCanvas(w, h); }`,
+            `static inline CuttlefishCanvas16* display_createCanvas(int16_t w, int16_t h) { return new (std::nothrow) SdlGfxCanvas(w, h); }`,
             `static inline CuttlefishCanvas16* display_createCanvasPsram(int16_t, int16_t) { return nullptr; }`,
             `static inline void display_deleteCanvas(CuttlefishCanvas16* c) { delete c; }`,
             `static inline int16_t display_canvasWidth(CuttlefishCanvas16* c) { return c->width(); }`,

package/dist/api/shared/display-profile.d.ts

@@ -86,6 +86,11 @@ export interface DisplayProfile {
      * is read, so a missing/unsafe readback path must not affect normal drawing.
      */
     scanlineSync?: boolean;
+    /** Tearing-effect (TE) sync, hardware variant: GPIO number of the panel's
+     *  TE output. Opt-in — few off-the-shelf display boards break the pin out.
+     *  When wired, panel updates wait for the TE frame pulse instead of the
+     *  GET_SCANLINE readback (no MISO needed; see also scanlineSync). */
+    tearingEffectPin?: number;
     touch?: TouchProfile;
     /** Enable antialiased rendering for circles, lines, rounded corners, and text
      *  unless a node opts out with font-smoothing:none.
@@ -158,6 +163,12 @@ export interface DisplayConfig {
      * default because some ST7796S modules misbehave when this command is read.
      */
     scanlineSync?: boolean;
+    /** Tearing-effect (TE) hardware sync: GPIO number of the panel's TE output
+     *  (ST7796S TE / ILI9341 TE pin). Strictly opt-in — few off-the-shelf
+     *  display boards break the pin out. When wired, panel updates arm on the
+     *  TE frame pulse (tear-free writes, no MISO readback); the Zephyr overlay
+     *  emits te-gpios on the display DT node and the adapter raises TEON. */
+    tearingEffectPin?: number;
     touch?: TouchProfile | false;
     cs?: number;
     dc?: number;

package/dist/api/shared/display-profile.js

@@ -81,6 +81,7 @@ export function resolveDisplayProfile(config, registry) {
             spiPins: config.spiPins,
             colorOrder: config.colorOrder,
             invertDisplay: config.invertDisplay,
+            tearingEffectPin: config.tearingEffectPin,
             touch: config.touch === false ? undefined : config.touch,
             displayClass: config.displayClass,
             capabilities: config.capabilities,
@@ -112,6 +113,8 @@ export function resolveDisplayProfile(config, registry) {
         base.colorOrder = config.colorOrder;
     if (config.invertDisplay !== undefined)
         base.invertDisplay = config.invertDisplay;
+    if (config.tearingEffectPin !== undefined)
+        base.tearingEffectPin = config.tearingEffectPin;
     if (config.scanlineSync !== undefined)
         base.scanlineSync = config.scanlineSync;
     if (config.touch === false)

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

@@ -20,17 +20,17 @@ export declare const FrameworkManifestSchema: z.ZodObject<{
         generateHeaderFile: z.ZodBoolean;
         customBridgeShim: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
+        sourceExtension: "cpp" | "ino" | "cc" | "h";
         entrypointFunctionName: string;
         requiresLoopFunction: boolean;
-        sourceExtension: "ino" | "cc" | "cpp" | "h";
         generateHeaderFile: boolean;
         overrideBaseName?: string | undefined;
         outputSubdirectory?: string | undefined;
         customBridgeShim?: string | undefined;
     }, {
+        sourceExtension: "cpp" | "ino" | "cc" | "h";
         entrypointFunctionName: string;
         requiresLoopFunction: boolean;
-        sourceExtension: "ino" | "cc" | "cpp" | "h";
         generateHeaderFile: boolean;
         overrideBaseName?: string | undefined;
         outputSubdirectory?: string | undefined;
@@ -41,13 +41,13 @@ export declare const FrameworkManifestSchema: z.ZodObject<{
         forcedIncludes: z.ZodArray<z.ZodString, "many">;
         symbolAliases: z.ZodRecord<z.ZodString, z.ZodString>;
     }, "strip", z.ZodTypeAny, {
-        targets: string[];
         forcedIncludes: string[];
         symbolAliases: Record<string, string>;
-    }, {
         targets: string[];
+    }, {
         forcedIncludes: string[];
         symbolAliases: Record<string, string>;
+        targets: string[];
     }>;
     hal: z.ZodObject<{
         [x: string]: z.ZodObject<{
@@ -57,12 +57,12 @@ export declare const FrameworkManifestSchema: z.ZodObject<{
             partialCoverage: z.ZodDefault<z.ZodBoolean>;
         }, "strip", z.ZodTypeAny, {
             supported: boolean;
-            ops: Record<string, "supported" | "stub" | "unsupported" | "probe-inconclusive" | "polyfill">;
+            ops: Record<string, "stub" | "polyfill" | "supported" | "unsupported" | "probe-inconclusive">;
             partialCoverage: boolean;
             unsupportedReason?: string | undefined;
         }, {
             supported: boolean;
-            ops: Record<string, "supported" | "stub" | "unsupported" | "probe-inconclusive" | "polyfill">;
+            ops: Record<string, "stub" | "polyfill" | "supported" | "unsupported" | "probe-inconclusive">;
             unsupportedReason?: string | undefined;
             partialCoverage?: boolean | undefined;
         }>;
@@ -81,12 +81,12 @@ export declare const FrameworkManifestSchema: z.ZodObject<{
         partialCoverage: z.ZodDefault<z.ZodBoolean>;
     }, "strip", z.ZodTypeAny, {
         supported: boolean;
-        ops: Record<string, "supported" | "stub" | "unsupported" | "probe-inconclusive" | "polyfill">;
+        ops: Record<string, "stub" | "polyfill" | "supported" | "unsupported" | "probe-inconclusive">;
         partialCoverage: boolean;
         unsupportedReason?: string | undefined;
     }, {
         supported: boolean;
-        ops: Record<string, "supported" | "stub" | "unsupported" | "probe-inconclusive" | "polyfill">;
+        ops: Record<string, "stub" | "polyfill" | "supported" | "unsupported" | "probe-inconclusive">;
         unsupportedReason?: string | undefined;
         partialCoverage?: boolean | undefined;
     }>, z.objectOutputType<{
@@ -97,12 +97,12 @@ export declare const FrameworkManifestSchema: z.ZodObject<{
             partialCoverage: z.ZodDefault<z.ZodBoolean>;
         }, "strip", z.ZodTypeAny, {
             supported: boolean;
-            ops: Record<string, "supported" | "stub" | "unsupported" | "probe-inconclusive" | "polyfill">;
+            ops: Record<string, "stub" | "polyfill" | "supported" | "unsupported" | "probe-inconclusive">;
             partialCoverage: boolean;
             unsupportedReason?: string | undefined;
         }, {
             supported: boolean;
-            ops: Record<string, "supported" | "stub" | "unsupported" | "probe-inconclusive" | "polyfill">;
+            ops: Record<string, "stub" | "polyfill" | "supported" | "unsupported" | "probe-inconclusive">;
             unsupportedReason?: string | undefined;
             partialCoverage?: boolean | undefined;
         }>;
@@ -121,12 +121,12 @@ export declare const FrameworkManifestSchema: z.ZodObject<{
         partialCoverage: z.ZodDefault<z.ZodBoolean>;
     }, "strip", z.ZodTypeAny, {
         supported: boolean;
-        ops: Record<string, "supported" | "stub" | "unsupported" | "probe-inconclusive" | "polyfill">;
+        ops: Record<string, "stub" | "polyfill" | "supported" | "unsupported" | "probe-inconclusive">;
         partialCoverage: boolean;
         unsupportedReason?: string | undefined;
     }, {
         supported: boolean;
-        ops: Record<string, "supported" | "stub" | "unsupported" | "probe-inconclusive" | "polyfill">;
+        ops: Record<string, "stub" | "polyfill" | "supported" | "unsupported" | "probe-inconclusive">;
         unsupportedReason?: string | undefined;
         partialCoverage?: boolean | undefined;
     }>, "strip">, z.objectInputType<{
@@ -137,12 +137,12 @@ export declare const FrameworkManifestSchema: z.ZodObject<{
             partialCoverage: z.ZodDefault<z.ZodBoolean>;
         }, "strip", z.ZodTypeAny, {
             supported: boolean;
-            ops: Record<string, "supported" | "stub" | "unsupported" | "probe-inconclusive" | "polyfill">;
+            ops: Record<string, "stub" | "polyfill" | "supported" | "unsupported" | "probe-inconclusive">;
             partialCoverage: boolean;
             unsupportedReason?: string | undefined;
         }, {
             supported: boolean;
-            ops: Record<string, "supported" | "stub" | "unsupported" | "probe-inconclusive" | "polyfill">;
+            ops: Record<string, "stub" | "polyfill" | "supported" | "unsupported" | "probe-inconclusive">;
             unsupportedReason?: string | undefined;
             partialCoverage?: boolean | undefined;
         }>;
@@ -161,12 +161,12 @@ export declare const FrameworkManifestSchema: z.ZodObject<{
         partialCoverage: z.ZodDefault<z.ZodBoolean>;
     }, "strip", z.ZodTypeAny, {
         supported: boolean;
-        ops: Record<string, "supported" | "stub" | "unsupported" | "probe-inconclusive" | "polyfill">;
+        ops: Record<string, "stub" | "polyfill" | "supported" | "unsupported" | "probe-inconclusive">;
         partialCoverage: boolean;
         unsupportedReason?: string | undefined;
     }, {
         supported: boolean;
-        ops: Record<string, "supported" | "stub" | "unsupported" | "probe-inconclusive" | "polyfill">;
+        ops: Record<string, "stub" | "polyfill" | "supported" | "unsupported" | "probe-inconclusive">;
         unsupportedReason?: string | undefined;
         partialCoverage?: boolean | undefined;
     }>, "strip">>;
@@ -222,16 +222,19 @@ export declare const FrameworkManifestSchema: z.ZodObject<{
             compile: z.ZodBoolean;
             upload: z.ZodBoolean;
             monitor: z.ZodBoolean;
+            debug: z.ZodOptional<z.ZodBoolean>;
         }, "strip", z.ZodTypeAny, {
             prepare: boolean;
             compile: boolean;
             upload: boolean;
             monitor: boolean;
+            debug?: boolean | undefined;
         }, {
             prepare: boolean;
             compile: boolean;
             upload: boolean;
             monitor: boolean;
+            debug?: boolean | undefined;
         }>;
         reexportedFrom: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
@@ -241,6 +244,7 @@ export declare const FrameworkManifestSchema: z.ZodObject<{
             compile: boolean;
             upload: boolean;
             monitor: boolean;
+            debug?: boolean | undefined;
         };
         reexportedFrom?: string | undefined;
     }, {
@@ -250,6 +254,7 @@ export declare const FrameworkManifestSchema: z.ZodObject<{
             compile: boolean;
             upload: boolean;
             monitor: boolean;
+            debug?: boolean | undefined;
         };
         reexportedFrom?: string | undefined;
     }>;
@@ -305,12 +310,12 @@ export declare const FrameworkManifestSchema: z.ZodObject<{
             recommendedStringImpl: "std_string" | "static_string";
         }>;
     }, "strip", z.ZodTypeAny, {
-        normalizeCppType: boolean;
-        mathHeader: "none" | "<math.h>" | "<Arduino.h>";
+        needsIostream: boolean;
         needsStdString: boolean;
         needsStdVector: boolean;
-        needsIostream: boolean;
         needsStdFunction: boolean;
+        mathHeader: "none" | "<math.h>" | "<Arduino.h>";
+        normalizeCppType: boolean;
         stdlibSupport: {
             hasVector: boolean;
             hasString: boolean;
@@ -321,12 +326,12 @@ export declare const FrameworkManifestSchema: z.ZodObject<{
             recommendedStringImpl: "std_string" | "static_string";
         };
     }, {
-        normalizeCppType: boolean;
-        mathHeader: "none" | "<math.h>" | "<Arduino.h>";
+        needsIostream: boolean;
         needsStdString: boolean;
         needsStdVector: boolean;
-        needsIostream: boolean;
         needsStdFunction: boolean;
+        mathHeader: "none" | "<math.h>" | "<Arduino.h>";
+        normalizeCppType: boolean;
         stdlibSupport: {
             hasVector: boolean;
             hasString: boolean;
@@ -371,42 +376,42 @@ export declare const FrameworkManifestSchema: z.ZodObject<{
         zephyr?: string | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
+    hal: {
+        [x: string]: {
+            supported: boolean;
+            ops: Record<string, "stub" | "polyfill" | "supported" | "unsupported" | "probe-inconclusive">;
+            partialCoverage: boolean;
+            unsupportedReason?: string | undefined;
+        };
+        raw?: unknown;
+    } & {
+        [k: string]: {
+            supported: boolean;
+            ops: Record<string, "stub" | "polyfill" | "supported" | "unsupported" | "probe-inconclusive">;
+            partialCoverage: boolean;
+            unsupportedReason?: string | undefined;
+        };
+    };
+    packageName: string;
     schemaVersion: 1;
     frameworkId: string;
-    packageName: string;
     canonical: boolean;
     displayName: string;
     description: string;
     implementationMode: "from-scratch" | "extends-canonical" | "extends-other";
     entrypoint: {
+        sourceExtension: "cpp" | "ino" | "cc" | "h";
         entrypointFunctionName: string;
         requiresLoopFunction: boolean;
-        sourceExtension: "ino" | "cc" | "cpp" | "h";
         generateHeaderFile: boolean;
         overrideBaseName?: string | undefined;
         outputSubdirectory?: string | undefined;
         customBridgeShim?: string | undefined;
     };
     profile: {
-        targets: string[];
         forcedIncludes: string[];
         symbolAliases: Record<string, string>;
-    };
-    hal: {
-        [x: string]: {
-            supported: boolean;
-            ops: Record<string, "supported" | "stub" | "unsupported" | "probe-inconclusive" | "polyfill">;
-            partialCoverage: boolean;
-            unsupportedReason?: string | undefined;
-        };
-        raw?: unknown;
-    } & {
-        [k: string]: {
-            supported: boolean;
-            ops: Record<string, "supported" | "stub" | "unsupported" | "probe-inconclusive" | "polyfill">;
-            partialCoverage: boolean;
-            unsupportedReason?: string | undefined;
-        };
+        targets: string[];
     };
     polyfills: {
         emitted: {
@@ -426,16 +431,17 @@ export declare const FrameworkManifestSchema: z.ZodObject<{
             compile: boolean;
             upload: boolean;
             monitor: boolean;
+            debug?: boolean | undefined;
         };
         reexportedFrom?: string | undefined;
     };
     typeEmission: {
-        normalizeCppType: boolean;
-        mathHeader: "none" | "<math.h>" | "<Arduino.h>";
+        needsIostream: boolean;
         needsStdString: boolean;
         needsStdVector: boolean;
-        needsIostream: boolean;
         needsStdFunction: boolean;
+        mathHeader: "none" | "<math.h>" | "<Arduino.h>";
+        normalizeCppType: boolean;
         stdlibSupport: {
             hasVector: boolean;
             hasString: boolean;
@@ -451,6 +457,12 @@ export declare const FrameworkManifestSchema: z.ZodObject<{
         hardwareTestGroups: string[];
         halResolutionTests: string[];
     };
+    doctor?: {
+        available: boolean;
+    } | undefined;
+    licenses?: {
+        available: boolean;
+    } | undefined;
     basedOn?: string | undefined;
     inheritsStrategyId?: string | undefined;
     libraryResolution?: {
@@ -460,51 +472,45 @@ export declare const FrameworkManifestSchema: z.ZodObject<{
         tryGenerateLibDecl: boolean;
         reexportedFrom?: string | undefined;
     } | undefined;
-    doctor?: {
-        available: boolean;
-    } | undefined;
-    licenses?: {
-        available: boolean;
-    } | undefined;
     compat?: {
         zephyr?: string | undefined;
     } | undefined;
 }, {
+    hal: {
+        [x: string]: {
+            supported: boolean;
+            ops: Record<string, "stub" | "polyfill" | "supported" | "unsupported" | "probe-inconclusive">;
+            unsupportedReason?: string | undefined;
+            partialCoverage?: boolean | undefined;
+        };
+        raw?: unknown;
+    } & {
+        [k: string]: {
+            supported: boolean;
+            ops: Record<string, "stub" | "polyfill" | "supported" | "unsupported" | "probe-inconclusive">;
+            unsupportedReason?: string | undefined;
+            partialCoverage?: boolean | undefined;
+        };
+    };
+    packageName: string;
     schemaVersion: 1;
     frameworkId: string;
-    packageName: string;
     displayName: string;
     description: string;
     implementationMode: "from-scratch" | "extends-canonical" | "extends-other";
     entrypoint: {
+        sourceExtension: "cpp" | "ino" | "cc" | "h";
         entrypointFunctionName: string;
         requiresLoopFunction: boolean;
-        sourceExtension: "ino" | "cc" | "cpp" | "h";
         generateHeaderFile: boolean;
         overrideBaseName?: string | undefined;
         outputSubdirectory?: string | undefined;
         customBridgeShim?: string | undefined;
     };
     profile: {
-        targets: string[];
         forcedIncludes: string[];
         symbolAliases: Record<string, string>;
-    };
-    hal: {
-        [x: string]: {
-            supported: boolean;
-            ops: Record<string, "supported" | "stub" | "unsupported" | "probe-inconclusive" | "polyfill">;
-            unsupportedReason?: string | undefined;
-            partialCoverage?: boolean | undefined;
-        };
-        raw?: unknown;
-    } & {
-        [k: string]: {
-            supported: boolean;
-            ops: Record<string, "supported" | "stub" | "unsupported" | "probe-inconclusive" | "polyfill">;
-            unsupportedReason?: string | undefined;
-            partialCoverage?: boolean | undefined;
-        };
+        targets: string[];
     };
     polyfills: {
         emitted: {
@@ -524,16 +530,17 @@ export declare const FrameworkManifestSchema: z.ZodObject<{
             compile: boolean;
             upload: boolean;
             monitor: boolean;
+            debug?: boolean | undefined;
         };
         reexportedFrom?: string | undefined;
     };
     typeEmission: {
-        normalizeCppType: boolean;
-        mathHeader: "none" | "<math.h>" | "<Arduino.h>";
+        needsIostream: boolean;
         needsStdString: boolean;
         needsStdVector: boolean;
-        needsIostream: boolean;
         needsStdFunction: boolean;
+        mathHeader: "none" | "<math.h>" | "<Arduino.h>";
+        normalizeCppType: boolean;
         stdlibSupport: {
             hasVector: boolean;
             hasString: boolean;
@@ -549,6 +556,12 @@ export declare const FrameworkManifestSchema: z.ZodObject<{
         hardwareTestGroups: string[];
         halResolutionTests: string[];
     };
+    doctor?: {
+        available: boolean;
+    } | undefined;
+    licenses?: {
+        available: boolean;
+    } | undefined;
     canonical?: boolean | undefined;
     basedOn?: string | undefined;
     inheritsStrategyId?: string | undefined;
@@ -559,12 +572,6 @@ export declare const FrameworkManifestSchema: z.ZodObject<{
         tryGenerateLibDecl: boolean;
         reexportedFrom?: string | undefined;
     } | undefined;
-    doctor?: {
-        available: boolean;
-    } | undefined;
-    licenses?: {
-        available: boolean;
-    } | undefined;
     compat?: {
         zephyr?: string | undefined;
     } | undefined;

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

@@ -84,6 +84,7 @@ const ToolchainCoverageSchema = z.object({
         compile: z.boolean(),
         upload: z.boolean(),
         monitor: z.boolean(),
+        debug: z.boolean().optional(),
     }),
     reexportedFrom: z.string().optional(),
 });

package/dist/api/shared/hal-op-ir.d.ts

@@ -7,16 +7,35 @@ export interface GpioWriteOp {
     pin: number;
     /** 0 = LOW, 1 = HIGH, or a runtime expression string (e.g. "state", "!state") */
     value: 0 | 1 | string;
+    /**
+     * Output-pin state tracking: set at the END of the file's IR build (see
+     * markShadowUpdatingOps) when this pin has a tracked shadow read anywhere
+     * in the file — the emitted write must also assign the shadow state
+     * variable. Baked into the op at build time because emit never sees live
+     * tracker state: every file's buildProgramIR resets the tracker, and all
+     * files build before any emit runs.
+     */
+    updatesShadow?: boolean;
 }
 export interface GpioReadOp {
     operation: "gpio.read";
     port?: string;
     pin: number;
+    /**
+     * Output-pin state tracking: when set, this read is on a pin explicitly
+     * configured as OUTPUT and must NOT lower to a hardware pin read (which is
+     * not portable for direction-only outputs, e.g. Zephyr). 'high'/'low' fold
+     * to a compile-time constant; 'shadow' lowers to the tracked state
+     * variable that generated writes keep updated.
+     */
+    trackedValue?: "high" | "low" | "shadow";
 }
 export interface GpioToggleOp {
     operation: "gpio.toggle";
     port?: string;
     pin: number;
+    /** Output-pin state tracking — same contract as GpioWriteOp.updatesShadow. */
+    updatesShadow?: boolean;
 }
 export interface GpioSetModeOp {
     operation: "gpio.set_mode";

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

@@ -28,7 +28,6 @@ export interface ToolchainOptions {
     buildTarget?: string;
     port?: string;
     baud?: number;
-    optimize?: string;
     extraFlags?: string[];
     defines?: Record<string, string>;
     /** ESP32 PSRAM type ('opi' | 'quad') when the target board has PSRAM. */