@@ -5,8 +5,8 @@
 #   2. For blocks with a local `notebook`: run the notebook headlessly, copy the
 #      .jl and generated .plutostate into the build output, and fill in
 #      `resolved_notebook` / `resolved_state` on the block.
-#   3. For blocks with a `url`: pass `url`/`state` straight through to the
-#      resolved fields.
+#   3. For blocks without `notebook`: nothing to resolve — the pre-hosted URLs
+#      are already sitting in `pluto_params` and will be emitted verbatim.
 #   4. If any PlutoBlock was seen, push one `RawHTMLHeadContent` onto the
 #      site's `format.assets` so every page loads Pluto's frontend.
 
@@ -62,11 +62,7 @@ function _materialise_notebooks!(doc, blocks)
     asset_dir   = joinpath(build_root, _PLUTO_ASSET_SUBDIR)
 
     for (page, block) in blocks
-        if block.url !== nothing
-            block.resolved_notebook = block.url
-            block.resolved_state    = block.state
-            continue
-        end
+        block.notebook === nothing && continue  # pre-hosted: pluto_params carries the URLs
 
         nb_rel = block.notebook::String
         nb_src = isabspath(nb_rel) ? nb_rel : normpath(joinpath(source_root, nb_rel))
 
@@ -1,20 +1,24 @@
 # Render a PlutoBlock as the HTML a Pluto frontend needs to bring itself online:
-# the `launch-parameters` <script> that sets window.pluto_{notebookfile,state…},
-# followed by the <pluto-editor> placeholder that the JS in <head> hydrates.
+# the `launch-parameters` <script> that sets window.pluto_* globals, followed
+# by the <pluto-editor> placeholder that the JS in <head> hydrates.
 
 function Documenter.HTMLWriter.domify(dctx::DCtx, ::Node, block::PlutoBlock)
     page_url = Documenter.HTMLWriter.get_url(dctx.ctx, dctx.navnode.page)
-    nb_href    = _resolve_href(page_url, block.resolved_notebook)
-    state_href = _resolve_href(page_url, block.resolved_state)
 
-    launch_params = """
-    window.pluto_notebookfile = $(_js_string(nb_href));
-    window.pluto_disable_ui = $(_js_string(block.disable_ui));
-    window.pluto_binder_url = $(_js_string(block.binder));
-    window.pluto_statefile = $(_js_string(state_href));
-    window.pluto_recording_url = undefined;
-    window.pluto_recording_audio_url = undefined;
-    """
+    # Start from the user's pluto_* params, then overlay the locally-resolved
+    # notebook/state paths (if any) so they win over anything the user set.
+    params = copy(block.pluto_params)
+    if block.resolved_notebook !== nothing
+        params["pluto_notebookfile"] = Documenter.HTMLWriter.relhref(page_url, block.resolved_notebook)
+    end
+    if block.resolved_state !== nothing
+        params["pluto_statefile"] = Documenter.HTMLWriter.relhref(page_url, block.resolved_state)
+    end
+
+    launch_params = join(
+        ["window.$k = $(_js_string(params[k]));" for k in sort!(collect(keys(params)))],
+        "\n",
+    )
 
     editor = DOM.Tag(Symbol("pluto-editor"))[ :class => "loading" ](
         DOM.Tag(:progress)[
@@ -30,34 +34,18 @@ function Documenter.HTMLWriter.domify(dctx::DCtx, ::Node, block::PlutoBlock)
     ]
 end
 
-# target is either an external URL (http/https), or a build-root-relative path
-# like "pluto_notebooks/foo.jl". For the relative case, turn it into a
-# page-relative href via Documenter's own helper so that baseurl/prettyurl
-# deployments keep working.
-function _resolve_href(page_url::AbstractString, target::Union{String,Nothing})
-    target === nothing && return ""
-    _is_absolute_url(target) && return target
-    return Documenter.HTMLWriter.relhref(page_url, target)
-end
-
-_is_absolute_url(s::AbstractString) =
-    startswith(s, "http://") || startswith(s, "https://") || startswith(s, "//") || startswith(s, "/")
-
-# Minimal JS string literal: JSON encoding is a superset of JS-string syntax for
-# our purposes (URLs), and Julia's repr() for String happens to produce a valid JS string too. Use repr.
-
 struct JSLiteral
     x
 end
 
-
-_js_string(s::AbstractString) = repr(s)
-_js_string(s::Nothing) = "undefined"
-_js_string(s::Bool) = repr(s)
-_js_string(s::Number) = repr(s)
-_js_string(s::JSLiteral) = s.x
-
-
-
-
-
+# JS literal encoding for the scalar types TOML can produce, plus Nothing
+# (→ `undefined`) and JSLiteral (raw unquoted JS, e.g. `undefined`, function
+# literals) for user-provided pluto_* values that need to be something other
+# than a string/number/bool.
+_js_string(s::AbstractString) = repr(String(s))
+_js_string(s::Nothing)        = "undefined"
+_js_string(s::Bool)           = s ? "true" : "false"
+_js_string(s::Number)         = string(s)
+_js_string(s::AbstractVector) = "[" * join((_js_string(x) for x in s), ", ") * "]"
+_js_string(s::AbstractDict)   = "{" * join(("$(repr(String(k))): $(_js_string(v))" for (k,v) in s), ", ") * "}"
+_js_string(s::JSLiteral)      = s.x
@@ -7,39 +7,36 @@
     PlutoBlock
 
 MarkdownAST element produced by the `@pluto` expander. Holds the parsed
-attributes of one ```` ```@pluto ```` code block:
+attributes of one ```` ```@pluto ```` code block.
+
+The only recognised special key is:
 
 - `notebook :: Union{String, Nothing}` — path to a local `.jl` file, relative to
   the Documenter source root. When set, the plugin runs the notebook headlessly
   and copies both the `.jl` and the generated `.plutostate` into the build
-  output.
-- `url :: Union{String, Nothing}` — URL of a hosted notebook file
-  (`pluto_notebookfile`).
-- `state :: Union{String, Nothing}` — URL of a hosted `.plutostate` file.
-- `binder :: Union{String, Nothing}` — optional Binder launch URL.
-- `disable_ui :: Bool` — whether to hide Pluto's UI chrome (default `true`).
+  output, then exposes them to the frontend as `window.pluto_notebookfile` and
+  `window.pluto_statefile`.
 
-Exactly one of `notebook` or `url` must be set. When `url` is set, `state` is
-required too.
+Every other key must start with `pluto_` and is forwarded verbatim to the
+frontend as `window.<key> = <value>;` in the launch-parameters script. Typical
+keys for pre-hosted notebooks are `pluto_notebookfile` and `pluto_statefile`;
+see Pluto's frontend for the full list (`pluto_disable_ui`, `pluto_binder_url`,
+`pluto_recording_url`, …).
 
