@microbit/microbit-connection 0.9.0-apps.alpha.2 → 0.9.0-apps.alpha.20

package/build/cjs/service-events.js

@@ -1,39 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ServiceConnectionEventMap = void 0;
-class ServiceConnectionEventMap {
-    constructor() {
-        Object.defineProperty(this, "accelerometerdatachanged", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "buttonachanged", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "buttonbchanged", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "magnetometerdatachanged", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "uartdata", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-    }
-}
-exports.ServiceConnectionEventMap = ServiceConnectionEventMap;
+exports.ButtonState = void 0;
+exports.ButtonState = {
+    NotPressed: 0,
+    ShortPress: 1,
+    LongPress: 2,
+};
 //# sourceMappingURL=service-events.js.map

package/build/cjs/service-events.js.map

@@ -1 +1 @@
-{"version":3,"file":"service-events.js","sourceRoot":"","sources":["../../lib/service-events.ts"],"names":[],"mappings":";;;AAMA,MAAa,yBAAyB;IAAtC;QACE,4BAAA,0BAA0B;;;;;WAAyB;QACnD,4BAAA,gBAAgB;;;;;WAAc;QAC9B,4BAAA,gBAAgB;;;;;WAAc;QAC9B,4BAAA,yBAAyB;;;;;WAAwB;QACjD,4BAAA,UAAU;;;;;WAAgB;IAC5B,CAAC;CAAA;AAND,8DAMC"}
+{"version":3,"file":"service-events.js","sourceRoot":"","sources":["../../src/service-events.ts"],"names":[],"mappings":";;;AASa,QAAA,WAAW,GAAG;IACzB,UAAU,EAAE,CAAC;IACb,UAAU,EAAE,CAAC;IACb,SAAS,EAAE,CAAC;CACJ,CAAC"}

package/build/cjs/setupTests.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * (c) 2024, Micro:bit Educational Foundation and contributors
+ *
+ * SPDX-License-Identifier: MIT
+ */
+//# sourceMappingURL=setupTests.js.map

package/build/cjs/setupTests.js.map

@@ -1 +1 @@
-{"version":3,"file":"setupTests.js","sourceRoot":"","sources":["../../lib/setupTests.ts"],"names":[],"mappings":";;AAAA;;;;GAIG"}
+{"version":3,"file":"setupTests.js","sourceRoot":"","sources":["../../src/setupTests.ts"],"names":[],"mappings":";;AAAA;;;;GAIG"}

package/build/{esm/hex-flash-data-source.d.ts → cjs/universal-hex/flash-data-source.d.ts}

@@ -1,4 +1,4 @@
-import { FlashDataSource } from "./device.js";
+import { FlashDataSource } from "../device.js";
 /**
  * A flash data source that converts universal hex files as needed.
  *

package/build/cjs/{hex-flash-data-source.js → universal-hex/flash-data-source.js}

@@ -1,8 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createUniversalHexFlashDataSource = void 0;
-const board_id_js_1 = require("./board-id.js");
-const device_js_1 = require("./device.js");
+// This module is deliberately kept separate so that
+// @microbit/microbit-universal-hex can be tree-shaken by bundlers
+// when consumers don't use createUniversalHexFlashDataSource.
+const board_id_js_1 = require("../board-id.js");
+const device_js_1 = require("../device.js");
 const microbit_universal_hex_1 = require("@microbit/microbit-universal-hex");
 /**
  * A flash data source that converts universal hex files as needed.
@@ -23,4 +26,4 @@ const createUniversalHexFlashDataSource = (universalHex) => {
     };
 };
 exports.createUniversalHexFlashDataSource = createUniversalHexFlashDataSource;
-//# sourceMappingURL=hex-flash-data-source.js.map
+//# sourceMappingURL=flash-data-source.js.map

package/build/cjs/universal-hex/flash-data-source.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flash-data-source.js","sourceRoot":"","sources":["../../../src/universal-hex/flash-data-source.ts"],"names":[],"mappings":";;;AAAA,oDAAoD;AACpD,kEAAkE;AAClE,8DAA8D;AAC9D,gDAAyC;AACzC,4CAIsB;AACtB,6EAG0C;AAE1C;;;;GAIG;AACI,MAAM,iCAAiC,GAAG,CAC/C,YAAoB,EACH,EAAE;IACnB,OAAO,CAAC,YAA0B,EAAE,EAAE;QACpC,IAAI,IAAA,uCAAc,EAAC,YAAY,CAAC,EAAE,CAAC;YACjC,MAAM,KAAK,GAAG,IAAA,6CAAoB,EAAC,YAAY,CAAC,CAAC;YACjD,MAAM,QAAQ,GAAG,KAAK,CAAC,IAAI,CACzB,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,IAAI,qBAAO,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC,EAAE,CACxD,CAAC;YACF,IAAI,CAAC,QAAQ,EAAE,CAAC;gBACd,MAAM,IAAI,0BAAc,CAAC,kBAAkB,CAAC,CAAC;YAC/C,CAAC;YACD,OAAO,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;QACvC,CAAC;QACD,OAAO,OAAO,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;IACvC,CAAC,CAAC;AACJ,CAAC,CAAC;AAhBW,QAAA,iCAAiC,qCAgB5C"}

package/build/cjs/universal-hex/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @module @microbit/microbit-connection/universal-hex
+ */
+export { createUniversalHexFlashDataSource } from "./flash-data-source.js";

package/build/cjs/universal-hex/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUniversalHexFlashDataSource = void 0;
+/**
+ * @module @microbit/microbit-connection/universal-hex
+ */
+var flash_data_source_js_1 = require("./flash-data-source.js");
+Object.defineProperty(exports, "createUniversalHexFlashDataSource", { enumerable: true, get: function () { return flash_data_source_js_1.createUniversalHexFlashDataSource; } });
+//# sourceMappingURL=index.js.map

package/build/cjs/universal-hex/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/universal-hex/index.ts"],"names":[],"mappings":";;;AAAA;;GAEG;AACH,+DAA2E;AAAlE,yIAAA,iCAAiC,OAAA"}

package/build/cjs/usb/arm-debug.d.ts

@@ -0,0 +1,137 @@
+/**
+ * (c) 2026, Micro:bit Educational Foundation and contributors
+ *
+ * Derived from dapjs (https://github.com/ARMmbed/dapjs) which is
+ * Copyright (c) Arm Limited 2018
+ * Copyright (c) Microsoft Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * ARM Debug Interface (ADI) layer for SWD access to a Cortex-M target,
+ * derived from dapjs (https://github.com/ARMmbed/dapjs). This file and
+ * its siblings (transport.ts, cmsis-dap.ts, cortex-m.ts, daplink.ts)
+ * are a minimal reimplementation covering only the features needed for
+ * micro:bit.
+ *
+ * ArmDebugSwd manages the SWD connection lifecycle and provides
+ * register-level access to the Debug Port (DP) and Access Port (AP).
+ * It sits between CmsisDapUsb (command framing) and higher-level consumers
+ * like CortexM (processor control) and DAPLink (flash/serial).
+ *
+ * Key responsibilities:
+ * - SWD initialisation sequence (JTAG-to-SWD switch, power-up, ID read)
+ * - Automatic drain-and-retry on stale USB responses after page reload
+ * - DP_SELECT and AP_CSW register caching to reduce redundant writes
+ * - Memory read/write via AP_TAR + AP_DRW, handling page boundaries
+ *   and block-transfer size limits
+ *
+ * Protocol references:
+ * - ARM ADI: https://developer.arm.com/documentation/ihi0031/a/
+ * - DAPLink: https://github.com/ARMmbed/DAPLink
+ *
+ * The dapjs license is included below:
+ *
+ * DAPjs
+ * Copyright (c) Arm Limited 2018
+ * Copyright (c) Microsoft Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+import { Logging } from "../logging.js";
+import { type CmsisDap, DapOperation } from "./cmsis-dap.js";
+export declare function waitFor(fn: () => Promise<boolean>, timeout?: number, delay?: number): Promise<void>;
+export interface ArmDebug {
+    readonly dap: CmsisDap;
+    readonly isOpen: boolean;
+    /** Read a 32-bit word from a memory-mapped address. */
+    readMem32(address: number): Promise<number>;
+    /** Write a 32-bit word to a memory-mapped address. */
+    writeMem32(address: number, value: number): Promise<void>;
+    /** Build DAP operations for reading a 32-bit word (for use with transferSequence). */
+    readMem32Ops(address: number): DapOperation[];
+    /** Build DAP operations for writing a 32-bit word (for use with transferSequence). */
+    writeMem32Ops(address: number, value: number): DapOperation[];
+    /**
+     * Read a block of 32-bit words from memory.
+     * Handles TAR auto-increment page boundaries and block size limits.
+     */
+    readBlock(address: number, count: number): Promise<Uint32Array>;
+    /**
+     * Write a block of 32-bit words to memory.
+     * Handles TAR auto-increment page boundaries and block size limits.
+     */
+    writeBlock(address: number, values: Uint32Array): Promise<void>;
+    /**
+     * Execute a sequence of operation groups as individual transfers.
+     * Each group is sent as a separate DAP_TRANSFER to guarantee that
+     * all operations within a group execute atomically on the wire.
+     */
+    transferSequence(groups: DapOperation[][]): Promise<Uint32Array>;
+    /**
+     * Reset cached protocol state without closing the transport.
+     * Call after operations that reset the target (e.g. DAPLink flash reset).
+     */
+    resetState(): void;
+    /**
+     * Connect to the target with automatic drain-and-retry on stale responses.
+     */
+    connect(maxRetries?: number): Promise<void>;
+    disconnect(): Promise<void>;
+    /**
+     * Reset cached state and reconnect without closing the transport.
+     * Use after operations like DAPLink flash that leave the protocol state
+     * stale but don't require full re-enumeration.
+     */
+    reinit(): Promise<void>;
+}
+export declare class ArmDebugSwd implements ArmDebug {
+    readonly dap: CmsisDap;
+    private logging;
+    private swdConnected;
+    private selectedAddress?;
+    private cswValue?;
+    constructor(dap: CmsisDap, logging: Logging);
+    get isOpen(): boolean;
+    /**
+     * Initialize SWD: connect to the target, set up the debug port,
+     * and power up the debug and system domains.
+     */
+    private connectOnce;
+    connect(maxRetries?: number): Promise<void>;
+    resetState(): void;
+    disconnect(): Promise<void>;
+    reinit(): Promise<void>;
+    private readDPOps;
+    private writeDPOps;
+    private readAPOps;
+    private writeAPOps;
+    readMem32Ops(address: number): DapOperation[];
+    writeMem32Ops(address: number, value: number): DapOperation[];
+    /**
+     * Execute a batch of DAP transfer operations, deduplicating writes
+     * to DP_SELECT and AP_CSW that match cached state.
+     */
+    private transfer;
+    transferSequence(groups: DapOperation[][]): Promise<Uint32Array>;
+    private readDP;
+    readMem32(address: number): Promise<number>;
+    writeMem32(address: number, value: number): Promise<void>;
+    readBlock(address: number, count: number): Promise<Uint32Array>;
+    writeBlock(address: number, values: Uint32Array): Promise<void>;
+}

