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

package/dist/types.d.ts

@@ -1,5 +1,6 @@
 import type { TargetProfile as CoreTargetProfile, PlatformContext as CorePlatformContext, SourceSpan as CoreSourceSpan, Diagnostic as CoreDiagnostic } from "./api/shared/index.js";
 export type EmitMode = "cpp" | "split";
+export type ComplianceMode = "off" | "warn" | "strict";
 export type TargetProfile = CoreTargetProfile;
 export type PlatformContext = CorePlatformContext;
 export type SourceSpan = CoreSourceSpan;
@@ -95,6 +96,10 @@ export interface TranspileOptions {
     diagnostics?: boolean;
     /** Display profile config from cuttlefish.config.ts */
     display?: import("./api/shared/display-profile.js").DisplayConfig;
+    /** AUTOSAR C++14 compliance mode for emitted code (default: "off"). */
+    autosar?: ComplianceMode;
+    /** When true (and autosar is warn/strict), also emit the .autosar-deviations.arxml sidecar. */
+    autosarArxml?: boolean;
 }
 export interface LibraryDefinitionCondition {
     target?: TargetProfile;
@@ -114,7 +119,11 @@ export interface LibraryDefinition {
     variants?: LibraryDefinitionVariant[];
 }
 export interface CommandLineOptions {
-    command: "default" | "build" | "gen-libdefs" | "gen-decls" | "map-error" | "preview";
+    command: "default" | "build" | "gen-libdefs" | "gen-decls" | "map-error" | "preview" | "doctor" | "licenses";
+    /** For `licenses`: treat unknown/missing licenses as failures (exit 1). */
+    strict?: boolean;
+    /** For `licenses`: scan all installed libraries (default: this project's only). */
+    all?: boolean;
     inputFile?: string;
     emitMode: EmitMode;
     target: TargetProfile;
@@ -130,8 +139,10 @@ export interface CommandLineOptions {
     monitor: boolean;
     /** Serial port for upload and monitor (e.g. COM4 or /dev/ttyACM0) */
     port?: string;
-    /** Baud rate for monitor (default: 9600) */
-    baud: number;
+    /** Baud rate for monitor. Undefined when --baud is absent so the consumer
+     *  can fall back to config.console.baudRate (the framework monitor default
+     *  applies only when neither is set). */
+    baud?: number;
     platformContext?: PlatformContext;
     mapFile?: string;
     cppFile?: string;
@@ -164,6 +175,10 @@ export interface CommandLineOptions {
     expectFile?: string;
     /** Generate diagnostics.md and diagnostics.json reports */
     diagnostics?: boolean;
+    /** AUTOSAR C++14 compliance mode for emitted code (default: "off"). */
+    autosar?: ComplianceMode;
+    /** When true (and autosar is warn/strict), also emit the .autosar-deviations.arxml sidecar. */
+    autosarArxml?: boolean;
     /** Config file for preview command */
     configPath?: string;
     /** Project root (dir of cuttlefish.config.ts); passed to transpileFile for the ESLint gate. */
@@ -181,6 +196,8 @@ export interface GeneratedOutputs {
     diagnostics: Diagnostic[];
     asyncTaskNames?: string[];
     usesTimers?: boolean;
+    /** Path to the diagnostics.md report, if --diagnostics was passed. */
+    diagnosticsReportPath?: string;
 }
 interface CompileErrorEntry {
     filePath: string;
@@ -208,6 +225,8 @@ export interface CreateCommandOptions {
     baud?: number;
     noSketch?: boolean;
     outDir?: string;
+    /** Skip the automatic `npm install` in the scaffolded project. */
+    noInstall?: boolean;
 }
 export interface BoardAddCommandOptions {
     command: "board-add";

package/dist/ui-hook.d.ts

@@ -9,7 +9,6 @@ export interface LoweredUI {
     screenCount: number;
     imageTables: string;
     keyframeTables: string;
-    scrollMemoryDiagnostics: Diagnostic[];
     diagnostics: Diagnostic[];
 }
 export interface UIModule {
@@ -58,7 +57,23 @@ export interface TranspilerUIHook {
     lowerOnMount(htmlPath: string, opts: LowerOptions): LoweredUI;
     resolveColor(input: string, format: "rgb565" | "rgb666" | "rgb888" | "mono"): number;
     resolveColorInternal(input: string, format: "rgb565" | "rgb666" | "rgb888" | "mono"): number;
-    emitRuntimeHeader(): string;
+    /**
+     * Emits ONLY the CuttlefishGFX class definition (the shared GFX base for
+     * native display paths). Called separately from emitRuntimeHeader so the
+     * class can be emitted BEFORE display adapter declarations that
+     * instantiate CuttlefishGFX by value. Returns "" when active is false
+     * (Arduino path).
+     */
+    emitCuttlefishGfx(active: boolean): string;
+    /**
+     * Options controlling runtime-header emission.
+     *   - nativeDisplayActive: when true, emit the shared CuttlefishGFX class
+     *     (used by native display adapters on AVR/ESP32). Arduino paths pass
+     *     false (default) and use Adafruit_GFX directly.
+     */
+    emitRuntimeHeader(opts?: {
+        nativeDisplayActive?: boolean;
+    }): string;
     splitUiFile(src: string): UiFileParts;
     generateProjectUITypeDeclarations(projectRoot: string): {
         written: string[];
@@ -67,7 +82,6 @@ export interface TranspilerUIHook {
             error: Error;
         }>;
     };
-    analyzeScrollMemory(styled: unknown, budget: number): Diagnostic[];
 }
 /** Set the UI hook. Called by transpile.ts after dynamically loading
  *  @typecad/ui/engine. Passing null clears it (end of transpile run). */

package/dist/utils/cli.js

@@ -17,6 +17,8 @@ export function printHelp() {
     console.log(`  cuttlefish board add <spec.jsonc> [--force]   Generate board + MCU packages from a chip spec`);
     console.log(`  cuttlefish gen-decls <input.cpp|--all <directory>>`);
     console.log(`  cuttlefish map-error <mapFile> [options]`);
+    console.log(`  cuttlefish doctor                              Check the active framework's environment (e.g. toolchain + board core)`);
+    console.log(`  cuttlefish licenses [--all] [--strict]          Scan this project's Arduino libraries for SPDX licenses (--all: every installed library)`);
     console.log();
     console.log(chalk.gray(`Transpilation is always performed first. Use --compile, --upload, and`));
     console.log(chalk.gray(`--monitor to chain operations after transpilation.`));
@@ -37,6 +39,16 @@ export function printHelp() {
     console.log(`  --emit-maps <bool>      Emit source maps: "true" or "false" (default: true)`);
     console.log(`                          Source maps enable mapping C++ errors back to TypeScript`);
     console.log();
+    console.log(`  --autosar[=<mode>]      AUTOSAR C++14 compliance mode for emitted code:`);
+    console.log(`                            off     no enforcement (default)`);
+    console.log(`                            warn    emit AUTOSAR_* diagnostics + sidecar, build still succeeds`);
+    console.log(`                            strict  abort emit on unrecorded required violations`);
+    console.log(`                          A sidecar <name>.autosar-deviations.json is written next to the`);
+    console.log(`                          emitted artifact in warn/strict modes. See COMPLIANCE.md.`);
+    console.log();
+    console.log(`  --autosar-arxml         Also write <name>.autosar-deviations.arxml (Artop/DaVinci).`);
+    console.log(`                          No-op unless --autosar is warn or strict.`);
+    console.log();
     console.log(chalk.cyan(`BUILD COMMANDS`) + chalk.gray(` (chain in order: --compile → --upload → --monitor)`));
     console.log();
     console.log(`  --compile               Compile the generated output using the framework toolchain.`);
@@ -102,6 +114,12 @@ export function printHelp() {
     console.log(`  --diagnostics           Generate diagnostics.md and diagnostics.json reports`);
     console.log(`                          Includes IR graph, heap analysis, and task analysis`);
     console.log();
+    console.log(`  --debug                 Inject Serial.println instrumentation at breakpoints.`);
+    console.log(`                          Reads .cuttlefish/breakpoints.json (written by the`);
+    console.log(`                          TypeCAD Debug VS Code extension). At each breakpoint the`);
+    console.log(`                          firmware prints the location, original line, and in-scope`);
+    console.log(`                          variables, then halts — press ENTER over serial to continue.`);
+    console.log();
     console.log(`  --help, -h              Show this help message`);
     console.log();
     console.log(chalk.cyan(`PROJECT CREATION`));
@@ -209,7 +227,11 @@ function parsePipelineCommand(argv, command, inputFile) {
     const emitMapsFlag = readFirstFlagValue(argv, ["--emit-maps"]);
     const buildTarget = readFirstFlagValue(argv, ["--build-target"]);
     const port = readFirstFlagValue(argv, ["--port"]);
-    const baud = readNumberFlag(argv, ["--baud"], 9600) ?? 9600;
+    // Default to undefined (NOT 9600) so the build/upload/monitor flow's
+    // `options.baud ?? config.console.baudRate` falls through to the configured
+    // baud. Hardcoding 9600 here shadowed config.console.baudRate whenever --baud
+    // was absent (the monitor then opened the port at 9600, ignoring the config).
+    const baud = readNumberFlag(argv, ["--baud"]);
     const frameworkFlag = readFirstFlagValue(argv, ["--framework"]);
     const compile = readBooleanFlag(argv, ["--compile"]);
     const upload = readBooleanFlag(argv, ["--upload"]);
@@ -229,6 +251,32 @@ function parsePipelineCommand(argv, command, inputFile) {
     const keepUnusedTypes = readBooleanFlag(argv, ["--keep-unused-types"]);
     const keepUnusedVariables = readBooleanFlag(argv, ["--keep-unused-variables"]);
     const entryPoints = readRepeatedFlag(argv, "--entry-point");
+    // AUTOSAR C++14 compliance mode for emitted code. Accepts both
+    // `--autosar=strict` (= syntax) and `--autosar strict` (space syntax),
+    // plus the bare `--autosar` (treated as "strict"). Defaults to undefined,
+    // which the emitter treats as "off".
+    let autosar;
+    const autosarFlagIdx = argv.findIndex((a) => a === "--autosar" || a.startsWith("--autosar="));
+    if (autosarFlagIdx !== -1) {
+        const raw = argv[autosarFlagIdx];
+        if (raw === "--autosar") {
+            // Bare flag → strict. (No following value consumed.)
+            autosar = "strict";
+        }
+        else {
+            // --autosar=<mode>
+            const value = raw.slice("--autosar=".length);
+            if (value === "strict" || value === "warn" || value === "off") {
+                autosar = value;
+            }
+            else {
+                throw new Error(`--autosar must be one of: strict, warn, off (got: ${value})`);
+            }
+        }
+    }
+    // --autosar-arxml: also write the .autosar-deviations.arxml sidecar
+    // (Artop/DaVinci tooling). No-op unless --autosar is warn or strict.
+    const autosarArxml = readBooleanFlag(argv, ["--autosar-arxml"]);
     const emitMode = emitFlag === "cpp" || emitFlag === "split" ? emitFlag : "split";
     const emitMaps = emitMapsFlag === undefined ? true : emitMapsFlag !== "false";
     // Accept any target string — the framework package registers its own strategy id.
@@ -279,6 +327,8 @@ function parsePipelineCommand(argv, command, inputFile) {
         expect,
         expectFile,
         frameworkPackage: frameworkFlag,
+        autosar,
+        autosarArxml,
     };
 }
 export function parseCommandLine(argv) {
@@ -296,6 +346,7 @@ export function parseCommandLine(argv) {
         const baudRaw = readFirstFlagValue(argv, ["--baud"]);
         const outDir = readFirstFlagValue(argv, ["--outDir", "--out-dir", "-o"]);
         const noSketch = argv.includes("--no-sketch");
+        const noInstall = argv.includes("--no-install");
         const baud = baudRaw && !Number.isNaN(Number(baudRaw)) ? Number(baudRaw) : undefined;
         return {
             command: "create",
@@ -304,6 +355,7 @@ export function parseCommandLine(argv) {
             baud,
             framework,
             noSketch,
+            noInstall,
             outDir: outDir ? path.resolve(process.cwd(), outDir) : undefined,
         };
     }
@@ -337,6 +389,48 @@ export function parseCommandLine(argv) {
             port: port ? String(port) : undefined,
         };
     }
+    // doctor subcommand — verify the active framework's environment
+    if (firstArg === "doctor") {
+        return {
+            command: "doctor",
+            // The remaining pipeline fields are unused by doctor; fill with safe
+            // defaults, the same way the preview branch does.
+            inputFile: undefined,
+            emitMode: "split",
+            target: "generic",
+            outDir: undefined,
+            emitMaps: true,
+            noTranspile: false,
+            compile: false,
+            upload: false,
+            monitor: false,
+            watch: false,
+            baud: 9600,
+            platformContext: {},
+        };
+    }
+    // licenses subcommand — scan installed Arduino libraries for SPDX licenses
+    if (firstArg === "licenses") {
+        return {
+            command: "licenses",
+            strict: argv.includes("--strict"),
+            all: argv.includes("--all"),
+            // The remaining pipeline fields are unused by licenses; fill with safe
+            // defaults, the same way the doctor branch does.
+            inputFile: undefined,
+            emitMode: "split",
+            target: "generic",
+            outDir: undefined,
+            emitMaps: true,
+            noTranspile: false,
+            compile: false,
+            upload: false,
+            monitor: false,
+            watch: false,
+            baud: 9600,
+            platformContext: {},
+        };
+    }
     // Named subcommands
     if (firstArg === "gen-libdefs" || firstArg === "gen-decls" || firstArg === "map-error") {
         const command = firstArg;
@@ -387,12 +481,16 @@ export function parseCommandLine(argv) {
         // gen-decls - generate .d.ts from C++ files
         if (command === "gen-decls") {
             const allFlag = argv.includes("--all");
+            const componentsFlag = argv.includes("--components");
+            if (allFlag && componentsFlag) {
+                throw new Error("gen-decls: --components and --all are mutually exclusive. Use one or the other.");
+            }
             // The positional path may sit at argv[3] or argv[4] depending on whether
             // --all precedes or follows it. Scan argv starting after the subcommand
             // name (argv[2]) for the first token that is not a flag and not a known
             // flag's value. This mirrors the default-pipeline approach of "first
             // non-flag token wins".
-            const booleanFlags = new Set(["--all"]);
+            const booleanFlags = new Set(["--all", "--components"]);
             const valueFlags = new Set([
                 "--emit", "--target", "--outDir", "--out-dir", "--emit-maps", "--build-target",
             ]);
@@ -413,6 +511,28 @@ export function parseCommandLine(argv) {
                 inputPath = tok;
                 break;
             }
+            // --components mode: scan managed_components/ + components/ declared in
+            // cuttlefish.config.ts. Falls back to cwd when no path is given.
+            if (componentsFlag) {
+                const componentsDir = inputPath || process.cwd();
+                return {
+                    command: "gen-decls",
+                    inputFile: undefined,
+                    emitMode,
+                    target,
+                    outDir: outDir ? path.resolve(process.cwd(), outDir) : undefined,
+                    emitMaps,
+                    noTranspile: false,
+                    compile: false,
+                    upload: false,
+                    monitor: false,
+                    watch: false,
+                    baud: 9600,
+                    platformContext,
+                    scanDir: undefined,
+                    componentsDir: path.resolve(process.cwd(), componentsDir),
+                };
+            }
             if (!inputPath && !allFlag) {
                 throw new Error("Missing input C++ file path. Use: gen-decls <file.cpp> or gen-decls --all <directory>");
             }

package/dist/utils/fs.d.ts

@@ -2,3 +2,16 @@ export declare function ensureDir(dirPath: string): void;
 export declare function readText(filePath: string): string;
 export declare function writeText(filePath: string, content: string): void;
 export declare function listFiles(dirPath: string, extension: string): string[];
+/**
+ * Recursive variant of {@link listFiles}. Walks `dirPath` depth-first and
+ * returns every file (in every subdirectory) whose name ends with `extension`.
+ *
+ * Used by {@link loadLibraryDefinitions} so libdefs under nested cache dirs
+ * like `.cuttlefish/component-decls/<component>/` are discovered. Purely
+ * additive vs. the non-recursive `listFiles` — single-level layouts keep
+ * working, nested layouts now also work.
+ *
+ * Returns absolute paths. Unreadable directories are silently skipped
+ * (matches `listFiles`'s not-exist behavior for non-existent roots).
+ */
+export declare function listFilesRecursive(dirPath: string, extension: string): string[];

package/dist/utils/fs.js

@@ -10,6 +10,15 @@ export function readText(filePath) {
 }
 export function writeText(filePath, content) {
     ensureDir(path.dirname(filePath));
+    // Skip writing when content is identical — preserves mtime so downstream
+    // build tools (idf.py/ninja, arduino-cli, make) can skip recompilation.
+    try {
+        if (fs.readFileSync(filePath, "utf8") === content)
+            return;
+    }
+    catch {
+        // File doesn't exist yet — fall through to write.
+    }
     fs.writeFileSync(filePath, content, "utf8");
 }
 export function listFiles(dirPath, extension) {
@@ -21,3 +30,44 @@ export function listFiles(dirPath, extension) {
         .filter((name) => name.toLowerCase().endsWith(extension.toLowerCase()))
         .map((name) => path.join(dirPath, name));
 }
+/**
+ * Recursive variant of {@link listFiles}. Walks `dirPath` depth-first and
+ * returns every file (in every subdirectory) whose name ends with `extension`.
+ *
+ * Used by {@link loadLibraryDefinitions} so libdefs under nested cache dirs
+ * like `.cuttlefish/component-decls/<component>/` are discovered. Purely
+ * additive vs. the non-recursive `listFiles` — single-level layouts keep
+ * working, nested layouts now also work.
+ *
+ * Returns absolute paths. Unreadable directories are silently skipped
+ * (matches `listFiles`'s not-exist behavior for non-existent roots).
+ */
+export function listFilesRecursive(dirPath, extension) {
+    if (!fs.existsSync(dirPath)) {
+        return [];
+    }
+    const ext = extension.toLowerCase();
+    const out = [];
+    const stack = [dirPath];
+    while (stack.length > 0) {
+        const cur = stack.pop();
+        let entries;
+        try {
+            entries = fs.readdirSync(cur, { withFileTypes: true });
+        }
+        catch {
+            // Permission error / race / etc. Skip this subtree.
+            continue;
+        }
+        for (const entry of entries) {
+            const full = path.join(cur, entry.name);
+            if (entry.isDirectory()) {
+                stack.push(full);
+            }
+            else if (entry.isFile() && entry.name.toLowerCase().endsWith(ext)) {
+                out.push(full);
+            }
+        }
+    }
+    return out;
+}

package/dist/utils/ui.js

@@ -86,7 +86,9 @@ export function printMonitoring(port, baud) {
  * Print success message
  */
 export function printSuccess(message = "Done") {
-    console.log(chalk.green(`${ICON_SUCCESS} ${message}`));
+    // Cyan (not green) so the completion marker matches the cyan step indicators
+    // (⇉ Compiling / Uploading / Transpiling). The ✓ icon conveys success.
+    console.log(chalk.cyan(`${ICON_SUCCESS} ${message}`));
 }
 /**
  * Print error message

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typecad/cuttlefish",
-  "version": "0.1.0-alpha.2",
+  "version": "1.0.0-alpha.10",
   "description": "TypeScript to C++ transpiler — native, Arduino, and bare-metal targets",
   "type": "module",
   "main": "./dist/transpile.js",
@@ -29,10 +29,22 @@
       "types": "./dist/ui-hook.d.ts",
       "default": "./dist/ui-hook.js"
     },
+    "./safety-hook-types": {
+      "types": "./dist/safety-hook.d.ts",
+      "default": "./dist/safety-hook.js"
+    },
+    "./build-ir-state": {
+      "types": "./dist/ir/build-ir-state.d.ts",
+      "default": "./dist/ir/build-ir-state.js"
+    },
     "./config-loader": {
       "types": "./dist/config-loader.d.ts",
       "default": "./dist/config-loader.js"
     },
+    "./utils/ui": {
+      "types": "./dist/utils/ui.d.ts",
+      "default": "./dist/utils/ui.js"
+    },
     "./stores/display-profile-store": {
       "types": "./dist/stores/display-profile-store.d.ts",
       "default": "./dist/stores/display-profile-store.js"
@@ -49,6 +61,10 @@
       "types": "./dist/emit/route-hal-op.d.ts",
       "default": "./dist/emit/route-hal-op.js"
     },
+    "./lib/component-decls": {
+      "types": "./dist/libdef/component-decls.d.ts",
+      "default": "./dist/libdef/component-decls.js"
+    },
     "./ir/transformers/ui-lowering": {
       "types": "./dist/ir/transformers/ui-lowering.d.ts",
       "default": "./dist/ir/transformers/ui-lowering.js"
@@ -83,15 +99,19 @@
     "zod": "^3.24.0"
   },
   "peerDependencies": {
-    "@typecad/ui": "0.1.0-alpha.2"
+    "@typecad/ui": "1.0.0-alpha.10",
+    "@typecad/safety": "1.0.0-alpha.10"
   },
   "peerDependenciesMeta": {
     "@typecad/ui": {
       "optional": true
+    },
+    "@typecad/safety": {
+      "optional": true
     }
   },
   "optionalDependencies": {
-    "@typecad/framework-native": "0.1.0-alpha.2"
+    "@typecad/framework-native": "1.0.0-alpha.10"
   },
   "devDependencies": {
     "@types/node": "^22.10.7"

package/dist/api/shared/display-adapters/eink-mono.d.ts

@@ -1,2 +0,0 @@
-import type { DisplayAdapterGenerator } from "../display-adapter.js";
-export declare const einkMonoAdapter: DisplayAdapterGenerator;

package/dist/api/shared/display-adapters/eink-mono.js

@@ -1,53 +0,0 @@
-// ---------------------------------------------------------------------------
-// eink-mono display adapter — 1-bit B&W e-ink panels (SSD1680-class, e.g. the
-// common 296×128 / 250×122 breakouts). Deferred refresh: no fillScreen on init
-// (a full clear flashes), and a partial-refresh entry point the runtime's dirty-
-// rect union calls once per frame.
-//
-// Library note: targets Adafruit_EPD (Adafruit_SSD168x). The exact partial-
-// refresh method name varies by library (Adafruit_EPD: refreshPartial / GxEPD:
-// updateWindow). Verify against the target library before flashing — the shim
-// shape is correct; the method call is library-specific. TODO Phase 5.
-// ---------------------------------------------------------------------------
-export const einkMonoAdapter = (display) => {
-    const cs = display._mountCs;
-    const dc = display._mountDc;
-    const rst = display._mountRst;
-    const rotation = display.rotation ?? 0;
-    const w = display.width;
-    const h = display.height;
-    return {
-        includes: [
-            "#include <Adafruit_GFX.h>",
-            "#include <Adafruit_EPD.h>",
-        ].join("\n"),
-        // busy pin = -1 (unused); SRCS+D/C+RST+CS wiring. Adafruit_SSD168x(width, height, dc, rst, cs, busy).
-        declaration: `Adafruit_SSD168x __tc_display(${w}, ${h}, ${dc}, ${rst}, ${cs}, -1);`,
-        functions: [
-            "// --- Display adapter: eink-mono (SSD1680-class, 1-bit, deferred refresh) ---",
-            "static inline void display_init() {",
-            "  __tc_display.begin();",
-            `  __tc_display.setRotation(${rotation});`,
-            "  // No full-screen clear here — e-ink flashes on a full clear. The runtime",
-            "  // marks all nodes dirty (UI_REFRESH_DEFERRED) and the first flush repaints",
-            "  // via partial refresh instead.",
-            "}",
-            "",
-            "static inline CuttlefishDisplayTarget* display_defaultTarget() { return &__tc_display; }",
-            "static inline int16_t display_width() { return __tc_display.width(); }",
-            "static inline int16_t display_height() { return __tc_display.height(); }",
-            "static inline void display_startWrite() {}",
-            "static inline void display_endWrite() {}",
-            "static inline void display_setAddrWindow(int16_t x, int16_t y, int16_t w, int16_t h) { (void)x; (void)y; (void)w; (void)h; }",
-            // Partial refresh: push just the dirty region. The runtime draws into the
-            // EPD's built-in GFX buffer (the display IS the backing store for 1-bit),
-            // then calls this with the unioned dirty rect. TODO Phase 5: verify the
-            // exact partial-refresh API for the target EPD library.
-            "static inline void display_partial_refresh(int16_t x, int16_t y, int16_t w, int16_t h) {",
-            "  __tc_display.refreshPartial(x, y, (uint16_t)w, (uint16_t)h);",
-            "}",
-            // drawPixel goes through GFX into the EPD buffer; partial_refresh publishes it.
-            "static inline void display_fillScreen(uint32_t color) { __tc_display.fillScreen(color ? EPD_WHITE : EPD_BLACK); }",
-        ].join("\n"),
-    };
-};

package/dist/api/shared/display-adapters/ssd1309.d.ts

@@ -1,2 +0,0 @@
-import type { DisplayAdapterGenerator } from "../display-adapter.js";
-export declare const ssd1309Adapter: DisplayAdapterGenerator;