Troubles building the documentation

[m57-prot]

Hello,

Just as a first warning, I am completely new to Julia programming.

OS: Linux
Julia ver. 1.12.3

1. Steps to recreate the issue:
1.a. After launching Julia in terminal, I created a separate environment for ControlSystems-related stuff using Pkg.activate("ControlSystems_env")
1.b. changed to the docs directory: cd("<.../docs/>")
1.c. Run include("make.jl")
1.d. Wanted then to build the documentation to follow the tutorials offline, but after a few unsuccessful attempts found that many required dependencies were missing, and installing ControlSystems, ControlSystemsBase and ControlSystemsMTK does not pull those packages:

 - ForwardDiff 
 - ImplicitDifferentiation 
 - ComponentArrays 
 - MonteCarloMeasurements
 - Optimization 
 - OptimizationMOI
 - StaticArrays
 - GLMakie (or CairoMakie, or WGLMakie)
 - SymbolicControlSystems
 - TrajectoryLimiters
 - LinearAlgebra
 - Ipopt
 - DSP
 - ModelingToolkit

2. Trying to install that bunch of the packages just made things worse due to inability to precompile some of those, as some of them may refer to

3. Many keywords unsupported by Plots(?)

Click

┌ Warning: Keyword argument hover not supported with Plots.GRBackend().  
Choose from: annotationcolor, annotationfontfamily, annotationfontsize, 
annotationhalign, annotationrotation, annotations, annotationvalign, 
arrow, aspect_ratio, axis, background_color, background_color_inside, 
background_color_outside, background_color_subplot, bar_width, bins, bottom_margin, camera, clims, color_palette, colorbar, colorbar_entry, colorbar_scale, colorbar_title, 
colorbar_titlefont, colorbar_titlefontcolor, colorbar_titlefontrotation, 
colorbar_titlefontsize, connections, contour_labels, discrete_values, fill, 
...
...
...
zminorgridstyle, zminorticks, zmirror, zrotation, zscale, zshowaxis, ztick_direction, 
ztickfontcolor, ztickfontfamily, ztickfonthalign, ztickfontrotation, ztickfontsize, 
ztickfontvalign, zticks, zunitformat, zwiden
└ @ Plots ~/.julia/packages/Plots/pxXHF/src/args.jl:1563

4. Also get a lot of warnings about missing docstrings:

...
 Warning: Cannot resolve @ref for md"[`sigmaplot`](@ref)" in ../../../../../..localst/Julia/ControlSystems.jl/docs/src/lib/timefreqresponse.md.
│ - No docstring found in doc for binding `ControlSystemsBase.sigmaplot`.
└ @ Documenter ~/.julia/packages/Documenter/xvqbW/src/utilities/utilities.jl:49
┌ Warning: Cannot resolve @ref for md"[`nyquistplot`](@ref)" in ../../../../../..localst/Julia/ControlSystems.jl/docs/src/lib/timefreqresponse.md.
│ - No docstring found in doc for binding `ControlSystemsBase.nyquistplot`.
└ @ Documenter ~/.julia/packages/Documenter/xvqbW/src/utilities/utilities.jl:49
┌ Warning: Cannot resolve @ref for md"[`marginplot`](@ref)" in ../../../../../..localst/Julia/ControlSystems.jl/docs/src/lib/timefreqresponse.md.
│ - No docstring found in doc for binding `ControlSystemsBase.marginplot`.
└ @ Documenter ~/.julia/packages/Documenter/xvqbW/src/utilities/utilities.jl:49
...

5. Missing dosctrings:

Click

