@typecad/cuttlefish 1.0.0-alpha.6 → 1.0.0-alpha.8

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

@@ -0,0 +1,182 @@
+// ---------------------------------------------------------------------------
+// Framework manifest schema
+//
+// Single source of truth for "what a framework is." A zod schema defines the
+// contract; the FrameworkManifest type is inferred from it so there is no
+// drift between runtime validation and static types. Each field maps to a real
+// code artifact (PlatformStrategy method, LoadedFramework export, file path).
+//
+// Per-package `framework.manifest.ts` files call defineFrameworkManifest() to
+// declare their coverage. The validator in validate-framework-manifest.ts
+// cross-checks each claim against the loaded strategy/toolchain.
+// ---------------------------------------------------------------------------
+import { z } from 'zod';
+// Core HAL categories that EVERY framework MUST declare coverage for (the
+// universal embedded surface: digital/analog I/O, comms buses, timing, power,
+// watchdog). These keys are required in every manifest's `hal` block.
+//
+// Extended categories — `rmt`, `ble`, `preferences`, `random`, `fs`, `mqtt`,
+// `mdns`, `ota`, etc. — are OPTIONAL: a framework declares them only if it
+// lowers them. The HalCoverageSchema below uses `.catchall()` so declared
+// extended categories survive zod parsing (they used to be silently stripped,
+// which made esp32's ble/rmt/preferences manifest blocks dead data) and get
+// validated by the manifest validator like any core category. A framework that
+// does not lower an extended category simply omits it.
+const HAL_CATEGORIES = [
+    'gpio', 'pwm', 'adc', 'dac', 'interrupts', 'tone', 'timing', 'power',
+    'i2c', 'spi', 'uart', 'pulse', 'shift', 'board', 'wdt', 'wifi', 'http',
+    'mqtt', 'display',
+];
+const OpStatus = z.enum(['supported', 'stub', 'unsupported', 'probe-inconclusive', 'polyfill']);
+const HalCategorySchema = z.object({
+    supported: z.boolean(),
+    unsupportedReason: z.string().optional(),
+    ops: z.record(z.string(), OpStatus),
+    partialCoverage: z.boolean().default(false),
+});
+const DisplayCategorySchema = HalCategorySchema.extend({
+    drivers: z.array(z.string()),
+    colorFormat: z.enum(['rgb565', 'mono']).nullable(),
+});
+const HalCoverageSchema = z.object(Object.fromEntries(HAL_CATEGORIES.map((c) => [
+    c,
+    c === 'display' ? DisplayCategorySchema : HalCategorySchema,
+]))).extend({
+    raw: z.object({ supported: z.boolean() }).default({ supported: true }),
+    // catchall: extended categories (rmt, ble, preferences, random, fs, mqtt,
+    // mdns, ota, ...) declared by a framework that lowers them. Without this,
+    // zod's default object parsing silently strips unknown keys, so a manifest's
+    // `ble:` / `rmt:` / `preferences:` / `random:` blocks never reached the
+    // validator or consumers. The catchall validates them with the same shape as
+    // core categories (HalCategorySchema) and preserves them on the parsed
+    // object. Frameworks that don't lower an extended category simply omit it.
+    // `raw` is excluded — it is the escape hatch, not a HAL category.
+}).catchall(HalCategorySchema);
+const EntrypointSchema = z.object({
+    entrypointFunctionName: z.string(),
+    requiresLoopFunction: z.boolean(),
+    sourceExtension: z.enum(['ino', 'cc', 'cpp', 'h']),
+    overrideBaseName: z.string().optional(),
+    outputSubdirectory: z.string().optional(),
+    generateHeaderFile: z.boolean(),
+    customBridgeShim: z.string().optional(),
+});
+const ProfileSchema = z.object({
+    targets: z.array(z.string()),
+    forcedIncludes: z.array(z.string()),
+    symbolAliases: z.record(z.string(), z.string()),
+});
+const PolyfillCoverageSchema = z.object({
+    emitted: z.array(z.object({
+        id: z.string(),
+        domain: z.string(),
+        notes: z.string().optional(),
+    })),
+    suppressed: z.array(z.object({
+        id: z.string(),
+        reason: z.string(),
+    })),
+});
+const ToolchainCoverageSchema = z.object({
+    backend: z.string(),
+    operations: z.object({
+        prepare: z.boolean(),
+        compile: z.boolean(),
+        upload: z.boolean(),
+        monitor: z.boolean(),
+    }),
+    reexportedFrom: z.string().optional(),
+});
+const LibraryResolutionSchema = z.object({
+    isFrameworkLibraryImport: z.boolean(),
+    getFrameworkLibraryHeaderName: z.boolean(),
+    buildClassNameMap: z.boolean(),
+    tryGenerateLibDecl: z.boolean(),
+    reexportedFrom: z.string().optional(),
+});
+/**
+ * Capability block for an optional subcommand the framework may own (e.g.
+ * `cuttlefish doctor`, `cuttlefish licenses`). The manifest only declares
+ * availability; the framework's runtime `doctor` / `licenses` exports provide
+ * the implementation, and cuttlefish dispatches to them when present.
+ */
+const SubcommandCapabilitySchema = z.object({
+    available: z.boolean(),
+});
+const StdLibSupportSchema = z.object({
+    hasVector: z.boolean(),
+    hasString: z.boolean(),
+    hasIostream: z.boolean(),
+    hasExceptions: z.boolean(),
+    hasRTTI: z.boolean(),
+    recommendedArrayImpl: z.enum(['std_vector', 'static_array']),
+    recommendedStringImpl: z.enum(['std_string', 'static_string']),
+});
+const TypeEmissionSchema = z.object({
+    normalizeCppType: z.boolean(),
+    mathHeader: z.enum(['none', '<math.h>', '<Arduino.h>']),
+    needsStdString: z.boolean(),
+    needsStdVector: z.boolean(),
+    needsIostream: z.boolean(),
+    needsStdFunction: z.boolean(),
+    stdlibSupport: StdLibSupportSchema,
+});
+const ConformanceSchema = z.object({
+    hardwareTestGroups: z.array(z.string()),
+    halResolutionTests: z.array(z.string()),
+});
+export const FrameworkManifestSchema = z.object({
+    schemaVersion: z.literal(1),
+    frameworkId: z.string(),
+    packageName: z.string(),
+    canonical: z.boolean().default(false),
+    displayName: z.string(),
+    description: z.string(),
+    basedOn: z.string().optional(),
+    implementationMode: z.enum(['from-scratch', 'extends-canonical', 'extends-other']),
+    inheritsStrategyId: z.string().optional(),
+    entrypoint: EntrypointSchema,
+    profile: ProfileSchema,
+    hal: HalCoverageSchema,
+    polyfills: PolyfillCoverageSchema,
+    toolchain: ToolchainCoverageSchema,
+    libraryResolution: LibraryResolutionSchema.optional(),
+    typeEmission: TypeEmissionSchema,
+    ambientTypes: z.array(z.string()),
+    conformance: ConformanceSchema,
+    // Optional subcommand capabilities owned by the framework. When declared
+    // `{ available: true }`, the framework exports matching `doctor` / `licenses`
+    // functions that cuttlefish dispatches the corresponding CLI subcommands to.
+    doctor: SubcommandCapabilitySchema.optional(),
+    licenses: SubcommandCapabilitySchema.optional(),
+});
+/**
+ * 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 const POLYFILL_BACKED_OPS = {
+    'timing.set_interval': 'timer_methods',
+    'timing.set_timeout': 'timer_methods',
+    'timing.clear_interval': 'timer_methods',
+    'timing.clear_timeout': 'timer_methods',
+};
+/**
+ * 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 function defineFrameworkManifest(input) {
+    return FrameworkManifestSchema.parse(input);
+}
+export { HAL_CATEGORIES };

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

@@ -0,0 +1,12 @@
+export declare const GLCDFONT_BYTES: readonly number[];
+/**
+ * Render the font as a C++ byte-array literal (16 bytes per line). Used by
+ * adapters that need the table emitted into the synthesized translation unit.
+ *
+ * Example output:
+ *   static const uint8_t glcdfont[] = {
+ *     0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x5b, 0x4f, 0x5b, 0x3e, ...
+ *     ...
+ *   };
+ */
+export declare function renderGlcdfontArray(name: string, type?: string): string;

