@typecad/cuttlefish 0.1.0-alpha.1

package/dist/ir/utils/walk-ir.js

@@ -0,0 +1,162 @@
+export function walkNestedStatements(stmt, visitor) {
+    if (!stmt || typeof stmt !== "object")
+        return;
+    if ("thenBranch" in stmt && Array.isArray(stmt.thenBranch)) {
+        for (const s of stmt.thenBranch)
+            visitor(s);
+    }
+    if ("elseBranch" in stmt && Array.isArray(stmt.elseBranch)) {
+        for (const s of stmt.elseBranch)
+            visitor(s);
+    }
+    if ("body" in stmt && Array.isArray(stmt.body)) {
+        for (const s of stmt.body)
+            visitor(s);
+    }
+    if ("initializer" in stmt && stmt.initializer && typeof stmt.initializer === "object" && "sourceSpan" in stmt.initializer)
+        visitor(stmt.initializer);
+    if ("increment" in stmt && stmt.increment && typeof stmt.increment === "object" && "sourceSpan" in stmt.increment)
+        visitor(stmt.increment);
+    if ("cases" in stmt && Array.isArray(stmt.cases)) {
+        for (const c of stmt.cases) {
+            if (c.body && Array.isArray(c.body)) {
+                for (const s of c.body)
+                    visitor(s);
+            }
+        }
+    }
+    if ("tryBlock" in stmt && Array.isArray(stmt.tryBlock)) {
+        for (const s of stmt.tryBlock)
+            visitor(s);
+    }
+    if ("catchBlock" in stmt && Array.isArray(stmt.catchBlock)) {
+        for (const s of stmt.catchBlock)
+            visitor(s);
+    }
+    if ("finallyBlock" in stmt && Array.isArray(stmt.finallyBlock)) {
+        for (const s of stmt.finallyBlock)
+            visitor(s);
+    }
+}
+export function walkStatements(stmts, visitor) {
+    for (const stmt of stmts) {
+        visitor(stmt);
+        walkNestedStatements(stmt, (s) => walkStatements([s], visitor));
+    }
+}
+export function walkExpressionsInExpression(expr, visitor) {
+    if (!expr || typeof expr !== "object")
+        return;
+    visitor(expr);
+    if ("args" in expr && Array.isArray(expr.args)) {
+        for (const arg of expr.args)
+            walkExpressionsInExpression(arg, visitor);
+    }
+    if ("left" in expr)
+        walkExpressionsInExpression(expr.left, visitor);
+    if ("right" in expr)
+        walkExpressionsInExpression(expr.right, visitor);
+    if ("operand" in expr)
+        walkExpressionsInExpression(expr.operand, visitor);
+    if ("condition" in expr && typeof expr.condition === "object")
+        walkExpressionsInExpression(expr.condition, visitor);
+    if ("whenTrue" in expr)
+        walkExpressionsInExpression(expr.whenTrue, visitor);
+    if ("whenFalse" in expr)
+        walkExpressionsInExpression(expr.whenFalse, visitor);
+    if ("inner" in expr)
+        walkExpressionsInExpression(expr.inner, visitor);
+    if ("object" in expr && typeof expr.object === "object" && expr.kind !== "instanceof") {
+        walkExpressionsInExpression(expr.object, visitor);
+    }
+    if ("value" in expr && expr.value && typeof expr.value === "object" && "kind" in expr.value) {
+        walkExpressionsInExpression(expr.value, visitor);
+    }
+    if ("elements" in expr && Array.isArray(expr.elements)) {
+        for (const e of expr.elements)
+            walkExpressionsInExpression(e, visitor);
+    }
+    if ("fields" in expr && Array.isArray(expr.fields)) {
+        for (const f of expr.fields)
+            walkExpressionsInExpression(f.value, visitor);
+    }
+    if ("parts" in expr && Array.isArray(expr.parts)) {
+        for (const p of expr.parts)
+            walkExpressionsInExpression(p, visitor);
+    }
+    if ("expression" in expr && typeof expr.expression === "object" && "kind" in expr.expression) {
+        walkExpressionsInExpression(expr.expression, visitor);
+    }
+    if ("statements" in expr && Array.isArray(expr.statements)) {
+        for (const s of expr.statements) {
+            if ("value" in s && s.value && typeof s.value === "object")
+                walkExpressionsInExpression(s.value, visitor);
+            if ("args" in s && Array.isArray(s.args)) {
+                for (const a of s.args)
+                    walkExpressionsInExpression(a, visitor);
+            }
+            if ("initializer" in s && s.initializer)
+                walkExpressionsInExpression(s.initializer, visitor);
+            if ("condition" in s && typeof s.condition === "object")
+                walkExpressionsInExpression(s.condition, visitor);
+        }
+    }
+}
+export function walkExpressions(stmts, visitor) {
+    for (const stmt of stmts) {
+        if ("value" in stmt && stmt.value && typeof stmt.value === "object") {
+            walkExpressionsInExpression(stmt.value, visitor);
+        }
+        if ("condition" in stmt && typeof stmt.condition === "object") {
+            walkExpressionsInExpression(stmt.condition, visitor);
+        }
+        if ("args" in stmt && Array.isArray(stmt.args)) {
+            for (const arg of stmt.args)
+                walkExpressionsInExpression(arg, visitor);
+        }
+        if ("initializer" in stmt && stmt.initializer) {
+            walkExpressionsInExpression(stmt.initializer, visitor);
+        }
+        if ("expression" in stmt && typeof stmt.expression === "object") {
+            walkExpressionsInExpression(stmt.expression, visitor);
+        }
+        walkNestedStatements(stmt, (s) => walkExpressions([s], visitor));
+    }
+}
+export function walkProgramIR(program, visitor) {
+    walkStatements(program.topLevelStatements, visitor);
+    for (const fn of program.functions) {
+        walkStatements(fn.statements, visitor);
+    }
+    for (const cls of program.classes) {
+        if (cls.constructor)
+            walkStatements(cls.constructor.statements, visitor);
+        for (const method of cls.methods)
+            walkStatements(method.statements, visitor);
+        for (const getter of cls.getters)
+            walkStatements(getter.statements, visitor);
+        for (const setter of cls.setters)
+            walkStatements(setter.statements, visitor);
+    }
+    for (const ns of program.namespaces) {
+        walkNamespaceStatements(ns, visitor);
+    }
+}
+function walkNamespaceStatements(ns, visitor) {
+    for (const fn of ns.functions)
+        walkStatements(fn.statements, visitor);
+    for (const cls of ns.classes) {
+        if (cls.constructor)
+            walkStatements(cls.constructor.statements, visitor);
+        for (const method of cls.methods)
+            walkStatements(method.statements, visitor);
+        for (const getter of cls.getters)
+            walkStatements(getter.statements, visitor);
+        for (const setter of cls.setters)
+            walkStatements(setter.statements, visitor);
+    }
+    if (ns.children) {
+        for (const child of ns.children)
+            walkNamespaceStatements(child, visitor);
+    }
+}

