@typecad/cuttlefish 1.0.0-alpha.14 → 1.0.0-alpha.16

package/dist/safety/runtime/write-verify.d.ts

@@ -0,0 +1,8 @@
+import type { RuntimePolyfillIR } from "../../api/index.js";
+/** Write-then-readback verification. Tree-shaken out unless
+ *  __tc_safety_write_verify appears in the program (registered in
+ *  POLYFILL_HELPER_MAP).
+ *
+ *  MCU-agnosticism: writes via the strategy-injected __tc_gpio_write shim,
+ *  reads back via __tc_gpio_read — references zero target-specific symbols. */
+export declare function writeVerifyPolyfill(): RuntimePolyfillIR;

package/dist/safety/runtime/write-verify.js

@@ -0,0 +1,71 @@
+/** Write-then-readback verification. Tree-shaken out unless
+ *  __tc_safety_write_verify appears in the program (registered in
+ *  POLYFILL_HELPER_MAP).
+ *
+ *  MCU-agnosticism: writes via the strategy-injected __tc_gpio_write shim,
+ *  reads back via __tc_gpio_read — references zero target-specific symbols. */
+export function writeVerifyPolyfill() {
+    return {
+        kind: "polyfill",
+        id: "safety_write_verify",
+        domain: "embedded",
+        requiredIncludes: [],
+        forwardDeclarations: [],
+        helperStructs: [],
+        helperFunctions: [`
+// Forward declaration — the strategy's shimLines() defines this AFTER the
+// polyfill block (polyfills emit before shims in emitPreamble).
+void __tc_gpio_write(uint32_t pin, uint32_t value);
+int __tc_gpio_read(uint32_t pin);
+
+namespace __tc_safety {
+
+inline SafeWriteResult write_verify(uint32_t pin, uint32_t value) {
+  SafeWriteResult result;
+  result.code   = SafetyFaultCode::Ok;
+  result.status = SafetyStatus::Ok;
+
+  const TrackedMode mode = get_pin_mode(pin);
+  if (mode == TrackedMode::Unknown) {
+    result.code   = SafetyFaultCode::PinModeUnknown;
+    result.status = SafetyStatus::Fault;
+    return result;
+  }
+  if (mode != TrackedMode::Output) {
+    result.code   = SafetyFaultCode::PinModeMismatch;
+    result.status = SafetyStatus::Fault;
+    return result;
+  }
+
+  __tc_gpio_write(pin, (value != 0U) ? 0x1U : 0x0U);
+
+  // Read back the pin to verify the write took effect. On AVR/ESP32
+  // Arduino core, digitalRead on an OUTPUT pin returns the last value
+  // written to the PORT register, so this check catches software bugs
+  // (wrong pin, wrong mode) but not electrical faults (shorted pin,
+  // disconnected wire). True electrical verification requires external
+  // circuitry routing the output back to a separate input pin.
+  const int rd = __tc_gpio_read(pin);
+  const uint32_t readback = rd ? 0xFFFFFFFFU : 0x00000000U;
+  const uint32_t expected = (value != 0U) ? 0xFFFFFFFFU : 0x00000000U;
+
+  if (readback == expected) {
+    result.status = SafetyStatus::Ok;
+    result.code   = SafetyFaultCode::Ok;
+  } else {
+    result.status = SafetyStatus::Fault;
+    result.code   = SafetyFaultCode::WriteMismatch;
+  }
+  return result;
+}
+
+}  // namespace __tc_safety
+
+inline SafeWriteResult __tc_safety_write_verify(uint32_t pin, uint32_t value) {
+  return __tc_safety::write_verify(pin, value);
+}
+`.trim()],
+        shimMacros: [],
+        dependencies: ["safety_mode_table"],
+    };
+}

package/dist/safety/safe-int-types.d.ts

