@esp-vision/device-core 0.4.2 → 0.5.0

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'))
+})

package/tests/test-node-inventory.mjs

@@ -0,0 +1,136 @@
+// SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+// SPDX-License-Identifier: Apache-2.0
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import {
+  defaultPython, filterSerialPorts, inventory, listSerial, serialEntry, transportFor,
+} from '../src/node.js'
+
+test('the public Node entry point exposes passive inventory and serial adapters', () => {
+  assert.equal(typeof defaultPython, 'string')
+  assert.equal(typeof listSerial, 'function')
+  assert.equal(typeof filterSerialPorts, 'function')
+  assert.equal(typeof serialEntry, 'function')
+  assert.equal(typeof transportFor, 'function')
+  assert.equal(typeof inventory, 'function')
+})
+
+test('serial listing passes a bounded non-opening enumeration request to Python', async () => {
+  const controller = new AbortController()
+  let invocation
+  const ports = await listSerial({ python: 'python-test', signal: controller.signal, timeout: 2345 }, {
+    async execFile(command, args, options) {
+      invocation = { command, args, options }
+      return { stdout: '[{"path":"/dev/ttyACM0","vendorId":1234}]' }
+    },
+  })
+
+  assert.deepEqual(ports, [{ path: '/dev/ttyACM0', vendorId: 1234 }])
+  assert.equal(invocation.command, 'python-test')
+  assert.match(invocation.args[0], /node_serial\.py$/)
+  assert.deepEqual(invocation.args.slice(1), ['--list'])
+  assert.equal(invocation.options.signal, controller.signal)
+  assert.equal(invocation.options.timeout, 2345)
+  assert.equal(invocation.options.maxBuffer, 1024 * 1024)
+  assert.equal(invocation.options.windowsHide, true)
+})
+
+test('serial enumeration reports a bounded-process timeout and preserves cancellation', async () => {
+  const timedOut = Object.assign(new Error('private process details'), { code: 'ETIMEDOUT' })
+  await assert.rejects(
+    listSerial({ timeout: 250 }, { execFile: async () => { throw timedOut } }),
+    error => error.code === 'TIMEOUT' && error.cause === timedOut && !error.message.includes('private'),
+  )
+
+  const controller = new AbortController()
+  const reason = new Error('cancelled')
+  const pending = listSerial({ signal: controller.signal }, {
+    execFile: async (_command, _args, options) => new Promise((_resolve, reject) => {
+      options.signal.addEventListener('abort', () => reject(reason), { once: true })
+    }),
+  })
+  controller.abort(reason)
+  await assert.rejects(pending, error => error === reason)
+})
+
+test('serial candidate filtering stays platform-aware and classification is descriptor-only', () => {
+  const ports = [
+    { path: '/dev/ttyACM0', vendorId: 0x303a, productId: 0x1001, product: 'USB JTAG/serial' },
+    { path: '/dev/ttyUSB0' },
+    { path: '/dev/ttyS0' },
+  ]
+  assert.deepEqual(filterSerialPorts(ports, { platform: 'linux' }), ports.slice(0, 2))
+  assert.deepEqual(filterSerialPorts(ports, { platform: 'linux', allPorts: true }), ports)
+  const entry = serialEntry(ports[0])
+  assert.equal(entry.interface, 'usj')
+  assert.equal(entry.status, 'unprobed')
+  assert.equal(entry.identity, null)
+  const transport = transportFor(entry, { python: 'python-test' })
+  assert.equal(typeof transport.connect, 'function')
+})
+
+test('inventory forwards timeout and cancellation without probing by default', async () => {
+  const controller = new AbortController()
+  let serialRequest
+  let opened = 0
+  const result = await inventory({ interfaces: ['serial'], timeout: 750, signal: controller.signal }, {
+    platform: 'linux',
+    async listSerial(request) {
+      serialRequest = request
+      return [{ path: '/dev/ttyACM1', vendorId: 0x303a, productId: 0x1001 }]
+    },
+    createDevice() {
+      opened += 1
+      throw new Error('passive inventory opened a serial port')
+    },
+  })
+
+  assert.equal(serialRequest.timeout, 750)
+  assert.equal(serialRequest.signal, controller.signal)
+  assert.equal(opened, 0)
+  assert.equal(result.devices.length, 1)
+  assert.equal(result.devices[0].address, '/dev/ttyACM1')
+  assert.equal(result.devices[0].status, 'unprobed')
+  assert.equal(result.devices[0].identity, null)
+})
+
+test('explicit inventory probing acquires and reads metadata without interrupting the REPL', async () => {
+  const controller = new AbortController()
+  let connection, inspection, disconnected = false
+  const result = await inventory({
+    interfaces: ['serial'], probe: true, probeTimeout: 1250, signal: controller.signal,
+  }, {
+    platform: 'linux',
+    async listSerial() { return [{ path: '/dev/ttyUSB7', vendorId: 0x1234 }] },
+    transportFor(row) { return { address: row.address } },
+    createDevice() {
+      return {
+        async connect(options) {
+          connection = options
+          return { identity: { deviceId: 'e8f60ae75642', board: 'TEST' } }
+        },
+        async inspect(options) { inspection = options; return { runtime: { vmReady: false } } },
+        async disconnect() { disconnected = true },
+      }
+    },
+  })
+
+  assert.equal(connection.role, 'unknown')
+  assert.equal(connection.timeout, 1250)
+  assert.equal(connection.signal, controller.signal)
+  assert.equal(connection.probeRepl, false)
+  assert.equal(inspection.signal, controller.signal)
+  assert.equal(disconnected, true)
+  assert.equal(result.devices[0].status, 'identified')
+  assert.deepEqual(result.devices[0].inspection, { runtime: { vmReady: false } })
+})
+
+test('inventory propagates an aborted serial enumeration', async () => {
+  const reason = new Error('cancelled')
+  await assert.rejects(
+    inventory({ interfaces: ['serial'], signal: AbortSignal.abort(reason) }, {
+      async listSerial({ signal }) { throw signal.reason },
+    }),
+    error => error === reason,
+  )
+})

