@esp-vision/device-core 0.4.1 → 0.4.2

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 0.4.2 (unreleased)
+
+### Fixed
+
+- Route browser ROM reset calls through the active flash stub after upload, preserving its two-byte status decoder during P4 watchdog register writes; report reset failure diagnostics without invalidating successful firmware verification.
+
 ## 0.4.1 (unreleased)
 
 ### Fixed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@esp-vision/device-core",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "description": "Shared EV-MUX, framed REPL, device session, and action contracts for ESP Vision clients.",
   "type": "module",
   "exports": {

package/schemas/device-actions-v1.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "title": "ESP Vision Device Actions",
-  "deviceCoreVersion": "0.4.1",
+  "deviceCoreVersion": "0.4.2",
   "schemaVersion": 1,
   "actions": [
     {

package/src/browser_rom_compat.js

@@ -15,6 +15,13 @@ export function browserRomCompatibility(loader) {
       }
     }
   }
+  // runStub returns a separate loader. Its command replies use two status bytes;
+  // the ROM loader still expects four and cannot issue reset register writes.
+  let activeStub
+  const hardReset = loader.hardReset
+  loader.hardReset = function (...args) {
+    return activeStub ? activeStub.hardReset(...args) : hardReset.apply(this, args)
+  }
   const runStub = loader.runStub
   loader.runStub = async function (skipFlashDetection = false) {
     const memFinish = this.memFinish, packet = this.readPacket
@@ -34,6 +41,7 @@ export function browserRomCompatibility(loader) {
       const stub = await runStub.call(this, skipFlashDetection)
       if (!stub.IS_STUB) throw new Error('This device has no supported browser flash stub')
       browserStubCompatibility(stub)
+      activeStub = stub
       return stub
     } finally { this.memFinish = memFinish; this.readPacket = packet }
   }

package/src/firmware_flash.js

@@ -112,7 +112,10 @@ export class FirmwareFlashSession {
         }
         await this.reset()
       }
-      catch { onPhase('Firmware verified. Press RESET or reconnect power to start it.'); return { verified: true, needsReset: true } }
+      catch (error) {
+        onPhase('Firmware verified. Automatic reset did not complete; wait for runtime reconnection or press RESET.')
+        return { verified: true, needsReset: true, resetError: { code: error?.code ?? 'RESET_FAILED', message: error?.message ?? String(error) } }
+      }
       onPhase('Firmware verified and reset. Reconnect in the IDE to verify EV-MUX v4.')
       return { verified: true, needsReset: false }
     } catch (error) { this.state = 'error'; throw error }

package/tests/check-browser.mjs

@@ -23,7 +23,7 @@ try {
   assert.ok(Object.keys(result.metafile.inputs).some(path => path.includes('stubs/esp32p4.json')))
   assert.ok(Object.keys(result.metafile.inputs).some(path => path.includes('stubs/esp32s31.json')))
   assert.ok(!Object.keys(result.metafile.inputs).some(path => /src\/(node|cli)/.test(path)))
-  const context = vm.createContext({ EventTarget, URL, TextDecoder, TextEncoder, Uint8Array, AbortController, setTimeout, clearTimeout, console, crypto: webcrypto, structuredClone })
+  const context = vm.createContext({ atob, btoa, EventTarget, URL, TextDecoder, TextEncoder, Uint8Array, AbortController, setTimeout, clearTimeout, console, crypto: webcrypto, structuredClone })
   vm.runInContext(code, context)
   let opens = 0, closes = 0
   const adapter = context.DeviceCore.openBrowserRom({ port: {
@@ -46,6 +46,29 @@ try {
     raw._inputBuffer.push(0xc0, 0xdb, 0x47, 0xc0)
     await assert.rejects(raw.readPacket(100), /Invalid SLIP escape/)
   }
+  // Exercise real upstream stub status decoding. A ROM reset consumes four
+  // status bytes while the running stub replies with two; route reset to it.
+  {
+    const raw = new context.DeviceCore.TestLoader({ getInfo: () => ({ usbVendorId: 0x303a, usbProductId: 0x1001 }) }, { log() {}, error() {}, debug() {} })
+    raw.chipFamily = 0x3280; raw.chipRevision = 302
+    raw.memBegin = raw.memBlock = raw.memFinish = async () => {}
+    raw.readPacket = async () => new Uint8Array([79, 72, 65, 73])
+    context.DeviceCore.testCompatibility(raw)
+    const stub = await raw.runStub(true)
+    let writes = 0
+    stub.detectUsbConnectionType = async () => true
+    stub.getUsbMode = async () => ({ mode: 'usb-jtag-serial' })
+    stub.sendCommand = async () => { writes++ }
+    stub.getResponse = async () => [0, new Uint8Array([0, 0])]
+    // Confirm the original ROM instance rejects the exact same stub response.
+    raw.detectUsbConnectionType = stub.detectUsbConnectionType
+    raw.getUsbMode = stub.getUsbMode
+    raw.sendCommand = async () => {}
+    raw.getResponse = stub.getResponse
+    await assert.rejects(context.DeviceCore.TestLoader.prototype.hardReset.call(raw), /status|response|enough/i)
+    await raw.hardReset()
+    assert.equal(writes, 4, 'P4 watchdog writes must use the running stub status decoder')
+  }
   const prototype = context.DeviceCore.TestLoader.prototype
   const originals = Object.fromEntries(['initialize', 'disconnect', 'getSecurityInfo', 'runStub', 'hardReset'].map(key => [key, prototype[key]]))
   let initializeCalls = 0, disconnectCalls = 0
@@ -115,6 +138,7 @@ try {
         async flashData() { writes++; writing.abort() },
         async readFlash(offset) { return offset === 32768 ? table : data },
         async readRegister() { return 0 },
+        async hardReset() { resets++ },
       }
     }
     prototype.hardReset = async () => { resets++ }

package/tests/test-device-firmware.mjs

@@ -80,7 +80,10 @@ test('failed readback never reports verified or resets the device', async () =>
 })
 test('reset failure returns verified with explicit manual reset requirement', async () => {
   const f = await fixture(); f.loader.hardReset = async () => { throw new Error('reset unavailable') }
-  assert.equal((await f.device.firmware.update(f.request)).needsReset, true)
+  const result = await f.device.firmware.update(f.request)
+  assert.equal(result.needsReset, true)
+  assert.equal(result.verified, true)
+  assert.deepEqual(result.resetError, { code: 'RESET_FAILED', message: 'reset unavailable' })
 })
 
 test('firmware check lists all board versions and selects an explicit older version', async () => {