nc-gcode-interpreter 0.2.8__tar.gz → 0.2.10__tar.gz

{nc_gcode_interpreter-0.2.8 → nc_gcode_interpreter-0.2.10}/.github/workflows/build-and-release.yml

@@ -80,7 +80,7 @@ jobs:
         uses: PyO3/maturin-action@v1
         with:
           target: ${{ matrix.platform.target }}
-          args: --release --out dist --find-interpreter
+          args: --release --out dist -i python3.12 -i python3.13 -i python3.14 -i python3.14t -i python3.15 -i python3.15t
           sccache: 'true'
           manylinux: auto
       - name: Upload wheels
@@ -156,7 +156,9 @@ jobs:
         uses: PyO3/maturin-action@v1
         with:
           target: ${{ matrix.platform.target }}
-          args: --release --out dist --find-interpreter
+          # Every wheel job names its interpreters (the set 0.2.8 shipped per platform):
+          # --find-interpreter picks up whatever the image has, e.g. PyPy, which fails.
+          args: --release --out dist -i python3.12 -i python3.13 -i python3.14 -i python3.14t
           sccache: 'true'
           manylinux: auto
       - name: Upload wheels
@@ -214,7 +216,7 @@ jobs:
         uses: PyO3/maturin-action@v1
         with:
           target: ${{ matrix.platform.target }}
-          args: --release --out dist --find-interpreter
+          args: --release --out dist -i python3.12 -i python3.13 -i python3.14
           sccache: 'true'
       - name: Upload wheels
         uses: actions/upload-artifact@v4
@@ -254,7 +256,7 @@ jobs:
         uses: PyO3/maturin-action@v1
         with:
           target: ${{ matrix.platform.target }}
-          args: --release --out dist --find-interpreter
+          args: --release --out dist -i python3.12 -i python3.13 -i python3.14 -i python3.15
           sccache: 'true'
       - name: Upload wheels
         uses: actions/upload-artifact@v4
@@ -303,7 +305,7 @@ jobs:
       contents: write
       attestations: write
     steps:
-      # Do NOT use `merge-multiple: true`. With `--find-interpreter`, every
+      # Do NOT use `merge-multiple: true`. With a shared interpreter list, every
       # build matrix leg (py3.12 AND py3.13) produces cp312/cp313/cp314 wheels
       # with identical filenames but non-identical bytes (sccache makes builds
       # nondeterministic). Merging them into one directory makes

{nc_gcode_interpreter-0.2.8 → nc_gcode_interpreter-0.2.10}/CHANGELOG.md

