txt: explicit latin1

crates/mb3-txt/src/encoding.rs

@@ -0,0 +1,93 @@
+use super::*;
+/// Explicit source decoding. Latin1 is ISO-8859-1, never Windows-1252 or guessed.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub enum Encoding {
+    #[default]
+    Utf8,
+    Latin1,
+}
+pub fn decode_with_encoding(
+    bytes: &[u8],
+    encoding: Encoding,
+    limits: &Limits,
+) -> Result<mb3_dat::World> {
+    if encoding == Encoding::Utf8 {
+        return decode(bytes, limits);
+    }
+    if bytes.len() > limits.max_bytes {
+        return Err(err(0, ErrorKind::LimitExceeded("file bytes")));
+    }
+    if bytes.starts_with(b"\xef\xbb\xbf") {
+        return Err(err(0, ErrorKind::ConflictingBom));
+    }
+    let n = bytes
+        .len()
+        .checked_add(bytes.iter().filter(|b| **b >= 128).count())
+        .ok_or_else(|| err(0, ErrorKind::CountOverflow))?;
+    if n > limits.max_bytes {
+        return Err(err(0, ErrorKind::LimitExceeded("transcoded bytes")));
+    }
+    let owned = limits
+        .max_owned_bytes
+        .checked_sub(n)
+        .ok_or_else(|| err(0, ErrorKind::LimitExceeded("transcode storage")))?;
+    let mut text = Vec::new();
+    text.try_reserve_exact(n)
+        .map_err(|_| err(0, ErrorKind::Allocation))?;
+    for b in bytes {
+        let mut buf = [0; 4];
+        text.extend_from_slice(char::from(*b).encode_utf8(&mut buf).as_bytes());
+    }
+    decode(
+        &text,
+        &Limits {
+            max_owned_bytes: owned,
+            ..*limits
+        },
+    )
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn explicit_encoding_limits_and_bom() {
+        let input = b"world(computedFeatures false stringProperties[\"\xe9\"] )";
+        assert!(decode(input, &Limits::default()).is_err());
+        let w = decode_with_encoding(input, Encoding::Latin1, &Limits::default()).unwrap();
+        assert_eq!(w.string_properties, ["é"]);
+        assert_eq!(
+            decode(&encode(&w, &Limits::default()).unwrap(), &Limits::default()).unwrap(),
+            w
+        );
+        assert!(
+            decode_with_encoding(
+                b"\xef\xbb\xbfworld(computedFeatures false)",
+                Encoding::Latin1,
+                &Limits::default()
+            )
+            .is_err()
+        );
+        assert!(
+            decode_with_encoding(
+                input,
+                Encoding::Latin1,
+                &Limits {
+                    max_bytes: input.len(),
+                    ..Limits::default()
+                }
+            )
+            .is_err()
+        );
+        assert!(
+            decode_with_encoding(
+                input,
+                Encoding::Latin1,
+                &Limits {
+                    max_owned_bytes: 1,
+                    ..Limits::default()
+                }
+            )
+            .is_err()
+        );
+    }
+}

crates/mb3-txt/src/lib.rs

@@ -9,6 +9,8 @@
 //! assert_eq!(mb3_txt::decode(&bytes, &Limits::default())?, world);
 //! # Ok::<(), mb3_txt::Error>(())
 //! ```
+mod encoding;
+pub use encoding::{Encoding, decode_with_encoding};
 mod parser;
 mod writer;
 use mb3_dat::Limits;