package/dist/api/shared/glcdfont.js

@@ -0,0 +1,124 @@
+// ---------------------------------------------------------------------------
+// Adafruit GFX 5x7 glcdfont — the 'classic' fixed-space bitmap font shipped
+// with Adafruit_GFX since 1.0.
+//
+// Source: Adafruit_GFX library glcdfont.c
+//   Copyright (c) 2013 Adafruit Industries. All rights reserved.
+//   Licensed under BSD-3-Clause (as part of the Adafruit_GFX library).
+//   Upstream: https://github.com/adafruit/Adafruit-GFX-Library/blob/master/glcdfont.c
+//
+// NOTE: an earlier revision of this file described the bytes as "public
+// domain." That claim could not be verified — glcdfont.c carries no
+// per-file license statement and is distributed as part of the BSD-3-Clause
+// Adafruit_GFX library, so the conservative treatment is BSD-3-Clause.
+//
+// Shared between:
+//   - packages/cuttlefish/src/api/shared/display-adapters/sdl.ts
+//     (emits __sdl_glcdfont[] for the SDL preview host adapter)
+//   - packages/ui/src/ui-engine/runtime-header/cuttlefish-gfx.ts
+//     (emits glcdfont[] for native display adapters — AVR, ESP32)
+//
+// 256 glyphs × 5 bytes = 1280 bytes. Indexed as glcdfont[ch * 5 + column].
+// ---------------------------------------------------------------------------
+export 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,
+    0x7f, 0x5e, 0x1c, 0x00, 0x18, 0x3c, 0x18, 0x00, 0xff, 0xe7, 0xc3, 0xe7, 0xff, 0x00, 0x18, 0x24,
+    0x18, 0x00, 0xff, 0xe7, 0xdb, 0xe7, 0xff, 0x30, 0x48, 0x3a, 0x06, 0x0e, 0x26, 0x29, 0x79, 0x29,
+    0x26, 0x40, 0x7f, 0x05, 0x05, 0x07, 0x40, 0x7f, 0x05, 0x25, 0x3f, 0x5a, 0x3c, 0xe7, 0x3c, 0x5a,
+    0x7f, 0x3e, 0x1c, 0x1c, 0x08, 0x08, 0x1c, 0x1c, 0x3e, 0x7f, 0x14, 0x22, 0x7f, 0x22, 0x14, 0x5f,
+    0x5f, 0x00, 0x5f, 0x5f, 0x06, 0x09, 0x7f, 0x01, 0x7f, 0x00, 0x66, 0x89, 0x95, 0x6a, 0x60, 0x60,
+    0x60, 0x60, 0x60, 0x94, 0xa2, 0xff, 0xa2, 0x94, 0x08, 0x04, 0x7e, 0x04, 0x08, 0x10, 0x20, 0x7e,
+    0x20, 0x10, 0x08, 0x08, 0x2a, 0x1c, 0x08, 0x08, 0x1c, 0x2a, 0x08, 0x08, 0x1e, 0x10, 0x10, 0x10,
+    0x10, 0x0c, 0x1e, 0x0c, 0x1e, 0x0c, 0x30, 0x38, 0x3e, 0x38, 0x30, 0x06, 0x0e, 0x3e, 0x0e, 0x06,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5f, 0x00, 0x00, 0x00, 0x07, 0x00, 0x07, 0x00, 0x14,
+    0x7f, 0x14, 0x7f, 0x14, 0x24, 0x2a, 0x7f, 0x2a, 0x12, 0x23, 0x13, 0x08, 0x64, 0x62, 0x36, 0x49,
+    0x56, 0x20, 0x50, 0x00, 0x08, 0x07, 0x03, 0x00, 0x00, 0x1c, 0x22, 0x41, 0x00, 0x00, 0x41, 0x22,
+    0x1c, 0x00, 0x2a, 0x1c, 0x7f, 0x1c, 0x2a, 0x08, 0x08, 0x3e, 0x08, 0x08, 0x00, 0x80, 0x70, 0x30,
+    0x00, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 0x00, 0x60, 0x60, 0x00, 0x20, 0x10, 0x08, 0x04, 0x02,
+    0x3e, 0x51, 0x49, 0x45, 0x3e, 0x00, 0x42, 0x7f, 0x40, 0x00, 0x72, 0x49, 0x49, 0x49, 0x46, 0x21,
+    0x41, 0x49, 0x4d, 0x33, 0x18, 0x14, 0x12, 0x7f, 0x10, 0x27, 0x45, 0x45, 0x45, 0x39, 0x3c, 0x4a,
+    0x49, 0x49, 0x31, 0x41, 0x21, 0x11, 0x09, 0x07, 0x36, 0x49, 0x49, 0x49, 0x36, 0x46, 0x49, 0x49,
+    0x29, 0x1e, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x40, 0x34, 0x00, 0x00, 0x00, 0x08, 0x14, 0x22,
+    0x41, 0x14, 0x14, 0x14, 0x14, 0x14, 0x00, 0x41, 0x22, 0x14, 0x08, 0x02, 0x01, 0x59, 0x09, 0x06,
+    0x3e, 0x41, 0x5d, 0x59, 0x4e, 0x7c, 0x12, 0x11, 0x12, 0x7c, 0x7f, 0x49, 0x49, 0x49, 0x36, 0x3e,
+    0x41, 0x41, 0x41, 0x22, 0x7f, 0x41, 0x41, 0x41, 0x3e, 0x7f, 0x49, 0x49, 0x49, 0x41, 0x7f, 0x09,
+    0x09, 0x09, 0x01, 0x3e, 0x41, 0x41, 0x51, 0x73, 0x7f, 0x08, 0x08, 0x08, 0x7f, 0x00, 0x41, 0x7f,
+    0x41, 0x00, 0x20, 0x40, 0x41, 0x3f, 0x01, 0x7f, 0x08, 0x14, 0x22, 0x41, 0x7f, 0x40, 0x40, 0x40,
+    0x40, 0x7f, 0x02, 0x1c, 0x02, 0x7f, 0x7f, 0x04, 0x08, 0x10, 0x7f, 0x3e, 0x41, 0x41, 0x41, 0x3e,
+    0x7f, 0x09, 0x09, 0x09, 0x06, 0x3e, 0x41, 0x51, 0x21, 0x5e, 0x7f, 0x09, 0x19, 0x29, 0x46, 0x26,
+    0x49, 0x49, 0x49, 0x32, 0x03, 0x01, 0x7f, 0x01, 0x03, 0x3f, 0x40, 0x40, 0x40, 0x3f, 0x1f, 0x20,
+    0x40, 0x20, 0x1f, 0x3f, 0x40, 0x38, 0x40, 0x3f, 0x63, 0x14, 0x08, 0x14, 0x63, 0x03, 0x04, 0x78,
+    0x04, 0x03, 0x61, 0x59, 0x49, 0x4d, 0x43, 0x00, 0x7f, 0x41, 0x41, 0x41, 0x02, 0x04, 0x08, 0x10,
+    0x20, 0x00, 0x41, 0x41, 0x41, 0x7f, 0x04, 0x02, 0x01, 0x02, 0x04, 0x40, 0x40, 0x40, 0x40, 0x40,
+    0x00, 0x03, 0x07, 0x08, 0x00, 0x20, 0x54, 0x54, 0x78, 0x40, 0x7f, 0x28, 0x44, 0x44, 0x38, 0x38,
+    0x44, 0x44, 0x44, 0x28, 0x38, 0x44, 0x44, 0x28, 0x7f, 0x38, 0x54, 0x54, 0x54, 0x18, 0x00, 0x08,
+    0x7e, 0x09, 0x02, 0x18, 0xa4, 0xa4, 0x9c, 0x78, 0x7f, 0x08, 0x04, 0x04, 0x78, 0x00, 0x44, 0x7d,
+    0x40, 0x00, 0x20, 0x40, 0x40, 0x3d, 0x00, 0x7f, 0x10, 0x28, 0x44, 0x00, 0x00, 0x41, 0x7f, 0x40,
+    0x00, 0x7c, 0x04, 0x78, 0x04, 0x78, 0x7c, 0x08, 0x04, 0x04, 0x78, 0x38, 0x44, 0x44, 0x44, 0x38,
+    0xfc, 0x18, 0x24, 0x24, 0x18, 0x18, 0x24, 0x24, 0x18, 0xfc, 0x7c, 0x08, 0x04, 0x04, 0x08, 0x48,
+    0x54, 0x54, 0x54, 0x24, 0x04, 0x04, 0x3f, 0x44, 0x24, 0x3c, 0x40, 0x40, 0x20, 0x7c, 0x1c, 0x20,
+    0x40, 0x20, 0x1c, 0x3c, 0x40, 0x30, 0x40, 0x3c, 0x44, 0x28, 0x10, 0x28, 0x44, 0x4c, 0x90, 0x90,
+    0x90, 0x7c, 0x44, 0x64, 0x54, 0x4c, 0x44, 0x00, 0x08, 0x36, 0x41, 0x00, 0x00, 0x00, 0x77, 0x00,
+    0x00, 0x00, 0x41, 0x36, 0x08, 0x00, 0x02, 0x01, 0x02, 0x04, 0x02, 0x3c, 0x26, 0x23, 0x26, 0x3c,
+    0x1e, 0xa1, 0xa1, 0x61, 0x12, 0x3a, 0x40, 0x40, 0x20, 0x7a, 0x38, 0x54, 0x54, 0x55, 0x59, 0x21,
+    0x55, 0x55, 0x79, 0x41, 0x22, 0x54, 0x54, 0x78, 0x42, 0x21, 0x55, 0x54, 0x78, 0x40, 0x20, 0x54,
+    0x55, 0x79, 0x40, 0x0c, 0x1e, 0x52, 0x72, 0x12, 0x39, 0x55, 0x55, 0x55, 0x59, 0x39, 0x54, 0x54,
+    0x54, 0x59, 0x39, 0x55, 0x54, 0x54, 0x58, 0x00, 0x00, 0x45, 0x7c, 0x41, 0x00, 0x02, 0x45, 0x7d,
+    0x42, 0x00, 0x01, 0x45, 0x7c, 0x40, 0x7d, 0x12, 0x11, 0x12, 0x7d, 0xf0, 0x28, 0x25, 0x28, 0xf0,
+    0x7c, 0x54, 0x55, 0x45, 0x00, 0x20, 0x54, 0x54, 0x7c, 0x54, 0x7c, 0x0a, 0x09, 0x7f, 0x49, 0x32,
+    0x49, 0x49, 0x49, 0x32, 0x3a, 0x44, 0x44, 0x44, 0x3a, 0x32, 0x4a, 0x48, 0x48, 0x30, 0x3a, 0x41,
+    0x41, 0x21, 0x7a, 0x3a, 0x42, 0x40, 0x20, 0x78, 0x00, 0x9d, 0xa0, 0xa0, 0x7d, 0x3d, 0x42, 0x42,
+    0x42, 0x3d, 0x3d, 0x40, 0x40, 0x40, 0x3d, 0x3c, 0x24, 0xff, 0x24, 0x24, 0x48, 0x7e, 0x49, 0x43,
+    0x66, 0x2b, 0x2f, 0xfc, 0x2f, 0x2b, 0xff, 0x09, 0x29, 0xf6, 0x20, 0xc0, 0x88, 0x7e, 0x09, 0x03,
+    0x20, 0x54, 0x54, 0x79, 0x41, 0x00, 0x00, 0x44, 0x7d, 0x41, 0x30, 0x48, 0x48, 0x4a, 0x32, 0x38,
+    0x40, 0x40, 0x22, 0x7a, 0x00, 0x7a, 0x0a, 0x0a, 0x72, 0x7d, 0x0d, 0x19, 0x31, 0x7d, 0x26, 0x29,
+    0x29, 0x2f, 0x28, 0x26, 0x29, 0x29, 0x29, 0x26, 0x30, 0x48, 0x4d, 0x40, 0x20, 0x38, 0x08, 0x08,
+    0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x38, 0x2f, 0x10, 0xc8, 0xac, 0xba, 0x2f, 0x10, 0x28, 0x34,
+    0xfa, 0x00, 0x00, 0x7b, 0x00, 0x00, 0x08, 0x14, 0x2a, 0x14, 0x22, 0x22, 0x14, 0x2a, 0x14, 0x08,
+    0x55, 0x00, 0x55, 0x00, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0xff, 0x55, 0xff, 0x55, 0xff, 0x00,
+    0x00, 0x00, 0xff, 0x00, 0x10, 0x10, 0x10, 0xff, 0x00, 0x14, 0x14, 0x14, 0xff, 0x00, 0x10, 0x10,
+    0xff, 0x00, 0xff, 0x10, 0x10, 0xf0, 0x10, 0xf0, 0x14, 0x14, 0x14, 0xfc, 0x00, 0x14, 0x14, 0xf7,
+    0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0x14, 0x14, 0xf4, 0x04, 0xfc, 0x14, 0x14, 0x17, 0x10,
+    0x1f, 0x10, 0x10, 0x1f, 0x10, 0x1f, 0x14, 0x14, 0x14, 0x1f, 0x00, 0x10, 0x10, 0x10, 0xf0, 0x00,
+    0x00, 0x00, 0x00, 0x1f, 0x10, 0x10, 0x10, 0x10, 0x1f, 0x10, 0x10, 0x10, 0x10, 0xf0, 0x10, 0x00,
+    0x00, 0x00, 0xff, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0xff, 0x10, 0x00, 0x00,
+    0x00, 0xff, 0x14, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x1f, 0x10, 0x17, 0x00, 0x00, 0xfc,
+    0x04, 0xf4, 0x14, 0x14, 0x17, 0x10, 0x17, 0x14, 0x14, 0xf4, 0x04, 0xf4, 0x00, 0x00, 0xff, 0x00,
+    0xf7, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0xf7, 0x00, 0xf7, 0x14, 0x14, 0x14, 0x17, 0x14,
+    0x10, 0x10, 0x1f, 0x10, 0x1f, 0x14, 0x14, 0x14, 0xf4, 0x14, 0x10, 0x10, 0xf0, 0x10, 0xf0, 0x00,
+    0x00, 0x1f, 0x10, 0x1f, 0x00, 0x00, 0x00, 0x1f, 0x14, 0x00, 0x00, 0x00, 0xfc, 0x14, 0x00, 0x00,
+    0xf0, 0x10, 0xf0, 0x10, 0x10, 0xff, 0x10, 0xff, 0x14, 0x14, 0x14, 0xff, 0x14, 0x10, 0x10, 0x10,
+    0x1f, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x10, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0xf0, 0xf0, 0xf0,
+    0xf0, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
+    0x38, 0x44, 0x44, 0x38, 0x44, 0xfc, 0x4a, 0x4a, 0x4a, 0x34, 0x7e, 0x02, 0x02, 0x06, 0x06, 0x02,
+    0x7e, 0x02, 0x7e, 0x02, 0x63, 0x55, 0x49, 0x41, 0x63, 0x38, 0x44, 0x44, 0x3c, 0x04, 0x40, 0x7e,
+    0x20, 0x1e, 0x20, 0x06, 0x02, 0x7e, 0x02, 0x02, 0x99, 0xa5, 0xe7, 0xa5, 0x99, 0x1c, 0x2a, 0x49,
+    0x2a, 0x1c, 0x4c, 0x72, 0x01, 0x72, 0x4c, 0x30, 0x4a, 0x4d, 0x4d, 0x30, 0x30, 0x48, 0x78, 0x48,
+    0x30, 0xbc, 0x62, 0x5a, 0x46, 0x3d, 0x3e, 0x49, 0x49, 0x49, 0x00, 0x7e, 0x01, 0x01, 0x01, 0x7e,
+    0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x44, 0x44, 0x5f, 0x44, 0x44, 0x40, 0x51, 0x4a, 0x44, 0x40, 0x40,
+    0x44, 0x4a, 0x51, 0x40, 0x00, 0x00, 0xff, 0x01, 0x03, 0xe0, 0x80, 0xff, 0x00, 0x00, 0x08, 0x08,
+    0x6b, 0x6b, 0x08, 0x36, 0x12, 0x36, 0x24, 0x36, 0x06, 0x0f, 0x09, 0x0f, 0x06, 0x00, 0x00, 0x18,
+    0x18, 0x00, 0x00, 0x00, 0x10, 0x10, 0x00, 0x30, 0x40, 0xff, 0x01, 0x01, 0x00, 0x1f, 0x01, 0x01,
+    0x1e, 0x00, 0x19, 0x1d, 0x17, 0x12, 0x00, 0x3c, 0x3c, 0x3c, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00,
+];
+/**
+ * Render the font as a C++ byte-array literal (16 bytes per line). Used by
+ * adapters that need the table emitted into the synthesized translation unit.
+ *
+ * Example output:
+ *   static const uint8_t glcdfont[] = {
+ *     0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x5b, 0x4f, 0x5b, 0x3e, ...
+ *     ...
+ *   };
+ */
+export function renderGlcdfontArray(name, type = "uint8_t") {
+    const lines = [];
+    for (let i = 0; i < GLCDFONT_BYTES.length; i += 16) {
+        const row = GLCDFONT_BYTES.slice(i, i + 16)
+            .map((b) => "0x" + b.toString(16).padStart(2, "0"))
+            .join(", ");
+        lines.push(`  ${row},`);
+    }
+    return `static const ${type} ${name}[] = {\n${lines.join("\n")}\n};`;
+}

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

