@typecad/cuttlefish 0.1.0-alpha.1

package/dist/profiler/profiler.js

@@ -0,0 +1,338 @@
+/**
+ * Performance profiler for the transpilation pipeline.
+ *
+ * Usage:
+ *   const profiler = initProfiler({ enabled: true });
+ *   profiler.startSession();
+ *   profiler.timeSync('phase:name', () => { ... });
+ *   await profiler.timeAsync('phase:async', async () => { ... });
+ *   const report = profiler.endSession();
+ */
+import { performance } from "node:perf_hooks";
+import { DEFAULT_PROFILER_OPTIONS, } from "./types.js";
+export class Profiler {
+    constructor(options = {}) {
+        this.timings = new Map();
+        this.activeTimers = new Map();
+        this.memorySnapshots = [];
+        this.sessionStart = 0;
+        this.parentStack = [];
+        this.timerCounter = 0;
+        this.enabled = options.enabled ?? DEFAULT_PROFILER_OPTIONS.enabled;
+        this.trackMemory = options.trackMemory ?? DEFAULT_PROFILER_OPTIONS.trackMemory;
+        this.threshold = options.threshold ?? DEFAULT_PROFILER_OPTIONS.threshold;
+    }
+    /**
+     * Check if profiling is enabled
+     */
+    isEnabled() {
+        return this.enabled;
+    }
+    /**
+     * Start a timing measurement
+     */
+    startTimer(name, metadata) {
+        if (!this.enabled)
+            return;
+        const uniqueName = `${name}#${this.timerCounter++}`;
+        const startTime = performance.now();
+        this.activeTimers.set(uniqueName, startTime);
+        // Track parent-child relationships
+        if (this.parentStack.length > 0) {
+            const parentName = this.parentStack[this.parentStack.length - 1];
+            const parentEntry = this.timings.get(parentName);
+            if (parentEntry) {
+                parentEntry.children.push(uniqueName);
+            }
+        }
+        // Store initial entry
+        const entry = {
+            name: uniqueName,
+            startTime,
+            endTime: 0,
+            duration: 0,
+            parent: this.parentStack[this.parentStack.length - 1],
+            children: [],
+            metadata,
+        };
+        this.timings.set(uniqueName, entry);
+        if (this.trackMemory) {
+            this.captureMemorySnapshot(`${name}:start`);
+        }
+    }
+    /**
+     * End a timing measurement
+     */
+    endTimer(name) {
+        if (!this.enabled)
+            return 0;
+        // Find the most recent timer with this base name
+        let uniqueName;
+        for (const [key] of [...this.timings.entries()].reverse()) {
+            if (key.startsWith(`${name}#`)) {
+                uniqueName = key;
+                break;
+            }
+        }
+        if (!uniqueName)
+            return 0;
+        const entry = this.timings.get(uniqueName);
+        if (!entry)
+            return 0;
+        const endTime = performance.now();
+        const duration = endTime - entry.startTime;
+        entry.endTime = endTime;
+        entry.duration = duration;
+        // Remove from active timers
+        this.activeTimers.delete(uniqueName);
+        // If duration is below threshold, remove the entry
+        if (duration < this.threshold) {
+            this.timings.delete(uniqueName);
+        }
+        return duration;
+    }
+    /**
+     * Time a synchronous function
+     */
+    timeSync(name, fn, metadata) {
+        if (!this.enabled)
+            return fn();
+        const uniqueName = `${name}#${this.timerCounter}`;
+        this.startTimer(name, metadata);
+        this.parentStack.push(uniqueName);
+        try {
+            const result = fn();
+            return result;
+        }
+        finally {
+            this.parentStack.pop();
+            this.endTimer(name);
+        }
+    }
+    /**
+     * Time an asynchronous function
+     */
+    async timeAsync(name, fn, metadata) {
+        if (!this.enabled)
+            return fn();
+        const uniqueName = `${name}#${this.timerCounter}`;
+        this.startTimer(name, metadata);
+        this.parentStack.push(uniqueName);
+        try {
+            const result = await fn();
+            return result;
+        }
+        finally {
+            this.parentStack.pop();
+            this.endTimer(name);
+        }
+    }
+    /**
+     * Capture a memory snapshot
+     */
+    captureMemorySnapshot(name) {
+        if (!this.enabled || !this.trackMemory)
+            return;
+        const mem = process.memoryUsage();
+        this.memorySnapshots.push({
+            name,
+            timestamp: performance.now(),
+            heapUsed: mem.heapUsed,
+            heapTotal: mem.heapTotal,
+            external: mem.external,
+        });
+    }
+    /**
+     * Start a profiling session
+     */
+    startSession() {
+        if (!this.enabled)
+            return;
+        this.sessionStart = performance.now();
+        this.timings.clear();
+        this.memorySnapshots = [];
+        this.parentStack = [];
+        this.timerCounter = 0;
+        this.captureMemorySnapshot("session:start");
+    }
+    /**
+     * End a profiling session and return the session data
+     */
+    endSession() {
+        const endTime = performance.now();
+        this.captureMemorySnapshot("session:end");
+        const phaseStats = this.computePhaseStatistics(endTime - this.sessionStart);
+        return {
+            startTime: this.sessionStart,
+            endTime,
+            totalDuration: endTime - this.sessionStart,
+            timings: new Map(this.timings),
+            memorySnapshots: [...this.memorySnapshots],
+            phaseStats,
+        };
+    }
+    /**
+     * Compute aggregated statistics by phase
+     */
+    computePhaseStatistics(totalDuration) {
+        const phaseMap = new Map();
+        for (const [, entry] of this.timings) {
+            // Extract base phase name (remove counter suffix and file-specific parts)
+            const basePhase = this.extractBasePhase(entry.name);
+            const existing = phaseMap.get(basePhase);
+            if (existing) {
+                existing.total += entry.duration;
+                existing.count++;
+                existing.min = Math.min(existing.min, entry.duration);
+                existing.max = Math.max(existing.max, entry.duration);
+            }
+            else {
+                phaseMap.set(basePhase, {
+                    total: entry.duration,
+                    count: 1,
+                    min: entry.duration,
+                    max: entry.duration,
+                });
+            }
+        }
+        const stats = [];
+        for (const [phase, data] of phaseMap) {
+            stats.push({
+                phase,
+                totalDuration: data.total,
+                callCount: data.count,
+                avgDuration: data.total / data.count,
+                minDuration: data.min,
+                maxDuration: data.max,
+                percentageOfTotal: totalDuration > 0 ? (data.total / totalDuration) * 100 : 0,
+            });
+        }
+        // Sort by total duration descending
+        stats.sort((a, b) => b.totalDuration - a.totalDuration);
+        return stats;
+    }
+    /**
+     * Extract the base phase name from a timer name
+     */
+    extractBasePhase(name) {
+        // Remove counter suffix (e.g., "phase#123" -> "phase")
+        let base = name.replace(/#\d+$/, "");
+        return base;
+    }
+    /**
+     * Generate a profiler report from a session
+     */
+    generateReport(session) {
+        const bottlenecks = this.identifyBottlenecks(session);
+        const recommendations = this.generateRecommendations(session, bottlenecks);
+        return {
+            session,
+            summary: this.generateSummary(session),
+            bottlenecks,
+            recommendations,
+        };
+    }
+    /**
+     * Identify phases that are bottlenecks (>10% of total time)
+     */
+    identifyBottlenecks(session) {
+        const bottlenecks = [];
+        const threshold = session.totalDuration * 0.1; // 10% threshold
+        for (const stat of session.phaseStats) {
+            if (stat.totalDuration > threshold) {
+                bottlenecks.push(`${stat.phase}: ${stat.totalDuration.toFixed(2)}ms (${stat.percentageOfTotal.toFixed(1)}%)`);
+            }
+        }
+        return bottlenecks;
+    }
+    /**
+     * Generate optimization recommendations based on profiling data
+     */
+    generateRecommendations(session, bottlenecks) {
+        const recommendations = new Set();
+        for (const stat of session.phaseStats) {
+            // Type-checking recommendations
+            if (stat.phase.includes("typecheck") && stat.percentageOfTotal > 30) {
+                recommendations.add("Consider using --skipTypeCheck during development for faster iteration");
+            }
+            // IR building recommendations
+            if (stat.phase.includes("ir:build") && stat.percentageOfTotal > 25) {
+                recommendations.add("IR building is slow - check if incremental cache is working properly");
+            }
+            // Emission recommendations
+            if (stat.phase.includes("emit") && stat.percentageOfTotal > 40) {
+                recommendations.add("Emission phase is slow - consider optimizing emitter or reducing output complexity");
+            }
+            // Graph collection recommendations
+            if (stat.phase.includes("graph:collect") && stat.percentageOfTotal > 15) {
+                recommendations.add("Graph collection is slow - consider caching import resolution results");
+            }
+        }
+        // Memory recommendations
+        if (session.memorySnapshots.length > 1) {
+            const startMem = session.memorySnapshots[0];
+            const endMem = session.memorySnapshots[session.memorySnapshots.length - 1];
+            const memDelta = endMem.heapUsed - startMem.heapUsed;
+            if (memDelta > 100 * 1024 * 1024) {
+                // > 100MB
+                recommendations.add(`High memory usage (${(memDelta / 1024 / 1024).toFixed(0)}MB delta) - consider streaming large files`);
+            }
+        }
+        return Array.from(recommendations);
+    }
+    /**
+     * Generate a human-readable summary
+     */
+    generateSummary(session) {
+        const lines = [
+            `Total transpilation time: ${session.totalDuration.toFixed(2)}ms`,
+            `Phases measured: ${session.phaseStats.length}`,
+        ];
+        if (session.memorySnapshots.length > 1) {
+            const start = session.memorySnapshots[0];
+            const end = session.memorySnapshots[session.memorySnapshots.length - 1];
+            const delta = end.heapUsed - start.heapUsed;
+            const sign = delta >= 0 ? "+" : "";
+            lines.push(`Memory delta: ${sign}${(delta / 1024 / 1024).toFixed(2)}MB`);
+        }
+        return lines.join("\n");
+    }
+    /**
+     * Get all timing durations as a flat record (for diagnostics integration).
+     */
+    getTimings() {
+        const result = {};
+        for (const [name, entry] of this.timings) {
+            result[name] = entry.duration;
+        }
+        return result;
+    }
+    /**
+     * Clear all profiling data
+     */
+    clear() {
+        this.timings.clear();
+        this.activeTimers.clear();
+        this.memorySnapshots = [];
+        this.parentStack = [];
+        this.timerCounter = 0;
+    }
+}
+// Global profiler instance
+let globalProfiler = null;
+/**
+ * Get the global profiler instance (creates one if not exists)
+ */
+export function getProfiler() {
+    if (!globalProfiler) {
+        globalProfiler = new Profiler();
+    }
+    return globalProfiler;
+}
+/**
+ * Initialize the global profiler with options
+ */
+export function initProfiler(options = {}) {
+    globalProfiler = new Profiler(options);
+    return globalProfiler;
+}

package/dist/profiler/types.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Types for the transpilation performance profiler.
+ */
+export interface TimingEntry {
+    /** Unique name for this timing entry */
+    name: string;
+    /** Start time from performance.now() */
+    startTime: number;
+    /** End time from performance.now() */
+    endTime: number;
+    /** Duration in milliseconds */
+    duration: number;
+    /** Parent timer name (for hierarchical timing) */
+    parent?: string;
+    /** Child timer names */
+    children: string[];
+    /** Optional metadata */
+    metadata?: Record<string, unknown>;
+}
+export interface MemorySnapshot {
+    /** Name/label for this snapshot */
+    name: string;
+    /** Timestamp from performance.now() */
+    timestamp: number;
+    /** Heap used in bytes */
+    heapUsed: number;
+    /** Heap total in bytes */
+    heapTotal: number;
+    /** External memory in bytes */
+    external: number;
+}
+export interface PhaseStatistics {
+    /** Phase name (base name without file-specific suffixes) */
+    phase: string;
+    /** Total duration in milliseconds */
+    totalDuration: number;
+    /** Number of times this phase was called */
+    callCount: number;
+    /** Average duration per call in milliseconds */
+    avgDuration: number;
+    /** Minimum duration in milliseconds */
+    minDuration: number;
+    /** Maximum duration in milliseconds */
+    maxDuration: number;
+    /** Percentage of total transpilation time */
+    percentageOfTotal: number;
+}
+export interface ProfilerSession {
+    /** Session start time from performance.now() */
+    startTime: number;
+    /** Session end time from performance.now() */
+    endTime: number;
+    /** Total session duration in milliseconds */
+    totalDuration: number;
+    /** All timing entries by name */
+    timings: Map<string, TimingEntry>;
+    /** Memory snapshots taken during profiling */
+    memorySnapshots: MemorySnapshot[];
+    /** Aggregated statistics by phase */
+    phaseStats: PhaseStatistics[];
+}
+export interface ProfilerOptions {
+    /** Enable profiling (default: false) */
+    enabled: boolean;
+    /** Track memory usage (default: false) */
+    trackMemory: boolean;
+    /** Output format for reports */
+    outputFormat: "console" | "json" | "markdown";
+    /** Output file path (default: console output) */
+    outputPath?: string;
+    /** Minimum duration (ms) to include in report (default: 0) */
+    threshold: number;
+}
+export interface ProfilerReport {
+    /** The profiling session data */
+    session: ProfilerSession;
+    /** Human-readable summary */
+    summary: string;
+    /** Identified bottlenecks (>10% of total time) */
+    bottlenecks: string[];
+    /** Optimization recommendations */
+    recommendations: string[];
+}
+/**
+ * Default profiler options
+ */
+export declare const DEFAULT_PROFILER_OPTIONS: ProfilerOptions;

package/dist/profiler/types.js

@@ -0,0 +1,12 @@
+/**
+ * Types for the transpilation performance profiler.
+ */
+/**
+ * Default profiler options
+ */
+export const DEFAULT_PROFILER_OPTIONS = {
+    enabled: false,
+    trackMemory: false,
+    outputFormat: "console",
+    threshold: 0,
+};

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

@@ -0,0 +1,16 @@
+import type { DisplayProfile, ResolvedDisplay } from "../api/shared/index.js";
+export type { ResolvedDisplay };
+/** Set the display profile for this transpile run. Called from transpileFile. */
+export declare function setDisplayProfile(profile: DisplayProfile, wiring: {
+    cs?: number;
+    dc?: number;
+    rst?: number;
+    bus?: string;
+    address?: number;
+    reset?: number;
+    buildTarget?: string;
+}): void;
+/** Get the current display profile, or a default if none set. */
+export declare function getDisplayProfile(): ResolvedDisplay;
+/** Reset for the next transpile run. */
+export declare function resetDisplayProfile(): void;

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

@@ -0,0 +1,48 @@
+// ---------------------------------------------------------------------------
+// Display profile store — module-scoped profile for the current transpile run.
+//
+// Set early in transpileFile when the config's `display` field is loaded.
+// All hardcoded display-value sites read from here via getDisplayProfile().
+//
+// This avoids deep changes to the config loader and TranspileOptions type —
+// the full config plumbing can come later. The important thing is that
+// display dimensions, pins, rotation, and touch config are data-driven.
+// ---------------------------------------------------------------------------
+let currentProfile = null;
+/** Set the display profile for this transpile run. Called from transpileFile. */
+export function setDisplayProfile(profile, wiring) {
+    currentProfile = {
+        ...profile,
+        _mountCs: wiring.cs ?? 5,
+        _mountDc: wiring.dc ?? 21,
+        _mountRst: wiring.rst ?? 22,
+        _mountBus: wiring.bus ?? "SPI",
+        _mountAddress: wiring.address ?? 0x3C,
+        _mountReset: wiring.reset ?? -1,
+        _buildTarget: wiring.buildTarget,
+    };
+}
+/** Get the current display profile, or a default if none set. */
+export function getDisplayProfile() {
+    if (currentProfile)
+        return currentProfile;
+    return {
+        driver: "ili9341",
+        width: 320,
+        height: 240,
+        colorFormat: "rgb565",
+        rotation: 1,
+        backlight: 17,
+        spiPins: { mosi: 23, sck: 18, miso: 19 },
+        _mountCs: 5,
+        _mountDc: 21,
+        _mountRst: 22,
+        _mountBus: "SPI",
+        _mountAddress: 0x3C,
+        _mountReset: -1,
+    };
+}
+/** Reset for the next transpile run. */
+export function resetDisplayProfile() {
+    currentProfile = null;
+}

package/dist/stores/theme-store.d.ts

@@ -0,0 +1,13 @@
+/** Set the CSS theme file path. When non-null, loadUIModule uses this
+ *  instead of the default sibling .ui.css. Pass null to restore default. */
+export declare function setThemeCss(path: string | null): void;
+/** Get the CSS theme override path, or null for default sibling-file behavior. */
+export declare function getThemeCss(): string | null;
+/** Set the active theme class for class-scoped CSS variables (e.g. "dark").
+ *  When set, var() substitution prefers variables defined under this class
+ *  over :root defaults. */
+export declare function setThemeClass(cls: string | null): void;
+/** Get the active theme class, or null (use :root only). */
+export declare function getThemeClass(): string | null;
+/** Reset to default (sibling-file convention). */
+export declare function resetThemeCss(): void;

package/dist/stores/theme-store.js

@@ -0,0 +1,30 @@
+// Module-scoped CSS theme path override.
+// Set via setThemeCss() from the config loader; read by loadUIModule().
+// When set, this path replaces the default sibling-file convention
+// (hello.ui.html → hello.ui.css).
+let themeCssOverride = null;
+let themeClassOverride = null;
+/** Set the CSS theme file path. When non-null, loadUIModule uses this
+ *  instead of the default sibling .ui.css. Pass null to restore default. */
+export function setThemeCss(path) {
+    themeCssOverride = path;
+}
+/** Get the CSS theme override path, or null for default sibling-file behavior. */
+export function getThemeCss() {
+    return themeCssOverride;
+}
+/** Set the active theme class for class-scoped CSS variables (e.g. "dark").
+ *  When set, var() substitution prefers variables defined under this class
+ *  over :root defaults. */
+export function setThemeClass(cls) {
+    themeClassOverride = cls;
+}
+/** Get the active theme class, or null (use :root only). */
+export function getThemeClass() {
+    return themeClassOverride;
+}
+/** Reset to default (sibling-file convention). */
+export function resetThemeCss() {
+    themeCssOverride = null;
+    themeClassOverride = null;
+}

package/dist/testing.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Testing utilities for @typecad/cuttlefish.
+ *
+ * This module exposes internal transpiler functions that are needed by
+ * the test suite but are intentionally kept out of the main public API
+ * (`@typecad/cuttlefish`).  Import via `@typecad/cuttlefish/testing`.
+ */
+export { buildProgramIR } from "./ir/build-ir.js";
+export { emitCpp, registerAllEnumNames } from "./emit/cpp-emitter.js";
+export { analyzePeripheralUsage, createEmptyPeripheralUsage } from "./ir/peripheral-usage.js";
+export { inferSnprintfArg, createEmissionScopeState, escapeCppStringLiteral } from "./emit/snprintf-helpers.js";
+export { setLoadedFramework } from "./framework-registry.js";
+export { registerPlatformStrategy, resolveStrategy, clearAllProfileCaches } from "./platform/registry.js";
+export type { EmitMode, GeneratedOutputs, TargetProfile, PlatformContext } from "./types.js";
+export { findConfigFile, parseConfigFile, loadCuttlefishConfig, generateVirtualTypeDeclaration, } from "./config-loader.js";
+export { transpileFile } from "./transpile.js";
+export { scaffoldProject, normalizeProjectName, KNOWN_BOARDS, generateProjectPackageJson, generateProjectTsconfig, generateProjectConfig, generateProjectEnvDts, generateStarterSketch, generateGitignore, generateEslintConfig, runInitWizard, } from "./create/index.js";
+export type { InitProjectOptions } from "./create/index.js";
+export { scaffoldBoardPackages, parseBoardSpec, safeParseBoardSpec, stripJsonc, } from "./create/index.js";
+export type { BoardSpec, ScaffoldBoardResult } from "./create/index.js";
+export { BoardGenerators } from "./create/index.js";
+export { buildCallGraph, getReachableSymbols } from "./ir/call-graph.js";
+export { detectEntryPoints, detectExportedEntryPoints } from "./ir/entry-points.js";
+export { analyzeReachability, getReachabilityStats } from "./ir/reachability.js";
+export { filterProgramIR } from "./ir/filter.js";
+export { validateTryCatch } from "./ir/try-catch-validation.js";
+export { prescanUnsupportedFeatures } from "./ir/feature-prescan.js";
+export { LINT_RULES, ESLINT_OPT_OUT_KINDS, kindRegistryEntries, } from "./ir/feature-registry.js";
+export type { LintRule, FeatureEntry, FeatureStatus, DiagnosticMatch } from "./ir/feature-registry.js";
+export { runEslintCheck } from "./eslint-check.js";
+export type { ESLintError } from "./eslint-check.js";
+export { runSemanticGates } from "./orchestrator/type-checker.js";
+export { canonicalize, buildSemanticFacts, } from "./orchestrator/semantic-facts.js";
+export type { CanonicalType, SemanticFacts, FactStore, ValueCategory, Lifetime, Nullable, SemanticOrigin, AnalysisResult, BindingResolver, } from "./orchestrator/semantic-facts.js";
+export { verifyFacts } from "./orchestrator/semantic-facts-verifier.js";
+export type { VerifierOptions, VerifierResult, UnknownTypeSeverity } from "./orchestrator/semantic-facts-verifier.js";
+export { discoverWatchDirs, isRelevantChange } from "./watch.js";
+export { parseCommandLine } from "./utils/cli.js";
+export { parseHeader, stripPreprocessorBlocks } from "./libdef/header-parser.js";
+export { BaseClassResolver, buildClassIndex } from "./libdef/base-class-resolver.js";
+export type { ResolveResult } from "./libdef/base-class-resolver.js";
+export { generateDecl, generateDeclsForDirectory } from "./libdef/cpp-to-decl.js";
+export { renderExprAsText } from "./ir/render-expr.js";
+export { contextStorage, CompilationContext } from "./ir/build-ir-state.js";
+export type { ExpressionIR } from "./api/index.js";

package/dist/testing.js

@@ -0,0 +1,47 @@
+/**
+ * Testing utilities for @typecad/cuttlefish.
+ *
+ * This module exposes internal transpiler functions that are needed by
+ * the test suite but are intentionally kept out of the main public API
+ * (`@typecad/cuttlefish`).  Import via `@typecad/cuttlefish/testing`.
+ */
+export { buildProgramIR } from "./ir/build-ir.js";
+export { emitCpp, registerAllEnumNames } from "./emit/cpp-emitter.js";
+export { analyzePeripheralUsage, createEmptyPeripheralUsage } from "./ir/peripheral-usage.js";
+export { inferSnprintfArg, createEmissionScopeState, escapeCppStringLiteral } from "./emit/snprintf-helpers.js";
+export { setLoadedFramework } from "./framework-registry.js";
+export { registerPlatformStrategy, resolveStrategy, clearAllProfileCaches } from "./platform/registry.js";
+// ── Config loader ───────────────────────────────────────────────────────────
+export { findConfigFile, parseConfigFile, loadCuttlefishConfig, generateVirtualTypeDeclaration, } from "./config-loader.js";
+// ── Transpiler internal API ─────────────────────────────────────────────────
+export { transpileFile } from "./transpile.js";
+// ── Project scaffolding ──────────────────────────────────────────────────────
+export { scaffoldProject, normalizeProjectName, KNOWN_BOARDS, generateProjectPackageJson, generateProjectTsconfig, generateProjectConfig, generateProjectEnvDts, generateStarterSketch, generateGitignore, generateEslintConfig, runInitWizard, } from "./create/index.js";
+// ── Board codegen (`cuttlefish board add`) ───────────────────────────────────
+export { scaffoldBoardPackages, parseBoardSpec, safeParseBoardSpec, stripJsonc, } from "./create/index.js";
+export { BoardGenerators } from "./create/index.js";
+// ── Tree-shaking & reachability ──────────────────────────────────────────────
+export { buildCallGraph, getReachableSymbols } from "./ir/call-graph.js";
+export { detectEntryPoints, detectExportedEntryPoints } from "./ir/entry-points.js";
+export { analyzeReachability, getReachabilityStats } from "./ir/reachability.js";
+export { filterProgramIR } from "./ir/filter.js";
+// ── Validation ──────────────────────────────────────────────────────────────
+export { validateTryCatch } from "./ir/try-catch-validation.js";
+export { prescanUnsupportedFeatures } from "./ir/feature-prescan.js";
+// Feature registry + ESLint selector source-of-truth (parity-tested).
+export { LINT_RULES, ESLINT_OPT_OUT_KINDS, kindRegistryEntries, } from "./ir/feature-registry.js";
+// ── ESLint gate ──────────────────────────────────────────────────────────────
+export { runEslintCheck } from "./eslint-check.js";
+// ── Semantic gates (TypeChecker-based) ──────────────────────────────────────
+export { runSemanticGates } from "./orchestrator/type-checker.js";
+export { canonicalize, buildSemanticFacts, } from "./orchestrator/semantic-facts.js";
+export { verifyFacts } from "./orchestrator/semantic-facts-verifier.js";
+// ── Watch & CLI utilities ───────────────────────────────────────────────────
+export { discoverWatchDirs, isRelevantChange } from "./watch.js";
+export { parseCommandLine } from "./utils/cli.js";
+export { parseHeader, stripPreprocessorBlocks } from "./libdef/header-parser.js";
+export { BaseClassResolver, buildClassIndex } from "./libdef/base-class-resolver.js";
+export { generateDecl, generateDeclsForDirectory } from "./libdef/cpp-to-decl.js";
+// ── IR rendering internals (for fail-closed regression tests) ───────────────
+export { renderExprAsText } from "./ir/render-expr.js";
+export { contextStorage, CompilationContext } from "./ir/build-ir-state.js";

package/dist/transpile/resolution.d.ts

@@ -0,0 +1,29 @@
+export interface ResolvedNpmPackage {
+    packagePath: string;
+    sourcePath: string;
+    subpath: string;
+    packageName: string;
+    moduleKey: string;
+}
+export interface NativeCppModule {
+    declPath: string;
+    cppPath: string;
+    headerPath?: string;
+    moduleKey: string;
+}
+export interface TranspileGraphResult {
+    files: string[];
+    npmPackages: Map<string, ResolvedNpmPackage>;
+    nativeModules: Map<string, NativeCppModule>;
+    /** `.ui.html` modules discovered during graph build, keyed by resolved path. */
+    uiModules: Set<string>;
+}
+export declare function resolveImport(fromFile: string, moduleSpecifier: string, boardPackage?: string): {
+    sourcePath: string;
+    npmPackage?: ResolvedNpmPackage;
+    uiModule?: boolean;
+} | undefined;
+export declare function isInNodeModules(filePath: string): boolean;
+export declare function getNpmPackageInfoForFile(filePath: string, moduleSpecifier: string): ResolvedNpmPackage | undefined;
+export declare function detectNativeCppModule(fromFile: string, moduleSpecifier: string): NativeCppModule | undefined;
+export declare function isCuttlefishSDKPath(filePath: string): boolean;