@@ -4,6 +4,66 @@ Notable changes to **nc-gcode-interpreter**. The format loosely follows
 [Keep a Changelog](https://keepachangelog.com/); versions are git tags,
 released to PyPI.
 
+## [v0.2.10] - 2026-11-10
+
+### Changed
+
+- `nc_to_batches` and `nc_to_dataframe` do less work per output row. The
+  G-group columns are held as per-batch dictionary codes and written straight
+  to the Arrow string array, instead of one `String` per row per column that
+  the consumer thread then freed; the batch builder finds a cell's column
+  without hashing its name; the streaming driver reuses its decode buffers.
+  Python output is unchanged (same columns, `String` dtype, values and
+  `variable_events`). With `flatten_tolerance`, line numbers and variables on,
+  a 7.2M-row, 442 MiB linear program takes 3.3 s instead of 8.3 s and a
+  22M-row, 1.1 GB program 10.5 s instead of 24 s, at the same peak memory
+  (#89).
+
+- `flatten_tolerance` costs almost nothing on rows that are not curves: the
+  flattener tracked positions with an allocation and a lookup per configured
+  axis for every row, about 2 s on the 7.2M-row program above, now about
+  0.15 s. B-spline flattening reuses one working buffer per curve; a
+  5.4M-row, 380 MB spline program takes 8 s instead of 16 s (#89).
+
+- Rust API: `Column` has a new `Dict(DictColumn)` variant, used for the
+  G-group columns (`values` plus one `u32` code per row,
+  `DictColumn::NULL` for a null cell). Code that matches `Column`
+  exhaustively needs one more arm; `DictColumn::iter` yields the cells as
+  `Option<&str>` (#89).
+
+### Fixed
+
+- A numeric tool selection (`T2`, `T=3`, `T=R1`) now reaches the output table.
+  It is written to the same string `T` column as `T="name"`, as the number's
+  text (`"2"`), on the row of the block that programs it. Before, only named
+  tools appeared and a numeric one was dropped without a warning. The value is
+  still stored as the variable `T` in the final state, as before (#101).
+
+## [v0.2.9] - 2026-11-01
+
+### Changed
+
+- `nc_to_batches` and `nc_to_rows` borrow the Python str's UTF-8 buffer for
+  the run instead of copying it twice (once into a Rust `String`, once more
+  for error messages). On a 5M-line, 322 MB program the peak footprint of
+  `nc_to_batches` drops from 1.28 to 0.72 GiB. The Rust entry points
+  (`nc_to_table`, `nc_to_row_stream`, `nc_to_batch_stream*`) take
+  `impl Into<SourceText>`: a `&str` still works and is copied once, an owned
+  `String` or `Arc<str>` is shared without a copy (#89).
+
+- Every jump-free program now runs on the streaming line driver, not only
+  those of 64 MiB or more, and the streaming driver decodes ahead on a second
+  thread instead of decoding inline. On a 1M-line, 63 MB program
+  `nc_to_batches` peaks at 0.21 GiB instead of 0.60 GiB and takes 1.02 s
+  instead of 1.24 s; at 5M lines it takes 5.1 s instead of 6.3 s. Programs
+  with jumps keep the indexed driver; `NC_STREAM_MIN_BYTES` still sets a size
+  threshold (#89).
+
+- Less work per output row on the interpreter thread: the batch builder moves
+  string cells out of the rows it recycles instead of cloning them, and the
+  per-row column set and the flattener's position maps hash with FxHash. At
+  5M lines `nc_to_batches` takes 4.4 s instead of 5.2 s (#89).
+
 ## [v0.2.8] - 2026-10-15
 
 ### Added

{nc_gcode_interpreter-0.2.8 → nc_gcode_interpreter-0.2.10}/Cargo.lock

@@ -506,7 +506,7 @@ checksum = "88904434abc2901f197fe8cc55f0445e7ded921dba5911dad2e2b39b48e663c4"
 
 [[package]]
 name = "nc-gcode-interpreter"
-version = "0.2.8"
+version = "0.2.10"
 dependencies = [
  "arrow-array",
  "arrow-data",

{nc_gcode_interpreter-0.2.8 → nc_gcode_interpreter-0.2.10}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nc-gcode-interpreter"
-version = "0.2.8"
+version = "0.2.10"
 edition = "2021"
 readme = "README.md"
 

{nc_gcode_interpreter-0.2.8 → nc_gcode_interpreter-0.2.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nc-gcode-interpreter
-Version: 0.2.8
+Version: 0.2.10
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: 3.12

{nc_gcode_interpreter-0.2.8 → nc_gcode_interpreter-0.2.10}/README.md

@@ -161,23 +161,24 @@ for line_no, row, variables in nc_to_rows(program, include_variables=True):
 
 Rows are typed and forward-filled like the batch DataFrame (disable with `forward_fill=False`); errors raise from `next()` at the offending row; after exhaustion the iterator's `state` attribute holds the final interpreter state. See `python/example/streaming.py` for a runnable version.
 
-**Memory.** Programs of 64 MiB or more without multi-line control blocks or
-jumps are validated in a parallel preflight scan and then executed one line at a
-time, so parse storage is bounded by the longest line instead of the program
-length. The input text, its diagnostic copy and line-offset index, variable
-state and any output the caller retains still grow with the program, so use
-`nc_to_batches` with a bounded consumer for large files. Smaller programs and
-programs with jumps keep the indexed fast path; `NC_STREAM_MIN_BYTES` sets the
-threshold in bytes (0 streams every jump-free program). Control blocks and
-`NC_STAGE1=0` still use the whole-file parser. On a 1.28M-line (112 MB) field
-program the peak RSS of `nc_to_batches` drops from about 1.3 GiB to 0.4 GiB,
-and the second decode during execution costs up to about 20 percent of
-interpretation time. Measure a local program with
+**Memory.** Programs without multi-line control blocks or jumps are validated
+in a preflight scan and then executed one line at a time, with the next lines
+decoded on a second thread, so parse storage is bounded by a chunk of lines
+instead of the program length. The input text (held once: the Python str is
+borrowed, not copied, and error messages read from the same buffer), its
+line-offset index, variable state and any output the caller retains still grow
+with the program, so use `nc_to_batches` with a bounded consumer for large
+files. Programs with jumps keep the indexed fast path; `NC_STREAM_MIN_BYTES`
+sets a size below which jump-free programs take it too (default 0). Control
+blocks and `NC_STAGE1=0` still use the whole-file parser. On a 1M-line (63 MB)
+generated program the peak footprint of `nc_to_batches` is about 0.2 GiB, and
+streaming is 5 to 20 percent faster than the indexed driver from 1 MB up.
+Measure a local program with
 `python scripts/benchmark.py --input <file> --modes fresh --edits none
 --threads 4 --samples 1 --batch-size 4096 --allow-undefined --axis-index-e 4
 --axis-index-elx 5 --output tmp/memory.json`.
 
-**Cancellation.** Dropping the iterator is the supported way to cancel a `nc_to_rows`/`nc_to_batches` run — leaving a `for` loop early or `del`-ing it drops it immediately; relying on garbage collection works too but only whenever the runtime happens to collect it, so it is not prompt on all interpreters: the background interpreter thread's next attempt to send a row hits a closed channel and returns internally via `ParsingError::StreamClosed`, so the thread unwinds promptly instead of running the rest of the program to completion. No explicit `.close()`/`.cancel()` call is needed or provided — drop is the whole contract, and downstreams (e.g. ribweaver's `/sim` live-edit reinterpret) rely on it for latest-wins cancellation.
+**Cancellation.** Dropping the iterator is the supported way to cancel a `nc_to_rows`/`nc_to_batches` run — leaving a `for` loop early or `del`-ing it drops it immediately; relying on garbage collection works too but only whenever the runtime happens to collect it, so it is not prompt on all interpreters: the background interpreter thread's next attempt to send a row hits a closed channel and returns internally via `ParsingError::StreamClosed`, so the thread unwinds promptly instead of running the rest of the program to completion. No explicit `.close()`/`.cancel()` call is needed or provided — drop is the whole contract, and downstreams (for example a live-edit re-interpret in an editor) rely on it for latest-wins cancellation.
 
 Additionally, conversion from a Polars DataFrame back to an MPF (NC) program is also supported:
 

{nc_gcode_interpreter-0.2.8 → nc_gcode_interpreter-0.2.10}/docs/resumable-interpretation-design.md

@@ -15,7 +15,7 @@ Expose a resumable interpretation handle:
 - `resume(token, patched_text)` — restart interpretation from a checkpoint,
   against an edited program.
 
-Consumer: ribweaver `/sim` phase-E *incremental re-interpret* for multi-million-row
+Consumer: a live-edit *incremental re-interpret* in a G-code editor, for multi-million-row
 loop expansions. When the user edits source line *L*, it resumes from the last
 checkpoint whose block cursor precedes *L* instead of re-running the whole program.
 Downstream is evidence-gated: debounced-full re-interpret is fine below ~10⁵ rows,

{nc_gcode_interpreter-0.2.8 → nc_gcode_interpreter-0.2.10}/python/tests/test_batches.py

@@ -208,3 +208,20 @@ def test_include_line_numbers_survives_flattening():
     assert per_line.count(2) > 5
     stream_lines = [line for line, *_ in nc_to_rows(program, flatten_tolerance=0.1)]
     assert per_line == stream_lines
+
+
+def test_g_group_columns_stay_plain_strings():
+    # The interpreter holds G-group columns as dictionary codes internally;
+    # Python must keep seeing String columns with the same values.
+    program = "G1 G64 X1\nX2\nG4 F0.5\nG0 X3\nG17 X4\nM30\n"
+    frames = list(nc_to_batches(program, batch_size=2))
+    assert [f.height for f in frames] == [2, 2, 2]
+    for frame in frames:
+        for name in frame.columns:
+            if name.startswith("gg"):
+                assert frame[name].dtype == pl.String, name
+    df = pl.concat(frames, how="diagonal")
+    assert df["gg01_motion"].to_list() == ["G1", "G1", "G1", "G0", "G0", "G0"]
+    assert df["gg10_exact_stop_mode"].to_list() == ["G64"] * 6
+    assert df["gg02_wait"].to_list() == [None, None, "G4", None, None, None]
+    assert df["gg06_plane_select"].to_list() == [None, None, None, None, "G17", "G17"]

{nc_gcode_interpreter-0.2.8 → nc_gcode_interpreter-0.2.10}/python/tests/test_stage1.py

@@ -159,3 +159,20 @@ def test_fast_path_matches_on_real_corpus(mpf):
         extra_axes=["ELX"],
         allow_undefined_variables=True,
     )
+
+
+@pytest.mark.parametrize(
+    "program, expected",
+    [
+        ("G1 X0\nT2\nX1", [None, "2", None]),
+        ("G1 X0\nT=3\nX1", [None, "3", None]),
+        ("G1 X0\nt4\nX1", [None, "4", None]),
+        ("R1=7\nG1 X0\nT=R1\nX1", [None, "7", None]),
+        ('G1 X0\nT="NOZ_A"\nT5 X1', [None, "NOZ_A", "5"]),
+    ],
+    ids=["T2", "T=3", "lowercase", "expression", "mixed with a named tool"],
+)
+def test_numeric_tool_selection_reaches_the_t_column(program, expected):
+    """A numeric tool selection lands in the same string T column as a named one (#101)."""
+    df = run_both(program)
+    assert df["T"].to_list() == expected

{nc_gcode_interpreter-0.2.8 → nc_gcode_interpreter-0.2.10}/src/flatten.rs

@@ -67,7 +67,7 @@
 //!   than being misread).
 
 use crate::errors::ParsingError;
-use crate::output::{intern_column, CellMap, Row, FLATTENED_COLUMN};
+use crate::output::{intern_column, key_eq, CellMap, Row, FLATTENED_COLUMN};
 use crate::state::emit_warning;
 use crate::types::Value;
 use std::collections::HashMap;
@@ -135,8 +135,9 @@ pub struct Flattener {
     /// Geometric axis columns (configured axis identifiers minus the
     /// non-geometric value columns), interned.
     geometric_axes: Vec<&'static str>,
-    /// Last known machine coordinate per geometric axis column.
-    positions: HashMap<&'static str, f64>,
+    /// Last known machine coordinate per geometric axis, indexed like
+    /// `geometric_axes` (a row updates a few slots, with no hashing).
+    positions: Vec<Option<f64>>,
     motion: Motion,
     plane: Plane,
     /// Buffered blocks of the active spline, in program order. Non-empty
@@ -144,7 +145,7 @@ pub struct Flattener {
     spline_buffer: Vec<SplineItem>,
     /// Snapshot of `positions` taken when the spline was selected: the
     /// spline's start point.
-    spline_start: HashMap<&'static str, f64>,
+    spline_start: Vec<Option<f64>>,
     /// Current B-spline degree (`SD=`, modal within the spline).
     spline_degree: usize,
     /// Curve motion words already warned about (CIP, CT, POLY, ...): one
@@ -159,8 +160,8 @@ impl Flattener {
     /// point even though the interpreter does.
     pub fn seed_position(&mut self, axis: &str, machine_value: f64) {
         let key = intern_column(&axis.to_uppercase());
-        if self.geometric_axes.contains(&key) {
-            self.positions.insert(key, machine_value);
+        if let Some(slot) = self.axis_slot(key) {
+            self.positions[slot] = Some(machine_value);
         }
     }
 
@@ -170,7 +171,7 @@ impl Flattener {
                 message: format!("flatten tolerance must be a positive number, got {}", tolerance),
             });
         }
-        let geometric_axes = axis_identifiers
+        let geometric_axes: Vec<&'static str> = axis_identifiers
             .iter()
             .map(|a| a.to_uppercase())
             .filter(|a| !NON_GEOMETRIC_AXES.contains(&a.as_str()))
@@ -178,12 +179,12 @@ impl Flattener {
             .collect();
         Ok(Flattener {
             tolerance,
+            positions: vec![None; geometric_axes.len()],
             geometric_axes,
-            positions: HashMap::new(),
             motion: Motion::Linear,
             plane: G17,
             spline_buffer: Vec::new(),
-            spline_start: HashMap::new(),
+            spline_start: Vec::new(),
             spline_degree: 3,
             warned_motions: Vec::new(),
         })
@@ -201,7 +202,7 @@ impl Flattener {
             }
             self.motion = new_motion;
         }
-        if let Some(Value::Str(plane)) = row.cells.get(intern_column("gg06_plane_select")) {
+        if let Some(Value::Str(plane)) = row.cells.get("gg06_plane_select") {
             self.plane = match plane.as_str() {
                 "G18" => G18,
                 "G19" => G19,
@@ -215,7 +216,7 @@ impl Flattener {
                     self.spline_start = self.positions.clone();
                     self.spline_degree = 3;
                 }
-                if let Some(Value::Float(sd)) = row.cells.get(intern_column("SD")) {
+                if let Some(Value::Float(sd)) = row.cells.get("SD") {
                     self.spline_degree = (*sd as usize).max(1);
                 }
                 let has_point = self
@@ -266,10 +267,23 @@ impl Flattener {
         !self.spline_buffer.is_empty()
     }
 
+    /// Index of `name` in `geometric_axes`.
+    fn axis_slot(&self, name: &str) -> Option<usize> {
+        self.geometric_axes.iter().position(|&axis| key_eq(axis, name))
+    }
+
+    /// Last known machine coordinate of a geometric axis.
+    fn position(&self, axis: &str) -> Option<f64> {
+        self.axis_slot(axis).and_then(|slot| self.positions[slot])
+    }
+
     fn track_positions(&mut self, row: &Row) {
-        for &axis in &self.geometric_axes {
-            if let Some(Value::Float(v)) = row.cells.get(axis) {
-                self.positions.insert(axis, *v);
+        // Walk the row's few cells, not every configured axis.
+        for (&key, value) in row.cells.iter() {
+            if let Value::Float(v) = value {
+                if let Some(slot) = self.axis_slot(key) {
+                    self.positions[slot] = Some(*v);
+                }
             }
         }
     }
@@ -309,7 +323,7 @@ impl Flattener {
             return;
         }
 
-        let (Some(su), Some(sv)) = (self.positions.get(u_axis).copied(), self.positions.get(v_axis).copied()) else {
+        let (Some(su), Some(sv)) = (self.position(u_axis), self.position(v_axis)) else {
             self.pass_through_with_warning(row, "arc start position is unknown", out);
             return;
         };
@@ -411,8 +425,8 @@ impl Flattener {
                 continue;
             }
             if let Some(end) = cell_float(&row, axis) {
-                let start = match self.positions.get(axis) {
-                    Some(&start) => start,
+                let start = match self.position(axis) {
+                    Some(start) => start,
                     None => {
                         // First-ever position of this axis: there is nothing
                         // to ramp from, so the channel holds its end value
@@ -501,17 +515,19 @@ impl Flattener {
         let mut current: Vec<f64> = channels
             .iter()
             .map(|&c| {
-                start.get(c).copied().unwrap_or_else(|| {
-                    // Channel never positioned before the spline: start it at
-                    // its first programmed value (a zero-length lead-in).
-                    items
-                        .iter()
-                        .find_map(|item| match item {
-                            SplineItem::Point(row) => cell_float(row, c),
-                            _ => None,
-                        })
-                        .unwrap_or(0.0)
-                })
+                self.axis_slot(c)
+                    .and_then(|slot| start.get(slot).copied().flatten())
+                    .unwrap_or_else(|| {
+                        // Channel never positioned before the spline: start it at
+                        // its first programmed value (a zero-length lead-in).
+                        items
+                            .iter()
+                            .find_map(|item| match item {
+                                SplineItem::Point(row) => cell_float(row, c),
+                                _ => None,
+                            })
+                            .unwrap_or(0.0)
+                    })
             })
             .collect();
         points.push(current.clone());
@@ -659,7 +675,7 @@ fn points_value(points: &[Vec<f64>], point_rows: &[Option<usize>], item_index: u
 }
 
 fn row_motion(row: &Row) -> Option<Motion> {
-    match row.cells.get(intern_column("gg01_motion")) {
+    match row.cells.get("gg01_motion") {
         Some(Value::Str(m)) => Some(match m.as_str() {
             "G0" | "G1" => Motion::Linear,
             "G2" => Motion::Arc { cw: true },
@@ -956,6 +972,9 @@ struct BSpline {
     knots: Vec<f64>,
     ctrl: Vec<Vec<f64>>,
     channels: usize,
+    /// de Boor working rows, `(p + 1) * (channels + 1)` values, reused by
+    /// every `eval` (the flattener evaluates several times per control point).
+    scratch: std::cell::RefCell<Vec<f64>>,
 }
 
 impl BSpline {
@@ -984,6 +1003,7 @@ impl BSpline {
             knots,
             ctrl,
             channels: points[0].len(),
+            scratch: std::cell::RefCell::new(Vec::new()),
         }
     }
 
@@ -998,7 +1018,13 @@ impl BSpline {
         } else {
             p + t as usize
         };
-        let mut d: Vec<Vec<f64>> = (0..=p).map(|j| self.ctrl[j + k - p].clone()).collect();
+        // Row j of `d` is control point j + k - p.
+        let width = channels + 1;
+        let mut d = self.scratch.borrow_mut();
+        d.clear();
+        for j in 0..=p {
+            d.extend_from_slice(&self.ctrl[j + k - p]);
+        }
         for r in 1..=p {
             for j in (r..=p).rev() {
                 let i = j + k - p;
@@ -1008,17 +1034,14 @@ impl BSpline {
                 } else {
                     (t - knots[i]) / denom
                 };
-                // Indexing two rows of `d` at once: a plain indexed loop is
-                // clearer than a split_at_mut dance.
-                #[allow(clippy::needless_range_loop)]
                 for c in 0..=channels {
-                    let previous = d[j - 1][c];
-                    d[j][c] = (1.0 - alpha) * previous + alpha * d[j][c];
+                    let previous = d[(j - 1) * width + c];
+                    d[j * width + c] = (1.0 - alpha) * previous + alpha * d[j * width + c];
                 }
             }
         }
-        let w = d[p][channels];
-        d[p][..channels].iter().map(|v| v / w).collect()
+        let w = d[p * width + channels];
+        d[p * width..p * width + channels].iter().map(|v| v / w).collect()
     }
 
     /// Greville abscissa of control point `i`, the mean of the `p` knots

{nc_gcode_interpreter-0.2.8 → nc_gcode_interpreter-0.2.10}/src/interpret_rules.rs

@@ -2514,6 +2514,9 @@ fn interpret_statement(element: Pair<Rule>, output: &mut Output, state: &mut Sta
                     }
                     None => {
                         state.warn_unsupported_address(&key, line_no);
+                        if key.eq_ignore_ascii_case("T") {
+                            last.insert("T", Value::Str(crate::output::tool_number_text(local_value)));
+                        }
                         output.record_variable_change(&key, local_value);
                     }
                 }

{nc_gcode_interpreter-0.2.8 → nc_gcode_interpreter-0.2.10}/src/interpreter.rs

@@ -6,6 +6,54 @@ use crate::state::{self, State};
 use crate::types::{NCParser, Rule};
 use pest::Parser;
 use std::collections::HashMap;
+use std::sync::Arc;
+
+/// Program text shared between the driver that interprets it and the state's
+/// diagnostics, so a run holds a single copy of the source. Converting from a
+/// `&str` copies once; an owned `String`, an `Arc<str>` or any other
+/// [`SourceText::new`] buffer is shared as is.
+#[derive(Clone)]
+pub struct SourceText(Arc<dyn AsRef<str> + Send + Sync>);
+
+impl SourceText {
+    pub fn new<T: AsRef<str> + Send + Sync + 'static>(text: T) -> Self {
+        SourceText(Arc::new(text))
+    }
+
+    pub fn as_str(&self) -> &str {
+        (*self.0).as_ref()
+    }
+}
+
+impl std::fmt::Debug for SourceText {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("SourceText").field("len", &self.as_str().len()).finish()
+    }
+}
+
+impl From<&str> for SourceText {
+    fn from(text: &str) -> Self {
+        SourceText(Arc::new(Box::<str>::from(text)))
+    }
+}
+
+impl From<&String> for SourceText {
+    fn from(text: &String) -> Self {
+        SourceText::from(text.as_str())
+    }
+}
+
+impl From<String> for SourceText {
+    fn from(text: String) -> Self {
+        SourceText::new(text)
+    }
+}
+
+impl From<Arc<str>> for SourceText {
+    fn from(text: Arc<str>) -> Self {
+        SourceText::new(text)
+    }
+}
 
 const DEFAULT_AXIS_IDENTIFIERS: &[&str] = &[
     "N", "X", "Y", "Z", "A", "B", "C", "D", "E", "F", "S", "U", "V", "RA1", "RA2", "RA3", "RA4", "RA5", "RA6",
@@ -13,7 +61,7 @@ const DEFAULT_AXIS_IDENTIFIERS: &[&str] = &[
 
 /// Main function: interpret the input program into a sanitized output table.
 pub fn nc_to_table(
-    input: &str,
+    input: impl Into<SourceText>,
     initial_state: Option<&str>,
     axis_identifiers: Option<Vec<String>>,
     extra_axes: Option<Vec<String>>,
@@ -41,7 +89,7 @@ pub fn nc_to_table(
     // Now interpret the main input using the axis_index_map from state
     let mut output = OutputRows::collect();
     install_flattener(&mut output, &state, flatten_tolerance)?;
-    interpret_file(input, &mut state, &mut output)?;
+    interpret_source(input.into(), &mut state, &mut output)?;
     let rows = output.finish()?;
 
     let table = Table::from_rows(&rows, disable_forward_fill);
@@ -104,7 +152,7 @@ fn install_flattener(
 #[allow(clippy::too_many_arguments)]
 #[allow(dead_code)] // used by the python-feature bindings, not the bin
 pub fn nc_to_row_stream(
-    input: &str,
+    input: impl Into<SourceText>,
     initial_state: Option<&str>,
     axis_identifiers: Option<Vec<String>>,
     extra_axes: Option<Vec<String>>,
@@ -127,7 +175,7 @@ pub fn nc_to_row_stream(
     }
     let mut output = OutputRows::stream(sender);
     install_flattener(&mut output, &state, flatten_tolerance)?;
-    interpret_file(input, &mut state, &mut output)?;
+    interpret_source(input.into(), &mut state, &mut output)?;
     output.finish()?;
     Ok(state)
 }
@@ -145,7 +193,7 @@ pub fn nc_to_row_stream(
 #[allow(dead_code)] // used by the python-feature bindings, not the bin
 #[allow(clippy::too_many_arguments)]
 pub fn nc_to_batch_stream(
-    input: &str,
+    input: impl Into<SourceText>,
     initial_state: Option<&str>,
     axis_identifiers: Option<Vec<String>>,
     extra_axes: Option<Vec<String>>,
@@ -183,7 +231,7 @@ pub fn nc_to_batch_stream(
 /// callers.
 #[allow(clippy::too_many_arguments)]
 pub fn nc_to_batch_stream_with_line_numbers(
-    input: &str,
+    input: impl Into<SourceText>,
     initial_state: Option<&str>,
     axis_identifiers: Option<Vec<String>>,
     extra_axes: Option<Vec<String>>,
@@ -218,15 +266,20 @@ pub fn nc_to_batch_stream_with_line_numbers(
         emit_line_no,
     );
     install_flattener(&mut output, &state, flatten_tolerance)?;
-    interpret_file(input, &mut state, &mut output)?;
+    interpret_source(input.into(), &mut state, &mut output)?;
     output.finish()?;
     Ok(state)
 }
 
 /// Interpret a file, pushing rows into `output`.
 fn interpret_file(input: &str, state: &mut State, output: &mut OutputRows) -> Result<(), ParsingError> {
-    // Store input for error messages
-    state.set_input(input);
+    interpret_source(SourceText::from(input), state, output)
+}
+
+/// As [`interpret_file`], sharing `source` with the state's diagnostics.
+fn interpret_source(source: SourceText, state: &mut State, output: &mut OutputRows) -> Result<(), ParsingError> {
+    state.set_source(source.clone());
+    let input = source.as_str();
 
     // Validate control-structure nesting first: a PEG reports an unclosed
     // IF/WHILE at the end of the file; the line scan reports the opener.
@@ -698,6 +751,32 @@ mod tests {
             .unwrap_or_else(|| panic!("column {name} missing; have {:?}", column_names(table)))
     }
 
+    /// An owned program is shared with the state's diagnostics, not copied.
+    #[test]
+    fn owned_source_is_shared_with_diagnostics() {
+        let program = String::from("G1 X0 Y0 F100\nX10 Y=\n");
+        let ptr = program.as_ptr();
+        let source = SourceText::from(program);
+        assert_eq!(source.as_str().as_ptr(), ptr);
+        let mut state = build_state(None, None, 10000, None, false);
+        state.set_source(source.clone());
+        assert_eq!(state.get_line(2), Some("X10 Y="));
+        assert_eq!(state.get_line(2).unwrap().as_ptr(), source.as_str()[14..].as_ptr());
+        let err = nc_to_table(
+            String::from("G1 X0\nX10 Y=\n"),
+            None,
+            None,
+            None,
+            10000,
+            false,
+            None,
+            false,
+            None,
+        )
+        .expect_err("a dangling assignment does not parse");
+        assert!(err.to_string().contains("X10 Y="), "{err}");
+    }
+
     /// `include_line_numbers` (default off) prepends a `line_no` column: one
     /// 1-based source line per output row, repeated under a loop and
     /// non-monotonic across a jump - matching what `nc_to_rows` yields.
@@ -1399,6 +1478,7 @@ mod tests {
         let strs = |name: &str| -> Vec<Option<String>> {
             match &table.columns.iter().find(|(n, _)| n == name).unwrap().1 {
                 Column::Str(v) => v.clone(),
+                Column::Dict(v) => v.iter().map(|cell| cell.map(str::to_string)).collect(),
                 other => panic!("column {name} is not a str column: {other:?}"),
             }
         };