@esp-vision/device-core 0.4.0 → 0.4.2

package/CHANGELOG.md

@@ -1,6 +1,19 @@
 # Changelog
 
-## 0.4.0 (unreleased)
+## 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
+
+- Fail camera mode checks on allocation, timeout and unexpected errors instead of silently classifying those modes as unsupported; inspect optional storage state only when advertised.
+- Keep hardware-check fixtures in bounded RAM-only Python calls, independent of filesystem availability. Add expected board/firmware and required-check validation, report storage mount state, and reject explicit file acceptance on unmounted Flash without formatting.
+
+## 0.4.0
 
 ### Added
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@esp-vision/device-core",
-  "version": "0.4.0",
+  "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.0",
+  "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/device-checks.mjs

@@ -2,6 +2,7 @@
 // Application-level HIL checks. All device I/O goes through createDevice's API.
 import { readFile, mkdir, writeFile } from 'node:fs/promises'
 import { dirname } from 'node:path'
+import { EV_REPL_INPUT_MAX_BYTES, evReplExecInputBytes } from '../src/evrepl.js'
 
 export const DEVICE_CHECKS = Object.freeze(['identity', 'memory', 'camera', 'framesizes', 'pixformats', 'orientation', 'ipa_stats', 'snapshot_rate', 'preview', 'image_ops', 'display', 'display_stream'])
 const MARKER = '__EVDEVICECHECK__'
