animation-fill-mode: forwards;

    animation-timing-function: var(--ease, cubic-bezier(0.16, 1, 0.3, 1));

    opacity: 0;

    /* These animate opacity, translate and scale, which a compositor can run

       on its own. Saying so gets each one its own layer up front, so the hero

       glow -- a very large gradient being scaled -- composites instead of

       repainting its whole area every frame. Four elements, all above the

       fold, so the layers are cheap and short-lived. */

    will-change: opacity, translate, scale;

  }

  .appear { animation-name: landing-appear; }

  .appear--delay-3 { animation-delay: 500ms; }

  .appear--delay-4 { animation-delay: 700ms; }

  /* Opacity and translate only. This also animated `filter: blur()`, which no

     compositor can do: every frame repainted the element at its full size, and

     the largest element here is a 5.5rem headline spanning the viewport. The

     dropped frames read as the animation stuttering and starting over. */

  @keyframes landing-appear {

    from {

      opacity: 0;

      translate: 0 1rem;

      filter: blur(0.5rem);

    }

    50% {

      filter: blur(0);

    }

    to {

      opacity: 1;

      translate: 0 0;

      filter: blur(0);

    }

  }

    .appear-zoom {

      animation: none;

      opacity: 1;

      will-change: auto;

    }

    .cta__glow,

config :openagents, :runtime_environment, :development

# The changelog seed. Deliberately not enabled in `test`: it runs off the boot

# path, and a write that escapes the sandbox is a flaky suite.

config :openagents, :changelog_backfill_on_boot, true

# Configure your database

config :openagents, OpenAgents.Repo,

  username: System.get_env("USER") || "christopherdavid",

  config :openagents, :openai_api_key, optional_text.("OPENAI_API_KEY")

end

# The changelog seed. Idempotent and off the boot path. It was gated behind a

# flag that nothing ever set, so the seed sat unused and the public page said

# "Nothing yet" from the day it shipped.

if config_env() == :prod do

  config :openagents, :changelog_backfill_on_boot, true

end