┌ Warning: 189 docstrings not included in the manual:
│ 
│     LinearAlgebra.norm :: Union{Tuple{AbstractStateSpace}, Tuple{AbstractStateSpace, Real}}
│     ControlSystemsBase.balance :: Union{Tuple{Any}, Tuple{Any, Bool}}
│     ControlSystemsBase.pzmap
│     ControlSystemsBase.DemoSystems.fotd :: Tuple{}
│     ControlSystemsBase.convert_pidparams_to_parallel :: Tuple{Any, Any, Any, Symbol}
│     ControlSystemsBase.c2d_roots2poly :: Tuple{Any, Any}
│     ControlSystemsBase.gram :: Tuple{AbstractStateSpace, Symbol}
│     ControlSystemsBase.sensitivity :: Tuple
│     ControlSystemsBase.count_integrators :: Tuple{LTISystem}
│     ControlSystemsBase.freqresp :: Union{Tuple{W}, Tuple{LTISystem, AbstractVector{W}}} where W<:Real
│     ControlSystemsBase.DelayLtiSystem :: Union{Tuple{StateSpace}, Tuple{S}, Tuple{T}, Tuple{StateSpace, AbstractVector{S}}} where {T<:Number, S<:Real}
│     ControlSystemsBase.DelayLtiSystem
│     ControlSystemsBase.sisomargin :: Tuple{LTISystem, AbstractVector{<:Real}}
│     ControlSystemsBase.balreal :: Tuple{ST} where ST<:AbstractStateSpace
│     Base.step :: Tuple{AbstractStateSpace, AbstractVector}
│     ControlSystems._equation_order :: Tuple{Any}
│     ControlSystemsBase._to1series :: Tuple{Any, Any}
│     ControlSystemsBase.G_CS :: Tuple{Any, Any}
│     ControlSystemsBase.struct_ctrb_states :: Tuple{AbstractVecOrMat, AbstractVecOrMat}
│     ControlSystemsBase.gangoffour :: Tuple{LTISystem, LTISystem}
│     ControlSystemsBase.observability :: Union{Tuple{T}, Tuple{AbstractMatrix{T}, Any}} where T
│     ControlSystemsBase.rgaplot
│     ControlSystemsBase.convert_pidparams_from_standard :: Tuple{Any, Any, Any, Symbol}
│     ControlSystemsBase.DemoSystems.lag :: Tuple{}
│     ControlSystemsBase.gangoffourplot :: Tuple{Union{LTISystem, Vector}, Vector, Vararg{Any}}
│     ControlSystemsBase.observer_predictor :: Tuple{AbstractStateSpace, Any, Union{AbstractArray, UniformScaling}, Vararg{Any}}
│     ControlSystemsBase.evalfr :: Tuple{AbstractStateSpace, Number}
│     ControlSystemsBase.DemoSystems.resonant :: Tuple{}
│     ControlSystemsBase.dcgain :: Union{Tuple{LTISystem}, Tuple{LTISystem, Any}}
│     ControlSystemsBase.d2c :: Union{Tuple{AbstractStateSpace{<:Discrete}}, Tuple{AbstractStateSpace{<:Discrete}, Symbol}}
│     ControlSystemsBase.d2c :: Union{Tuple{AbstractStateSpace{<:Discrete}, AbstractMatrix}, Tuple{AbstractStateSpace{<:Discrete}, AbstractMatrix, Union{Nothing, AbstractMatrix}}}
│     ControlSystemsBase.diagonalize :: Tuple{AbstractStateSpace}
│     ControlSystemsBase.leadlinkcurve
│     ControlSystemsBase.lsim :: Tuple{AbstractStateSpace, AbstractVecOrMat, AbstractVector}
│     ControlSystemsBase.similarity_transform :: Union{Tuple{ST}, Tuple{ST, Any}} where ST<:AbstractStateSpace
│     ControlSystemsBase.sigmav :: Tuple{LTISystem, AbstractVector}
│     ControlSystemsBase.sigmav :: Tuple{LTISystem}
│     ControlSystemsBase.stepinfo :: Tuple{ControlSystemsBase.SimResult}
│     ControlSystemsBase.timeevol :: Tuple{LTISystem}
│     ControlSystemsBase.freqresp! :: Union{Tuple{T}, Tuple{Array{T, 3}, LTISystem, AbstractVector{<:Real}}} where T
│     ControlSystemsBase.obsv :: Union{Tuple{AbstractMatrix, AbstractMatrix}, Tuple{AbstractMatrix, AbstractMatrix, Int64}}
│     ControlSystemsBase.input_sensitivity :: Tuple{Any, Any}
│     ControlSystemsBase.integrator_excess :: Tuple{LTISystem}
│     ControlSystemsBase.isproper :: Tuple{TransferFunction}
│     ControlSystemsBase.observer_controller :: Tuple{Any, AbstractMatrix, AbstractMatrix}
│     ControlSystemsBase.gangofseven :: Tuple{LTISystem, LTISystem, LTISystem}
│     ControlSystemsBase.markovparam :: Tuple{AbstractStateSpace{<:Discrete}, Integer}
│     ControlSystemsBase.det :: Union{Tuple{Matrix{S}}, Tuple{S}} where S<:ControlSystemsBase.SisoZpk
│     ControlSystemsBase.HammersteinWienerSystem :: Union{Tuple{StateSpace}, Tuple{T}, Tuple{StateSpace, Vector{Function}}} where T<:Number
│     ControlSystemsBase.HammersteinWienerSystem
│     ControlSystemsBase._processfreqplot :: Tuple{Any, LTISystem, Vararg{Any}}
│     ControlSystemsBase.index2range :: Tuple{Any, Any}
│     ControlSystemsBase.c2d_poly2poly :: Tuple{Any, Any}
│     ControlSystemsBase.plyap :: Tuple{AbstractStateSpace, Vararg{Any}}
│     Base.:* :: Tuple{ControlSystemsBase.PartitionedStateSpace, ControlSystemsBase.PartitionedStateSpace}
│     ControlSystemsBase.lsim! :: Union{Tuple{T}, Tuple{LsimWorkspace{T}, AbstractStateSpace{<:Discrete}, Any, AbstractVector}} where T
│     ControlSystemsBase.balance_statespace :: Union{Tuple{AbstractMatrix, AbstractMatrix, AbstractMatrix}, Tuple{AbstractMatrix, AbstractMatrix, AbstractMatrix, Bool}}
│     ControlSystemsBase.kalman :: Tuple{Any, Any, Any, Any, Any, Vararg{Any}}
│     ControlSystemsBase.starprod :: Tuple{Any, Any, Int64, Int64}
│     ControlSystemsBase.system_name :: Tuple{LTISystem}
│     ControlSystems.f_lsim :: NTuple{4, Any}
│     ControlSystemsBase.pidplots :: Tuple{LTISystem, Vararg{Any}}
│     ControlSystemsBase.freqresp!v :: Union{Tuple{var"#477#W"}, Tuple{var"#476#T"}, Tuple{Array{var"#476#T", 3}, AbstractStateSpace, AbstractVector{var"#477#W"}}} where {var"#476#T", var"#477#W"<:Real}
│     ControlSystemsBase.hcat_1 :: Tuple{Vararg{ControlSystemsBase.PartitionedStateSpace}}
│     ControlSystemsBase.StepInfo
│     ControlSystemsBase.observer_filter :: Tuple{AbstractStateSpace{<:Discrete}, AbstractMatrix}
│     ControlSystemsBase.innovation_form :: Union{Tuple{ST}, Tuple{ST, Any, Any, Vararg{Any}}} where ST<:AbstractStateSpace
│     ControlSystemsBase.innovation_form :: Union{Tuple{ST}, Tuple{ST, Any}} where ST<:AbstractStateSpace
│     ControlSystemsBase.fix_D_matrix :: Tuple{Type, Any, Any, Any}
│     ControlSystemsBase.bode :: Tuple{LTISystem, AbstractVector}
│     ControlSystemsBase.PartitionedStateSpace
│     ControlSystemsBase.convert_pidparams_from_to :: Tuple{Any, Any, Any, Symbol, Symbol}
│     ControlSystemsBase.bodemag! :: Tuple{BodemagWorkspace, LTISystem, AbstractVector}
│     ControlSystemsBase.DemoSystems.double_mass_model :: Tuple{}
│     ControlSystemsBase.BodemagWorkspace :: Tuple{LTISystem, Int64}
│     ControlSystemsBase.reduce_sys :: Tuple{AbstractMatrix, AbstractMatrix, AbstractMatrix, AbstractMatrix, AbstractFloat}
│     ControlSystemsBase.G_PS :: Tuple{Any, Any}
│     ControlSystemsBase.extended_gangoffour :: Union{Tuple{Any, Any}, Tuple{Any, Any, Any}}
│     ControlSystemsBase.hinfnorm :: Tuple{AbstractStateSpace{<:Continuous}}
│     ControlSystemsBase.zpconv :: NTuple{4, Any}
│     ControlSystemsBase.tzeros :: Tuple{TransferFunction}
│     ControlSystemsBase.d2c_exact :: Union{Tuple{AbstractStateSpace{<:Discrete}}, Tuple{AbstractStateSpace{<:Discrete}, Any}}
│     ControlSystemsBase.relative_gain_array :: Tuple{AbstractMatrix}
│     ControlSystemsBase.relative_gain_array :: Tuple{Any, AbstractVector}
│     ControlSystemsBase.baltrunc :: Tuple{ST} where ST<:AbstractStateSpace
│     ControlSystemsBase.poles :: Tuple{AbstractStateSpace}
│     ControlSystemsBase.RootLocusResult
│     ControlSystemsBase.output_names :: Tuple{LTISystem}
│     ControlSystemsBase.bodeplot
│     CommonSolve.solve :: Union{Tuple{ControlSystems.AbstractSimulator, Any, Any}, Tuple{ControlSystems.AbstractSimulator, Any, Any, Any, Vararg{Any}}}
│     ControlSystemsBase.stab_unstab :: Tuple{AbstractStateSpace}
│     ControlSystemsBase.issiso :: Tuple{LTISystem}
│     ControlSystemsBase.nyquistplot
│     ControlSystemsBase.place_knvd :: Tuple{AbstractMatrix, Any, Any}
│     ControlSystemsBase._linscale :: Tuple{Polynomials.Polynomial, Any}
│     ControlSystemsBase.state_names :: Tuple{LTISystem}
│     ControlSystemsBase.rstc :: Tuple
│     ControlSystemsBase.LsimWorkspace :: Tuple{AbstractStateSpace, Int64}
│     LinearAlgebra.lyap :: Tuple{Union{Type{Discrete}, Discrete}, AbstractMatrix, Any}
│     ControlSystemsBase.add_input :: Union{Tuple{AbstractStateSpace, AbstractArray}, Tuple{AbstractStateSpace, AbstractArray, Any}}
│     ControlSystemsBase.resolvent :: Tuple{AbstractStateSpace}
│     ControlSystemsBase.freqrespv :: Union{Tuple{var"#446#W"}, Tuple{LTISystem, AbstractVector{var"#446#W"}}} where var"#446#W"<:Real
│     ControlSystemsBase.freqrespv :: Tuple{AbstractMatrix, AbstractVector{<:Real}}
│     ControlSystemsBase.freqrespv :: Tuple{Number, AbstractVector{<:Real}}
│     ControlSystemsBase.to_similar_matrices :: NTuple{4, Any}
│     ControlSystemsBase.controllability :: Union{Tuple{T}, Tuple{AbstractMatrix{T}, Any}} where T
│     Base.exp :: Tuple{TransferFunction{Continuous, <:ControlSystemsBase.SisoRational}}
│     ControlSystemsBase.setPlotScale :: Tuple{AbstractString}
│     ControlSystemsBase.lft :: Union{Tuple{Any, Any}, Tuple{Any, Any, Any}}
│     ControlSystemsBase.TransferFunction :: Tuple{Any}
│     ControlSystemsBase.dampreport :: Tuple{IO, LTISystem}
│     ControlSystemsBase.ssrand :: Tuple{Type, Int64, Int64, Int64}
│     ControlSystemsBase.grampd :: Tuple{AbstractStateSpace, Symbol}
│     ControlSystemsBase.lqr :: Tuple{Union{Continuous, Type{Continuous}}, Any, Any, Any, Any, Vararg{Any}}
│     ControlSystemsBase.sigmaplot
│     ControlSystemsBase.to_sized :: Tuple{AbstractStateSpace}
│     ControlSystemsBase.zpkdata :: Tuple{LTISystem}
│     ControlSystemsBase.add_output :: Union{Tuple{AbstractStateSpace, AbstractArray}, Tuple{AbstractStateSpace, AbstractArray, Any}}
│     ControlSystemsBase.pairup_conjugates! :: Tuple{AbstractVector}
│     ControlSystemsBase.isstable :: Tuple{LTISystem{Continuous}}
│     ControlSystemsBase.balance_transform :: Union{Tuple{AbstractArray, AbstractArray, AbstractArray}, Tuple{AbstractArray, AbstractArray, AbstractArray, Bool}}
│     ControlSystemsBase.freqresp_nohess
│     ControlSystemsBase.laglink :: Tuple{Any, Any}
│     ControlSystemsBase.loopshapingPI :: Tuple{Any, Any}
│     ControlSystemsBase.margin :: Tuple{LTISystem, AbstractVector{<:Real}}
│     ControlSystemsBase.loopshapingPID :: Tuple{Any, Any}
│     ControlSystemsBase.c2d_x0map :: Union{Tuple{AbstractStateSpace{<:Continuous}, Real}, Tuple{AbstractStateSpace{<:Continuous}, Real, Symbol}}
│     ControlSystemsBase.isdiscrete :: Tuple{LTISystem}
│     Base.:/ :: Union{Tuple{TE}, Tuple{AbstractStateSpace{TE}, AbstractStateSpace{TE}}} where TE<:ControlSystemsBase.TimeEvolution
│     Base.:/ :: Tuple{Any, DelayLtiSystem}
│     ControlSystemsBase.iscontinuous :: Tuple{LTISystem}
│     ControlSystemsBase.siso_ss_to_zpk :: Tuple{Any, Any, Any}
│     ControlSystemsBase.output_sensitivity :: Tuple{Any, Any}
│     ControlSystemsBase.DemoSystems
│     ControlSystemsBase.placePI :: Union{Tuple{T}, Tuple{TransferFunction{<:Continuous, <:ControlSystemsBase.SisoRational{T}}, Any, Any}} where T
│     ControlSystemsBase.nicholsplot
│     ControlSystemsBase.leadlink :: Union{Tuple{Any, Any}, Tuple{Any, Any, Any}}
│     ControlSystemsBase.nyquistv :: Tuple{LTISystem, AbstractVector}
│     ControlSystemsBase.nyquistv :: Tuple{LTISystem}
│     ControlSystemsBase.DemoSystems.doylesat :: Tuple{}
│     ControlSystemsBase.input_names :: Tuple{LTISystem}
│     ControlSystemsBase.place :: Union{Tuple{Any, Any, Any}, NTuple{4, Any}}
│     ControlSystemsBase.are :: Tuple{Union{Continuous, Type{Continuous}}, AbstractMatrix, Any, Any, Any}
│     ControlSystemsBase.are :: Tuple{Union{Type{Discrete}, Discrete}, AbstractMatrix, Any, Any, Any}
│     ControlSystemsBase.acker :: Tuple{Any, Any, Any}
│     ControlSystemsBase.rstd :: Tuple
│     ControlSystemsBase.comp_sensitivity :: Tuple
│     ControlSystemsBase._fix_conjugate_pairs! :: Tuple{AbstractVector{<:Complex}}
│     ControlSystemsBase.StateSpace
│     ControlSystemsBase.unwrap :: Tuple{AbstractArray, Vararg{Any}}
│     ControlSystemsBase.StaticStateSpace :: Tuple{AbstractStateSpace}
│     ControlSystemsBase.freqresp_nohess!v :: Union{Tuple{var"#498#W"}, Tuple{var"#497#T"}, Tuple{Array{var"#497#T", 3}, AbstractStateSpace, AbstractVector{var"#498#W"}}} where {var"#497#T", var"#498#W"<:Real}
│     ControlSystemsBase.freqresp_nohess!v :: Union{Tuple{var"#1187#W"}, Tuple{var"#1186#T"}, Tuple{Array{var"#1186#T", 3}, StaticStateSpace{TE, ny, nu, nx} where {TE, ny, nu, nx}, AbstractVector{var"#1187#W"}}} where {var"#1186#T", var"#1187#W"<:Real}
│     ControlSystemsBase.marginplot
│     ControlSystemsBase.ltitr :: Union{Tuple{AbstractMatrix, AbstractMatrix, AbstractVecOrMat}, Tuple{AbstractMatrix, AbstractMatrix, AbstractVecOrMat, AbstractVecOrMat}}
│     ControlSystemsBase.SimResult
│     ControlSystemsBase.output_comp_sensitivity :: Tuple{Any, Any}
│     ControlSystemsBase.DemoSystems.sotd :: Tuple{}
│     ControlSystemsBase.array2mimo :: Tuple{AbstractArray{<:LTISystem}}
│     ControlSystems.hw_f :: NTuple{4, Any}
│     ControlSystemsBase.ctrb :: Tuple{AbstractMatrix, AbstractVecOrMat}
│     ControlSystemsBase.DemoSystems.woodberry :: Tuple{}
│     ControlSystemsBase.sigma :: Tuple{LTISystem, AbstractVector}
│     ControlSystemsBase.leadlinkat :: Union{Tuple{Any, Any}, Tuple{Any, Any, Any}}
│     ControlSystemsBase.pid_2dof :: Tuple
│     ControlSystemsBase.delaymargin :: Tuple{LTISystem}
│     ControlSystemsBase.linfnorm :: Tuple{AbstractStateSpace}
│     ControlSystemsBase.minorpoles :: Union{Tuple{Array{ControlSystemsBase.SisoZpk{T, TR}, 2}}, Tuple{TR}, Tuple{T}} where {T, TR}
│     ControlSystemsBase.covar :: Tuple{AbstractStateSpace, Any}
│     ControlSystemsBase.stabregionPID :: Union{Tuple{Any}, Tuple{Any, Any}}
│     ControlSystemsBase.damp :: Tuple{LTISystem}
│     ControlSystemsBase.charpoly :: Union{Tuple{AbstractMatrix{T}}, Tuple{T}} where T
│     ControlSystemsBase.input_comp_sensitivity :: Tuple{Any, Any}
│     ControlSystemsBase.time_scale :: Tuple{AbstractStateSpace{Continuous}, Any}
│     ControlSystemsBase.dab :: Tuple{Any, Any, Any}
│     ControlSystemsBase.input_resolvent :: Tuple{AbstractStateSpace}
│     ControlSystemsBase.@autovec :: Tuple{Any, Any}
│     ControlSystemsBase.f_lsim :: NTuple{4, Any}
│     ControlSystemsBase.pid :: Union{Tuple{Any, Any}, Tuple{Any, Any, Any}}
│     ControlSystemsBase.printpolyfun :: Tuple{Any}
│     ControlSystemsBase.impulse :: Tuple{AbstractStateSpace, AbstractVector}
│     ControlSystemsBase.convert_pidparams_from_parallel :: Tuple{Any, Any, Any, Symbol}
│     ControlSystemsBase.nyquist :: Tuple{LTISystem, AbstractVector}
│     ControlSystemsBase._printcoefficient :: Tuple{Number}
│     ControlSystemsBase.vcat_1 :: Tuple{Vararg{ControlSystemsBase.PartitionedStateSpace}}
│     ControlSystemsBase.convert_pidparams_to_standard :: Tuple{Any, Any, Any, Symbol}
│     ControlSystemsBase.delayd_ss :: Tuple{Number, Number}
│     ControlSystemsBase.bodev :: Tuple{LTISystem, AbstractVector}
│     ControlSystemsBase.bodev :: Tuple{LTISystem}
│ 
│ These are docstrings in the checked modules (configured with the modules keyword)
│ that are not included in canonical @docs or @autodocs blocks.
└ @ Documenter ~/.julia/packages/Documenter/xvqbW/src/utilities/utilities.jl:49

