@typecad/cuttlefish 1.0.0-alpha.3 → 1.0.0-alpha.7

package/README.md

@@ -12,15 +12,15 @@ C++, and can chain compile, upload, and serial-monitor steps.
 From a project root containing `cuttlefish.config.ts`:
 
 ```bash
-npx cuttlefish build
-npx cuttlefish build --compile --upload --port COM4
-npx cuttlefish build --compile --upload --monitor --port COM4 --baud 115200
+npx @typecad/cuttlefish build
+npx @typecad/cuttlefish build --compile --upload --port COM4
+npx @typecad/cuttlefish build --compile --upload --monitor --port COM4 --baud 115200
 ```
 
 Scaffold a starter project with the built-in wizard:
 
 ```bash
-npx cuttlefish create --board arduino:avr:uno --framework arduino
+npx @typecad/cuttlefish create --board arduino:avr:uno --framework arduino
 ```
 
 ## Commands

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

@@ -1,4 +1,5 @@
 import type { ResolvedDisplay } from "./display-profile.js";
+import type { PlatformStrategy } from "./platform-strategy.js";
 export interface DisplayAdapterCode {
     /** C++ #include lines (e.g. "#include <Adafruit_ILI9341.h>"). */
     includes: string;
@@ -9,4 +10,4 @@ export interface DisplayAdapterCode {
 }
 export type DisplayAdapterGenerator = (display: ResolvedDisplay) => DisplayAdapterCode;
 export declare function registerDisplayAdapter(driver: string, gen: DisplayAdapterGenerator): void;
-export declare function generateDisplayAdapter(display: ResolvedDisplay): DisplayAdapterCode;
+export declare function generateDisplayAdapter(display: ResolvedDisplay, strategy?: Pick<PlatformStrategy, "providesDisplayAdapter" | "resolveDisplayAdapter">): DisplayAdapterCode;

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

@@ -14,7 +14,14 @@ const adapters = new Map();
 export function registerDisplayAdapter(driver, gen) {
     adapters.set(driver, gen);
 }
-export function generateDisplayAdapter(display) {
+export function generateDisplayAdapter(display, strategy) {
+    // Strategy-owned adapters (AVR, ESP32) take precedence. Falls through to
+    // the built-in Adafruit registry for Arduino.
+    if (strategy?.providesDisplayAdapter?.() && strategy.resolveDisplayAdapter) {
+        const code = strategy.resolveDisplayAdapter(display);
+        if (code)
+            return code;
+    }
     const driver = display.driver;
     const gen = adapters.get(driver);
     if (!gen) {

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

@@ -366,8 +366,15 @@ function glcdfontBytes() {
     }
     return lines;
 }
-// Canonical Adafruit GFX 5x7 glcdfont. Public domain.
-// Source: Adafruit_GFX library glcdfont.c.
+// Adafruit GFX 5x7 glcdfont — the 'classic' fixed-space bitmap font shipped
+// with Adafruit_GFX since 1.0. BSD-3-Clause as part of the Adafruit_GFX
+// library (the file carries no per-file license statement; an earlier
+// revision of this comment claimed "public domain" but that could not be
+// verified). See packages/cuttlefish/src/api/shared/glcdfont.ts for the
+// canonical attribution header; this array is the same bytes, retained
+// here to keep the SDL preview self-contained.
+// Source: Adafruit_GFX library glcdfont.c
+//   Upstream: https://github.com/adafruit/Adafruit-GFX-Library/blob/master/glcdfont.c
 const GLCDFONT_BYTES = [
     0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x5b, 0x4f, 0x5b, 0x3e, 0x3e, 0x6b, 0x4f, 0x6b, 0x3e, 0x1c,
     0x3e, 0x7c, 0x3e, 0x1c, 0x18, 0x3c, 0x7e, 0x3c, 0x18, 0x1c, 0x57, 0x7d, 0x57, 0x1c, 0x1c, 0x5e,

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

@@ -1,5 +1,5 @@
 import type { DisplayCapabilities } from "./display-capabilities.js";
-export type TouchLibrary = "XPT2046_Touchscreen" | "Adafruit_TouchScreen" | "Adafruit_STMPE610" | "FT6336U" | "sdl";
+export type TouchLibrary = "XPT2046_Touchscreen" | "Adafruit_TouchScreen" | "Adafruit_STMPE610" | "FT6336U" | "GT911" | "CST816S" | "sdl";
 export interface TouchProfile {
     /**
      * Either a built-in library name OR a path to a custom TypeScript adapter
@@ -108,6 +108,10 @@ export interface ResolvedDisplay extends DisplayProfile {
     /** Arduino FQBN (e.g. "esp32:esp32:esp32s3:PSRAM=opi"), used to derive PSRAM
      *  availability for the scroll-canvas-memory budget. Optional. */
     _buildTarget?: string;
+    /** Explicit PSRAM flag from frameworkData.psram (IDF path). When true, the
+     *  scroll-canvas-memory diagnostic uses the PSRAM budget instead of the
+     *  SRAM default. Falls back to buildTargetHasPsram(_buildTarget) when unset. */
+    _psram?: boolean;
 }
 export interface DisplayConfig {
     profile?: string;
@@ -243,6 +247,7 @@ export declare function resolveScrollConfig(display: {
     scroll?: ScrollConfig;
 }, ctx?: {
     buildTarget?: string;
+    psram?: boolean;
 }): ResolvedScrollConfig;
 export declare function resolveDisplayProfile(config: DisplayConfig, registry: Map<string, DisplayProfile>): {
     profile: DisplayProfile;
@@ -261,5 +266,17 @@ export interface TouchAdapterCodegen {
     /** C++ static inline shim functions: touch_init, touch_isTouched, touch_readRaw. */
     functions: string;
 }
-/** Generate C++ code for a built-in touch library adapter. */
-export declare function generateTouchAdapter(touch: TouchProfile): TouchAdapterCodegen;
+/** Generate C++ code for a built-in touch library adapter.
+ *
+ *  Strategy-owned touch adapters (ESP32 native) take precedence: when the
+ *  strategy's `providesTouchAdapter()` returns true and `resolveTouchAdapter`
+ *  returns non-null, that codegen wins. Otherwise falls through to the
+ *  built-in library switch below (the Arduino path, unchanged).
+ *
+ *  Passing `undefined` for the strategy (or a strategy that doesn't provide
+ *  touch adapters) keeps the historical behavior — the Arduino library switch.
+ */
+export declare function generateTouchAdapter(touch: TouchProfile, strategy?: {
+    providesTouchAdapter?(): boolean;
+    resolveTouchAdapter?(touch: TouchProfile): TouchAdapterCodegen | undefined;
+}): TouchAdapterCodegen;

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

@@ -72,10 +72,11 @@ export function resolveScrollConfig(display, ctx) {
             ? "capacitive"
             : "none";
     // PSRAM-aware canvas budget: an explicit override always wins; otherwise use
-    // the PSRAM budget when the build target opts into PSRAM (so the scroll-canvas-
-    // memory diagnostic doesn't emit stale warnings for canvases the runtime
-    // allocates in external RAM without issue), else the no-PSRAM SRAM default.
-    const psramBudget = buildTargetHasPsram(ctx?.buildTarget);
+    // the PSRAM budget when the target opts into PSRAM — either via an explicit
+    // frameworkData.psram flag (IDF path) or an Arduino FQBN PSRAM= option — so
+    // the scroll-canvas-memory diagnostic doesn't emit stale warnings for canvases
+    // the runtime allocates in external RAM without issue. Else the SRAM default.
+    const psramBudget = ctx?.psram === true || buildTargetHasPsram(ctx?.buildTarget);
     const budgetDefault = psramBudget
         ? PSRAM_SCROLL_CANVAS_BUDGET_BYTES
         : DEFAULT_SCROLL_CANVAS_BUDGET_BYTES;
@@ -176,8 +177,22 @@ export function resolveDisplayProfile(config, registry) {
         reset: config.reset ?? -1,
     };
 }
-/** Generate C++ code for a built-in touch library adapter. */
-export function generateTouchAdapter(touch) {
+/** Generate C++ code for a built-in touch library adapter.
+ *
+ *  Strategy-owned touch adapters (ESP32 native) take precedence: when the
+ *  strategy's `providesTouchAdapter()` returns true and `resolveTouchAdapter`
+ *  returns non-null, that codegen wins. Otherwise falls through to the
+ *  built-in library switch below (the Arduino path, unchanged).
+ *
+ *  Passing `undefined` for the strategy (or a strategy that doesn't provide
+ *  touch adapters) keeps the historical behavior — the Arduino library switch.
+ */
+export function generateTouchAdapter(touch, strategy) {
+    if (strategy?.providesTouchAdapter?.() && strategy.resolveTouchAdapter) {
+        const code = strategy.resolveTouchAdapter(touch);
+        if (code)
+            return code;
+    }
     const cs = touch.cs ?? 0;
     const irq = touch.irq;
     if (touch.library === "XPT2046_Touchscreen") {

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

@@ -0,0 +1,9 @@
+import type { FrameworkManifest } from './framework-manifest.js';
+export declare const KNOWN_FRAMEWORK_PACKAGES: readonly ["@typecad/framework-arduino", "@typecad/framework-avr", "@typecad/framework-esp32"];
+export type KnownFrameworkPackage = typeof KNOWN_FRAMEWORK_PACKAGES[number];
+/**
+ * Loads a framework's manifest via its `./framework.manifest` subpath export.
+ * Throws if the package does not export that subpath or the export has no
+ * default value.
+ */
+export declare function loadFrameworkManifest(packageName: string): Promise<FrameworkManifest>;

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

@@ -0,0 +1,25 @@
+// ---------------------------------------------------------------------------
+// Framework manifest discovery
+//
+// KNOWN_FRAMEWORK_PACKAGES is the authoritative list of framework packages.
+// Add a new framework here when it ships. loadFrameworkManifest uses the
+// "./framework.manifest" subpath export each framework declares in its
+// package.json.
+// ---------------------------------------------------------------------------
+export const KNOWN_FRAMEWORK_PACKAGES = [
+    '@typecad/framework-arduino',
+    '@typecad/framework-avr',
+    '@typecad/framework-esp32',
+];
+/**
+ * Loads a framework's manifest via its `./framework.manifest` subpath export.
+ * Throws if the package does not export that subpath or the export has no
+ * default value.
+ */
+export async function loadFrameworkManifest(packageName) {
+    const mod = await import(/* @vite-ignore */ `${packageName}/framework.manifest`);
+    if (!mod.default) {
+        throw new Error(`Package ${packageName} does not export a default manifest from "./framework.manifest".`);
+    }
+    return mod.default;
+}

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

@@ -0,0 +1,462 @@
+import { z } from 'zod';
+declare const HAL_CATEGORIES: readonly ["gpio", "pwm", "adc", "dac", "interrupts", "tone", "timing", "power", "i2c", "spi", "uart", "pulse", "shift", "board", "wdt", "wifi", "http", "display"];
+export type HalCategory = typeof HAL_CATEGORIES[number];
+export declare const FrameworkManifestSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    frameworkId: z.ZodString;
+    packageName: z.ZodString;
+    canonical: z.ZodDefault<z.ZodBoolean>;
+    displayName: z.ZodString;
+    description: z.ZodString;
+    basedOn: z.ZodOptional<z.ZodString>;
+    implementationMode: z.ZodEnum<["from-scratch", "extends-canonical", "extends-other"]>;
+    inheritsStrategyId: z.ZodOptional<z.ZodString>;
+    entrypoint: z.ZodObject<{
+        entrypointFunctionName: z.ZodString;
+        requiresLoopFunction: z.ZodBoolean;
+        sourceExtension: z.ZodEnum<["ino", "cc", "cpp", "h"]>;
+        overrideBaseName: z.ZodOptional<z.ZodString>;
+        outputSubdirectory: z.ZodOptional<z.ZodString>;
+        generateHeaderFile: z.ZodBoolean;
+        customBridgeShim: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        sourceExtension: "cpp" | "ino" | "cc" | "h";
+        entrypointFunctionName: string;
+        requiresLoopFunction: boolean;
+        generateHeaderFile: boolean;
+        overrideBaseName?: string | undefined;
+        outputSubdirectory?: string | undefined;
+        customBridgeShim?: string | undefined;
+    }, {
+        sourceExtension: "cpp" | "ino" | "cc" | "h";
+        entrypointFunctionName: string;
+        requiresLoopFunction: boolean;
+        generateHeaderFile: boolean;
+        overrideBaseName?: string | undefined;
+        outputSubdirectory?: string | undefined;
+        customBridgeShim?: string | undefined;
+    }>;
+    profile: z.ZodObject<{
+        targets: z.ZodArray<z.ZodString, "many">;
+        forcedIncludes: z.ZodArray<z.ZodString, "many">;
+        symbolAliases: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        forcedIncludes: string[];
+        symbolAliases: Record<string, string>;
+        targets: string[];
+    }, {
+        forcedIncludes: string[];
+        symbolAliases: Record<string, string>;
+        targets: string[];
+    }>;
+    hal: z.ZodObject<{
+        [x: string]: z.ZodObject<{
+            supported: z.ZodBoolean;
+            unsupportedReason: z.ZodOptional<z.ZodString>;
+            ops: z.ZodRecord<z.ZodString, z.ZodEnum<["supported", "stub", "unsupported", "probe-inconclusive", "polyfill"]>>;
+            partialCoverage: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            supported: boolean;
+            ops: Record<string, "stub" | "polyfill" | "supported" | "unsupported" | "probe-inconclusive">;
+            partialCoverage: boolean;
+            unsupportedReason?: string | undefined;
+        }, {
+            supported: boolean;
+            ops: Record<string, "stub" | "polyfill" | "supported" | "unsupported" | "probe-inconclusive">;
+            unsupportedReason?: string | undefined;
+            partialCoverage?: boolean | undefined;
+        }>;
+    } & {
+        raw: z.ZodDefault<z.ZodObject<{
+            supported: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            supported: boolean;
+        }, {
+            supported: boolean;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        [x: string]: {
+            supported: boolean;
+            ops: Record<string, "stub" | "polyfill" | "supported" | "unsupported" | "probe-inconclusive">;
+            partialCoverage: boolean;
+            unsupportedReason?: string | undefined;
+        };
+        raw?: unknown;
+    }, {
+        [x: string]: {
+            supported: boolean;
+            ops: Record<string, "stub" | "polyfill" | "supported" | "unsupported" | "probe-inconclusive">;
+            unsupportedReason?: string | undefined;
+            partialCoverage?: boolean | undefined;
+        };
+        raw?: unknown;
+    }>;
+    polyfills: z.ZodObject<{
+        emitted: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            domain: z.ZodString;
+            notes: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            domain: string;
+            notes?: string | undefined;
+        }, {
+            id: string;
+            domain: string;
+            notes?: string | undefined;
+        }>, "many">;
+        suppressed: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            reason: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            reason: string;
+        }, {
+            id: string;
+            reason: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        emitted: {
+            id: string;
+            domain: string;
+            notes?: string | undefined;
+        }[];
+        suppressed: {
+            id: string;
+            reason: string;
+        }[];
+    }, {
+        emitted: {
+            id: string;
+            domain: string;
+            notes?: string | undefined;
+        }[];
+        suppressed: {
+            id: string;
+            reason: string;
+        }[];
+    }>;
+    toolchain: z.ZodObject<{
+        backend: z.ZodString;
+        operations: z.ZodObject<{
+            prepare: z.ZodBoolean;
+            compile: z.ZodBoolean;
+            upload: z.ZodBoolean;
+            monitor: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            prepare: boolean;
+            compile: boolean;
+            upload: boolean;
+            monitor: boolean;
+        }, {
+            prepare: boolean;
+            compile: boolean;
+            upload: boolean;
+            monitor: boolean;
+        }>;
+        reexportedFrom: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        backend: string;
+        operations: {
+            prepare: boolean;
+            compile: boolean;
+            upload: boolean;
+            monitor: boolean;
+        };
+        reexportedFrom?: string | undefined;
+    }, {
+        backend: string;
+        operations: {
+            prepare: boolean;
+            compile: boolean;
+            upload: boolean;
+            monitor: boolean;
+        };
+        reexportedFrom?: string | undefined;
+    }>;
+    libraryResolution: z.ZodOptional<z.ZodObject<{
+        isFrameworkLibraryImport: z.ZodBoolean;
+        getFrameworkLibraryHeaderName: z.ZodBoolean;
+        buildClassNameMap: z.ZodBoolean;
+        tryGenerateLibDecl: z.ZodBoolean;
+        reexportedFrom: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        isFrameworkLibraryImport: boolean;
+        getFrameworkLibraryHeaderName: boolean;
+        buildClassNameMap: boolean;
+        tryGenerateLibDecl: boolean;
+        reexportedFrom?: string | undefined;
+    }, {
+        isFrameworkLibraryImport: boolean;
+        getFrameworkLibraryHeaderName: boolean;
+        buildClassNameMap: boolean;
+        tryGenerateLibDecl: boolean;
+        reexportedFrom?: string | undefined;
+    }>>;
+    typeEmission: z.ZodObject<{
+        normalizeCppType: z.ZodBoolean;
+        mathHeader: z.ZodEnum<["none", "<math.h>", "<Arduino.h>"]>;
+        needsStdString: z.ZodBoolean;
+        needsStdVector: z.ZodBoolean;
+        needsIostream: z.ZodBoolean;
+        needsStdFunction: z.ZodBoolean;
+        stdlibSupport: z.ZodObject<{
+            hasVector: z.ZodBoolean;
+            hasString: z.ZodBoolean;
+            hasIostream: z.ZodBoolean;
+            hasExceptions: z.ZodBoolean;
+            hasRTTI: z.ZodBoolean;
+            recommendedArrayImpl: z.ZodEnum<["std_vector", "static_array"]>;
+            recommendedStringImpl: z.ZodEnum<["std_string", "static_string"]>;
+        }, "strip", z.ZodTypeAny, {
+            hasVector: boolean;
+            hasString: boolean;
+            hasIostream: boolean;
+            hasExceptions: boolean;
+            hasRTTI: boolean;
+            recommendedArrayImpl: "std_vector" | "static_array";
+            recommendedStringImpl: "std_string" | "static_string";
+        }, {
+            hasVector: boolean;
+            hasString: boolean;
+            hasIostream: boolean;
+            hasExceptions: boolean;
+            hasRTTI: boolean;
+            recommendedArrayImpl: "std_vector" | "static_array";
+            recommendedStringImpl: "std_string" | "static_string";
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        needsIostream: boolean;
+        needsStdString: boolean;
+        needsStdVector: boolean;
+        needsStdFunction: boolean;
+        mathHeader: "none" | "<math.h>" | "<Arduino.h>";
+        normalizeCppType: boolean;
+        stdlibSupport: {
+            hasVector: boolean;
+            hasString: boolean;
+            hasIostream: boolean;
+            hasExceptions: boolean;
+            hasRTTI: boolean;
+            recommendedArrayImpl: "std_vector" | "static_array";
+            recommendedStringImpl: "std_string" | "static_string";
+        };
+    }, {
+        needsIostream: boolean;
+        needsStdString: boolean;
+        needsStdVector: boolean;
+        needsStdFunction: boolean;
+        mathHeader: "none" | "<math.h>" | "<Arduino.h>";
+        normalizeCppType: boolean;
+        stdlibSupport: {
+            hasVector: boolean;
+            hasString: boolean;
+            hasIostream: boolean;
+            hasExceptions: boolean;
+            hasRTTI: boolean;
+            recommendedArrayImpl: "std_vector" | "static_array";
+            recommendedStringImpl: "std_string" | "static_string";
+        };
+    }>;
+    ambientTypes: z.ZodArray<z.ZodString, "many">;
+    conformance: z.ZodObject<{
+        hardwareTestGroups: z.ZodArray<z.ZodString, "many">;
+        halResolutionTests: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        hardwareTestGroups: string[];
+        halResolutionTests: string[];
+    }, {
+        hardwareTestGroups: string[];
+        halResolutionTests: string[];
+    }>;
+}, "strip", z.ZodTypeAny, {
+    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;
+        generateHeaderFile: boolean;
+        overrideBaseName?: string | undefined;
+        outputSubdirectory?: string | undefined;
+        customBridgeShim?: string | undefined;
+    };
+    profile: {
+        forcedIncludes: string[];
+        symbolAliases: Record<string, string>;
+        targets: string[];
+    };
+    hal: {
+        [x: string]: {
+            supported: boolean;
+            ops: Record<string, "stub" | "polyfill" | "supported" | "unsupported" | "probe-inconclusive">;
+            partialCoverage: boolean;
+            unsupportedReason?: string | undefined;
+        };
+        raw?: unknown;
+    };
+    polyfills: {
+        emitted: {
+            id: string;
+            domain: string;
+            notes?: string | undefined;
+        }[];
+        suppressed: {
+            id: string;
+            reason: string;
+        }[];
+    };
+    toolchain: {
+        backend: string;
+        operations: {
+            prepare: boolean;
+            compile: boolean;
+            upload: boolean;
+            monitor: boolean;
+        };
+        reexportedFrom?: string | undefined;
+    };
+    typeEmission: {
+        needsIostream: boolean;
+        needsStdString: boolean;
+        needsStdVector: boolean;
+        needsStdFunction: boolean;
+        mathHeader: "none" | "<math.h>" | "<Arduino.h>";
+        normalizeCppType: boolean;
+        stdlibSupport: {
+            hasVector: boolean;
+            hasString: boolean;
+            hasIostream: boolean;
+            hasExceptions: boolean;
+            hasRTTI: boolean;
+            recommendedArrayImpl: "std_vector" | "static_array";
+            recommendedStringImpl: "std_string" | "static_string";
+        };
+    };
+    ambientTypes: string[];
+    conformance: {
+        hardwareTestGroups: string[];
+        halResolutionTests: string[];
+    };
+    basedOn?: string | undefined;
+    inheritsStrategyId?: string | undefined;
+    libraryResolution?: {
+        isFrameworkLibraryImport: boolean;
+        getFrameworkLibraryHeaderName: boolean;
+        buildClassNameMap: boolean;
+        tryGenerateLibDecl: boolean;
+        reexportedFrom?: string | undefined;
+    } | undefined;
+}, {
+    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;
+        generateHeaderFile: boolean;
+        overrideBaseName?: string | undefined;
+        outputSubdirectory?: string | undefined;
+        customBridgeShim?: string | undefined;
+    };
+    profile: {
+        forcedIncludes: string[];
+        symbolAliases: Record<string, string>;
+        targets: string[];
+    };
+    hal: {
+        [x: string]: {
+            supported: boolean;
+            ops: Record<string, "stub" | "polyfill" | "supported" | "unsupported" | "probe-inconclusive">;
+            unsupportedReason?: string | undefined;
+            partialCoverage?: boolean | undefined;
+        };
+        raw?: unknown;
+    };
+    polyfills: {
+        emitted: {
+            id: string;
+            domain: string;
+            notes?: string | undefined;
+        }[];
+        suppressed: {
+            id: string;
+            reason: string;
+        }[];
+    };
+    toolchain: {
+        backend: string;
+        operations: {
+            prepare: boolean;
+            compile: boolean;
+            upload: boolean;
+            monitor: boolean;
+        };
+        reexportedFrom?: string | undefined;
+    };
+    typeEmission: {
+        needsIostream: boolean;
+        needsStdString: boolean;
+        needsStdVector: boolean;
+        needsStdFunction: boolean;
+        mathHeader: "none" | "<math.h>" | "<Arduino.h>";
+        normalizeCppType: boolean;
+        stdlibSupport: {
+            hasVector: boolean;
+            hasString: boolean;
+            hasIostream: boolean;
+            hasExceptions: boolean;
+            hasRTTI: boolean;
+            recommendedArrayImpl: "std_vector" | "static_array";
+            recommendedStringImpl: "std_string" | "static_string";
+        };
+    };
+    ambientTypes: string[];
+    conformance: {
+        hardwareTestGroups: string[];
+        halResolutionTests: string[];
+    };
+    canonical?: boolean | undefined;
+    basedOn?: string | undefined;
+    inheritsStrategyId?: string | undefined;
+    libraryResolution?: {
+        isFrameworkLibraryImport: boolean;
+        getFrameworkLibraryHeaderName: boolean;
+        buildClassNameMap: boolean;
+        tryGenerateLibDecl: boolean;
+        reexportedFrom?: string | undefined;
+    } | undefined;
+}>;
+export type FrameworkManifest = z.infer<typeof FrameworkManifestSchema>;
+/**
+ * Authoritative map of HAL op kinds that are lowered via the polyfill system
+ * rather than via `resolveHALOperation`. Keyed by op kind; value is the
+ * polyfill id that backs it.
+ *
+ * The manifest validator uses this to verify `polyfill`-declared ops: if a
+ * manifest declares `timing.set_interval: 'polyfill'`, the framework's
+ * `polyfills.emitted` list must include the polyfill id named here.
+ *
+ * Keep in sync with the transpiler's lowering routes — when a new op kind
+ * starts being routed via a polyfill instead of the HAL resolver, add it
+ * here. The set is intentionally small and stable: polyfill-routed ops are
+ * the exception, not the rule.
+ */
+export declare const POLYFILL_BACKED_OPS: Readonly<Record<string, string>>;
+/**
+ * Validates and returns a FrameworkManifest. Frameworks call this from their
+ * `framework.manifest.ts` to get both static type-checking (the parameter type
+ * is the inferred FrameworkManifest) and runtime validation (zod parse).
+ * Bad manifests throw at module-load time.
+ */
+export declare function defineFrameworkManifest(input: unknown): FrameworkManifest;
+export { HAL_CATEGORIES };