@@ -0,0 +1,45 @@
+/** SafeInt<T> — chainable bounds-checked signed-integer arithmetic.
+ *
+ *  The cuttlefish transpiler resolves SafeInt<number> to the C++ template
+ *  form SafeInt<int32_t> (and SafeInt<int8_t>/<int16_t>/<int64_t> for the
+ *  corresponding TS fixed-width aliases), and the safety polyfill provides
+ *  the template definition.
+ *
+ *  Signed integer T only. The emitted C++ template carries a static_assert
+ *  that rejects unsigned integers, bool, floating-point, and non-integer
+ *  types (notably string) at compile time.
+ *
+ *  Mutating chain: every math operation returns the same SafeInt<T> (by
+ *  reference) so calls chain: `x.add(5).mul(2).get()`. On overflow or
+ *  division error, a sticky fault flag is set and subsequent operations in
+ *  the chain become no-ops; get() returns the last good value. Check
+ *  hasFault() (or valid()) after a chain on safety-critical paths.
+ *
+ *  Usage:
+ *    let x: SafeInt<int32_t> = SafeInt(10);
+ *    x.add(5).mul(2);             // mutating chain — x is now 30
+ *    if (x.valid()) {
+ *      const v: int32_t = x.get();
+ *    }
+ */
+export interface SafeInt<T = number> {
+    add(delta: T): SafeInt<T>;
+    sub(delta: T): SafeInt<T>;
+    mul(factor: T): SafeInt<T>;
+    divide(d: T): SafeInt<T>;
+    mod(d: T): SafeInt<T>;
+    negate(): SafeInt<T>;
+    absValue(): SafeInt<T>;
+    get(): T;
+    /** True iff a prior operation in this chain overflowed or hit a division
+     *  error. Sticky — once set, stays set until reset(). While true, all
+     *  further math operations are no-ops and get() returns the last good
+     *  value. */
+    hasFault(): boolean;
+    /** !hasFault(). Symmetric with SafeVariable.valid(). */
+    valid(): boolean;
+    /** Clear the fault flag and set a new value. The only way to re-arm a
+     *  faulted SafeInt without reconstructing it. */
+    reset(newValue: T): void;
+}
+export declare function SafeInt<T>(initial: T): SafeInt<T>;

package/dist/safety/safe-int-types.js

@@ -0,0 +1,25 @@
+/** SafeInt<T> — chainable bounds-checked signed-integer arithmetic.
+ *
+ *  The cuttlefish transpiler resolves SafeInt<number> to the C++ template
+ *  form SafeInt<int32_t> (and SafeInt<int8_t>/<int16_t>/<int64_t> for the
+ *  corresponding TS fixed-width aliases), and the safety polyfill provides
+ *  the template definition.
+ *
+ *  Signed integer T only. The emitted C++ template carries a static_assert
+ *  that rejects unsigned integers, bool, floating-point, and non-integer
+ *  types (notably string) at compile time.
+ *
+ *  Mutating chain: every math operation returns the same SafeInt<T> (by
+ *  reference) so calls chain: `x.add(5).mul(2).get()`. On overflow or
+ *  division error, a sticky fault flag is set and subsequent operations in
+ *  the chain become no-ops; get() returns the last good value. Check
+ *  hasFault() (or valid()) after a chain on safety-critical paths.
+ *
+ *  Usage:
+ *    let x: SafeInt<int32_t> = SafeInt(10);
+ *    x.add(5).mul(2);             // mutating chain — x is now 30
+ *    if (x.valid()) {
+ *      const v: int32_t = x.get();
+ *    }
+ */
+export {};

package/dist/safety/safe-variable-types.d.ts

