config :openagents, OpenAgentsWeb.Endpoint,

  # Binding to loopback ipv4 address prevents access from other machines.

  # Change to `ip: {0, 0, 0, 0}` to allow access from other machines.

  http: [ip: {127, 0, 0, 1}],

  # 4000 unless `PORT` says otherwise. Another agent verifying a git-forge

  # receipt needs the canonical port free, and moving this server aside should

  # not mean editing checked-in config to do it.

  http: [ip: {127, 0, 0, 1}, port: String.to_integer(System.get_env("PORT") || "4000")],

  check_origin: false,

  code_reloader: true,

  debug_errors: true,

  ## Examples

      <Layouts.app flash={@flash}>

      <Layouts.app flash={@flash} sidebar_sections={assigns[:sidebar_sections]}>

        <h1>Content</h1>

      </Layouts.app>

    default: nil,

    doc: "the current [scope](https://phoenix.hexdocs.pm/scopes.html)"

  attr :sidebar_sections, :any,

    default: %{},

    doc: """

    Which sidebar sections the reader has collapsed, from their cookie. Passed

    down rather than read ambiently so a page that renders a sidebar cannot

    quietly lose it -- `test/openagents_web/sidebar_state_test.exs` fails on a

    call site that omits it.

    """

  attr :wide, :boolean,

    default: false,

    doc: "use a wider content column for catalog and list surfaces"

  def app(assigns) do

    ~H"""

    <div class="h-screen flex overflow-hidden bg-background">

      <.sidebar :if={@current_scope} current_scope={@current_scope}>

      <.sidebar

        :if={@current_scope}

        current_scope={@current_scope}

        sidebar_sections={@sidebar_sections || %{}}

      >

        <:extra>{render_slot(@sidebar_extra)}</:extra>

      </.sidebar>

  The component library is advertised outside production only. It documents

  the parts a page is built from rather than anything a visitor came for.

  """

  attr :current_user, :map, default: nil, doc: "used only to decide whether admin shows"

  # Required, with no default. Defaulting to nil made a forgotten attribute

  # look exactly like a signed-out visitor, and the docs and component-library

  # layouts both forgot it -- so an operator browsing either surface silently

  # lost the Admin row. `nil` is still a fine thing to pass; it just has to be

  # said.

  attr :current_user, :any,

    required: true,

    doc: "the scope whose access decides the admin row; nil for a visitor"

  def sidebar_footer(assigns) do

    assigns =

  the section you are reading would hide your own location.

  """

  attr :title, :string, required: true

  attr :open, :boolean, default: false, doc: "first paint only; the reader's choice wins after"

  attr :open, :boolean,

    default: false,

    doc: "the seed, used until the reader has said otherwise for this section"

  attr :state, :map,

    default: %{},

    doc: """

    The reader's collapsed/expanded sections, keyed by element id, as carried

    from their cookie by `OpenAgentsWeb.Plugs.SidebarSections`. Applied here,

    on the server, so a full page load paints what they chose rather than

    painting the seed and having a hook correct it a frame later.

    """

  attr :id, :string, default: nil, doc: "defaults to a slug of the title"

  slot :inner_block, required: true

    # assigns as nil, so `assign_new` would consider it present and never

    # compute. A hook without a DOM id silently does not run.

    assigns =

      assign(assigns, :id, assigns.id || "sidebar-section-" <> section_slug(assigns.title))

      assigns

      |> assign(:id, assigns.id || "sidebar-section-" <> section_slug(assigns.title))

      |> then(fn assigns ->

        assign(assigns, :open, Map.get(assigns.state, assigns.id, assigns.open))

      end)

    ~H"""

    <details

    a section the reader had closed. With no JavaScript the seed governs and

    the sidebar still works. --%>

    <script :type={Phoenix.LiveView.ColocatedHook} name=".SidebarSection">

      const KEY = "sidebar-sections"

      // A cookie rather than sessionStorage, because the server has to know.

      // Several sidebar destinations live in different live sessions, so

      // moving between them is a full page load; state the server cannot read

      // arrives too late, and the reader watches a section they collapsed

      // paint open and then shut. See `OpenAgentsWeb.Plugs.SidebarSections`.

      const KEY = "sidebar_sections"

      const read = () => {

        const entry = document.cookie

          .split("; ")

          .find((part) => part.startsWith(KEY + "="))

        if (!entry) return {}

        try {

          return JSON.parse(sessionStorage.getItem(KEY)) || {}

          return JSON.parse(decodeURIComponent(entry.slice(KEY.length + 1))) || {}

        } catch (_error) {

          return {}

        }

      }

      const write = (state) => {

        try {

          sessionStorage.setItem(KEY, JSON.stringify(state))

        } catch (_error) {

          // A full or unavailable store costs the reader their open sections

          // on the next navigation, which is the behaviour without the hook.

        }

        const value = encodeURIComponent(JSON.stringify(state))

        // Session-scoped, same-site, and readable by script because script is

        // what maintains it. It holds which sidebar sections are open, so it

        // is not worth protecting and must not be sent cross-site.

        document.cookie = KEY + "=" + value + "; path=/; samesite=lax"

      }

      export default {

  end

  attr :current_scope, :map, required: true

  attr :sidebar_sections, :map, required: true

  slot :extra, doc: "rows contributed by the current page"

  defp sidebar(assigns) do

    assigns = assign(assigns, :agent_surfaces?, agent_surfaces?(assigns[:current_scope]))

    assigns =

      assigns

      |> assign(:agent_surfaces?, agent_surfaces?(assigns[:current_scope]))

    ~H"""

    <aside id="sidebar" class="sidebar hidden lg:flex">

      the two things it can reach -- and reading as a group says that in a way

      six flat rows cannot. Open by default: grouping is for orientation here,

      not for hiding. --%>

      <Layouts.sidebar_section :if={@agent_surfaces?} title="Sarah" open>

      <Layouts.sidebar_section

        :if={@agent_surfaces?}

        title="Sarah"

        open

        state={@sidebar_sections}

      >

        <Layouts.sidebar_link path={~p"/chat"} label="Chat" icon="chat" patchable={false} />

        <Layouts.sidebar_link

          path={~p"/computers"}

      <Layouts.sidebar_section

        :for={section <- OpenAgentsWeb.ComponentCatalog.sections()}

        title={section.title}

        state={assigns[:sidebar_sections] || %{}}

        open={Enum.any?(section.items, &(&1.slug == @active_component))}

      >

        <Layouts.sidebar_link

        />

      </Layouts.sidebar_section>

      <Layouts.sidebar_section title="Reference" open={@active_component == :icons}>

      <Layouts.sidebar_section

        title="Reference"

        state={assigns[:sidebar_sections] || %{}}

        open={@active_component == :icons}

      >

        <Layouts.sidebar_link

          path={~p"/components/icons"}

          label="Icons"

      </Layouts.sidebar_section>

    </nav>

    <Layouts.sidebar_footer />

    <Layouts.sidebar_footer current_user={@current_scope} />

  </aside>

  <div class="docs-column">

      <Layouts.sidebar_section

        :for={section <- OpenAgentsWeb.DocsCatalog.sections()}

        title={section.title}

        state={assigns[:sidebar_sections] || %{}}

        open={Enum.any?(section.items, &(&1.slug == @active_page))}

      >

        <Layouts.sidebar_link

      </Layouts.sidebar_section>

    </nav>

    <Layouts.sidebar_footer />

    <Layouts.sidebar_footer current_user={@current_scope} />

  </aside>

  <div class="docs-column">

  @impl true

  def render(assigns) do

    ~H"""

    <Layouts.app flash={@flash} current_scope={@current_scope}>

    <Layouts.app

      flash={@flash}

      sidebar_sections={assigns[:sidebar_sections]}

      current_scope={@current_scope}

    >

      <main id="admin-forge-page" class="app-shell admin-shell">

        <section class="admin" aria-label="Forge deploy lane">

          <h1>Forge — {@repo}</h1>

  @impl true

  def render(assigns) do

    ~H"""

    <Layouts.app flash={@flash} current_scope={@current_scope} title="Admin" wide>

    <Layouts.app

      flash={@flash}

      sidebar_sections={assigns[:sidebar_sections]}

      current_scope={@current_scope}

      title="Admin"

      wide

    >

      <section class="panel" aria-label="Accounts">

        <header class="panel__header">

          <h1 class="panel__title">Accounts</h1>

  @impl true

  def render(assigns) do

    ~H"""

    <Layouts.app flash={@flash} current_scope={@current_scope} title="Voice recordings" wide>

    <Layouts.app

      flash={@flash}

      sidebar_sections={assigns[:sidebar_sections]}

      current_scope={@current_scope}

      title="Voice recordings"

      wide

    >

      <section id="admin-recordings-page" class="panel" aria-label="Voice call recordings">

        <header class="panel__header">

          <div>

  @impl true

  def render(assigns) do

    ~H"""

    <Layouts.app flash={@flash} current_scope={@current_scope} title="SCV Codex accounts">

    <Layouts.app

      flash={@flash}

      sidebar_sections={assigns[:sidebar_sections]}

      current_scope={@current_scope}

      title="SCV Codex accounts"

    >

      <main id="admin-scv-accounts-page" class="app-shell admin-shell">

        <section class="admin space-y-8" aria-labelledby="scv-codex-heading">

          <header class="admin-heading">

  @impl true

  def render(assigns) do

    ~H"""

    <Layouts.app flash={@flash} current_scope={@current_scope}>

    <Layouts.app

      flash={@flash}

      sidebar_sections={assigns[:sidebar_sections]}

      current_scope={@current_scope}

    >

      <main id="api-token-settings" class="mx-auto w-full max-w-4xl space-y-8 px-4 py-10">

        <header class="space-y-2">

          <h1 class="text-3xl font-semibold tracking-tight">API tokens</h1>

  def render(assigns) do

    ~H"""

    <Layouts.app flash={@flash} current_scope={@current_scope}>

    <Layouts.app

      flash={@flash}

      sidebar_sections={assigns[:sidebar_sections]}

      current_scope={@current_scope}

    >

      <h1 class="text-2xl font-bold mb-4">Assignees</h1>

      <%= if @assignees == [] do %>

  @impl true

  def render(assigns) do

    ~H"""

    <Layouts.app flash={@flash} current_scope={@current_scope} title="Changelog">

    <Layouts.app

      flash={@flash}

      sidebar_sections={assigns[:sidebar_sections]}

      current_scope={@current_scope}

      title="Changelog"

    >

      <main id="changelog-page" class="app-shell changelog-shell">

        <section class="changelog" aria-label="Changelog">

          <header class="changelog-heading">

  @impl true

  def render(assigns) do

    ~H"""

    <Layouts.app flash={@flash} title="Chat" current_scope={@current_scope} flush>

    <Layouts.app

      flash={@flash}

      sidebar_sections={assigns[:sidebar_sections]}

      title="Chat"

      current_scope={@current_scope}

      flush

    >

      <%!-- Export is the conversation's action, so it belongs beside the

      conversation's name rather than as a permanent sidebar row competing with

      the places you can go. --%>

  @impl true

  def render(assigns) do

    ~H"""

    <Layouts.app flash={@flash} current_scope={assigns[:current_scope]} title="Code">

    <Layouts.app

      flash={@flash}

      sidebar_sections={assigns[:sidebar_sections]}

      current_scope={assigns[:current_scope]}

      title="Code"

    >

      <main id="code-blob-page" class="app-shell code-shell">

        <section class="code" aria-label="File view">

          <header class="code-heading">

  @impl true

  def render(assigns) do

    ~H"""

    <Layouts.app flash={@flash} current_scope={@current_scope} title="Commit">

    <Layouts.app

      flash={@flash}

      sidebar_sections={assigns[:sidebar_sections]}

      current_scope={@current_scope}

      title="Commit"

    >

      <main id="code-commit-page" class="app-shell code-shell">

        <section class="code" aria-label="Commit view">

          <header class="code-heading">

  @impl true

  def render(assigns) do

    ~H"""

    <Layouts.app flash={@flash} current_scope={@current_scope} title="Code">

    <Layouts.app

      flash={@flash}

      sidebar_sections={assigns[:sidebar_sections]}

      current_scope={@current_scope}

      title="Code"

    >

      <main id="code-repo-page" class="app-shell code-shell">

        <section class="code" aria-label="Repository">

          <header class="code-heading">

        visitor sees.

      </p>

      <div class="demo-frame">

        <Layouts.sidebar_footer />

        <Layouts.sidebar_footer current_user={nil} />

      </div>

    </div>

    """

  @impl true

  def render(assigns) do

    ~H"""

    <Layouts.app flash={@flash} current_scope={assigns[:current_scope]} title="Computers">

    <Layouts.app

      flash={@flash}

      sidebar_sections={assigns[:sidebar_sections]}

      current_scope={assigns[:current_scope]}

      title="Computers"

    >

      <main id="computers-page" class="app-shell computers-shell">

        <section id="computers-manager" class="computers" aria-label="Paired computers">

          <div class="computers__inner">

  @impl true

  def render(%{current_user: user} = assigns) when not is_nil(user) do

    ~H"""

    <Layouts.app flash={@flash} current_scope={@current_scope} title="Home" wide>

    <Layouts.app

      flash={@flash}

      sidebar_sections={assigns[:sidebar_sections]}

      current_scope={@current_scope}

      title="Home"

      wide

    >

      <div class="dashboard">

        <div class="dashboard__main">

          <section class="panel" aria-labelledby="dashboard-issues">

  def render(assigns) do

    ~H"""

    <Layouts.app flash={@flash} current_scope={@current_scope} flush>

    <Layouts.app

      flash={@flash}

      sidebar_sections={assigns[:sidebar_sections]}

      current_scope={@current_scope}

      flush

    >

      <div class="landing-page">

        <Landing.layout_lines />

  def render(assigns) do

    ~H"""

    <Layouts.app flash={@flash} current_scope={@current_scope} title="Issues" wide>

    <Layouts.app

      flash={@flash}

      sidebar_sections={assigns[:sidebar_sections]}

      current_scope={@current_scope}

      title="Issues"

      wide

    >

      <Circle.issue_toolbar>

        <:leading>

          <Circle.view_tabs>

  def render(assigns) do

    ~H"""

    <Layouts.app flash={@flash} current_scope={@current_scope}>

    <Layouts.app

      flash={@flash}

      sidebar_sections={assigns[:sidebar_sections]}

      current_scope={@current_scope}

    >

      <h1 class="text-2xl font-bold mb-4">New issue</h1>

      <.form

  def render(assigns) do

    ~H"""

    <Layouts.app flash={@flash} current_scope={@current_scope} wide>

    <Layouts.app

      flash={@flash}

      sidebar_sections={assigns[:sidebar_sections]}

      current_scope={@current_scope}

      wide

    >

      <Circle.issue_detail>

        <:heading>

          <.form

  def render(assigns) do

    ~H"""

    <Layouts.app flash={@flash} current_scope={@current_scope}>

    <Layouts.app

      flash={@flash}

      sidebar_sections={assigns[:sidebar_sections]}

      current_scope={@current_scope}

    >

      <div class="flex items-center justify-between mb-4">

        <h1 class="text-2xl font-bold">Labels</h1>

      </div>

  @impl true

  def render(assigns) do

    ~H"""

    <Layouts.app flash={@flash} current_scope={assigns[:current_scope]} title="Leaderboard">

    <Layouts.app

      flash={@flash}

      sidebar_sections={assigns[:sidebar_sections]}

      current_scope={assigns[:current_scope]}

      title="Leaderboard"

    >

      <main id="leaderboard-page" class="app-shell leaderboard-shell">

        <section class="leaderboard" aria-label="Token leaderboard">

          <header class="leaderboard-heading">

  @impl true

  def render(assigns) do

    ~H"""

    <Layouts.app flash={@flash} current_scope={@current_scope} title="Memory" wide>

    <Layouts.app

      flash={@flash}

      sidebar_sections={assigns[:sidebar_sections]}

      current_scope={@current_scope}

      title="Memory"

      wide

    >

      <.memory_manager

        memory_records={@memory_records}

        memory_status={@memory_status}

  def render(assigns) do

    ~H"""

    <Layouts.app flash={@flash} current_scope={@current_scope}>

    <Layouts.app

      flash={@flash}

      sidebar_sections={assigns[:sidebar_sections]}

      current_scope={@current_scope}

    >

      <div class="flex items-center justify-between mb-4">

        <h1 class="text-2xl font-bold">Milestones</h1>

      </div>

  @impl true

  def render(assigns) do

    ~H"""

    <Layouts.app flash={@flash} current_scope={@current_scope} title="Status">

    <Layouts.app

      flash={@flash}

      sidebar_sections={assigns[:sidebar_sections]}

      current_scope={@current_scope}

      title="Status"

    >

      <main id="network-status-page" class="app-shell status-shell">

        <section class="status" aria-label="Network status">

          <header class="status-heading">

  def render(assigns) do

    ~H"""

    <Layouts.app flash={@flash} current_scope={@current_scope} title="Projects" wide>

    <Layouts.app

      flash={@flash}

      sidebar_sections={assigns[:sidebar_sections]}

      current_scope={@current_scope}

      title="Projects"

      wide

    >

      <.form

        for={@form}

        id="new-project-form"

  def render(assigns) do

    ~H"""

    <Layouts.app flash={@flash} current_scope={@current_scope}>

    <Layouts.app

      flash={@flash}

      sidebar_sections={assigns[:sidebar_sections]}

      current_scope={@current_scope}

    >

      <div class="flex items-center justify-between mb-4">

        <h1 class="text-2xl font-bold">{@project.title}</h1>

        <.link

  def render(assigns) do

    ~H"""

    <Layouts.app flash={@flash} current_scope={assigns[:current_scope]}>

    <Layouts.app

      flash={@flash}

      sidebar_sections={assigns[:sidebar_sections]}

      current_scope={assigns[:current_scope]}

    >

      <main

        id="ui-gallery"

        class="mx-auto flex h-dvh w-full max-w-[1040px] flex-col overflow-y-auto border-x border-[var(--line)] bg-[var(--ink-surface)]"

  @impl true

  def render(assigns) do

    ~H"""

    <Layouts.app flash={@flash} current_scope={@current_scope}>

    <Layouts.app

      flash={@flash}

      sidebar_sections={assigns[:sidebar_sections]}

      current_scope={@current_scope}

    >

      <main id="voice-spike" class="app-shell">

        <header class="command-bar">

          <div class="brand-lockup"><span class="brand-name">SARAH / VOICE SPIKE</span></div>

defmodule OpenAgentsWeb.Plugs.SidebarSections do

  @moduledoc """

  Carries which sidebar sections the reader has collapsed into the session, so

  the server can render them collapsed on the first paint.

  The reader's choice used to live only in the browser, applied by a hook after

  the document arrived. That is correct but late: several sidebar destinations

  cross live sessions, so moving between them is a full page load, and the

  server -- knowing nothing -- sent every section open. The reader watched a

  section they had collapsed appear and then collapse again on every

  navigation.

  A preference that has to affect the first paint has to travel with the

  request, which for a browser means a cookie. The hook writes one; this reads

  it into the session, where a LiveView mount can see it.

  The value is a reader's own UI state, so it is treated as untrusted input and

  bounded on the way in: unparseable JSON, a non-object, oversized content, or

  keys that are not section ids are dropped rather than passed inward.

  """

  @behaviour Plug

  @cookie "sidebar_sections"

  @session_key "sidebar_sections"

  # A section id per collapsible group, and no group has many. Well past what

  # the application renders, and far short of anything worth storing.

  @maximum_sections 64

  @maximum_bytes 2_048

  @id_pattern ~r/^sidebar-section-[a-z0-9-]{1,64}$/

  @impl Plug

  def init(options), do: options

  @impl Plug

  def call(conn, _options) do

    conn = Plug.Conn.fetch_cookies(conn)

    sections = parse(conn.cookies[@cookie])

    # Written only on change. The session cookie is re-signed and re-sent on

    # every write, and this value changes when a reader clicks a caret, not

    # when they load a page.

    if sections == Plug.Conn.get_session(conn, @session_key) do

      conn

    else

      Plug.Conn.put_session(conn, @session_key, sections)

    end

  end

  @doc "The sections map held in a LiveView's session, or an empty map."

  @spec from_session(map()) :: %{optional(String.t()) => boolean()}

  def from_session(session) when is_map(session) do

    case session[@session_key] do

      state when is_map(state) -> state

      _absent_or_wrong_shape -> %{}

    end

  end

  def from_session(_session), do: %{}

  defp parse(nil), do: %{}

  defp parse(value) when byte_size(value) > @maximum_bytes, do: %{}

  defp parse(value) do

    with {:ok, decoded} <- URI.decode(value) |> Jason.decode(),

         true <- is_map(decoded) do

      decoded

      |> Enum.filter(&admissible?/1)

      |> Enum.take(@maximum_sections)

      |> Map.new()

    else

      _unusable -> %{}

    end

  rescue

    # `URI.decode/1` raises on a malformed percent sequence, which a hand-edited

    # cookie can carry.

    ArgumentError -> %{}

  end

  defp admissible?({key, value}) when is_binary(key) and is_boolean(value),

    do: Regex.match?(@id_pattern, key)

  defp admissible?(_pair), do: false

end

    plug OpenAgentsWeb.Plugs.ContentSecurityPolicy

    plug :fetch_current_user

    plug OpenAgentsWeb.Plugs.SidebarSections

  end

  pipeline :api do

    end

  end

  # Which sections the reader has collapsed, so the first paint already agrees

  # with them. See `OpenAgentsWeb.Plugs.SidebarSections`.

  defp assign_sidebar_sections(socket, session) do

    Phoenix.Component.assign(

      socket,

      :sidebar_sections,

      OpenAgentsWeb.Plugs.SidebarSections.from_session(session)

    )

  end

  # The scope is the user, plus the answers the layout needs on every render

  # and must not re-ask for. Resolved once here, at mount.

  defp scope(user) do

  end

  def on_mount(:mount_current_user, _params, session, socket) do

    socket = assign_sidebar_sections(socket, session)

    with user_id when is_binary(user_id) <- session[@session_key],

         {:ok, user} <- Accounts.get_active_user(user_id) do

      {:cont,

  end

  def on_mount(:ensure_authenticated, _params, session, socket) do

    socket = assign_sidebar_sections(socket, session)

    with user_id when is_binary(user_id) <- session[@session_key],

         {:ok, user} <- Accounts.get_active_user(user_id) do

      {:cont,

defmodule OpenAgentsWeb.SidebarStateTest do

  @moduledoc """

  Two sidebar facts that are invisible when they break.

  The first is the Admin row. `sidebar_footer/1` used to default its user to

  `nil`, which made a forgotten attribute indistinguishable from a signed-out

  visitor -- and the docs and component-library layouts both forgot it, so an

  operator browsing either surface silently had no Admin row. It is a required

  attribute now, and the test below is the behavioural half of that.

  The second is which sections the reader has collapsed. That has to reach the

  server, because several sidebar destinations live in different live sessions

  and moving between them is a full page load: state the browser holds alone

  arrives a frame late, and the reader sees a collapsed section paint open and

  then shut. A page that renders the shell without passing the state gets that

  flicker back, and nothing else would say so.

  """

  use OpenAgentsWeb.ConnCase, async: true

  import Phoenix.LiveViewTest

  alias OpenAgentsWeb.Plugs.SidebarSections

  describe "the admin row" do

    test "an operator sees it on the application shell", %{conn: conn} do

      conn = log_in_admin_user(conn, "operator-shell")

      {:ok, view, _html} = live(conn, ~p"/leaderboard")

      assert has_element?(view, ~s(#sidebar .sidebar-footer a[href="/admin"]))

    end

    test "an operator sees it on the docs surface", %{conn: conn} do

      conn = log_in_admin_user(conn, "operator-docs")

      {:ok, view, _html} = live(conn, ~p"/docs")

      assert has_element?(view, ~s(.sidebar-footer a[href="/admin"]))

    end

    test "an operator sees it on the component library", %{conn: conn} do

      conn = log_in_admin_user(conn, "operator-components")

      {:ok, view, _html} = live(conn, ~p"/components")

      assert has_element?(view, ~s(.sidebar-footer a[href="/admin"]))

    end

    test "an ordinary account sees it on none of them", %{conn: conn} do

      conn = log_in_github_user(conn, "ordinary-account")

      for path <- [~p"/leaderboard", ~p"/docs", ~p"/components"] do

        {:ok, view, _html} = live(conn, path)

        refute has_element?(view, ~s(.sidebar-footer a[href="/admin"])),

               "admin row leaked on #{path}"

      end

    end

  end

  describe "collapsed sections survive the first paint" do

    test "a collapsed section renders collapsed, not open-then-corrected", %{conn: conn} do

      conn =

        conn

        |> log_in_chatting_user("collapse-first-paint")

        |> put_req_cookie("sidebar_sections", ~s({"sidebar-section-sarah":false}))

      {:ok, _view, html} = live(conn, ~p"/leaderboard")

      # `open` absent is the whole point: present would mean the browser paints

      # it expanded and a hook shuts it a frame later, which is the flicker.

      assert html =~ ~s(id="sidebar-section-sarah")

      refute html =~ ~r/id="sidebar-section-sarah"[^>]*\sopen/

    end

    test "with no cookie the seed governs, so the section is open", %{conn: conn} do

      conn = log_in_chatting_user(conn, "no-cookie-seed")

      {:ok, _view, html} = live(conn, ~p"/leaderboard")

      assert html =~ ~r/id="sidebar-section-sarah"[^>]*\sopen/

    end

    test "an expanded section stays expanded", %{conn: conn} do

      conn =

        conn

        |> log_in_chatting_user("expanded-stays")

        |> put_req_cookie("sidebar_sections", ~s({"sidebar-section-sarah":true}))

      {:ok, _view, html} = live(conn, ~p"/leaderboard")

      assert html =~ ~r/id="sidebar-section-sarah"[^>]*\sopen/

    end

  end

  describe "the cookie is reader-supplied, so it is bounded" do

    test "junk, wrong shapes, and unknown keys are dropped" do

      for value <- [

            "not json",

            "[1,2,3]",

            ~s({"sidebar-section-sarah":"yes"}),

            ~s({"../../etc/passwd":true}),

            ~s({"<script>":true}),

            ~s({"SIDEBAR-SECTION-SARAH":true}),

            "%E0%A4%A",

            String.duplicate("x", 4_000)

          ] do

        assert parse(value) == %{}, "admitted #{inspect(value)}"

      end

    end

    test "a well-formed entry survives" do

      assert parse(~s({"sidebar-section-sarah":false})) == %{"sidebar-section-sarah" => false}

    end

    test "a mixed payload keeps only the admissible entries" do

      assert parse(~s({"sidebar-section-sarah":false,"nope":true})) ==

               %{"sidebar-section-sarah" => false}

    end

    test "the number of sections is capped" do

      payload =

        1..200

        |> Map.new(fn n -> {"sidebar-section-s#{n}", false} end)

        |> Jason.encode!()

      parsed = parse(payload)

      assert map_size(parsed) <= 64

    end

  end

  describe "every shell call site passes the state" do

    # A page that renders the shell without it gets the flicker back, silently.

    # Checked at the source rather than by rendering, because the failure is a

    # missing attribute rather than a wrong output.

    test "no `<Layouts.app` omits sidebar_sections" do

      offenders =

        for path <- Path.wildcard("lib/openagents_web/**/*.{ex,heex}"),

            source = File.read!(path),

            [call] <- Regex.scan(~r/<Layouts\.app\b[^>]*>/s, source),

            not String.contains?(call, "sidebar_sections="),

            do: {path, String.slice(call, 0, 90)}

      assert offenders == [], """

      These render the application shell without passing the reader's collapsed

      sections, so a full page load paints their sections open and a hook shuts

      them a frame later:

      #{Enum.map_join(offenders, "\n", fn {file, call} -> "  #{file}\n    #{call}" end)}

      Add `sidebar_sections={assigns[:sidebar_sections]}`.

      """

    end

  end

  defp parse(value) do

    :get

    |> Plug.Test.conn("/")

    |> Plug.Test.put_req_cookie("sidebar_sections", value)

    |> Plug.Session.call(

      Plug.Session.init(store: :cookie, key: "_test", signing_salt: "salt", encryption_salt: "e")

    )

    |> Plug.Conn.fetch_session()

    |> SidebarSections.call([])

    |> Plug.Conn.get_session("sidebar_sections")

  end

end