package/dist/ir/validation-orchestrator.d.ts

@@ -0,0 +1,4 @@
+import type { Diagnostic } from "../types.js";
+import type { ProgramIR } from "../api/index.js";
+import type { PlatformStrategy } from "../api/shared/index.js";
+export declare function runProgramValidations(program: ProgramIR, strategy?: PlatformStrategy): Diagnostic[];

package/dist/ir/validation-orchestrator.js

@@ -0,0 +1,45 @@
+import { resolveStrategy } from "../platform/registry.js";
+import { hasLoadedFramework, getLoadedFramework } from "../framework-registry.js";
+import { analyzeInterruptSafety, inferVolatileForIsrSharedVars, detectReentrancyRisk } from "./interrupt-analysis.js";
+import { validateADCRange } from "./adc-range-validation.js";
+import { createEmptyPeripheralUsage } from "./peripheral-usage.js";
+import { validatePeripherals } from "./peripheral-validation.js";
+import { analyzeResources } from "./resource-analysis.js";
+import { validatePeripheralOwnership } from "./peripheral-ownership.js";
+import { validatePinAliasConflicts } from "./pin-alias-conflict.js";
+import { validatePinModeConfig } from "./pin-mode-validation.js";
+import { validateUnsafePins } from "./pin-safety.js";
+import { validatePulldownSupport } from "./pulldown-validation.js";
+import { validatePWMTimerSharing } from "./pwm-timer-sharing.js";
+import { validateTimer0PWMTimingConflict } from "./timer0-pwm-timing-conflict.js";
+import { validateTryCatch } from "./try-catch-validation.js";
+import { validateMemoryBudget } from "./memory-budget-validation.js";
+import { validateBlockingDelayInLoop } from "./timing-validation.js";
+import { validateUnitSuspicion } from "./unit-suspicion-validation.js";
+import { validateOwnership } from "./ownership-analysis.js";
+import { validatePinCapabilities } from "./pin-capability-validation.js";
+export function runProgramValidations(program, strategy) {
+    const resolvedStrategy = strategy ?? (hasLoadedFramework() ? getLoadedFramework().strategy : resolveStrategy('generic'));
+    const diagnostics = [];
+    const peripheralUsage = program.peripheralUsage ?? createEmptyPeripheralUsage();
+    diagnostics.push(...validatePinCapabilities(program));
+    diagnostics.push(...validatePeripherals(peripheralUsage, program.boardConstants));
+    diagnostics.push(...validateUnsafePins(peripheralUsage, program.boardConstants));
+    diagnostics.push(...analyzeResources(program, resolvedStrategy));
+    diagnostics.push(...validatePinAliasConflicts(peripheralUsage, program.boardConstants));
+    diagnostics.push(...validatePWMTimerSharing(peripheralUsage, program.boardConstants));
+    diagnostics.push(...validateTimer0PWMTimingConflict(peripheralUsage, program.boardConstants));
+    diagnostics.push(...validatePulldownSupport(peripheralUsage, program.boardConstants));
+    diagnostics.push(...analyzeInterruptSafety(program, peripheralUsage));
+    inferVolatileForIsrSharedVars(program, diagnostics);
+    detectReentrancyRisk(program, diagnostics);
+    diagnostics.push(...validateADCRange(program, program.boardConstants));
+    diagnostics.push(...validateUnitSuspicion(program));
+    diagnostics.push(...validatePinModeConfig(program));
+    diagnostics.push(...validatePeripheralOwnership(program));
+    diagnostics.push(...validateOwnership(program));
+    diagnostics.push(...validateTryCatch(program, program.boardConstants, resolvedStrategy));
+    diagnostics.push(...validateMemoryBudget(program, program.boardConstants));
+    diagnostics.push(...validateBlockingDelayInLoop(program));
+    return diagnostics;
+}

