@typecad/cuttlefish 1.0.0-alpha.13 → 1.0.0-alpha.15

package/dist/emit/utils/async-state-machine.js

@@ -12,12 +12,23 @@ import { routeHALOp } from "../route-hal-op.js";
  * @param str The input string (e.g., "my_function" or "myFunction")
  * @returns PascalCase string (e.g., "MyFunction")
  */
-export function toPascalCaseLocal(str) {
+function toPascalCaseLocal(str) {
     return str
         .split(/[_\s]+/)
         .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
         .join("");
 }
+/** Awaited callees that legitimately lower to a plain timed wait (their
+ *  single numeric argument IS the deadline). Everything else reaching the
+ *  plain-wait arm would have its call silently dropped — the embedding
+ *  emitter turns that into a diagnostic via onUnsupportedAwait. */
+const PLAIN_AWAIT_CALLEES = new Set([
+    "Async.sleep",
+    "AsyncClass.sleep",
+    "__cuttlefish_async_sleep",
+    "delay",
+    "sleep",
+]);
 /**
  * Generates a cooperative state-machine class for an async function.
  *
@@ -33,9 +44,11 @@ export function toPascalCaseLocal(str) {
  * @param knownFunctionReturnTypes Map of function names to their return types
  * @returns The class definition, instance declaration, and task variable name
  */
-export function generateAsyncTaskClass(fnName, fnStatements, strategy, knownFunctionReturnTypes, renderStatement) {
+export function generateAsyncTaskClass(fnName, fnStatements, strategy, knownFunctionReturnTypes, renderStatement, options) {
     const className = toPascalCaseLocal(fnName) + "Task";
     const instanceName = `${fnName}Task`;
+    const owner = options?.ownerClassName;
+    const starterName = `__tc_async_start_${fnName}`;
     // Detect whether the body is a single while-loop (cyclic) or linear statements
     let bodyStatements;
     let isCyclic = false;
@@ -51,7 +64,7 @@ export function generateAsyncTaskClass(fnName, fnStatements, strategy, knownFunc
     let currentPre = [];
     for (const stmt of bodyStatements) {
         if (stmt.kind === "call" && stmt.isAwaited) {
-            segments.push({ preStatements: currentPre, awaitedCallee: stmt.callee, awaitedArgs: stmt.args });
+            segments.push({ preStatements: currentPre, awaitedCallee: stmt.callee, awaitedArgs: stmt.args, awaitedSpan: stmt.sourceSpan });
             currentPre = [];
         }
         else if (
@@ -65,7 +78,7 @@ export function generateAsyncTaskClass(fnName, fnStatements, strategy, knownFunc
             stmt.body[stmt.body.length - 1].isAwaited) {
             const last = stmt.body[stmt.body.length - 1];
             currentPre.push(...stmt.body.slice(0, -1));
-            segments.push({ preStatements: currentPre, awaitedCallee: last.callee, awaitedArgs: last.args });
+            segments.push({ preStatements: currentPre, awaitedCallee: last.callee, awaitedArgs: last.args, awaitedSpan: last.sourceSpan });
             currentPre = [];
         }
         else {
@@ -173,7 +186,13 @@ export function generateAsyncTaskClass(fnName, fnStatements, strategy, knownFunc
             }
         }
         else {
-            // Plain timed wait (await delay(ms)) — arm its deadline.
+            // Plain timed wait (await delay(ms)) — arm its deadline. Anything whose
+            // callee is not a known timer shape has no cooperative lowering here:
+            // the call itself is NOT rendered (only marker/net awaits carry start
+            // code), so report it instead of silently dropping it.
+            if (!PLAIN_AWAIT_CALLEES.has(seg.awaitedCallee)) {
+                options?.onUnsupportedAwait?.(seg.awaitedCallee, seg.awaitedSpan);
+            }
             const ms = seg.awaitedArgs[0] ? renderExpression(seg.awaitedArgs[0], strategy) : "0";
             lines.push(`${pad}_waitUntil = ${strategy.currentTimeMillis()} + ${ms};`);
         }
@@ -265,19 +284,37 @@ export function generateAsyncTaskClass(fnName, fnStatements, strategy, knownFunc
         inits.push(`${m}(LOW)`);
     for (const m of tapMemberArr)
         inits.push(`${m}(0)`);
+    // Owner pointer (async methods): initialized null, bound by start(owner).
+    // Declared last / initialized last so the initializer list order matches.
+    if (owner)
+        inits.push("_owner(nullptr)");
     const ctorInitList = inits.join(", ");
     const edgeResetList = edgeMemberArr.map(m => ` ${m} = LOW;`).join("");
     const tapResetList = tapMemberArr.map(m => ` ${m} = 0;`).join("");
     const edgeMemberDecls = edgeMemberArr.map(m => `  int ${m};`);
     // __ui_tap_seq is uint32_t; the snapshot must match to detect bumps correctly.
     const tapMemberDecls = tapMemberArr.map(m => `  uint32_t ${m};`);
+    const ownerMemberDecl = owner ? [`  ${owner}* _owner;`] : [];
+    const runGuard = owner ? [`    if (_owner == nullptr) { return; }`] : [];
+    // start(owner): (re)bind the receiver and rewind the machine. Calling the
+    // async method again restarts the task with the new receiver — the task
+    // is a singleton per method, mirroring the free-function tasks.
+    const startMethod = owner ? [
+        `  void start(${owner}* owner) {`,
+        `    _owner = owner;`,
+        `    _state = ${Q_0};`,
+        `    _waitUntil = 0;${edgeResetList}${tapResetList}`,
+        `  }`,
+    ] : [];
     const classDef = [
         `// Async state machine for ${fnName}`,
         `class ${className} {`,
         `public:`,
         `  enum class State { ${stateEnumList} };`,
         `  ${className}() : ${ctorInitList} {}`,
+        ...startMethod,
         `  void run() {`,
+        ...runGuard,
         `    switch (_state) {`,
         ...caseLines,
         `    }`,
@@ -289,9 +326,13 @@ export function generateAsyncTaskClass(fnName, fnStatements, strategy, knownFunc
         `  unsigned long _waitUntil;`,
         ...edgeMemberDecls,
         ...tapMemberDecls,
+        ...ownerMemberDecl,
         `};`,
     ].join("\n");
-    return { classDef, instanceDecl: `${className} ${instanceName};`, taskVarName: instanceName };
+    const starterDef = owner
+        ? `void ${starterName}(${owner}* owner) { ${instanceName}.start(owner); }`
+        : undefined;
+    return { classDef, instanceDecl: `${className} ${instanceName};`, taskVarName: instanceName, starterDef };
 }
 /**
  * Renders an expression to a string (simplified version for async state machine).
@@ -346,10 +387,16 @@ function netWaitInfo(op, strategy) {
     const route = (routedOp) => routeHALOp(routedOp, strategy);
     const expr = (operation) => route({ operation })?.expression ?? null;
     switch (op.operation) {
-        case "timing.delay":
+        case "timing.sleep":
+            // Pure deadline wait: no start op, no poll — the machine arms
+            // _waitUntil and cooperatively yields until it passes. Bare
+            // (non-awaited) calls lower to the blocking form (k_msleep).
             return { startLines: [], pollCond: null, timeoutExpr: ms(o.ms) };
-        case "wifi.connect": {
-            const start = route({ operation: "wifi.connect_start", ssid: o.ssid, password: o.password });
+        case "wifi.join": {
+            // Awaited join splits into the staged association + the L4 poll.
+            // (Static-IPv4/power-save facts are join()-side blocking-path extras;
+            // the async form associates with defaults and polls connectivity.)
+            const start = route({ operation: "wifi.connect_start", ssid: o.ssid, password: o.psk });
             const poll = expr("wifi.is_connected");
             if (start?.code && poll) {
                 return {
@@ -360,24 +407,6 @@ function netWaitInfo(op, strategy) {
             }
             break;
         }
-        case "wifi.wait_connected": {
-            const poll = expr("wifi.is_connected");
-            if (poll) {
-                return {
-                    startLines: [],
-                    pollCond: poll,
-                    timeoutExpr: isZeroTimeout(o.timeoutMs) ? null : ms(o.timeoutMs),
-                };
-            }
-            break;
-        }
-        case "wifi.wait_disconnected": {
-            const poll = expr("wifi.is_connected");
-            if (poll) {
-                return { startLines: [], pollCond: `!${poll}`, timeoutExpr: null };
-            }
-            break;
-        }
         case "wifi.scan": {
             const start = route({ operation: "wifi.scan_start" });
             const poll = expr("wifi.scan_done");
@@ -394,33 +423,6 @@ function netWaitInfo(op, strategy) {
             }
             break;
         }
-        case "ble.until_connected": {
-            const start = route({ operation: "ble.until_connected_start" });
-            const poll = expr("ble.is_connected");
-            if (start?.code && poll) {
-                return {
-                    startLines: [start.code],
-                    pollCond: poll,
-                    timeoutExpr: isZeroTimeout(o.timeoutMs) ? null : ms(o.timeoutMs),
-                };
-            }
-            break;
-        }
-        case "worker.submit": {
-            // Worker offload (Phase 3). `await worker.submit(fn, arg)` rewrites to:
-            // submit the worker (start), then poll worker.done on the same handle.
-            // The submit op is emitted verbatim as the start line; the poll predicate
-            // is worker.done(handle) carrying the SAME handleId. This is a predicate-
-            // poll resume (same per-frame cost as net/timer awaits), NOT an ISR-driven
-            // resume — that defers with DMA-backed awaits.
-            const submit = routeHALOp(op, strategy);
-            // Carry the handle through to the poll so submit + done agree on the slot.
-            const poll = route({ operation: "worker.done", handleId: o.handleId })?.expression ?? null;
-            if (submit?.code && poll) {
-                return { startLines: [submit.code], pollCond: poll, timeoutExpr: null };
-            }
-            break;
-        }
     }
     // Fallback: run the blocking form immediately and complete on the next tick.
     const blocking = routeHALOp(op, strategy);

package/dist/emit/utils/comment-helpers.d.ts

@@ -2,14 +2,6 @@
  * Comment handling utilities for C++ code emission.
  * Extracted from cpp-emitter.ts
  */
-/**
- * Normalizes a comment string into an array of trimmed lines.
- * Removes empty lines and trailing whitespace.
- *
- * @param comment The comment string (may contain newlines)
- * @returns Array of normalized comment lines
- */
-export declare function normalizeComment(comment: string): string[];
 /**
  * Emits comment lines with proper indentation.
  *

package/dist/emit/utils/comment-helpers.js

@@ -9,7 +9,7 @@
  * @param comment The comment string (may contain newlines)
  * @returns Array of normalized comment lines
  */
-export function normalizeComment(comment) {
+function normalizeComment(comment) {
     return comment
         .split(/\r?\n/)
         .map((line) => line.trimEnd())

package/dist/emit/utils/cpp-helpers.d.ts

@@ -1,8 +1,8 @@
 export declare function accessorGetterName(prop: string): string;
 export declare function accessorSetterName(prop: string): string;
 /**
- * Matches a C++ INTEGRAL scalar type (the enum↔integral storage boundary in
- * SUPPORT_MATRIX §1.7). Used by the enum-storage cast sites to decide whether
+ * Matches a C++ INTEGRAL scalar type (the enum↔integral storage boundary).
+ * Used by the enum-storage cast sites to decide whether
  * a value/target is on the integral side of an `enum class` boundary that
  * needs a `static_cast`. Covers the signed/unsigned `char`/`short`/`int`/
  * `long` spellings, the fixed-width `<cstdint>` aliases, `size_t`, and `bool`

package/dist/emit/utils/cpp-helpers.js

@@ -5,8 +5,8 @@ export function accessorSetterName(prop) {
     return `set${prop.charAt(0).toUpperCase()}${prop.slice(1)}`;
 }
 /**
- * Matches a C++ INTEGRAL scalar type (the enum↔integral storage boundary in
- * SUPPORT_MATRIX §1.7). Used by the enum-storage cast sites to decide whether
+ * Matches a C++ INTEGRAL scalar type (the enum↔integral storage boundary).
+ * Used by the enum-storage cast sites to decide whether
  * a value/target is on the integral side of an `enum class` boundary that
  * needs a `static_cast`. Covers the signed/unsigned `char`/`short`/`int`/
  * `long` spellings, the fixed-width `<cstdint>` aliases, `size_t`, and `bool`

package/dist/emit/utils/hal-op-cpp-type.js

@@ -7,33 +7,31 @@ export function cppTypeForHalOp(operation) {
     switch (operation) {
         case "wifi.local_ip":
         case "wifi.mac":
-        case "wifi.ap_ip":
         case "wifi.scan_ssid":
         case "http.body":
         case "http.response_header":
             return "const char*";
         case "wifi.is_connected":
-        case "wifi.connect":
-        case "wifi.wait_connected":
+        case "wifi.join":
         case "wifi.scan_done":
         case "wifi.ap_start":
-        case "wifi.connect_saved":
         case "http.ok":
         case "http.done":
             return "bool";
-        case "wifi.status":
         case "wifi.rssi":
         case "wifi.scan":
         case "wifi.scan_count":
         case "wifi.scan_rssi":
         case "wifi.scan_encryption":
         case "wifi.scan_channel":
-        case "wifi.ap_client_count":
         case "http.status":
         case "http.content_length":
             return "int";
         case "http.send":
             return "bool";
+        // Zephyr's sensor channel value is a double (val1 + val2/1e6).
+        case "sensor.get":
+            return "double";
         default:
             return undefined;
     }

package/dist/emit/utils/index.d.ts

@@ -2,7 +2,7 @@
  * Emitter utilities barrel export.
  * Re-exports all utility functions for C++ code emission.
  */
-export { inferObjectFieldType, collectNestedStructDefs, hasArrayInObjectLiteral, hasThrowStatements, hasStdMathCalls, hasConsoleCalls, isConsoleCall, getConsoleMethod, isRuntimeExpression, statementRequiresRuntime, collectPointerVarTypes, collectExpressionIdentifiers, } from "./type-inference.js";
-export { toPascalCaseLocal, generateAsyncTaskClass, type AsyncTaskClassResult, } from "./async-state-machine.js";
+export { inferObjectFieldType, collectNestedStructDefs, hasArrayInObjectLiteral, hasThrowStatements, hasStdMathCalls, isRuntimeExpression, statementRequiresRuntime, collectPointerVarTypes, collectExpressionIdentifiers, } from "./type-inference.js";
+export { generateAsyncTaskClass, type AsyncTaskClassResult, } from "./async-state-machine.js";
 export { isCuttlefishSDKImport, normalizeInclude, dedupe, resolveTranspiledModuleInclude, applySymbolMap, } from "./include-resolver.js";
-export { normalizeComment, emitCommentLines, } from "./comment-helpers.js";
+export { emitCommentLines, } from "./comment-helpers.js";

package/dist/emit/utils/index.js

@@ -3,10 +3,10 @@
  * Re-exports all utility functions for C++ code emission.
  */
 // Type inference utilities
-export { inferObjectFieldType, collectNestedStructDefs, hasArrayInObjectLiteral, hasThrowStatements, hasStdMathCalls, hasConsoleCalls, isConsoleCall, getConsoleMethod, isRuntimeExpression, statementRequiresRuntime, collectPointerVarTypes, collectExpressionIdentifiers, } from "./type-inference.js";
+export { inferObjectFieldType, collectNestedStructDefs, hasArrayInObjectLiteral, hasThrowStatements, hasStdMathCalls, isRuntimeExpression, statementRequiresRuntime, collectPointerVarTypes, collectExpressionIdentifiers, } from "./type-inference.js";
 // Async state machine utilities
-export { toPascalCaseLocal, generateAsyncTaskClass, } from "./async-state-machine.js";
+export { generateAsyncTaskClass, } from "./async-state-machine.js";
 // Include resolution utilities
 export { isCuttlefishSDKImport, normalizeInclude, dedupe, resolveTranspiledModuleInclude, applySymbolMap, } from "./include-resolver.js";
 // Comment handling utilities
-export { normalizeComment, emitCommentLines, } from "./comment-helpers.js";
+export { emitCommentLines, } from "./comment-helpers.js";

package/dist/emit/utils/type-inference.d.ts

@@ -2,7 +2,7 @@
  * Type inference utilities for C++ code emission.
  * Pure functions with no side effects - extracted from cpp-emitter.ts
  */
-import type { ExpressionIR, StatementIR, PlatformStrategy } from "../../api/index.js";
+import type { ExpressionIR, StatementIR } from "../../api/index.js";
 /**
  * Infers the C++ type for an object field based on its initializer value.
  *
@@ -104,34 +104,6 @@ export declare function hasStdMathCalls(program: {
         };
     }>;
 }): boolean;
-/**
- * Checks if a program contains console.* calls (console.log, console.error, etc.)
- *
- * @param program The program IR to analyze
- * @returns true if console calls are found
- */
-export declare function hasConsoleCalls(program: {
-    topLevelStatements: StatementIR[];
-    functions: Array<{
-        statements: StatementIR[];
-    }>;
-    classes: Array<{
-        methods: Array<{
-            statements: StatementIR[];
-        }>;
-        constructor?: {
-            statements: StatementIR[];
-        };
-    }>;
-}, strategy?: PlatformStrategy): boolean;
-/**
- * Checks if a callee is a console method call (e.g., "console.log", "console.error")
- */
-export declare function isConsoleCall(callee: string, strategy?: PlatformStrategy): boolean;
-/**
- * Gets the console method name from a callee (e.g., "log" from "console.log")
- */
-export declare function getConsoleMethod(callee: string): string;
 /**
  * Checks if an expression requires runtime execution (cannot be evaluated at global scope in C++).
  * Compile-time expressions can be placed at global scope; runtime expressions must go in setup()/main().

package/dist/emit/utils/type-inference.js

@@ -330,81 +330,6 @@ export function hasStdMathCalls(program) {
     }
     return false;
 }
-/**
- * Checks if a program contains console.* calls (console.log, console.error, etc.)
- *
- * @param program The program IR to analyze
- * @returns true if console calls are found
- */
-export function hasConsoleCalls(program, strategy) {
-    const checkStatements = (statements) => {
-        for (const stmt of statements) {
-            if (stmt.kind === "call" && isConsoleCall(stmt.callee, strategy)) {
-                return true;
-            }
-            // Check nested statements in control flow
-            if ("body" in stmt && Array.isArray(stmt.body)) {
-                if (checkStatements(stmt.body))
-                    return true;
-            }
-            if ("thenBranch" in stmt && Array.isArray(stmt.thenBranch)) {
-                if (checkStatements(stmt.thenBranch))
-                    return true;
-            }
-            if ("elseBranch" in stmt && Array.isArray(stmt.elseBranch)) {
-                if (checkStatements(stmt.elseBranch))
-                    return true;
-            }
-            if ("cases" in stmt && Array.isArray(stmt.cases)) {
-                for (const c of stmt.cases) {
-                    if (checkStatements(c.body))
-                        return true;
-                }
-            }
-            if ("tryBlock" in stmt && Array.isArray(stmt.tryBlock)) {
-                if (checkStatements(stmt.tryBlock))
-                    return true;
-            }
-            if ("catchBlock" in stmt && Array.isArray(stmt.catchBlock)) {
-                if (checkStatements(stmt.catchBlock))
-                    return true;
-            }
-        }
-        return false;
-    };
-    // Check all functions
-    for (const fn of program.functions) {
-        if (checkStatements(fn.statements))
-            return true;
-    }
-    // Check top-level statements
-    if (checkStatements(program.topLevelStatements))
-        return true;
-    // Check class methods
-    for (const cls of program.classes) {
-        for (const method of cls.methods) {
-            if (checkStatements(method.statements))
-                return true;
-        }
-        if (cls.constructor && checkStatements(cls.constructor.statements))
-            return true;
-    }
-    return false;
-}
-/**
- * Checks if a callee is a console method call (e.g., "console.log", "console.error")
- */
-export function isConsoleCall(callee, strategy) {
-    if (strategy)
-        return strategy.isConsoleCall(callee);
-    return callee.startsWith("console.");
-}
-/**
- * Gets the console method name from a callee (e.g., "log" from "console.log")
- */
-export function getConsoleMethod(callee) {
-    return callee.slice("console.".length);
-}
 /**
  * Checks if an expression requires runtime execution (cannot be evaluated at global scope in C++).
  * Compile-time expressions can be placed at global scope; runtime expressions must go in setup()/main().

package/dist/framework-package.d.ts

@@ -5,6 +5,9 @@
  * Optional exports include `Toolchain`, `SYMBOL_KINDS`, library resolver,
  * class name map builder, and lib declaration generator.
  *
+ * Built-in frameworks (see BUILTIN_FRAMEWORK_MODULES) are loaded from this
+ * package directly; everything else resolves from the project directory.
+ *
  * Returns the raw module for backward compatibility.
  */
 export declare function loadFrameworkPackage(packageName: string, fromDir?: string): any;

package/dist/framework-package.js

@@ -2,7 +2,18 @@ import path from "node:path";
 import { createRequire } from "node:module";
 import { setLoadedFramework } from "./framework-registry.js";
 import { registerPlatformStrategy } from "./platform/registry.js";
+import * as nativeFramework from "./frameworks/native/index.js";
 const require = createRequire(import.meta.url);
+/**
+ * Frameworks that ship inside @typecad/cuttlefish instead of as separate
+ * @typecad/framework-* npm packages. Their config string stays the historical
+ * package name for continuity; the module is loaded directly instead of via
+ * require.resolve. (The native framework was merged in from the former
+ * @typecad/framework-native package.)
+ */
+const BUILTIN_FRAMEWORK_MODULES = {
+    "@typecad/framework-native": nativeFramework,
+};
 function resolveFrameworkPackage(packageName, fromDir = process.cwd()) {
     try {
         const resolved = require.resolve(packageName, { paths: [path.resolve(fromDir)] });
@@ -29,15 +40,21 @@ function extractToolchain(mod) {
  * Optional exports include `Toolchain`, `SYMBOL_KINDS`, library resolver,
  * class name map builder, and lib declaration generator.
  *
+ * Built-in frameworks (see BUILTIN_FRAMEWORK_MODULES) are loaded from this
+ * package directly; everything else resolves from the project directory.
+ *
  * Returns the raw module for backward compatibility.
  */
 export function loadFrameworkPackage(packageName, fromDir = process.cwd()) {
-    const packagePath = resolveFrameworkPackage(packageName, fromDir);
-    if (!packagePath) {
-        throw new Error(`Unable to resolve framework package '${packageName}' from '${fromDir}'. ` +
-            `Install it or pass a different framework package name in your TypeCAD config.`);
-    }
-    const mod = require(packagePath);
+    const builtin = BUILTIN_FRAMEWORK_MODULES[packageName];
+    const mod = builtin ?? (() => {
+        const packagePath = resolveFrameworkPackage(packageName, fromDir);
+        if (!packagePath) {
+            throw new Error(`Unable to resolve framework package '${packageName}' from '${fromDir}'. ` +
+                `Install it or pass a different framework package name in your TypeCAD config.`);
+        }
+        return require(packagePath);
+    })();
     // Populate the registry with the loaded framework components
     if (mod.FrameworkStrategy) {
         const strategy = new mod.FrameworkStrategy();

package/dist/framework-registry.d.ts

@@ -4,11 +4,11 @@ import type { CompileResult, UploadResult, ToolchainOptions } from "./api/shared
  * Components loaded from a framework package.
  */
 export interface LoadedFramework {
-    /** The platform strategy (e.g. ArduinoStrategy, NativeAVRStrategy) */
+    /** The platform strategy (e.g. ZephyrStrategy, NativeStrategy) */
     strategy: PlatformStrategy;
     /** Optional toolchain for compile/upload/monitor (framework-specific) */
     toolchain?: FrameworkToolchain;
-    /** Framework library import resolution (e.g., Arduino library detection) */
+    /** Framework library import resolution (e.g., framework library detection) */
     libraryResolver?: FrameworkLibraryResolver;
     /** Framework class name mapping for library imports */
     classNameMapBuilder?: (imports: any[]) => Map<string, string>;
@@ -18,15 +18,15 @@ export interface LoadedFramework {
      * Optional subcommand presenters owned by the framework. Cuttlefish dispatches
      * `cuttlefish doctor` / `cuttlefish licenses` to these when the loaded
      * framework provides them; otherwise it prints a no-support message. Each
-     * framework decides what (if anything) these do — e.g. framework-arduino
-     * checks arduino-cli + board core (doctor) and scans Arduino library licenses
+     * framework decides what (if anything) these do — e.g. framework-zephyr
+     * checks west + board target (doctor) and scans library licenses
      * (licenses).
      */
     doctor?: () => void;
     licenses?: (strict: boolean, all: boolean) => void;
 }
 /**
- * Resolves framework-specific library imports (e.g., Arduino libraries).
+ * Resolves framework-specific library imports.
  */
 export interface FrameworkLibraryResolver {
     isFrameworkLibraryImport(moduleSpecifier: string): boolean;

package/dist/frameworks/native/graphics/terminal-preview.d.ts

@@ -0,0 +1,5 @@
+import type { DisplayHALOp } from '../../../api/shared/index.js';
+export declare function resolveTerminalPreviewOp(op: DisplayHALOp): {
+    code?: string;
+    expression?: string;
+} | undefined;

package/dist/frameworks/native/graphics/terminal-preview.js

@@ -0,0 +1,33 @@
+// ---------------------------------------------------------------------------
+// Terminal preview — renders display ops as ANSI-colored cells to stdout
+//
+// Lets authors preview a UI on the host with no hardware. Colors map rgb565
+// back to the nearest ANSI 16-color for display only.
+// ---------------------------------------------------------------------------
+/** Map an rgb565 value to an ANSI color code (approximate). */
+function rgb565ToAnsi(c) {
+    const r5 = (c >> 11) & 0x1f;
+    const g6 = (c >> 5) & 0x3f;
+    const b5 = c & 0x1f;
+    const r = r5 >> 3, g = g6 >> 4, b = b5 >> 3; // 0/1 per channel
+    // ANSI 16-color: foreground 30+bit pattern
+    return 30 + (r ? 1 : 0) + (g ? 2 : 0) + (b ? 4 : 0);
+}
+export function resolveTerminalPreviewOp(op) {
+    switch (op.operation) {
+        case "display.init":
+            return { code: `/* native preview: ${op.driver} ${op.width}x${op.height} initialized */` };
+        case "display.fill_rect":
+            return {
+                code: `/* preview fill_rect ${op.x},${op.y} ${op.w}x${op.h} color=0x${op.color.toString(16)} ansi=${rgb565ToAnsi(op.color)} */`,
+            };
+        case "display.draw_rect":
+            return { code: `/* preview draw_rect ${op.x},${op.y} ${op.w}x${op.h} */` };
+        case "display.draw_text":
+            return { code: `/* preview draw_text ${op.x},${op.y} "${op.text}" */` };
+        case "display.flush":
+            return { code: `/* preview flush ${op.rects.length} rect(s) */` };
+        default:
+            return undefined;
+    }
+}

package/dist/frameworks/native/index.d.ts

@@ -0,0 +1,3 @@
+export { NativeStrategy, NativeStrategy as FrameworkStrategy } from './strategy.js';
+export { NativeToolchain as Toolchain } from './native-compile.js';
+export type { NativeCompileConfig } from './native-config.js';

package/dist/frameworks/native/index.js

@@ -0,0 +1,15 @@
+// ---------------------------------------------------------------------------
+// Native C++ framework — built into @typecad/cuttlefish
+//
+// Outputs standard C++ for portable Windows/Linux desktop executables.
+// Uses main(), std::string, and std::thread-based async.
+//
+// Usage:
+//   In cuttlefish.config.ts:
+//     framework: '@typecad/framework-native'
+// (The config string keeps the historical package name; the module is
+//  loaded directly by framework-package.ts, no npm package involved.)
+// ---------------------------------------------------------------------------
+export { NativeStrategy, NativeStrategy as FrameworkStrategy } from './strategy.js';
+// Native C++ toolchain (g++/clang++ compilation)
+export { NativeToolchain as Toolchain } from './native-compile.js';

package/dist/frameworks/native/native-compile.d.ts

@@ -0,0 +1,17 @@
+import type { CompileResult, ToolchainOptions } from '../../api/shared/index.js';
+/**
+ * Resolve the -l link libraries for a native build.
+ *
+ * The SDL display driver (#include <SDL2/SDL.h>) requires core SDL2 at link
+ * time on every platform; Windows/MSYS2 additionally needs -lmingw32 and
+ * -lSDL2main for the Win32 GUI entry-point glue (the SDL_MAIN_HANDLED define
+ * + SDL_SetMainReady() in display_init). Because the cuttlefish config loader
+ * is AST-only (it cannot evaluate process.platform conditionals), these libs
+ * are auto-provided here when the `sdl` display driver is active, so a single
+ * config links on both Windows and Linux without a platform-specific
+ * `native.libraries` array. User-supplied libraries are appended (deduped).
+ */
+export declare function resolveLinkLibraries(display: Record<string, unknown> | undefined, userLibs: string[]): string[];
+export declare const NativeToolchain: {
+    compile(options: ToolchainOptions): CompileResult;
+};