@@ -23,6 +25,7 @@ pub use writer::encode;
 pub enum ErrorKind {
     Io(io::Error),
     InvalidUtf8,
+    ConflictingBom,
     Syntax(&'static str),
     InvalidNumber,
     NonFinite,
@@ -159,7 +162,14 @@ fn append(out: &mut Vec<u8>, bytes: &[u8], limit: usize) -> Result<()> {
     Ok(())
 }
 /// Bounded buffering, then strict decoding; interrupted and short reads work.
-pub fn read(mut source: impl Read, limits: &Limits) -> Result<mb3_dat::World> {
+pub fn read(source: impl Read, limits: &Limits) -> Result<mb3_dat::World> {
+    read_with_encoding(source, Encoding::Utf8, limits)
+}
+pub fn read_with_encoding(
+    mut source: impl Read,
+    encoding: Encoding,
+    limits: &Limits,
+) -> Result<mb3_dat::World> {
     let mut data = Vec::new();
     let mut chunk = [0; 8192];
     loop {
@@ -176,7 +186,7 @@ pub fn read(mut source: impl Read, limits: &Limits) -> Result<mb3_dat::World> {
         };
         append(&mut data, &chunk[..n], limits.max_bytes)?;
     }
-    decode(&data, limits)
+    decode_with_encoding(&data, encoding, limits)
 }
 /// Validate/encode before touching the destination; does not flush or promise
 /// filesystem atomicity. Later I/O failure can leave a completed prefix.

crates/nanobrush-cli/src/lib.rs

@@ -8,7 +8,7 @@ use std::io::{self, BufRead, BufReader, Write};
 use std::path::{Path, PathBuf};
 use std::sync::atomic::{AtomicU64, Ordering};
 
-const HELP: &str = "nanobrush preflight INPUT --to txt|dat-201501280|dat-201512200 [LIMITS]\nnanobrush inspect INPUT [--from auto|txt|dat] [LIMITS]\nnanobrush validate INPUT [--from auto|txt|dat] [LIMITS]\nnanobrush convert INPUT OUTPUT --to txt|dat-201501280|dat-201512200 [--from auto|txt|dat] [--force] [LIMITS]\nLIMITS: --max-bytes N --max-items N --max-string-bytes N --max-owned-bytes N\nUse -- before positional paths beginning with a dash. TXT input is UTF-8; output has a BOM.\nExit: 0 success/help, 1 invalid data or I/O failure, 2 usage error.\n";
+const HELP: &str = "nanobrush preflight INPUT --to txt|dat-201501280|dat-201512200 [LIMITS]\nnanobrush inspect INPUT [--from auto|txt|dat] [LIMITS]\nnanobrush validate INPUT [--from auto|txt|dat] [LIMITS]\nnanobrush convert INPUT OUTPUT --to txt|dat-201501280|dat-201512200 [--from auto|txt|dat] [--force] [LIMITS]\nLIMITS: --max-bytes N --max-items N --max-string-bytes N --max-owned-bytes N\nTXT option: --text-encoding utf8|latin1 (default utf8).\nUse -- before positional paths beginning with a dash. TXT input is UTF-8; output has a BOM.\nExit: 0 success/help, 1 invalid data or I/O failure, 2 usage error.\n";
 #[derive(Debug)]
 pub struct Error {
     pub usage: bool,
@@ -56,6 +56,7 @@ struct Options {
     to: Option<To>,
     force: bool,
     limits: Limits,
+    encoding: mb3_txt::Encoding,
 }
 fn parse(args: impl IntoIterator<Item = OsString>) -> Result<Option<Options>> {
     let mut args = args.into_iter();
@@ -81,6 +82,7 @@ fn parse(args: impl IntoIterator<Item = OsString>) -> Result<Option<Options>> {
         to: None,
         force: false,
         limits: Limits::default(),
+        encoding: mb3_txt::Encoding::Utf8,
     };
     let mut positional = false;
     let mut seen = std::collections::HashSet::new();
@@ -104,6 +106,7 @@ fn parse(args: impl IntoIterator<Item = OsString>) -> Result<Option<Options>> {
             if !matches!(
                 flag,
                 "--from"
+                    | "--text-encoding"
                     | "--to"
                     | "--max-bytes"
                     | "--max-items"
@@ -119,6 +122,13 @@ fn parse(args: impl IntoIterator<Item = OsString>) -> Result<Option<Options>> {
                 .to_str()
                 .ok_or_else(|| usage("option value must be UTF-8"))?;
             match flag {
+                "--text-encoding" => {
+                    options.encoding = match value {
+                        "utf8" => mb3_txt::Encoding::Utf8,
+                        "latin1" => mb3_txt::Encoding::Latin1,
+                        _ => return Err(usage("--text-encoding requires utf8 or latin1")),
+                    }
+                }
                 "--from" => {
                     options.from = match value {
                         "auto" => InputFormat::Auto,
@@ -175,7 +185,12 @@ struct Input {
     world: World,
     version: Option<Version>,
 }
-fn load(path: &Path, from: InputFormat, limits: &Limits) -> Result<Input> {
+fn load(
+    path: &Path,
+    from: InputFormat,
+    encoding: mb3_txt::Encoding,
+    limits: &Limits,
+) -> Result<Input> {
     let mut file =
         BufReader::new(File::open(path).map_err(|e| fail(format!("{}: {e}", path.display())))?);
     let dat = match from {
@@ -184,6 +199,9 @@ fn load(path: &Path, from: InputFormat, limits: &Limits) -> Result<Input> {
         InputFormat::Auto => file.fill_buf()?.starts_with(b"Mb3World"),
     };
     if dat {
+        if encoding != mb3_txt::Encoding::Utf8 {
+            return Err(fail("--text-encoding latin1 requires TXT input"));
+        }
         let d =
             mb3_dat::read(file, limits).map_err(|e| fail(format!("{}: {e}", path.display())))?;
         Ok(Input {
@@ -191,8 +209,8 @@ fn load(path: &Path, from: InputFormat, limits: &Limits) -> Result<Input> {
             version: Some(d.version),
         })
     } else {
-        let world =
-            mb3_txt::read(file, limits).map_err(|e| fail(format!("{}: {e}", path.display())))?;
+        let world = mb3_txt::read_with_encoding(file, encoding, limits)
+            .map_err(|e| fail(format!("{}: {e}", path.display())))?;
         Ok(Input {
             world,
             version: None,
@@ -295,7 +313,7 @@ pub fn run(args: impl IntoIterator<Item = OsString>, stdout: &mut dyn Write) ->
         stdout.write_all(HELP.as_bytes())?;
         return Ok(());
     };
-    let input = load(&o.paths[0], o.from, &o.limits)?;
+    let input = load(&o.paths[0], o.from, o.encoding, &o.limits)?;
     match o.command.as_str() {
         "preflight" => {
             let target = match o.to.ok_or_else(|| usage("missing --to"))? {

docs/PROGRESS_2026-10-26.md

@@ -5,7 +5,7 @@ Scope: extend native headless formats and geometry. Each stage is independently
 | Stage | TODO | Scope | Status/evidence |
 | --- | --- | --- | --- |
 | 1 | P6.23 | Structured preflight reports | Complete: `preflight INPUT --to FORMAT` emits schema-1 JSON with grouped ASCII/downgrade/duplicate-name incompatibilities; reports never mutate documents. Parser/encoder validation remains authoritative. Unit tests and existing CLI unit regressions pass. |
-| 2 | P6.24 | Explicit Latin-1 TXT input | Pending |
+| 2 | P6.24 | Explicit Latin-1 TXT input | Complete: ISO-8859-1 API and `--text-encoding latin1`, no guessing, conflicting UTF-8 BOM rejected; transcoded bytes and scratch ownership are bounded. UTF-8 remains default and output. Encoding and CLI unit suites pass. |
 | 3 | P6.25 | Bounded computed OBJ writer | Pending |
 | 4 | P6.26 | CLI OBJ with loss acknowledgement | Pending |
 | 5 | P5.15 | Geometry primitives/bounds | Pending |

docs/RUST_TXT.md

@@ -53,3 +53,5 @@ Native Unicode output follows the recovered grammar/encoding contract; a broad n
 - The property-optimization fixture retains `[unused, rare, common]`, while the original CLI emitted `[common, rare]`; Unicode source fixtures retain `é`, while DAT conversion refuses replacement and the historical BOM-less path drifted.
 
 Twelve unit tests cover lexer errors, comments, exponent syntax, escapes/UTF-8, finite extremes, signed zero, proper-prefix truncations, all resource policies, array consistency, streaming I/O, 3,000 bounded deterministic mutations and rejection of recursive-looking syntax. Five integration tests require hydrated E02 fixtures. Coverage-guided fuzzing, large real TXT files, explicit legacy Latin-1 recoding, native-editor interoperability and cross-platform execution remain open. See [E04](experiments/txt-cli-2026-10-21.md) for reproduction.
+
+Explicit legacy input is now available through `Encoding::Latin1`, `decode_with_encoding` and `read_with_encoding`; the CLI uses `--text-encoding latin1`. ISO-8859-1 byte values map directly to Unicode, including C1 controls; this is not CP1252. UTF-8 BOM conflicts fail. Limits apply to raw and expanded UTF-8 bytes, and transcoding storage is subtracted from decoder ownership allowance. Parse error offsets in this mode refer to expanded UTF-8 bytes. Output stays BOM-prefixed UTF-8; no heuristic fallback occurs.

docs/TODO.md

@@ -159,6 +159,8 @@ Each task ID is stable. Split tasks into child IDs as evidence grows. Record dep
 
 - [x] P6.23 Implement grouped, versioned conversion preflight reports for TXT/DAT incompatibilities without mutation ([ten-task ledger](PROGRESS_2026-10-26.md)).
 
+- [x] P6.24 Support explicit bounded ISO-8859-1 TXT input and CLI selection without altering the UTF-8 default or output ([ledger](PROGRESS_2026-10-26.md)).
+
 ## P7 — Input, cameras, grids, views, and editing workflows
 
 **Depends on:** P4 dispatch and P5 geometry. **Exit:** complete interaction/state-machine specifications and reproducible replays.