@@ -0,0 +1,29 @@
+/** SafeVariable<T> — SEU-resistant storage with inverted-redundancy.
+ *
+ *  The cuttlefish transpiler resolves SafeVariable<number> to the C++
+ *  template form SafeVariable<int> (or int32_t under --autosar), and the
+ *  safety polyfill provides the template definition.
+ *
+ *  Arithmetic T only. The emitted C++ template carries a static_assert that
+ *  rejects non-arithmetic types (notably string) and bool at compile time.
+ *  float/double have explicit specializations (3-copy plain TMR — bitwise
+ *  inversion is not defined for floating-point).
+ *
+ *  Usage:
+ *    let x: SafeVariable<number> = SafeVariable(0);
+ *    x.set(2000);
+ *    const current = x.get();      // best-effort value
+ *    if (x.hasFault()) { ... }     // triple corruption — get() is untrusted
+ *    if (x.valid()) { ... }        // all three replicas agree and pass XOR checks
+ */
+export interface SafeVariable<T = number> {
+    set(value: T): void;
+    get(): T;
+    valid(): boolean;
+    /** True iff the most recent get() found zero valid replicas (triple
+     *  corruption). Cleared by set() and by a subsequent get() that finds at
+     *  least one valid replica. Check this after get() on safety-critical
+     *  paths; a true return means the returned value is untrusted. */
+    hasFault(): boolean;
+}
+export declare function SafeVariable(initial: number): SafeVariable<any>;

package/dist/safety/safe-variable-types.js

@@ -0,0 +1,19 @@
+/** SafeVariable<T> — SEU-resistant storage with inverted-redundancy.
+ *
+ *  The cuttlefish transpiler resolves SafeVariable<number> to the C++
+ *  template form SafeVariable<int> (or int32_t under --autosar), and the
+ *  safety polyfill provides the template definition.
+ *
+ *  Arithmetic T only. The emitted C++ template carries a static_assert that
+ *  rejects non-arithmetic types (notably string) and bool at compile time.
+ *  float/double have explicit specializations (3-copy plain TMR — bitwise
+ *  inversion is not defined for floating-point).
+ *
+ *  Usage:
+ *    let x: SafeVariable<number> = SafeVariable(0);
+ *    x.set(2000);
+ *    const current = x.get();      // best-effort value
+ *    if (x.hasFault()) { ... }     // triple corruption — get() is untrusted
+ *    if (x.valid()) { ... }        // all three replicas agree and pass XOR checks
+ */
+export {};

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

@@ -1,11 +1,10 @@
-/** 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). */
+/** Load the safety engine and register the hook. Called by transpile.ts at
+ *  the start of each transpile run. */
 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. */
+/** Test-only: force the bridge into the "safety not loaded" state — mark the
+ *  load as already attempted and leave the hook null, exactly as the old
+ *  dynamic import behaved when @typecad/safety was not installed. */
 export declare function __simulateSafetyAbsentForTest(): void;

package/dist/safety/safety-bridge.js

@@ -1,37 +1,24 @@
 // ---------------------------------------------------------------------------
-// Safety bridge — loads the safety engine from @typecad/safety and registers it.
+// Safety bridge — registers the built-in safety engine.
 //
-// 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.
+// The engine used to ship as the optional @typecad/safety package and was
+// loaded via a dynamic package import; it now lives in this package under
+// src/safety/. transpile.ts still calls loadSafetyEngine() at the start of
+// transpileFile(), and the hook seam (safety-hook.ts) is unchanged so the
+// degradation paths (resetSafetyEngine / __simulateSafetyAbsentForTest) keep
+// working for tests.
 // ---------------------------------------------------------------------------
 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). */
+/** Load the safety engine and register the hook. Called by transpile.ts at
+ *  the start of each transpile run. */
 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.
-    }
+    const engine = await import("./engine.js");
+    const hook = engine.registerSafetyEngine();
+    setSafetyHook(hook);
 }
 /** Reset the safety bridge: forget a load was attempted and clear the hook.
  *  Mirrors resetUIEngine() so each transpile run / test starts clean. */
@@ -39,9 +26,9 @@ 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. */
+/** Test-only: force the bridge into the "safety not loaded" state — mark the
+ *  load as already attempted and leave the hook null, exactly as the old
+ *  dynamic import behaved when @typecad/safety was not installed. */
 export function __simulateSafetyAbsentForTest() {
     loaded = true;
     setSafetyHook(null);

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

@@ -1,5 +1,3 @@
 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). */
+/** Render the safety sidecar artifact via the built-in ISO 26262 writer. */
 export declare function renderSafetySidecar(metadata: SafetyMetadata, toolVersion: string): Promise<string>;