package/dist/libdef/base-class-resolver.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Resolves a base class name to the header file that declares it.
+ *
+ * Scoped to the set of .h files under a scan root — no parent-directory
+ * climbing. See
+ * docs/superpowers/specs/2026-06-20-gen-decls-inheritance-design.md.
+ */
+export type ResolveResult = {
+    kind: "found";
+    headerPath: string;
+} | {
+    kind: "external";
+};
+export declare class BaseClassResolver {
+    private readonly index;
+    constructor(index: Map<string, string>);
+    resolve(name: string): ResolveResult;
+}
+/**
+ * Walks a directory tree for .h files and builds Map<className, headerPath>.
+ * First declaration wins (deterministic). Recursive.
+ */
+export declare function buildClassIndex(dir: string): Map<string, string>;

package/dist/libdef/base-class-resolver.js

@@ -0,0 +1,50 @@
+/**
+ * Resolves a base class name to the header file that declares it.
+ *
+ * Scoped to the set of .h files under a scan root — no parent-directory
+ * climbing. See
+ * docs/superpowers/specs/2026-06-20-gen-decls-inheritance-design.md.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { parseHeader } from "./header-parser.js";
+export class BaseClassResolver {
+    constructor(index) {
+        this.index = index;
+    }
+    resolve(name) {
+        const headerPath = this.index.get(name);
+        if (headerPath !== undefined) {
+            return { kind: "found", headerPath };
+        }
+        return { kind: "external" };
+    }
+}
+/**
+ * Walks a directory tree for .h files and builds Map<className, headerPath>.
+ * First declaration wins (deterministic). Recursive.
+ */
+export function buildClassIndex(dir) {
+    const index = new Map();
+    if (!fs.existsSync(dir)) {
+        return index;
+    }
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            for (const [name, hp] of buildClassIndex(full)) {
+                if (!index.has(name))
+                    index.set(name, hp);
+            }
+        }
+        else if (entry.isFile() && entry.name.toLowerCase().endsWith(".h")) {
+            const content = fs.readFileSync(full, "utf8");
+            for (const cls of parseHeader(content)) {
+                if (!index.has(cls.name))
+                    index.set(cls.name, full);
+            }
+        }
+    }
+    return index;
+}

package/dist/libdef/cpp-to-decl.d.ts

@@ -0,0 +1,34 @@
+/**
+ * C++ to TypeScript Declaration Generator
+ *
+ * Parses simple C++ class definitions and generates .d.ts declaration files
+ * for use with TypeCAD's native module support.
+ */
+/**
+ * Backward-compat wrapper — delegates to generateDecl so legacy callers
+ * (e.g. cli.ts) keep resolving while the richer .h/.cpp merge lives in
+ * generateDecl.
+ */
+export declare function generateDeclFromCpp(cppFilePath: string, outputPath?: string): string | null;
+/**
+ * Scans a directory for .h and .cpp files and generates .d.ts files.
+ *
+ * Two passes:
+ *   1. Build a class-name → header-path index from all .h under dir.
+ *   2. For each .h (and .cpp with no sibling .h), parse + merge + emit with
+ *      cross-file base resolution.
+ */
+export declare function generateDeclsForDirectory(dir: string, recursive?: boolean): string[];
+/**
+ * Generates a .d.ts from a .h OR .cpp file.
+ *
+ * - For .h: parses the header; if a sibling .cpp exists, merges its
+ *   impl-only methods (ClassName::method) into the header's classes.
+ * - For .cpp: if a sibling .h exists, parses the header and merges; else
+ *   behaves as the legacy flattened path.
+ *
+ * Does NOT resolve cross-file base classes — bases from other headers are
+ * left as bare `extends Foo` (no import). Cross-file resolution is added in
+ * a later step for the directory-scan path.
+ */
+export declare function generateDecl(filePath: string, outputPath?: string): string | null;