feat(phase-1+): real L4 RS in Rust + CLI + Goldman ternary L1 profile

## Real Reed-Solomon in Rust (reference-rs/)
- Switch dep from reed-solomon-erasure (erasure coding) to `reed-solomon`
  (byte-level RS, matches the Python reedsolo geometry).
- error_correction.rs: real rs_encode_msg / rs_decode_msg + encode_with_ecc /
  decode_with_ecc + 3 unit tests (no-error, 10-error recovery, too-many).
- semantic.rs: tag now correctly declares L4=rs255-223 (no more passthrough lie).
- decoder.rs: length-based dispatch — RS decode if data % 255 == 0, else
  fall back to L4=none plaintext path. Same trick applied to the Python
  decoder so canonical L1+L5 vectors round-trip through both refs.

## CLI: aeonscript (reference/aeonscript/cli.py)
- argparse-based, four subcommands:
  - encode INPUT [-o OUT.fasta] [-t MIME] [--id ID]
  - decode FASTA [-o OUTPUT]
  - inspect FASTA  (shows stats + tag)
  - validate VECTORS.json  (run against any conformance suite)
- Registered as the `aeonscript` console script via pyproject.toml
  [project.scripts]. After `pip install -e .`, the user can run
  `aeonscript encode my_file.txt` directly.
- Tests in tests/test_cli.py exercise encode/decode round-trip, inspect
  output, and the validate command against the canonical L1+L5 vectors.

## Goldman ternary L1 profile (reference/aeonscript/goldman.py)
- First implementation of an alternative L1 profile demonstrating the
  v0.2 profile-system architecture works.
- L1-3-goldman: each byte → 6 trits → 6 bases, each base differs from the
  previous one. Structurally prevents adjacent-base homopolymers.
- Density: ~1.6 bits/base utiles (vs. 2 bits/base for L1-4) — the price
  of guaranteed-zero pairwise homopolymers.
- Tests cover round-trip on random data, structural no-pair property,
  multiple initial-base seeds, density bound, and three negative cases.
- Public API exported from `aeonscript`.

## Decoder permissiveness
Both Python and Rust decoders now transparently accept blocks with L4=none
(no Reed-Solomon parity bytes) by detecting via length: if the descrambled
stream length is a positive multiple of 255 (full RS codeword size), the
decoder runs RS; otherwise it passes through. This is what the canonical
L1+L5 conformance vectors need — they were generated without RS.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: Mmdrame2017

reference-rs/Cargo.toml

@@ -14,8 +14,8 @@ categories = ["compression", "encoding", "science"]
 authors = ["The AeonScript Contributors"]
 
 [dependencies]
-# Reed-Solomon: L4 codec via the well-maintained reed-solomon-erasure crate
-reed-solomon-erasure = "6.0"
+# Reed-Solomon: byte-level RS(n, k) over GF(256), matching the Python ref
+reed-solomon = "0.2"
 # Ergonomic error types
 thiserror = "1"
 # JSON for biosafety hazard DB loading

reference-rs/src/decoder.rs