package/dist/safety/sidecar-bridge.js

@@ -1,22 +1,5 @@
-/** 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). */
+import { renderSafetySidecar as renderSidecar } from "./iso26262/sidecar-writer.js";
+/** Render the safety sidecar artifact via the built-in ISO 26262 writer. */
 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);
-    }
+    return renderSidecar(metadata, toolVersion);
 }

package/dist/safety/specifiers.d.ts

@@ -0,0 +1,6 @@
+/** The canonical specifier for the safety authoring surface. */
+export declare const SAFETY_SPECIFIER = "@typecad/cuttlefish/safety";
+/** The legacy specifier from when safety was a standalone package. */
+export declare const LEGACY_SAFETY_SPECIFIER = "@typecad/safety";
+/** True iff an import specifier refers to the safety authoring surface. */
+export declare function isSafetyImportSpecifier(moduleSpecifier: string): boolean;

package/dist/safety/specifiers.js

@@ -0,0 +1,14 @@
+// Import specifiers that activate the safety engine. The safety engine was
+// merged into @typecad/cuttlefish from the former @typecad/safety package;
+// both specifiers keep working. Detection is purely by name — the module is
+// never resolved or parsed (the graph builder skips it), so the legacy
+// specifier does not require the frozen npm package to be installed.
+/** The canonical specifier for the safety authoring surface. */
+export const SAFETY_SPECIFIER = "@typecad/cuttlefish/safety";
+/** The legacy specifier from when safety was a standalone package. */
+export const LEGACY_SAFETY_SPECIFIER = "@typecad/safety";
+/** True iff an import specifier refers to the safety authoring surface. */
+export function isSafetyImportSpecifier(moduleSpecifier) {
+    return (moduleSpecifier === SAFETY_SPECIFIER ||
+        moduleSpecifier === LEGACY_SAFETY_SPECIFIER);
+}

package/dist/safety-hook.d.ts

@@ -1,8 +1,9 @@
 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. */
+    /** True iff the entry file imports `safe` from the safety authoring
+     *  surface (@typecad/cuttlefish/safety, or legacy @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-
@@ -30,7 +31,7 @@ export interface TranspilerSafetyHook {
     } | 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. */