-The resolved URLs used by the frontend (`window.pluto_notebookfile`,
-`window.pluto_statefile`) are filled in by the builder step before domify runs.
+Exactly one of the following must hold: `notebook` is set, *or* both
+`pluto_notebookfile` and `pluto_statefile` are set.
 """
 mutable struct PlutoBlock <: Documenter.AbstractDocumenterBlock
-    notebook   :: Union{String, Nothing}
-    url        :: Union{String, Nothing}
-    state      :: Union{String, Nothing}
-    binder     :: Union{String, Nothing}
-    disable_ui :: Bool
-    # Filled in by the builder: final URLs the rendered <script> will point at.
-    # For a local `notebook`, these become build-relative paths.
+    notebook     :: Union{String, Nothing}
+    pluto_params :: Dict{String, Any}
+    # Filled in by the builder for local notebooks: build-root-relative paths
+    # that domify turns into page-relative hrefs.
     resolved_notebook :: Union{String, Nothing}
     resolved_state    :: Union{String, Nothing}
 end
 
-function PlutoBlock(; notebook=nothing, url=nothing, state=nothing, binder=nothing, disable_ui=true)
-    PlutoBlock(notebook, url, state, binder, disable_ui, nothing, nothing)
-end
+PlutoBlock(; notebook=nothing, pluto_params=Dict{String,Any}()) =
+    PlutoBlock(notebook, pluto_params, nothing, nothing)
 
 abstract type PlutoExpander <: Documenter.Expanders.ExpanderPipeline end
 Selectors.order(::Type{PlutoExpander}) = 7.9
@@ -57,36 +54,36 @@ function Selectors.runner(::Type{PlutoExpander}, node, page, doc)
     return
 end
 
-# The block body is TOML. Keys accepted (case-insensitive, snake-cased):
-#   notebook | url | state | binder | disable_ui
+# The block body is TOML. `notebook` is special; every other key must start
+# with `pluto_` and is forwarded as-is to `window.<key>` in the launch script.
 function _parse_pluto_block(code::AbstractString)
     raw = isempty(strip(code)) ? Dict{String,Any}() : TOML.parse(code)
-    # Normalise keys to lowercase so `Notebook=` and `notebook=` both work.
-    kv = Dict{String,Any}(lowercase(k) => v for (k, v) in raw)
-
-    notebook  = get(kv, "notebook", nothing)
-    url       = get(kv, "url", nothing)
-    state     = get(kv, "state", nothing)
-    binder    = get(kv, "binder", nothing)
-    disable_ui = get(kv, "disable_ui", true)
 
-    if notebook === nothing && url === nothing
-        error("`@pluto` block must set either `notebook = \"path/to/notebook.jl\"` or `url = \"…\"` + `state = \"…\"`.")
+    notebook     = nothing
+    pluto_params = Dict{String,Any}()
+    for (k, v) in raw
+        if k == "notebook"
+            v isa AbstractString || error("`@pluto`: `notebook` must be a string.")
+            notebook = String(v)
+        elseif startswith(k, "pluto_")
+            pluto_params[k] = v
+        else
+            error("`@pluto`: unknown key `$k`. Use `notebook = \"…\"` or a key starting with `pluto_`.")
+        end
     end
-    if notebook !== nothing && url !== nothing
-        error("`@pluto` block sets both `notebook` and `url`; use exactly one.")
+
+    # Default: hide Pluto's UI chrome in docs builds.
+    get!(pluto_params, "pluto_disable_ui", true)
+
+    has_urls = haskey(pluto_params, "pluto_notebookfile") && haskey(pluto_params, "pluto_statefile")
+    if notebook === nothing && !has_urls
+        error("`@pluto` block must set either `notebook = \"path/to/notebook.jl\"` or both `pluto_notebookfile` and `pluto_statefile`.")
     end
-    if url !== nothing && state === nothing
-        error("`@pluto` block with `url` must also set `state = \"…plutostate\"`.")
+    if notebook !== nothing && (haskey(pluto_params, "pluto_notebookfile") || haskey(pluto_params, "pluto_statefile"))
+        error("`@pluto` block sets `notebook` together with `pluto_notebookfile`/`pluto_statefile`; use one or the other.")
     end
 
-    PlutoBlock(;
-        notebook   = notebook isa AbstractString ? String(notebook) : nothing,
-        url        = url      isa AbstractString ? String(url)      : nothing,
-        state      = state    isa AbstractString ? String(state)    : nothing,
-        binder     = binder   isa AbstractString ? String(binder)   : nothing,
-        disable_ui = Bool(disable_ui),
-    )
+    return PlutoBlock(; notebook, pluto_params)
 end
 
 # Documenter's search-index and link-check phases flatten pages to plain text
 
@@ -6,25 +6,35 @@ const DP = DocumenterPluto
 
 @testset "block parsing" begin
     b = DP._parse_pluto_block("""