@@ -1,4 +1,6 @@
 import type { DisplayHALOp } from "./display-op-ir.js";
+import type { DisplayProfile, ResolvedDisplay, TouchProfile, TouchAdapterCodegen } from "./display-profile.js";
+import type { DisplayAdapterCode } from "./display-adapter.js";
 export interface GraphicsCapacity {
     /** Max nodes the retained tree may hold on this target. */
     maxNodes: number;
@@ -15,6 +17,41 @@ export interface PlatformGraphicsStrategy {
         code?: string;
         expression?: string;
     } | undefined;
+    /**
+     * True if this strategy emits its own display adapters (e.g. framework-arduino
+     * owns the Adafruit_GFX drivers, framework-native owns SDL). When false or
+     * undefined, generateDisplayAdapter() falls back to cuttlefish's generic
+     * built-in adapter registry.
+     */
+    providesDisplayAdapter?(): boolean;
+    /**
+     * Returns the adapter code for one display, or undefined to defer to cuttlefish's
+     * built-in adapter registry. Only called when providesDisplayAdapter()
+     * returns true.
+     */
+    resolveDisplayAdapter?(display: ResolvedDisplay): DisplayAdapterCode | undefined;
+    /**
+     * True if this strategy emits its own touch adapters (ESP32 native). When
+     * false or undefined, generateTouchAdapter() falls back to the built-in
+     * library switch (the Arduino path, unchanged).
+     */
+    providesTouchAdapter?(): boolean;
+    /**
+     * Returns the touch adapter codegen for the given touch profile, or
+     * undefined to defer to the built-in library switch. Only called when
+     * providesTouchAdapter() returns true. Returning undefined for an
+     * unsupported library (e.g. XPT2046 on native IDF) lets the dispatch
+     * surface a clear compile-time error instead of emitting incompatible code.
+     */
+    resolveTouchAdapter?(touch: TouchProfile): TouchAdapterCodegen | undefined;
+    /**
+     * Optional hook returning this framework's named display-profile registry
+     * (profile name → DisplayProfile). When present, transpile.ts consults it to
+     * resolve `display.profile` config values instead of dynamically importing a
+     * framework module — so profile names resolve correctly per-framework.
+     * Returns undefined to fall back to the legacy dynamic-import path.
+     */
+    getProfileRegistry?(): Map<string, DisplayProfile>;
     /** Display driver ids this framework provides (e.g. new Set(["ili9341"])). */
     supportedDisplayDrivers(): ReadonlySet<string>;
     /** Target color format — drives transpile-time color resolution.