oep-client-python 0.0.20__tar.gz → 0.0.22__tar.gz

{oep_client_python-0.0.20 → oep_client_python-0.0.22}/CHANGELOG.md

@@ -2,6 +2,36 @@
 
 ## Unreleased
 
+## 0.0.22
+- (EN) Breaking: the wire follows oep-spec's zero-base rewrite of 2026-10-01 (docs/v1-zero-base-proposal.ja.md §3 / §7; registry synced). Every answer that ended in data or a list now carries its length and may be followed by TLVs: read answers `start flags len data [TLV]` (console, fixture UART; capture `len` u32), gpio read `n n×level`, dmi `done status nvals values`, arm-adi transfer `done status ack nvals values`, run `status stopped dpc elapsed_us nvals values` (stopped 2 = the hart could not be halted: `RunResult.not_halted`), data frames `position len data [TLV]`, events `kind fixed-part [TLV]`. TLVs have a long form (`tag 0xFF len(u16) value` for 255 bytes and more; `message.tlv` / `split_tlvs`, the long form with a short value is `message.BadTlv`). confirm answers the probe's `boot_id`; subscribe's `max_delay_ms` is u32; `rejected unsupported` is always `tag [TLV]` (0x00 = a fixed-part value: `Unsupported.tag` None, `.tlvs`).
+- (JA) 破壊的変更: wire を oep-spec の 2026-10-01 のゼロベース見直し（docs/v1-zero-base-proposal.ja.md §3 / §7。registry を写し直した）に揃えた。データや並びで終わっていた応答はすべて長さを持ち、後ろに TLV を置ける: read の応答 `start flags len data [TLV]`（console、fixture UART。capture の `len` は u32）、gpio read `n n×level`、dmi `done status nvals values`、arm-adi transfer `done status ack nvals values`、run `status stopped dpc elapsed_us nvals values`（stopped 2 = hart を止められなかった: `RunResult.not_halted`）、データフレーム `position len data [TLV]`、出来事 `kind 固定部 [TLV]`。TLV に長い形（255 byte 以上は `tag 0xFF len(u16) value`。`message.tlv` / `split_tlvs`、短い値の長い形は `message.BadTlv`）。confirm は probe の `boot_id` を返す。subscribe の `max_delay_ms` は u32。`rejected unsupported` は常に `tag [TLV]`（0x00 = 固定部の値: `Unsupported.tag` は None、`.tlvs`）。
+- (EN) Breaking: after the lease lapsed, the same session id's next request is `rejected expired` (0x0E): `host.Expired(Rejected)` with `.lease_ms`, never re-opened silently; `open()` then answers `Opened.resumed == 2` (`.swept`) and `Host.epoch` moves (as it does on `no_session` - what an id forced out by another meets after `locked`). `Wire.connections()` and `Console.streams()` page through `first` / `more`. Subscriptions survive a same-id open while the lock is held; a subscribe to an fn that emits nothing is unsupported, an unsubscribe of nothing is ok.
+- (JA) 破壊的変更: lease が切れた後の同じ session_id の要求は `rejected expired`（0x0E）: `host.Expired(Rejected)`（`.lease_ms` つき）。黙って open し直さない。その後の `open()` は `Opened.resumed == 2`（`.swept`）を返し、`Host.epoch` が進む（`no_session` でも進む。force で奪われた側は locked のあと no_session）。`Wire.connections()` と `Console.streams()` は `first` / `more` でページを辿る。保持中の同じ ID の open で購読は残る。送り出さない fn の subscribe は unsupported、購読の無い unsubscribe は ok。
+- (EN) Breaking: `oep.probe.config` - describe is declarations only (`ProbeConfig.describe()` -> `Declared`: storage `max_bytes` u32, items, slots_max, bind_modes u32); the live storage / slot / bind state is the lock-free `state` op (0x06, paged; `ProbeConfig.state()` -> `State`, `SlotState.last_try_at_ns`); `unset` (0x05) removes items by key (`ProbeConfig.unset`, `config.remove()` in a `set` list goes as an unset - a key alone no longer removes); the new `uart` item (`config.Uart(fn, baud, format)`) is applied whenever that UART's plan has RX or TX (a session's configure wins until the plan goes); slot fields are `retry_ms` (u32; the Python `Slot.retry_s` stays, seconds) and `max_speed_hz` (u32; `Slot.max_speed` stays, Hz); mechanism `none` (0xFF) = a slot without a console; the hash is the CRC-32 of the canonical form (`config.canonical` / `hash_of`). CLI: `oep config state`, `oep config uart`, `remove` for every item kind.
+- (JA) 破壊的変更: `oep.probe.config` - describe は宣言だけ（`ProbeConfig.describe()` -> `Declared`: storage は `max_bytes` u32、items、slots_max、bind_modes u32）。保存・スロット・bind の今の状態はロック不要の `state` op（0x06、ページング。`ProbeConfig.state()` -> `State`、`SlotState.last_try_at_ns`）。`unset`（0x05）はキーで項目を消す（`ProbeConfig.unset`。`set` の並びの `config.remove()` は unset として送る。キーだけの項目で消す規則は廃止）。新しい `uart` 項目（`config.Uart(fn, baud, format)`）は、その UART の plan に RX / TX が付くたびに掛かる（セッションの configure は plan を解くまで勝つ）。スロットのフィールドは `retry_ms`（u32。Python の `Slot.retry_s` は秒のまま）と `max_speed_hz`（u32。`Slot.max_speed` は Hz のまま）。mechanism `none`（0xFF）= コンソール無しのスロット。hash は正規形の CRC-32（`config.canonical` / `hash_of`）。CLI: `oep config state`、`oep config uart`、`remove` はすべての項目。
+- (EN) Breaking: wires - `attach_under_reset` (op 0x04) is gone: `Wire.attach(reset=(channel, hold_ms))` sends the attach's critical TLV 0x05 (the `attach_under_reset()` method stays as a wrapper and returns the dpc from the answer's TLV 0x11); `max_speed` is required by the probe, so `attach()` always sends one (None: the wire's declared `max_clock_hz`, else 1 MHz); the answer's flags are the common `attach_flags` (`Wire.halted` / `.dpc`; swd's dormant bit moved to bit2); scan takes `max_speed` / `idle_clock` TLVs and its skip is TLV 0x02; `WireBase.connections()` and `detach(force=)`. `RiscvDm.run(timeout_ms=None)` is the probe's `max_op_ms` (`core.max_op_ms`), no longer 0xFFFFFFFF.
+- (JA) 破壊的変更: 線 - `attach_under_reset`（op 0x04）は無くなり、`Wire.attach(reset=(channel, hold_ms))` が attach の critical TLV 0x05 を送る（`attach_under_reset()` メソッドは包みとして残り、応答の TLV 0x11 の dpc を返す）。probe は `max_speed` を必須にしたので `attach()` は常に送る（None: その線の宣言の `max_clock_hz`、無ければ 1 MHz）。応答の flags は共通の `attach_flags`（`Wire.halted` / `.dpc`。swd の dormant は bit2 に移った）。scan は `max_speed` / `idle_clock` の TLV を取り、skip は TLV 0x02。`WireBase.connections()` と `detach(force=)`。`RiscvDm.run(timeout_ms=None)` は probe の `max_op_ms`（`core.max_op_ms`）で、0xFFFFFFFF ではなくなった。
+- (EN) Breaking: console - marks carry `time_ns` (u64, the probe's one clock; `Mark.time_ns`, 22 bytes), a stream lives while anything uses it (the sessions that opened it, a bound slot; `close` takes one share; a lapse takes the session's), one live stream per connection (another mechanism: unavailable cause 6), a closed stream of the same place and mechanism comes back under its old number, mark `closed` (0x09) with why, the lock-free `streams` op (`Console.streams()` -> `StreamInfo`), a write that fits nothing is completed failed. Connections and streams share one u16 number space (wrapping); a number of the other kind is unavailable cause 6. `registry.COMMON.enum` holds `read_from`, `read_flags`, `mark_kind` and the mark details (they left the console's enum).
+- (JA) 破壊的変更: console - マークは `time_ns`（u64、probe の 1 本の時計。`Mark.time_ns`、22 byte）。ストリームは使っているもの（open したセッション、bind されたスロット）がある間生きる（`close` は自分の分、lease 切れはセッションの分を外す）。1 つの connection に生きているストリームは 1 つ（別の mechanism は unavailable cause 6）。閉じたストリームは同じ場所・同じ mechanism の open で同じ番号で戻る。マーク `closed`（0x09）に理由。ロック不要の `streams` op（`Console.streams()` -> `StreamInfo`）。何も入らなかった write は completed failed。connection とストリームは 1 つの u16 の番号空間（一周する）で、別の種類の番号は unavailable cause 6。`registry.COMMON.enum` に `read_from`、`read_flags`、`mark_kind` とマークの detail（console の enum から移った）。
+- (EN) Breaking: capture - every start is a generation (u32): start answers `blocking_ms generation`, status `state serial_done write_pos flags generation [TLV error]` (`LogicCapture.status()` -> `Status`, still iterable as the old 4-tuple), segment records are 37 bytes (`Segment.generation`), read is `generation position max`, release `generation serial` (another generation: unavailable cause 6), streaming data frames carry TLV generation (`stream()` drops another generation's, `Received.stale`); `LogicCapture.generation` / `read(..., generation=)`; `read_segment(segment)` passes the segment's own. Trigger values are u32; segments answers have `more`; state 5 goes on by itself after release (no stopped 2 event); describe `channels` layouts / `trigger` types are u32, `rate_list` / group `tracks` / `budget` carry `n`; `Calibration.vrefint_nominal_mv`, factory data has `raw_len`; the group's start answers each track's generation (`CaptureGroup.generations`), its events are triggered 0x03 / stopped 0x02.
+- (JA) 破壊的変更: capture - start ごとに世代（u32）: start の応答 `blocking_ms generation`、status `state serial_done write_pos flags generation [TLV error]`（`LogicCapture.status()` -> `Status`。前の 4 つ組としても展開できる）、区画の情報は 37 byte（`Segment.generation`）、read は `generation position max`、release は `generation serial`（違う世代は unavailable cause 6）、ストリーミングのデータフレームは TLV generation を持つ（`stream()` は別の世代を捨てる。`Received.stale`）。`LogicCapture.generation` / `read(..., generation=)`。`read_segment(segment)` は区画の世代を付ける。trigger の value は u32。segments の応答に `more`。state 5 は release で自動で再開（stopped 2 の出来事は無い）。describe の `channels` の layout / `trigger` の types は u32、`rate_list` / 組の `tracks` / `budget` は `n` を持つ。`Calibration.vrefint_nominal_mv`。factory に `raw_len`。組の start は各トラックの世代を返す（`CaptureGroup.generations`）、組の出来事は triggered 0x03 / stopped 0x02。
+- (EN) Breaking: fixture - gpio read answers `n n×level`, its describe `modes` is u32 (a mode the probe lacks is unsupported with channel / index TLVs; mode 8+ malformed); the UART's stream is made by the plan (RX or TX) and goes with it, its position never going back within a boot; `FixtureUart.status()` (op 0x07) -> `UartStatus` (`configured` is a name: default / session / item / item_fallback, registry `uart_configured`); an undefined format bit is malformed, an undeclared format unsupported, a baud more than 5 % off unsupported; i2c / spi `errors` are u32, `read_rx` reads its TLV tail (`last_ns`), describe `queue_depth`.
+- (JA) 破壊的変更: fixture - gpio read の応答は `n n×level`、describe の `modes` は u32（持たない mode は channel / index の TLV つきの unsupported。mode 8 以上は malformed）。UART のストリームは plan（RX か TX）が作り、plan と一緒に消える。位置は起動の中で戻らない。`FixtureUart.status()`（op 0x07）-> `UartStatus`（`configured` は名前: default / session / item / item_fallback、registry の `uart_configured`）。format の未定義のビットは malformed、宣言に無い format は unsupported、±5% を超える baud は unsupported。i2c / spi の `errors` は u32、`read_rx` は TLV の後ろを読む（`last_ns`）、describe に `queue_depth`。
+- (EN) The fake probe follows all of it (the working spec): `boot_id` in confirm, `expired` and `resumed` 2, one resource number space, the heartbeat `boot_id uptime_ns`, the plan's `plan_roles` limit and reason table, attach's reset TLV / required max_speed / scan TLVs, dmi / run answers with nvals (run's `FakeTarget.unstoppable` for stopped 2), the console's stream lifetime and `streams`, gpio modes, the UART's plan-made stream / `status` / formats, probe.config's `state` / `unset` / `uart` item / canonical hash, capture generations and the group's generations TLV. Its describes declare `max_op_ms` 10000, `plan_roles`, `discoverable` (was `oep_pid`), gpio `modes`, UART `formats`. USB: the vendor interface is told by class 0xFF, subclass 0x4F, protocol 0x45 and a probe by its iProduct `OEP` alone (`registry.USB`).
+- (JA) fake の probe もすべてに追随した（動く spec）: confirm の `boot_id`、`expired` と `resumed` 2、資源番号の 1 つの空間、ハートビート `boot_id uptime_ns`、plan の `plan_roles` の上限と断り方の表、attach の reset TLV / 必須の max_speed / scan の TLV、nvals を持つ dmi / run の応答（stopped 2 は `FakeTarget.unstoppable`）、console のストリームの寿命と `streams`、gpio の modes、UART の plan が作るストリーム / `status` / formats、probe.config の `state` / `unset` / `uart` 項目 / 正規形の hash、capture の世代と組の世代の TLV。describe は `max_op_ms` 10000、`plan_roles`、`discoverable`（`oep_pid` から改名）、gpio の `modes`、UART の `formats` を宣言する。USB: vendor の interface は class 0xFF・subclass 0x4F・protocol 0x45 で、probe は iProduct `OEP` だけで見分ける（`registry.USB`）。
+
+## 0.0.21
+- (EN) Breaking: a bind's streams carry a length each (oep-spec probe.config §1.2, freeze decision 1, missed until now): `n × (len, kind, id)`, len 3 today; the fake skips a longer one's tail and refuses one under 3 as malformed.
+- (JA) 破壊的変更: bind のストリームの並びの各要素の前に長さを置く（oep-spec probe.config §1.2。凍結の決定 1 で漏れていた）: `n × (len、kind、id)`、今の len は 3。fake は長い要素の後ろを飛ばし、3 未満は malformed で断る。
+- (EN) `usb:X` is always a unit id, whatever its length (a 4-character unit id was read as a VID); a VID comes with its PID, `usb:VID:PID[:SERIAL]`.
+- (JA) `usb:X` は長さによらず unit id として読む（4 文字の unit id を VID と読んでいた）。VID は PID と一緒に `usb:VID:PID[:SERIAL]` で書く。
+- (EN) Breaking: the CLI's `name#k` is the list's instance, from 0 (oep-spec core §7.2's `name#instance`; `#0` may be left out). It was the k-th from 1.
+- (JA) 破壊的変更: CLI の `name#k` は list の instance（0 から）にした（oep-spec core §7.2 の `name#instance`、`#0` は省ける）。1 から数えた k 番目だった。
+- (EN) The fake probes number each interface's instance from 0 per name (core §7.2), as the probe firmware now does; they had arbitrary numbers.
+- (JA) fake の probe はインターフェースの instance を名前ごとに 0 から振る（core §7.2）。probe の firmware も同じにした。これまでは適当な番号だった。
+- (EN) README: `registry.INTERFACES[name]` is the public way to reach an interface's numbers by name.
+- (JA) README: 名前からインターフェースの番号を引く公開の入口は `registry.INTERFACES[name]` と書いた。
+
 ## 0.0.20
 - (EN) A console write's chunk fits the probe's frame: frame - 12 - the stream's prefix (the console's stream u16; none on a fixture UART). It was frame - 13 for both, one byte over on a console with 64-byte frames. Found porting it to oep-client-js.
 - (JA) console の書き込みの 1 回の大きさが probe のフレームに収まるようにした: frame − 12 − stream の前置き（console は stream の u16、fixture UART は無し）。両方とも frame − 13 だったので、64 byte のフレームの console で 1 byte はみ出していた。oep-client-js に移すときに見つかった。

{oep_client_python-0.0.20 → oep_client_python-0.0.22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: oep-client-python
-Version: 0.0.20
+Version: 0.0.22
 Summary: Open Embedded Probe (OEP) v1 host: serial / USB / TCP transports, the session rules, the standard interfaces, and a fake probe
 Project-URL: Homepage, https://github.com/Open-Embedded-Probe/oep-client-python
 Project-URL: Repository, https://github.com/Open-Embedded-Probe/oep-client-python
@@ -55,16 +55,16 @@ oep-client-python X.Y.Z (until the v1 freeze every release may break the wire; t
 
 | Module | Contents |
 |---|---|
-| `host` | requests and results, the session id and the lock, `call()` (raises unless it worked), pipelining, the errors (`OepError` / `Rejected` / `Failed`) |
+| `host` | requests and results, the session id and the lock, `call()` (raises unless it worked), pipelining, the errors (`OepError` / `Rejected` / `Failed`; `Expired` when the lease lapsed - the session is never re-opened behind the caller's back, `Host.epoch` moves) |
 | `link` | transports: serial ports (always COBS + CRC as `0x00 <COBS> 0x00`, bytes outside frames skipped as noise, opened exclusively), USB vendor bulk / HID and TCP (length frames, the §5.1 resync); matching by corr and resending; `open_host(target)` |
-| `core` | interfaces by name (cached), confirm, the probe's describe (labels, the transport list), taking the lock (`take`), the pin plan, the `Interface` base |
-| `riscv` | `oep.wire.rvswd` / `oep.wire.swio`, `oep.target.riscv-dm`, finding the reset line, attach through GPIO |
-| `console` | `oep.target.console` (position streams) and `ConsoleIO`, read as bytes |
-| `fixture` | `oep.fixture.gpio` / `uart` / `i2c-target` / `spi-target` (revision 1) |
-| `config` | `oep.probe.config` (slots, binds, plan / label / idle items, get / set / save / erase, the live slot and bind state) |
-| `capture` | `oep.fixture.logic` (revision 1, oep-spec oep-if-capture). Every segment read goes to the `Host.on_capture` callbacks as a `CaptureRecord` (the hook for run recorders; no wireskein dependency) |
+| `core` | interfaces by name (cached), confirm (with the probe's `boot_id`), the probe's describe (declarations only, cached per boot: labels, the transport list, `max_op_ms`), taking the lock (`take`), the pin plan, the `Interface` base |
+| `riscv` | `oep.wire.rvswd` / `oep.wire.swio` (scan, attach - `max_speed` always sent, `reset=(channel, hold_ms)` for an attach under reset -, detach, connections), `oep.target.riscv-dm` (answers count their values; `RunResult.not_halted`), finding the reset line, attach through GPIO |
+| `console` | `oep.target.console` (position streams: read answers carry their length, marks are `time_ns`, the lock-free `streams()` list) and `ConsoleIO`, read as bytes |
+| `fixture` | `oep.fixture.gpio` / `uart` (its stream is the plan's; `status()`) / `i2c-target` / `spi-target` (revision 1) |
+| `config` | `oep.probe.config` (slots, binds, plan / label / idle / uart items, get / set / unset / save / erase; `describe()` = the declarations, `state()` = the live storage / slot / bind state; `hash_of(items)` = the probe's hash) |
+| `capture` | `oep.fixture.logic` / `analog` / `capture-group` (revision 1, oep-spec oep-if-capture). Every start is a generation (`LogicCapture.generation`) that read and release name - `read_segment(segment)` does it by itself; `status()` returns a `Status`. Every segment read goes to the `Host.on_capture` callbacks as a `CaptureRecord` (the hook for run recorders; no wireskein dependency) |
 | `decode` | decoding capture channels (I2C) |
-| `registry` | generated from oep-spec's number table (never edited; copied again from oep-spec) |
+| `registry` | generated from oep-spec's number table (never edited; copied again from oep-spec). The public way to reach an interface by name is `registry.INTERFACES[name]` (`.revision`, `.op`, `.tlv`, `.enum`, e.g. `INTERFACES["oep.fixture.uart"].enum["role"]`); the module-level names (`FIXTURE_UART`, ...) are the same objects |
 | `arm` | `oep.wire.swd`, `oep.target.arm-adi`, MEM-AP, halting and calling functions on a Cortex-M |
 | `ch32_flash` | writing a CH32 (a RAM loader, page by page) |
 | `rp2350` | flash and reboot through the RP2350 boot ROM |
@@ -95,10 +95,12 @@ hst.end()
 
 ```sh
 oep dump --port <probe>                      # what the probe offers (--fake p4-x035: no hardware)
-oep config show <probe>                      # the settings and the live slot / bind state
+oep config show <probe>                      # the settings, the declarations and the live state
+oep config state <probe>                     # the live slot / bind / storage state alone (lock-free, for polling)
 oep config slot <probe> --name x035 --wire rvswd --pins 2,54 --attach at-boot --retry 1 --mechanism dmseq
 oep config bind <probe> --port 1 --mode last-reset --stream slot:x035
-oep config save <probe>                      # kept over a restart (also: remove, erase)
+oep config uart <probe> oep.fixture.uart 115200 --format 8N1   # applied whenever that UART's plan has RX or TX
+oep config save <probe>                      # kept over a restart (also: remove = unset, erase)
 ```
 
 `<probe>` is a serial port, `tcp://HOST:PORT` or `usb[:VID:PID[:SERIAL]]`. A change takes the lock (owner "oep config") and
@@ -108,8 +110,10 @@ A run on hardware: ArduinoCore-CH32's `tests/manual/oep_smoke/` (`oep_smoke.py`,
 
 ## The fake probe (a working spec)
 
-`endpoint.Endpoint` is a fake probe that answers as oep-spec says; ch32rv, this client and the probe firmware are checked
-against it (when the spec changes, this is brought in line before the firmware). `fake` holds example declarations (profiles
+`endpoint.Endpoint` is a fake probe that answers as oep-spec says (2026-10-01: every answer carries the length of its
+data or list, TLVs may follow anything, rejected `expired` after a lapse, one resource number space, describe = declarations
+and `state` for the rest, capture generations); ch32rv, this client and the probe firmware are checked against it (when the
+spec changes, this is brought in line before the firmware). `fake` holds example declarations (profiles
 `p4-x035`, `esp32-v003`, `p4-bench` = a made-up jig with three slots and two seats, `rp2350-pins` = a wire whose pins the host
 chooses), `fake_serial` the byte side of a serial port (COBS candidates, raw bytes and binds, held during a session and
 resumed after it).

{oep_client_python-0.0.20 → oep_client_python-0.0.22}/README.ja.md

@@ -29,16 +29,16 @@ X.Y.Z（v1 の凍結までは、どのリリースも wire を壊しうるので
 
 | モジュール | 中身 |
 |---|---|
-| `host` | 要求と結果、session_id とロック、`call()`（失敗なら例外）、pipeline、エラーの階層（`OepError` / `Rejected` / `Failed`） |
+| `host` | 要求と結果、session_id とロック、`call()`（失敗なら例外）、pipeline、エラーの階層（`OepError` / `Rejected` / `Failed`。lease 切れなら `Expired`。黙って open し直さず、`Host.epoch` が進む） |
 | `link` | transport: シリアルの口（常に COBS + CRC、`0x00 <COBS> 0x00`、フレームの外は雑音として捨てる、排他で開く）、USB vendor bulk / HID と TCP（長さつきフレーム、§5.1 の立て直し）、corr による照合と送り直し、`open_host(target)` |
-| `core` | インターフェースを名前で探す（キャッシュつき）、confirm、probe の describe（ラベル、transport の一覧）、ロックの取り方（`take`）、ピンの割り当て（plan）、`Interface` の土台 |
-| `riscv` | `oep.wire.rvswd` / `oep.wire.swio`、`oep.target.riscv-dm`、リセット線の探索、GPIO 経由の attach |
-| `console` | `oep.target.console`（位置つきのストリーム）と、バイト列として読む `ConsoleIO` |
-| `fixture` | `oep.fixture.gpio` / `uart` / `i2c-target` / `spi-target`（revision 1） |
-| `config` | `oep.probe.config`（スロット、bind、plan / label / idle の項目、get / set / save / erase、スロットと bind の今の状態） |
-| `capture` | `oep.fixture.logic`（revision 1、oep-spec の oep-if-capture）。読んだ区画は `Host.on_capture` の callback に `CaptureRecord` で渡る（記録の受け口。wireskein には依存しない） |
+| `core` | インターフェースを名前で探す（キャッシュつき）、confirm（probe の `boot_id` つき）、probe の describe（宣言だけ。起動の間 cache: ラベル、transport の一覧、`max_op_ms`）、ロックの取り方（`take`）、ピンの割り当て（plan）、`Interface` の土台 |
+| `riscv` | `oep.wire.rvswd` / `oep.wire.swio`（scan、attach: `max_speed` は常に送る、`reset=(channel, hold_ms)` でリセットをかけながら attach、detach、connections）、`oep.target.riscv-dm`（応答は値の数を持つ。`RunResult.not_halted`）、リセット線の探索、GPIO 経由の attach |
+| `console` | `oep.target.console`（位置つきのストリーム: read の応答は長さを持ち、マークは `time_ns`、ロック不要の `streams()`）と、バイト列として読む `ConsoleIO` |
+| `fixture` | `oep.fixture.gpio` / `uart`（ストリームは plan が作る。`status()`）/ `i2c-target` / `spi-target`（revision 1） |
+| `config` | `oep.probe.config`（スロット、bind、plan / label / idle / uart の項目、get / set / unset / save / erase。`describe()` = 宣言、`state()` = 保存・スロット・bind の今の状態、`hash_of(items)` = probe と同じ hash） |
+| `capture` | `oep.fixture.logic` / `analog` / `capture-group`（revision 1、oep-spec の oep-if-capture）。start ごとに世代（`LogicCapture.generation`）が進み、read と release はそれを付ける（`read_segment(segment)` は自分で付ける）。`status()` は `Status` を返す。読んだ区画は `Host.on_capture` の callback に `CaptureRecord` で渡る（記録の受け口。wireskein には依存しない） |
 | `decode` | キャプチャのチャネルの復号（I2C） |
-| `registry` | oep-spec の番号の表から生成したモジュール（編集しない。oep-spec から写し直す） |
+| `registry` | oep-spec の番号の表から生成したモジュール（編集しない。oep-spec から写し直す）。名前からインターフェースの番号を引く公開の入口は `registry.INTERFACES[name]`（`.revision`、`.op`、`.tlv`、`.enum`。例 `INTERFACES["oep.fixture.uart"].enum["role"]`）。`FIXTURE_UART` などのモジュールの名前は同じもの |
 | `arm` | `oep.wire.swd`、`oep.target.arm-adi`、MEM-AP、Cortex-M の停止と関数呼び出し |
 | `ch32_flash` | CH32 の書き込み（RAM ローダー、ページ単位の書き直し） |
 | `rp2350` | RP2350 の boot ROM 経由の flash と reboot |
@@ -69,10 +69,12 @@ hst.end()
 
 ```sh
 oep dump --port <probe>                      # 能力の一覧（--fake p4-x035 でハードウェアなし）
-oep config show <probe>                      # 設定とスロット / bind の今の状態
+oep config show <probe>                      # 設定、宣言、今の状態
+oep config state <probe>                     # スロット / bind / 保存の今の状態だけ（ロック不要。監視用）
 oep config slot <probe> --name x035 --wire rvswd --pins 2,54 --attach at-boot --retry 1 --mechanism dmseq
 oep config bind <probe> --port 1 --mode last-reset --stream slot:x035
-oep config save <probe>                      # 再起動の後も残す（remove / erase もある）
+oep config uart <probe> oep.fixture.uart 115200 --format 8N1   # その UART の plan に RX / TX が付くたびに掛かる
+oep config save <probe>                      # 再起動の後も残す（remove = unset、erase もある）
 ```
 
 `<probe>` はシリアルの口、`tcp://HOST:PORT`、`usb[:VID:PID[:SERIAL]]`。変更はロックを取り（owner "oep config"）、終わったら
@@ -81,8 +83,9 @@ oep config save <probe>                      # 再起動の後も残す（remove
 
 ## 偽の probe（動く spec）
 
-`endpoint.Endpoint` は oep-spec の規範どおりに答える偽の probe で、ch32rv・この client・probe の firmware を突き合わせる
-「動く spec」として使う（spec が変わったら、probe の firmware より先にここを合わせる）。`fake` は宣言の例（profile:
+`endpoint.Endpoint` は oep-spec の規範どおりに答える偽の probe で（2026-10-01: 応答のデータと並びは長さを持ち、どの応答にも TLV が
+続けられる、期限切れ後の rejected `expired`、資源番号は 1 つの空間、describe は宣言だけで状態は `state`、キャプチャの世代）、
+ch32rv・この client・probe の firmware を突き合わせる「動く spec」として使う（spec が変わったら、probe の firmware より先にここを合わせる）。`fake` は宣言の例（profile:
 `p4-x035`、`esp32-v003`、`p4-bench` = スロット 3 か所と席 2 つの架空の治具、`rp2350-pins` = host がピンを選ぶ wire）、`fake_serial` は
 シリアルの口のバイトの側（COBS の候補、生のバイトと bind、セッション中の停止と再開）。
 

{oep_client_python-0.0.20 → oep_client_python-0.0.22}/README.md

@@ -33,16 +33,16 @@ oep-client-python X.Y.Z (until the v1 freeze every release may break the wire; t
 
 | Module | Contents |
 |---|---|
-| `host` | requests and results, the session id and the lock, `call()` (raises unless it worked), pipelining, the errors (`OepError` / `Rejected` / `Failed`) |
+| `host` | requests and results, the session id and the lock, `call()` (raises unless it worked), pipelining, the errors (`OepError` / `Rejected` / `Failed`; `Expired` when the lease lapsed - the session is never re-opened behind the caller's back, `Host.epoch` moves) |
 | `link` | transports: serial ports (always COBS + CRC as `0x00 <COBS> 0x00`, bytes outside frames skipped as noise, opened exclusively), USB vendor bulk / HID and TCP (length frames, the §5.1 resync); matching by corr and resending; `open_host(target)` |
-| `core` | interfaces by name (cached), confirm, the probe's describe (labels, the transport list), taking the lock (`take`), the pin plan, the `Interface` base |
-| `riscv` | `oep.wire.rvswd` / `oep.wire.swio`, `oep.target.riscv-dm`, finding the reset line, attach through GPIO |
-| `console` | `oep.target.console` (position streams) and `ConsoleIO`, read as bytes |
-| `fixture` | `oep.fixture.gpio` / `uart` / `i2c-target` / `spi-target` (revision 1) |
-| `config` | `oep.probe.config` (slots, binds, plan / label / idle items, get / set / save / erase, the live slot and bind state) |
-| `capture` | `oep.fixture.logic` (revision 1, oep-spec oep-if-capture). Every segment read goes to the `Host.on_capture` callbacks as a `CaptureRecord` (the hook for run recorders; no wireskein dependency) |
+| `core` | interfaces by name (cached), confirm (with the probe's `boot_id`), the probe's describe (declarations only, cached per boot: labels, the transport list, `max_op_ms`), taking the lock (`take`), the pin plan, the `Interface` base |
+| `riscv` | `oep.wire.rvswd` / `oep.wire.swio` (scan, attach - `max_speed` always sent, `reset=(channel, hold_ms)` for an attach under reset -, detach, connections), `oep.target.riscv-dm` (answers count their values; `RunResult.not_halted`), finding the reset line, attach through GPIO |
+| `console` | `oep.target.console` (position streams: read answers carry their length, marks are `time_ns`, the lock-free `streams()` list) and `ConsoleIO`, read as bytes |
+| `fixture` | `oep.fixture.gpio` / `uart` (its stream is the plan's; `status()`) / `i2c-target` / `spi-target` (revision 1) |
+| `config` | `oep.probe.config` (slots, binds, plan / label / idle / uart items, get / set / unset / save / erase; `describe()` = the declarations, `state()` = the live storage / slot / bind state; `hash_of(items)` = the probe's hash) |
+| `capture` | `oep.fixture.logic` / `analog` / `capture-group` (revision 1, oep-spec oep-if-capture). Every start is a generation (`LogicCapture.generation`) that read and release name - `read_segment(segment)` does it by itself; `status()` returns a `Status`. Every segment read goes to the `Host.on_capture` callbacks as a `CaptureRecord` (the hook for run recorders; no wireskein dependency) |
 | `decode` | decoding capture channels (I2C) |
-| `registry` | generated from oep-spec's number table (never edited; copied again from oep-spec) |
+| `registry` | generated from oep-spec's number table (never edited; copied again from oep-spec). The public way to reach an interface by name is `registry.INTERFACES[name]` (`.revision`, `.op`, `.tlv`, `.enum`, e.g. `INTERFACES["oep.fixture.uart"].enum["role"]`); the module-level names (`FIXTURE_UART`, ...) are the same objects |
 | `arm` | `oep.wire.swd`, `oep.target.arm-adi`, MEM-AP, halting and calling functions on a Cortex-M |
 | `ch32_flash` | writing a CH32 (a RAM loader, page by page) |
 | `rp2350` | flash and reboot through the RP2350 boot ROM |
@@ -73,10 +73,12 @@ hst.end()
 
 ```sh
 oep dump --port <probe>                      # what the probe offers (--fake p4-x035: no hardware)
-oep config show <probe>                      # the settings and the live slot / bind state
+oep config show <probe>                      # the settings, the declarations and the live state
+oep config state <probe>                     # the live slot / bind / storage state alone (lock-free, for polling)
 oep config slot <probe> --name x035 --wire rvswd --pins 2,54 --attach at-boot --retry 1 --mechanism dmseq
 oep config bind <probe> --port 1 --mode last-reset --stream slot:x035
-oep config save <probe>                      # kept over a restart (also: remove, erase)
+oep config uart <probe> oep.fixture.uart 115200 --format 8N1   # applied whenever that UART's plan has RX or TX
+oep config save <probe>                      # kept over a restart (also: remove = unset, erase)
 ```
 
 `<probe>` is a serial port, `tcp://HOST:PORT` or `usb[:VID:PID[:SERIAL]]`. A change takes the lock (owner "oep config") and
@@ -86,8 +88,10 @@ A run on hardware: ArduinoCore-CH32's `tests/manual/oep_smoke/` (`oep_smoke.py`,
 
 ## The fake probe (a working spec)
 
-`endpoint.Endpoint` is a fake probe that answers as oep-spec says; ch32rv, this client and the probe firmware are checked
-against it (when the spec changes, this is brought in line before the firmware). `fake` holds example declarations (profiles
+`endpoint.Endpoint` is a fake probe that answers as oep-spec says (2026-10-01: every answer carries the length of its
+data or list, TLVs may follow anything, rejected `expired` after a lapse, one resource number space, describe = declarations
+and `state` for the rest, capture generations); ch32rv, this client and the probe firmware are checked against it (when the
+spec changes, this is brought in line before the firmware). `fake` holds example declarations (profiles
 `p4-x035`, `esp32-v003`, `p4-bench` = a made-up jig with three slots and two seats, `rp2350-pins` = a wire whose pins the host
 chooses), `fake_serial` the byte side of a serial port (COBS candidates, raw bytes and binds, held during a session and
 resumed after it).

{oep_client_python-0.0.20 → oep_client_python-0.0.22}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "oep-client-python"
-version = "0.0.20"
+version = "0.0.22"
 description = "Open Embedded Probe (OEP) v1 host: serial / USB / TCP transports, the session rules, the standard interfaces, and a fake probe"
 readme = "README.md"
 license = "MIT"

{oep_client_python-0.0.20 → oep_client_python-0.0.22}/src/oep_client/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.0.20"
+__version__ = "0.0.22"

{oep_client_python-0.0.20 → oep_client_python-0.0.22}/src/oep_client/__main__.py

@@ -1,10 +1,12 @@
 """The oep command: what a probe offers (dump) and its settings (config).
 
   oep dump --port /run/board-identify/by-id/<probe>        oep dump --fake p4-x035 --prefix oep.target --json
-  oep config show <probe>
+  oep config show <probe>                 (the settings and what the probe declares; lock-free)
+  oep config state <probe>                (the live slot / bind / storage state; lock-free)
   oep config slot <probe> --name x035 --wire rvswd --pins 2,54 --attach at-boot --retry 1 --mechanism dmseq
   oep config bind <probe> --port 1 --mode last-reset --stream slot:x035
-  oep config plan <probe> oep.fixture.uart#2 rx=48 tx=49       (the fn's whole plan; fn number or name#instance)
+  oep config plan <probe> oep.fixture.uart#1 rx=48 tx=49       (the fn's whole plan; fn number or name#instance)
+  oep config uart <probe> oep.fixture.uart#1 115200 --format 8N1
   oep config remove <probe> bind 1        oep config save <probe>        oep config erase <probe>
 
 <probe>: a serial port, tcp://HOST:PORT or usb[:VID:PID[:SERIAL]]. A change takes the lock (owner "oep config") and
@@ -52,9 +54,12 @@ def main(argv=None) -> int:
 def _config_parser(sub) -> None:
     c = sub.add_parser("config", help="the probe's settings (oep.probe.config): slots, binds, save")
     cs = c.add_subparsers(dest="action", required=True)
-    show = cs.add_parser("show", help="the settings and the live slot / bind state")
+    show = cs.add_parser("show", help="the settings, what the probe declares, and the live slot / bind state")
     show.add_argument("probe")
     show.add_argument("--json", action="store_true")
+    state = cs.add_parser("state", help="the live slot / bind / storage state (op state, lock-free)")
+    state.add_argument("probe")
+    state.add_argument("--json", action="store_true")
     slot = cs.add_parser("slot", help="register a slot (a place a target is wired to)")
     slot.add_argument("probe")
     slot.add_argument("--slot", type=int, default=0, help="the slot number (default 0)")
@@ -62,8 +67,9 @@ def _config_parser(sub) -> None:
     slot.add_argument("--wire", help="rvswd or swio (or an fn); default: the probe's only wire")
     slot.add_argument("--pins", help="swdio,swclk (one pin on swio); default: the wire's only pin set")
     slot.add_argument("--attach", choices=sorted(config.ATTACH), default="host")
-    slot.add_argument("--retry", type=int, default=0, help="at-boot: try again every N s while absent (0: never)")
-    slot.add_argument("--mechanism", choices=sorted(config.MECHANISM), default="dmseq")
+    slot.add_argument("--retry", type=float, default=0, help="at-boot: try again every N s while absent (0: never)")
+    slot.add_argument("--mechanism", choices=sorted(config.MECHANISM), default="dmseq",
+                      help="the console's mechanism, or none (no console on this slot)")
     slot.add_argument("--max-speed", type=int, default=0,
                       help="the line's ceiling in Hz for the probe's own attach (0: none); the target's, e.g. 1000000")
     slot.add_argument("--idle-clock", choices=sorted(config.IDLE_CLOCK), default="high",
@@ -79,7 +85,7 @@ def _config_parser(sub) -> None:
     bind.add_argument("--save", action="store_true")
     plan = cs.add_parser("plan", help="the pins an interface keeps (its whole plan, kept as a setting)")
     plan.add_argument("probe")
-    plan.add_argument("fn", help="an fn, or an interface name with #k for its k-th instance (1 = the first)")
+    plan.add_argument("fn", help="an fn, or name#instance (the list instance, 0 = the first; #0 may be left out, core §7.2)")
     plan.add_argument("roles", nargs="+", help="ROLE=CHANNEL, ROLE a number or the interface's role name (rx, tx, line...)")
     plan.add_argument("--save", action="store_true")
     label = cs.add_parser("label", help="name a channel (shown in oep.core's describe)")
@@ -92,9 +98,15 @@ def _config_parser(sub) -> None:
     idle.add_argument("channel", type=int)
     idle.add_argument("mode", choices=sorted(config.IDLE))
     idle.add_argument("--save", action="store_true")
-    rm = cs.add_parser("remove", help="remove one item: slot N, bind PORT, plan FN, label CH, idle CH")
+    uart = cs.add_parser("uart", help="a fixture UART's baud / format, applied whenever its plan has RX or TX")
+    uart.add_argument("probe")
+    uart.add_argument("fn", help="an fn, or name#instance of the oep.fixture.uart")
+    uart.add_argument("baud", type=int)
+    uart.add_argument("--format", default="8N1", help="data bits, parity, stop bits: 8N1 (default), 8E1, 7O2 ...")
+    uart.add_argument("--save", action="store_true")
+    rm = cs.add_parser("remove", help="remove one item (unset): slot N, bind PORT, plan FN, label CH, idle CH, uart FN")
     rm.add_argument("probe")
-    rm.add_argument("kind", choices=["slot", "bind", "plan", "label", "idle"])
+    rm.add_argument("kind", choices=sorted(config.ITEM))
     rm.add_argument("key", type=int)
     rm.add_argument("--save", action="store_true")
     for name in ("save", "erase"):
@@ -108,7 +120,7 @@ def _pins(hst, fn: int, text: str | None, wire: str) -> tuple[int, int]:
     groups = []
     for tag, v in core.describe(hst, fn):
         if tag & 0x7F == catalog.CHANNEL_GROUP:
-            roles = {v[1 + 3 * i]: struct.unpack_from("<H", v, 2 + 3 * i)[0] for i in range((len(v) - 1) // 3)}
+            roles = dict(catalog.unpack_channel_group(v)[1])
             groups.append((roles.get(1, 0xFFFF), roles.get(2, 0xFFFF)))
     if len(groups) != 1:
         raise SystemExit(f"{wire}: {len(groups)} pin sets on this probe - name one with --pins")
@@ -116,20 +128,21 @@ def _pins(hst, fn: int, text: str | None, wire: str) -> tuple[int, int]:
 
 
 def _plan_fn(hst, spec: str) -> tuple[int, dict[str, int]]:
-    """fn and its role names (from the registry) for `spec`: an fn number, or name[#k] (k-th instance, 1-based)."""
+    """fn and its role names (from the registry) for `spec`: an fn number, or name[#instance] (the list's instance,
+    0-based, core §7.2)."""
     from . import registry as reg
     if spec.isdigit():
         fn = int(spec)
         name = next((e.name for e in core.list_entries(hst) if e.fn == fn), "")
     else:
         name, _, k = spec.partition("#")
-        fns = core.find_all(hst, name)
-        if not fns:
+        entries = [e for e in core.list_entries(hst, name, exact=True)]
+        if not entries:
             raise SystemExit(f"the probe offers no {name}")
-        index = int(k) - 1 if k else 0
-        if not 0 <= index < len(fns):
-            raise SystemExit(f"{name}: {len(fns)} instance(s), fns {fns}")
-        fn = fns[index]
+        instance = int(k) if k else 0
+        fn = next((e.fn for e in entries if e.instance == instance), None)
+        if fn is None:
+            raise SystemExit(f"{name}: instances {sorted(e.instance for e in entries)}, not {instance}")
     iface = reg.INTERFACES.get(name)
     roles = dict(iface.enum.get("role", {})) if iface else {}
     return fn, roles
@@ -179,6 +192,8 @@ def _config(args) -> int:
         cfg = config.ProbeConfig(hst)
         if args.action == "show":
             return _show(hst, cfg, args.json)
+        if args.action == "state":
+            return _state(cfg, args.json)
         if args.action == "slot":
             fn = _wire_fn(hst, args.wire)
             args.wire = args.wire or str(fn)
@@ -207,6 +222,15 @@ def _config(args) -> int:
                     raise SystemExit(f"{role}: not a role of fn {fn} (roles: {', '.join(sorted(roles)) or 'numbers only'})")
                 items.append(config.Plan(fn=fn, role=number, channel=int(ch, 0)))
             _change(hst, cfg, items, args.save)
+        elif args.action == "uart":
+            fn, _ = _plan_fn(hst, args.fn)
+            from .fixture import FixtureUart
+            fmt = args.format.upper()
+            try:
+                byte = FixtureUart.format_byte(int(fmt[0]), fmt[1], int(fmt[2]))
+            except (KeyError, ValueError, IndexError):
+                raise SystemExit(f"--format {args.format}: want <data bits><parity><stop bits>, e.g. 8N1, 8E2, 7O1") from None
+            _change(hst, cfg, [config.Uart(fn=fn, baud=args.baud, format=byte)], args.save)
         elif args.action == "label":
             _change(hst, cfg, [config.Label(channel=args.channel, text=args.text)], args.save)
         elif args.action == "idle":
@@ -231,42 +255,66 @@ def _config(args) -> int:
         hst.link.close()
 
 
+def _plain(o):
+    return {k: (v.hex() if isinstance(v, bytes) else v) for k, v in vars(o).items()} if hasattr(o, "__dict__") \
+        else list(o)
+
+
+def _state_dict(st) -> dict:
+    return {**{k: v for k, v in vars(st).items() if k not in ("slots", "binds")},
+            "slots": [_plain(s) for s in st.slots], "binds": [_plain(b) for b in st.binds]}
+
+
+def _state(cfg, as_json: bool) -> int:
+    """The live state alone (op state, lock-free): what a monitor polls."""
+    st = cfg.state()
+    if as_json:
+        print(json.dumps(_state_dict(st), indent=2, default=lambda o: o.hex() if isinstance(o, bytes) else str(o)))
+        return 0
+    why = f" ({st.unreadable})" if st.unreadable else ""
+    print(f"storage: {st.storage}{why}, saved hash 0x{st.saved_hash:08x}")
+    for s in st.slots:
+        print(f"  slot {s.slot}: {s.state}" + (f", connection {s.connection}" if s.connection else "")
+              + (f", tried at {s.last_try_at_ns / 1e9:.3f} s" if s.last_try_at_ns is not None else "")
+              + (f", target_id {s.target_id[::-1].hex()}" if s.target_id else ""))
+    for b in st.binds:
+        print(f"  port {b.port}: {b.mode}, {b.flow}" + (f", carrying {b.selected}" if b.selected is not None else ""))
+    return 0
+
+
 def _show(hst, cfg, as_json: bool) -> int:
     h, _ = cfg.get()
     items = cfg.items()
+    decl = cfg.describe()
     st = cfg.state()
     kinds = {i: _name(k) for i, k, _ in core.transports(hst)}
     if as_json:
-        def plain(o):
-            return {k: (v.hex() if isinstance(v, bytes) else v) for k, v in vars(o).items()} if hasattr(o, "__dict__") \
-                else list(o)
-        out = {"hash": h, "items": [dict(type=type(i).__name__, **plain(i)) if hasattr(i, "__dict__") else plain(i)
+        out = {"hash": h, "items": [dict(type=type(i).__name__, **_plain(i)) if hasattr(i, "__dict__") else _plain(i)
                                      for i in items],
-               "state": {**{k: v for k, v in vars(st).items() if k not in ("slots", "binds")},
-                         "slots": [plain(s) for s in st.slots], "binds": [plain(b) for b in st.binds]},
-               "transports": kinds}
+               "declared": _plain(decl), "state": _state_dict(st), "transports": kinds}
         print(json.dumps(out, indent=2, default=lambda o: o.hex() if isinstance(o, bytes) else str(o)))
         return 0
-    print(f"storage: {st.storage} ({st.storage_bytes} bytes), saved hash 0x{st.saved_hash:08x}; now 0x{h:08x}")
+    why = f" ({st.unreadable})" if st.unreadable else ""
+    print(f"storage: {st.storage}{why} ({decl.storage_bytes} bytes), saved hash 0x{st.saved_hash:08x}; now 0x{h:08x}")
     print("transports: " + ", ".join(f"{i} {k}" for i, k in kinds.items()))
     by_slot = {s.slot: s for s in st.slots}
-    print(f"slots (up to {st.slots_max}):")
+    print(f"slots (up to {decl.slots_max}):")
     for it in items:
         if isinstance(it, config.Slot):
             s = by_slot.get(it.slot)
             pins = f"{it.pins[0]}" if it.pins[1] == 0xFFFF else f"{it.pins[0]},{it.pins[1]}"
-            retry = f" retry {it.retry_s} s" if it.attach == "at-boot" else ""
+            retry = f" retry {it.retry_s:g} s" if it.attach == "at-boot" else ""
             retry += (f" max {it.max_speed} Hz" if it.max_speed else "") + (" idle-low" if it.idle_clock == "low" else "")
             lock = (f" lock {int.from_bytes(it.lock[1], 'little'):08x}:{int.from_bytes(it.lock[2], 'little'):08x}"
                     if it.lock else "")
             live = ""
             if s:
-                tried = "never tried" if s.last_try_ms is None else f"tried {s.last_try_ms} ms ago"
+                tried = "never tried" if s.last_try_at_ns is None else f"tried at {s.last_try_at_ns / 1e9:.3f} s"
                 tid = f" target_id {s.target_id[::-1].hex()}" if s.target_id else ""
                 live = f"  -> {s.state}" + (f" (connection {s.connection})" if s.connection else f" ({tried})") + tid
             print(f"  {it.slot} {it.name}: fn {it.wire_fn} pins {pins} {it.attach}{retry} {it.mechanism}{lock}{live}")
     by_port = {b.port: b for b in st.binds}
-    print(f"binds (modes: {', '.join(st.bind_modes) or '-'}):")
+    print(f"binds (modes: {', '.join(decl.bind_modes) or '-'}):")
     names = {it.slot: it.name for it in items if isinstance(it, config.Slot)}
     for it in items:
         if isinstance(it, config.Bind):

{oep_client_python-0.0.20 → oep_client_python-0.0.22}/src/oep_client/arm.py

@@ -29,17 +29,19 @@ class SwdWire(WireBase):
         self.existing = False
 
     def attach(self, targetsel: int | None = None, max_speed: int | None = None,
-               pins: tuple[int, int] | None = None) -> tuple[int, int, bool]:
-        """-> (connection, DPIDR, woke from dormant). targetsel (multidrop) and max_speed go as critical TLVs: a probe
-        that cannot honour them refuses. self.existing: the wire was attached already (its connection returned)."""
-        body = self._speed_tlv(max_speed) + self._pins_tlv(pins)
+               pins: tuple[int, int] | None = None, reset: tuple[int, int] | None = None) -> tuple[int, int, bool]:
+        """-> (connection, DPIDR, woke from dormant). The request is method 0 (swd has no halting attach) and TLVs:
+        max_speed (required, critical; None: the wire's declared max_clock_hz), targetsel (multidrop, critical), pins,
+        reset = (channel, hold_ms) (critical). self.existing: the wire was attached already (its connection returned).
+        self.flags: the attach_flags byte."""
+        body = bytes([0]) + self._speed_tlv(self._speed_or_default(max_speed)) + self._pins_tlv(pins) + self._reset_tlv(reset)
         if targetsel is not None:
             body += m.tlv(self.TAG_TARGETSEL, struct.pack("<I", targetsel), critical=True)
         rd = m.Reader(self._call(self.ATTACH, body).payload)
-        conn, dpidr, flags, self.speed_hz = rd.take("HIBI")
-        self.existing = bool(flags & 2)
+        conn, dpidr, self.flags, self.speed_hz = rd.take("HIBI")
+        self.existing = bool(self.flags & self.FLAGS["existing"])
         rd.tail()
-        return conn, dpidr, bool(flags & 1)
+        return conn, dpidr, bool(self.flags & self.FLAGS["dormant_woken"])
 
 
 class AdiError(TargetError):
@@ -82,8 +84,8 @@ class ArmAdi(Interface):
         reads = transfer_reads(steps)
         r = self._request(self.TRANSFER, struct.pack("<H", len(reads)) + steps)
         rd = ran(r)
-        done, status, self.last_ack = rd.take("HBB")
-        values = rd.words(sum(reads[:done]))
+        done, status, self.last_ack, nvals = rd.take("HBBH")    # nvals: the values the answer carries (debug §6)
+        values = rd.words(nvals)
         rd.tail()
         if status != OK or not r.succeeded or done != len(reads):
             raise AdiError(f"transfer (ack {self.last_ack:#x})", status, r, done=done, values=values)