For those of us who have one notebook that must run before others, it would be great if the notebooks were generated in the order as specified by "[frontmatter] order=n", as a fallback, use of alphabetic sort would also be helpful.

See #29

Looking at our testcase, the bond connections reported on the JS console is an empty array: Bond connections: {}
From my understanding, this causes our sliders to not update all of the affected cells.

The front-end JS (editor.bundle.js) and static export uses Pluto.jl@d9a3466 and PlutoUtils.js@e36c984. The bind server is PlutoBindServer.jl@01836ca and loads the same Pluto.jl and PlutoUtils.js.

The complete setup+notebookfiles can be found here: https://github.com/Captain-Bayes/bayes-imoox, the setup is heavily based on the computationalthinking course.

We have little experience in debugging julia code, so I would appreciate some hints on how to debug bound_variable_connections_graph and ultimately notebook.topology in the context of PlutoBindServer.jl.

@dorn-gerhard

Part 2 of #32 and #35 , see #68

This would help with JuliaPluto/static-export-template#12 and #63

I started trying PlutoSliderServer today and had problems making it work even with small simple notebook due to the following error:

This seem to be caused by fonsp/Pluto.jl#2300 which has been merged since v0.19.13

I was surprised that installing PlutoSliderServer would download Pluto v0.19.14 as the compat seems to speciy v0.19.10:

But then I realized that that compat entry does not limit patch release updates.

We currently generate a temporary index.html that shows the list of notebooks while they are booting up, finished notebooks are links, busy notebooks are (busy...).

Instead, we should serve a dynamic json with this session info, and then use JS to render the index page client-side.

Discussed in #32

After talking to @fonsp I will start to report my random error messages from now on ;)

This one appears when I just started the sliderserver. Julia 1.8.3, [2fc8631c] PlutoSliderServer v0.3.21

Prior to this I had killed all julia processes on my virtual machine (centos 7)

I have seen the error before, it didnt affect my notebooks in any way. No entry in journalctl

┌ Info:
│   Starting server...
│   ≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡
└   address = "http://0.0.0.0:8082/"

