@esp-vision/device-core 0.4.2 → 0.5.1

package/tests/test-device-execution.mjs

@@ -1,29 +1,71 @@
 // SPDX-License-Identifier: Apache-2.0
 import assert from 'node:assert/strict'
 import test from 'node:test'
+import { createPythonApi } from '../src/device_python.js'
 import { DeviceSession } from '../src/device_session.js'
 import { EvMuxParser, makeEvMuxFrame } from '../src/evmux.js'
 import { EvRepl } from '../src/evrepl.js'
 
-function executionFixture({ short = false, failWrite = false, failStop = false, stalledReset = false } = {}) {
+function executionFixture({ short = false, failWrite = false, failStop = false, stalledReset = false, deferExec = false, deferRun = false, deferStart = false, features = ['file.write.binary', 'script.run', 'device.control'] } = {}) {
   const requests = []
   let running = false
   let sentinel = null
+  let startMarker = null
+  let startMarkerEmitted = false
+  let pendingExec = null
   let terminal = ''
+  let startAndCompletionInSameFrame = false
   let session
   let resetRequested = false
   let resetPolls = 0
   let uploaded = 0
-  const stdout = (payload) => session.feedBytes(makeEvMuxFrame({
-    channel: 'repl.stdout', type: 'data', sessionId: session.sessionId, vmEpoch: session.vmEpoch, payload,
-  }))
+  const stdout = (payload) => {
+    if (startMarker && sentinel?.marker && String(payload).includes(startMarker) && String(payload).includes(sentinel.marker)) {
+      startAndCompletionInSameFrame = true
+    }
+    session.feedBytes(makeEvMuxFrame({
+      channel: 'repl.stdout', type: 'data', sessionId: session.sessionId, vmEpoch: session.vmEpoch, payload,
+    }))
+  }
+  const finishFast = () => {
+    if (startMarker && !startMarkerEmitted && sentinel) {
+      startMarkerEmitted = true
+      running = true
+      const completionMarker = sentinel.marker
+      stdout(`${startMarker}\r\n${completionMarker}\r\n>>> `)
+      running = false
+      sentinel = null
+      startMarker = null
+      startMarkerEmitted = false
+      return
+    }
+    finish()
+  }
+  const enter = () => {
+    if (!startMarker || startMarkerEmitted) return
+    startMarkerEmitted = true
+    running = true
+    const split = Math.floor(startMarker.length / 2)
+    stdout(startMarker.slice(0, split))
+    stdout(`${startMarker.slice(split)}\r`)
+    stdout('\n')
+  }
   const finish = () => {
+    if (startMarker && !startMarkerEmitted) enter()
     running = false
     if (sentinel) {
-      stdout(`${sentinel.line}${sentinel.marker}\r\n>>> `)
+      stdout(`${sentinel.startMarker ? '' : sentinel.line}${sentinel.marker}\r\n>>> `)
       sentinel = null
+      startMarker = null
+      startMarkerEmitted = false
     }
   }
+  const finishExec = () => {
+    if (!pendingExec) return
+    const command = pendingExec
+    pendingExec = null
+    stdout(`${command}>>> `)
+  }
   const parser = new EvMuxParser({
     filterFrame: (metadata, bytes) => {
       const text = new TextDecoder().decode(bytes)
@@ -35,10 +77,27 @@ function executionFixture({ short = false, failWrite = false, failStop = false,
           resetRequested = true
           return
         }
-        const match = /print\("(~~EVSCRIPT-END:[^"]+)"\)/.exec(text)
-        if (match) {
-          sentinel = { line: text, marker: match[1] }
-          if (short) finish()
+        const marker = /~~EVSCRIPT-END:[A-Za-z0-9-]+~~/.exec(text)?.[0]
+        if (marker) {
+          startMarker = /~~EVSCRIPT-START:[A-Za-z0-9-]+~~/.exec(text)?.[0] ?? null
+          startMarkerEmitted = false
+          sentinel = { line: text.trimEnd(), marker, startMarker }
+          if (startMarker) {
+            const echoSplit = Math.floor(text.length / 2)
+            stdout(text.slice(0, echoSplit))
+            stdout(`${text.slice(echoSplit)}\r\n`)
+          }
+          if (deferRun) {
+            if (startMarker && !deferStart) enter()
+            running = true
+            stdout('')
+          } else if (short && startMarker && !deferStart) finishFast()
+          else {
+            if (startMarker && !deferStart) enter()
+            if (short) finish()
+          }
+        } else if (deferExec && text.startsWith('exec(')) {
+          pendingExec = text
         } else {
           stdout(`${text}\r\n>>> `)
         }
@@ -85,10 +144,79 @@ function executionFixture({ short = false, failWrite = false, failStop = false,
   session.vmEpoch = 1
   session.vmReady = true
   session.limits.fileWriteChunkMax = 16384
-  session.capabilities = { features: ['file.write.binary', 'script.run', 'device.control'] }
-  return { session, requests, finish, get terminal() { return terminal }, get running() { return running } }
+  session.capabilities = { features }
+  return { session, requests, finish, enter, finishExec, get terminal() { return terminal }, get running() { return running },
+    get startAndCompletionInSameFrame() { return startAndCompletionInSameFrame } }
 }
 
+test('inline source assignment splits at the REPL limit without changing source text', () => {
+  const repl = new EvRepl({ writeEvmux: async () => {} })
+  const variableName = '__evcore_python_boundary'
+  const source = `${'x'.repeat(470)}😀\nprint("done")`
+  assert.ok(repl.execInputBytes(source) <= repl.inputMaxBytes)
+  const assignments = repl.createInlineSourceAssignments(source, variableName)
+  assert.ok(assignments.length > 1, 'the private assignment prefix requires safe chunks at this boundary')
+  assert.ok(assignments.every(statement => repl.execInputBytes(statement) <= repl.inputMaxBytes))
+  const rebuilt = assignments.map((statement, index) => JSON.parse(statement.slice(variableName.length + (index === 0 ? 1 : 2)))).join('')
+  assert.equal(rebuilt, source)
+  const command = repl.createInlineScriptRunCommand(variableName)
+  assert.ok(new TextEncoder().encode(command).length <= repl.inputMaxBytes)
+  assert.match(command, new RegExp(`exec\\(${variableName}\\)`))
+  assert.match(command, new RegExp(`del ${variableName}`))
+})
+
+test('python.execute small source waits past 30 seconds without requiring device storage', async (t) => {
+  t.mock.timers.enable({ apis: ['setTimeout'] })
+  const fixture = executionFixture({ deferRun: true, features: [] })
+  t.after(() => fixture.session.close())
+  let settled = false
+  const execution = fixture.session.executePython('while True: pass').then(output => {
+    settled = true
+    return output
+  })
+  await new Promise(resolve => setImmediate(resolve))
+  assert.equal(fixture.session.runCapture?.timer, null, 'omitted timeout leaves completion pending')
+  assert.equal(fixture.session.runCapture?.path, null, 'small source does not create a device file')
+  assert.ok(fixture.requests.some(({ metadata, payload }) => metadata.channel === 'repl.stdin' && String(payload).includes('__evcore_python_')))
+  assert.ok(!fixture.requests.some(({ metadata }) => ['file.write', 'script.run'].includes(metadata.method)))
+  t.mock.timers.tick(31000)
+  await Promise.resolve()
+  assert.equal(settled, false, 'silent Python still waits beyond the former fixed completion timeout')
+  fixture.finish()
+  assert.match(await execution, /^\s*$/)
+})
+
+test('Python deadlines include REPL setup and cancellation releases API ownership', async (t) => {
+  t.mock.timers.enable({ apis: ['setTimeout'] })
+  const timed = executionFixture({ deferExec: true })
+  t.after(() => timed.session.close())
+  const state = {}
+  const python = createPythonApi({ session: timed.session, state })
+  const execution = python.execute({ source: 'print(42)', timeout: 1000 })
+  const timedOut = assert.rejects(execution, { code: 'TIMEOUT' })
+  await new Promise(resolve => setImmediate(resolve))
+  t.mock.timers.tick(1000)
+  await timedOut
+  assert.equal(state.operation, null, 'deadline releases the operation lock even during setup')
+
+  const cancelled = executionFixture({ deferRun: true })
+  t.after(() => cancelled.session.close())
+  const cancelledState = {}
+  const cancelledPython = createPythonApi({ session: cancelled.session, state: cancelledState })
+  const controller = new AbortController()
+  const cancellation = cancelledPython.execute({ source: 'while True: pass', signal: controller.signal })
+  const aborted = assert.rejects(cancellation, { name: 'AbortError' })
+  await new Promise(resolve => setImmediate(resolve))
+  assert.ok(cancelledState.operation, 'the operation remains owned while Python is still running')
+  controller.abort()
+  await aborted
+  await new Promise(resolve => setImmediate(resolve))
+  assert.equal(cancelledState.operation, null, 'cancellation releases the operation lock')
+  assert.equal(cancelledState.run, null, 'cancellation does not leave a false active-run claim')
+  assert.ok(cancelled.requests.some(({ metadata, payload }) => metadata.method === 'device.control' && payload.action === 'stop'),
+    'cancellation requests a stop but the API still reports cancellation, not success')
+})
+
 test('interactive execution survives the bounded-run deadline, streams output, and completes on shared stop', async (t) => {
   t.mock.timers.enable({ apis: ['setTimeout'] })
   const fixture = executionFixture()
@@ -111,11 +239,75 @@ test('interactive execution survives the bounded-run deadline, streams output, a
   assert.ok(!fixture.terminal.includes('~~EVSCRIPT-END'), 'shared completion markers never leak into terminal output')
 })
 
-test('short scripts can complete while startScript is returning', async () => {
+test('startScript waits for the VM-entry marker and ignores the echoed marker in its command', async () => {
+  const fixture = executionFixture({ deferStart: true })
+  let resolved = false
+  const starting = fixture.session.startScript('/main.py', undefined, { inlineCompletion: true }).then(run => {
+    resolved = true
+    return run
+  })
+  await new Promise(resolve => setImmediate(resolve))
+  assert.equal(resolved, false, 'a successful stdin write is not evidence that MicroPython entered the runner')
+  assert.equal(fixture.running, false)
+  assert.equal(fixture.session.runCapture?.timer, null, 'interactive start acknowledgement does not create an aggregate run deadline')
+  fixture.enter()
+  const run = await starting
+  assert.equal(fixture.running, true)
+  assert.doesNotMatch(fixture.terminal, /~~EVSCRIPT-START:/, 'the private entry marker is filtered from terminal output')
+  fixture.finish()
+  await run.done
+  fixture.session.close()
+})
+
+test('startScript entry acknowledgement has a bounded setup wait', async (t) => {
+  t.mock.timers.enable({ apis: ['setTimeout'] })
+  const fixture = executionFixture({ deferStart: true })
+  const starting = fixture.session.startScript('/main.py', undefined, { inlineCompletion: true })
+  const timedOut = assert.rejects(starting, { code: 'SCRIPT_START_TIMEOUT' })
+  await new Promise(resolve => setImmediate(resolve))
+  t.mock.timers.tick(5000)
+  await timedOut
+  assert.equal(fixture.session.scriptRunSnapshot(), null)
+  fixture.session.close()
+})
+
+test('cancellation while waiting for VM entry rejects start and releases the run capture', async () => {
+  const fixture = executionFixture({ deferStart: true })
+  const controller = new AbortController()
+  const starting = fixture.session.startScript('/main.py', undefined, {
+    inlineCompletion: true,
+    signal: controller.signal,
+  })
+  const cancelled = assert.rejects(starting, { name: 'AbortError' })
+  await new Promise(resolve => setImmediate(resolve))
+  controller.abort()
+  await cancelled
+  await new Promise(resolve => setImmediate(resolve))
+  assert.equal(fixture.session.scriptRunSnapshot(), null)
+  assert.ok(fixture.requests.some(({ metadata, payload }) => metadata.method === 'device.control' && payload.action === 'stop'))
+  fixture.session.close()
+})
+
+test('closing the transport while waiting for VM entry rejects start and releases the run capture', async () => {
+  const fixture = executionFixture({ deferStart: true })
+  const starting = fixture.session.startScript('/main.py', undefined, { inlineCompletion: true })
+  const disconnected = assert.rejects(starting, /device disconnected/)
+  await new Promise(resolve => setImmediate(resolve))
+  assert.ok(fixture.session.repl.scriptStartWaiter, 'startup is waiting for the VM-entry acknowledgement')
+  fixture.session.close(new Error('device disconnected'))
+  await disconnected
+  assert.equal(fixture.session.scriptRunSnapshot(), null)
+  assert.equal(fixture.session.repl.scriptStartWaiter, null)
+  assert.doesNotMatch(fixture.terminal, /~~EVSCRIPT-START:/)
+})
+
+test('short scripts can complete in the same frame while startScript is returning', async () => {
   const fixture = executionFixture({ short: true })
-  const run = await fixture.session.startScript('/short.py', 'print(1)')
+  const run = await fixture.session.startScript('/short.py', undefined, { inlineCompletion: true })
+  assert.equal(fixture.startAndCompletionInSameFrame, true)
   assert.equal((await run.done).path, '/short.py')
   assert.equal(fixture.session.scriptRunSnapshot(), null)
+  assert.doesNotMatch(fixture.terminal, /~~EVSCRIPT-START:/)
   fixture.session.close()
 })
 
@@ -149,18 +341,45 @@ test('failed stop does not claim execution has finished', async () => {
   fixture.session.close()
 })
 
-test('bounded Agent execution still times out and sends a shared interrupt', async () => {
+test('bounded Agent execution still times out and sends a shared interrupt', async (t) => {
+  t.mock.timers.enable({ apis: ['setTimeout'] })
   const fixture = executionFixture()
+  t.after(() => fixture.session.close())
+  // Isolate the running-script deadline from the separately covered upload
+  // and REPL setup. A real 30 ms startup budget races CI scheduling.
+  fixture.session.stopForRepl = async () => true
+  fixture.session.writeScript = async () => {}
   let started
   const starting = new Promise(resolve => { started = resolve })
   const done = fixture.session.runScript('/trial.py', 'while True: pass', { timeout: 30, onStarted: started })
   const rejected = assert.rejects(done, (error) => error.code === 'SCRIPT_TIMEOUT')
   await starting
+  t.mock.timers.tick(30)
   await rejected
   assert.equal(fixture.session.scriptRunSnapshot(), null)
-  await new Promise(resolve => setTimeout(resolve, 0))
+  await new Promise(resolve => setImmediate(resolve))
   assert.ok(fixture.requests.some(({ metadata, payload }) => metadata.method === 'device.control' && payload.action === 'stop'))
-  fixture.session.close()
+})
+
+test('bounded start handles reject when the deadline precedes VM entry', async (t) => {
+  t.mock.timers.enable({ apis: ['setTimeout'] })
+  const fixture = executionFixture({ deferStart: true })
+  t.after(() => fixture.session.close())
+  fixture.session.stopForRepl = async () => true
+  fixture.session.writeScript = async () => {}
+  let started = false
+  const starting = fixture.session.startScript('/trial.py', undefined, {
+    inlineCompletion: true,
+    timeout: 30,
+    onStarted() { started = true },
+  })
+  const rejected = assert.rejects(starting, { code: 'SCRIPT_TIMEOUT' })
+  await new Promise(resolve => setImmediate(resolve))
+  t.mock.timers.tick(30)
+  await rejected
+  assert.equal(started, false)
+  assert.equal(fixture.session.scriptRunSnapshot(), null)
+  assert.equal(fixture.session.runStarting, false)
 })
 
 test('VM reset and disconnect settle interactive completion and allow the next VM run', async () => {

package/tests/test-device-files-api.mjs

@@ -35,8 +35,92 @@ test('file upload selects encoding and creation policy from public parameters',
 test('file read is binary by default with explicit UTF-8 decoding and bounded options', async () => {
   const { files, calls } = fixture()
   assert.ok(await files.read({ path: '/model.bin' }) instanceof Uint8Array)
+  assert.deepEqual(calls[0][2], { timeout: null, chunkTimeout: 30000, maxBytes: null, signal: null })
   assert.equal(await files.read({ path: '/a.txt', encoding: 'utf-8', maxBytes: 512 }), '你好')
-  assert.equal(calls[1][2].maxBytes, 512)
+  assert.deepEqual(calls[1][2], { timeout: null, chunkTimeout: 30000, maxBytes: 512, signal: null })
+})
+
+test('files.read forwards aggregate and per-command timeouts and validates both', async () => {
+  const { files, calls } = fixture()
+  await files.read({ path: '/a', timeout: 90000, chunkTimeout: 4500, maxBytes: 2048 })
+  assert.deepEqual(calls[0][2], { timeout: 90000, chunkTimeout: 4500, maxBytes: 2048, signal: null })
+  await files.read({ path: '/a', timeout: null, chunkTimeout: 12000 })
+  assert.deepEqual(calls[1][2], { timeout: null, chunkTimeout: 12000, maxBytes: null, signal: null })
+  for (const timeout of [0, -1, NaN, Infinity, '100']) {
+    await assert.rejects(files.read({ path: '/a', timeout }), RangeError)
+  }
+  for (const chunkTimeout of [null, 0, -1, NaN, Infinity, '100']) {
+    await assert.rejects(files.read({ path: '/a', chunkTimeout }), RangeError)
+  }
+  assert.equal(calls.length, 2, 'invalid timeout settings must fail before device I/O')
+})
+
+function installSimulatedFileRead(repl, data, { commandDurationMs, advanceClock }) {
+  const budgets = []
+  repl._execPy = async (source, timeout) => {
+    budgets.push(timeout)
+    if (commandDurationMs > timeout) {
+      advanceClock(timeout)
+      throw Object.assign(new Error('repl exec timeout'), { code: 'TIMEOUT' })
+    }
+    advanceClock(commandDurationMs)
+    const offset = Number(/f.seek\((\d+)\)/.exec(source)[1])
+    const count = Number(/f.read\((\d+)\)/.exec(source)[1])
+    const chunk = data.slice(offset, offset + count)
+    const hex = [...chunk].map(byte => byte.toString(16).padStart(2, '0')).join('')
+    return `__EVREAD_OK__${data.length}:${chunk.length}:${hex}\n`
+  }
+  return budgets
+}
+
+test('a 56 KiB file read can take longer than 30 seconds with a fresh bound per REPL command', async () => {
+  const repl = new EvRepl({ writeEvmux() {} })
+  const data = Uint8Array.from({ length: 56 * 1024 }, (_, index) => index % 256)
+  const originalNow = Date.now
+  let now = 100000
+  Date.now = () => now
+  try {
+    const budgets = installSimulatedFileRead(repl, data, {
+      commandDurationMs: 1000,
+      advanceClock: duration => { now += duration },
+    })
+    assert.deepEqual(await repl.readFile('/slow.bin'), data)
+    assert.equal(now - 100000, 56000)
+    assert.equal(budgets.length, 56)
+    assert.ok(budgets.every(timeout => timeout === 30000))
+  } finally {
+    Date.now = originalNow
+  }
+})
+
+test('file reads keep per-command bounds and an optional aggregate deadline', async () => {
+  const data = Uint8Array.from({ length: 4096 }, (_, index) => index % 256)
+  const originalNow = Date.now
+  let now = 200000
+  Date.now = () => now
+  try {
+    const chunkedRepl = new EvRepl({ writeEvmux() {} })
+    const chunkBudgets = installSimulatedFileRead(chunkedRepl, data, {
+      commandDurationMs: 4000,
+      advanceClock: duration => { now += duration },
+    })
+    assert.deepEqual(await chunkedRepl.readFile('/slow.bin', { timeout: 20000, chunkTimeout: 5000 }), data)
+    assert.deepEqual(chunkBudgets, [5000, 5000, 5000, 5000])
+
+    now = 300000
+    const totalTimeoutRepl = new EvRepl({ writeEvmux() {} })
+    const totalBudgets = installSimulatedFileRead(totalTimeoutRepl, data, {
+      commandDurationMs: 8000,
+      advanceClock: duration => { now += duration },
+    })
+    await assert.rejects(
+      totalTimeoutRepl.readFile('/slow.bin', { timeout: 25000, chunkTimeout: 30000 }),
+      { code: 'TIMEOUT' },
+    )
+    assert.deepEqual(totalBudgets, [25000, 17000, 9000, 1000])
+  } finally {
+    Date.now = originalNow
+  }
 })
 
 test('file listing passes scoped path and recursion without walking the entire device', async () => {

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

@@ -135,3 +135,12 @@ test('identity and RAM checks do not require optional storage inspection support
   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 })
 })
+
+test('P4 issue regressions are included in the strict target-check path', async () => {
+  const required = ['camera_display_lifecycle', 'image_copy_to_fb', 'image_transform_argument', 'sensor_snapshot_buffer', 'memory_policy']
+  assert.ok(required.every(name => DEVICE_CHECKS.includes(name)))
+  const device = devicePeer(), reports = []
+  await runDeviceChecks(device, parseArgs(['--tcp', 'test', '--checks', required.join(','), '--require-all']),
+    { nonce: 'issue910', report: value => reports.push(value) })
+  assert.deepEqual(reports.at(-1), { check: 'summary', passed: required.length, failed: 0, skipped: 0 })
+})

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

@@ -19,9 +19,17 @@ test('default hardware acceptance exercises real facade over a fake EV-MUX TCP p
   const server = createServer(socket => {
     sockets.add(socket)
     socket.on('close', () => sockets.delete(socket))
+    let pythonMarker = null
     const parser = new EvMuxParser({ filterFrame(metadata, bytes) {
       const text = new TextDecoder().decode(bytes)
       if (metadata.channel === 'repl.stdin') {
+        pythonMarker ??= /EV_HARDWARE_[a-z0-9]+/.exec(text)?.[0] ?? null
+        const completionMarker = /~~EVSCRIPT-END:[A-Za-z0-9-]+~~/.exec(text)?.[0]
+        if (completionMarker) {
+          socket.write(makeEvMuxFrame({ channel: 'repl.stdout', type: 'data', sessionId, vmEpoch: 1,
+            payload: `${text}\r\n${pythonMarker ?? ''}\r\n${completionMarker}\r\n>>> ` }))
+          return false
+        }
         const marker = /EV_HARDWARE_[a-z0-9]+/.exec(text)?.[0] ?? 'EVIDE_BOOT_OK'
         socket.write(makeEvMuxFrame({ channel: 'repl.stdout', type: 'data', sessionId, vmEpoch: 1, payload: `${text}\r\n${marker}\r\n>>> ` }))
         return false

package/tests/test-device-python-api.mjs

@@ -7,6 +7,7 @@ import { createFilesApi } from '../src/device_files.js'
 function fixture() {
   const calls = [], state = {}
   const session = {
+    state: 'ready',
     repl: { writeStdin: async data => calls.push(['input', data]), removeFile: async path => calls.push(['remove', path]) },
     executePython: async (source, options) => { calls.push(['source', source, options]); return '42\r\n' },
     runScript: async (path, content, options) => { calls.push(['run', path, content, options]); return { ok: true, output: 'existing', outputTruncated: false } },
@@ -19,18 +20,28 @@ test('source wait and path wait return the same result shape without rewriting p
   const { python, calls } = fixture()
   assert.deepEqual(await python.execute({ source: 'print(42)' }), { ok: true, path: null, output: '42\n', outputTruncated: false })
   assert.deepEqual(await python.execute({ path: '/existing.py' }), { ok: true, path: '/existing.py', output: 'existing', outputTruncated: false })
+  assert.equal(calls[0][2].timeout, null, 'wait execution has no aggregate deadline by default')
   assert.deepEqual(calls[1].slice(0, 3), ['run', '/existing.py', undefined])
+  assert.equal(calls[1][3].timeout, null, 'path execution has no aggregate deadline by default')
   assert.equal(calls[1][3].inlineCompletion, true)
 })
 
 test('execution rejects ambiguous input, unsupported modes, unsafe paths and invalid deadlines before I/O', async () => {
   const { python, calls } = fixture()
-  for (const request of [{}, { source: '', path: '/a.py' }, { source: 0 }, { path: '../a.py' }, { path: '/a/../b.py' }, { source: '', completion: 'other' }, { source: '', timeout: 0 }, { source: '', completion: 'start', timeout: 3 }]) {
+  for (const request of [{}, { source: '', path: '/a.py' }, { source: 0 }, { path: '../a.py' }, { path: '/a/../b.py' }, { source: '', completion: 'other' }, { source: '', timeout: 0 }, { source: '', completion: 'start', timeout: 3 }, { source: '', completion: 'start', timeout: null }]) {
     await assert.rejects(python.execute(request))
   }
   assert.equal(calls.length, 0)
 })
 
+test('wait execution accepts null and forwards an explicit positive deadline', async () => {
+  const { python, calls } = fixture()
+  await python.execute({ source: 'print(42)', timeout: null })
+  await python.execute({ source: 'print(42)', timeout: 12000 })
+  assert.equal(calls[0][2].timeout, null)
+  assert.equal(calls[1][2].timeout, 12000)
+})
+
 test('pre-aborted execution never starts Python', async () => {
   const { python, calls } = fixture()
   await assert.rejects(python.execute({ source: '', signal: AbortSignal.abort() }), { name: 'AbortError' })
@@ -76,6 +87,21 @@ test('started source uses a private temporary file and removes it only after com
   assert.deepEqual(calls.at(-1), ['remove', handle.path])
 })
 
+test('disconnect skips remote cleanup for a started temporary source', async () => {
+  const { python, calls, session, state } = fixture()
+  let rejectDone
+  session.stopForRepl = async () => { calls.push(['stop']); return true }
+  session.startScript = async () => ({ done: new Promise((_resolve, reject) => { rejectDone = reject }) })
+  const handle = await python.execute({ source: 'while True: pass', completion: 'start' })
+  const disconnected = assert.rejects(handle.done, /device disconnected/)
+  session.state = 'disconnected'
+  rejectDone(new Error('device disconnected'))
+  await disconnected
+  assert.equal(calls.some(([kind]) => kind === 'stop' || kind === 'remove'), false)
+  assert.equal(state.operation, null)
+  assert.equal(state.run, null)
+})
+
 test('execution failures release the operation and retain the original error', async () => {
   const { python, session, state } = fixture()
   const failure = Object.assign(new Error('disconnected'), { code: 'SESSION_REQUIRED' })
@@ -123,7 +149,8 @@ test('interactive script input receives only user data, never the completion mar
         stdout(`${text}\r\nreceived:${text.trim()}\r\n${session.repl.scriptEndMarker}\r\n>>> `)
       } else if (text.includes('/interactive.py')) {
         waitingForInput = true
-        stdout(`${text}\r\nNAME?`)
+        const startMarker = /~~EVSCRIPT-START:[A-Za-z0-9-]+~~/.exec(text)?.[0]
+        stdout(`${text}\r\n${startMarker ? `${startMarker}\r\n` : ''}NAME?`)
       } else stdout(`${text}\r\n>>> `)
       return
     }

package/tests/test-firmware-install.mjs

@@ -4,7 +4,6 @@ import { test } from 'node:test'
 import assert from 'node:assert/strict'
 import { createDevice } from '../src/index.js'
 import { firmwareSha256 } from '../src/firmware_flash.js'
-import { parseCli, runCli } from '../src/cli.js'
 
 async function fixture() {
   const data = new Uint8Array(0x11000).fill(0xff), calls = []
@@ -108,19 +107,3 @@ test('installation with damaged readback does not reset or report success', asyn
   await assert.rejects(f.device.firmware.update(f.request), /verification failed/)
   assert.ok(!f.calls.includes('reset')); assert.equal(f.calls.at(-1), 'close')
 })
-
-test('CLI install uses ROM directly and passes mode through both check and update', async () => {
-  const f = await fixture(), checked = []
-  const options = parseCli(['firmware', 'update', '--mode', 'install', '--board', 'BOARD', '--port', '/dev/ttyACM0', '--version', 'new'])
-  const result = await runCli(options, {
-    transportFor: () => { throw new Error('No application transport should be acquired') },
-    async readFile() { throw new Error('No user catalog required') },
-    createDevice: () => ({ firmware: {
-      async check(request) { checked.push(request.mode); return { release: f.release } },
-      async update(request) { assert.equal(request.mode, 'install'); return { verified: true } },
-    }, async disconnect() {} }),
-  })
-  assert.equal(result.verified, true); assert.deepEqual(checked, ['install'])
-  assert.throws(() => parseCli(['firmware', 'update', '--mode', 'install', '--port', 'COM3', '--version', 'new']), /explicit --board/)
-  assert.throws(() => parseCli(['firmware', 'update', '--mode', 'install', '--tcp', 'host', '--board', 'BOARD', '--version', 'new']), /local --port/)
-})

package/tests/test-node-adapter-assets.mjs

@@ -0,0 +1,16 @@
+// SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+// SPDX-License-Identifier: Apache-2.0
+import assert from 'node:assert/strict'
+import { readFile } from 'node:fs/promises'
+import { test } from 'node:test'
+import { nodeAdapterAssets } from '../src/node.js'
+
+test('public Node asset URLs identify the exact passive SDK adapters', async () => {
+  const assets = nodeAdapterAssets()
+  assert.ok(Object.isFrozen(assets))
+  assert.deepEqual(Object.keys(assets).sort(), ['rom', 'serial'])
+  assert.match(await readFile(assets.serial, 'utf8'), /serial/)
+  assert.match(await readFile(assets.rom, 'utf8'), /esptool/)
+  assets.serial.pathname = '/changed-by-consumer'
+  assert.ok(nodeAdapterAssets().serial.pathname.endsWith('/node_serial.py'))
+})