6. Many errors like this one about missing packages (should I change folders?):

Click

┌ Error: failed to run `@example` block in ../../../../../..localst/Julia/ControlSystems.jl/docs/src/examples/automatic_differentiation.md:78-84
│ @example autodiff
│ using ControlSystemsBase, ForwardDiff, Plots
│ 
│ P = DemoSystems.double_mass_model()
│ 
│ bodeplot(P, title="Bode plot of Double-mass system \$P(s)\$")
│ 
│   exception =
│    ArgumentError: Package ForwardDiff not found in current path.
│    - Run `import Pkg; Pkg.add("ForwardDiff")` to install the ForwardDiff package.
│    Stacktrace:
│      [1] macro expansion
│        @ ./loading.jl:2403 [inlined]
│      [2] macro expansion
│        @ ./lock.jl:376 [inlined]
│      [3] __require(into::Module, mod::Symbol)
│        @ Base ./loading.jl:2386
│      [4] require(into::Module, mod::Symbol)
│        @ Base ./loading.jl:2362
│      [5] eval(m::Module, e::Any)
│        @ Core ./boot.jl:489
│      [6] #61
│        @ ~/.julia/packages/Documenter/xvqbW/src/expander_pipeline.jl:879 [inlined]
│      [7] cd(f::Documenter.var"#61#62"{Module, Expr}, dir::String)
│        @ Base.Filesystem ./file.jl:112
│      [8] (::Documenter.var"#59#60"{Documenter.Page, Module, Expr})()
│        @ Documenter ~/.julia/packages/Documenter/xvqbW/src/expander_pipeline.jl:878
│      [9] (::IOCapture.var"#12#13"{Type{InterruptException}, Documenter.var"#59#60"{Documenter.Page, Module, Expr}, IOContext{Base.PipeEndpoint}, IOContext{Base.PipeEndpoint}, Base.TTY, Base.TTY})()
│        @ IOCapture ~/.julia/packages/IOCapture/MR051/src/IOCapture.jl:170
│     [10] with_logstate(f::IOCapture.var"#12#13"{Type{InterruptException}, Documenter.var"#59#60"{Documenter.Page, Module, Expr}, IOContext{Base.PipeEndpoint}, IOContext{Base.PipeEndpoint}, Base.TTY, Base.TTY}, logstate::Base.CoreLogging.LogState)
│        @ Base.CoreLogging ./logging/logging.jl:540
│     [11] with_logger(f::Function, logger::Base.CoreLogging.ConsoleLogger)
│        @ Base.CoreLogging ./logging/logging.jl:651
│     [12] capture(f::Documenter.var"#59#60"{Documenter.Page, Module, Expr}; rethrow::Type, color::Bool, passthrough::Bool, capture_buffer::IOBuffer, io_context::Vector{Any})
│        @ IOCapture ~/.julia/packages/IOCapture/MR051/src/IOCapture.jl:167
│     [13] runner(::Type{Documenter.Expanders.ExampleBlocks}, node::MarkdownAST.Node{Nothing}, page::Documenter.Page, doc::Documenter.Document)
│        @ Documenter ~/.julia/packages/Documenter/xvqbW/src/expander_pipeline.jl:877
└ @ Documenter ~/.julia/packages/Documenter/xvqbW/src/utilities/utilities.jl:47