package/tests/test-node-serial.mjs

@@ -0,0 +1,104 @@
+// SPDX-License-Identifier: Apache-2.0
+import assert from 'node:assert/strict'
+import { spawnSync } from 'node:child_process'
+import { mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises'
+import { delimiter, dirname, join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { test } from 'node:test'
+import { createDevice } from '../src/device.js'
+import { serialTransport } from '../src/node_transport.js'
+
+const coreRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..')
+const adapter = join(coreRoot, 'src/node_serial.py')
+const tempBase = resolve(process.env.ESP_VISION_NPM_TEMP_DIR ?? process.env.TMPDIR ?? join(coreRoot, '.cache/node-serial'))
+const python = [process.env.PYTHON, 'python3', 'python'].filter(Boolean).find(candidate => {
+  const result = spawnSync(candidate, ['-c', 'pass'], { encoding: 'utf8', windowsHide: true })
+  return result.status === 0
+})
+
+async function createSerialFixture() {
+  await mkdir(tempBase, { recursive: true })
+  const root = await mkdtemp(join(tempBase, 'serial-lock-'))
+  const moduleDir = join(root, 'python')
+  await mkdir(moduleDir, { recursive: true })
+  const stateFile = join(root, 'open-state.json')
+  const serialModule = `
+import json
+
+class SerialException(Exception):
+    pass
+
+class Serial:
+    def __init__(self, *args, **kwargs):
+        self.rts = None
+        self.dtr = None
+        self.port = None
+        self.exclusive = None
+
+    def open(self):
+        with open(${JSON.stringify(stateFile)}, 'w', encoding='utf-8') as stream:
+            json.dump({'port': self.port, 'rts': self.rts, 'dtr': self.dtr, 'exclusive': self.exclusive}, stream)
+        raise SerialException('Could not exclusively lock port /dev/fixture: [Errno 11] Resource temporarily unavailable')
+
+    def close(self):
+        pass
+`
+  await writeFile(join(moduleDir, 'serial.py'), serialModule)
+  return { root, moduleDir, stateFile }
+}
+
+function fixturePythonEnv(moduleDir) {
+  return {
+    ...process.env,
+    PYTHONPATH: [moduleDir, process.env.PYTHONPATH].filter(Boolean).join(delimiter),
+  }
+}
+
+test('POSIX serial open requests an exclusive lock and exposes SERIAL_BUSY', {
+  skip: !python || process.platform === 'win32',
+}, async (t) => {
+  const fixture = await createSerialFixture()
+  t.after(() => rm(fixture.root, { recursive: true, force: true }))
+  const previousPythonPath = process.env.PYTHONPATH
+  process.env.PYTHONPATH = [fixture.moduleDir, previousPythonPath].filter(Boolean).join(delimiter)
+  t.after(() => {
+    if (previousPythonPath === undefined) delete process.env.PYTHONPATH
+    else process.env.PYTHONPATH = previousPythonPath
+  })
+
+  const direct = spawnSync(python, ['-u', adapter, '/dev/fixture'], {
+    env: fixturePythonEnv(fixture.moduleDir),
+    encoding: 'utf8',
+    windowsHide: true,
+  })
+  assert.equal(direct.status, 2, direct.stderr || direct.error?.message || 'Python adapter fixture did not fail as expected')
+  assert.equal(direct.stderr.trim(), 'SERIAL_BUSY')
+  const opened = JSON.parse(await readFile(fixture.stateFile, 'utf8'))
+  assert.deepEqual(opened, { port: '/dev/fixture', rts: false, dtr: true, exclusive: true })
+  await rm(fixture.stateFile)
+
+  const device = createDevice({ transport: serialTransport({ python, serial: '/dev/fixture' }) })
+  t.after(() => device.disconnect())
+  await assert.rejects(device.connect({ timeout: 5000 }), { code: 'SERIAL_BUSY' })
+  assert.deepEqual(JSON.parse(await readFile(fixture.stateFile, 'utf8')), opened)
+})
+
+test('non-POSIX serial backends do not receive the unsupported exclusive option', {
+  skip: !python,
+}, async () => {
+  const source = [
+    'import importlib.util, sys, types',
+    'sys.modules["serial"] = types.SimpleNamespace()',
+    'spec = importlib.util.spec_from_file_location("node_serial", sys.argv[1])',
+    'module = importlib.util.module_from_spec(spec)',
+    'spec.loader.exec_module(module)',
+    'port = types.SimpleNamespace()',
+    'module._configure_serial_exclusive(port, "nt")',
+    'assert not hasattr(port, "exclusive")',
+  ].join('\n')
+  const result = spawnSync(python, ['-c', source, adapter], {
+    encoding: 'utf8',
+    windowsHide: true,
+  })
+  assert.equal(result.status, 0, result.stderr || result.error?.message || 'Python fixture failed')
+})