@@ -39,11 +40,14 @@ function pause(milliseconds, signal) {
 }
 
 export async function runDeviceChecks(device, options, { signal, nonce, report = value => console.log(JSON.stringify(value)) } = {}) {
-  const results = [], fixturePath = `/evhil_${nonce}.py`, namespace = `_evhil_${nonce}`
-  let ownsFixture = false, loaded = false, namespaceStarted = false, loadError = null
+  const results = [], namespace = `_evhil_${nonce}`
+  let loaded = false, namespaceStarted = false, loadError = null, inputLimit = EV_REPL_INPUT_MAX_BYTES
   const parameters = { frames: options.frames, framesize: options.framesize, pixformat: options.pixformat, displayHold: options.displayHold, screenCapture: Boolean(options.screenOutput) }
   const timeoutFor = name => 1000 * (name === 'display' ? 30 + options.displayHold * 3 : name === 'ipa_stats' ? options.frameTimeout + 40 : options.frameTimeout + Math.max(30, options.frames * (name === 'display_stream' ? 2 : 1)))
   const execute = async (source, timeout = 10000, operationSignal = signal) => {
+    // Larger python.execute() requests use temporary files in Device Core.
+    // Keep fixtures in RAM by respecting the actual encoded REPL-line budget.
+    if (evReplExecInputBytes(source) > inputLimit) throw failure('REPL_INPUT_LIMIT', 'Hardware fixture command exceeds the device REPL input limit')
     const result = await device.python.execute({ source, timeout, maxOutputChars: 16384, signal: operationSignal })
     if (result.ok === false || result.outputTruncated) throw failure('PYTHON_CHECK', 'Device Python check did not complete')
     return result.output
@@ -52,16 +56,25 @@ export async function runDeviceChecks(device, options, { signal, nonce, report =
     if (loaded) return
     if (loadError) throw loadError
     try {
-      const entries = await device.files.list({ path: '/', signal })
-      if (entries.some(entry => [fixturePath, `${fixturePath}.tmp`].includes(entry.path))) throw failure('TEST_PATH_EXISTS', 'Fixture path already exists')
+      const info = await device.inspect({ fields: ['capabilities'], signal })
+      const advertised = info.capabilities?.limits?.replInputMax
+      if (Number.isSafeInteger(advertised) && advertised > 0) inputLimit = Math.min(inputLimit, advertised)
       const source = await readFile(new URL('./fixtures/device-checks.py', import.meta.url), 'utf8')
-      ownsFixture = true
-      await device.files.write({ path: fixturePath, data: source, overwrite: false, signal })
       namespaceStarted = true
-      const loader = `with open(${JSON.stringify(fixturePath)}) as _fixture:\n exec(_fixture.read(),globals())`
-      await execute(`${namespace}={};exec(${JSON.stringify(loader)},${namespace})`)
+      await execute(`${namespace}={'_source':[]}`)
+      const append = chunk => `${namespace}['_source'].append(${JSON.stringify(chunk)})`
+      let chunk = ''
+      for (const character of source) {
+        if (evReplExecInputBytes(append(chunk + character)) > inputLimit) {
+          if (!chunk) throw failure('REPL_INPUT_LIMIT', 'Device REPL input limit cannot load hardware fixtures')
+          await execute(append(chunk))
+          chunk = ''
+        }
+        chunk += character
+      }
+      if (chunk) await execute(append(chunk))
+      await execute(`exec(''.join(${namespace}['_source']),${namespace});del ${namespace}['_source']`)
       loaded = true
-      await device.files.remove({ path: fixturePath, signal })
     } catch (error) { loadError = error; throw error }
   }
   const invoke = async name => {
@@ -83,8 +96,12 @@ export async function runDeviceChecks(device, options, { signal, nonce, report =
         let data
         if (name === 'identity') {
           const info = await device.inspect({ fields: ['identity', 'capabilities', 'runtime'], signal })
+          if (info.capabilities?.features?.includes('storage.writer.lease')) {
+            info.storage = (await device.inspect({ fields: ['storage'], signal })).storage
+          }
           if (!info.identity?.board || !info.identity.firmwareVersion || info.capabilities?.protocol?.evMuxVersion !== 4 || info.runtime?.vmReady !== true) throw failure('IDENTITY_INVALID', 'Expected a ready EV-MUX v4 firmware identity')
-          data = { identity: info.identity, features: info.capabilities.features, vmReady: info.runtime.vmReady }
+          data = { identity: info.identity, features: info.capabilities.features, vmReady: info.runtime.vmReady,
+            storage: info.storage && Object.fromEntries(Object.entries(info.storage).map(([volume, state]) => [volume, { present: state.present, mounted: state.mounted, writable: state.writable, reason: state.reason }])) }
         } else if (name === 'camera') {
           const image = await device.capture({ source: 'camera', format: 'jpeg', quality: options.quality, timeout: options.frameTimeout * 1000, signal })
           data = await saveJpeg(image, options.output)
@@ -116,14 +133,8 @@ export async function runDeviceChecks(device, options, { signal, nonce, report =
         result = { name, status: 'PASS', data }
       } catch (error) {
         cancelled(signal)
-        const skip = unsupported(error) && !(name === 'display' && options.screenOutput)
+        const skip = unsupported(error) && !options.requireAll && !(name === 'display' && options.screenOutput)
         result = { name, status: skip ? 'SKIP' : 'FAIL', error: { code: error.code ?? 'DEVICE_CHECK_FAILED', message: String(error.message ?? 'Device check failed').slice(0, 240) } }
-        if (error.code === 'WRITE_FAILED') {
-          try {
-            const status = await device.inspect({ fields: ['storage'], timeout: 3000, signal })
-            result.storage = Object.fromEntries(Object.entries(status.storage).map(([volume, state]) => [volume, { present: state.present, mounted: state.mounted, status: state.status, writable: state.writable, reason: state.reason }]))
-          } catch { /* Preserve the upload failure. */ }
-        }
       } finally {
         if (name === 'display' && loaded) {
           try { await execute(`${namespace}['close_display']()`, 5000, AbortSignal.timeout(6000)) }
@@ -140,13 +151,7 @@ export async function runDeviceChecks(device, options, { signal, nonce, report =
       try { await execute(`if ${JSON.stringify(namespace)} in globals():\n ${namespace}.get('close_display',lambda:None)()\n del ${namespace}`, 5000, cleanupSignal) }
       catch (error) { cleanupError = error }
     }
-    if (ownsFixture) {
-      try {
-        const entries = await device.files.list({ path: '/', signal: cleanupSignal })
-        for (const entry of entries) if ([fixturePath, `${fixturePath}.tmp`].includes(entry.path)) await device.files.remove({ path: entry.path, signal: cleanupSignal })
-      } catch (error) { cleanupError ??= error }
-    }
-    if (cleanupError) record({ name: 'fixture-cleanup', status: 'FAIL', error: { code: 'FIXTURE_CLEANUP_FAILED', message: 'Could not clean up the hardware fixture', path: fixturePath } })
+    if (cleanupError) record({ name: 'fixture-cleanup', status: 'FAIL', error: { code: 'FIXTURE_CLEANUP_FAILED', message: 'Could not release the hardware fixture namespace' } })
   }
   const summary = { passed: results.filter(result => result.status === 'PASS').length, failed: results.filter(result => result.status === 'FAIL').length, skipped: results.filter(result => result.status === 'SKIP').length }
   report({ check: 'summary', ...summary })

package/tests/fixtures/device-checks.py

@@ -6,6 +6,11 @@ All transport, ownership and cleanup are supplied by the public JS SDK.
 """
 
 
+def is_unsupported(exc):
+    message = str(exc).lower()
+    return any(token in message for token in ('esp_err_not_supported', 'esp_err_not_found', 'no module named', 'enodev'))
+
+
 def framesizes(opts):
     import sensor
     sensor.reset()
@@ -18,8 +23,10 @@ def framesizes(opts):
             img = sensor.snapshot()
             results.append(dict(name=name, supported=True, width=img.width(), height=img.height(),
                                 reportedWidth=sensor.width(), reportedHeight=sensor.height()))
-        except Exception:
-            results.append(dict(name=name, supported=False))
+        except Exception as exc:
+            if not is_unsupported(exc):
+                raise
+            results.append(dict(name=name, supported=False, reason=str(exc)))
     working = [item for item in results if item['supported']]
     assert working, 'no framesize produced a frame'
     for item in working:
@@ -39,8 +46,10 @@ def pixformats(opts):
             img = sensor.snapshot()
             results.append(dict(name=name, supported=True, width=img.width(), height=img.height(),
                                 actualBytes=img.size(), expectedBytes=img.width() * img.height() * depth))
-        except Exception:
-            results.append(dict(name=name, supported=False))
+        except Exception as exc:
+            if not is_unsupported(exc):
+                raise
+            results.append(dict(name=name, supported=False, reason=str(exc)))
     working = [item for item in results if item['supported']]
     assert working, 'no pixel format produced a frame'
     for item in working:
@@ -311,7 +320,6 @@ def run_check(name, opts):
         result = dict(name=name, status='PASS', data=data)
     except Exception as exc:
         message = str(exc)
-        unsupported = ('ESP_ERR_NOT_SUPPORTED', 'ESP_ERR_NOT_FOUND', 'no module named', 'ENODEV')
-        status = 'SKIP' if any(token.lower() in message.lower() for token in unsupported) else 'FAIL'
+        status = 'SKIP' if is_unsupported(exc) else 'FAIL'
         result = dict(name=name, status=status, error=dict(type=type(exc).__name__, message=message))
     print('__EVDEVICECHECK__' + json.dumps(result))

package/tests/hardware-check.mjs

@@ -7,7 +7,7 @@ export { tcpTransport, serialTransport } from '../src/node_transport.js'
 import { createDevice } from '../src/index.js'
 import { DEVICE_CHECKS, runDeviceChecks, saveJpeg } from './device-checks.mjs'
 
-export const usage = 'Usage: npm run test:hardware -- (--tcp HOST[:PORT] | --serial PATH) [--role usj|usb|uart] [--python PYTHON] [--write] [--capture] [--checks all|CSV] [--frames N] [--framesize QVGA] [--pixformat RGB565] [--quality 60] [--frame-timeout SECONDS] [--display-hold SECONDS] [--output CAMERA.jpg] [--screen-output LCD.jpg] [--timeout MILLISECONDS]'
+export const usage = 'Usage: npm run test:hardware -- (--tcp HOST[:PORT] | --serial PATH) [--role usj|usb|uart] [--python PYTHON] [--expect-board BOARD] [--expect-firmware-version VERSION] [--write] [--capture] [--checks all|CSV] [--require-all] [--frames N] [--framesize QVGA] [--pixformat RGB565] [--quality 60] [--frame-timeout SECONDS] [--display-hold SECONDS] [--output CAMERA.jpg] [--screen-output LCD.jpg] [--timeout MILLISECONDS]'
 const fail = (code, message) => Object.assign(new Error(message), { code })
 
 export function parseArgs(args) {
@@ -16,8 +16,8 @@ export function parseArgs(args) {
   for (let index = 0; index < args.length; index++) {
     const option = args[index]
     if (option === '--help') return { help: true }
-    if (option === '--write' || option === '--capture') { options[option.slice(2)] = true; continue }
-    if (!['--tcp', '--serial', '--role', '--python', '--timeout', '--checks', '--screen-output', '--output', '--frames', '--display-hold', '--framesize', '--pixformat', '--quality', '--frame-timeout'].includes(option)) throw fail('ARGUMENT', 'Unknown argument')
+    if (['--write', '--capture', '--require-all'].includes(option)) { options[option === '--require-all' ? 'requireAll' : option.slice(2)] = true; continue }
+    if (!['--tcp', '--serial', '--role', '--python', '--timeout', '--checks', '--screen-output', '--output', '--frames', '--display-hold', '--framesize', '--pixformat', '--quality', '--frame-timeout', '--expect-board', '--expect-firmware-version'].includes(option)) throw fail('ARGUMENT', 'Unknown argument')
     const value = args[++index]
     if (!value || value.startsWith('--')) throw fail('ARGUMENT', 'Missing argument value')
     const key = option.slice(2).replace(/-([a-z])/g, (_match, letter) => letter.toUpperCase())
@@ -75,13 +75,20 @@ export async function checkHardware(options, { device = createDevice({ transport
     await device.connect({ role: options.role, timeout: Math.min(options.timeout, 30000), signal: controller.signal })
     cancelled()
     const status = await device.inspect({ fields: ['identity', 'capabilities', 'runtime'], signal: controller.signal })
+    if (options.expectBoard && status.identity?.board !== options.expectBoard) throw fail('BOARD_MISMATCH', 'Connected board does not match the requested board')
+    if (options.expectFirmwareVersion && status.identity?.firmwareVersion !== options.expectFirmwareVersion) throw fail('FIRMWARE_MISMATCH', 'Running firmware does not match the selected build artifact')
     // Only selected public identity fields are logged; never network credentials or Python output.
-    report({ check: 'inspect', ok: true, identity: { deviceId: status.identity?.deviceId ?? null, board: status.identity?.board ?? null, hostname: status.identity?.hostname ?? null } })
+    report({ check: 'inspect', ok: true, identity: { deviceId: status.identity?.deviceId ?? null, board: status.identity?.board ?? null, hostname: status.identity?.hostname ?? null, firmwareVersion: status.identity?.firmwareVersion ?? null } })
     const marker = `EV_HARDWARE_${nonce}`
     const execution = await device.python.execute({ source: `print('${marker}')`, timeout: 10000, maxOutputChars: 1024, signal: controller.signal })
     if (!execution.ok || !execution.output.split(/\r?\n/).some(line => line.trim() === marker)) throw fail('PYTHON_CHECK', 'Python marker was not received')
     report({ check: 'python', ok: true })
     if (options.write) {
+      const storage = await device.inspect({ fields: ['storage'], signal: controller.signal })
+      const flash = storage.storage?.flash
+      const ready = flash?.present === true && flash?.mounted === true && flash?.writable === true
+      report({ check: 'storage', ok: ready, flash: { present: flash?.present ?? null, mounted: flash?.mounted ?? null, writable: flash?.writable ?? null, reason: flash?.reason ?? null } })
+      if (!ready) throw fail('STORAGE_UNAVAILABLE', 'File acceptance requires a mounted writable Flash filesystem; no formatting was attempted')
       const entries = await device.files.list({ path: '/', signal: controller.signal })
       if (entries.some(entry => entry.path === path || entry.path === `${path}.tmp`)) throw fail('TEST_PATH_EXISTS', 'Test path already exists; refusing to modify it')
       ownedPath = path

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 () => {

package/tests/test-device-functional-checks.mjs

@@ -3,6 +3,7 @@ import test from 'node:test'
 import assert from 'node:assert/strict'
 import { readFile, mkdtemp, rm } from 'node:fs/promises'
 import { join } from 'node:path'
+import { EV_REPL_INPUT_MAX_BYTES, evReplExecInputBytes } from '../src/evrepl.js'
 import { tmpdir } from 'node:os'
 import { parseArgs } from './hardware-check.mjs'
 import { DEVICE_CHECKS, parseCheckResult, runDeviceChecks, saveJpeg } from './device-checks.mjs'
@@ -11,11 +12,11 @@ function devicePeer({ results = {}, board = 'TEST', screenFails = false } = {})
   const files = new Map(), calls = [], listeners = new Map()
   return {
     calls, files, listeners,
-    async inspect({ fields }) { calls.push(['inspect', fields]); return { identity: { board, firmwareVersion: 'test' }, capabilities: { protocol: { evMuxVersion: 4 }, features: [] }, runtime: { vmReady: true } } },
+    async inspect({ fields }) { calls.push(['inspect', fields]); return { identity: { board, firmwareVersion: 'test' }, capabilities: { protocol: { evMuxVersion: 4 }, features: ['storage.writer.lease'], limits: { replInputMax: EV_REPL_INPUT_MAX_BYTES } }, runtime: { vmReady: true }, storage: { flash: { present: true, mounted: false, writable: false } } } },
     files: Object.assign(files, {
-      async list() { return [...files.keys()].map(path => ({ path })) },
-      async write({ path, data, overwrite }) { calls.push(['write', path]); assert.equal(overwrite, false); files.set(path, data) },
-      async remove({ path }) { calls.push(['remove', path]); files.delete(path) },
+      async list() { throw new Error('Runtime checks must not access storage') },
+      async write() { throw Object.assign(new Error('Flash unmounted'), { code: 'FILE_OPEN_FAILED' }) },
+      async remove() { throw new Error('Runtime checks must not access storage') },
     }),
     python: { async execute({ source }) {
       calls.push(['execute', source])
@@ -48,10 +49,15 @@ test('device check reports reject stale, duplicated and malformed markers', () =
   for (const output of ['', valid + '\n' + valid, '__EVDEVICECHECK__bad', valid.replace('memory', 'camera'), valid.replace('PASS', 'UNKNOWN')]) assert.throws(() => parseCheckResult(output, 'memory'), { code: 'CHECK_REPORT_INVALID' })
 })
 
-test('functional checks stage their shared fixture once and consume preview via public events', async () => {
+test('functional checks load fixtures in RAM despite unmounted storage and consume public preview events', async () => {
   const device = devicePeer(), reports = []
   await runDeviceChecks(device, parseArgs(['--tcp', 'test', '--checks', 'memory,preview,orientation']), { nonce: 'abc123', report: value => reports.push(value) })
-  assert.equal(device.calls.filter(call => call[0] === 'write').length, 1)
+  const commands = device.calls.filter(call => call[0] === 'execute').map(call => call[1])
+  assert.ok(commands.every(source => evReplExecInputBytes(source) <= EV_REPL_INPUT_MAX_BYTES))
+  assert.equal(commands.filter(source => source.startsWith("exec(''.join(")).length, 1)
+  const loader = commands.filter(source => source.includes("['_source']") || source.includes("={'_source':"))
+  const uploaded = loader.filter(source => source.includes("['_source'].append(")).map(source => JSON.parse(source.slice(source.indexOf('.append(') + 8, -1))).join('')
+  assert.equal(uploaded, await readFile(new URL('./fixtures/device-checks.py', import.meta.url), 'utf8'))
   assert.equal(device.files.size, 0)
   assert.equal(device.listeners.size, 0)
   assert.equal(reports.find(result => result.check === 'preview').data.received, 1)
@@ -96,3 +102,36 @@ test('truncated JPEG and missing dimensions are refused before host artifact is
   await assert.rejects(saveJpeg({ data: new Uint8Array([255, 216]), mimeType: 'image/jpeg', metadata: { width: 1, height: 1 } }), { code: 'CAPTURE_INVALID' })
   await assert.rejects(saveJpeg({ data: new Uint8Array([255, 216, 255, 217]), mimeType: 'image/jpeg' }), { code: 'CAPTURE_INVALID' })
 })
+
+
+test('strict acceptance fails unsupported selected checks without preventing independent identity evidence', async () => {
+  const device = devicePeer({ results: { memory: { name: 'memory', status: 'SKIP', error: { message: 'ESP_ERR_NOT_SUPPORTED' } } } }), reports = []
+  await assert.rejects(runDeviceChecks(device, parseArgs(['--tcp', 'test', '--checks', 'memory,identity', '--require-all']), { nonce: 'abc123', report: value => reports.push(value) }), { code: 'DEVICE_CHECKS_FAILED' })
+  assert.equal(reports.find(result => result.check === 'memory').status, 'FAIL')
+  assert.equal(reports.find(result => result.check === 'identity').status, 'PASS')
+  assert.equal(reports.find(result => result.check === 'identity').data.storage.flash.mounted, false)
+})
+
+test('failed partial RAM loading still releases its namespace without filesystem cleanup', async () => {
+  const device = devicePeer(), reports = [], execute = device.python.execute
+  let failed = false
+  device.python.execute = async request => {
+    if (!failed && request.source.includes("['_source'].append")) { failed = true; throw new Error('fixture load failed') }
+    return execute(request)
+  }
+  await assert.rejects(runDeviceChecks(device, parseArgs(['--tcp', 'test', '--checks', 'memory']), { nonce: 'abc123', report: value => reports.push(value) }), { code: 'DEVICE_CHECKS_FAILED' })
+  assert.ok(device.calls.some(call => call[0] === 'execute' && call[1].includes('del _evhil_abc123')))
+  assert.equal(reports.at(-1).failed, 1)
+})
+
+test('identity and RAM checks do not require optional storage inspection support', async () => {
+  const device = devicePeer(), inspect = device.inspect, reports = []
+  device.inspect = async request => {
+    assert.ok(!request.fields.includes('storage'))
+    const info = await inspect(request)
+    info.capabilities.features = []
+    return info
+  }
+  await runDeviceChecks(device, parseArgs(['--tcp', 'test', '--checks', 'identity,memory']), { nonce: 'abc123', report: value => reports.push(value) })
+  assert.deepEqual(reports.at(-1), { check: 'summary', passed: 2, failed: 0, skipped: 0 })
+})

package/tests/test-device-hardware-cli.mjs

@@ -54,7 +54,7 @@ function fakeDevice({ mismatch = false, collision = false, writeFails = false }
   return {
     calls, files,
     async connect() { calls.push('connect') },
-    async inspect() { return { identity: { board: 'TEST' }, network: { password: 'NEVER_PRINT' } } },
+    async inspect() { return { identity: { board: 'TEST', firmwareVersion: 'test' }, storage: { flash: { present: true, mounted: true, writable: true } }, network: { password: 'NEVER_PRINT' } } },
     python: { async execute() { return { ok: true, output: 'EV_HARDWARE_abc123\n' } } },
     files: Object.assign(files, {
       async list() { return [...files.keys()].map(path => ({ path })) },
@@ -101,3 +101,22 @@ test('missing optional Python executable fails cleanly without opening a port',
     await assert.rejects(transport.connect({ signal: AbortSignal.timeout(1000) }), { code: 'SERIAL_ERROR' })
   } finally { unsubscribe(); await transport.disconnect() }
 })
+
+
+test('expected board and firmware must match before any Python or file operations', async () => {
+  for (const args of [['--expect-board', 'OTHER'], ['--expect-firmware-version', 'stale']]) {
+    const device = fakeDevice()
+    device.python.execute = async () => assert.fail('Wrong device must not execute Python')
+    await assert.rejects(checkHardware(parseArgs(['--tcp', 'localhost', ...args]), { device, report() {} }), { code: args[0] === '--expect-board' ? 'BOARD_MISMATCH' : 'FIRMWARE_MISMATCH' })
+    assert.deepEqual(device.calls, ['connect', 'disconnect'])
+  }
+})
+
+test('explicit file acceptance reports unmounted storage and fails without writing or formatting', async () => {
+  const device = fakeDevice(), inspect = device.inspect, reports = []
+  device.inspect = async request => ({ ...await inspect(request), storage: { flash: { present: true, mounted: false, writable: true, reason: 'HOST_WRITER_ACTIVE' } } })
+  await assert.rejects(checkHardware(parseArgs(['--tcp', 'localhost', '--write']), { device, nonce: 'abc123', report: value => reports.push(value) }), { code: 'STORAGE_UNAVAILABLE' })
+  assert.deepEqual(device.calls, ['connect', 'disconnect'])
+  assert.equal(reports.find(result => result.check === 'storage').flash.mounted, false)
+  assert.equal(reports.find(result => result.check === 'storage').ok, false)
+})