if config_env() == :prod and runtime_role == :web do

  runtime_environment =

    case required_text.("OPENAGENTS_ENVIRONMENT") do

  @doc "Insert every seed entry idempotently. Returns the inserted count."

  def run do

    Enum.count(entries(), fn attrs ->

    Enum.count(seeded_entries(), fn attrs ->

      case Changelog.record(Map.merge(attrs, %{repo: @repo, source: "backfill"})) do

        {:ok, %{id: id}} when not is_nil(id) -> true

        _ -> false

    end)

  end

  @doc "The curated seed, lead-commit-anchored, from CHANGELOG.md."

  def entries do

  @doc """

  What actually gets seeded.

  Every entry links to its commit, and the page says so, so an entry may only

  be published if its commit is in this repository's history. The curated

  entries in `pre_public_entries/0` are anchored to the history that preceded

  this repository's clean-room rewrite: those commits are not here, and

  publishing them would give the page thirty links that resolve to nothing.

  So the launch is stated once, as a release, from a commit that exists. If

  the earlier history is ever grafted in, move those entries back.

  """

  def seeded_entries, do: [launch_entry()]

  @doc """

  The first public release.

  Anchored to this repository's initial commit, which is where its history --

  and everything the changelog can show a diff for -- begins.

  """

  def launch_entry do

    e(

      ~U[2026-08-19 19:47:28Z],

      "a352f78",

      "feature",

      "v0.0.1 — the first public release: issues, projects and milestones over a GitHub-shaped API; repositories to create, import from GitHub, clone and push; code and diffs beside the issues that changed them; an agent to talk to; receipts under all of it."

    )

  end

  @doc """

  The curated seed, lead-commit-anchored, from CHANGELOG.md.

  Retained, not seeded: see `seeded_entries/0`.

  """

  def entries, do: pre_public_entries()

  @doc "Curated entries from before this repository's history begins."

  def pre_public_entries do

    [

      # ── 2026-08-19 (later) — the transparency surfaces themselves

      e(

    ])

    |> validate_required([:repo, :sha, :summary, :category, :source, :entry_at])

    |> validate_format(:sha, ~r/^[0-9a-f]{7,40}$/)

    |> validate_length(:summary, max: 500)

    # 255, because that is what the column is. This said 500, so a summary

    # between the two passed validation and then raised

    # `string_data_right_truncation` from Postgres -- a changeset error turned

    # into a crash, on the one path that writes this table.

    |> validate_length(:summary, max: 255)

    |> validate_inclusion(:category, @categories)

    |> validate_inclusion(:source, @sources)

    |> validate_inclusion(:visibility, @visibilities)

  @empty_link ~s(<a href="" target="_blank" rel="noopener noreferrer nofollow">)

  # The sanitizer gives every link the same isolation attributes, which is

  # right for a link that leaves the site and wrong for one that does not: a

  # link to our own page opened a second tab, and the reader ends up with a

  # trail of tabs for what is one visit.

  #

  # `safe_url/1` has already rewritten `//host` to `https://host`, so at this

  # point a leading single `/` means same-origin, and `#` means this very page.

  # Everything else -- any scheme, any bare host -- is still treated as leaving.

  @internal_link ~r{<a href="(/(?!/)[^"]*|#[^"]*)" target="_blank" rel="noopener noreferrer nofollow">}

  @same_tab ~S(<a href="\1">)

  @emphasis_markers ~w(*** ___ ** __ ~~ * _)

  @doc """

         document <- normalize_links(document),

         {:ok, rendered} <- MDEx.to_html(document, mdex_options),

         rendered <- String.replace(rendered, @empty_link, "<a>"),

         rendered <- String.replace(rendered, @internal_link, @same_tab),

         :ok <- validate_output(rendered) do

      {:safe, rendered}

    else

    which applies it to `default` as well: a page with no title of its own

    rendered the brand twice. --%>

    <.live_title default="OpenAgents" phx-no-format>{page_title(assigns)}</.live_title>

    <%!-- The faces the first paint actually uses, fetched in parallel with the

    stylesheet instead of after it. Every face is `font-display: swap`, so one

    arriving late re-lays-out text that is already on screen -- and the hero

    animates while that happens, which reads as the animation stuttering and

    restarting rather than as text reflowing.

    Plain paths, not `~p`: these must be byte-identical to the `src` in

    `@font-face`, or the browser fetches the file twice and preloads nothing.

    `crossorigin` is required even same-origin -- fonts are fetched in CORS

    mode, and a preload without it is discarded and re-fetched. --%>

    <link

      rel="preload"

      as="font"

      type="font/woff2"

      href="/fonts/geist-sans-latin-400-normal.woff2"

      crossorigin="anonymous"

    />

    <link

      rel="preload"

      as="font"

      type="font/woff2"

      href="/fonts/geist-sans-latin-500-normal.woff2"

      crossorigin="anonymous"

    />

    <link

      rel="preload"

      as="font"

      type="font/woff2"

      href="/fonts/geist-sans-latin-600-normal.woff2"

      crossorigin="anonymous"

    />

    <link phx-track-static rel="stylesheet" href={~p"/assets/css/app.css"} />

    <%!-- Runs before first paint, and deliberately not deferred: resolving the

    theme after the stylesheet has painted produces a flash of the wrong theme.

  @impl true

  def render(%{live_action: :index} = assigns) do

    ~H"""

    <div id="components-index" class="max-w-3xl">

    <div id="components-index">

      <h1 class="text-3xl font-semibold mb-4">Component library</h1>

      <p class="text-muted-foreground mb-8 text-pretty max-w-[68ch]">

        Live examples of every supported function component in <code>OpenAgentsWeb.UI</code>, <code>OpenAgentsWeb.Layouts</code>, and the

        <h2 class="text-sm font-semibold uppercase tracking-wide text-muted-foreground mb-3">

          {section.title}

        </h2>

        <div class="grid gap-4 sm:grid-cols-2">

        <div class="grid gap-4 sm:grid-cols-2 xl:grid-cols-3">

          <.link

            :for={item <- section.items}

            patch={~p"/components/#{item.slug}"}

  def render(assigns) do

    ~H"""

    <div id={"component-#{@item.slug}"} class="max-w-3xl space-y-6">

    <%!-- The page fills its column and the prose caps itself. Capping the page

    capped the demo too, which is the one thing on it that wants the room: a

    composed surface squeezed into a reading measure stops demonstrating the

    proportions it exists to show. --%>

    <div id={"component-#{@item.slug}"} class="space-y-6">

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

        <h1 class="text-3xl font-semibold">{@item.title}</h1>

        <p class="text-sm text-muted-foreground"><code>{@item.source}</code></p>

  end

  describe "Backfill.run/0" do

    test "seeds every curated entry and is idempotent on re-run" do

    test "seeds what it can prove and is idempotent on re-run" do

      Backfill.run()

      seeded = Repo.aggregate(Entry, :count)

      assert seeded == length(Backfill.entries())

      assert seeded == length(Backfill.seeded_entries())

      # Re-running inserts nothing: the {repo, sha, source} conflict target

      # makes every duplicate a DB-level no-op.

      assert {:ok, rows} = Changelog.timeline("openagents.com", refresh: true)

      assert Enum.any?(rows, &(&1.source == "backfill"))

    end

    test "the launch entry is the release, and its commit is in this history" do

      # The page tells a reader that every entry links to its commit and that

      # the diff is readable from there. An entry anchored to a commit this

      # repository does not contain is a link to nothing, so the seed may only

      # publish entries whose sha is really here.

      assert [launch] = Backfill.seeded_entries()

      assert launch.summary =~ "v0.0.1"

      for %{sha: sha} <- Backfill.seeded_entries() do

        assert {_output, 0} = System.cmd("git", ["cat-file", "-e", sha <> "^{commit}"]),

               "seeded entry #{sha} is not a commit in this repository"

      end

    end

    test "the curated pre-public entries are retained but not published" do

      # They are anchored to the history that preceded this repository's

      # clean-room rewrite. Kept so they can be restored if that history is

      # ever grafted in; not seeded, because today they would be dead links.

      refute Backfill.pre_public_entries() == []

      seeded = MapSet.new(Backfill.seeded_entries(), & &1.sha)

      for %{sha: sha} <- Backfill.pre_public_entries() do

        refute MapSet.member?(seeded, sha)

      end

    end

    test "a summary the column cannot hold is a changeset error, not a crash" do

      # `changelog_entries.summary` is varchar(255) and the validation allowed

      # 500, so anything between the two raised from Postgres instead.

      attrs = %{

        repo: "openagents.com",

        sha: "abcdef1",

        summary: String.duplicate("x", 256),

        category: "feature",

        source: "backfill",

        entry_at: DateTime.utc_now()

      }

      assert {:error, changeset} = Changelog.record(attrs)

      assert %{summary: [_message]} = errors_on(changeset)

    end

  end

end

      assert html("[cdn](//example.com/x)") =~ ~s(href="https://example.com/x")

    end

    test "a link that stays on the site opens in the same tab" do

      # A second tab per internal link leaves the reader with a trail of them

      # for what is one visit.

      for markdown <- ["[path](/docs)", "[root](/)", "[section](#part)"] do

        rendered = html(markdown)

        refute rendered =~ ~s(target="_blank"), "opened a new tab: #{markdown}"

        refute rendered =~ ~s(rel="noopener noreferrer nofollow"),

               "isolated a same-origin link: #{markdown}"

      end

    end

    test "a link that only looks internal still leaves" do

      # `//host` is a protocol-relative URL: it reads as a path and is not one.

      # It is rewritten to https earlier, and must still be treated as leaving.

      rendered = html("[cdn](//example.com/x)")

      assert rendered =~ ~s(href="https://example.com/x")

      assert rendered =~ ~s(target="_blank")

      assert rendered =~ ~s(rel="noopener noreferrer nofollow")

    end

    test "a bare domain is resolved as https rather than relative to Sarah" do

      assert html("[site](example.com)") =~ ~s(href="https://example.com")

    end