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

package/dist/platform/generic-strategy.js

@@ -42,10 +42,14 @@ export class GenericStrategy {
     // ── Type normalisation ──────────────────────────────────────────────────
     normalizeCppType(typeName) {
         if (typeName === "auto")
-            return "int";
+            return this.defaultNumericType();
         return typeName;
     }
-    defaultNumericType() { return "int"; }
+    defaultNumericType(compliance) {
+        // A3-9-1: fixed-width integers under AUTOSAR. Legacy 'int' spelling
+        // preserved when autosar is off so default output is byte-identical.
+        return compliance?.isBanned("A3-9-1") ? "int32_t" : "int";
+    }
     mapReturnType(_functionName, returnType) {
         return this.normalizeCppType(returnType);
     }
@@ -185,17 +189,23 @@ export class GenericStrategy {
             helpers.push(asyncRuntime);
         return helpers;
     }
-    asyncLoopInjection(_taskVarNames, configOrBool) {
+    asyncLoopInjection(taskVarNames, configOrBool) {
         let hasPromiseRuntime;
-        if (typeof configOrBool === 'boolean') {
+        if (typeof configOrBool === "boolean") {
             hasPromiseRuntime = configOrBool;
         }
         else {
             hasPromiseRuntime = configOrBool.hasPromiseRuntime;
         }
+        // Drive every async state-machine task once per driver-function iteration.
+        // Task globals auto-start on their first .run() (STATE_0 runs
+        // unconditionally); the state machine no-ops in its terminal/cyclic state.
         const lines = [];
         if (hasPromiseRuntime)
             lines.push("  cuttlefish_pump_microtasks();");
+        for (const n of taskVarNames) {
+            lines.push(`  ${n}.run();`);
+        }
         return lines;
     }
     asyncDriverFunctionName() { return "main"; }
@@ -213,6 +223,9 @@ export class GenericStrategy {
     enumApiGuard(_enumName) { return undefined; }
     getStdLibSupport(_architecture) { return DEFAULT_STDLIB_SUPPORT; }
     // ── Debug code generation ─────────────────────────────────────────────────
+    debugMode(_target) {
+        return 'printf';
+    }
     generateDebugInitCode() {
         return [
             '// === DEBUG: Initialize ===',
@@ -286,4 +299,36 @@ export class GenericStrategy {
             nodeStorage: "flash",
         };
     }
+    // ── HAL (generic fallback) ──────────────────────────────────────────────
+    // The generic/host target has no GPIO or timing hardware. These return
+    // documented no-op stubs so emit stays deterministic rather than throwing
+    // mid-codegen. Host tests that exercise pin-polling paths use a mock
+    // PlatformStrategy (see tests/packages/cuttlefish/async-runtime-static.test.ts).
+    readDigitalPin(_pin) {
+        return "/* gpio unavailable on generic target */ 0";
+    }
+    readAnalogPin(_pin) {
+        return "/* adc unavailable on generic target */ 0";
+    }
+    writeDigitalPin(_pin, _val) {
+        return "/* gpio unavailable on generic target */";
+    }
+    setPinMode(_pin, _mode) {
+        return "/* gpio unavailable on generic target */";
+    }
+    delayMs(_ms) {
+        return "/* delay unavailable on generic target */";
+    }
+    delayMicroseconds(_us) {
+        return "/* delay unavailable on generic target */";
+    }
+    halCallNames() {
+        return new Set();
+    }
+    isHalCall(_name) {
+        return false;
+    }
+    analogReadCallNames() {
+        return new Set();
+    }
 }

package/dist/safety/safety-bridge.d.ts

@@ -0,0 +1,11 @@
+/** Dynamically load @typecad/safety/engine and register the hook.
+ *  Called by transpile.ts at the start of each transpile run.
+ *  Safe to call when @typecad/safety is absent (hook stays null). */
+export declare function loadSafetyEngine(): Promise<void>;
+/** Reset the safety bridge: forget a load was attempted and clear the hook.
+ *  Mirrors resetUIEngine() so each transpile run / test starts clean. */
+export declare function resetSafetyEngine(): void;
+/** Test-only: force the bridge into the "no @typecad/safety" state — mark the
+ *  load as already attempted and leave the hook null, exactly as if the
+ *  dynamic import had failed because the package is not installed. */
+export declare function __simulateSafetyAbsentForTest(): void;

package/dist/safety/safety-bridge.js

@@ -0,0 +1,48 @@
+// ---------------------------------------------------------------------------
+// Safety bridge — loads the safety engine from @typecad/safety and registers it.
+//
+// transpile.ts calls loadSafetyEngine() at the start of transpileFile(). If
+// @typecad/safety is not installed, the import fails gracefully and the hook
+// stays null — cuttlefish works as a pure TS→C++ transpiler with no safety
+// support.
+// ---------------------------------------------------------------------------
+import { setSafetyHook } from "../safety-hook.js";
+let loaded = false;
+/** Dynamically load @typecad/safety/engine and register the hook.
+ *  Called by transpile.ts at the start of each transpile run.
+ *  Safe to call when @typecad/safety is absent (hook stays null). */
+export async function loadSafetyEngine() {
+    if (loaded)
+        return;
+    loaded = true;
+    try {
+        // Dynamic import — @typecad/safety is optional. The module specifier is
+        // routed through a variable (rather than a string literal) so tsc types
+        // the result as `any` and never resolves @typecad/safety's declaration
+        // files while type-checking this file. A literal specifier would make tsc
+        // load safety's dist/engine-index.d.ts, which imports back
+        // @typecad/cuttlefish/safety-hook-types — a self-referencing package path
+        // that resolves into this package's own dist/ output and causes TS5055
+        // ("would overwrite input file") on every rebuild where dist/ exists.
+        const safetyEnginePath = "@typecad/safety/engine";
+        const engine = await import(safetyEnginePath);
+        const hook = engine.registerSafetyEngine();
+        setSafetyHook(hook);
+    }
+    catch {
+        // @typecad/safety is not installed — cuttlefish works without safety.
+    }
+}
+/** Reset the safety bridge: forget a load was attempted and clear the hook.
+ *  Mirrors resetUIEngine() so each transpile run / test starts clean. */
+export function resetSafetyEngine() {
+    loaded = false;
+    setSafetyHook(null);
+}
+/** Test-only: force the bridge into the "no @typecad/safety" state — mark the
+ *  load as already attempted and leave the hook null, exactly as if the
+ *  dynamic import had failed because the package is not installed. */
+export function __simulateSafetyAbsentForTest() {
+    loaded = true;
+    setSafetyHook(null);
+}

package/dist/safety/sidecar-bridge.d.ts

@@ -0,0 +1,5 @@
+import type { SafetyMetadata } from "../safety-hook.js";
+/** Dynamically import the safety package's sidecar renderer.
+ *  Uses a variable-held specifier so tsc doesn't try to resolve the
+ *  @typecad/safety types at build time (avoids circular dependency). */
+export declare function renderSafetySidecar(metadata: SafetyMetadata, toolVersion: string): Promise<string>;

package/dist/safety/sidecar-bridge.js

@@ -0,0 +1,22 @@
+/** Dynamically import the safety package's sidecar renderer.
+ *  Uses a variable-held specifier so tsc doesn't try to resolve the
+ *  @typecad/safety types at build time (avoids circular dependency). */
+export async function renderSafetySidecar(metadata, toolVersion) {
+    const spec = "@typecad/safety/iso26262/sidecar-writer";
+    try {
+        const mod = await import(spec);
+        return mod.renderSafetySidecar(metadata, toolVersion);
+    }
+    catch {
+        // Fallback: inline the renderer so the sidecar is produced even if
+        // the subpath export isn't configured.
+        return JSON.stringify({
+            schemaVersion: "1.0.0",
+            standard: "ISO 26262 Part 6",
+            tool: "cuttlefish (@typecad/safety)",
+            toolVersion,
+            generatedAt: new Date().toISOString(),
+            safetyFunctions: metadata.functions,
+        }, null, 2);
+    }
+}

package/dist/safety-hook.d.ts

@@ -0,0 +1,79 @@
+import type { HALOpIR, ProgramIR, RuntimePolyfillIR, Diagnostic } from "./api/shared/index.js";
+/** Context handed to transformIR. */
+export interface SafetyTransformContext {
+    /** True iff the entry file imports `safe` from @typecad/safety. The pass
+     *  uses this as a fast no-op guard. */
+    readonly safetyInUse: boolean;
+    /** Build target (e.g. "esp32", "avr"). Strategies still resolve the
+     *  underlying pinMode/digitalRead symbols; the safety package is target-
+     *  agnostic. */
+    readonly target: string;
+}
+/** Capabilities cuttlefish core needs from the safety engine.
+ *
+ *  Part A uses transformIR + resolveSafetyOp + resolveSemanticCall.
+ *  Part B (ISO 26262 Part 6 rules) adds analyzeIR; Part C (sidecar) will
+ *  add collectSafetyMetadata. Both reuse this same seam with no new core
+ *  machinery. */
+export interface TranspilerSafetyHook {
+    /** Post-build IR transform. Must return a (possibly new) ProgramIR. Part A
+     *  uses this to inject safety.record_pin_mode companions after every
+     *  gpio.pin_mode / safety.pin_mode op. Called only when hasSafetyHook(). */
+    transformIR(program: ProgramIR, ctx: SafetyTransformContext): ProgramIR;
+    /** Resolve a safety.* HAL op to C++ code or expression. Called from the
+     *  extended routeHALOp() for any op whose `operation` starts with "safety.".
+     *  NEVER delegated to a per-target strategy. Returns undefined if the op
+     *  is not recognized (caller emits an unhandled-op warning). */
+    resolveSafetyOp(op: HALOpIR): {
+        code?: string;
+        expression?: string;
+    } | undefined;
+    /** Lower a safe.* TS call to a HAL op. Called from an extension point in
+     *  tryResolveSemanticCall (hal-plugins.ts) when the callee resolves to the
+     *  @typecad/safety package. Returns undefined if not a safety call. */
+    resolveSemanticCall?(callee: string, args: readonly unknown[]): HALOpIR | undefined;
+    /** Provide safety runtime polyfills (mode table + voter). Called from
+     *  buildEmitterContext so the polyfills participate in tree-shaking.
+     *  Returns [] when safety is not in use. */
+    buildPolyfills?(): RuntimePolyfillIR[];
+    /** Part B: read-only ISO 26262 Part 6 software-rule analysis. Called
+     *  after transformIR completes, on the final transformed IR. Returns
+     *  diagnostics that flow into the build's diagnostic list. Diagnostics
+     *  with severity "error" abort the build (via throwIfFatalDiagnostics);
+     *  "warning"/"info" are logged but the build succeeds. */
+    analyzeIR?(program: ProgramIR, ctx: SafetyTransformContext): Diagnostic[];
+    /** Part C: collect safety metadata for sidecar artifact generation.
+     *  Called after analyzeIR completes. Returns structured metadata about
+     *  each safety-critical function (ASIL level, mechanisms, rule results)
+     *  that the caller writes to a sidecar JSON file. */
+    collectSafetyMetadata?(program: ProgramIR, ctx: SafetyTransformContext): SafetyMetadata[];
+}
+/** Set the safety hook. Called by transpile.ts after dynamically loading
+ *  @typecad/safety/engine. Passing null clears it. */
+export declare function setSafetyHook(hook: TranspilerSafetyHook | null): void;
+/** Get the current safety hook, or null if @typecad/safety is not loaded. */
+export declare function getSafetyHook(): TranspilerSafetyHook | null;
+/** Returns true if the safety hook is registered (i.e. @typecad/safety loaded). */
+export declare function hasSafetyHook(): boolean;
+/** Get the safety hook, throwing if it's not set. Use only inside
+ *  `if (hasSafetyHook())` guards. */
+export declare function requireSafetyHook(): TranspilerSafetyHook;
+export type { Diagnostic };
+/** Metadata about one safety-critical function, collected for Part C. */
+export interface SafetyFunctionMetadata {
+    name: string;
+    asilLevel: string;
+    source?: {
+        tsFile: string;
+        tsLine: number;
+    };
+    mechanisms: string[];
+    rules: Record<string, "pass" | {
+        severity: string;
+        message: string;
+    }>;
+}
+/** Result of Part C's metadata collection. */
+export interface SafetyMetadata {
+    functions: SafetyFunctionMetadata[];
+}

package/dist/safety-hook.js

@@ -0,0 +1,35 @@
+// ---------------------------------------------------------------------------
+// Safety hook — the contract cuttlefish core uses to talk to the optional
+// @typecad/safety package. Modeled on ui-hook.ts.
+//
+// @typecad/safety is an optional peer dependency. When it is installed and
+// imported by a sketch, transpile.ts calls loadSafetyEngine() which dynamic-
+// imports @typecad/safety/engine and calls registerSafetyEngine() to push an
+// implementation of this interface into the registry. When absent, every
+// hasSafetyHook() guard returns false and cuttlefish behaves as before.
+// ---------------------------------------------------------------------------
+// ── Module-level hook state ────────────────────────────────────────────────
+let safetyHook = null;
+/** Set the safety hook. Called by transpile.ts after dynamically loading
+ *  @typecad/safety/engine. Passing null clears it. */
+export function setSafetyHook(hook) {
+    safetyHook = hook;
+}
+/** Get the current safety hook, or null if @typecad/safety is not loaded. */
+export function getSafetyHook() {
+    return safetyHook;
+}
+/** Returns true if the safety hook is registered (i.e. @typecad/safety loaded). */
+export function hasSafetyHook() {
+    return safetyHook !== null;
+}
+/** Get the safety hook, throwing if it's not set. Use only inside
+ *  `if (hasSafetyHook())` guards. */
+export function requireSafetyHook() {
+    if (!safetyHook) {
+        throw new Error("Safety hook is not registered. This code path requires @typecad/safety " +
+            "to be installed and loaded. This should not happen — the hook is set " +
+            "at the start of transpileFile() when safety is detected.");
+    }
+    return safetyHook;
+}

package/dist/stores/display-profile-store.d.ts

@@ -9,7 +9,6 @@ export declare function setDisplayProfile(profile: DisplayProfile, wiring: {
     address?: number;
     reset?: number;
     buildTarget?: string;
-    psram?: boolean;
 }): void;
 /** Get the current display profile, or a default if none set. */
 export declare function getDisplayProfile(): ResolvedDisplay;

package/dist/stores/display-profile-store.js

@@ -20,7 +20,6 @@ export function setDisplayProfile(profile, wiring) {
         _mountAddress: wiring.address ?? 0x3C,
         _mountReset: wiring.reset ?? -1,
         _buildTarget: wiring.buildTarget,
-        _psram: wiring.psram,
     };
 }
 /** Get the current display profile, or a default if none set. */

package/dist/testing.d.ts

@@ -12,9 +12,13 @@ export { inferSnprintfArg, createEmissionScopeState, escapeCppStringLiteral } fr
 export { setLoadedFramework } from "./framework-registry.js";
 export { registerPlatformStrategy, resolveStrategy, clearAllProfileCaches } from "./platform/registry.js";
 export type { EmitMode, GeneratedOutputs, TargetProfile, PlatformContext } from "./types.js";
+export { ComplianceContext, runSelfCheck, renderRegistryJson } from "./emit/compliance/index.js";
+export type { ComplianceMode, SelfCheckFinding, Deviation } from "./emit/compliance/index.js";
 export { findConfigFile, parseConfigFile, loadCuttlefishConfig, generateVirtualTypeDeclaration, } from "./config-loader.js";
 export { transpileFile } from "./transpile.js";
 export { resetUIEngine, __simulateUIAbsentForTest } from "./ui/ui-bridge.js";
+export { resetSafetyEngine, __simulateSafetyAbsentForTest } from "./safety/safety-bridge.js";
+export { setSafetyHook, hasSafetyHook } from "./safety-hook.js";
 export { scaffoldProject, normalizeProjectName, KNOWN_BOARDS, generateProjectPackageJson, generateProjectTsconfig, generateProjectConfig, generateProjectEnvDts, generateStarterSketch, generateStarterTest, generateStarterSim, generateGitignore, generateEslintConfig, runInitWizard, } from "./create/index.js";
 export type { InitProjectOptions } from "./create/index.js";
 export { scaffoldBoardPackages, parseBoardSpec, safeParseBoardSpec, stripJsonc, } from "./create/index.js";

package/dist/testing.js

@@ -11,12 +11,17 @@ export { analyzePeripheralUsage, createEmptyPeripheralUsage } from "./ir/periphe
 export { inferSnprintfArg, createEmissionScopeState, escapeCppStringLiteral } from "./emit/snprintf-helpers.js";
 export { setLoadedFramework } from "./framework-registry.js";
 export { registerPlatformStrategy, resolveStrategy, clearAllProfileCaches } from "./platform/registry.js";
+// ── AUTOSAR compliance module (test-visible) ───────────────────────────────
+export { ComplianceContext, runSelfCheck, renderRegistryJson } from "./emit/compliance/index.js";
 // ── Config loader ───────────────────────────────────────────────────────────
 export { findConfigFile, parseConfigFile, loadCuttlefishConfig, generateVirtualTypeDeclaration, } from "./config-loader.js";
 // ── Transpiler internal API ─────────────────────────────────────────────────
 export { transpileFile } from "./transpile.js";
 // ── UI bridge (optional @typecad/ui) ─────────────────────────────────────────
 export { resetUIEngine, __simulateUIAbsentForTest } from "./ui/ui-bridge.js";
+// ── Safety bridge (optional @typecad/safety) ────────────────────────────────
+export { resetSafetyEngine, __simulateSafetyAbsentForTest } from "./safety/safety-bridge.js";
+export { setSafetyHook, hasSafetyHook } from "./safety-hook.js";
 // ── Project scaffolding ──────────────────────────────────────────────────────
 export { scaffoldProject, normalizeProjectName, KNOWN_BOARDS, generateProjectPackageJson, generateProjectTsconfig, generateProjectConfig, generateProjectEnvDts, generateStarterSketch, generateStarterTest, generateStarterSim, generateGitignore, generateEslintConfig, runInitWizard, } from "./create/index.js";
 // ── Board codegen (`cuttlefish board add`) ───────────────────────────────────

package/dist/transpile.js

@@ -3,15 +3,33 @@ import path from "node:path";
 import fs from "node:fs";
 import { createRequire } from "node:module";
 import ts from "typescript";
+// Read once at module load. Used to populate the AUTOSAR deviation sidecar's
+// `toolVersion` field. Falls back to "unknown" if the read fails (e.g. tests
+// that import the module from an unexpected location).
+const CUTTLEFISH_VERSION = (() => {
+    try {
+        const require_ = createRequire(import.meta.url);
+        // transpile.ts lives in src/, compiled to dist/transpile.js. The package
+        // root is one level up from dist/, so from dist/ the path is ../package.json.
+        // From src/ (TypeScript source used by tests) it's also ../package.json.
+        const pkg = require_("../package.json");
+        return pkg.version ?? "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+})();
 import { buildProgramIR } from "./ir/build-ir.js";
 import { classDeclarationToIR } from "./ir/declaration-builders.js";
 import { clickHandlers } from "./ir/transformers/ui-call-resolver.js";
 import { requireUIHook, hasUIHook } from "./ui-hook.js";
 import { loadUIEngine } from "./ui/ui-bridge.js";
+import { hasSafetyHook, requireSafetyHook } from "./safety-hook.js";
+import { loadSafetyEngine } from "./safety/safety-bridge.js";
 import { setDisplayProfile, resetDisplayProfile } from "./stores/display-profile-store.js";
 import { setThemeCss, resetThemeCss, setThemeClass } from "./stores/theme-store.js";
 import { emitCpp, registerAllEnumNames } from "./emit/cpp-emitter.js";
-import { readText } from "./utils/fs.js";
+import { readText, writeText } from "./utils/fs.js";
 import { debug as logDebug, info } from "./utils/logger.js";
 import { loadLibraryDefinitions, generateLibdefStubs } from "./libdef/registry.js";
 import { buildCallGraph } from "./ir/call-graph.js";
@@ -60,6 +78,18 @@ function cleanOutput(_entryDir, outDir) {
  * Also tries to generate declarations for framework libraries.
  * Returns list of generated files.
  */
+/**
+ * True iff the program imports `@typecad/safety` anywhere. The safety
+ * transform pass uses this as its fast no-op guard — when no file imports
+ * safety, the pass returns the program unchanged.
+ */
+function entryImportsSafety(program) {
+    for (const imp of program.imports) {
+        if (imp.moduleSpecifier === "@typecad/safety")
+            return true;
+    }
+    return false;
+}
 /**
  * Apply tree-shaking to program IR if enabled
  */
@@ -136,7 +166,11 @@ function formatFatalDiagnostics(entries) {
         `Transpilation aborted because ${errors.length} unsupported pattern${errors.length === 1 ? "" : "s"} were found.`,
     ];
     for (const { filePath, diagnostic } of errors) {
-        const resolvedFile = filePath ?? diagnostic.filePath;
+        // Prefer diagnostic.filePath (set explicitly by the emitter, e.g. AUTOSAR
+        // diagnostics that map a C++ line back to TS) over the wrapper's filePath
+        // (the TS source file being processed, which may not be the right pointer
+        // for emit-stage diagnostics).
+        const resolvedFile = diagnostic.filePath ?? filePath;
         const locationBase = resolvedFile
             ? path.relative(process.cwd(), resolvedFile) || resolvedFile
             : diagnostic.source ?? "user code";
@@ -215,6 +249,10 @@ export async function transpileFile(options) {
     // requireUIHook() works throughout this transpile run. Gracefully no-ops
     // when @typecad/ui is absent (pure TS→C++ transpile).
     await loadUIEngine();
+    // Load the safety engine from @typecad/safety (if installed). Sets up the
+    // hook so requireSafetyHook() works throughout this transpile run.
+    // Gracefully no-ops when @typecad/safety is absent.
+    await loadSafetyEngine();
     const entryFile = path.resolve(options.inputFile);
     const entryDir = path.dirname(entryFile);
     const sourceDir = entryDir;
@@ -236,41 +274,29 @@ export async function transpileFile(options) {
     const configDisplay = options.display;
     if (configDisplay) {
         const { resolveDisplayProfile } = await import("./api/shared/display-profile.js");
-        try {
-            // Load built-in profiles from the framework package via its exported path
-            const registry = new Map();
-            if (options.frameworkPackage) {
-                // Built-in display profiles live in the framework's displays/ili9341-spi
-                // module. Non-Arduino frameworks (avr, esp32) may not ship their own
-                // profile registry — fall back to framework-arduino, which all current
-                // frameworks depend on and which owns the canonical profile definitions.
-                const profileMod = await import(options.frameworkPackage + "/displays/ili9341-spi").catch(() => null);
-                // The fallback uses a non-literal specifier so tsc does not require
-                // framework-arduino to be a build-time dependency (it is an optional
-                // runtime fallback — frameworks like avr/esp32 may not ship their own
-                // profile registry). Declaring it as a dependency would create a cycle
-                // (framework-arduino already depends on cuttlefish).
-                const fallbackPkg = "@typecad/framework-arduino";
-                const fallbackMod = (options.frameworkPackage !== fallbackPkg)
-                    ? await import(fallbackPkg + "/displays/ili9341-spi").catch(() => null)
-                    : null;
-                for (const mod of [profileMod, fallbackMod]) {
-                    if (mod?.BUILT_IN_PROFILES) {
-                        for (const [k, v] of Object.entries(mod.BUILT_IN_PROFILES)) {
-                            registry.set(k, v);
-                        }
-                    }
+        // Build the named-profile registry. Prefer the strategy's hook (per-framework
+        // canonical profiles — Arduino returns its BUILT_IN_PROFILES, Zephyr returns
+        // its DT-binding profiles). Fall back to the legacy dynamic import of the
+        // framework's displays/ili9341-spi module when the strategy provides none.
+        // The registry maps a config `profile` name (e.g. "st7796-zephyr") to its
+        // DisplayProfile; an empty registry makes resolveDisplayProfile fall back to
+        // the bare default driver (config.driver ?? "ili9341") when no profile name
+        // is set, or throw "Unknown display profile" when one is.
+        let registry = new Map();
+        if (strategy.getProfileRegistry) {
+            registry = strategy.getProfileRegistry();
+        }
+        else if (options.frameworkPackage) {
+            const profileMod = await import(options.frameworkPackage + "/displays/ili9341-spi").catch(() => null);
+            if (profileMod?.BUILT_IN_PROFILES) {
+                for (const [k, v] of Object.entries(profileMod.BUILT_IN_PROFILES)) {
+                    registry.set(k, v);
                 }
             }
-            const resolved = resolveDisplayProfile(configDisplay, registry);
-            const buildTarget = options.platformContext?.frameworkData?.buildTarget;
-            const psramRaw = options.platformContext?.frameworkData?.psram;
-            const psram = psramRaw === 'opi' || psramRaw === 'quad';
-            setDisplayProfile(resolved.profile, { cs: resolved.cs, dc: resolved.dc, rst: resolved.rst, bus: resolved.bus, address: resolved.address, reset: resolved.reset, buildTarget, psram });
-        }
-        catch {
-            // Fall back to default profile — not fatal
         }
+        const resolved = resolveDisplayProfile(configDisplay, registry);
+        const buildTarget = options.platformContext?.frameworkData?.buildTarget;
+        setDisplayProfile(resolved.profile, { cs: resolved.cs, dc: resolved.dc, rst: resolved.rst, bus: resolved.bus, address: resolved.address, reset: resolved.reset, buildTarget });
         // Apply theme CSS override if specified.
         if (configDisplay.themeCss) {
             setThemeCss(configDisplay.themeCss);
@@ -478,7 +504,13 @@ export async function transpileFile(options) {
             }
             sourceText = preprocess(sourceText, filePath);
         }
-        if (options.debug && breakpoints) {
+        // Printf instrumentation runs only in printf debug mode. In gdb mode
+        // (e.g. ESP32-S3), --debug emits #line markers at the emit stage and
+        // uses VS Code native breakpoints; the printf preprocessor is skipped
+        // so the source reaches IR/emit unmodified.
+        const buildTarget = options.platformContext?.frameworkData?.buildTarget;
+        const debugMode = strategy.debugMode?.(buildTarget) ?? 'printf';
+        if (options.debug && breakpoints && debugMode === 'printf') {
             const instrumented = debugPreprocess({
                 fileName: filePath,
                 breakpoints,
@@ -665,6 +697,60 @@ export async function transpileFile(options) {
     profiler.startTimer("emit:register-enums");
     registerAllEnumNames(allEnumIRs);
     profiler.endTimer("emit:register-enums");
+    // ── Phase D: safety transform pass ──────────────────────────────────────
+    // When @typecad/safety is in use, run its post-build IR transform to inject
+    // safety ops (e.g. companion safety.record_pin_mode after every
+    // gpio.pin_mode). Produces new IR per file; no-op when safety is off or
+    // absent.
+    if (hasSafetyHook()) {
+        profiler.startTimer("safety:transform");
+        const hook = requireSafetyHook();
+        for (const [filePath, item] of preBuilt) {
+            const newIR = hook.transformIR(item.programIR, {
+                safetyInUse: entryImportsSafety(item.programIR),
+                target: options.target,
+            });
+            preBuilt.set(filePath, { ...item, programIR: newIR });
+        }
+        profiler.endTimer("safety:transform");
+        // Part B: ISO 26262 Part 6 read-only IR analysis. Runs after transformIR
+        // so it sees the final IR (including injected safety ops). Returned
+        // diagnostics flow into the build's diagnostic list; error-severity
+        // diagnostics abort via throwIfFatalDiagnostics.
+        if (hook.analyzeIR) {
+            profiler.startTimer("safety:analyze");
+            for (const [, item] of preBuilt) {
+                const irDiags = hook.analyzeIR(item.programIR, {
+                    safetyInUse: entryImportsSafety(item.programIR),
+                    target: options.target,
+                });
+                if (irDiags.length > 0) {
+                    diagnostics.push(...irDiags);
+                }
+            }
+            profiler.endTimer("safety:analyze");
+        }
+        // Part C: collect safety metadata and write sidecar artifact.
+        if (hook.collectSafetyMetadata) {
+            profiler.startTimer("safety:collect");
+            for (const [filePath, item] of preBuilt) {
+                if (!entryImportsSafety(item.programIR))
+                    continue;
+                const metadata = hook.collectSafetyMetadata(item.programIR, {
+                    safetyInUse: true,
+                    target: options.target,
+                });
+                if (metadata.length > 0 && metadata[0].functions.length > 0) {
+                    const { renderSafetySidecar } = await import("./safety/sidecar-bridge.js");
+                    const toolVersion = CUTTLEFISH_VERSION;
+                    const sidecarPath = path.join(outDir, path.basename(filePath).replace(/\.\w+$/, ".safety-sidecar.json"));
+                    const sidecarJson = await renderSafetySidecar(metadata[0], toolVersion);
+                    writeText(sidecarPath, sidecarJson);
+                }
+            }
+            profiler.endTimer("safety:collect");
+        }
+    }
     // ── Pass 2: emit (only for files that needed retranspilation) ─────────────
     profiler.startTimer("emit:all");
     profiler.captureMemorySnapshot("emit:pre");
@@ -689,6 +775,9 @@ export async function transpileFile(options) {
             crossModuleEnumNames: allEnumNames,
             crossModuleStringEnumNames: allStringEnumNames,
             crossModuleVariableTypes: allVariableTypes,
+            autosar: options.autosar,
+            toolVersion: CUTTLEFISH_VERSION,
+            autosarArxml: options.autosarArxml,
         };
         // Pass the already-resolved strategy (framework-loaded or target-based)
         emitOptions.strategy = strategy;

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;
@@ -134,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;
@@ -168,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. */

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 {
@@ -83,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). */