chore: update tomls

Author: samp-reston

crates/ace-can/Cargo.toml

@@ -2,6 +2,13 @@
 name = "ace-can"
 version = "0.1.0"
 edition = "2024"
+authors = ["Samuel Preston <samp.reston@outlook.com>"]
+description = "ISO-TP implementation. Provides the reassembler and segmenter used by an IsoTpNode to bridge DoIP UDS payloads to CAN frames."
+readme = "README.md"
+repository = "https://github.com/samp-reston/ace"
+license = "MIT or Apache-2.0"
+keywords = ["diagnostics", "vehicle", "standards"]
+categories = ["development-tools", "network-programming", "automotive"]
 
 [features]
 default = []

crates/ace-can/README.md

@@ -0,0 +1,33 @@
+# `ace-can`
+
+ISO-TP implementation (ISO 15765-2). Provides the reassembler and segmenter used by `ace-gateway`'s `IsoTpNode` to bridge DoIP UDS payloads to CAN frames.
+
+**Design:** addressing mode (Normal / Extended / Mixed) is a caller concern. The reassembler and segmenter operate on pure PCI bytes — callers strip/prepend the address byte at the transport boundary.
+
+```rust
+// Segmenter — owns its payload buffer, no lifetime, no unsafe
+let mut seg = Segmenter::<4096>::new(SegmenterConfig::classic(Normal));
+seg.start(&uds_payload)?;
+
+let mut out = [0u8; 8];
+loop {
+    match seg.next_frame(&mut out)? {
+        SegmentResult::Frame { len } => { /* put out[..len] on CAN bus */ }
+        SegmentResult::Complete      => break,
+        SegmentResult::WaitForFlowControl => {
+            // wait for FC from receiver then call seg.handle_flow_control(fc)
+        }
+    }
+}
+```
+
+```rust
+// Reassembler
+let mut rsm = Reassembler::<4096>::new(ReassemblerConfig::new(Normal));
+match rsm.feed(&can_frame_bytes)? {
+    ReassembleResult::Complete { len }     => { /* rsm.message(len) */ }
+    ReassembleResult::FlowControl { .. }   => { /* send FC back */ }
+    ReassembleResult::InProgress           => {}
+    ReassembleResult::SessionAborted { .. } => {}
+}
+```

crates/ace-client/Cargo.toml

@@ -2,6 +2,13 @@
 name = "ace-client"
 version = "0.1.0"
 edition = "2024"
+authors = ["Samuel Preston <samp.reston@outlook.com>"]
+description = "UDS tester client state machine."
+readme = "README.md"
+repository = "https://github.com/samp-reston/ace"
+license = "MIT or Apache-2.0"
+keywords = ["diagnostics", "vehicle", "standards"]
+categories = ["development-tools", "network-programming", "automotive"]
 
 [features]
 default = []

crates/ace-client/README.md

@@ -0,0 +1,31 @@
+# `ace-client`
+
+UDS tester client state machine (ISO 14229-1 tester side).
+
+A dumb request/response pipe. Sends raw UDS frames, emits `ClientEvent`s as responses arrive. Tracks P2/P2* timeouts per pending request. Session state, security state, and retry logic are the caller's responsibility.
+
+```rust
+let mut client = UdsClient::<1>::new(config, address);
+
+// Send a request
+client.request(&[0x10, 0x03], now)?;
+
+// After ticking, drain events
+for event in client.drain_events() {
+    match event {
+        ClientEvent::PositiveResponse { sid, data } => { /* ... */ }
+        ClientEvent::NegativeResponse { sid, nrc }  => { /* ... */ }
+        ClientEvent::ResponsePending  { sid }        => { /* extended timeout active */ }
+        ClientEvent::Timeout          { sid }        => { /* no response in time */ }
+        ClientEvent::PeriodicData     { did, data }  => { /* periodic DID data */ }
+        ClientEvent::Unsolicited      { data }        => { /* unmatched frame */ }
+    }
+}
+```
+
+Periodic DID subscriptions control classification of `0xF2xx` response frames:
+
+```rust
+client.subscribe_periodic(0x90);   // DID 0xF290 low byte
+client.unsubscribe_periodic(0x90);
+```

crates/ace-core/Cargo.toml

@@ -2,6 +2,13 @@
 name = "ace-core"
 version = "0.1.0"
 edition = "2024"
+authors = ["Samuel Preston <samp.reston@outlook.com>"]
+description = "Foundation layer, providing three codec traits that the rest of ACE builds on: FrameRead, FrameWrite, Writer"
+readme = "README.md"
+repository = "https://github.com/samp-reston/ace"
+license = "MIT or Apache-2.0"
+keywords = ["diagnostics", "vehicle", "standards"]
+categories = ["development-tools", "network-programming", "automotive"]
 
 [features]
 default = []

crates/ace-core/README.md

@@ -0,0 +1,14 @@
+# `ace-core`
+
+Foundation layer. Defines the three codec traits that everything else builds on:
+
+- `FrameRead<'a>` — zero-copy decode from a `&mut &'a [u8]` cursor
+- `FrameWrite` — encode into a `Writer` (either `&mut [u8]` or `BytesMut`)
+- `Writer` — sealed trait abstracting alloc and no-alloc write targets
+
+Also provides `DiagError`, `AddressMode`, `DiagnosticAddress`, and the `FrameIter<'a, T>` lazy iterator for variable-length repeated fields.
+
+```toml
+[dependencies]
+ace-core = { path = "../ace-core", default-features = false }
+```

