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

package/dist/ir/hal/hal-parser.js

@@ -4,7 +4,7 @@ import { createRequire } from "node:module";
 import { fileURLToPath } from "node:url";
 import ts from "typescript";
 import { parseSource } from "../../ast/parse.js";
-import { requiredIncludes, getCurrentBoardConstants, mcuPinForwardMap, mcuPinReverseMap, halInstances, topLevelAliasReceivers } from "../build-ir-state.js";
+import { requiredIncludes, getCurrentBoardConstants, mcuPinForwardMap, mcuPinReverseMap, halInstances, topLevelAliasReceivers, pinAliasMap } from "../build-ir-state.js";
 import { mapPeripheralName } from "../../mapping/peripheral-names.js";
 import { escapeCppStringLiteral } from "../../utils/strings.js";
 const require = createRequire(import.meta.url);
@@ -167,6 +167,18 @@ export function loadHALModules(force = false) {
                     let instanceName;
                     let includes;
                     const defaultFields = new Map();
+                    const fieldDefaults = new Map();
+                    for (const member of stmt.members) {
+                        // Instance property initializers with literal values (`private
+                        // readonly _spiHz: number = 1000000;`) are static facts — the
+                        // default a method body sees when construction didn't override.
+                        if (ts.isPropertyDeclaration(member) && ts.isIdentifier(member.name) && member.initializer) {
+                            const init = member.initializer;
+                            if (ts.isNumericLiteral(init) || ts.isStringLiteral(init)) {
+                                fieldDefaults.set(member.name.text, init.text);
+                            }
+                        }
+                    }
                     for (const member of stmt.members) {
                         if (ts.isPropertyDeclaration(member) &&
                             member.modifiers?.some(m => m.kind === ts.SyntaxKind.StaticKeyword) &&
@@ -186,7 +198,7 @@ export function loadHALModules(force = false) {
                             }
                         }
                     }
-                    halClassRegistry.set(className, { ctorFieldMap, ctorDefaults, methods });
+                    halClassRegistry.set(className, { ctorFieldMap, ctorDefaults, fieldDefaults, methods });
                     if (instanceName) {
                         halSingletons.set(instanceName, { className, fieldValues: defaultFields, includes });
                     }
@@ -210,21 +222,79 @@ export function loadHALModules(force = false) {
 export function getCtorIncludes(className) {
     return halCtorIncludes.get(className) ?? [];
 }
-/** Map an HttpClass factory method name to its HTTP verb, or null. */
-export function httpFactoryVerb(methodName) {
-    switch (methodName) {
-        case "get": return "GET";
-        case "post": return "POST";
-        case "put": return "PUT";
-        case "del": return "DELETE";
-        case "head": return "HEAD";
-        case "patch": return "PATCH";
-        default: return null;
-    }
-}
 /** Render an Http factory URL argument as C++ expression text (string
  *  literals quoted, identifiers/member accesses verbatim), or null when the
  *  argument shape can't be resolved at compile time. */
+/** Capture `new Request(method, url, opts?)` construction facts into
+ *  fieldValues (method token/string → verb, URL as C++ text, opts with
+ *  class-default sentinels so send()'s setter calls always resolve).
+ *  Returns null when the arg shapes don't resolve. */
+/** Top-level `const NAME = "literal"` lookup, or null. One pass over the
+ *  file's statements — cheap and cached by the TS compiler. */
+function topLevelStringConst(sourceFile, name) {
+    for (const stmt of sourceFile.statements) {
+        if (!ts.isVariableStatement(stmt))
+            continue;
+        for (const decl of stmt.declarationList.declarations) {
+            if (ts.isIdentifier(decl.name) && decl.name.text === name
+                && decl.initializer && ts.isStringLiteral(decl.initializer)) {
+                return decl.initializer.text;
+            }
+        }
+    }
+    return null;
+}
+export function requestCtorFields(ctorArgs, sourceFile) {
+    if (!ctorArgs || ctorArgs.length < 2)
+        return null;
+    const fieldValues = new Map();
+    const methodArg = ctorArgs[0];
+    if (ts.isStringLiteral(methodArg)) {
+        fieldValues.set("_method", methodArg.text.toUpperCase());
+    }
+    else if (ts.isPropertyAccessExpression(methodArg) && methodArg.expression.getText() === "Request") {
+        fieldValues.set("_method", methodArg.name.text);
+    }
+    else {
+        return null;
+    }
+    const urlText = httpUrlArgText(ctorArgs[1]);
+    if (!urlText)
+        return null;
+    fieldValues.set("_url", urlText);
+    fieldValues.set("_timeoutMs", "10000");
+    fieldValues.set("_body", '""');
+    fieldValues.set("_json", "false");
+    fieldValues.set("_insecure", "false");
+    fieldValues.set("_caCert", '""');
+    const opts = ctorArgs[2];
+    if (opts && ts.isObjectLiteralExpression(opts)) {
+        for (const prop of opts.properties) {
+            if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name))
+                continue;
+            const name = prop.name.text;
+            if (name === "timeoutMs" && ts.isNumericLiteral(prop.initializer)) {
+                fieldValues.set("_timeoutMs", prop.initializer.text.replace(/_/g, ""));
+            }
+            else if (name === "body" || name === "caCert") {
+                // Literal, or an identifier resolving to a top-level string const
+                // (the PEM-as-const pattern the hardware suite uses).
+                if (ts.isStringLiteral(prop.initializer)) {
+                    fieldValues.set("_" + name, JSON.stringify(prop.initializer.text));
+                }
+                else if (ts.isIdentifier(prop.initializer) && sourceFile) {
+                    const lit = topLevelStringConst(sourceFile, prop.initializer.text);
+                    if (lit !== null)
+                        fieldValues.set("_" + name, JSON.stringify(lit));
+                }
+            }
+            else if (name === "json" || name === "insecure") {
+                fieldValues.set("_" + name, prop.initializer.kind === ts.SyntaxKind.TrueKeyword ? "true" : "false");
+            }
+        }
+    }
+    return fieldValues;
+}
 export function httpUrlArgText(arg) {
     if (ts.isStringLiteral(arg) || ts.isNoSubstitutionTemplateLiteral(arg))
         return JSON.stringify(arg.text);
@@ -242,7 +312,7 @@ export function resolveHALReceiver(receiver) {
             const inst = halInstances.get(receiver.text);
             if (inst)
                 return inst;
-            // Metadata-driven singleton resolution (e.g., ADC, EEPROM, WDT)
+            // Metadata-driven singleton resolution (e.g., ADC, WDT)
             const singleton = halSingletons.get(receiver.text);
             if (singleton) {
                 if (singleton.includes) {
@@ -265,13 +335,35 @@ export function resolveHALReceiver(receiver) {
             if (mappedName) {
                 const canonical = name.toUpperCase();
                 if (canonical.startsWith("UART"))
-                    return { className: "SerialPort", fieldValues: new Map([["_port", mappedName]]) };
+                    return {
+                        className: "UART",
+                        fieldValues: new Map([["_port", mappedName], ["_bus", mappedName], ["_baud", "115200"], ["_rxBufferBytes", "64"]]),
+                    };
+                if (canonical.startsWith("USB"))
+                    return { className: "USBConsole", fieldValues: new Map([["_port", mappedName]]) };
                 if (canonical.startsWith("I2C"))
                     return { className: "I2CBus", fieldValues: new Map([["_bus", mappedName]]) };
                 if (canonical.startsWith("SPI"))
                     return { className: "SPIBus", fieldValues: new Map([["_bus", mappedName]]) };
             }
-            // Bare pin resolution (D0, A0, etc.) — enriched with MCU port name
+            // Board-module pin constant (LED, BUTTON, D0, A0, connector labels,
+            // datasheet-named pins — anything the generated board manifest maps
+            // through pins.aliases.*). Checked BEFORE the legacy Arduino D/A
+            // arithmetic below: the alias carries the board's actual wiring, which
+            // the Arduino-style offset math cannot know (the XIAO's D0 is
+            // gpio0.2, not Arduino pin 0).
+            const aliasNum = pinAliasMap.get(name);
+            if (getCurrentBoardConstants() && aliasNum !== undefined) {
+                const portName = mcuPinReverseMap.get(aliasNum);
+                const fields = new Map([["_pin", aliasNum]]);
+                if (portName)
+                    fields.set("_port", portName);
+                const inst = { className: "Pin", fieldValues: fields };
+                halInstances.set(name, inst);
+                return inst;
+            }
+            // Legacy Arduino-style D/A fallback (no board manifest — the old
+            // package-less path or bare-silicon configs).
             const dMatch = name.match(/^D(\d+)$/);
             if (dMatch) {
                 const arduinoPin = dMatch[1];
@@ -323,11 +415,18 @@ export function resolveHALReceiver(receiver) {
                     const returnClassName = methodName === "asOutput" ? "OutputPin" : "InputPin";
                     return { className: returnClassName, fieldValues: new Map(innerInstance.fieldValues) };
                 }
-                // Specialized handling for device() factory pattern (I2CBus/SPIBus -> I2CDevice/SPIDevice)
+                // Specialized handling for device() factory pattern (I2CBus/SPIBus -> I2CTarget/SPITarget)
                 // This allows propagating the address/CS pin from the call argument to the new instance.
                 if (methodName === "device" && (innerInstance.className === "I2CBus" || innerInstance.className === "SPIBus") && receiver.arguments.length > 0) {
-                    const returnClassName = innerInstance.className === "SPIBus" ? "SPIDevice" : "I2CDevice";
+                    const isSpi = innerInstance.className === "SPIBus";
+                    const returnClassName = isSpi ? "SPITarget" : "I2CTarget";
                     const fieldValues = new Map(innerInstance.fieldValues);
+                    // The targets' __default_fields channel does not reach factory-made
+                    // instances; carry the class defaults so `this._hz`/`this._mode`
+                    // resolve in the inlined method bodies.
+                    fieldValues.set("_hz", isSpi ? "1000000" : "0");
+                    if (isSpi)
+                        fieldValues.set("_mode", "0");
                     const arg = receiver.arguments[0];
                     let argVal = null;
                     if (ts.isNumericLiteral(arg))
@@ -360,22 +459,6 @@ export function resolveHALReceiver(receiver) {
                         return { className: "ToneChain", fieldValues };
                     }
                 }
-                // Specialized handling for Http factory chaining
-                // (Http.get(url).header(...).send()): the factory records the HTTP
-                // verb and URL into the HttpRequest instance so send() can resolve
-                // this._method / this._url.
-                if (innerInstance.className === "HttpClass") {
-                    const verb = httpFactoryVerb(methodName);
-                    if (verb && receiver.arguments.length > 0) {
-                        const urlText = httpUrlArgText(receiver.arguments[0]);
-                        if (urlText) {
-                            return {
-                                className: "HttpRequest",
-                                fieldValues: new Map([["_method", verb], ["_url", urlText]]),
-                            };
-                        }
-                    }
-                }
                 // Specialized handling for BLE factory chaining
                 // (Ble.server(name).characteristic(uuid,type,perms).onRead(handler)):
                 // server() creates a BleServer. The characteristic index is taken from a
@@ -431,6 +514,11 @@ export function resolveHALReceiver(receiver) {
         // Inline new expression: new Pin(x).method()
         if (ts.isNewExpression(receiver) && ts.isIdentifier(receiver.expression)) {
             const className = receiver.expression.text;
+            if (className === "Request") {
+                const reqFields = requestCtorFields(receiver.arguments, receiver.getSourceFile());
+                if (reqFields)
+                    return { className, fieldValues: reqFields };
+            }
             const classEntry = halClassRegistry.get(className);
             if (!classEntry)
                 return null;
@@ -474,8 +562,12 @@ export function resolveHALReceiver(receiver) {
                     }
                     // I2C/SPI device factory: bus → device with address/cs from args
                     if (entry.method === "device" && (resolvedInst.className === "I2CBus" || resolvedInst.className === "SPIBus")) {
-                        const returnClassName = resolvedInst.className === "SPIBus" ? "SPIDevice" : "I2CDevice";
+                        const isSpi = resolvedInst.className === "SPIBus";
+                        const returnClassName = isSpi ? "SPITarget" : "I2CTarget";
                         const fieldValues = new Map(resolvedInst.fieldValues);
+                        fieldValues.set("_hz", isSpi ? "1000000" : "0");
+                        if (isSpi)
+                            fieldValues.set("_mode", "0");
                         const fieldName = resolvedInst.className === "SPIBus" ? "_cs" : "_address";
                         if (entry.args && entry.args.length > 0) {
                             // Resolve identifier args (e.g. D10 → 10) via halInstances.

package/dist/ir/hal/hal-plugins.d.ts

@@ -2,7 +2,6 @@ import ts from "typescript";
 import { HALOpIR } from "../../api/index.js";
 import { HALInstance } from "./hal-parser.js";
 import type { ExpressionIR } from "../../api/index.js";
-/** Resolve a single argument from a semantic call's AST node list. */
 export declare function resolveSemanticArg(args: readonly ts.Expression[], idx: number, instance: HALInstance, paramNames: string[], callArgTexts: string[], paramDefaults: Map<string, string> | undefined): string | null;
 /** Resolve a numeric argument, returning its numeric value or null. */
 export declare function resolveNumericArg(args: readonly ts.Expression[], idx: number, instance: HALInstance, paramNames: string[], callArgTexts: string[], paramDefaults: Map<string, string> | undefined): number | null;