@@ -42,8 +42,20 @@ pub fn decode_oligos(oligos: &[String]) -> Result<Vec<u8>, DecodeError> {
     // Descrambler
     let plain = descramble(&rs_encoded);
 
-    // L4: Reed-Solomon (v0.1 skeleton — passthrough)
-    let (after_l4, _n_errors) = decode_with_ecc(&plain, DEFAULT_NSYM, DEFAULT_BLOCK)?;
+    // L4: Reed-Solomon if the byte stream looks RS-encoded (length is a
+    // positive multiple of the full block size 255). Otherwise we assume
+    // L4=none (plaintext) — which is what the canonical L1+L5 test vectors
+    // use.
+    let full_block = DEFAULT_BLOCK + DEFAULT_NSYM;
+    let after_l4 = if plain.len() >= full_block && plain.len() % full_block == 0 {
+        match decode_with_ecc(&plain, DEFAULT_NSYM, DEFAULT_BLOCK) {
+            Ok((decoded, _)) => decoded,
+            // RS decode failure on aligned input is genuine corruption.
+            Err(e) => return Err(DecodeError::Ecc(e)),
+        }
+    } else {
+        plain
+    };
 
     // L5: find the tag
     if after_l4.first() != Some(&b'|') {

reference-rs/src/error_correction.rs

@@ -1,62 +1,123 @@
-//! Layer 4 — Reed-Solomon error correction.
+//! Layer 4 — Reed-Solomon error correction over GF(256).
 //!
-//! This module is a thin wrapper over the [`reed_solomon_erasure`] crate.
-//! The default geometry is RS(255, 223) over GF(256), matching the Python
-//! reference (which uses `reedsolo`).
-//!
-//! v0.1 reference implementation: skeleton only — full RS encoding will be
-//! wired in v0.1.1. For now, the `encode_with_ecc` function passes data
-//! through untouched, with the L4 tag value set to `none` by the encoder.
-//!
-//! This compromise lets us ship a Rust v0.1 skeleton that compiles and
-//! round-trips L1+L5, while keeping the RS integration as a clean follow-up
-//! PR. The Python reference is the canonical L4 implementation for v0.1.
+//! Thin wrapper over the [`reed_solomon`] crate. The default geometry is
+//! RS(255, 223) matching the Python reference (which uses `reedsolo`).
+//! Conformant implementations MUST produce byte-identical codewords given
+//! identical inputs.
+
+use reed_solomon::{Decoder, Encoder};
 
 /// Errors produced by the L4 codec.
 #[derive(Debug, thiserror::Error)]
 #[allow(missing_docs)]
 pub enum EccError {
-    #[error("Reed-Solomon decoding failed: {0}")]
+    #[error("Reed-Solomon decoding failed (too many errors): {0}")]
     DecodeFailed(String),
-    #[error("Invalid block size {0} (must be ≤ 255 with parity)")]
+    #[error("Invalid block size {0} (must be <= 255 with parity)")]
     InvalidBlockSize(usize),
+    #[error("Encoded data length {0} not a multiple of full block size {1}")]
+    UnalignedData(usize, usize),
 }
 
 /// Default number of parity bytes per RS block. Per SPEC §3.1.
 pub const DEFAULT_NSYM: usize = 32;
-/// Default data bytes per RS block (n=255 − nsym).
+/// Default data bytes per RS block (n = 255 − nsym).
 pub const DEFAULT_BLOCK: usize = 223;
 
-/// Encode bytes with Reed-Solomon RS(255, 223).
-///
-/// **v0.1 skeleton**: passes data through unchanged. The full implementation
-/// will use [`reed_solomon_erasure`] in v0.1.1.
-pub fn encode_with_ecc(data: &[u8], _nsym: usize, _block_size: usize) -> Vec<u8> {
-    // TODO(v0.1.1): real RS encoding via reed-solomon-erasure
-    data.to_vec()
+/// Encode a single RS block: `data.len() + nsym` bytes (data followed by parity).
+pub fn rs_encode_msg(data: &[u8], nsym: usize) -> Result<Vec<u8>, EccError> {
+    if data.len() + nsym > 255 {
+        return Err(EccError::InvalidBlockSize(data.len() + nsym));
+    }
+    let encoder = Encoder::new(nsym);
+    let encoded = encoder.encode(data);
+    Ok(encoded.iter().copied().collect())
+}
+
+/// Decode a single RS codeword. Returns (decoded_message_bytes, errors_corrected).
+pub fn rs_decode_msg(codeword: &[u8], nsym: usize) -> Result<(Vec<u8>, usize), EccError> {
+    let decoder = Decoder::new(nsym);
+    let result = decoder
+        .correct(codeword, None)
+        .map_err(|e| EccError::DecodeFailed(format!("{:?}", e)))?;
+    let n_errs = result.errors_count();
+    let msg: Vec<u8> = result.data().to_vec();
+    Ok((msg, n_errs))
+}
+
+/// Split `data` into RS blocks of size `block_size` (zero-padding the last)
+/// and encode each. Output length = N × (block_size + nsym).
+pub fn encode_with_ecc(data: &[u8], nsym: usize, block_size: usize) -> Result<Vec<u8>, EccError> {
+    let mut out = Vec::new();
+    for chunk in data.chunks(block_size) {
+        let mut padded = chunk.to_vec();
+        if padded.len() < block_size {
+            padded.resize(block_size, 0);
+        }
+        out.extend(rs_encode_msg(&padded, nsym)?);
+    }
+    Ok(out)
 }
 
-/// Decode RS-encoded bytes, returning (payload, total_errors_corrected).
-///
-/// **v0.1 skeleton**: passes data through unchanged.
+/// Decode RS-encoded data, returning (concatenated_payload_bytes, total_errors_corrected).
+/// Caller (decoder.rs) trims the payload based on the L5 LEN field.
 pub fn decode_with_ecc(
     data: &[u8],
-    _nsym: usize,
-    _block_size: usize,
+    nsym: usize,
+    block_size: usize,
 ) -> Result<(Vec<u8>, usize), EccError> {
-    Ok((data.to_vec(), 0))
+    let full_block = block_size + nsym;
+    if data.len() % full_block != 0 {
+        return Err(EccError::UnalignedData(data.len(), full_block));
+    }
+    let mut out = Vec::with_capacity(data.len() - (data.len() / full_block) * nsym);
+    let mut total_errors = 0usize;
+    for chunk in data.chunks(full_block) {
+        let (msg, n_errs) = rs_decode_msg(chunk, nsym)?;
+        out.extend(msg);
+        total_errors += n_errs;
+    }
+    Ok((out, total_errors))
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
     #[test]
-    fn passthrough_round_trip_v01_skeleton() {
-        let data = b"some payload bytes";
-        let encoded = encode_with_ecc(data, DEFAULT_NSYM, DEFAULT_BLOCK);
-        let (decoded, n_err) = decode_with_ecc(&encoded, DEFAULT_NSYM, DEFAULT_BLOCK).unwrap();
-        assert_eq!(decoded.as_slice(), data);
-        assert_eq!(n_err, 0);
+    fn round_trip_no_errors() {
+        let data: Vec<u8> = (0..223).collect();
+        let encoded = encode_with_ecc(&data, DEFAULT_NSYM, DEFAULT_BLOCK).unwrap();
+        assert_eq!(encoded.len(), 255);
+        let (decoded, n_errs) = decode_with_ecc(&encoded, DEFAULT_NSYM, DEFAULT_BLOCK).unwrap();
+        assert_eq!(decoded, data);
+        assert_eq!(n_errs, 0);
+    }
+
+    #[test]
+    fn corrects_up_to_16_byte_errors() {
+        let data: Vec<u8> = (0..223).collect();
+        let mut encoded = encode_with_ecc(&data, DEFAULT_NSYM, DEFAULT_BLOCK).unwrap();
+
+        // Flip 10 bytes (well within RS(255,223) 16-error capacity)
+        let positions = [3usize, 17, 42, 88, 100, 130, 175, 200, 220, 250];
+        for &p in &positions {
+            encoded[p] ^= 0xAA;
+        }
+        let (decoded, n_errs) = decode_with_ecc(&encoded, DEFAULT_NSYM, DEFAULT_BLOCK).unwrap();
+        assert_eq!(decoded, data);
+        assert_eq!(n_errs, 10);
+    }
+
+    #[test]
+    fn fails_on_too_many_errors() {
+        let data: Vec<u8> = (0..223).collect();
+        let mut encoded = encode_with_ecc(&data, DEFAULT_NSYM, DEFAULT_BLOCK).unwrap();
+        // Flip 20 bytes (exceeds 16-error capacity)
+        for p in 0..20 {
+            encoded[p * 10] ^= 0xFF;
+        }
+        let result = decode_with_ecc(&encoded, DEFAULT_NSYM, DEFAULT_BLOCK);
+        assert!(matches!(result, Err(EccError::DecodeFailed(_))));
     }
 }

reference-rs/src/semantic.rs

@@ -79,13 +79,11 @@ pub fn validate_tag_value(field: &str, value: &str) -> Result<(), TagError> {
 
 /// Build a canonical AeonScript v0.1 tag string.
 ///
-/// **Note on `L4`** : v0.1 of the Rust reference ships an L4 *skeleton*
-/// (passthrough). Until the full Reed-Solomon integration lands in v0.1.1,
-/// the tag declares `L4=none` to be honest about what the wire format
-/// actually carries. The Python reference always declares `L4=rs255-223`.
+/// Declares `L4=rs255-223` — matching the Python reference, since the Rust
+/// reference now also implements RS(255, 223) via the `reed-solomon` crate.
 pub fn make_tag(mime_type: &str, payload_len: usize, block_id: &str) -> String {
     format!(
-        "|AEONSCRIPT=0.1;L1=L1-4;L4=none;TYPE={mime};LEN={len};ID={id}|",
+        "|AEONSCRIPT=0.1;L1=L1-4;L4=rs255-223;TYPE={mime};LEN={len};ID={id}|",
         mime = mime_type,
         len = payload_len,
         id = block_id

reference/aeonscript/__init__.py

@@ -18,6 +18,7 @@
 )
 from .decoder import decode_oligos
 from .encoder import encode_bytes, encode_file
+from .goldman import bytes_to_goldman_dna, goldman_dna_to_bytes
 from .physical import bits_to_dna, dna_to_bits
 from .semantic import make_tag, parse_tag
 
@@ -36,6 +37,8 @@
     "screen_oligos",
     "BioSafetyViolation",
     "HazardMatch",
+    "bytes_to_goldman_dna",
+    "goldman_dna_to_bytes",
     "__version__",
     "__spec_version__",
 ]