7. The result of some previous fails?

Error: failed to run `@example` block in ../../../../../..localst/Julia/ControlSystems.jl/docs/src/examples/tuning_from_data.md:142-147
exception =
│    UndefVarError: `inputstep` not defined in `Main.__atexample__named__PID_TUNING`
│    Suggestion: check for spelling errors or missing imports.

8. Stack trace:

Click

[ Info: Populate: populating indices.
ERROR: LoadError: `makedocs` encountered an error [:example_block] -- terminating build before rendering.
Stacktrace:
  [1] error(s::String)
    @ Base ./error.jl:44
  [2] runner(::Type{Documenter.Builder.RenderDocument}, doc::Documenter.Document)
    @ Documenter ~/.julia/packages/Documenter/dadeg/src/builder_pipeline.jl:259
  [3] dispatch(::Type{Documenter.Builder.DocumentPipeline}, x::Documenter.Document)
    @ Documenter.Selectors ~/.julia/packages/Documenter/dadeg/src/utilities/Selectors.jl:170
  [4] #89
    @ ~/.julia/packages/Documenter/dadeg/src/makedocs.jl:283 [inlined]
  [5] withenv(::Documenter.var"#89#90"{Documenter.Document}, ::Pair{String, Nothing}, ::Vararg{Pair{String, Nothing}})
    @ Base ./env.jl:265
  [6] #87
    @ ~/.julia/packages/Documenter/dadeg/src/makedocs.jl:282 [inlined]
  [7] cd(f::Documenter.var"#87#88"{Documenter.Document}, dir::String)
    @ Base.Filesystem ./file.jl:112
  [8] makedocs(; debug::Bool, format::Documenter.HTMLWriter.HTML, kwargs::@Kwargs{…})
    @ Documenter ~/.julia/packages/Documenter/dadeg/src/makedocs.jl:281
  [9] top-level scope
    @ localst/Julia/ControlSystems.jl/docs/make.jl:21
 [10] include(mapexpr::Function, mod::Module, _path::String)
    @ Base ./Base.jl:307
 [11] top-level scope
    @ REPL[7]:1
in expression starting at localst/Julia/ControlSystems.jl/docs/make.jl:21
Some type information was truncated. Use `show(err)` to see complete types.

I am confused on where to find the full log of what happened in this case. Lines limitation in the terminal make hard to catch the whole messages, that shoot fast during compilation processes.
Am I missing something here?

Would appreciate it if you could point me to a solution to either properly diagnose the issue or to what packages and how I should install - together at once or in separate environments - to use all the features of the ControlSystems package and to build the documentation.

Let me know please if some additional info is needed.

Regards

[m57-prot]

Partially solved this issue by reinstalling everything in a new environment and by listing all the packages altogether within Pkg.add("<pkg1>", "<pkg2>", ...), Otherwise, for some reason, precompilation of later added packages fails.

I'm closing this issue.

---

Just as a note, however:
When opening the pages in Chrome-based browsers, no LaTeX formulas are rendered in the generated html files, no matter what browser I use to read the local pages.

Editing the makedocs block in the make.jl-file to include

makedocs(
    format = Documenter.HTML(; mathengine = Documenter.MathJax(Dict(
        :delimiters => [
            Dict(:left => raw"$", :right => raw"$", display => false),
            Dict(:left => raw"$$", :right => raw"$$", display => true),
            Dict(:left => raw"\\[", :right => raw"\\]", display => true),
        ],
        :macros => Dict(
            "\\\\RR" => "\\\\mathbb{R}",
            raw"\\Xi" => raw"X_{i}",
            raw"\\Ru" => raw"R_{\\mathrm{univ.}}",
            raw"\\Pstd" => raw"P_{\\mathrm{std}}",
            raw"\\Tstd" => raw"T_{\\mathrm{std}}",
        ),
    ))),
)

makes the compilation fail. Firefox renderes the formulas fine.