[ Info: Listening on: 0.0.0.0:8082, thread id: 1

┌ Info:
│   Server started
└   ≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡

┌ Info: Notebook list updated
│   added =
│    7-element Vector{String}:
│     "unfoldSimDemo.jl"
│     "splineRegression.jl"
│     "lmmType1.jl"
│     "heatmap.jl"
│     "filterArtefacts.jl"
│     "deconvolution.jl"
│     "clusterPermutationTest.jl"
│   updated = String[]
└   removed = String[]

┌ Info:
│   ◐ [1/7] Launching...
└   s.path = "unfoldSimDemo.jl"


    Updating registry at `~/.julia/registries/General.toml`
┌ Warning: The project dependencies or compat requirements have changed since the manifest was last resolved. It is recommended to Pkg.resolve() or consider Pkg.update() if necessary.
└ @ Pkg.API /cache/build/default-amdci5-6/julialang/julia-release-1-dot-8/usr/share/julia/stdlib/v1.8/Pkg/src/API.jl:1532

┌ Error: handle_connection handler error
│   exception =
│    IOError: write: broken pipe (EPIPE)
│    Stacktrace:
│      [1] uv_write(s::Sockets.TCPSocket, p::Ptr{UInt8}, n::UInt64)
│        @ Base ./stream.jl:1064
│      [2] unsafe_write(s::Sockets.TCPSocket, p::Ptr{UInt8}, n::UInt64)
│        @ Base ./stream.jl:1118
│      [3] unsafe_write
│        @ ~/.julia/packages/HTTP/z8l0i/src/ConnectionPool.jl:107 [inlined]
│      [4] unsafe_write(http::HTTP.Streams.Stream{HTTP.Messages.Request, HTTP.ConnectionPool.Connection{Sockets.TCPSocket}}, p::Ptr{UInt8}, n::UInt64)
│        @ HTTP.Streams ~/.julia/packages/HTTP/z8l0i/src/Streams.jl:93
│      [5] write
│        @ ./strings/io.jl:244 [inlined]
│      [6] write(io::HTTP.Streams.Stream{HTTP.Messages.Request, HTTP.ConnectionPool.Connection{Sockets.TCPSocket}}, s::Base.CodeUnits{UInt8, String})
│        @ Base ./strings/basic.jl:758
│      [7] (::HTTP.Handlers.var"#1#2"{PlutoSliderServer.var"../HTTPRouter.jl".var"#27#28"{HTTP.Handlers.Router{typeof(HTTP.Handlers.default404), typeof(HTTP.Handlers.default405), Nothing}}})(stream::HTTP.Streams.Stream{HTTP.Messages.Request, HTTP.ConnectionPool.Connection{Sockets.TCPSocket}})
│        @ HTTP.Handlers ~/.julia/packages/HTTP/z8l0i/src/Handlers.jl:61
│      [8] #invokelatest#2
│        @ ./essentials.jl:729 [inlined]
│      [9] invokelatest
│        @ ./essentials.jl:726 [inlined]
│     [10] handle_connection(f::Function, c::HTTP.ConnectionPool.Connection{Sockets.TCPSocket}, listener::HTTP.Servers.Listener{Nothing, Sockets.TCPServer}, readtimeout::Int64, access_log::Nothing)
│        @ HTTP.Servers ~/.julia/packages/HTTP/z8l0i/src/Servers.jl:447
│     [11] (::HTTP.Servers.var"#16#17"{HTTP.Handlers.var"#1#2"{PlutoSliderServer.var"../HTTPRouter.jl".var"#27#28"{HTTP.Handlers.Router{typeof(HTTP.Handlers.default404), typeof(HTTP.Handlers.default405), Nothing}}}, HTTP.Servers.Listener{Nothing, Sockets.TCPServer}, Set{HTTP.ConnectionPool.Connection}, Int64, Nothing, Base.Semaphore, HTTP.ConnectionPool.Connection{Sockets.TCPSocket}})()
│        @ HTTP.Servers ./task.jl:484
└ @ HTTP.Servers /home/bene/.julia/packages/HTTP/z8l0i/src/Servers.jl:461

Diffing with the initial notebook state can be significantly bigger than diffing with the "previous" state, especially if there is a file input somewhere. In this proposal we would send both the current C and the previous P state values and caclulate the diff between P and C, then send this diff back to the client.

Given that state P must be already calculated by the same server, it could be memoized already somewhere in the server, to avoid duplicate calculations (given no rand(), of course)

Note that PlutoSliderServer currenty always diffs to the initial state of each notebook.

It would be great if the "more" button in the Pluto Table View also works in PlutoSliderServer (both for rows and columns):

Currently, only the data needed for display are fetched from the server. Thus, when pressing "more" the frontend would need to request additional rows/ columns from the backend.

Hi!
I am trying to run a PlutoSliderServer.jl - I notice this problem occuring:

TypeError: ids_of_cells_that_ran is undefined
    request_bond_response SliderServerClient.js:67
    produce immerClass.ts:80
    produce immerClass.ts:96
    produce immerClass.ts:80
    request_bond_response SliderServerClient.js:70
SliderServerClient.js:73:25
    request_bond_response https://cdn.jsdelivr.net/gh/fonsp/[email protected]/frontend/common/SliderServerClient.js:73

I get this, whenever I try to update any cell via a @Bind - the value does not change if this occurs.

I also get the

┌ Info: Request hash not found. See errror hint in my source code.                                             │
└   notebook_hash = "ogR7NHsu1B9cYJ32"                                                                         │

Errror in the server console (with three r's very convient for googling :-D) - but don't know why I get it.

Config & Run

I run the notebook via PlutoSliderServer.run_git_directory("folderName";config_toml_path="./PlutoDeployment.toml") or via run_directory

My PlutoDeployment.toml

[SliderServer]
host = "127.0.0.1"
port = 2345
[Export]
# sliderServer = "http..." # commented out

Newest PlutoSliderServer & Pluto, Julia1.6 & Julia1.7

I constructed a minimal example here:
https://gist.github.com/behinger/4a3163913618db706c2e3897865151e9

Note the combination of a slider, a figure (sometimes one seems enough, sometimes I have to define two) and a css - haven't really figured out what exactly brings up the problem - it is not straight forward for me to debug this.

Maybe someone can help?

I am stuck with the following error message for one of my notebooks

Funnily enough, the page loads just fine in some browsers (e.g. qutebrowser) but I get the above error message in others (e.g. firefox).

Any ideas?

Hi,
I am trying to use PlutoSliderServer for the first time. I created a Julia environment that I called plutoserver, then I did add PlutoSliderServer. Apparently, the installation went smoothly. I tried the first example on the website, and I got the message:

julia> path_to_notebook = download("https://raw.githubusercontent.com/fonsp/Pluto.jl/v0.17.2/sample/Interactivity.jl")
"C:\\Users\\UTILIZ~1\\AppData\\Local\\Temp\\jl_49sv0d6TwR"

julia> PlutoSliderServer.run_notebook("C:\\Users\\UTILIZ~1\\AppData\\Local\\Temp\\jl_49sv0d6TwR")
ERROR: AssertionError: PlutoSliderServer does not work on Windows yet!

Is the error message correct, or am I doing something wrong?
Thanks

From time to time I get an email from students that some notebook on https://bio322.epfl.ch is not interactive anymore, i.e. the page shows constantly the loading bar and the sliders don't work anymore. Usually I just push an empty commit to trigger reloading of the page and then it works again for a while (days to weeks). One error message that I see often in my logs is the following (not sure it is related, though):

Distributed.ProcessExitedException(3)
Stacktrace:
  [1] worker_from_id(pg::Distributed.ProcessGroup, i::Int64)
    @ Distributed /usr/local/julia/share/julia/stdlib/v1.9/Distributed/src/cluster.jl:1093
  [2] worker_from_id
    @ /usr/local/julia/share/julia/stdlib/v1.9/Distributed/src/cluster.jl:1090 [inlined]
  [3] #remotecall_fetch#162
    @ /usr/local/julia/share/julia/stdlib/v1.9/Distributed/src/remotecall.jl:492 [inlined]
  [4] remotecall_fetch
    @ /usr/local/julia/share/julia/stdlib/v1.9/Distributed/src/remotecall.jl:492 [inlined]
  [5] remotecall_eval
    @ /usr/local/julia/share/julia/stdlib/v1.9/Distributed/src/macros.jl:242 [inlined]
  [6] create_emptyworkspacemodule(pid::Int64)
    @ Pluto.WorkspaceManager ~/.julia/packages/Pluto/8HhXY/src/evaluation/WorkspaceManager.jl:280
  [7] bump_workspace_module(session_notebook::Tuple{Pluto.ServerSession, Pluto.Notebook})
    @ Pluto.WorkspaceManager ~/.julia/packages/Pluto/8HhXY/src/evaluation/WorkspaceManager.jl:258
  [8] run_reactive_core!(session::Pluto.ServerSession, notebook::Pluto.Notebook, old_topology::Pluto.NotebookTopology, new_topology::Pluto.NotebookTopology, roots::Vector{Pluto.Cell}; save::Bool, deletion_hook::Pluto.var"#custom_deletion_hook#328"{Pluto.var"#custom_deletion_hook#324#329"{Set{Symbol}, Vector{Any}, Vector{Symbol}}}, user_requested_run::Bool, already_run::Vector{Pluto.Cell}, bond_value_pairs::Base.Iterators.Zip{Tuple{Vector{Symbol}, Vector{Any}}})
    @ Pluto ~/.julia/packages/Pluto/8HhXY/src/evaluation/Run.jl:59
  [9] run_reactive_core!
    @ ~/.julia/packages/Pluto/8HhXY/src/evaluation/Run.jl:44 [inlined]
 [10] #267
    @ ~/.julia/packages/Pluto/8HhXY/src/evaluation/Run.jl:22 [inlined]
 [11] withtoken(f::Pluto.var"#267#268"{Bool, Pluto.var"#custom_deletion_hook#328"{Pluto.var"#custom_deletion_hook#324#329"{Set{Symbol}, Vector{Any}, Vector{Symbol}}}, Bool, Base.Iterators.Zip{Tuple{Vector{Symbol}, Vector{Any}}}, Pluto.ServerSession, Pluto.Notebook, Pluto.NotebookTopology, Pluto.NotebookTopology, Vector{Pluto.Cell}}, token::Pluto.Token)
    @ Pluto ~/.julia/packages/Pluto/8HhXY/src/evaluation/Tokens.jl:19
 [12] #run_reactive!#266
    @ ~/.julia/packages/Pluto/8HhXY/src/evaluation/Run.jl:21 [inlined]
 [13] run_reactive!
    @ ~/.julia/packages/Pluto/8HhXY/src/evaluation/Run.jl:10 [inlined]
 [14] #288
    @ ~/.julia/packages/Pluto/8HhXY/src/evaluation/Run.jl:261 [inlined]
 [15] macro expansion
    @ ~/.julia/packages/Pluto/8HhXY/src/evaluation/Tokens.jl:58 [inlined]
 [16] (::Pluto.var"#290#291"{Pluto.var"#288#289"{Base.Pairs{Symbol, Any, NTuple{4, Symbol}, NamedTuple{(:deletion_hook, :save, :user_requested_run, :bond_value_pairs), Tuple{Pluto.var"#custom_deletion_hook#328"{Pluto.var"#custom_deletion_hook#324#329"{Set{Symbol}, Vector{Any}, Vector{Symbol}}}, Bool, Bool, Base.Iterators.Zip{Tuple{Vector{Symbol}, Vector{Any}}}}}}, Pluto.ServerSession, Pluto.Notebook, Pluto.NotebookTopology, Pluto.NotebookTopology, Vector{Pluto.Cell}}})()
    @ Pluto ./task.jl:514┌ Error: Failed to set bond values
│   exception =
│    TaskFailedException
│    Stacktrace:
│      [1] wait
│        @ ./task.jl:349 [inlined]
│      [2] fetch
│        @ ./task.jl:369 [inlined]
│      [3] maybe_async(f::Pluto.var"#288#289"{Base.Pairs{Symbol, Any, NTuple{4, Symbol}, NamedTuple{(:deletion_hook, :save, :user_requested_run, :bond_value_pairs), Tuple{Pluto.var"#custom_deletion_hook#328"{Pluto.var"#custom_deletion_hook#324#329"{Set{Symbol}, Vector{Any}, Vector{Symbol}}}, Bool, Bool, Base.Iterators.Zip{Tuple{Vector{Symbol}, Vector{Any}}}}}}, Pluto.ServerSession, Pluto.Notebook, Pluto.NotebookTopology, Pluto.NotebookTopology, Vector{Pluto.Cell}}, async::Bool)
│        @ Pluto ~/.julia/packages/Pluto/8HhXY/src/evaluation/Run.jl:270
│      [4] run_reactive_async!(session::Pluto.ServerSession, notebook::Pluto.Notebook, old::Pluto.NotebookTopology, new::Pluto.NotebookTopology, to_run::Vector{Pluto.Cell}; run_async::Bool, kwargs::Base.Pairs{Symbol, Any, NTuple{4, Symbol}, NamedTuple{(:deletion_hook, :save, :user_requested_run, :bond_value_pairs), Tuple{Pluto.var"#custom_deletion_hook#328"{Pluto.var"#custom_deletion_hook#324#329"{Set{Symbol}, Vector{Any}, Vector{Symbol}}}, Bool, Bool, Base.Iterators.Zip{Tuple{Vector{Symbol}, Vector{Any}}}}}})
│        @ Pluto ~/.julia/packages/Pluto/8HhXY/src/evaluation/Run.jl:260
│      [5] run_reactive_async!
│        @ ~/.julia/packages/Pluto/8HhXY/src/evaluation/Run.jl:259 [inlined]
│      [6] #run_reactive_async!#286
│        @ ~/.julia/packages/Pluto/8HhXY/src/evaluation/Run.jl:257 [inlined]
│      [7] run_reactive_async!
│        @ ~/.julia/packages/Pluto/8HhXY/src/evaluation/Run.jl:257 [inlined]
│      [8] set_bond_values_reactive(; session::Pluto.ServerSession, notebook::Pluto.Notebook, bound_sym_names::Vector{Symbol}, is_first_values::Vector{Bool}, initiator::Nothing, kwargs::Base.Pairs{Symbol, Bool, Tuple{Symbol}, NamedTuple{(:run_async,), Tuple{Bool}}})
│        @ Pluto ~/.julia/packages/Pluto/8HhXY/src/evaluation/RunBonds.jl:60
│      [9] set_bond_values_reactive
│        @ ~/.julia/packages/Pluto/8HhXY/src/evaluation/RunBonds.jl:1 [inlined]
│     [10] (::PlutoSliderServer.var"../HTTPRouter.jl".var"#4#16"{Dict{Symbol, Any}, Pluto.Notebook, Pluto.ServerSession})()
│        @ PlutoSliderServer.var"../HTTPRouter.jl" ~/.julia/packages/PlutoSliderServer/N6YBS/src/HTTPRouter.jl:116
│     [11] withtoken(f::PlutoSliderServer.var"../HTTPRouter.jl".var"#4#16"{Dict{Symbol, Any}, Pluto.Notebook, Pluto.ServerSession}, token::Pluto.Token)
│        @ Pluto ~/.julia/packages/Pluto/8HhXY/src/evaluation/Tokens.jl:19
│     [12] (::PlutoSliderServer.var"../HTTPRouter.jl".var"#serve_staterequest#15"{PlutoSliderServer.var"../Configuration.jl".PlutoDeploySettings, Pluto.ServerSession, PlutoSliderServer.var"../HTTPRouter.jl".var"#get_bonds#13", PlutoSliderServer.var"../HTTPRouter.jl".var"#get_sesh#11"{Vector{PlutoSliderServer.var"../Types.jl".NotebookSession}}, PlutoSliderServer.var"../HTTPRouter.jl".var"#27#28"{String}})(request::HTTP.Messages.Request)
│        @ PlutoSliderServer.var"../HTTPRouter.jl" ~/.julia/packages/PlutoSliderServer/N6YBS/src/HTTPRouter.jl:110
│     [13] (::HTTP.Handlers.Router{typeof(HTTP.Handlers.default404), typeof(HTTP.Handlers.default405), Nothing})(req::HTTP.Messages.Request)
│        @ HTTP.Handlers ~/.julia/packages/HTTP/SN7VW/src/Handlers.jl:439
│     [14] (::PlutoSliderServer.var"../HTTPRouter.jl".var"#29#30"{HTTP.Handlers.Router{typeof(HTTP.Handlers.default404), typeof(HTTP.Handlers.default405), Nothing}})(req::HTTP.Messages.Request)
│        @ PlutoSliderServer.var"../HTTPRouter.jl" ~/.julia/packages/PlutoSliderServer/N6YBS/src/HTTPRouter.jl:308
│     [15] (::HTTP.Handlers.var"#1#2"{PlutoSliderServer.var"../HTTPRouter.jl".var"#29#30"{HTTP.Handlers.Router{typeof(HTTP.Handlers.default404), typeof(HTTP.Handlers.default405), Nothing}}})(stream::HTTP.Streams.Stream{HTTP.Messages.Request, HTTP.Connections.Connection{Sockets.TCPSocket}})
│        @ HTTP.Handlers ~/.julia/packages/HTTP/SN7VW/src/Handlers.jl:58
│     [16] #invokelatest#2
│        @ ./essentials.jl:819 [inlined]
│     [17] invokelatest
│        @ ./essentials.jl:816 [inlined]
│     [18] handle_connection(f::Function, c::HTTP.Connections.Connection{Sockets.TCPSocket}, listener::HTTP.Servers.Listener{Nothing, Sockets.TCPServer}, readtimeout::Int64, access_log::Nothing)
│        @ HTTP.Servers ~/.julia/packages/HTTP/SN7VW/src/Servers.jl:450
│     [19] macro expansion
│        @ ~/.julia/packages/HTTP/SN7VW/src/Servers.jl:386 [inlined]
│     [20] (::HTTP.Servers.var"#16#17"{HTTP.Handlers.var"#1#2"{PlutoSliderServer.var"../HTTPRouter.jl".var"#29#30"{HTTP.Handlers.Router{typeof(HTTP.Handlers.default404), typeof(HTTP.Handlers.default405), Nothing}}}, HTTP.Servers.Listener{Nothing, Sockets.TCPServer}, Set{HTTP.Connections.Connection}, Int64, Nothing, Base.Semaphore, HTTP.Connections.Connection{Sockets.TCPSocket}})()
│        @ HTTP.Servers ./task.jl:514
│    
│        nested task error: Distributed.ProcessExitedException(3)
│        Stacktrace:
│          [1] worker_from_id(pg::Distributed.ProcessGroup, i::Int64)
│            @ Distributed /usr/local/julia/share/julia/stdlib/v1.9/Distributed/src/cluster.jl:1093
│          [2] worker_from_id
│            @ /usr/local/julia/share/julia/stdlib/v1.9/Distributed/src/cluster.jl:1090 [inlined]
│          [3] #remotecall_fetch#162
│            @ /usr/local/julia/share/julia/stdlib/v1.9/Distributed/src/remotecall.jl:492 [inlined]
│          [4] remotecall_fetch
│            @ /usr/local/julia/share/julia/stdlib/v1.9/Distributed/src/remotecall.jl:492 [inlined]
│          [5] remotecall_eval
│            @ /usr/local/julia/share/julia/stdlib/v1.9/Distributed/src/macros.jl:242 [inlined]
│          [6] create_emptyworkspacemodule(pid::Int64)
│            @ Pluto.WorkspaceManager ~/.julia/packages/Pluto/8HhXY/src/evaluation/WorkspaceManager.jl:280
│          [7] bump_workspace_module(session_notebook::Tuple{Pluto.ServerSession, Pluto.Notebook})
│            @ Pluto.WorkspaceManager ~/.julia/packages/Pluto/8HhXY/src/evaluation/WorkspaceManager.jl:258
│          [8] run_reactive_core!(session::Pluto.ServerSession, notebook::Pluto.Notebook, old_topology::Pluto.NotebookTopology, new_topology::Pluto.NotebookTopology, roots::Vector{Pluto.Cell}; save::Bool, deletion_hook::Pluto.var"#custom_deletion_hook#328"{Pluto.var"#custom_deletion_hook#324#329"{Set{Symbol}, Vector{Any}, Vector{Symbol}}}, user_requested_run::Bool, already_run::Vector{Pluto.Cell}, bond_value_pairs::Base.Iterators.Zip{Tuple{Vector{Symbol}, Vector{Any}}})
│            @ Pluto ~/.julia/packages/Pluto/8HhXY/src/evaluation/Run.jl:59
│          [9] run_reactive_core!
│            @ ~/.julia/packages/Pluto/8HhXY/src/evaluation/Run.jl:44 [inlined]
│         [10] #267
│            @ ~/.julia/packages/Pluto/8HhXY/src/evaluation/Run.jl:22 [inlined]
│         [11] withtoken(f::Pluto.var"#267#268"{Bool, Pluto.var"#custom_deletion_hook#328"{Pluto.var"#custom_deletion_hook#324#329"{Set{Symbol}, Vector{Any}, Vector{Symbol}}}, Bool, Base.Iterators.Zip{Tuple{Vector{Symbol}, Vector{Any}}}, Pluto.ServerSession, Pluto.Notebook, Pluto.NotebookTopology, Pluto.NotebookTopology, Vector{Pluto.Cell}}, token::Pluto.Token)
│            @ Pluto ~/.julia/packages/Pluto/8HhXY/src/evaluation/Tokens.jl:19
│         [12] #run_reactive!#266
│            @ ~/.julia/packages/Pluto/8HhXY/src/evaluation/Run.jl:21 [inlined]
│         [13] run_reactive!
│            @ ~/.julia/packages/Pluto/8HhXY/src/evaluation/Run.jl:10 [inlined]
│         [14] #288
│            @ ~/.julia/packages/Pluto/8HhXY/src/evaluation/Run.jl:261 [inlined]
│         [15] macro expansion
│            @ ~/.julia/packages/Pluto/8HhXY/src/evaluation/Tokens.jl:58 [inlined]
│         [16] (::Pluto.var"#290#291"{Pluto.var"#288#289"{Base.Pairs{Symbol, Any, NTuple{4, Symbol}, NamedTuple{(:deletion_hook, :save, :user_requested_run, :bond_value_pairs), Tuple{Pluto.var"#custom_deletion_hook#328"{Pluto.var"#custom_deletion_hook#324#329"{Set{Symbol}, Vector{Any}, Vector{Symbol}}}, Bool, Bool, Base.Iterators.Zip{Tuple{Vector{Symbol}, Vector{Any}}}}}}, Pluto.ServerSession, Pluto.Notebook, Pluto.NotebookTopology, Pluto.NotebookTopology, Vector{Pluto.Cell}}})()
│            @ Pluto ./task.jl:514
└ @ PlutoSliderServer.var"../HTTPRouter.jl" /home/MLCourse/.julia/packages/PlutoSliderServer/N6YBS/src/HTTPRouter.jl:128

Another error I have in the logs is

UNHANDLED TASK ERROR: EOFError: read end of file
Stacktrace:
 [1] (::Base.var"#wait_locked#715")(s::Sockets.TCPSocket, buf::IOBuffer, nb::Int64)
   @ Base ./stream.jl:947
 [2] unsafe_read(s::Sockets.TCPSocket, p::Ptr{UInt8}, nb::UInt64)
   @ Base ./stream.jl:955
 [3] unsafe_read
   @ ./io.jl:761 [inlined]
 [4] unsafe_read(s::Sockets.TCPSocket, p::Base.RefValue{NTuple{4, Int64}}, n::Int64)
   @ Base ./io.jl:760
 [5] read!
   @ ./io.jl:762 [inlined]
 [6] deserialize_hdr_raw
   @ /usr/local/julia/share/julia/stdlib/v1.9/Distributed/src/messages.jl:167 [inlined]
 [7] message_handler_loop(r_stream::Sockets.TCPSocket, w_stream::Sockets.TCPSocket, incoming::Bool)
   @ Distributed /usr/local/julia/share/julia/stdlib/v1.9/Distributed/src/process_messages.jl:172
 [8] process_tcp_streams(r_stream::Sockets.TCPSocket, w_stream::Sockets.TCPSocket, incoming::Bool)
   @ Distributed /usr/local/julia/share/julia/stdlib/v1.9/Distributed/src/process_messages.jl:133
 [9] (::Distributed.var"#103#104"{Sockets.TCPSocket, Sockets.TCPSocket, Bool})()
   @ Distributed ./task.jl:514

This issue is used to trigger TagBot; feel free to unsubscribe.

If you haven't already, you should update your TagBot.yml to include issue comment triggers.
Please see this post on Discourse for instructions and more details.

If you'd like for me to do this for you, comment TagBot fix on this issue.
I'll open a PR within a few hours, please be patient!

See https://docs.juliahub.com/AbstractPlutoDingetjes/UHbnu/1.1.1/#AbstractPlutoDingetjes.Bonds.validate_value-Tuple{Any,%20Any}

This will require changes to Pluto.jl itself, perhaps it should be fully implemented in Pluto

Firstly, thanks for producing this really cool software! I'm planning to use Pluto (especially with precomputed static outputs) as much as possible now :)

I was just trying the precomputed static html branch (though I would guess this behaviour is unrelated to the pre-computation), and found that sometimes I would get 404 error when trying to load the bond connections file, and the dynamic content would fail.

Specifically, I generated a static HTML output using

PlutoSliderServer.export_notebook("basic3.jl", Precompute_enabled=true)

on the basic3.jl test file, then if I ran

deno run --allow-net --allow-read https://deno.land/[email protected]/http/file_server.ts .  --port 8000

the localhost:8000/basic3.html page would work as expected, whereas if instead I tried Python's built-in server

python3 -m http.server 8000

then the Javascript console would show a 404 error trying to load bondconnections and the interactivity would not work anymore.

Javascript prints out the same notebook hash in both cases, 7uehaeBoJorFiesT4uKI7Rl3bFJcsQwdILATmeaacfs=, and both links request

http://localhost:8000/bondconnections/7uehaeBoJorFiesT4uKI7Rl3bFJcsQwdILATmeaacfs%3D

however Python's server will only load this file if the URL used is

http://localhost:8000/bondconnections/7uehaeBoJorFiesT4uKI7Rl3bFJcsQwdILATmeaacfs%253D

The difference appears to be a different escaping mechanism for the URL (Python wanting the escaped characters to have '25' after each '%').

Having the Python server supported is not important, I was simply hoping to put the precomputed html files onto Github Pages and I spotted this problem there. Using Python locally was just a convenient way to reproduce this error. I'm not a web developer, so I hope this isn't simply some trivial error caused by my ignorance! Thanks.

Hello!

First of all, thanks for all the effort in creating these tools!

The issue

When running PlutoSliderServer.run_directory(".") and accessing the webserver using nginx as a reverse proxy like this:

location /pluto/ {
   proxy_pass         "http://127.0.0.1:2345/";
}

sometimes I get an error, reported by the PlutSliderServer process, of the type:

┌ Info: Request hash not found. See errror hint in my source code.
└   notebook_hash = "EJV5zDLtcW"

The error happens on page load and each time the slider is adjusted.

The corresponding published notebook:

as can be seen from the screenshot, somehow the URL containing the hash with the forward slash is escaped and causes a problem. This only happens when forwarding /pluto/ to http://127.0.0.1:2345/. This issue does not exist if the root is forwarded like so:

location / {
    proxy_pass         "http://127.0.0.1:2345";
}

I have changed my notebooks slightly by adding whitespaces in the text to generate different hashes and each time a forward slash is in the hash, this issue arises.

For reference

Here are examples that cause the issue:
Example 3,
Example 4

Examples with hashes that do not cause issues:
Example 1,
Example 2,
Example 1,
Example 2

My setup

I am using the default settings for PlutoSliderServer (v0.3.3), julia version 1.7.0, nginx version 1.14.1, CentOS version 8.

I don't know if the hashing procedure can be altered to avoid certain characters or if this is an nginx configuration issue.

Issues #42 and #45 seem to be similar to this.

Now, I could fiddle around with whitespaces to find hashes that do work, but it's kind of an inelegant solution.

How did you avoid these issues when creating the Computational Thinking site?

As discussed on zulip, it would be very helpful to see which cells are running on the notebook on the server especially for long running computations.

Another interesting point raised on discourse would be having the possibility of relaying logs back to the clients, though I am not sure how feasible or easy that is.

Tagging @ctrekker as he mentioned the first part would be rather simple to implement.

Hi!
When I run Export_output_dir, within export_dir, somehow the server calculates the .html's twice, e.g. https://benediktehinger.de/interactive-eeg/output/index.html

Also note the double of "output/output"

(it also copies the .jl files to the output directory, I guess that is on purpose?)

Don't have a MWE atm, sorry!

PlutoSliderServer.export_directory(path_to_dir, Export_output_dir="./output/" ,Export_offer_binder=true)

edit: note that the generation of the notebooks failed, thus quite a lot of 404s :)

This notebook produces a weird cell topology and results on unintended behavior:

# ╔═╡ eab54436-2314-11ed-372a-536153d0ba0e
using PlutoUI

# ╔═╡ db24a888-617d-4123-84e6-cb57aacd68e7
@bind a Slider(1:10; show_value=true)

# ╔═╡ 2515ccde-fafd-42db-b75c-110817f9074d
begin
	a
	@bind b Slider(1:10; show_value=true)
end

# ╔═╡ 5a37bce9-d9e4-456f-9b9d-7d8755b1e0db
begin
	a
	rand()
end

Bond topology generated:

┌ Info: Bond connections
│   s.path = "test-pss-deps.jl"
│   showall(collect(bond_connections)) =
│    :a => [:a, :b]
└    :b => [:a, :b]

Shouldn't the topology be :a => [:a], :b => [:a, :b]?

Also, this notebook's behavior makes it so everytime you change b, you generate a different rand number. This might be because rand relies on the current overall state of the notebook, but still shouldn't happen. Also, the slider for b seems stuck, as it doesn't slide but directly moves to where the cursor is. The slider value displaying also doesn't change and isn't going back to 0 when we change a. Here is a quick video:

When changing elements in the notebook which trigger longer running calculations on the server, it is currently not visible for the user if the notebook is already updated with the new results or not.

It would be great to have the same UI as for "normal" Pluto notebooks indicating that a notebook is running (here: there is a backend request awaiting an answer) and which cells are not updated yet.

I am consistently getting buggy behavior when the SliderServer runs a notebook with PlutoUI elements; specifically the MultiCheckBox. The notebook runs fine when Pluto is running it; but shows errors when the SliderServer runs it. Here is a MWE:

using  PlutoUI

begin
	sites = ["France","Germany","Russia","China"]
	groupdict = Dict(zip(sites,[[:blue, :white, :red], 
		[:black, :red, :yellow], [:blue, :red, :white], 
		[:red, :yellow]] ))
end

@bind loc Select(sites)

@bind col MultiCheckBox(groupdict[loc])

Any clue what could be going wrong?

This happened with nightly on my local machine and with the official 1.8-beta1 docker image. It did not happen with 1.7.1 on my local machine, nor with the official 1.7.2 docker image.

I have a single notebook in a notebook folder, I freshly install the latest PlutoSliderServer, then run run_directory("./notebooks"). The notebooks are detected, all evaluations are reported as normal, the terminal generally says everything is fine.

However loading localhost:port just gives me a 404 server message in the browser console with an empty page (both before and after the terminal message tells me the notebook is ready).

This docker file works fine:

FROM julia:1.7.2-bullseye
WORKDIR /app
RUN julia -e "import Pkg; Pkg.add(\"PlutoSliderServer\");"
ENTRYPOINT julia -e "import PlutoSliderServer; PlutoSliderServer.run_directory(\"./notebooks\")"

This docker file gives the empty page 404 errors:

FROM julia:1.8.0-beta1-bullseye
WORKDIR /app
RUN julia -e "import Pkg; Pkg.add(\"PlutoSliderServer\");"
ENTRYPOINT julia -e "import PlutoSliderServer; PlutoSliderServer.run_directory(\"./notebooks\")"

Both of these need to be started with -v local_notebook_folder:/app/notebooks

This has not been reported to julialang.

When evaluation time of the notebook directory is large, it would be nice to know which notebooks contribute to it the most.

Would be cool printing the evaluation time next to [Ready]

Our deployment stopped automatically updating from git, and in the logs I found this error:

Nov 11 19:59:33 c25-bind-2 pluto-slider-server.sh[486301]: fatal: unable to access 'https://github.com/mitmath/JuliaComputation.git/': The requested URL returned error: 504
Nov 11 19:59:35 c25-bind-2 pluto-slider-server.sh[258452]: failed process: Process(setenv(`/root/.julia/artifacts/33c5e3a13ad6427f86436f577c0edce1e468ac80/bin/git fetch origin main --quiet`,["PATH=/root/.julia/artifacts/fac7e6d8fc4c5775bf5118ab494120d2a0db4d64/bin:/root/.julia/artifacts/53037ac9d528ee46c3526799b407ee52b7c224f3/bin:/root/.julia/artifacts/3e19866657986912870f596aecfee137473965a9/bin:/root/.julia/artifacts/33c5e3a13ad6427f86436f577c0edce1e468ac80/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/snap/bin", "PWD=/home/fons/JuliaComputation", "GIT_EXEC_PATH=/root/.julia/artifacts/33c5e3a13ad6427f86436f577c0edce1e468ac80/libexec/git-core", "LD_LIBRARY_PATH=/home/fons/julia-1.8.2/bin/../lib/julia:/root/.julia/artifacts/fac7e6d8fc4c5775bf5118ab494120d2a0db4d64/lib:/root/.julia/artifacts/53037ac9d528ee46c3526799b407ee52b7c224f3/lib:/root/.julia/artifacts/2e8fae88dcadc37883e31246fe7397f4f1039f88/lib:/root/.julia/artifacts/3e19866657986912870f596aecfee137473965a9/lib:/root/.julia/artifacts/dc526f26fb179a3f68eb13fcbe5d2d2a5aa7eeac/lib:/home/fons/julia-1.8.2/bin/../lib/julia:/home/fons/julia-1.8.2/bin/../lib", "INVOCATION_ID=6fc99650364e490c9eac8fa6557f27ea", "LANG=C.UTF-8", "SHLVL=1", "JOURNAL_STREAM=8:1271154", "OLDPWD=/", "_=/usr/bin/julia", "SYSTEMD_EXEC_PID=258451", "GIT_TEMPLATE_DIR=/root/.julia/artifacts/33c5e3a13ad6427f86436f577c0edce1e468ac80/share/git-core/templates", "JULIA_PKG_USE_CLI_GIT=true", "GIT_SSL_CAINFO=/home/fons/julia-1.8.2/share/julia/cert.pem"]), ProcessExited(128)) [128]
Nov 11 19:59:35 c25-bind-2 pluto-slider-server.sh[258452]: Stacktrace:
Nov 11 19:59:35 c25-bind-2 pluto-slider-server.sh[258452]:   [1] pipeline_error
Nov 11 19:59:35 c25-bind-2 pluto-slider-server.sh[258452]:     @ ./process.jl:565 [inlined]
Nov 11 19:59:35 c25-bind-2 pluto-slider-server.sh[258452]:   [2] run(::Cmd; wait::Bool)
Nov 11 19:59:35 c25-bind-2 pluto-slider-server.sh[258452]:     @ Base ./process.jl:480
Nov 11 19:59:35 c25-bind-2 pluto-slider-server.sh[258452]:   [3] run
Nov 11 19:59:35 c25-bind-2 pluto-slider-server.sh[258452]:     @ ./process.jl:477 [inlined]
Nov 11 19:59:36 c25-bind-2 pluto-slider-server.sh[258452]:   [4] (::PlutoSliderServer.var"../gitpull.jl".var"#3#4"{SubString{String}})()
Nov 11 19:59:36 c25-bind-2 pluto-slider-server.sh[258452]:     @ PlutoSliderServer.var"../gitpull.jl" ~/.julia/packages/PlutoSliderServer/K4Eto/src/gitpull.jl:16
Nov 11 19:59:36 c25-bind-2 pluto-slider-server.sh[258452]:   [5] cd(f::PlutoSliderServer.var"../gitpull.jl".var"#3#4"{SubString{String}}, dir::String)
Nov 11 19:59:36 c25-bind-2 pluto-slider-server.sh[258452]:     @ Base.Filesystem ./file.jl:112
Nov 11 19:59:36 c25-bind-2 pluto-slider-server.sh[258452]:   [6] fetch
Nov 11 19:59:36 c25-bind-2 pluto-slider-server.sh[258452]:     @ ~/.julia/packages/PlutoSliderServer/K4Eto/src/gitpull.jl:15 [inlined]
Nov 11 19:59:36 c25-bind-2 pluto-slider-server.sh[258452]:   [7] #fetch_pull#7
Nov 11 19:59:36 c25-bind-2 pluto-slider-server.sh[258452]:     @ ~/.julia/packages/PlutoSliderServer/K4Eto/src/gitpull.jl:38 [inlined]
Nov 11 19:59:36 c25-bind-2 pluto-slider-server.sh[258452]:   [8] fetch_pull
Nov 11 19:59:36 c25-bind-2 pluto-slider-server.sh[258452]:     @ ~/.julia/packages/PlutoSliderServer/K4Eto/src/gitpull.jl:37 [inlined]
Nov 11 19:59:36 c25-bind-2 pluto-slider-server.sh[258452]:   [9] macro expansion
Nov 11 19:59:36 c25-bind-2 pluto-slider-server.sh[258452]:     @ ~/.julia/packages/PlutoSliderServer/K4Eto/src/PlutoSliderServer.jl:473 [inlined]
Nov 11 19:59:36 c25-bind-2 pluto-slider-server.sh[258452]:  [10] macro expansion
Nov 11 19:59:36 c25-bind-2 pluto-slider-server.sh[258452]:     @ ~/.julia/packages/Pluto/JnB0V/src/evaluation/Tokens.jl:58 [inlined]
Nov 11 19:59:36 c25-bind-2 pluto-slider-server.sh[258452]:  [11] (::PlutoSliderServer.var"#29#34"{String, PlutoSliderServer.var"../Configuration.jl".PlutoDeploySettings, PlutoSliderServer.var"#get_settings#32"{String, Base.Pairs{Symbol, Bool, Tuple{Symbol}, NamedTuple{(:Export_enabled,), Tuple{Bool}}}}})()

I found that auto-updating from the folder (watching) was still working (doing manual fetch & pull triggered the server to update), but it was no longer running git fetch pull on its own.

fons@c25-bind-2:~/JuliaComputation/notebooks$ sudo git fetch
remote: Enumerating objects: 166, done.
remote: Counting objects: 100% (166/166), done.
remote: Compressing objects: 100% (64/64), done.
remote: Total 166 (delta 120), reused 148 (delta 102), pack-reused 0
Receiving objects: 100% (166/166), 8.51 MiB | 34.30 MiB/s, done.
Resolving deltas: 100% (120/120), completed with 14 local objects.
From https://github.com/mitmath/JuliaComputation
   3130315..2907b5a  main       -> origin/main
   438ceef..70e2ae4  gh-pages   -> origin/gh-pages

Here are the logs. On Nov 21 14:02:27 I did the manual fetch & pull, and then some restarts, which is why things are working again after that point.

pss-log-dump-nov-21-2022.log

The following notebook will reproduce the issue:

The value of f depends on both x and y, implying that x and y are codependent. It seems like PlutoSliderServer's analysis doesn't recognize this:

I haven't done much more testing beyond finding this simplified MWE, but it seems this is an issue with codependents and friends, since Pluto calculates the topology of this notebook without any issues.

When converting this notebook (link to github gist) to a slider server notebook, the notebook returns a StateOfOutSync error after uploading a file and then trying to change the model variable. The notebook works correctly inside of a pluto notebook but fails to update after uploading a file.

The full error returned in the web console is:

#######################**************************########################
PlutoError: StateOutOfSync: Failed to apply patches.
Please report this: https://github.com/fonsp/Pluto.jl/issues adding the info below:
failing path: status_tree.subtasks.run.subtasks.evaluate.subtasks.1.finished_at 
notebook previous value: Not Found
patch: undefined
#######################**************************########################
Error: [Immer] minified error nr: 15 'status_tree/subtasks/run/subtasks/evaluate/subtasks/1/finished_at'. 
Find the full error at: https://bit.ly/3cXEKWf

So I am trying to use a button to trigger a recalculation (in my actual example there are a lot of variables to be set prior to a recalculation of an expensive bit of code) - I have this working in a Pluto notebook (also using Refs to de-bind the variables), but this doesnt work when pushed to the SliderServer.

I have created this simplified example and the button only causes a recalculation the very first time.

# ╔═╡ a014ff5c-bba4-4e0d-bf67-bdfb2654d5c1
using PlutoUI

# ╔═╡ 1a026e8a-ed1e-11ee-3520-518d87dd0688
@bind go2 Button("Recalculate!")

# ╔═╡ 7f2a2ad7-0bc3-4880-b947-c69eb554b83a
begin 
	go2
	rand()
end

Is there something I'm doing wrong? (this simplified situation works as I would expect on Pluto but differently via the SliderServer) or is there some work around I have to do?

One central aspect of PlutoSliderServer is the plutohash, which denotes when a file has changed.

Currently plutohash = base64urlencode ∘ sha256. This does not take into account running PlutoHooks use_state, which may change values without neither the file being changed, nor bonds being changed.

If I understood it right, PlutoHooks @use_state is already the perfect abstraction - the hash just needs to include also all plutohook @use_state current values. (I have no clue how easy this in reality, just conceptually it looks easy).

Do you know a workaround for now?

Concretely it would be great to use PlutoHooks to update things in the background automatically by e.g. file triggers, and still be able to serve the Pluto notebook to many clients where every client can play with their own bonds (what PlutoSliderServer does, but maybe Pluto itself can already somehow do it).

• the common hooks state should be seen by all
• the bonds are only seen by each individual

Is there a way to know if some cells failed while running export_notebook or export_directory?
When running PlutoSliderServer.jl on CI, it would be good to know if the build worked or not

The main page showing all hosted notebooks is currently rather minimalistic. Having it in Pluto style would be nice.

In addition, it would be great if the hosted notebooks themselves would have a link back to the main page (e.g. using the Pluto logic as in "standard" Pluto notebooks).

For example, suppose that someone works in a PlutoSliderServer notebook and accidentally closes the tab. It would be nice to save and reload the state when we reload the page, for example by saving in the localStorage

https://computationalthinking.mit.edu/Spring21/week1/ returns 404

First of all I want to say thank you so much for the developers. This is an amazing tool!
Second, I was able to use github pages to host my notebook, but for some reason the sliders are greyed out in the notebook (I only use the bind feature). Is there any step I'm missing in the configurations? Seems like it should work from what I read in the readme file.

Hello!

Thanks for all the hard work the Pluto team has put into this.

I don't have a MWE, but this is something I've observed for weeks now on a personal server. I have a PlutoSliderServer running on a virtual machine. Based on a cronjob, the virtual machine recomputes some data every 24 hours, restarts the SliderServer, shows a table of data, and (in theory) plots the results.

The data table shows up as normal, however, unless you open the page in an incognito window, commit a git change, or manually delete browser data, the plots and UI functions are NOT updated.

I tried adding a @bind go button("RECOMPUTE"), but this had no effect. The only way that the UI faithfully updates is if I commit some change to the directory.

Is there a function which forces a full refresh of the underlying browser data, similar to when a git directory change is detected?

This was not enabled initially because Pkg is not thread-safe, and many notebooks included a "Pkg cell" that sets up the environment. Running mulitple notebooks in parallel was known to crash Pkg sometimes.

Nowadays, Pluto has a built-in package manager, and this built-in package manager is thread-safe (Pluto has a global Pkg lock). This means that we can safely run multiple notebooks in parallel (if they all use the built-in package manager).

We should add this feature, with a configuration Export_max_parallel_notebooks (default to 4).

PlutoSliderServer does not work on Julia 1.9 yet because of:
Roger-luo/Configurations.jl#88
JuliaLang/julia#49103

Right now, we don't use the frontmatter to set HTML metadata, because this code is skipped, we run this method directly (from here). This is because we might not have access to the Notebook object, we might only have the cached statefile.

The fix should be easy, because notebook.metadata is stored in the statefile, or it can be retrieved easily from the notebook file by loading it.

Hello,
first of all, thank you for this great package.

To use Pluto and PlutoUI beyond the scope of education it would be great to if there is an option not to display hidden cells at all, currently they are shown as white space.
Here a random example outlining the issue:

The resulting reports / dashboards would look much better if hidden cells are not displayed at all.

BR Stefan

See JuliaWeb/HTTP.jl#803

I disabled CI for 1.8 until the HTTP issue is fixed

The following notebook works fine in Pluto, but does not update after selecting a csv file when deployed on a SliderServer:

The test csv file was quite small (only 20kB), thus data amount should not be the issue here.

I am using PlutoSliderServer 0.3.9, Pluto 0.18.3 and Julia 1.7.2.

Recently I updated PlutoSliderServer for my course material from 0.3.11 to 0.3.12. Everything worked normally, except that after loading the notebooks they were not accessible at the usual address, e.g. https://bio322.epfl.ch/notebooks/pca.html showed me just a 404 error.
The index page, however, loaded normally.

Meanwhile I went back PlutoSliderServer to 0.3.11, because I wanted to serve the pages and I couldn't figure out what was wrong.

This currently works in Pluto, but not in PlutoSliderServer:

@bind x Slider(1:10)

@bind y Slider(1:x)

x, y

Why? When moving the y slider in normal Pluto, we just send the y value to the Pluto server, it sets it in the notebook process and runs the dependent cells (just cell 3). In PlutoSliderServer, moving y will send x and y together, this is our stateless idea.

Pluto does not handle this correctly (this is a bug in Pluto, not PSS): it first sets both x and y in the notebook process, and then runs the cells that depend on them: cells 2 and 3. The problem is: running cell 2 will set y to its initial value: 1, and you will always see x, 1 in the third cell.

I already have an example notebook for this: https://github.com/JuliaPluto/PlutoSliderServer.jl/blob/main/test/onedefinesanother.jl

Is there a way to catch julia code errors when running pluto notebooks with PlutoSliderServer?

When I want to run e.g. this notebook on binder (clicking the "run on binder" button in the notebook), it loads fine on binder, but I cannot edit the notebook, unless I navigate to the Pluto main page (by clicking on the Pluto logo at the top), shut down the notebook (clicking the "x" button) and restart it again (clicking on the file name). What does go wrong here? Note that I am using the custom binder url Export_binder_url = "https://mybinder.org/v2/gh/jbrea/MLCourse/binder". Opening the notebook directly on binder through this link works fine.

When running export_directory with the cache activated and state "unbaked", it looks like the file.plutostate is modified by rerunning the script once, future reruns do not modify the file.

To reproduce:

• Get a notebook file.jl
• Render it once with Export_baked_state = false and with a Export_cache_dir and get file.html, file.plutostate and some cache/<hash>.plutostate
• Store a copy of file.plutostate.old
• Render it again, the execution states: Loaded from cache, skipping notebook run
• The file.plutostate is now different from file.plutostate.old
• Make another copy file.plutostate.notthatold
• Render again!
• Now file.plutostate is the same as file.plutostate.notthatold

The slider server works perfectly locally, but the exact same notebook and versions of everything does not work remotely.

Julia v.1.7.1
Pluto v0.17.4
PlutoSliderServer v0.3.3

Starting a remote server gets me a correctly rendered notebook in the browser, but moving a slider has no effect. There's a JavaScript error in the browser console:

Uncaught (in promise) TypeError: Cannot read properties of undefined (reading 'digest')
    at hash_arraybuffer (PlutoHash.js:15)

The line referred to is:

    const hashed_buffer = await window.crypto.subtle.digest("SHA-256", data)

This problem occurs both when starting the server with 0.0.0.0 and with 127.0.0.1 and accessing through a reverse proxy.

Hi!

I noticed this before - but once I have PlutoSliderServer started (using run_directory) - I can add new notebooks, but they are not actually detected.

According to the code that should be checked every 0.5s

But for me it doesnt work.

Note that the sliderserver does tell me at the end:
Info: Watching directory for changes...

edit: just noticed I used SliderServer 0.3.21 -> restarting right now (but takes 20min or so) before I could test again

An HTML export includes the Process status data: fonsp/Pluto.jl#2399

We should add an option to clear this from the exports generated by PlutoSliderServer, to:

• Avoid a slightly confusing situation when launching a featured notebook: while loading, it will show a Status tab where everything has completed.
• Canonalize exports a bit.
• It feels more "clean"