///|
/// Reusable linear encoding transform for objects with the same source-symbol
/// count. Construction costs a dense solve; each object then needs only matrix
/// products. Useful for repeated fixed-size telemetry or asset blocks.
pub struct EncodingPlan {
  priv source_symbols : Int32
  priv coefficients : Array[Array[Int32]]
}

///|
pub fn EncodingPlan::new(
  source_symbols : Int32,
) -> Result[EncodingPlan, RaptorError] {
  if source_symbols < 1 || source_symbols > 256 {
    return Err(ResourceLimit("encoding plan requires 1..256 source symbols"))
  }
  let p = parameters(source_symbols)
  let matrix = precode(p)
  let rhs = zero_matrix(p.ldpc + p.hdpc, source_symbols)
  for id in 0.. Err(error)
    Ok(None) => Err(InconsistentEquations)
    Ok(Some(coefficients)) => Ok({ source_symbols, coefficients, })
  }
}

///|
pub fn EncodingPlan::source_symbols(self : EncodingPlan) -> Int32 {
  self.source_symbols
}

///|
/// Actual Int32 coefficient storage, excluding array headers and allocator
/// overhead. Plans can be shared across different symbol sizes and objects.
pub fn EncodingPlan::coefficient_bytes(self : EncodingPlan) -> Int32 {
  self.coefficients.length() * self.source_symbols * 4
}

///|
pub fn EncodingPlan::encode(
  self : EncodingPlan,
  data : Bytes,
  symbol_size : Int32,
) -> Result[Encoder, RaptorError] {
  let config = match Config::new(data.length(), symbol_size) {
    Err(error) => return Err(error)
    Ok(config) => config
  }
  if config.source_symbols != self.source_symbols {
    return Err(
      InvalidParameters("object source-symbol count differs from plan"),
    )
  }
  let source = zero_matrix(self.source_symbols, symbol_size)
  for id in 0..