package/build/cjs/usb/arm-debug.js

@@ -0,0 +1,414 @@
+"use strict";
+/**
+ * (c) 2026, Micro:bit Educational Foundation and contributors
+ *
+ * Derived from dapjs (https://github.com/ARMmbed/dapjs) which is
+ * Copyright (c) Arm Limited 2018
+ * Copyright (c) Microsoft Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * ARM Debug Interface (ADI) layer for SWD access to a Cortex-M target,
+ * derived from dapjs (https://github.com/ARMmbed/dapjs). This file and
+ * its siblings (transport.ts, cmsis-dap.ts, cortex-m.ts, daplink.ts)
+ * are a minimal reimplementation covering only the features needed for
+ * micro:bit.
+ *
+ * ArmDebugSwd manages the SWD connection lifecycle and provides
+ * register-level access to the Debug Port (DP) and Access Port (AP).
+ * It sits between CmsisDapUsb (command framing) and higher-level consumers
+ * like CortexM (processor control) and DAPLink (flash/serial).
+ *
+ * Key responsibilities:
+ * - SWD initialisation sequence (JTAG-to-SWD switch, power-up, ID read)
+ * - Automatic drain-and-retry on stale USB responses after page reload
+ * - DP_SELECT and AP_CSW register caching to reduce redundant writes
+ * - Memory read/write via AP_TAR + AP_DRW, handling page boundaries
+ *   and block-transfer size limits
+ *
+ * Protocol references:
+ * - ARM ADI: https://developer.arm.com/documentation/ihi0031/a/
+ * - DAPLink: https://github.com/ARMmbed/DAPLink
+ *
+ * The dapjs license is included below:
+ *
+ * DAPjs
+ * Copyright (c) Arm Limited 2018
+ * Copyright (c) Microsoft Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArmDebugSwd = void 0;
+exports.waitFor = waitFor;
+const device_js_1 = require("../device.js");
+const cmsis_dap_js_1 = require("./cmsis-dap.js");
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+// DP registers
+const DP_ABORT = 0x0;
+const DP_DPIDR = 0x0;
+const DP_CTRL_STAT = 0x4;
+const DP_SELECT = 0x8;
+// AP registers (values are byte addresses, pre-shifted to match the DAP
+// transfer operation encoding where bits [3:2] carry A[3:2])
+const AP_CSW = 0x00;
+const AP_TAR = 0x04;
+const AP_DRW = 0x0c;
+// CSW mask values
+const CSW_SIZE32 = 1 << 1;
+const CSW_ADDRINC_SINGLE = 1 << 4;
+const CSW_DBGSTATUS = 1 << 6;
+const CSW_RESERVED = 1 << 24;
+const CSW_HPROT1 = 1 << 25;
+const CSW_MASTERTYPE = 1 << 29;
+const CSW_VALUE = CSW_ADDRINC_SINGLE |
+    CSW_DBGSTATUS |
+    CSW_RESERVED |
+    CSW_HPROT1 |
+    CSW_MASTERTYPE;
+// Bank select masks
+const APSEL = 0xff000000;
+const APBANKSEL = 0x000000f0;
+// CTRL/STAT register bits
+const CSYSPWRUPREQ = 1 << 30;
+const CDBGPWRUPREQ = 1 << 28;
+const CSYSPWRUPACK = 1 << 31;
+const CDBGPWRUPACK = 1 << 29;
+// TAR auto-increment page size (1KB, implementation-defined minimum)
+const AUTOINC_PAGESIZE = 1 << 10;
+// Clock frequency (10 MHz)
+const CLOCK_FREQUENCY = 10_000_000;
+// Wait delay for polling loops
+const WAIT_DELAY = 100;
+// ---------------------------------------------------------------------------
+// Utilities
+// ---------------------------------------------------------------------------
+async function waitFor(fn, timeout = 10_000, delay = WAIT_DELAY) {
+    const deadline = timeout > 0 ? Date.now() + timeout : 0;
+    while (true) {
+        if (await fn())
+            return;
+        if (deadline && Date.now() > deadline) {
+            throw new device_js_1.DeviceError({
+                code: "timeout",
+                message: "Wait timed out",
+            });
+        }
+        await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+}
+function concatUint32Arrays(arrays) {
+    if (arrays.length === 1)
+        return arrays[0];
+    let length = 0;
+    for (const a of arrays)
+        length += a.length;
+    const result = new Uint32Array(length);
+    let offset = 0;
+    for (const a of arrays) {
+        result.set(a, offset);
+        offset += a.length;
+    }
+    return result;
+}
+class ArmDebugSwd {
+    constructor(dap, logging) {
+        Object.defineProperty(this, "dap", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: dap
+        });
+        Object.defineProperty(this, "logging", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: logging
+        });
+        Object.defineProperty(this, "swdConnected", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        // ADI state (register caching)
+        Object.defineProperty(this, "selectedAddress", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "cswValue", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+    }
+    get isOpen() {
+        return this.dap.isOpen;
+    }
+    // ---- SWD lifecycle ----
+    /**
+     * Initialize SWD: connect to the target, set up the debug port,
+     * and power up the debug and system domains.
+     */
+    async connectOnce() {
+        if (this.swdConnected)
+            return;
+        await this.dap.open();
+        // SWD protocol setup. On failure the transport is left open so the
+        // caller can drain stale responses and retry without re-opening.
+        try {
+            await this.dap.swjClock(CLOCK_FREQUENCY);
+            await this.dap.connect();
+        }
+        catch (error) {
+            try {
+                await this.dap.clearAbort();
+            }
+            catch {
+                /* ignore */
+            }
+            throw error;
+        }
+        await this.dap.configureTransfer(0, 100, 0);
+        // Select SWD protocol
+        await this.dap.swjSequence(new Uint8Array([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]));
+        await this.dap.swjSequence(new Uint8Array([0x9e, 0xe7]));
+        await this.dap.swjSequence(new Uint8Array([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]));
+        await this.dap.swjSequence(new Uint8Array([0x00]));
+        this.swdConnected = true;
+        // Initialize debug port and power up
+        try {
+            await this.readDP(DP_DPIDR);
+            await this.transferSequence([
+                this.writeDPOps(DP_ABORT, cmsis_dap_js_1.ABORT_ALL),
+                this.writeDPOps(DP_SELECT, AP_CSW),
+                this.writeDPOps(DP_CTRL_STAT, CSYSPWRUPREQ | CDBGPWRUPREQ),
+            ]);
+            const mask = CDBGPWRUPACK | CSYSPWRUPACK;
+            await waitFor(async () => {
+                const status = await this.readDP(DP_CTRL_STAT);
+                return (status & mask) === mask;
+            }, 5000);
+        }
+        catch (error) {
+            await this.disconnect();
+            throw error;
+        }
+        this.logging.log("SWD connected");
+    }
+    async connect(maxRetries = 3) {
+        let lastError;
+        for (let attempt = 0; attempt < maxRetries; attempt++) {
+            try {
+                if (attempt > 0) {
+                    this.logging.log(`Connection retry attempt ${attempt + 1}/${maxRetries}`);
+                    await this.dap.drainStaleResponses();
+                }
+                await this.connectOnce();
+                return;
+            }
+            catch (e) {
+                if (e instanceof cmsis_dap_js_1.DapResponseMismatchError) {
+                    lastError = e;
+                    this.logging.log(`Stale response during connect: ${e.message}`);
+                    continue;
+                }
+                throw e;
+            }
+        }
+        throw lastError || new Error("Connection failed after retries");
+    }
+    resetState() {
+        this.swdConnected = false;
+        this.selectedAddress = undefined;
+        this.cswValue = undefined;
+    }
+    async disconnect() {
+        if (!this.swdConnected)
+            return;
+        try {
+            await this.dap.disconnect();
+        }
+        catch {
+            this.logging.log("Disconnect failed, clearing abort");
+            try {
+                await this.dap.clearAbort();
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        await this.dap.close();
+        this.resetState();
+        this.logging.log("SWD disconnected");
+    }
+    async reinit() {
+        this.logging.log("Reinitialising SWD");
+        this.resetState();
+        await this.connectOnce();
+    }
+    // ---- DP/AP register helpers ----
+    readDPOps(register) {
+        return [{ mode: cmsis_dap_js_1.READ, port: cmsis_dap_js_1.DP, register }];
+    }
+    writeDPOps(register, value) {
+        return [{ mode: cmsis_dap_js_1.WRITE, port: cmsis_dap_js_1.DP, register, value }];
+    }
+    readAPOps(register) {
+        const address = (register & APSEL) | (register & APBANKSEL);
+        return [
+            ...this.writeDPOps(DP_SELECT, address),
+            { mode: cmsis_dap_js_1.READ, port: cmsis_dap_js_1.AP, register },
+        ];
+    }
+    writeAPOps(register, value) {
+        const address = (register & APSEL) | (register & APBANKSEL);
+        return [
+            ...this.writeDPOps(DP_SELECT, address),
+            { mode: cmsis_dap_js_1.WRITE, port: cmsis_dap_js_1.AP, register, value },
+        ];
+    }
+    readMem32Ops(address) {
+        return [
+            ...this.writeAPOps(AP_CSW, CSW_VALUE | CSW_SIZE32),
+            ...this.writeAPOps(AP_TAR, address),
+            ...this.readAPOps(AP_DRW),
+        ];
+    }
+    writeMem32Ops(address, value) {
+        return [
+            ...this.writeAPOps(AP_CSW, CSW_VALUE | CSW_SIZE32),
+            ...this.writeAPOps(AP_TAR, address),
+            ...this.writeAPOps(AP_DRW, value),
+        ];
+    }
+    // ---- Transfer with register caching ----
+    /**
+     * Execute a batch of DAP transfer operations, deduplicating writes
+     * to DP_SELECT and AP_CSW that match cached state.
+     */
+    async transfer(operations) {
+        const filtered = operations.filter((op) => {
+            if (op.mode !== cmsis_dap_js_1.WRITE)
+                return true;
+            if (op.port === cmsis_dap_js_1.DP && op.register === DP_SELECT) {
+                return op.value !== this.selectedAddress;
+            }
+            if (op.port === cmsis_dap_js_1.AP && op.register === AP_CSW) {
+                return op.value !== this.cswValue;
+            }
+            return true;
+        });
+        if (filtered.length === 0) {
+            return new Uint32Array(0);
+        }
+        try {
+            const result = await this.dap.transfer(filtered);
+            // Update cache on success
+            for (const op of filtered) {
+                if (op.mode !== cmsis_dap_js_1.WRITE)
+                    continue;
+                if (op.port === cmsis_dap_js_1.DP && op.register === DP_SELECT) {
+                    this.selectedAddress = op.value;
+                }
+                else if (op.port === cmsis_dap_js_1.AP && op.register === AP_CSW) {
+                    this.cswValue = op.value;
+                }
+            }
+            return result;
+        }
+        catch (error) {
+            // Transfer failed — invalidate the cache
+            this.selectedAddress = undefined;
+            this.cswValue = undefined;
+            throw error;
+        }
+    }
+    async transferSequence(groups) {
+        const results = [];
+        for (const group of groups) {
+            const result = await this.transfer(group);
+            results.push(result);
+        }
+        return concatUint32Arrays(results);
+    }
+    // ---- Memory operations ----
+    async readDP(register) {
+        const result = await this.transfer(this.readDPOps(register));
+        return result[0];
+    }
+    async readMem32(address) {
+        const result = await this.transfer(this.readMem32Ops(address));
+        return result[0];
+    }
+    async writeMem32(address, value) {
+        await this.transfer(this.writeMem32Ops(address, value));
+    }
+    async readBlock(address, count) {
+        const results = [];
+        let remaining = count;
+        let addr = address;
+        while (remaining > 0) {
+            const nextPageOffset = AUTOINC_PAGESIZE - (addr % AUTOINC_PAGESIZE);
+            const chunkWords = Math.min(remaining, nextPageOffset / 4);
+            await this.transferSequence([
+                this.writeAPOps(AP_CSW, CSW_VALUE | CSW_SIZE32),
+                this.writeAPOps(AP_TAR, addr),
+            ]);
+            let subRemaining = chunkWords;
+            while (subRemaining > 0) {
+                const subChunk = Math.min(subRemaining, Math.floor(this.dap.blockSize / 4));
+                const result = await this.dap.transferBlockRead(cmsis_dap_js_1.AP, AP_DRW, subChunk);
+                results.push(result);
+                subRemaining -= subChunk;
+            }
+            addr += chunkWords * 4;
+            remaining -= chunkWords;
+        }
+        return concatUint32Arrays(results);
+    }
+    async writeBlock(address, values) {
+        let index = 0;
+        let addr = address;
+        while (index < values.length) {
+            const nextPageOffset = AUTOINC_PAGESIZE - (addr % AUTOINC_PAGESIZE);
+            const chunkWords = Math.min(values.length - index, nextPageOffset / 4);
+            const chunk = values.slice(index, index + chunkWords);
+            await this.transferSequence([
+                this.writeAPOps(AP_CSW, CSW_VALUE | CSW_SIZE32),
+                this.writeAPOps(AP_TAR, addr),
+            ]);
+            let subIndex = 0;
+            while (subIndex < chunk.length) {
+                const subChunk = chunk.slice(subIndex, subIndex + Math.floor(this.dap.blockSize / 4));
+                await this.dap.transferBlockWrite(cmsis_dap_js_1.AP, AP_DRW, subChunk);
+                subIndex += Math.floor(this.dap.blockSize / 4);
+            }
+            addr += chunkWords * 4;
+            index += chunkWords;
+        }
+    }
+}
+exports.ArmDebugSwd = ArmDebugSwd;
+//# sourceMappingURL=arm-debug.js.map