+     *  safety authoring surface. 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.
@@ -48,12 +49,12 @@ export interface TranspilerSafetyHook {
      *  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. */
+/** Set the safety hook. Called by transpile.ts after loading the 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. */
+/** Get the current safety hook, or null if the safety engine is not loaded. */
 export declare function getSafetyHook(): TranspilerSafetyHook | null;
-/** Returns true if the safety hook is registered (i.e. @typecad/safety loaded). */
+/** Returns true if the safety hook is registered (i.e. safety engine loaded). */
 export declare function hasSafetyHook(): boolean;
 /** Get the safety hook, throwing if it's not set. Use only inside
  *  `if (hasSafetyHook())` guards. */

package/dist/safety-hook.js

@@ -1,25 +1,24 @@
 // ---------------------------------------------------------------------------
-// Safety hook — the contract cuttlefish core uses to talk to the optional
-// @typecad/safety package. Modeled on ui-hook.ts.
+// Safety hook — the contract cuttlefish core uses to talk to the safety
+// engine. 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.
+// The engine lives in this package (src/safety/engine.ts); transpile.ts calls
+// loadSafetyEngine() at the start of each run, which registers an
+// implementation of this interface. The seam is kept so the degradation paths
+// (resetSafetyEngine / __simulateSafetyAbsentForTest) stay testable.
 // ---------------------------------------------------------------------------
 // ── 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. */
+/** Set the safety hook. Called by transpile.ts after loading the 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. */
+/** Get the current safety hook, or null if the safety engine is not loaded. */
 export function getSafetyHook() {
     return safetyHook;
 }
-/** Returns true if the safety hook is registered (i.e. @typecad/safety loaded). */
+/** Returns true if the safety hook is registered (i.e. safety engine loaded). */
 export function hasSafetyHook() {
     return safetyHook !== null;
 }
@@ -27,8 +26,8 @@ export function hasSafetyHook() {
  *  `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 " +
+        throw new Error("Safety hook is not registered. This code path requires the safety " +
+            "engine to be loaded. This should not happen — the hook is set " +
             "at the start of transpileFile() when safety is detected.");
     }
     return safetyHook;

package/dist/testing.d.ts

@@ -19,11 +19,8 @@ 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, runCreateWizard, } from "./create/index.js";
+export { scaffoldProject, normalizeProjectName, generateProjectPackageJson, generateProjectTsconfig, generateProjectConfig, generateProjectEnvDts, generateStarterProgram, generateStarterTest, generateStarterSim, generateGitignore, generateEslintConfig, runCreateWizard, } from "./create/index.js";
 export type { CreateProjectOptions } 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";
@@ -37,6 +34,8 @@ export type { ESLintError } from "./eslint-check.js";
 export { checkLintCache, recordLintSuccess, invalidateLint, computeLintFingerprint, resolveEslintConfigPath, } from "./lint-cache.js";
 export type { LintFingerprint, GateCacheResult } from "./lint-cache.js";
 export { runSemanticGates } from "./orchestrator/type-checker.js";
+export { readGeneratedBoardConstants } from "./ir/board-resolver.js";
+export { pinEntryIndexForNumber } from "./ir/pin-capability-validation.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";
@@ -46,7 +45,7 @@ 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, generateComponentDeclsForProject } from "./libdef/cpp-to-decl.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

@@ -23,10 +23,7 @@ export { resetUIEngine, __simulateUIAbsentForTest } from "./ui/ui-bridge.js";
 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, runCreateWizard, } from "./create/index.js";
-// ── Board codegen (`cuttlefish board add`) ───────────────────────────────────
-export { scaffoldBoardPackages, parseBoardSpec, safeParseBoardSpec, stripJsonc, } from "./create/index.js";
-export { BoardGenerators } from "./create/index.js";
+export { scaffoldProject, normalizeProjectName, generateProjectPackageJson, generateProjectTsconfig, generateProjectConfig, generateProjectEnvDts, generateStarterProgram, generateStarterTest, generateStarterSim, generateGitignore, generateEslintConfig, runCreateWizard, } from "./create/index.js";
 // ── Tree-shaking & reachability ──────────────────────────────────────────────
 export { buildCallGraph, getReachableSymbols } from "./ir/call-graph.js";
 export { detectEntryPoints, detectExportedEntryPoints } from "./ir/entry-points.js";
@@ -43,6 +40,9 @@ export { runEslintCheck } from "./eslint-check.js";
 export { checkLintCache, recordLintSuccess, invalidateLint, computeLintFingerprint, resolveEslintConfigPath, } from "./lint-cache.js";
 // ── Semantic gates (TypeChecker-based) ──────────────────────────────────────
 export { runSemanticGates } from "./orchestrator/type-checker.js";
+// ── Board constants / pin capability internals ──────────────────────────────
+export { readGeneratedBoardConstants } from "./ir/board-resolver.js";
+export { pinEntryIndexForNumber } from "./ir/pin-capability-validation.js";
 export { canonicalize, buildSemanticFacts, } from "./orchestrator/semantic-facts.js";
 export { verifyFacts } from "./orchestrator/semantic-facts-verifier.js";
 // ── Watch & CLI utilities ───────────────────────────────────────────────────
@@ -50,7 +50,7 @@ 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, generateComponentDeclsForProject } from "./libdef/cpp-to-decl.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

@@ -18,7 +18,7 @@ export interface TranspileGraphResult {
     /** `.ui.html` modules discovered during graph build, keyed by resolved path. */
     uiModules: Set<string>;
 }
-export declare function resolveImport(fromFile: string, moduleSpecifier: string, boardPackage?: string): {
+export declare function resolveImport(fromFile: string, moduleSpecifier: string, boardTarget?: string): {
     sourcePath: string;
     npmPackage?: ResolvedNpmPackage;
     uiModule?: boolean;

package/dist/transpile/resolution.js

@@ -1,5 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
+import { findGeneratedBoard } from "../ir/board-resolver.js";
 function resolveLocalImport(fromFile, moduleSpecifier) {
     if (!moduleSpecifier.startsWith(".")) {
         return undefined;
@@ -179,13 +180,19 @@ function resolveNpmPackageImport(fromFile, moduleSpecifier) {
         moduleKey,
     };
 }
-export function resolveImport(fromFile, moduleSpecifier, boardPackage) {
+export function resolveImport(fromFile, moduleSpecifier, boardTarget) {
     let effectiveSpecifier = moduleSpecifier;
-    // The `@typecad/board` virtual import resolves to the configured board package.
-    // (Case-insensitive so the documented mixed-case form is treated identically.)
-    if (moduleSpecifier.toLowerCase() === "@typecad/board" && boardPackage) {
-        effectiveSpecifier = boardPackage;
+    // The `@typecad/board` virtual import resolves to the project-local
+    // generated board module (.cuttlefish/board.ts) when one exists — the
+    // config's board target materialized by boardgen. Falls through to the
+    // package-based path otherwise (transition; board packages are going away).
+    if (moduleSpecifier.toLowerCase() === "@typecad/board") {
+        const generated = findGeneratedBoard(fromFile);
+        if (generated) {
+            return { sourcePath: generated.boardTs };
+        }
     }
+    void boardTarget;
     const localResolved = resolveLocalImport(fromFile, effectiveSpecifier);
     if (localResolved) {
         // .ui.html files resolve as UI modules, not TypeScript sources. Only set
@@ -271,12 +278,14 @@ export function detectNativeCppModule(fromFile, moduleSpecifier) {
 export function isCuttlefishSDKPath(filePath) {
     const normalized = filePath.replace(/\\/g, "/");
     return (/\/code\/core\//.test(normalized) ||
-        /\/code\/board-/.test(normalized) ||
-        /\/packages\/board-/.test(normalized) ||
         /\/packages\/expect\//.test(normalized) ||
         /\/packages\/cuttlefish\//.test(normalized) ||
-        /\/node_modules\/@typecad\/board-/.test(normalized) ||
         /\/node_modules\/@typecad\/core\//.test(normalized) ||
         /\/node_modules\/@typecad\/expect\//.test(normalized) ||
-        /\/node_modules\/@typecad\/cuttlefish\//.test(normalized));
+        /\/node_modules\/@typecad\/cuttlefish\//.test(normalized) ||
+        // The generated project-local board module: like @typecad/hal, its source
+        // exists for pin resolution (halInstances / board constants), never for
+        // C++ emission — transpiling it would treat LED/PA5 as cross-module
+        // imports instead of compile-time pin facts.
+        /\/\.cuttlefish\/board\.ts$/.test(normalized));
 }

package/dist/transpile/test-pins.d.ts

@@ -0,0 +1,18 @@
+export interface TestPinsFile {
+    pins?: Record<string, string | string[]>;
+    facts?: Record<string, number>;
+}
+/** Read and parse a project's test-pins.json. Returns undefined when absent. */
+export declare function readTestPinsFile(projectDir: string): TestPinsFile | undefined;
+/**
+ * Build the generated module's source: role consts re-exported from the
+ * board package. Used by the editor-support generator
+ * (.cuttlefish/test-pins.ts — see config-loader's generateVirtualTypeDeclaration)
+ * so the language server resolves the '@typecad/test-pins' specifier.
+ * Hardware runs do NOT transpile this module: the @typecad/expect
+ * preprocessor substitutes role identifiers in test sources with the
+ * board's real pin symbols before the transpiler runs (the HAL resolves
+ * pins through board-package metadata, not through transpiled modules).
+ * Returns undefined when the board declares no usable roles.
+ */
+export declare function buildTestPinsModuleContent(boardTarget: string, data: TestPinsFile): string | undefined;