crates/ace-doip/Cargo.toml

@@ -2,6 +2,13 @@
 name = "ace-doip"
 version = "0.1.0"
 edition = "2024"
+authors = ["Samuel Preston <samp.reston@outlook.com>"]
+description = "DoIP typed message and session layer implementing ISO 13400-2."
+readme = "README.md"
+repository = "https://github.com/samp-reston/ace"
+license = "MIT or Apache-2.0"
+keywords = ["diagnostics", "vehicle", "standards"]
+categories = ["development-tools", "network-programming", "automotive"]
 
 [features]
 default = []

crates/ace-doip/README.md

@@ -0,0 +1,32 @@
+# `ace-doip`
+
+DoIP typed message and session layer implementing ISO 13400-2.
+
+**Message layer** — all payload types as structs deriving `FrameCodec`: `RoutingActivationRequest`, `RoutingActivationResponse`, `DiagnosticMessage`, `DiagnosticMessageAck`, `DiagnosticMessageNack`, `VehicleAnnouncementMessage`, `EntityStatusResponse`, `AliveCheckRequest`, `AliveCheckResponse`, and more.
+
+**Session layer** — `ActivationStateMachine` and `ConnectionState` model the per-TCP-connection routing activation lifecycle:
+
+```
+Idle → ActivationPending → Active → Deactivated
+```
+
+`ActivationAuthProvider` is a hook trait for OEM-specific authentication on `CentralSecurity` (0xFF) activation:
+
+```rust
+pub trait ActivationAuthProvider {
+    fn authenticate(
+        &mut self,
+        source_address: u16,
+        oem_data: &[u8],
+    ) -> Result<(), ActivationDenialReason>;
+}
+```
+
+`DoipFrameExt` provides semantic accessors on `DoipFrame`:
+
+```rust
+frame.validate_header()?;          // checks version, inverse, type, length
+frame.payload_type();              // Option<Result<PayloadType, _>>
+frame.payload_bytes();             // Option<&[u8]> — bytes after 8-byte header
+frame.payload_length_declared();   // length from header bytes 4-7
+```

crates/ace-gateway/Cargo.toml

@@ -2,6 +2,13 @@
 name = "ace-gateway"
 version = "0.1.0"
 edition = "2024"
+authors = ["Samuel Preston <samp.reston@outlook.com>"]
+description = "DoIP Gateway, ISO-TP bridge node, and DoIP Tester"
+readme = "README.md"
+repository = "https://github.com/samp-reston/ace"
+license = "MIT or Apache-2.0"
+keywords = ["diagnostics", "vehicle", "standards"]
+categories = ["development-tools", "network-programming", "automotive"]
 
 [dependencies]
 ace-sim = { path = "../ace-sim", default-features = false }

crates/ace-gateway/README.md

@@ -0,0 +1,49 @@
+# `ace-gateway`
+
+DoIP gateway, ISO-TP bridge node, and DoIP tester.
+
+**`DoipGateway<A, MAX_TESTERS, BUF>`** — gateway state machine. Translates DoIP frames from TCP into UDS bytes on CAN, and CAN responses back into DoIP frames. Has two faces — `handle_tcp` and `handle_can` — because it spans two buses. Routing table maps DoIP logical addresses to CAN IDs.
+
+**`IsoTpNode<N>`** — bridges raw UDS bytes to ISO-TP CAN frames. Two independent segmenters (request and response directions) to handle concurrent multi-frame exchanges. Key methods: `handle_from_gateway(uds_data)`, `handle_uds_response(uds_data)`, `handle_from_ecu(can_frame)`.
+
+**`DoipTester<MAX_CONNECTIONS, MAX_TARGETS>`** — models a physical DoIP tester device. Owns multiple `DoipConnection`s (one per TCP connection). Each connection addresses multiple ECUs simultaneously via `target_address`. P2/P2* timeouts are learned dynamically from `DiagnosticSessionControlResponse`. Events are tagged `(ConnectionId, TargetId, DoipTesterEvent)`.
+
+```rust
+let mut tester = DoipTester::<4, 8>::new(0x0E00, NodeAddress(0x0E00));
+
+// Open a connection to a gateway
+let conn = tester.open_connection(DoipConnectionConfig::new(0x0E80))?;
+
+// After TCP connects (TcpSimBus::connect or real TcpStream):
+// tester.on_tcp_event(&TcpEvent::ConnectionEstablished { .. }, now);
+// → automatically sends RoutingActivationRequest
+
+// Send UDS to ECU 0x0001 on that connection
+tester.request(conn, 0x0001, &[0x10, 0x03], now)?;
+
+// Drain events
+for (conn_id, target_id, event) in tester.drain_events() {
+    // ...
+}
+```
+
+Node profiles accumulate from UDP announcements:
+
+```rust
+if let Some(profile) = tester.profile(0x0E80) {
+    println!("VIN: {:?}", profile.vin);
+}
+```
+
+**`GatewayConfig`** builder:
+
+```rust
+let config = GatewayConfig::new(0x0E80)
+    .with_tester(0x0E00)
+    .with_node(CanNodeEntry {
+        logical_address:   0x0001,
+        request_can_id:    0x7E0,
+        response_can_id:   0x7E8,
+        functional_can_id: 0x7DF,
+    });
+```