-    url   = "https://example.com/n.jl"
-    state = "https://example.com/n.plutostate"
+    pluto_notebookfile = "https://example.com/n.jl"
+    pluto_statefile    = "https://example.com/n.plutostate"
     """)
     @test b isa DP.PlutoBlock
-    @test b.url == "https://example.com/n.jl"
-    @test b.state == "https://example.com/n.plutostate"
     @test b.notebook === nothing
-    @test b.disable_ui == true
+    @test b.pluto_params["pluto_notebookfile"] == "https://example.com/n.jl"
+    @test b.pluto_params["pluto_statefile"]    == "https://example.com/n.plutostate"
+    @test b.pluto_params["pluto_disable_ui"]   == true  # default
 
     b2 = DP._parse_pluto_block("""
-    notebook   = "notebooks/intro.jl"
-    disable_ui = false
+    notebook         = "notebooks/intro.jl"
+    pluto_disable_ui = false
+    pluto_binder_url = "https://mybinder.org/…"
     """)
     @test b2.notebook == "notebooks/intro.jl"
-    @test b2.disable_ui == false
+    @test b2.pluto_params["pluto_disable_ui"] == false
+    @test b2.pluto_params["pluto_binder_url"] == "https://mybinder.org/…"
 
+    # empty block rejected
     @test_throws Exception DP._parse_pluto_block("")
-    @test_throws Exception DP._parse_pluto_block("""notebook = "a"
-                                                    url      = "b" """)
+    # can't mix local notebook with explicit pluto_notebookfile
+    @test_throws Exception DP._parse_pluto_block("""
+        notebook           = "a.jl"
+        pluto_notebookfile = "https://example.com/n.jl"
+        pluto_statefile    = "https://example.com/n.plutostate"
+        """)
+    # pluto_statefile required alongside pluto_notebookfile
+    @test_throws Exception DP._parse_pluto_block("""pluto_notebookfile = "https://example.com/n.jl" """)
+    # unknown (non-pluto_) key rejected
     @test_throws Exception DP._parse_pluto_block("""url = "https://example.com/n.jl" """)
 end
 
@@ -43,8 +53,8 @@ end
         # Test
 
         ```@pluto
-        url   = "https://example.com/n.jl"
-        state = "https://example.com/n.plutostate"
+        pluto_notebookfile = "https://example.com/n.jl"
+        pluto_statefile    = "https://example.com/n.plutostate"
         ```
         """)
 
@@ -63,5 +73,6 @@ end
         @test occursin("pluto-editor", html)
         @test occursin("https://example.com/n.jl", html)
         @test occursin("https://example.com/n.plutostate", html)
+        @test occursin("window.pluto_disable_ui = true;", html)
     end
 end