@typecad/framework-zephyr 1.0.0-alpha.15 → 1.0.0-alpha.18

package/dist/lowering/mqtt.js

@@ -13,7 +13,11 @@
 // shim getaddrinfo-resolves the broker host itself (like the HTTP shim).
 // URI scheme: mqtt:// → 1883 plain TCP, mqtts:// → 8883 TLS
 // (MQTT_TRANSPORT_SECURE + mqtt_sec_config, reusing the same mbedTLS matrix
-// the HTTP TLS path established).
+// the HTTP TLS path established). caCert pins the broker's CA — the PEM is
+// DER-decoded at emit time and registered via tls_credential_add as a
+// CA_CERTIFICATE sec tag with TLS_PEER_VERIFY_REQUIRED (verified TLS, the
+// MQTT analogue of Request's caCert); mqtts:// without a CA stays
+// encrypted-but-unverified (TLS_PEER_VERIFY_NONE).
 //
 // One client slot (HAL singleton). on_message callbacks are dispatched on the
 // poll thread.
@@ -45,6 +49,8 @@ export function mqttInitLines() {
         `// at connect time; host drives both DNS resolution and the TLS SNI/hostname.`,
         `// on_message is the user callback (set via mqtt.on_message); it fires on the`,
         `// poll thread for every incoming PUBLISH on a subscribed topic.`,
+        `// ca_der is the pinned CA (DER, user-owned from the caCert fact); nullptr`,
+        `// means mqtts:// runs encrypted-but-unverified.`,
         `typedef void (*__tc_mqtt_msg_cb_t)(const char* topic, const char* payload);`,
         `static struct {`,
         `    struct mqtt_client client;`,
@@ -55,6 +61,16 @@ export function mqttInitLines() {
         `    uint16_t port;             // 1883 / 8883 unless overridden in the URI`,
         `    char client_id[64];`,
         `    bool tls;                  // scheme == "mqtts"`,
+        `    const uint8_t* ca_der;     // pinned CA (DER), nullptr = no CA`,
+        `    size_t ca_der_len;`,
+        `    // What this shim last registered under __TC_MQTT_SEC_TAG (DER arrays`,
+        `    // are function-static, so pointer identity is stable). Zephyr's`,
+        `    // credential store never REPLACES a tag — repeats are skipped, a`,
+        `    // different CA at an occupied tag is reported, not silent.`,
+        `    const uint8_t* ca_added;`,
+        `    size_t ca_added_len;`,
+        `    bool ca_added_set;`,
+        `    sec_tag_t sec_tags[1];     // backs tls.config.sec_tag_list (static lifetime)`,
         `    volatile bool connected;`,
         `    volatile bool stop_poll;   // set by disconnect to terminate the poll thread`,
         `    __tc_mqtt_msg_cb_t on_message;`,
@@ -196,6 +212,35 @@ export function mqttInitLines() {
         `    return host_len > 0U;`,
         `}`,
         ``,
+        `// Strict IPv4 dotted-quad predicate: exactly four 0-255 groups. A`,
+        `// digit-and-dot scan would also swallow numeric-only DNS names ("123"),`,
+        `// silently skipping the TLS hostname check for them (same helper as the`,
+        `// HTTP shim).`,
+        `static bool __tc_mqtt_host_is_ipv4(const char* h) {`,
+        `    uint32_t quads = 0U;`,
+        `    uint32_t val = 0U;`,
+        `    uint32_t digits = 0U;`,
+        `    for (const char* p = h; ; p++) {`,
+        `        if (*p >= '0' && *p <= '9') {`,
+        `            val = (val * 10U) + static_cast<uint32_t>(*p - '0');`,
+        `            digits++;`,
+        `            if (digits > 3U || val > 255U) return false;`,
+        `        } else if (*p == '.') {`,
+        `            if (digits == 0U || quads >= 3U) return false;`,
+        `            quads++;`,
+        `            val = 0U;`,
+        `            digits = 0U;`,
+        `        } else if (*p == '\\0') {`,
+        `            if (digits == 0U) return false;`,
+        `            quads++;`,
+        `            break;`,
+        `        } else {`,
+        `            return false;`,
+        `        }`,
+        `    }`,
+        `    return quads == 4U;`,
+        `}`,
+        ``,
         `// ── connect ─────────────────────────────────────────────────────────────`,
         `// Parse URI → resolve broker → init client → mqtt_connect → spawn poll thread.`,
         `// Blocks until CONNACK (the poll thread isn't running yet, so we drive a few`,
@@ -244,14 +289,47 @@ export function mqttInitLines() {
         `        __tc_mqtt.client.transport.type = MQTT_TRANSPORT_SECURE;`,
         `        struct mqtt_sec_config* tls_cfg = &__tc_mqtt.client.transport.tls.config;`,
         `        (void)memset(tls_cfg, 0, sizeof(*tls_cfg));`,
-        `        // The HAL MQTT surface has no CA-pinning op (unlike HTTP's caCert), so`,
-        `        // there is no way to register a trusted CA here. Verify-NONE keeps the`,
-        `        // TLS session encrypted but skips identity verification — the strongest`,
-        `        // the current surface can express. A future mqtt.set_ca_cert op would`,
-        `        // flip this to REQUIRED + a registered sec_tag (like the HTTPS path).`,
-        `        tls_cfg->peer_verify = TLS_PEER_VERIFY_NONE;`,
+        `        if (__tc_mqtt.ca_der != nullptr) {`,
+        `            // Pinned CA (the caCert construction fact): register it as a`,
+        `            // CA_CERTIFICATE sec tag and REQUIRE peer verification — the MQTT`,
+        `            // analogue of the HTTPS caCert path. Zephyr's credential store`,
+        `            // never REPLACES a tag+type pair: re-registering the same DER`,
+        `            // (pointer identity — the arrays are function-static) is skipped`,
+        `            // silently; a DIFFERENT CA hitting an occupied tag is reported so`,
+        `            // a wrong-CA verify is never silent; any other failure keeps the`,
+        `            // tag list empty and verification required — fail closed.`,
+        `            if (!__tc_mqtt.ca_added_set || __tc_mqtt.ca_added != __tc_mqtt.ca_der`,
+        `                || __tc_mqtt.ca_added_len != __tc_mqtt.ca_der_len) {`,
+        `                int cred_rc = tls_credential_add(__TC_MQTT_SEC_TAG,`,
+        `                                                 TLS_CREDENTIAL_CA_CERTIFICATE,`,
+        `                                                 __tc_mqtt.ca_der, __tc_mqtt.ca_der_len);`,
+        `                __tc_mqtt.ca_added = __tc_mqtt.ca_der;`,
+        `                __tc_mqtt.ca_added_len = __tc_mqtt.ca_der_len;`,
+        `                __tc_mqtt.ca_added_set = true;`,
+        `                if (cred_rc == -17 /* -EEXIST */) {`,
+        `                    printk("tc-mqtt: sec tag %d already holds a CA; the first one stays active (rc=%d)\\n", __TC_MQTT_SEC_TAG, cred_rc);`,
+        `                } else if (cred_rc != 0) {`,
+        `                    printk("tc-mqtt: CA registration failed (rc=%d) - verifying against no credentials\\n", cred_rc);`,
+        `                }`,
+        `            }`,
+        `            if (__tc_mqtt.ca_added_set) {`,
+        `                __tc_mqtt.sec_tags[0] = __TC_MQTT_SEC_TAG;`,
+        `                tls_cfg->sec_tag_list = __tc_mqtt.sec_tags;`,
+        `                tls_cfg->sec_tag_count = 1U;`,
+        `            }`,
+        `            tls_cfg->peer_verify = TLS_PEER_VERIFY_REQUIRED;`,
+        `        } else {`,
+        `            // No CA pinned: the session is encrypted but the broker's identity`,
+        `            // is not verified — the strongest the no-caCert form can express.`,
+        `            tls_cfg->peer_verify = TLS_PEER_VERIFY_NONE;`,
+        `        }`,
         `        tls_cfg->cipher_list = nullptr;`,
-        `        tls_cfg->hostname = __tc_mqtt.host;`,
+        `        // mbedtls does not match IP literals against SAN entries — set the`,
+        `        // hostname (SNI + identity check) only for name hosts; IP brokers`,
+        `        // verify chain-only (same policy as the HTTPS path).`,
+        `        if (!__tc_mqtt_host_is_ipv4(__tc_mqtt.host)) {`,
+        `            tls_cfg->hostname = __tc_mqtt.host;`,
+        `        }`,
         `#else`,
         `        printk("tc-mqtt: mqtts:// requested but CONFIG_MQTT_LIB_TLS is off\\n");`,
         `        return;`,
@@ -303,6 +381,10 @@ export function mqttInitLines() {
         `    __tc_mqtt.on_message = fn;`,
         `}`,
         ``,
+        `// ca_cert is the DER-decoded PEM from the caCert construction fact`,
+        `// (user-owned static array; nullptr = no pinned CA).`,
+        `static inline void __tc_mqtt_set_ca_cert_der(const uint8_t* der, size_t len) { __tc_mqtt.ca_der = der; __tc_mqtt.ca_der_len = len; }`,
+        ``,
         `static inline void __tc_mqtt_subscribe(const char* topic) {`,
         `    static struct mqtt_topic topics[4];`,
         `    static uint16_t msg_id = 1;`,
@@ -356,6 +438,26 @@ export function lowerMqtt(op) {
     switch (op.operation) {
         case 'mqtt.connect':
             return { code: `__tc_mqtt_connect(${s(o.brokerUri)}, ${s(o.clientId)});` };
+        case 'mqtt.set_ca_cert': {
+            // PEM → DER at emit time (this tree's tf-psa-crypto mbedTLS has no PEM
+            // parser — same decode as http.set_ca_cert; tls_credential_add takes
+            // the DER directly).
+            const pem = String(o.pem ?? '').replace(/^"|"$/g, '').replace(/\\n/g, '\n');
+            if (pem.replace(/\s+/g, '') === '') {
+                // No-CA sentinel (Mqtt always emits the op from connect(); opts.caCert
+                // defaults to '') — elide silently so plain-mqtt:// carries no comment.
+                return { code: '' };
+            }
+            const b64 = pem.replace(/-----[A-Z ]+-----/g, '').replace(/\s+/g, '');
+            const der = Buffer.from(b64, 'base64');
+            // Every X.509 DER starts with the ASN.1 SEQUENCE tag (0x30); a long
+            // but non-cert payload fails here instead of at a confusing handshake
+            // error on the target (same check as http.set_ca_cert).
+            if (der.length < 100 || der[0] !== 0x30)
+                return { code: `// tc-mqtt: caCert PEM failed to decode` };
+            const hex = [...der].map((b) => `0x${b.toString(16).padStart(2, '0')}`).join(', ');
+            return { code: `{ static const uint8_t __tc_mqtt_ca_der[] = { ${hex} }; __tc_mqtt_set_ca_cert_der(__tc_mqtt_ca_der, sizeof(__tc_mqtt_ca_der)); }` };
+        }
         case 'mqtt.on_message':
             return { code: `__tc_mqtt_set_on_message(${s(o.handler)});` };
         case 'mqtt.subscribe':

package/dist/lowering/usb.js

@@ -87,13 +87,13 @@ export function usbdDeviceLines(chip) {
         `    ${vid}, ${pid});`,
         'USBD_DESC_LANG_DEFINE(__tc_usbd_lang);',
         'USBD_DESC_MANUFACTURER_DEFINE(__tc_usbd_mfr, "typecad");',
-        'USBD_DESC_PRODUCT_DEFINE(__tc_usbd_product, "cuttlefish app");',
+        'USBD_DESC_PRODUCT_DEFINE(__tc_usbd_product, "typecad-hal app");',
         // Serial number from hwinfo: Windows keys USB devnodes without a serial
         // on the physical port, so flash-cycle re-enumerations reuse stale
         // port-keyed nodes (the "access denied" open wedge). Identity-based
         // instance paths are stable across ports and never hit that pool.
         'USBD_DESC_SERIAL_NUMBER_DEFINE(__tc_usbd_sn);',
-        'USBD_DESC_CONFIG_DEFINE(__tc_usbd_cfg_desc, "cuttlefish");',
+        'USBD_DESC_CONFIG_DEFINE(__tc_usbd_cfg_desc, "typecad-hal");',
         'USBD_CONFIGURATION_DEFINE(__tc_usbd_cfg, 0, 250, &__tc_usbd_cfg_desc);',
         'static bool __tc_usbd_started = false;',
         ...touchLines,
@@ -101,17 +101,17 @@ export function usbdDeviceLines(chip) {
         '    if (__tc_usbd_started) { return; }',
         '    __tc_usbd_started = true;',
         '    int err = usbd_add_descriptor(&__tc_usbd, &__tc_usbd_lang);',
-        '    if (err != 0) { printk("cuttlefish usb: lang descriptor failed: %d\\n", err); return; }',
+        '    if (err != 0) { printk("typecad-hal usb: lang descriptor failed: %d\\n", err); return; }',
         '    err = usbd_add_descriptor(&__tc_usbd, &__tc_usbd_sn);',
-        '    if (err != 0) { printk("cuttlefish usb: serial descriptor failed: %d\\n", err); return; }',
+        '    if (err != 0) { printk("typecad-hal usb: serial descriptor failed: %d\\n", err); return; }',
         '    err = usbd_add_descriptor(&__tc_usbd, &__tc_usbd_mfr);',
-        '    if (err != 0) { printk("cuttlefish usb: manufacturer descriptor failed: %d\\n", err); return; }',
+        '    if (err != 0) { printk("typecad-hal usb: manufacturer descriptor failed: %d\\n", err); return; }',
         '    err = usbd_add_descriptor(&__tc_usbd, &__tc_usbd_product);',
-        '    if (err != 0) { printk("cuttlefish usb: product descriptor failed: %d\\n", err); return; }',
+        '    if (err != 0) { printk("typecad-hal usb: product descriptor failed: %d\\n", err); return; }',
         '    err = usbd_add_configuration(&__tc_usbd, USBD_SPEED_FS, &__tc_usbd_cfg);',
-        '    if (err != 0) { printk("cuttlefish usb: add configuration failed: %d\\n", err); return; }',
+        '    if (err != 0) { printk("typecad-hal usb: add configuration failed: %d\\n", err); return; }',
         '    err = usbd_register_all_classes(&__tc_usbd, USBD_SPEED_FS, 1, NULL);',
-        '    if (err != 0) { printk("cuttlefish usb: register classes failed: %d\\n", err); return; }',
+        '    if (err != 0) { printk("typecad-hal usb: register classes failed: %d\\n", err); return; }',
         // Registered before usbd_init so no line-coding event can be missed.
         ...touchRegister,
         // usbd_init builds the descriptor tables from the registered
@@ -119,14 +119,14 @@ export function usbdDeviceLines(chip) {
         // refuses with -EPERM ("not initialized") without it (sample_usbd_init.c
         // calls it between setup and enable).
         '    err = usbd_init(&__tc_usbd);',
-        '    if (err != 0) { printk("cuttlefish usb: init failed: %d\\n", err); return; }',
+        '    if (err != 0) { printk("typecad-hal usb: init failed: %d\\n", err); return; }',
         // Boards with VBUS detection start on the VBUS event in the Zephyr
         // sample, via a message callback we do not register; enabling
         // unconditionally (and reporting the error) is the sample's own path
         // for boards without detection (STM32 OTG_FS).
         '    err = usbd_enable(&__tc_usbd);',
-        '    if (err != 0) { printk("cuttlefish usb: enable failed: %d\\n", err); return; }',
-        '    printk("cuttlefish usb: device enabled\\n");',
+        '    if (err != 0) { printk("typecad-hal usb: enable failed: %d\\n", err); return; }',
+        '    printk("typecad-hal usb: device enabled\\n");',
         '}',
         '// CUTTLEFISH_USBD_END',
     ];

package/dist/lowering/wdt.js

@@ -6,36 +6,9 @@
 // wdt_install_timeout in a static var so wdt.reset can feed it.
 //
 // enable(timeout): wdt_install_timeout + wdt_setup. Zephyr expects the timeout
-// in milliseconds (wdt_window.max). The HAL passes a "250ms" string or WDTO_*
-// constant or a number; we parse to ms in the lowering.
+// in milliseconds (wdt_window.max); the thin Watchdog (hal/watchdog.ts)
+// construction already carries a plain timeoutMs number.
 // ---------------------------------------------------------------------------
-/** Parse a HAL wdt timeout ("250ms", WDTO_2S, or a bare number) to ms.
- *  Tolerates undefined (the manifest validator's probe sends a minimal op)
- *  and quote-wrapped strings (resolveSemanticArg can hand the literal's
- *  quoted source text through). */
-function timeoutToMs(timeout) {
-    if (typeof timeout === 'number')
-        return timeout;
-    if (!timeout)
-        return 1000; // default 1s when absent (e.g. the validator probe)
-    timeout = timeout.replace(/^['"]|['"]$/g, '');
-    // Arduino WDTO_* constants.
-    const wdto = {
-        WDTO_15MS: 15, WDTO_30MS: 30, WDTO_60MS: 60, WDTO_120MS: 120,
-        WDTO_250MS: 250, WDTO_500MS: 500, WDTO_1S: 1000, WDTO_2S: 2000,
-        WDTO_4S: 4000, WDTO_8S: 8000,
-    };
-    if (wdto[timeout])
-        return wdto[timeout];
-    const m = timeout.match(/^(\d+)\s*ms$/i);
-    if (m)
-        return parseInt(m[1], 10);
-    const s = timeout.match(/^(\d+)\s*s$/i);
-    if (s)
-        return parseInt(s[1], 10) * 1000;
-    const n = parseInt(timeout, 10);
-    return isNaN(n) ? 1000 : n;
-}
 /**
  * Emit the WDT device + channel state. Called from shimLines when the program
  * uses the watchdog.

package/dist/sdk/board-catalog-sync.d.ts

@@ -2,7 +2,7 @@ import * as catalog from '@typecad/cuttlefish/board-catalog';
 export type BoardCatalogSyncReport = catalog.BoardCatalogSyncReport;
 export type BoardCatalogEnsureResult = catalog.BoardCatalogEnsureResult;
 export type BoardCatalogOverlay = catalog.BoardCatalogOverlay;
-export declare const GENERATOR_REV: number, isZephyrBase: typeof catalog.isZephyrBase, locateZephyrBaseCheap: typeof catalog.locateZephyrBaseCheap, overlayPathFor: typeof catalog.overlayPathFor, readBoardCatalogOverlayFile: typeof catalog.readBoardCatalogOverlayFile, loadBoardCatalogOverlay: typeof catalog.loadBoardCatalogOverlay, resetBoardCatalogOverlayCache: typeof catalog.resetBoardCatalogOverlayCache, isOverlayStale: typeof catalog.isOverlayStale, diffBoardCatalogs: typeof catalog.diffBoardCatalogs, boardRecordFingerprint: typeof catalog.boardRecordFingerprint, findBoardInCatalog: typeof catalog.findBoardInCatalog, activeBoardCatalog: typeof catalog.activeBoardCatalog, resetActiveBoardCatalog: typeof catalog.resetActiveBoardCatalog;
+export declare const loadBoardCatalogOverlay: typeof catalog.loadBoardCatalogOverlay, resetBoardCatalogOverlayCache: typeof catalog.resetBoardCatalogOverlayCache;
 /** Sync with the full west discovery cascade behind it (the CLI's path):
  * falls back through spawn-based discovery when the cheap fs probes find
  * nothing. */
@@ -12,5 +12,3 @@ export declare function syncBoardCatalog(opts?: {
 /** The build-path pre-step: refresh a stale overlay before a regen
  * (fs-only discovery — no spawns during builds). */
 export declare function ensureFreshBoardCatalog(): catalog.BoardCatalogEnsureResult;
-/** Locate a Zephyr tree by any means (spawn cascade included). */
-export declare function locateZephyrBaseFull(): string | undefined;

package/dist/sdk/board-catalog-sync.js

@@ -5,13 +5,14 @@
 // @typecad/cuttlefish/board-catalog — the create flow needs it before any
 // framework is installed. This module adds the one thing the framework owns
 // — the full spawn-based west discovery cascade for an explicit
-// `cuttlefish board sync` — and re-exports the store for the strategy's
-// import surface.
+// `typecad-hal board sync`. Consumers pull the rest of the store's surface
+// from @typecad/cuttlefish/board-catalog directly.
 // ----------------------------------------------------------------------------
 import path from 'node:path';
 import * as catalog from '@typecad/cuttlefish/board-catalog';
 import { discoverWest } from '../toolchain/west-discover.js';
-export const { GENERATOR_REV, isZephyrBase, locateZephyrBaseCheap, overlayPathFor, readBoardCatalogOverlayFile, loadBoardCatalogOverlay, resetBoardCatalogOverlayCache, isOverlayStale, diffBoardCatalogs, boardRecordFingerprint, findBoardInCatalog, activeBoardCatalog, resetActiveBoardCatalog, } = catalog;
+// Re-exported for the package index's board-sync surface.
+export const { loadBoardCatalogOverlay, resetBoardCatalogOverlayCache } = catalog;
 /** Sync with the full west discovery cascade behind it (the CLI's path):
  * falls back through spawn-based discovery when the cheap fs probes find
  * nothing. */
@@ -32,10 +33,3 @@ export function syncBoardCatalog(opts = {}) {
 export function ensureFreshBoardCatalog() {
     return catalog.ensureFreshBoardCatalog();
 }
-/** Locate a Zephyr tree by any means (spawn cascade included). */
-export function locateZephyrBaseFull() {
-    const install = discoverWest();
-    return install?.zephyrBase && catalog.isZephyrBase(install.zephyrBase)
-        ? path.resolve(install.zephyrBase)
-        : undefined;
-}

package/dist/strategy.d.ts

@@ -88,15 +88,6 @@ export declare class ZephyrStrategy implements PlatformStrategy {
         boardJson: string;
     };
     private resolveChip;
-    /**
-     * Resolve the debug mode for the active target from the platform context.
-     * Mirrors resolveChip's target extraction so shimLines/forcedIncludes can
-     * gate the printf halt shim + console UART include to printf builds only
-     * (gdb builds use VS Code native breakpoints + #line markers, so the
-     * __tc_debug_wait_for_continue shim and its <zephyr/drivers/uart.h> include
-     * are dead code there).
-     */
-    private resolveDebugMode;
     forcedIncludes(_program?: ProgramIR, ctx?: PlatformContext): string[];
     symbolAliases(): Record<string, string>;
     /**
@@ -110,15 +101,27 @@ export declare class ZephyrStrategy implements PlatformStrategy {
      */
     private programUsesAsyncRuntime;
     /** Pins referenced by gpio.* hal-ops in the program IR. lowerGpio routes a
-     *  pin to its devicetree spec by pin NUMBER, so the structured hal-op pins
-     *  are the authoritative signal for which __tc_dt_* specs are needed —
-     *  regardless of when the final call text is rendered. */
+     * pin to its devicetree spec by pin NUMBER, so the structured hal-op pins
+     * are the authoritative signal for which __tc_dt_* specs are needed —
+     * regardless of when the final call text is rendered.
+     *
+     * A gpio op interpolated into another HAL call's template literal
+     * (`USB0.writeLine(\`led: ${led.get()}\`)`) never becomes an IR node —
+     * resolveHALExprToText lowers it to C++ text while building the IR and bakes
+     * it into an __EMIT__ snprintf prelude, so the walk cannot see its pin. The
+     * spec NAME it references is still in that text; collectRawMatches finds it
+     * there, or the spec goes undeclared and the build fails on `__tc_dt_led0
+     * was not declared in this scope`. */
     private collectGpioPinUsage;
     /** Run `re` (global) against every raw string in the IR — raw expression
-     *  values plus raw hal-op codes — returning capture group 1 of each match
-     *  (the full match when the regex has no group). This is how references the
-     *  text scanners must see but that never appear as IR call nodes (e.g. a
-     *  rawCpp() escape hatch naming `__tc_dt_sw0` directly) are discovered. */
+     * values plus raw hal-op codes — returning capture group 1 of each match
+     * (the full match when the regex has no group). This is how references the
+     * text scanners must see but that never appear as IR call nodes are
+     * discovered: a rawCpp() escape hatch naming `__tc_dt_sw0` directly, and —
+     * the reason every string LEAF is scanned, not just raw nodes — the
+     * pre-lowered C++ text of a HAL call inlined into another HAL call's
+     * template literal, which the IR builder bakes into plain `string` payloads
+     * (__EMIT__ snprintf preludes, op data fields) rather than raw nodes. */
     private collectRawMatches;
     /** Whether the wiring-compat GPIO read surface (__tc_gpio_read definition,
      *  __tc_gpio_dev dispatcher, and the wiring_compat polyfill's digitalRead /
@@ -210,14 +213,14 @@ export declare class ZephyrStrategy implements PlatformStrategy {
     } | undefined;
     /**
      * Regenerate the board catalog overlay from the user's own Zephyr tree —
-     * `cuttlefish board sync`. After a `west update`, this is how new/changed/
+     * `typecad-hal board sync`. After a `west update`, this is how new/changed/
      * removed boards reach projects without a cuttlefish release. See
      * src/sdk/board-catalog-sync.ts.
      */
     syncBoardCatalog(zephyrBase?: string): BoardCatalogSyncReport;
     /**
      * Refresh the overlay only when it is stale (provenance no longer matches
-     * the tree) — the pre-step `cuttlefish board regen` runs so a regen after
+     * the tree) — the pre-step `typecad-hal board regen` runs so a regen after
      * `west update` picks up the tree's boards automatically. Tree walk only
      * happens when there is actual refreshing to do.
      */
@@ -282,30 +285,5 @@ export declare class ZephyrStrategy implements PlatformStrategy {
     getProfileRegistry(): Map<string, DisplayProfile>;
     colorFormat(): 'rgb565' | 'rgb666' | 'rgb888' | 'mono';
     graphicsCapacity(): GraphicsCapacity;
-    debugMode(target?: string): 'gdb' | 'printf';
-    generateDebugInitCode(): string[];
-    generateDebugBreakpointCode(params: {
-        fileName: string;
-        lineNum: number;
-        originalLine: string;
-        variables: Array<{
-            name: string;
-            isFunction?: boolean;
-            cppType?: 'bool' | 'int' | 'long' | 'float' | 'string' | 'unknown';
-        }>;
-        normalizedCondition?: string;
-        breakpointId?: number;
-    }): string[];
-    generateDebugLogpointCode(params: {
-        fileName: string;
-        lineNum: number;
-        parts: Array<{
-            type: 'text' | 'variable';
-            value: string;
-        }>;
-        variables: Array<{
-            name: string;
-            isFunction?: boolean;
-        }>;
-    }): string[];
+    debugMode(target?: string): 'gdb' | 'none';
 }